源代码改用vs默认格式化

This commit is contained in:
28810
2019-06-27 09:40:35 +08:00
parent 873364c7ee
commit f8c3608fda
309 changed files with 73814 additions and 67594 deletions

View File

@ -4,90 +4,92 @@ using System.Data.Common;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql {
public interface IDelete<T1> where T1 : class {
namespace FreeSql
{
public interface IDelete<T1> where T1 : class
{
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IDelete<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
IDelete<T1> WithConnection(DbConnection connection);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IDelete<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
IDelete<T1> WithConnection(DbConnection connection);
/// <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>
/// 传入动态对象如:主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
IDelete<T1> WhereDynamic(object dywhere);
/// <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>
/// 传入动态对象如:主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
IDelete<T1> WhereDynamic(object dywhere);
/// <summary>
/// 设置表名规则,可用于分库/分表参数1默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
IDelete<T1> AsTable(Func<string, string> tableRule);
/// <summary>
/// 动态Type在使用 Delete&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
IDelete<T1> AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句返回影响的行数
/// </summary>
/// <returns></returns>
int ExecuteAffrows();
Task<int> ExecuteAffrowsAsync();
/// <summary>
/// 执行SQL语句返回被删除的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteDeleted();
Task<List<T1>> ExecuteDeletedAsync();
}
/// <summary>
/// 设置表名规则,可用于分库/分表参数1默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
IDelete<T1> AsTable(Func<string, string> tableRule);
/// <summary>
/// 动态Type在使用 Delete&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
IDelete<T1> AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句返回影响的行数
/// </summary>
/// <returns></returns>
int ExecuteAffrows();
Task<int> ExecuteAffrowsAsync();
/// <summary>
/// 执行SQL语句返回被删除的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteDeleted();
Task<List<T1>> ExecuteDeletedAsync();
}
}

View File

@ -4,94 +4,96 @@ using System.Data.Common;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql {
public interface IInsert<T1> where T1 : class {
namespace FreeSql
{
public interface IInsert<T1> where T1 : class
{
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IInsert<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
IInsert<T1> WithConnection(DbConnection connection);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IInsert<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
IInsert<T1> WithConnection(DbConnection connection);
/// <summary>
/// 追加准备插入的实体
/// </summary>
/// <param name="source">实体</param>
/// <returns></returns>
IInsert<T1> AppendData(T1 source);
/// <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>
/// 追加准备插入的实体
/// </summary>
/// <param name="source">实体</param>
/// <returns></returns>
IInsert<T1> AppendData(T1 source);
/// <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>
/// 只插入的列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>
/// 不使用参数化,可通过 IFreeSql.CodeFirst.IsNotCommandParameter 全局性设置
/// </summary>
/// <returns></returns>
IInsert<T1> NoneParameter();
/// <summary>
/// 不使用参数化,可通过 IFreeSql.CodeFirst.IsNotCommandParameter 全局性设置
/// </summary>
/// <returns></returns>
IInsert<T1> NoneParameter();
/// <summary>
/// 设置表名规则,可用于分库/分表参数1默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
IInsert<T1> AsTable(Func<string, string> tableRule);
/// <summary>
/// 动态Type在使用 Insert&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
IInsert<T1> AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句返回影响的行数
/// </summary>
/// <returns></returns>
int ExecuteAffrows();
Task<int> ExecuteAffrowsAsync();
/// <summary>
/// 执行SQL语句返回自增值
/// </summary>
/// <returns></returns>
long ExecuteIdentity();
Task<long> ExecuteIdentityAsync();
/// <summary>
/// 执行SQL语句返回插入后的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteInserted();
Task<List<T1>> ExecuteInsertedAsync();
}
/// <summary>
/// 设置表名规则,可用于分库/分表参数1默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
IInsert<T1> AsTable(Func<string, string> tableRule);
/// <summary>
/// 动态Type在使用 Insert&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
IInsert<T1> AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句返回影响的行数
/// </summary>
/// <returns></returns>
int ExecuteAffrows();
Task<int> ExecuteAffrowsAsync();
/// <summary>
/// 执行SQL语句返回自增值
/// </summary>
/// <returns></returns>
long ExecuteIdentity();
Task<long> ExecuteIdentityAsync();
/// <summary>
/// 执行SQL语句返回插入后的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteInserted();
Task<List<T1>> ExecuteInsertedAsync();
}
}

View File

@ -3,27 +3,29 @@ using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
namespace FreeSql {
public interface ILinqToSql<T1> where T1 : class {
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TReturn> Select<TReturn>(Expression<Func<T1, TReturn>> select) where TReturn : class;
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TResult> Join<TInner, TKey, TResult>(ISelect<TInner> inner, Expression<Func<T1, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<T1, TInner, TResult>> resultSelector) where TInner : class where TResult : class;
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TResult> GroupJoin<TInner, TKey, TResult>(ISelect<TInner> inner, Expression<Func<T1, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<T1, ISelect<TInner>, TResult>> resultSelector) where TInner : class where TResult : class;
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<T1> DefaultIfEmpty();
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TResult> SelectMany<TCollection, TResult>(Expression<Func<T1, ISelect<TCollection>>> collectionSelector, Expression<Func<T1, TCollection, TResult>> resultSelector) where TCollection : class where TResult : class;
}
namespace FreeSql
{
public interface ILinqToSql<T1> where T1 : class
{
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TReturn> Select<TReturn>(Expression<Func<T1, TReturn>> select) where TReturn : class;
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TResult> Join<TInner, TKey, TResult>(ISelect<TInner> inner, Expression<Func<T1, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<T1, TInner, TResult>> resultSelector) where TInner : class where TResult : class;
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TResult> GroupJoin<TInner, TKey, TResult>(ISelect<TInner> inner, Expression<Func<T1, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<T1, ISelect<TInner>, TResult>> resultSelector) where TInner : class where TResult : class;
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<T1> DefaultIfEmpty();
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
ISelect<TResult> SelectMany<TCollection, TResult>(Expression<Func<T1, ISelect<TCollection>>> collectionSelector, Expression<Func<T1, TCollection, TResult>> resultSelector) where TCollection : class where TResult : class;
}
}

View File

@ -6,255 +6,257 @@ using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace FreeSql {
public interface ISelect0<TSelect, T1> {
namespace FreeSql
{
public interface ISelect0<TSelect, T1>
{
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
TSelect WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定连接对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
TSelect WithConnection(DbConnection connection);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
TSelect WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定连接对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
TSelect WithConnection(DbConnection connection);
/// <summary>
/// 审核或跟踪 ToList 即将返回的数据
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
TSelect TrackToList(Action<object> action);
/// <summary>
/// 审核或跟踪 ToList 即将返回的数据
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
TSelect TrackToList(Action<object> action);
/// <summary>
/// 执行SQL查询返回 DataTable
/// </summary>
/// <returns></returns>
DataTable ToDataTable(string field = null);
Task<DataTable> ToDataTableAsync(string field = null);
/// <summary>
/// 执行SQL查询返回 DataTable
/// </summary>
/// <returns></returns>
DataTable ToDataTable(string field = null);
Task<DataTable> ToDataTableAsync(string field = null);
/// <summary>
/// 执行SQL查询返回 T1 实体所有字段的记录,记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <param name="includeNestedMembers">false: 返回 2级 LeftJoin/InnerJoin/RightJoin 对象true: 返回所有 LeftJoin/InnerJoin/RightJoin 的导航数据</param>
/// <returns></returns>
List<T1> ToList(bool includeNestedMembers = false);
Task<List<T1>> ToListAsync(bool includeNestedMembers = false);
/// <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);
Task<List<TTuple>> ToListAsync<TTuple>(string field);
/// <summary>
/// 执行SQL查询返回 T1 实体所有字段的第一条记录,记录不存在时返回 null
/// </summary>
/// <returns></returns>
T1 ToOne();
Task<T1> ToOneAsync();
/// <summary>
/// 执行SQL查询返回 T1 实体所有字段的记录,记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <param name="includeNestedMembers">false: 返回 2级 LeftJoin/InnerJoin/RightJoin 对象true: 返回所有 LeftJoin/InnerJoin/RightJoin 的导航数据</param>
/// <returns></returns>
List<T1> ToList(bool includeNestedMembers = false);
Task<List<T1>> ToListAsync(bool includeNestedMembers = false);
/// <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);
Task<List<TTuple>> ToListAsync<TTuple>(string field);
/// <summary>
/// 执行SQL查询返回 T1 实体所有字段的第一条记录,记录不存在时返回 null
/// </summary>
/// <returns></returns>
T1 ToOne();
Task<T1> ToOneAsync();
/// <summary>
/// 执行SQL查询返回 T1 实体所有字段的第一条记录,记录不存在时返回 null
/// </summary>
/// <returns></returns>
T1 First();
Task<T1> FirstAsync();
/// <summary>
/// 执行SQL查询返回 T1 实体所有字段的第一条记录,记录不存在时返回 null
/// </summary>
/// <returns></returns>
T1 First();
Task<T1> FirstAsync();
/// <summary>
/// 设置表名规则,可用于分库/分表参数1实体类型参数2默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
TSelect AsTable(Func<Type, string, string> tableRule);
/// <summary>
/// 动态Type在使用 Select&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
TSelect AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <param name="field">指定字段</param>
/// <returns></returns>
string ToSql(string field = null);
/// <summary>
/// 执行SQL查询是否有记录
/// </summary>
/// <returns></returns>
bool Any();
Task<bool> AnyAsync();
/// <summary>
/// 设置表名规则,可用于分库/分表参数1实体类型参数2默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
TSelect AsTable(Func<Type, string, string> tableRule);
/// <summary>
/// 动态Type在使用 Select&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
TSelect AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <param name="field">指定字段</param>
/// <returns></returns>
string ToSql(string field = null);
/// <summary>
/// 执行SQL查询是否有记录
/// </summary>
/// <returns></returns>
bool Any();
Task<bool> AnyAsync();
/// <summary>
/// 查询的记录数量
/// </summary>
/// <returns></returns>
long Count();
Task<long> CountAsync();
/// <summary>
/// 查询的记录数量以参数out形式返回
/// </summary>
/// <param name="count">返回的变量</param>
/// <returns></returns>
TSelect Count(out long count);
/// <summary>
/// 查询的记录数量
/// </summary>
/// <returns></returns>
long Count();
Task<long> CountAsync();
/// <summary>
/// 查询的记录数量以参数out形式返回
/// </summary>
/// <param name="count">返回的变量</param>
/// <returns></returns>
TSelect Count(out long count);
/// <summary>
/// 指定从主库查询(默认查询从库)
/// </summary>
/// <returns></returns>
TSelect Master();
/// <summary>
/// 指定从主库查询(默认查询从库)
/// </summary>
/// <returns></returns>
TSelect Master();
/// <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
/// </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语法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语法条件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语法分组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 desc", new { cc = 1 })
/// </summary>
/// <param name="sql">sql语法</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect OrderBy(string sql, object parms = null);
/// <summary>
/// 按原生sql语法排序OrderBy(true, "count(name) + ?cc desc", new { cc = 1 })
/// </summary>
/// <param name="condition">true 时生效</param>
/// <param name="sql">sql语法</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect OrderBy(bool condition, string sql, object parms = null);
/// <summary>
/// 按原生sql语法排序OrderBy("count(name) + ?cc desc", new { cc = 1 })
/// </summary>
/// <param name="sql">sql语法</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect OrderBy(string sql, object parms = null);
/// <summary>
/// 按原生sql语法排序OrderBy(true, "count(name) + ?cc desc", new { cc = 1 })
/// </summary>
/// <param name="condition">true 时生效</param>
/// <param name="sql">sql语法</param>
/// <param name="parms">参数</param>
/// <returns></returns>
TSelect OrderBy(bool condition, 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="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="pageNumber">第几页</param>
/// <param name="pageSize">每页多少</param>
/// <returns></returns>
TSelect Page(int pageNumber, int pageSize);
/// <summary>
/// 分页
/// </summary>
/// <param name="pageNumber">第几页</param>
/// <param name="pageSize">每页多少</param>
/// <returns></returns>
TSelect Page(int pageNumber, int pageSize);
/// <summary>
/// 查询数据前,去重
/// </summary>
/// <returns></returns>
TSelect Distinct();
}
/// <summary>
/// 查询数据前,去重
/// </summary>
/// <returns></returns>
TSelect Distinct();
}
}

View File

@ -4,325 +4,327 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql {
public interface ISelect<T1> : ISelect0<ISelect<T1>, T1>, ILinqToSql<T1> where T1 : class {
namespace FreeSql
{
public interface ISelect<T1> : ISelect0<ISelect<T1>, T1>, ILinqToSql<T1> where T1 : class
{
/// <summary>
/// 执行SQL查询是否有记录
/// </summary>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
bool Any(Expression<Func<T1, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, bool>> exp);
/// <summary>
/// 执行SQL查询是否有记录
/// </summary>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
bool Any(Expression<Func<T1, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, bool>> exp);
/// <summary>
/// 执行SQL查询返回 DataTable
/// </summary>
/// <returns></returns>
DataTable ToDataTable<TReturn>(Expression<Func<T1, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回 DataTable
/// </summary>
/// <returns></returns>
DataTable ToDataTable<TReturn>(Expression<Func<T1, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回指定字段的记录记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
List<TReturn> ToList<TReturn>(Expression<Func<T1, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回 TDto 映射的字段,记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TDto"></typeparam>
/// <returns></returns>
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
/// <summary>
/// 执行SQL查询返回指定字段的记录记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
List<TReturn> ToList<TReturn>(Expression<Func<T1, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回 TDto 映射的字段,记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TDto"></typeparam>
/// <returns></returns>
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
/// <summary>
/// 执行SQL查询返回指定字段的记录的第一条记录记录不存在时返回 TReturn 默认值
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
TReturn ToOne<TReturn>(Expression<Func<T1, TReturn>> select);
Task<TReturn> ToOneAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回指定字段的记录的第一条记录记录不存在时返回 TReturn 默认值
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
TReturn ToOne<TReturn>(Expression<Func<T1, TReturn>> select);
Task<TReturn> ToOneAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回指定字段的记录的第一条记录记录不存在时返回 TReturn 默认值
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
TReturn First<TReturn>(Expression<Func<T1, TReturn>> select);
Task<TReturn> FirstAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回指定字段的记录的第一条记录记录不存在时返回 TReturn 默认值
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
TReturn First<TReturn>(Expression<Func<T1, TReturn>> select);
Task<TReturn> FirstAsync<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
string ToSql<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
string ToSql<TReturn>(Expression<Func<T1, TReturn>> select);
/// <summary>
/// 执行SQL查询返回指定字段的聚合结果
/// </summary>
/// <typeparam name="TReturn"></typeparam>
/// <param name="select"></param>
/// <returns></returns>
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, TReturn>> select);
/// <summary>
/// 执行SQL查询返回指定字段的聚合结果
/// </summary>
/// <typeparam name="TReturn"></typeparam>
/// <param name="select"></param>
/// <returns></returns>
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, TReturn>> select);
/// <summary>
/// 求和
/// </summary>
/// <typeparam name="TMember">返回类型</typeparam>
/// <param name="column">列</param>
/// <returns></returns>
TMember Sum<TMember>(Expression<Func<T1, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 求和
/// </summary>
/// <typeparam name="TMember">返回类型</typeparam>
/// <param name="column">列</param>
/// <returns></returns>
TMember Sum<TMember>(Expression<Func<T1, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, TMember>> column);
/// <summary>
/// 指定别名
/// </summary>
/// <param name="alias">别名</param>
/// <returns></returns>
ISelect<T1> As(string alias = "a");
/// <summary>
/// 指定别名
/// </summary>
/// <param name="alias">别名</param>
/// <returns></returns>
ISelect<T1> As(string alias = "a");
/// <summary>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) where T2 : class;
/// <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>
/// 多表查询
/// </summary>
/// <typeparam name="T2"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) where T2 : class;
/// <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>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> Where<T2>(Expression<Func<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>
/// 传入动态对象如:主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
ISelect<T1> WhereDynamic(object dywhere);
/// <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>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelect<T1> Where<T2>(Expression<Func<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>
/// 传入动态对象如:主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
ISelect<T1> WhereDynamic(object dywhere);
/// <summary>
/// 按选择的列分组GroupBy(a => a.Name) | GroupBy(a => new{a.Name,a.Time})
/// </summary>
/// <param name="exp"></param>
/// <returns></returns>
ISelectGrouping<TKey, T1> GroupBy<TKey>(Expression<Func<T1, TKey>> exp);
/// <summary>
/// 按选择的列分组GroupBy(a => a.Name) | GroupBy(a => new{a.Name,a.Time})
/// </summary>
/// <param name="exp"></param>
/// <returns></returns>
ISelectGrouping<TKey, T1> GroupBy<TKey>(Expression<Func<T1, TKey>> exp);
/// <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>
/// 按列排序OrderBy(true, a => a.Time)
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="condition">true 时生效</param>
/// <param name="column"></param>
/// <returns></returns>
ISelect<T1> OrderBy<TMember>(bool condition, 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);
/// <summary>
/// 按列倒向排序OrderByDescending(true, a => a.Time)
/// </summary>
/// <param name="condition">true 时生效</param>
/// <param name="column">列</param>
/// <returns></returns>
ISelect<T1> OrderByDescending<TMember>(bool condition, Expression<Func<T1, TMember>> column);
/// <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>
/// 按列排序OrderBy(true, a => a.Time)
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="condition">true 时生效</param>
/// <param name="column"></param>
/// <returns></returns>
ISelect<T1> OrderBy<TMember>(bool condition, 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);
/// <summary>
/// 按列倒向排序OrderByDescending(true, a => a.Time)
/// </summary>
/// <param name="condition">true 时生效</param>
/// <param name="column">列</param>
/// <returns></returns>
ISelect<T1> OrderByDescending<TMember>(bool condition, Expression<Func<T1, TMember>> column);
/// <summary>
/// 贪婪加载导航属性,如果查询中已经使用了 a.Parent.Parent 类似表达式,则可以无需此操作
/// </summary>
/// <typeparam name="TNavigate"></typeparam>
/// <param name="navigateSelector">选择一个导航属性</param>
/// <returns></returns>
ISelect<T1> Include<TNavigate>(Expression<Func<T1, TNavigate>> navigateSelector) where TNavigate : class;
/// <summary>
/// 贪婪加载集合的导航属性其实是分两次查询ToList 后进行了数据重装
/// </summary>
/// <typeparam name="TNavigate"></typeparam>
/// <param name="navigateSelector">选择一个集合的导航属性,也可通过 .Where 设置临时的关系映射,还可以 .Take(5) 每个子集合只取5条</param>
/// <param name="then">即能 ThenInclude还可以二次过滤这个 EFCore 做不到?)</param>
/// <returns></returns>
ISelect<T1> IncludeMany<TNavigate>(Expression<Func<T1, IEnumerable<TNavigate>>> navigateSelector, Action<ISelect<TNavigate>> then = null) where TNavigate : class;
}
/// <summary>
/// 贪婪加载导航属性,如果查询中已经使用了 a.Parent.Parent 类似表达式,则可以无需此操作
/// </summary>
/// <typeparam name="TNavigate"></typeparam>
/// <param name="navigateSelector">选择一个导航属性</param>
/// <returns></returns>
ISelect<T1> Include<TNavigate>(Expression<Func<T1, TNavigate>> navigateSelector) where TNavigate : class;
/// <summary>
/// 贪婪加载集合的导航属性其实是分两次查询ToList 后进行了数据重装
/// </summary>
/// <typeparam name="TNavigate"></typeparam>
/// <param name="navigateSelector">选择一个集合的导航属性,也可通过 .Where 设置临时的关系映射,还可以 .Take(5) 每个子集合只取5条</param>
/// <param name="then">即能 ThenInclude还可以二次过滤这个 EFCore 做不到?)</param>
/// <returns></returns>
ISelect<T1> IncludeMany<TNavigate>(Expression<Func<T1, IEnumerable<TNavigate>>> navigateSelector, Action<ISelect<TNavigate>> then = null) where TNavigate : class;
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
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 {
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
{
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, ISelectGroupingAggregate<T10>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, ISelectGroupingAggregate<T10>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, ISelectGroupingAggregate<T10>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, ISelectGroupingAggregate<T10>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<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> 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);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TKey>> exp);
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);
}
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);
}
}

View File

@ -4,40 +4,42 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql {
public interface ISelect<T1, T2> : ISelect0<ISelect<T1, T2>, T1> where T1 : class where T2 : class {
namespace FreeSql
{
public interface ISelect<T1, T2> : ISelect0<ISelect<T1, T2>, T1> where T1 : class where T2 : class
{
bool Any(Expression<Func<T1, T2, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, bool>> exp);
bool Any(Expression<Func<T1, T2, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, TReturn>> select);
string ToSql<TReturn>(Expression<Func<T1, T2, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, TMember>> column);
Task<TMember> AvgAsync<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> Where(Expression<Func<T1, T2, bool>> exp);
ISelect<T1, T2> WhereIf(bool condition, Expression<Func<T1, T2, bool>> exp);
ISelectGrouping<TKey, (T1, T2)> GroupBy<TKey>(Expression<Func<T1, T2, TKey>> exp);
ISelectGrouping<TKey, (T1, T2)> GroupBy<TKey>(Expression<Func<T1, T2, TKey>> exp);
ISelect<T1, T2> OrderBy<TMember>(Expression<Func<T1, T2, TMember>> column);
ISelect<T1, T2> OrderByDescending<TMember>(Expression<Func<T1, T2, TMember>> column);
}
ISelect<T1, T2> OrderBy<TMember>(Expression<Func<T1, T2, TMember>> column);
ISelect<T1, T2> OrderByDescending<TMember>(Expression<Func<T1, T2, TMember>> column);
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql {
public interface ISelect<T1, T2, T3> : ISelect0<ISelect<T1, T2, T3>, T1> where T1 : class where T2 : class where T3 : class {
namespace FreeSql
{
public interface ISelect<T1, T2, T3> : ISelect0<ISelect<T1, T2, T3>, T1> where T1 : class where T2 : class where T3 : class
{
bool Any(Expression<Func<T1, T2, T3, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, TMember>> column);
Task<TMember> AvgAsync<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> Where(Expression<Func<T1, T2, T3, bool>> exp);
ISelect<T1, T2, T3> WhereIf(bool condition, Expression<Func<T1, T2, T3, bool>> exp);
ISelectGrouping<TKey, (T1, T2, T3)> GroupBy<TKey>(Expression<Func<T1, T2, T3, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3)> GroupBy<TKey>(Expression<Func<T1, T2, T3, TKey>> exp);
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);
}
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);
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
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 {
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
{
bool Any(Expression<Func<T1, T2, T3, T4, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, T4, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column);
Task<TMember> AvgAsync<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> 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);
ISelectGrouping<TKey, (T1, T2, T3, T4)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3, T4)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, TKey>> exp);
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);
}
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);
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
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 {
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
{
bool Any(Expression<Func<T1, T2, T3, T4, T5, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, T4, T5, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column);
Task<TMember> AvgAsync<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> 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);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, TKey>> exp);
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);
}
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);
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
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 {
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
{
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
TMember Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column);
Task<TMember> AvgAsync<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> 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);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, TKey>> exp);
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);
}
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);
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
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 {
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
{
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<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> 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);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TKey>> exp);
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);
}
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);
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
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 {
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
{
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<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> 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);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TKey>> exp);
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);
}
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);
}
}

View File

@ -4,39 +4,41 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
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 {
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
{
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp);
bool Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp);
Task<bool> AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
DataTable ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
Task<DataTable> ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
List<TReturn> ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
List<TDto> ToList<TDto>();
Task<List<TDto>> ToListAsync<TDto>();
string ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select);
TReturn ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select);
Task<TReturn> ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
TMember Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column);
Task<TMember> SumAsync<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);
Task<TMember> MinAsync<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);
Task<TMember> MaxAsync<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);
Task<TMember> AvgAsync<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> 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);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TKey>> exp);
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TKey>> exp);
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);
}
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);
}
}

View File

@ -2,39 +2,41 @@
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql {
public interface ISelectFromExpression<T1> where T1 : class {
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);
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>
/// 查询条件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>
/// 按列排序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);
}
/// <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);
}
}

View File

@ -4,128 +4,132 @@ using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace FreeSql {
public interface ISelectGrouping<TKey, TValue> {
/// <summary>
/// 按聚合条件过滤Where(a => a.Count() > 10)
/// </summary>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Having(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, bool>> exp);
namespace FreeSql
{
public interface ISelectGrouping<TKey, TValue>
{
/// <summary>
/// 按聚合条件过滤Where(a => a.Count() > 10)
/// </summary>
/// <param name="exp">lambda表达式</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Having(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, bool>> exp);
/// <summary>
/// 按列排序OrderBy(a => a.Time)
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> OrderBy<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column);
/// <summary>
/// 按列倒向排序OrderByDescending(a => a.Time)
/// </summary>
/// <param name="column">列</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> OrderByDescending<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column);
/// <summary>
/// 按列排序OrderBy(a => a.Time)
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> OrderBy<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column);
/// <summary>
/// 按列倒向排序OrderByDescending(a => a.Time)
/// </summary>
/// <param name="column">列</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> OrderByDescending<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column);
/// <summary>
/// 执行SQL查询返回指定字段的记录记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
List<TReturn> ToList<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
/// <summary>
/// 执行SQL查询返回指定字段的记录记录不存在时返回 Count 为 0 的列表
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
List<TReturn> ToList<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
List<TReturn> Select<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
/// <summary>
/// 【linq to sql】专用方法不建议直接使用
/// </summary>
List<TReturn> Select<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
string ToSql<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <typeparam name="TReturn">返回类型</typeparam>
/// <param name="select">选择列</param>
/// <returns></returns>
string ToSql<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select);
/// <summary>
/// 查询向后偏移行数
/// </summary>
/// <param name="offset"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Skip(int offset);
/// <summary>
/// 查询向后偏移行数
/// </summary>
/// <param name="offset">行数</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Offset(int offset);
/// <summary>
/// 查询多少条数据
/// </summary>
/// <param name="limit"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Limit(int limit);
/// <summary>
/// 查询多少条数据
/// </summary>
/// <param name="limit"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Take(int limit);
/// <summary>
/// 查询向后偏移行数
/// </summary>
/// <param name="offset"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Skip(int offset);
/// <summary>
/// 查询向后偏移行数
/// </summary>
/// <param name="offset">行数</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Offset(int offset);
/// <summary>
/// 查询多少条数据
/// </summary>
/// <param name="limit"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Limit(int limit);
/// <summary>
/// 查询多少条数据
/// </summary>
/// <param name="limit"></param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Take(int limit);
/// <summary>
/// 分页
/// </summary>
/// <param name="pageNumber">第几页</param>
/// <param name="pageSize">每页多少</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Page(int pageNumber, int pageSize);
}
/// <summary>
/// 分页
/// </summary>
/// <param name="pageNumber">第几页</param>
/// <param name="pageSize">每页多少</param>
/// <returns></returns>
ISelectGrouping<TKey, TValue> Page(int pageNumber, int pageSize);
}
public interface ISelectGroupingAggregate<TKey> {
/// <summary>
/// 分组的数据
/// </summary>
TKey Key { get; set; }
/// <summary>
/// 记录总数
/// </summary>
/// <returns></returns>
int Count();
/// <summary>
/// 求和
/// </summary>
/// <typeparam name="T3"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
T3 Sum<T3>(T3 column);
/// <summary>
/// 平均值
/// </summary>
/// <typeparam name="T3"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
T3 Avg<T3>(T3 column);
/// <summary>
/// 最大值
/// </summary>
/// <typeparam name="T3"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
T3 Max<T3>(T3 column);
/// <summary>
/// 最小值
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
T3 Min<T3>(T3 column);
}
public interface ISelectGroupingAggregate<TKey, TValue> : ISelectGroupingAggregate<TKey> {
/// <summary>
/// 所有元素
/// </summary>
TValue Value { get; set; }
}
public interface ISelectGroupingAggregate<TKey>
{
/// <summary>
/// 分组的数据
/// </summary>
TKey Key { get; set; }
/// <summary>
/// 记录总数
/// </summary>
/// <returns></returns>
int Count();
/// <summary>
/// 求和
/// </summary>
/// <typeparam name="T3"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
T3 Sum<T3>(T3 column);
/// <summary>
/// 平均值
/// </summary>
/// <typeparam name="T3"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
T3 Avg<T3>(T3 column);
/// <summary>
/// 最大值
/// </summary>
/// <typeparam name="T3"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
T3 Max<T3>(T3 column);
/// <summary>
/// 最小值
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
T3 Min<T3>(T3 column);
}
public interface ISelectGroupingAggregate<TKey, TValue> : ISelectGroupingAggregate<TKey>
{
/// <summary>
/// 所有元素
/// </summary>
TValue Value { get; set; }
}
}

View File

@ -4,159 +4,161 @@ using System.Data.Common;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql {
public interface IUpdate<T1> where T1 : class {
namespace FreeSql
{
public interface IUpdate<T1> where T1 : class
{
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IUpdate<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
IUpdate<T1> WithConnection(DbConnection connection);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
IUpdate<T1> WithTransaction(DbTransaction transaction);
/// <summary>
/// 指定事务对象
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
IUpdate<T1> WithConnection(DbConnection connection);
/// <summary>
/// 不使用参数化,可通过 IFreeSql.CodeFirst.IsNotCommandParameter 全局性设置
/// </summary>
/// <returns></returns>
IUpdate<T1> NoneParameter();
/// <summary>
/// 不使用参数化,可通过 IFreeSql.CodeFirst.IsNotCommandParameter 全局性设置
/// </summary>
/// <returns></returns>
IUpdate<T1> NoneParameter();
/// <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>
/// 忽略的列
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
IUpdate<T1> IgnoreColumns(string[] columns);
/// <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>
/// 忽略的列
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
IUpdate<T1> IgnoreColumns(string[] columns);
/// <summary>
/// 指定的列UpdateColumns(a => a.Name) | UpdateColumns(a => new{a.Name,a.Time}) | UpdateColumns(a => new[]{"name","time"})
/// </summary>
/// <param name="columns">lambda选择列</param>
/// <returns></returns>
IUpdate<T1> UpdateColumns(Expression<Func<T1, object>> columns);
/// <summary>
/// 指定的列
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
IUpdate<T1> UpdateColumns(string[] columns);
/// <summary>
/// 指定的列UpdateColumns(a => a.Name) | UpdateColumns(a => new{a.Name,a.Time}) | UpdateColumns(a => new[]{"name","time"})
/// </summary>
/// <param name="columns">lambda选择列</param>
/// <returns></returns>
IUpdate<T1> UpdateColumns(Expression<Func<T1, object>> columns);
/// <summary>
/// 指定的列
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
IUpdate<T1> UpdateColumns(string[] 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
/// <para></para>
/// 指定更新格式Set(a => new { Clicks = a.Clicks + 1, Time = DateTime.Now }) 相当于 set clicks=clicks+1,time='2019-06-19....'
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
IUpdate<T1> Set<TMember>(Expression<Func<T1, TMember>> exp);
/// <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>
/// 设置列的新值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
/// <para></para>
/// 指定更新格式Set(a => new { Clicks = a.Clicks + 1, Time = DateTime.Now }) 相当于 set clicks=clicks+1,time='2019-06-19....'
/// </summary>
/// <typeparam name="TMember"></typeparam>
/// <param name="exp"></param>
/// <returns></returns>
IUpdate<T1> Set<TMember>(Expression<Func<T1, TMember>> exp);
/// <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>
/// 传入动态对象如:主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
IUpdate<T1> WhereDynamic(object dywhere);
/// <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>
/// 传入动态对象如:主键值 | new[]{主键值1,主键值2} | TEntity1 | new[]{TEntity1,TEntity2} | new{id=1}
/// </summary>
/// <param name="dywhere">主键值、主键值集合、实体、实体集合、匿名对象、匿名对象集合</param>
/// <returns></returns>
IUpdate<T1> WhereDynamic(object dywhere);
/// <summary>
/// 设置表名规则,可用于分库/分表参数1默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
IUpdate<T1> AsTable(Func<string, string> tableRule);
/// <summary>
/// 动态Type在使用 Update&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
IUpdate<T1> AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句返回影响的行数
/// </summary>
/// <returns></returns>
int ExecuteAffrows();
Task<int> ExecuteAffrowsAsync();
/// <summary>
/// 执行SQL语句返回更新后的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteUpdated();
Task<List<T1>> ExecuteUpdatedAsync();
}
/// <summary>
/// 设置表名规则,可用于分库/分表参数1默认表名返回值新表名
/// </summary>
/// <param name="tableRule"></param>
/// <returns></returns>
IUpdate<T1> AsTable(Func<string, string> tableRule);
/// <summary>
/// 动态Type在使用 Update&lt;object&gt; 后使用本方法,指定实体类型
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
IUpdate<T1> AsType(Type entityType);
/// <summary>
/// 返回即将执行的SQL语句
/// </summary>
/// <returns></returns>
string ToSql();
/// <summary>
/// 执行SQL语句返回影响的行数
/// </summary>
/// <returns></returns>
int ExecuteAffrows();
Task<int> ExecuteAffrowsAsync();
/// <summary>
/// 执行SQL语句返回更新后的记录
/// </summary>
/// <returns></returns>
List<T1> ExecuteUpdated();
Task<List<T1>> ExecuteUpdatedAsync();
}
}

View File

@ -7,385 +7,387 @@ 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>
/// 监视数据库命令对象(执行前,调试)
/// </summary>
Action<DbCommand> AopCommandExecuting { get; set; }
/// <summary>
/// 监视数据库命令对象(执行后,用于监视执行性能)
/// </summary>
Action<DbCommand, string> AopCommandExecuted { get; set; }
/// <summary>
/// 数据库类型
/// </summary>
DataType DataType { get; }
namespace FreeSql
{
public partial interface IAdo
{
/// <summary>
/// 主库连接池
/// </summary>
ObjectPool<DbConnection> MasterPool { get; }
/// <summary>
/// 从库连接池
/// </summary>
List<ObjectPool<DbConnection>> SlavePools { get; }
/// <summary>
/// 监视数据库命令对象(执行前,调试)
/// </summary>
Action<DbCommand> AopCommandExecuting { get; set; }
/// <summary>
/// 监视数据库命令对象(执行后,用于监视执行性能)
/// </summary>
Action<DbCommand, string> AopCommandExecuted { get; set; }
/// <summary>
/// 数据库类型
/// </summary>
DataType DataType { get; }
#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; }
#endregion
#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; }
#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);
void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
void ExecuteReader(DbConnection connection, DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteReader(dr => {}, "select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null);
void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null);
void ExecuteReader(DbConnection connection, DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteArray("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
object[][] ExecuteArray(string cmdText, object parms = null);
object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null);
object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
DataSet ExecuteDataSet(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataSet ExecuteDataSet(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataSet ExecuteDataSet(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataSet("select * from user where age > @age; select 2", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
DataSet ExecuteDataSet(string cmdText, object parms = null);
DataSet ExecuteDataSet(DbTransaction transaction, string cmdText, object parms = null);
DataSet ExecuteDataSet(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataTable("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
DataTable ExecuteDataTable(string cmdText, object parms = null);
DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null);
DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteNonQuery("delete from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
int ExecuteNonQuery(string cmdText, object parms = null);
int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null);
int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object ExecuteScalar(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteScalar("select 1 from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
object ExecuteScalar(string cmdText, object parms = null);
object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null);
object ExecuteScalar(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <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);
void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
void ExecuteReader(DbConnection connection, DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteReader(dr => {}, "select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null);
void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null);
void ExecuteReader(DbConnection connection, DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteArray("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
object[][] ExecuteArray(string cmdText, object parms = null);
object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null);
object[][] ExecuteArray(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
DataSet ExecuteDataSet(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataSet ExecuteDataSet(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataSet ExecuteDataSet(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataSet("select * from user where age > @age; select 2", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
DataSet ExecuteDataSet(string cmdText, object parms = null);
DataSet ExecuteDataSet(DbTransaction transaction, string cmdText, object parms = null);
DataSet ExecuteDataSet(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataTable("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
DataTable ExecuteDataTable(string cmdText, object parms = null);
DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null);
DataTable ExecuteDataTable(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteNonQuery("delete from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
int ExecuteNonQuery(string cmdText, object parms = null);
int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null);
int ExecuteNonQuery(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
object ExecuteScalar(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteScalar("select 1 from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
object ExecuteScalar(string cmdText, object parms = null);
object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null);
object ExecuteScalar(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
List<T> Query<T>(DbConnection connection, DbTransaction transaction, 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);
List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null);
List<T> Query<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
List<T> Query<T>(DbConnection connection, DbTransaction transaction, 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);
List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null);
List<T> Query<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
(List<T1>, List<T2>) Query<T1, T2>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>) Query<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>) Query<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new { age = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
(List<T1>, List<T2>) Query<T1, T2>(string cmdText, object parms = null);
(List<T1>, List<T2>) Query<T1, T2>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>) Query<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
(List<T1>, List<T2>) Query<T1, T2>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>) Query<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>) Query<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new { age = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
(List<T1>, List<T2>) Query<T1, T2>(string cmdText, object parms = null);
(List<T1>, List<T2>) Query<T1, T2>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>) Query<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>) Query<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>) Query<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null);
(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>) Query<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, 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);
Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteReaderAsync(dr => {}, "select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteArrayAsync("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<DataSet> ExecuteDataSetAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataSetAsync("select * from user where age > @age; select 2", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<DataSet> ExecuteDataSetAsync(string cmdText, object parms = null);
Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteScalarAsync("select 1 from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<object> ExecuteScalarAsync(string cmdText, object parms = null);
Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, 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);
Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteReaderAsync(dr => {}, "select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
Task ExecuteReaderAsync(DbConnection connection, DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteArrayAsync("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null);
Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<object[][]> ExecuteArrayAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<DataSet> ExecuteDataSetAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataSetAsync("select * from user where age > @age; select 2", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<DataSet> ExecuteDataSetAsync(string cmdText, object parms = null);
Task<DataSet> ExecuteDataSetAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<DataSet> ExecuteDataSetAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 查询
/// </summary>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 查询ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null);
Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<DataTable> ExecuteDataTableAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null);
Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<int> ExecuteNonQueryAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 在【主库】执行
/// </summary>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 在【主库】执行ExecuteScalarAsync("select 1 from user where age > @age", new { age = 25 })
/// </summary>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<object> ExecuteScalarAsync(string cmdText, object parms = null);
Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null);
Task<object> ExecuteScalarAsync(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合QueryAsync&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合QueryAsync&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);
Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null);
Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合QueryAsync&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合QueryAsync&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);
Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null);
Task<List<T>> QueryAsync<T>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new { age = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new SqlParameter { ParameterName = "age", Value = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdType"></param>
/// <param name="cmdText"></param>
/// <param name="cmdParms"></param>
/// <returns></returns>
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
/// <summary>
/// 执行SQL返回对象集合Query&lt;User&gt;("select * from user where age > @age; select * from address", new { age = 25 })
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="cmdText"></param>
/// <param name="parms"></param>
/// <returns></returns>
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>)> QueryAsync<T1, T2>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
#endregion
}
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>)> QueryAsync<T1, T2, T3>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>)> QueryAsync<T1, T2, T3, T4>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbTransaction transaction, string cmdText, object parms = null);
Task<(List<T1>, List<T2>, List<T3>, List<T4>, List<T5>)> QueryAsync<T1, T2, T3, T4, T5>(DbConnection connection, DbTransaction transaction, string cmdText, object parms = null);
#endregion
}
}

View File

@ -7,238 +7,261 @@ using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
namespace FreeSql {
public interface IAop {
namespace FreeSql
{
public interface IAop
{
/// <summary>
/// 监控 ToList 返回的的数据,用于拦截重新装饰
/// </summary>
EventHandler<Aop.ToListEventArgs> ToList { get; set; }
/// <summary>
/// 监控 ToList 返回的的数据,用于拦截重新装饰
/// </summary>
EventHandler<Aop.ToListEventArgs> ToList { get; set; }
/// <summary>
/// 监视 Where包括 select/update/delete可控制使上层不被执行。
/// </summary>
EventHandler<Aop.WhereEventArgs> Where { get; set; }
/// <summary>
/// 监视 Where包括 select/update/delete可控制使上层不被执行。
/// </summary>
EventHandler<Aop.WhereEventArgs> Where { get; set; }
/// <summary>
/// 可自定义解析表达式
/// </summary>
EventHandler<Aop.ParseExpressionEventArgs> ParseExpression { get; set; }
/// <summary>
/// 可自定义解析表达式
/// </summary>
EventHandler<Aop.ParseExpressionEventArgs> ParseExpression { get; set; }
/// <summary>
/// 自定义实体的配置,方便和多个 ORM 共同使用
/// </summary>
EventHandler<Aop.ConfigEntityEventArgs> ConfigEntity { get; set; }
/// <summary>
/// 自定义实体的属性配置,方便和多个 ORM 共同使用
/// </summary>
EventHandler<Aop.ConfigEntityPropertyEventArgs> ConfigEntityProperty { get; set; }
/// <summary>
/// 自定义实体的配置,方便和多个 ORM 共同使用
/// </summary>
EventHandler<Aop.ConfigEntityEventArgs> ConfigEntity { get; set; }
/// <summary>
/// 自定义实体的属性配置,方便和多个 ORM 共同使用
/// </summary>
EventHandler<Aop.ConfigEntityPropertyEventArgs> ConfigEntityProperty { get; set; }
/// <summary>
/// 增删查改,执行命令之前触发
/// </summary>
EventHandler<Aop.CurdBeforeEventArgs> CurdBefore { get; set; }
/// <summary>
/// 增删查改,执行命令完成后触发
/// </summary>
EventHandler<Aop.CurdAfterEventArgs> CurdAfter { get; set; }
/// <summary>
/// 增删查改,执行命令之前触发
/// </summary>
EventHandler<Aop.CurdBeforeEventArgs> CurdBefore { get; set; }
/// <summary>
/// 增删查改,执行命令完成后触发
/// </summary>
EventHandler<Aop.CurdAfterEventArgs> CurdAfter { get; set; }
/// <summary>
/// CodeFirst迁移执行之前触发
/// </summary>
EventHandler<Aop.SyncStructureBeforeEventArgs> SyncStructureBefore { get; set; }
/// <summary>
/// CodeFirst迁移执行完成触发
/// </summary>
EventHandler<Aop.SyncStructureAfterEventArgs> SyncStructureAfter { get; set; }
}
/// <summary>
/// CodeFirst迁移执行之前触发
/// </summary>
EventHandler<Aop.SyncStructureBeforeEventArgs> SyncStructureBefore { get; set; }
/// <summary>
/// CodeFirst迁移执行完成触发
/// </summary>
EventHandler<Aop.SyncStructureAfterEventArgs> SyncStructureAfter { get; set; }
}
}
namespace FreeSql.Aop {
public class ToListEventArgs : EventArgs {
public ToListEventArgs(object list) {
this.List = list;
}
/// <summary>
/// 可重新装饰的引用数据
/// </summary>
public object List { get; }
}
public class WhereEventArgs : EventArgs {
public WhereEventArgs(params object[] parameters) {
this.Parameters = parameters;
}
public object[] Parameters { get; }
/// <summary>
/// 可使上层不被执行这个条件
/// </summary>
public bool IsCancel { get; set; }
}
public class ParseExpressionEventArgs : EventArgs {
public ParseExpressionEventArgs(Expression expression, Func<Expression, string> freeParse) {
this.Expression = expression;
this.FreeParse = freeParse;
}
namespace FreeSql.Aop
{
public class ToListEventArgs : EventArgs
{
public ToListEventArgs(object list)
{
this.List = list;
}
/// <summary>
/// 可重新装饰的引用数据
/// </summary>
public object List { get; }
}
public class WhereEventArgs : EventArgs
{
public WhereEventArgs(params object[] parameters)
{
this.Parameters = parameters;
}
public object[] Parameters { get; }
/// <summary>
/// 可使上层不被执行这个条件
/// </summary>
public bool IsCancel { get; set; }
}
public class ParseExpressionEventArgs : EventArgs
{
public ParseExpressionEventArgs(Expression expression, Func<Expression, string> freeParse)
{
this.Expression = expression;
this.FreeParse = freeParse;
}
/// <summary>
/// 内置解析功能,可辅助您进行解析
/// </summary>
public Func<Expression, string> FreeParse { get; }
/// <summary>
/// 内置解析功能,可辅助您进行解析
/// </summary>
public Func<Expression, string> FreeParse { get; }
/// <summary>
/// 需要您解析的表达式
/// </summary>
public Expression Expression { get; }
/// <summary>
/// 解析后的内容
/// </summary>
public string Result { get; set; }
}
public class ConfigEntityEventArgs : EventArgs {
public ConfigEntityEventArgs(Type entityType) {
this.EntityType = entityType;
this.ModifyResult = new TableAttribute();
}
/// <summary>
/// 需要您解析的表达式
/// </summary>
public Expression Expression { get; }
/// <summary>
/// 解析后的内容
/// </summary>
public string Result { get; set; }
}
public class ConfigEntityEventArgs : EventArgs
{
public ConfigEntityEventArgs(Type entityType)
{
this.EntityType = entityType;
this.ModifyResult = new TableAttribute();
}
/// <summary>
/// 实体类型
/// </summary>
public Type EntityType { get; }
/// <summary>
/// 实体配置
/// </summary>
public TableAttribute ModifyResult { get; }
}
public class ConfigEntityPropertyEventArgs : EventArgs {
public ConfigEntityPropertyEventArgs(Type entityType, PropertyInfo property) {
this.EntityType = entityType;
this.Property = property;
this.ModifyResult = new ColumnAttribute();
}
/// <summary>
/// 实体类型
/// </summary>
public Type EntityType { get; }
/// <summary>
/// 实体配置
/// </summary>
public TableAttribute ModifyResult { get; }
}
public class ConfigEntityPropertyEventArgs : EventArgs
{
public ConfigEntityPropertyEventArgs(Type entityType, PropertyInfo property)
{
this.EntityType = entityType;
this.Property = property;
this.ModifyResult = new ColumnAttribute();
}
/// <summary>
/// 实体类型
/// </summary>
public Type EntityType { get; }
/// <summary>
/// 实体的属性
/// </summary>
public PropertyInfo Property { get; }
/// <summary>
/// 实体的属性配置
/// </summary>
public ColumnAttribute ModifyResult { get; }
}
/// <summary>
/// 实体类型
/// </summary>
public Type EntityType { get; }
/// <summary>
/// 实体的属性
/// </summary>
public PropertyInfo Property { get; }
/// <summary>
/// 实体的属性配置
/// </summary>
public ColumnAttribute ModifyResult { get; }
}
public class CurdBeforeEventArgs : EventArgs {
public CurdBeforeEventArgs(Type entityType, CurdType curdType, string sql, DbParameter[] dbParms) :
this(Guid.NewGuid(), new Stopwatch(), entityType, curdType, sql, dbParms) {
this.Stopwatch.Start();
}
protected CurdBeforeEventArgs(Guid identifier, Stopwatch stopwatch, Type entityType, CurdType curdType, string sql, DbParameter[] dbParms) {
this.Identifier = identifier;
this.Stopwatch = stopwatch;
this.EntityType = entityType;
this.CurdType = curdType;
this.Sql = sql;
this.DbParms = dbParms;
}
public class CurdBeforeEventArgs : EventArgs
{
public CurdBeforeEventArgs(Type entityType, CurdType curdType, string sql, DbParameter[] dbParms) :
this(Guid.NewGuid(), new Stopwatch(), entityType, curdType, sql, dbParms)
{
this.Stopwatch.Start();
}
protected CurdBeforeEventArgs(Guid identifier, Stopwatch stopwatch, Type entityType, CurdType curdType, string sql, DbParameter[] dbParms)
{
this.Identifier = identifier;
this.Stopwatch = stopwatch;
this.EntityType = entityType;
this.CurdType = curdType;
this.Sql = sql;
this.DbParms = dbParms;
}
/// <summary>
/// 标识符,可将 CurdBefore 与 CurdAfter 进行匹配
/// </summary>
public Guid Identifier { get; protected set; }
protected Stopwatch Stopwatch { get; }
internal Stopwatch StopwatchInternal => Stopwatch;
/// <summary>
/// 操作类型
/// </summary>
public CurdType CurdType { get; }
/// <summary>
/// 实体类型
/// </summary>
public Type EntityType { get; }
/// <summary>
/// 执行的 SQL
/// </summary>
public string Sql { get; }
/// <summary>
/// 参数化命令
/// </summary>
public DbParameter[] DbParms { get; }
}
public enum CurdType { Select, Delete, Update, Insert }
public class CurdAfterEventArgs : CurdBeforeEventArgs {
public CurdAfterEventArgs(CurdBeforeEventArgs before, Exception exception, object executeResult) :
base(before.Identifier, before.StopwatchInternal, before.EntityType, before.CurdType, before.Sql, before.DbParms) {
this.Exception = exception;
this.ExecuteResult = executeResult;
this.Stopwatch.Stop();
}
/// <summary>
/// 标识符,可将 CurdBefore 与 CurdAfter 进行匹配
/// </summary>
public Guid Identifier { get; protected set; }
protected Stopwatch Stopwatch { get; }
internal Stopwatch StopwatchInternal => Stopwatch;
/// <summary>
/// 操作类型
/// </summary>
public CurdType CurdType { get; }
/// <summary>
/// 实体类型
/// </summary>
public Type EntityType { get; }
/// <summary>
/// 执行的 SQL
/// </summary>
public string Sql { get; }
/// <summary>
/// 参数化命令
/// </summary>
public DbParameter[] DbParms { get; }
}
public enum CurdType { Select, Delete, Update, Insert }
public class CurdAfterEventArgs : CurdBeforeEventArgs
{
public CurdAfterEventArgs(CurdBeforeEventArgs before, Exception exception, object executeResult) :
base(before.Identifier, before.StopwatchInternal, before.EntityType, before.CurdType, before.Sql, before.DbParms)
{
this.Exception = exception;
this.ExecuteResult = executeResult;
this.Stopwatch.Stop();
}
/// <summary>
/// 发生的错误
/// </summary>
public Exception Exception { get; }
/// <summary>
/// 执行SQL命令返回的结果
/// </summary>
public object ExecuteResult { get; set; }
/// <summary>
/// 耗时单位Ticks
/// </summary>
public long ElapsedTicks => this.Stopwatch.ElapsedTicks;
/// <summary>
/// 耗时(单位:毫秒)
/// </summary>
public long ElapsedMilliseconds => this.Stopwatch.ElapsedMilliseconds;
}
/// <summary>
/// 发生的错误
/// </summary>
public Exception Exception { get; }
/// <summary>
/// 执行SQL命令返回的结果
/// </summary>
public object ExecuteResult { get; set; }
/// <summary>
/// 耗时单位Ticks
/// </summary>
public long ElapsedTicks => this.Stopwatch.ElapsedTicks;
/// <summary>
/// 耗时(单位:毫秒)
/// </summary>
public long ElapsedMilliseconds => this.Stopwatch.ElapsedMilliseconds;
}
public class SyncStructureBeforeEventArgs : EventArgs {
public SyncStructureBeforeEventArgs(Type[] entityTypes) :
this(Guid.NewGuid(), new Stopwatch(), entityTypes) {
this.Stopwatch.Start();
}
protected SyncStructureBeforeEventArgs(Guid identifier, Stopwatch stopwatch, Type[] entityTypes) {
this.Identifier = identifier;
this.Stopwatch = stopwatch;
this.EntityTypes = entityTypes;
}
public class SyncStructureBeforeEventArgs : EventArgs
{
public SyncStructureBeforeEventArgs(Type[] entityTypes) :
this(Guid.NewGuid(), new Stopwatch(), entityTypes)
{
this.Stopwatch.Start();
}
protected SyncStructureBeforeEventArgs(Guid identifier, Stopwatch stopwatch, Type[] entityTypes)
{
this.Identifier = identifier;
this.Stopwatch = stopwatch;
this.EntityTypes = entityTypes;
}
/// <summary>
/// 标识符,可将 SyncStructureBeforeEventArgs 与 SyncStructureAfterEventArgs 进行匹配
/// </summary>
public Guid Identifier { get; protected set; }
protected Stopwatch Stopwatch { get; }
internal Stopwatch StopwatchInternal => Stopwatch;
/// <summary>
/// 实体类型
/// </summary>
public Type[] EntityTypes { get; }
}
public class SyncStructureAfterEventArgs : SyncStructureBeforeEventArgs {
public SyncStructureAfterEventArgs(SyncStructureBeforeEventArgs before, string sql, Exception exception) :
base(before.Identifier, before.StopwatchInternal, before.EntityTypes) {
this.Sql = sql;
this.Exception = exception;
this.Stopwatch.Stop();
}
/// <summary>
/// 标识符,可将 SyncStructureBeforeEventArgs 与 SyncStructureAfterEventArgs 进行匹配
/// </summary>
public Guid Identifier { get; protected set; }
protected Stopwatch Stopwatch { get; }
internal Stopwatch StopwatchInternal => Stopwatch;
/// <summary>
/// 实体类型
/// </summary>
public Type[] EntityTypes { get; }
}
public class SyncStructureAfterEventArgs : SyncStructureBeforeEventArgs
{
public SyncStructureAfterEventArgs(SyncStructureBeforeEventArgs before, string sql, Exception exception) :
base(before.Identifier, before.StopwatchInternal, before.EntityTypes)
{
this.Sql = sql;
this.Exception = exception;
this.Stopwatch.Stop();
}
/// <summary>
/// 执行的 SQL
/// </summary>
public string Sql { get; }
/// <summary>
/// 发生的错误
/// </summary>
public Exception Exception { get; }
/// <summary>
/// 耗时单位Ticks
/// </summary>
public long ElapsedTicks => this.Stopwatch.ElapsedTicks;
/// <summary>
/// 耗时(单位:毫秒)
/// </summary>
public long ElapsedMilliseconds => this.Stopwatch.ElapsedMilliseconds;
}
/// <summary>
/// 执行的 SQL
/// </summary>
public string Sql { get; }
/// <summary>
/// 发生的错误
/// </summary>
public Exception Exception { get; }
/// <summary>
/// 耗时单位Ticks
/// </summary>
public long ElapsedTicks => this.Stopwatch.ElapsedTicks;
/// <summary>
/// 耗时(单位:毫秒)
/// </summary>
public long ElapsedMilliseconds => this.Stopwatch.ElapsedMilliseconds;
}
}

View File

@ -2,91 +2,93 @@
using FreeSql.Internal.Model;
using System;
namespace FreeSql {
public interface ICodeFirst {
namespace FreeSql
{
public interface ICodeFirst
{
/// <summary>
/// 【开发环境必备】自动同步实体结构到数据库,程序运行中检查实体表是否存在,然后创建或修改
/// </summary>
bool IsAutoSyncStructure { get; set; }
/// <summary>
/// 【开发环境必备】自动同步实体结构到数据库,程序运行中检查实体表是否存在,然后创建或修改
/// </summary>
bool IsAutoSyncStructure { get; set; }
/// <summary>
/// 转小写同步结构
/// </summary>
bool IsSyncStructureToLower { get; set; }
/// <summary>
/// 转大写同步结构
/// </summary>
bool IsSyncStructureToUpper { get; set; }
/// <summary>
/// 使用数据库的主键和自增,适用 DbFirst 模式,无须在实体类型上设置 [Column(IsPrimary)] 或者 ConfigEntity。此功能目前可用于 mysql/sqlserver/postgresql。
/// </summary>
bool IsConfigEntityFromDbFirst { get; set; }
/// <summary>
/// 不使用命令参数化执行,针对 Insert/Update
/// </summary>
bool IsNoneCommandParameter { get; set; }
/// <summary>
/// 延时加载导航属性对象,导航属性需要声明 virtual
/// </summary>
bool IsLazyLoading { get; set; }
/// <summary>
/// 转小写同步结构
/// </summary>
bool IsSyncStructureToLower { get; set; }
/// <summary>
/// 转大写同步结构
/// </summary>
bool IsSyncStructureToUpper { get; set; }
/// <summary>
/// 使用数据库的主键和自增,适用 DbFirst 模式,无须在实体类型上设置 [Column(IsPrimary)] 或者 ConfigEntity。此功能目前可用于 mysql/sqlserver/postgresql。
/// </summary>
bool IsConfigEntityFromDbFirst { get; set; }
/// <summary>
/// 不使用命令参数化执行,针对 Insert/Update
/// </summary>
bool IsNoneCommandParameter { get; set; }
/// <summary>
/// 延时加载导航属性对象,导航属性需要声明 virtual
/// </summary>
bool IsLazyLoading { 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>
/// 将实体类型与数据库对比返回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, object defaultValue)? GetDbInfo(Type type);
/// <summary>
/// 在外部配置实体的特性
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
ICodeFirst ConfigEntity<T>(Action<TableFluent<T>> entity);
/// <summary>
/// 在外部配置实体的特性
/// </summary>
/// <param name="type"></param>
/// <param name="entity"></param>
/// <returns></returns>
ICodeFirst ConfigEntity(Type type, Action<TableFluent> entity);
/// <summary>
/// 获取在外部配置实体的特性
/// </summary>
/// <param name="type"></param>
/// <returns>未使用ConfigEntity配置时返回null</returns>
TableAttribute GetConfigEntity(Type type);
/// <summary>
/// 获取实体类核心配置
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
TableInfo GetTableByEntity(Type type);
}
/// <summary>
/// 根据 System.Type 获取数据库信息
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
(int type, string dbtype, string dbtypeFull, bool? isnullable, object defaultValue)? GetDbInfo(Type type);
/// <summary>
/// 在外部配置实体的特性
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
ICodeFirst ConfigEntity<T>(Action<TableFluent<T>> entity);
/// <summary>
/// 在外部配置实体的特性
/// </summary>
/// <param name="type"></param>
/// <param name="entity"></param>
/// <returns></returns>
ICodeFirst ConfigEntity(Type type, Action<TableFluent> entity);
/// <summary>
/// 获取在外部配置实体的特性
/// </summary>
/// <param name="type"></param>
/// <returns>未使用ConfigEntity配置时返回null</returns>
TableAttribute GetConfigEntity(Type type);
/// <summary>
/// 获取实体类核心配置
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
TableInfo GetTableByEntity(Type type);
}
}

View File

@ -4,104 +4,105 @@ using System.Collections.Generic;
public interface IFreeSql<TMark> : IFreeSql { }
public interface IFreeSql : IDisposable {
/// <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>(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;
public interface IFreeSql : IDisposable
{
/// <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>(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>
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>
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>
/// 删除数据
/// </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>
/// 开启事务不支持异步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>
IAdo Ado { get; }
/// <summary>
/// 所有拦截方法都在这里
/// </summary>
IAop Aop { get; }
/// <summary>
/// 数据库访问对象
/// </summary>
IAdo Ado { get; }
/// <summary>
/// 所有拦截方法都在这里
/// </summary>
IAop Aop { get; }
/// <summary>
/// CodeFirst 模式开发相关方法
/// </summary>
ICodeFirst CodeFirst { get; }
/// <summary>
/// DbFirst 模式开发相关方法
/// </summary>
IDbFirst DbFirst { get; }
/// <summary>
/// CodeFirst 模式开发相关方法
/// </summary>
ICodeFirst CodeFirst { get; }
/// <summary>
/// DbFirst 模式开发相关方法
/// </summary>
IDbFirst DbFirst { get; }
}

View File

@ -2,76 +2,78 @@
using System;
using System.Collections.Generic;
namespace FreeSql {
public interface IDbFirst {
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>
/// 获取所有数据库
/// </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>
/// 获取数据库枚举类型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);
/// <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);
/// <summary>
/// 获取数据库枚举类型,适用 PostgreSQL
/// </summary>
/// <param name="database"></param>
/// <returns></returns>
List<DbEnumInfo> GetEnumsByDatabase(params string[] database);
}
/// <summary>
/// 获取数据库枚举类型,适用 PostgreSQL
/// </summary>
/// <param name="database"></param>
/// <returns></returns>
List<DbEnumInfo> GetEnumsByDatabase(params string[] database);
}
}