tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-06-19 12:28:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

pgsql/mysql/sqlserver适配

Browse Source
This commit is contained in:
28810
2018-12-18 20:09:52 +08:00
commit 9b5e34032c
130 changed files with 12283 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
FreeSql/Interface/Curd/IDelete.cs Normal file
View File

@ -0,0 +1,57 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface IDelete<T1> where T1 : class {
/// <summary>
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象）
/// </summary>
/// <param name="exp">lambda表达式条件</param>
/// <returns></returns>
IDelete<T1> Where(Expression<Func<T1, bool>> exp);
/// <summary>
/// 原生sql语法条件，Where("id = ?id", new { id = 1 })
/// </summary>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
IDelete<T1> Where(string sql, object parms = null);
/// <summary>
/// 传入实体，将主键作为条件
/// </summary>
/// <param name="item">实体</param>
/// <returns></returns>
IDelete<T1> Where(T1 item);
/// <summary>
/// 传入实体集合，将主键作为条件
/// </summary>
/// <param name="items">实体集合</param>
/// <returns></returns>
IDelete<T1> Where(IEnumerable<T1> items);
/// <summary>
/// 子查询是否存在
/// </summary>
/// <typeparam name="TEntity2"></typeparam>
/// <param name="select">子查询</param>
/// <param name="notExists">不存在</param>
/// <returns></returns>
IDelete<T1> WhereExists<TEntity2>(ISelect<TEntity2> select, bool notExists = false) where TEntity2 : class;
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句，返回影响的行数
/// </summary>
/// <returns></returns>
long ExecuteAffrows();
/// <summary>
/// 执行SQL语句，返回被删除的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteDeleted();
}
}

55
FreeSql/Interface/Curd/IInsert.cs Normal file
View File

@ -0,0 +1,55 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface IInsert<T1> where T1 : class {
/// <summary>
/// 追加准备插入的实体
/// </summary>
/// <param name="source">实体</param>
/// <returns></returns>
IInsert<T1> AppendData(T1 source);
/// <summary>
/// 追加准备插入的实体集合
/// </summary>
/// <param name="source">实体集合</param>
/// <returns></returns>
IInsert<T1> AppendData(IEnumerable<T1> source);
/// <summary>
/// 只插入的列，InsertColumns(a => a.Name) | InsertColumns(a => new{a.Name,a.Time}) | InsertColumns(a => new[]{"name","time"})
/// </summary>
/// <param name="columns">lambda选择列</param>
/// <returns></returns>
IInsert<T1> InsertColumns(Expression<Func<T1, object>> columns);
/// <summary>
/// 忽略的列，IgnoreColumns(a => a.Name) | IgnoreColumns(a => new{a.Name,a.Time}) | IgnoreColumns(a => new[]{"name","time"})
/// </summary>
/// <param name="columns">lambda选择列</param>
/// <returns></returns>
IInsert<T1> IgnoreColumns(Expression<Func<T1, object>> columns);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句，返回影响的行数
/// </summary>
/// <returns></returns>
long ExecuteAffrows();
/// <summary>
/// 执行SQL语句，返回自增值
/// </summary>
/// <returns></returns>
long ExecuteIdentity();
/// <summary>
/// 执行SQL语句，返回插入后的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteInserted();
}
}

198
FreeSql/Interface/Curd/ISelect/ISelect0.cs Normal file
View File

@ -0,0 +1,198 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
namespace FreeSql {
public interface ISelect0<TSelect, T1> {
/// <summary>
/// 执行SQL查询，返回 T1 实体所有字段的记录，记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <returns></returns>
List<T1> ToList();
/// <summary>
/// 执行SQL查询，返回 field 指定字段的记录，并以元组或基础类型(int,string,long)接收，记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TTuple"></typeparam>
/// <param name="field"></param>
/// <returns></returns>
List<TTuple> ToList<TTuple>(string field);
/// <summary>
/// 执行SQL查询，返回 T1 实体所有字段的第一条记录，记录不存在时返回 null
/// </summary>
/// <returns></returns>
T1 ToOne();
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <param name="field">指定字段</param>
/// <returns></returns>
string ToSql(string field = null);
/// <summary>
/// 执行SQL查询，是否有记录
/// </summary>
/// <returns></returns>
bool Any();
/// <summary>
/// 查询的记录数量
/// </summary>
/// <returns></returns>
long Count();
/// <summary>
/// 查询的记录数量，以参数out形式返回
/// </summary>
/// <param name="count">返回的变量</param>
/// <returns></returns>
TSelect Count(out long count);
/// <summary>
/// 指定从主库查询（默认查询从库）
/// </summary>
/// <returns></returns>
TSelect Master();
/// <summary>
/// 缓存查询结果
/// </summary>
/// <param name="seconds">缓存秒数</param>
/// <param name="key">缓存key</param>
/// <returns></returns>
TSelect Caching(int seconds, string key = null);
/// <summary>
/// 左联查询，使用导航属性自动生成SQL
/// </summary>
/// <param name="exp">表达式</param>
/// <returns></returns>
TSelect LeftJoin(Expression<Func<T1, bool>> exp);
/// <summary>
/// 联接查询，使用导航属性自动生成SQL
/// </summary>
/// <param name="exp">表达式</param>
/// <returns></returns>
TSelect InnerJoin(Expression<Func<T1, bool>> exp);
/// <summary>
/// 右联查询，使用导航属性自动生成SQL
/// </summary>
/// <param name="exp">表达式</param>
/// <returns></returns>
TSelect RightJoin(Expression<Func<T1, bool>> exp);
/// <summary>
/// 左联查询，指定关联的实体类型
/// </summary>
/// <typeparam name="T2">关联的实体类型</typeparam>
/// <param name="exp">表达式</param>
/// <returns></returns>
TSelect LeftJoin<T2>(Expression<Func<T1, T2, bool>> exp);
/// <summary>
/// 联接查询，指定关联的实体类型
/// </summary>
/// <typeparam name="T2">关联的实体类型</typeparam>
/// <param name="exp">表达式</param>
/// <returns></returns>
TSelect InnerJoin<T2>(Expression<Func<T1, T2, bool>> exp);
/// <summary>
/// 右联查询，指定关联的实体类型
/// </summary>
/// <typeparam name="T2">关联的实体类型</typeparam>
/// <param name="exp">表达式</param>
/// <returns></returns>
TSelect RightJoin<T2>(Expression<Func<T1, T2, bool>> exp);
/// <summary>
/// 左联查询，使用原生sql语法，LeftJoin("type b on b.id = a.id and b.clicks > ?clicks", new { clicks = 1 })
/// </summary>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect LeftJoin(string sql, object parms = null);
/// <summary>
/// 联接查询，使用原生sql语法，InnerJoin("type b on b.id = a.id and b.clicks > ?clicks", new { clicks = 1 })
/// </summary>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect InnerJoin(string sql, object parms = null);
/// <summary>
/// 右联查询，使用原生sql语法，RightJoin("type b on b.id = a.id and b.clicks > ?clicks", new { clicks = 1 })
/// </summary>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect RightJoin(string sql, object parms = null);
/// <summary>
/// 原生sql语法条件，Where("id = ?id", new { id = 1 })
/// </summary>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect Where(string sql, object parms = null);
/// <summary>
/// 原生sql语法条件，WhereIf(true, "id = ?id", new { id = 1 })
/// </summary>
/// <param name="condition">true 时生效</param>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect WhereIf(bool condition, string sql, object parms = null);
/// <summary>
/// 按原生sql语法分组，GroupBy("concat(name, ?cc)", new { cc = 1 })
/// </summary>
/// <param name="sql">sql语法</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect GroupBy(string sql, object parms = null);
/// <summary>
/// 按原生sql语法聚合条件过滤，Having("count(name) = ?cc", new { cc = 1 })
/// </summary>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect Having(string sql, object parms = null);
/// <summary>
/// 按原生sql语法排序，OrderBy("count(name) + ?cc", new { cc = 1 })
/// </summary>
/// <param name="sql">sql语法</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect OrderBy(string sql, object parms = null);
/// <summary>
/// 查询向后偏移行数
/// </summary>
/// <param name="offset"></param>
/// <returns></returns>
TSelect Skip(int offset);
/// <summary>
/// 查询向后偏移行数
/// </summary>
/// <param name="offset">行数</param>
/// <returns></returns>
TSelect Offset(int offset);
/// <summary>
/// 查询多少条数据
/// </summary>
/// <param name="limit"></param>
/// <returns></returns>
TSelect Limit(int limit);
/// <summary>
/// 查询多少条数据
/// </summary>
/// <param name="limit"></param>
/// <returns></returns>
TSelect Take(int limit);
/// <summary>
/// 分页
/// </summary>
/// <param name="pageIndex">第几页</param>
/// <param name="pageSize">每页多少</param>
/// <returns></returns>
TSelect Page(int pageIndex, int pageSize);
}
}

230
FreeSql/Interface/Curd/ISelect/ISelect1.cs Normal file
View File

@ -0,0 +1,230 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1> : ISelect0<ISelect<T1>, T1> where T1 : class {
/// <summary>
/// 执行SQL查询，返回指定字段的记录，记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
List<TReturn> ToList<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 求和
/// </summary>
/// <typeparam name="TMember">返回类型</typeparam>
/// <param name="column">列</param>
/// <returns></returns>
TMember Sum<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 最小值
/// </summary>
/// <typeparam name="TMember">返回类型</typeparam>
/// <param name="column">列</param>
/// <returns></returns>
TMember Min<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 最大值
/// </summary>
/// <typeparam name="TMember">返回类型</typeparam>
/// <param name="column">列</param>
/// <returns></returns>
TMember Max<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 平均值
/// </summary>
/// <typeparam name="TMember">返回类型</typeparam>
/// <param name="column">列</param>
/// <returns></returns>
TMember Avg<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 指定别名
/// </summary>
/// <param name="alias">别名</param>
/// <returns></returns>
ISelect<T1> As(string alias = "a");
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class;
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class;
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <typeparam name="T5"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3, T4, T5> From<T2, T3, T4, T5>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class where T5 : class;
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <typeparam name="T5"></typeparam>
/// <typeparam name="T6"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3, T4, T5, T6> From<T2, T3, T4, T5, T6>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class;
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <typeparam name="T5"></typeparam>
/// <typeparam name="T6"></typeparam>
/// <typeparam name="T7"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3, T4, T5, T6, T7> From<T2, T3, T4, T5, T6, T7>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class;
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <typeparam name="T5"></typeparam>
/// <typeparam name="T6"></typeparam>
/// <typeparam name="T7"></typeparam>
/// <typeparam name="T8"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> From<T2, T3, T4, T5, T6, T7, T8>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class;
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <typeparam name="T5"></typeparam>
/// <typeparam name="T6"></typeparam>
/// <typeparam name="T7"></typeparam>
/// <typeparam name="T8"></typeparam>
/// <typeparam name="T9"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> From<T2, T3, T4, T5, T6, T7, T8, T9>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class where T9 : class;
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <typeparam name="T5"></typeparam>
/// <typeparam name="T6"></typeparam>
/// <typeparam name="T7"></typeparam>
/// <typeparam name="T8"></typeparam>
/// <typeparam name="T9"></typeparam>
/// <typeparam name="T10"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> From<T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, ISelectFromExpression<T1>>> exp) where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class where T9 : class where T10 : class;
/// <summary>
/// 查询条件，Where(a => a.Id > 10)，支持导航对象查询，Where(a => a.Author.Email == "2881099@qq.com")
/// </summary>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> Where(Expression<Func<T1, bool>> exp);
/// <summary>
/// 查询条件，Where(true, a => a.Id > 10)，支导航对象查询，Where(true, a => a.Author.Email == "2881099@qq.com")
/// </summary>
/// <param name="condition">true 时生效</param>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> WhereIf(bool condition, Expression<Func<T1, bool>> exp);
/// <summary>
/// 多表条件查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> Where<T2>(Expression<Func<T1, T2, bool>> exp) where T2 : class;
/// <summary>
/// 多表条件查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> Where<T2, T3>(Expression<Func<T1, T2, T3, bool>> exp) where T2 : class where T3 : class;
/// <summary>
/// 多表条件查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> Where<T2, T3, T4>(Expression<Func<T1, T2, T3, T4, bool>> exp) where T2 : class where T3 : class where T4 : class;
/// <summary>
/// 多表条件查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> Where<T2, T3, T4, T5>(Expression<Func<T1, T2, T3, T4, T5, bool>> exp) where T2 : class where T3 : class where T4 : class where T5 : class;
/// <summary>
/// 模糊查询，选择多个列 OR，WhereLike(a => new[] { a.Title, a.Content }, "%sql%")
/// </summary>
/// <param name="columns">lambda选择列</param>
/// <param name="pattern">查询内容</param>
/// <param name="notLike">not like</param>
/// <returns></returns>
ISelect<T1> WhereLike(Expression<Func<T1, string[]>> columns, string pattern, bool notLike = false);
/// <summary>
/// 模糊查询，WhereLike(a => a.Title, "%sql")
/// </summary>
/// <param name="column">lambda选择列</param>
/// <param name="pattern">查询内容</param>
/// <param name="notLike">not like</param>
/// <returns></returns>
ISelect<T1> WhereLike(Expression<Func<T1, string>> column, string pattern, bool notLike = false);
/// <summary>
/// 按选择的列分组，GroupBy(a => a.Name) | GroupBy(a => new{a.Name,a.Time}) | GroupBy(a => new[]{"name","time"})
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
ISelect<T1> GroupBy(Expression<Func<T1, object>> columns);
/// <summary>
/// 按列排序，OrderBy(a => a.Time)
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
ISelect<T1> OrderBy<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 按列倒向排序，OrderByDescending(a => a.Time)
/// </summary>
/// <param name="column">列</param>
/// <returns></returns>
ISelect<T1> OrderByDescending<TMember>(Expression<Func<T1, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect10.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : ISelect0<ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, T1> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class where T9 : class where T10 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, object>> columns);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect2.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2> : ISelect0<ISelect<T1, T2>, T1> where T1 : class where T2 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, TMember>> column);
ISelect<T1, T2> Where(Expression<Func<T1, T2, bool>> exp);
ISelect<T1, T2> WhereIf(bool condition, Expression<Func<T1, T2, bool>> exp);
ISelect<T1, T2> WhereLike(Expression<Func<T1, T2, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2> WhereLike(Expression<Func<T1, T2, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2> GroupBy(Expression<Func<T1, T2, object>> columns);
ISelect<T1, T2> OrderBy<TMember>(Expression<Func<T1, T2, TMember>> column);
ISelect<T1, T2> OrderByDescending<TMember>(Expression<Func<T1, T2, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect3.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3> : ISelect0<ISelect<T1, T2, T3>, T1> where T1 : class where T2 : class where T3 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
ISelect<T1, T2, T3> Where(Expression<Func<T1, T2, T3, bool>> exp);
ISelect<T1, T2, T3> WhereIf(bool condition, Expression<Func<T1, T2, T3, bool>> exp);
ISelect<T1, T2, T3> WhereLike(Expression<Func<T1, T2, T3, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3> WhereLike(Expression<Func<T1, T2, T3, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3> GroupBy(Expression<Func<T1, T2, T3, object>> columns);
ISelect<T1, T2, T3> OrderBy<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
ISelect<T1, T2, T3> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect4.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3, T4> : ISelect0<ISelect<T1, T2, T3, T4>, T1> where T1 : class where T2 : class where T3 : class where T4 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
ISelect<T1, T2, T3, T4> Where(Expression<Func<T1, T2, T3, T4, bool>> exp);
ISelect<T1, T2, T3, T4> WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, bool>> exp);
ISelect<T1, T2, T3, T4> WhereLike(Expression<Func<T1, T2, T3, T4, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4> WhereLike(Expression<Func<T1, T2, T3, T4, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4> GroupBy(Expression<Func<T1, T2, T3, T4, object>> columns);
ISelect<T1, T2, T3, T4> OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
ISelect<T1, T2, T3, T4> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect5.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3, T4, T5> : ISelect0<ISelect<T1, T2, T3, T4, T5>, T1> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
ISelect<T1, T2, T3, T4, T5> Where(Expression<Func<T1, T2, T3, T4, T5, bool>> exp);
ISelect<T1, T2, T3, T4, T5> WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, bool>> exp);
ISelect<T1, T2, T3, T4, T5> WhereLike(Expression<Func<T1, T2, T3, T4, T5, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5> WhereLike(Expression<Func<T1, T2, T3, T4, T5, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5> GroupBy(Expression<Func<T1, T2, T3, T4, T5, object>> columns);
ISelect<T1, T2, T3, T4, T5> OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
ISelect<T1, T2, T3, T4, T5> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect6.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3, T4, T5, T6> : ISelect0<ISelect<T1, T2, T3, T4, T5, T6>, T1> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6> Where(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6> WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6> GroupBy(Expression<Func<T1, T2, T3, T4, T5, T6, object>> columns);
ISelect<T1, T2, T3, T4, T5, T6> OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect7.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3, T4, T5, T6, T7> : ISelect0<ISelect<T1, T2, T3, T4, T5, T6, T7>, T1> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7> WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T1, T2, T3, T4, T5, T6, T7, object>> columns);
ISelect<T1, T2, T3, T4, T5, T6, T7> OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect8.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3, T4, T5, T6, T7, T8> : ISelect0<ISelect<T1, T2, T3, T4, T5, T6, T7, T8>, T1> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, object>> columns);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
}
}

26
FreeSql/Interface/Curd/ISelect/ISelect9.cs Normal file
View File

@ -0,0 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> : ISelect0<ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>, T1> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class where T9 : class {
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, string[]>> columns, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> WhereLike(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, string>> column, string pattern, bool notLike = false);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, object>> columns);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
}
}

64
FreeSql/Interface/Curd/ISelect/ISelectFrom.cs Normal file
View File

@ -0,0 +1,64 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelectFromExpression<T1> where T1 : class {
ISelectFromExpression<T1> LeftJoin(Expression<Func<T1, bool>> exp);
ISelectFromExpression<T1> InnerJoin(Expression<Func<T1, bool>> exp);
ISelectFromExpression<T1> RightJoin(Expression<Func<T1, bool>> exp);
/// <summary>
/// 查询条件，Where(a => a.Id > 10)，支持导航对象查询，Where(a => a.Author.Email == "2881099@qq.com")
/// </summary>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelectFromExpression<T1> Where(Expression<Func<T1, bool>> exp);
/// <summary>
/// 查询条件，Where(true, a => a.Id > 10)，支导航对象查询，Where(true, a => a.Author.Email == "2881099@qq.com")
/// </summary>
/// <param name="condition">true 时生效</param>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelectFromExpression<T1> WhereIf(bool condition, Expression<Func<T1, bool>> exp);
/// <summary>
/// 模糊查询，选择多个列 OR，WhereLike(a => new[] { a.Title, a.Content }, "%sql%")
/// </summary>
/// <param name="columns">lambda选择列</param>
/// <param name="pattern">查询内容</param>
/// <param name="notLike">not like</param>
/// <returns></returns>
ISelectFromExpression<T1> WhereLike(Expression<Func<T1, string[]>> columns, string pattern, bool notLike = false);
/// <summary>
/// 模糊查询，WhereLike(a => a.Title, "%sql")
/// </summary>
/// <param name="column">lambda选择列</param>
/// <param name="pattern">查询内容</param>
/// <param name="notLike">not like</param>
/// <returns></returns>
ISelectFromExpression<T1> WhereLike(Expression<Func<T1, string>> column, string pattern, bool notLike = false);
/// <summary>
/// 按选择的列分组，GroupBy(a => a.Name) | GroupBy(a => new{a.Name,a.Time}) | GroupBy(a => new[]{"name","time"})
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
ISelectFromExpression<T1> GroupBy(Expression<Func<T1, object>> columns);
/// <summary>
/// 按列排序，OrderBy(a => a.Time)
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
ISelectFromExpression<T1> OrderBy<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 按列倒向排序，OrderByDescending(a => a.Time)
/// </summary>
/// <param name="column">列</param>
/// <returns></returns>
ISelectFromExpression<T1> OrderByDescending<TMember>(Expression<Func<T1, TMember>> column);
}
}

100
FreeSql/Interface/Curd/IUpdate.cs Normal file
View File

@ -0,0 +1,100 @@
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface IUpdate<T1> where T1 : class {
/// <summary>
/// 更新数据，设置更新的实体
/// </summary>
/// <param name="source">实体</param>
/// <returns></returns>
IUpdate<T1> SetSource(T1 source);
/// <summary>
/// 更新数据，设置更新的实体集合
/// </summary>
/// <param name="source">实体集合</param>
/// <returns></returns>
IUpdate<T1> SetSource(IEnumerable<T1> source);
/// <summary>
/// 忽略的列，IgnoreColumns(a => a.Name) | IgnoreColumns(a => new{a.Name,a.Time}) | IgnoreColumns(a => new[]{"name","time"})
/// </summary>
/// <param name="columns">lambda选择列</param>
/// <returns></returns>
IUpdate<T1> IgnoreColumns(Expression<Func<T1, object>> columns);
/// <summary>
/// 设置列的新值，Set(a => a.Name, "newvalue")
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="column">lambda选择列</param>
/// <param name="value">新值</param>
/// <returns></returns>
IUpdate<T1> Set<TMember>(Expression<Func<T1, TMember>> column, TMember value);
/// <summary>
/// 设置列的的新值为基础上增加，格式：Set(a => a.Clicks + 1) 相当于 clicks=clicks+1
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
IUpdate<T1> Set<TMember>(Expression<Func<T1, TMember>> binaryExpression);
/// <summary>
/// 设置值，自定义SQL语法，SetRaw("title = ?title", new { title = "newtitle" })
/// </summary>
/// <param name="sql">sql语法</param>
/// <param name="parms">参数</param>
/// <returns></returns>
IUpdate<T1> SetRaw(string sql, object parms = null);
/// <summary>
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象）
/// </summary>
/// <param name="exp">lambda表达式条件</param>
/// <returns></returns>
IUpdate<T1> Where(Expression<Func<T1, bool>> exp);
/// <summary>
/// 原生sql语法条件，Where("id = ?id", new { id = 1 })
/// </summary>
/// <param name="sql">sql语法条件</param>
/// <param name="parms">参数</param>
/// <returns></returns>
IUpdate<T1> Where(string sql, object parms = null);
/// <summary>
/// 传入实体，将主键作为条件
/// </summary>
/// <param name="item">实体</param>
/// <returns></returns>
IUpdate<T1> Where(T1 item);
/// <summary>
/// 传入实体集合，将主键作为条件
/// </summary>
/// <param name="items">实体集合</param>
/// <returns></returns>
IUpdate<T1> Where(IEnumerable<T1> items);
/// <summary>
/// 子查询是否存在
/// </summary>
/// <typeparam name="TEntity2"></typeparam>
/// <param name="select">子查询</param>
/// <param name="notExists">不存在</param>
/// <returns></returns>
IUpdate<T1> WhereExists<TEntity2>(ISelect<TEntity2> select, bool notExists = false) where TEntity2 : class;
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句，返回影响的行数
/// </summary>
/// <returns></returns>
long ExecuteAffrows();
/// <summary>
/// 执行SQL语句，返回更新后的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteUpdated();
}
}

138
FreeSql/Interface/IAdo.cs Normal file
View File

@ -0,0 +1,138 @@
using FreeSql.DatabaseModel;
using SafeObjectPool;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Text;
using System.Threading.Tasks;
namespace FreeSql {
public partial interface IAdo {
/// <summary>
/// 主库连接池
/// </summary>
ObjectPool<DbConnection> MasterPool { get; }
/// <summary>
/// 从库连接池
/// </summary>
List<ObjectPool<DbConnection>> SlavePools { get; }
/// <summary>
/// 是否跟踪记录SQL执行性能日志
/// </summary>
bool IsTracePerformance { get; set; }
#region 事务
/// <summary>
/// 开启事务（不支持异步），60秒未执行完将自动提交
/// </summary>
/// <param name="handler">事务体 () => {}</param>
void Transaction(Action handler);
/// <summary>
/// 开启事务（不支持异步）
/// </summary>
/// <param name="handler">事务体 () => {}</param>
/// <param name="timeout">超时，未执行完将自动提交</param>
void Transaction(Action handler, TimeSpan timeout);
/// <summary>
/// 当前线程的事务
/// </summary>
DbTransaction TransactionCurrentThread { get; }
/// <summary>
/// 事务完成前预删除缓存
/// </summary>
/// <param name="keys"></param>
void TransactionPreRemoveCache(params string[] keys);
#endregion
/// <summary>
/// 若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
/// </summary>
/// <param name="readerHander"></param>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
List<T> Query<T>(string cmdText, object parms = null);
#region async
/// <summary>
/// 若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
/// </summary>
/// <param name="readerHander"></param>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 若使用读写分离，查询【从库】条件cmdText.StartsWith("SELECT ")，否则查询【主库】
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<List<T>> QueryAsync<T>(string cmdText, object parms = null);
#endregion
}
}

118
FreeSql/Interface/ICache.cs Normal file
View File

@ -0,0 +1,118 @@
using System;
using System.Threading.Tasks;
namespace FreeSql {
public interface ICache {
/// <summary>
/// 缓存数据时序列化方法，若无设置则默认使用 Json.net
/// </summary>
Func<object, string> Serialize { get; set; }
/// <summary>
/// 获取缓存数据时反序列化方法，若无设置则默认使用 Json.net
/// </summary>
Func<string, Type, object> Deserialize { get; set; }
/// <summary>
/// 缓存可序列化数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">缓存键</param>
/// <param name="data">可序列化数据</param>
/// <param name="timeoutSeconds">缓存秒数，&lt;=0时永久缓存</param>
void Set<T>(string key, T data, int timeoutSeconds = 0);
/// <summary>
/// 循环或批量获取缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
T Get<T>(string key);
/// <summary>
/// 循环或批量获取缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
string Get(string key);
/// <summary>
/// 循环或批量删除缓存键
/// </summary>
/// <param name="keys">缓存键[数组]</param>
void Remove(params string[] keys);
/// <summary>
/// 缓存壳
/// </summary>
/// <typeparam name="T">缓存类型</typeparam>
/// <param name="key">缓存键</param>
/// <param name="timeoutSeconds">缓存秒数</param>
/// <param name="getData">获取源数据的函数</param>
/// <param name="serialize">序列化函数</param>
/// <param name="deserialize">反序列化函数</param>
/// <returns></returns>
T Shell<T>(string key, int timeoutSeconds, Func<T> getData);
/// <summary>
/// 缓存壳(哈希表)
/// </summary>
/// <typeparam name="T">缓存类型</typeparam>
/// <param name="key">缓存键</param>
/// <param name="field">字段</param>
/// <param name="timeoutSeconds">缓存秒数</param>
/// <param name="getData">获取源数据的函数</param>
/// <param name="serialize">序列化函数</param>
/// <param name="deserialize">反序列化函数</param>
/// <returns></returns>
T Shell<T>(string key, string field, int timeoutSeconds, Func<T> getData);
/// <summary>
/// 缓存可序列化数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">缓存键</param>
/// <param name="data">可序列化数据</param>
/// <param name="timeoutSeconds">缓存秒数，&lt;=0时永久缓存</param>
Task SetAsync<T>(string key, T data, int timeoutSeconds = 0);
/// <summary>
/// 循环或批量获取缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
Task<T> GetAsync<T>(string key);
/// <summary>
/// 循环或批量获取缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
Task<string> GetAsync(string key);
/// <summary>
/// 循环或批量删除缓存键
/// </summary>
/// <param name="keys">缓存键[数组]</param>
Task RemoveAsync(params string[] keys);
/// <summary>
/// 缓存壳
/// </summary>
/// <typeparam name="T">缓存类型</typeparam>
/// <param name="key">缓存键</param>
/// <param name="timeoutSeconds">缓存秒数</param>
/// <param name="getData">获取源数据的函数</param>
/// <param name="serialize">序列化函数</param>
/// <param name="deserialize">反序列化函数</param>
/// <returns></returns>
Task<T> ShellAsync<T>(string key, int timeoutSeconds, Func<Task<T>> getDataAsync);
/// <summary>
/// 缓存壳(哈希表)
/// </summary>
/// <typeparam name="T">缓存类型</typeparam>
/// <param name="key">缓存键</param>
/// <param name="field">字段</param>
/// <param name="timeoutSeconds">缓存秒数</param>
/// <param name="getData">获取源数据的函数</param>
/// <param name="serialize">序列化函数</param>
/// <param name="deserialize">反序列化函数</param>
/// <returns></returns>
Task<T> ShellAsync<T>(string key, string field, int timeoutSeconds, Func<Task<T>> getDataAsync);
}
}

43
FreeSql/Interface/ICodeFirst.cs Normal file
View File

@ -0,0 +1,43 @@
using System;
namespace FreeSql {
public interface ICodeFirst {
/// <summary>
/// 【开发环境必备】自动同步实体结构到数据库，程序运行中检查实体表是否存在，然后创建或修改
/// </summary>
bool IsAutoSyncStructure { get; set; }
/// <summary>
/// 将实体类型与数据库对比，返回DDL语句
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
string GetComparisonDDLStatements<TEntity>();
/// <summary>
/// 将实体类型集合与数据库对比，返回DDL语句
/// </summary>
/// <param name="entityTypes"></param>
/// <returns></returns>
string GetComparisonDDLStatements(params Type[] entityTypes);
/// <summary>
/// 同步实体类型到数据库
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
bool SyncStructure<TEntity>();
/// <summary>
/// 同步实体类型集合到数据库
/// </summary>
/// <param name="entityTypes"></param>
/// <returns></returns>
bool SyncStructure(params Type[] entityTypes);
/// <summary>
/// 根据 System.Type 获取数据库信息
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
(int type, string dbtype, string dbtypeFull, bool? isnullable)? GetDbInfo(Type type);
}
}

100
FreeSql/Interface/IDasql.cs Normal file
View File

@ -0,0 +1,100 @@
using FreeSql;
using System;
using System.Collections.Generic;
using System.Data;
using System.Text;
public interface IFreeSql {
/// <summary>
/// 插入数据
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <returns></returns>
IInsert<T1> Insert<T1>() where T1 : class;
/// <summary>
/// 插入数据，传入实体
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
IInsert<T1> Insert<T1>(T1 source) where T1 : class;
/// <summary>
/// 插入数据，传入实体集合
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
IInsert<T1> Insert<T1>(IEnumerable<T1> source) where T1 : class;
/// <summary>
/// 修改数据
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <returns></returns>
IUpdate<T1> Update<T1>() where T1 : class;
/// <summary>
/// 修改数据，传入动态对象如：主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
IUpdate<T1> Update<T1>(object dywhere) where T1 : class;
/// <summary>
/// 查询数据
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <returns></returns>
ISelect<T1> Select<T1>() where T1 : class;
/// <summary>
/// 查询数据，传入动态对象如：主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
ISelect<T1> Select<T1>(object dywhere) where T1 : class;
/// <summary>
/// 删除数据
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <returns></returns>
IDelete<T1> Delete<T1>() where T1 : class;
/// <summary>
/// 删除数据，传入动态对象如：主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
IDelete<T1> Delete<T1>(object dywhere) where T1 : class;
/// <summary>
/// 开启事务（不支持异步），60秒未执行完将自动提交
/// </summary>
/// <param name="handler">事务体 () => {}</param>
void Transaction(Action handler);
/// <summary>
/// 开启事务（不支持异步）
/// </summary>
/// <param name="handler">事务体 () => {}</param>
/// <param name="timeout">超时，未执行完将自动提交</param>
void Transaction(Action handler, TimeSpan timeout);
/// <summary>
/// 缓存
/// </summary>
ICache Cache { get; }
/// <summary>
/// 数据库访问对象
/// </summary>
IAdo Ado { get; }
/// <summary>
/// CodeFirst 模式开发相关方法
/// </summary>
ICodeFirst CodeFirst { get; }
/// <summary>
/// DbFirst 模式开发相关方法
/// </summary>
IDbFirst DbFirst { get; }
}

70
FreeSql/Interface/iDbFirst.cs Normal file
View File

@ -0,0 +1,70 @@
using FreeSql.DatabaseModel;
using System;
using System.Collections.Generic;
namespace FreeSql {
public interface IDbFirst {
/// <summary>
/// 获取所有数据库
/// </summary>
/// <returns></returns>
List<string> GetDatabases();
/// <summary>
/// 获取指定数据库的表信息，包括表、列详情、主键、唯一键、索引、外键
/// </summary>
/// <param name="database"></param>
/// <returns></returns>
List<DbTableInfo> GetTablesByDatabase(params string[] database);
/// <summary>
/// 获取数据库枚举类型int值
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
int GetDbType(DbColumnInfo column);
/// <summary>
/// 获取c#转换，(int)、(long)
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
string GetCsConvert(DbColumnInfo column);
/// <summary>
/// 获取c#值
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
string GetCsTypeValue(DbColumnInfo column);
/// <summary>
/// 获取c#类型，int、long
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
string GetCsType(DbColumnInfo column);
/// <summary>
/// 获取c#类型对象
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
Type GetCsTypeInfo(DbColumnInfo column);
/// <summary>
/// 获取ado.net读取方法, GetBoolean、GetInt64
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
string GetDataReaderMethod(DbColumnInfo column);
/// <summary>
/// 序列化
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
string GetCsStringify(DbColumnInfo column);
/// <summary>
/// 反序列化
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
string GetCsParse(DbColumnInfo column);
}
}