tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-11-04 09:15:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

源代码改用vs默认格式化

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

143
FreeSql/DataAnnotations/ColumnAttribute.cs
View File

@@ -1,76 +1,83 @@
using System;
using System.Linq;
namespace FreeSql.DataAnnotations {
public class ColumnAttribute : Attribute {
namespace FreeSql.DataAnnotations
{
public class ColumnAttribute : Attribute
{
/// <summary>
/// 数据库列名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 指定数据库旧的列名，修改实体属性命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库字段；否则将视为【新增字段】
/// </summary>
public string OldName { get; set; }
/// <summary>
/// 数据库类型，如： varchar(255)
/// </summary>
public string DbType { get; set; }
/// <summary>
/// 数据库列名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 指定数据库旧的列名，修改实体属性命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库字段；否则将视为【新增字段】
/// </summary>
public string OldName { get; set; }
/// <summary>
/// 数据库类型，如： varchar(255)
/// </summary>
public string DbType { get; set; }
internal bool? _IsPrimary, _IsIdentity, _IsNullable, _IsIgnore, _IsVersion;
/// <summary>
/// 主键
/// </summary>
public bool IsPrimary { get => _IsPrimary ?? false; set => _IsPrimary = value; }
/// <summary>
/// 自增标识
/// </summary>
public bool IsIdentity { get => _IsIdentity ?? false; set => _IsIdentity = value; }
/// <summary>
/// 是否可DBNull
/// </summary>
public bool IsNullable { get => _IsNullable ?? false; set => _IsNullable = value; }
/// <summary>
/// 忽略此列，不迁移、不插入
/// </summary>
public bool IsIgnore { get => _IsIgnore ?? false; set => _IsIgnore = value; }
/// <summary>
/// 设置行锁（乐观锁）版本号，每次更新累加版本号，若更新整个实体时会附带当前的版本号判断（修改失败时抛出异常）
/// </summary>
public bool IsVersion { get => _IsVersion ?? false; set => _IsVersion = value; }
internal bool? _IsPrimary, _IsIdentity, _IsNullable, _IsIgnore, _IsVersion;
/// <summary>
/// 主键
/// </summary>
public bool IsPrimary { get => _IsPrimary ?? false; set => _IsPrimary = value; }
/// <summary>
/// 自增标识
/// </summary>
public bool IsIdentity { get => _IsIdentity ?? false; set => _IsIdentity = value; }
/// <summary>
/// 是否可DBNull
/// </summary>
public bool IsNullable { get => _IsNullable ?? false; set => _IsNullable = value; }
/// <summary>
/// 忽略此列，不迁移、不插入
/// </summary>
public bool IsIgnore { get => _IsIgnore ?? false; set => _IsIgnore = value; }
/// <summary>
/// 设置行锁（乐观锁）版本号，每次更新累加版本号，若更新整个实体时会附带当前的版本号判断（修改失败时抛出异常）
/// </summary>
public bool IsVersion { get => _IsVersion ?? false; set => _IsVersion = value; }
internal string[] _Uniques;
/// <summary>
/// 唯一键，在多个属性指定相同的标识，代表联合键；可使用逗号分割多个 UniqueKey 名。
/// </summary>
public string Unique {
get => _Uniques == null ? null : string.Join(", ", _Uniques);
set {
if (string.IsNullOrEmpty(value)) {
_Uniques = null;
return;
}
var val = value?.Trim(' ', '\t', ',');
if (string.IsNullOrEmpty(val)) {
_Uniques = null;
return;
}
var arr = val.Split(',').Select(a => a.Trim(' ', '\t').Trim()).Where(a => !string.IsNullOrEmpty(a)).ToArray();
if (arr.Any() == false) {
_Uniques = null;
return;
}
_Uniques = arr;
}
}
/// <summary>
/// 数据库默认值
/// </summary>
public object DbDefautValue { get; internal set; }
internal string[] _Uniques;
/// <summary>
/// 唯一键，在多个属性指定相同的标识，代表联合键；可使用逗号分割多个 UniqueKey 名。
/// </summary>
public string Unique
{
get => _Uniques == null ? null : string.Join(", ", _Uniques);
set
{
if (string.IsNullOrEmpty(value))
{
_Uniques = null;
return;
}
var val = value?.Trim(' ', '\t', ',');
if (string.IsNullOrEmpty(val))
{
_Uniques = null;
return;
}
var arr = val.Split(',').Select(a => a.Trim(' ', '\t').Trim()).Where(a => !string.IsNullOrEmpty(a)).ToArray();
if (arr.Any() == false)
{
_Uniques = null;
return;
}
_Uniques = arr;
}
}
/// <summary>
/// 数据库默认值
/// </summary>
public object DbDefautValue { get; internal set; }
/// <summary>
/// 类型映射，比如：可将 enum 属性映射成 typeof(string)
/// </summary>
public Type MapType { get; set; }
}
/// <summary>
/// 类型映射，比如：可将 enum 属性映射成 typeof(string)
/// </summary>
public Type MapType { get; set; }
}
}

175
FreeSql/DataAnnotations/ColumnFluent.cs
View File

@@ -1,87 +1,100 @@
using System;
namespace FreeSql.DataAnnotations {
public class ColumnFluent {
namespace FreeSql.DataAnnotations
{
public class ColumnFluent
{
public ColumnFluent(ColumnAttribute column) {
_column = column;
}
public ColumnFluent(ColumnAttribute column)
{
_column = column;
}
ColumnAttribute _column;
/// <summary>
/// 数据库列名
/// </summary>
public ColumnFluent Name(string value) {
_column.Name = value;
return this;
}
/// <summary>
/// 指定数据库旧的列名，修改实体属性命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库字段；否则将视为【新增字段】
/// </summary>
public ColumnFluent OldName(string value) {
_column.OldName = value;
return this;
}
/// <summary>
/// 数据库类型，如： varchar(255)
/// </summary>
public ColumnFluent DbType(string value) {
_column.DbType = value;
return this;
}
ColumnAttribute _column;
/// <summary>
/// 数据库列名
/// </summary>
public ColumnFluent Name(string value)
{
_column.Name = value;
return this;
}
/// <summary>
/// 指定数据库旧的列名，修改实体属性命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库字段；否则将视为【新增字段】
/// </summary>
public ColumnFluent OldName(string value)
{
_column.OldName = value;
return this;
}
/// <summary>
/// 数据库类型，如： varchar(255)
/// </summary>
public ColumnFluent DbType(string value)
{
_column.DbType = value;
return this;
}
/// <summary>
/// 主键
/// </summary>
public ColumnFluent IsPrimary(bool value) {
_column.IsPrimary = value;
return this;
}
/// <summary>
/// 自增标识
/// </summary>
public ColumnFluent IsIdentity(bool value) {
_column.IsIdentity = value;
return this;
}
/// <summary>
/// 是否可DBNull
/// </summary>
public ColumnFluent IsNullable(bool value) {
_column.IsNullable = value;
return this;
}
/// <summary>
/// 忽略此列，不迁移、不插入
/// </summary>
public ColumnFluent IsIgnore(bool value) {
_column.IsIgnore = value;
return this;
}
/// <summary>
/// 乐观锁
/// </summary>
public ColumnFluent IsVersion(bool value) {
_column.IsVersion = value;
return this;
}
/// <summary>
/// 唯一键，在多个属性指定相同的标识，代表联合键；可使用逗号分割多个 UniqueKey 名。
/// </summary>
/// <param name="value">标识</param>
/// <returns></returns>
public ColumnFluent Unique(string value) {
_column.Unique = value;
return this;
}
/// <summary>
/// 类型映射，比如：可将 enum 属性映射成 typeof(string)
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public ColumnFluent MapType(Type type) {
_column.MapType = type;
return this;
}
}
/// <summary>
/// 主键
/// </summary>
public ColumnFluent IsPrimary(bool value)
{
_column.IsPrimary = value;
return this;
}
/// <summary>
/// 自增标识
/// </summary>
public ColumnFluent IsIdentity(bool value)
{
_column.IsIdentity = value;
return this;
}
/// <summary>
/// 是否可DBNull
/// </summary>
public ColumnFluent IsNullable(bool value)
{
_column.IsNullable = value;
return this;
}
/// <summary>
/// 忽略此列，不迁移、不插入
/// </summary>
public ColumnFluent IsIgnore(bool value)
{
_column.IsIgnore = value;
return this;
}
/// <summary>
/// 乐观锁
/// </summary>
public ColumnFluent IsVersion(bool value)
{
_column.IsVersion = value;
return this;
}
/// <summary>
/// 唯一键，在多个属性指定相同的标识，代表联合键；可使用逗号分割多个 UniqueKey 名。
/// </summary>
/// <param name="value">标识</param>
/// <returns></returns>
public ColumnFluent Unique(string value)
{
_column.Unique = value;
return this;
}
/// <summary>
/// 类型映射，比如：可将 enum 属性映射成 typeof(string)
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public ColumnFluent MapType(Type type)
{
_column.MapType = type;
return this;
}
}
}

23
FreeSql/DataAnnotations/NavigateAttribute.cs
View File

@@ -1,16 +1,19 @@
using System;
using System.Linq;
namespace FreeSql.DataAnnotations {
public class NavigateAttribute : Attribute {
namespace FreeSql.DataAnnotations
{
public class NavigateAttribute : Attribute
{
/// <summary>
/// 导航属性，手工绑定
/// </summary>
public string Bind { get; set; }
/// <summary>
/// 导航属性，手工绑定
/// </summary>
public string Bind { get; set; }
public NavigateAttribute(string bind) {
this.Bind = bind;
}
}
public NavigateAttribute(string bind)
{
this.Bind = bind;
}
}
}

44
FreeSql/DataAnnotations/TableAttribute.cs
View File

@@ -1,28 +1,30 @@
using System;
using System.Collections.Concurrent;
namespace FreeSql.DataAnnotations {
public class TableAttribute : Attribute {
namespace FreeSql.DataAnnotations
{
public class TableAttribute : Attribute
{
/// <summary>
/// 数据库表名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 指定数据库旧的表名，修改实体命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库表；否则将视为【创建新表】
/// </summary>
public string OldName { get; set; }
/// <summary>
/// 查询过滤SQL，实现类似 a.IsDeleted = 1 功能
/// </summary>
public string SelectFilter { get; set; }
/// <summary>
/// 数据库表名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 指定数据库旧的表名，修改实体命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库表；否则将视为【创建新表】
/// </summary>
public string OldName { get; set; }
/// <summary>
/// 查询过滤SQL，实现类似 a.IsDeleted = 1 功能
/// </summary>
public string SelectFilter { get; set; }
internal bool? _DisableSyncStructure;
/// <summary>
/// 禁用 CodeFirst 同步结构迁移
/// </summary>
public bool DisableSyncStructure { get => _DisableSyncStructure ?? false; set => _DisableSyncStructure = value; }
internal bool? _DisableSyncStructure;
/// <summary>
/// 禁用 CodeFirst 同步结构迁移
/// </summary>
public bool DisableSyncStructure { get => _DisableSyncStructure ?? false; set => _DisableSyncStructure = value; }
internal ConcurrentDictionary<string, ColumnAttribute> _columns { get; } = new ConcurrentDictionary<string, ColumnAttribute>(StringComparer.CurrentCultureIgnoreCase);
}
internal ConcurrentDictionary<string, ColumnAttribute> _columns { get; } = new ConcurrentDictionary<string, ColumnAttribute>(StringComparer.CurrentCultureIgnoreCase);
}
}

183
FreeSql/DataAnnotations/TableFluent.cs
View File

@@ -4,97 +4,112 @@ using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
namespace FreeSql.DataAnnotations {
public class TableFluent {
namespace FreeSql.DataAnnotations
{
public class TableFluent
{
public TableFluent(Type entityType, TableAttribute table) {
_entityType = entityType;
_properties = _entityType.GetProperties().ToDictionary(a => a.Name, a => a, StringComparer.CurrentCultureIgnoreCase);
_table = table;
}
public TableFluent(Type entityType, TableAttribute table)
{
_entityType = entityType;
_properties = _entityType.GetProperties().ToDictionary(a => a.Name, a => a, StringComparer.CurrentCultureIgnoreCase);
_table = table;
}
Type _entityType;
Dictionary<string, PropertyInfo> _properties;
TableAttribute _table;
/// <summary>
/// 数据库表名
/// </summary>
public TableFluent Name(string value) {
_table.Name = value;
return this;
}
/// <summary>
/// 指定数据库旧的表名，修改实体命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库表；否则将视为【创建新表】
/// </summary>
public TableFluent OldName(string value) {
_table.OldName = value;
return this;
}
/// <summary>
/// 查询过滤SQL，实现类似 a.IsDeleted = 1 功能
/// </summary>
public TableFluent SelectFilter(string value) {
_table.SelectFilter = value;
return this;
}
Type _entityType;
Dictionary<string, PropertyInfo> _properties;
TableAttribute _table;
/// <summary>
/// 数据库表名
/// </summary>
public TableFluent Name(string value)
{
_table.Name = value;
return this;
}
/// <summary>
/// 指定数据库旧的表名，修改实体命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库表；否则将视为【创建新表】
/// </summary>
public TableFluent OldName(string value)
{
_table.OldName = value;
return this;
}
/// <summary>
/// 查询过滤SQL，实现类似 a.IsDeleted = 1 功能
/// </summary>
public TableFluent SelectFilter(string value)
{
_table.SelectFilter = value;
return this;
}
/// <summary>
/// 禁用 CodeFirst 同步结构迁移
/// </summary>
public TableFluent DisableSyncStructure(bool value) {
_table.DisableSyncStructure = value;
return this;
}
/// <summary>
/// 禁用 CodeFirst 同步结构迁移
/// </summary>
public TableFluent DisableSyncStructure(bool value)
{
_table.DisableSyncStructure = value;
return this;
}
public ColumnFluent Property(string proto) {
if (_properties.ContainsKey(proto) == false) throw new KeyNotFoundException($"找不到属性名 {proto}");
var col = _table._columns.GetOrAdd(proto, name => new ColumnAttribute { Name = proto });
return new ColumnFluent(col);
}
}
public ColumnFluent Property(string proto)
{
if (_properties.ContainsKey(proto) == false) throw new KeyNotFoundException($"找不到属性名 {proto}");
var col = _table._columns.GetOrAdd(proto, name => new ColumnAttribute { Name = proto });
return new ColumnFluent(col);
}
}
public class TableFluent<T> {
public class TableFluent<T>
{
public TableFluent(TableAttribute table) {
_table = table;
}
public TableFluent(TableAttribute table)
{
_table = table;
}
TableAttribute _table;
/// <summary>
/// 数据库表名
/// </summary>
public TableFluent<T> Name(string value) {
_table.Name = value;
return this;
}
/// <summary>
/// 指定数据库旧的表名，修改实体命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库表；否则将视为【创建新表】
/// </summary>
public TableFluent<T> OldName(string value) {
_table.OldName = value;
return this;
}
/// <summary>
/// 查询过滤SQL，实现类似 a.IsDeleted = 1 功能
/// </summary>
public TableFluent<T> SelectFilter(string value) {
_table.SelectFilter = value;
return this;
}
TableAttribute _table;
/// <summary>
/// 数据库表名
/// </summary>
public TableFluent<T> Name(string value)
{
_table.Name = value;
return this;
}
/// <summary>
/// 指定数据库旧的表名，修改实体命名时，同时设置此参数为修改之前的值，CodeFirst才可以正确修改数据库表；否则将视为【创建新表】
/// </summary>
public TableFluent<T> OldName(string value)
{
_table.OldName = value;
return this;
}
/// <summary>
/// 查询过滤SQL，实现类似 a.IsDeleted = 1 功能
/// </summary>
public TableFluent<T> SelectFilter(string value)
{
_table.SelectFilter = value;
return this;
}
/// <summary>
/// 禁用 CodeFirst 同步结构迁移
/// </summary>
public TableFluent<T> DisableSyncStructure(bool value) {
_table.DisableSyncStructure = value;
return this;
}
/// <summary>
/// 禁用 CodeFirst 同步结构迁移
/// </summary>
public TableFluent<T> DisableSyncStructure(bool value)
{
_table.DisableSyncStructure = value;
return this;
}
public ColumnFluent Property<TProto>(Expression<Func<T, TProto>> column) {
var proto = (column.Body as MemberExpression)?.Member;
if (proto == null) throw new FormatException($"错误的表达式格式 {column}");
var col = _table._columns.GetOrAdd(proto.Name, name => new ColumnAttribute { Name = proto.Name });
return new ColumnFluent(col);
}
}
public ColumnFluent Property<TProto>(Expression<Func<T, TProto>> column)
{
var proto = (column.Body as MemberExpression)?.Member;
if (proto == null) throw new FormatException($"错误的表达式格式 {column}");
var col = _table._columns.GetOrAdd(proto.Name, name => new ColumnAttribute { Name = proto.Name });
return new ColumnFluent(col);
}
}
}

5
FreeSql/DataType.cs
View File

@@ -2,6 +2,7 @@
using System.Collections.Generic;
using System.Text;
namespace FreeSql {
public enum DataType { MySql, SqlServer, PostgreSQL, Oracle, Sqlite }
namespace FreeSql
{
public enum DataType { MySql, SqlServer, PostgreSQL, Oracle, Sqlite }
}

96
FreeSql/DatabaseModel/DBColumnInfo.cs
View File

@@ -1,50 +1,52 @@
using System;
namespace FreeSql.DatabaseModel {
public class DbColumnInfo {
/// <summary>
/// 所属表
/// </summary>
public DbTableInfo Table { get; set; }
/// <summary>
/// 列名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 映射到 C# 类型
/// </summary>
public Type CsType { get; set; }
/// <summary>
/// 数据库枚举类型int值
/// </summary>
public int DbType { get; set; }
/// <summary>
/// 数据库类型，字符串，varchar
/// </summary>
public string DbTypeText { get; set; }
/// <summary>
/// 数据库类型，字符串，varchar(255)
/// </summary>
public string DbTypeTextFull { get; set; }
/// <summary>
/// 最大长度
/// </summary>
public int MaxLength { get; set; }
/// <summary>
/// 主键
/// </summary>
public bool IsPrimary { get; set; }
/// <summary>
/// 自增标识
/// </summary>
public bool IsIdentity { get; set; }
/// <summary>
/// 是否可DBNull
/// </summary>
public bool IsNullable { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Coment { get; set; }
}
namespace FreeSql.DatabaseModel
{
public class DbColumnInfo
{
/// <summary>
/// 所属表
/// </summary>
public DbTableInfo Table { get; set; }
/// <summary>
/// 列名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 映射到 C# 类型
/// </summary>
public Type CsType { get; set; }
/// <summary>
/// 数据库枚举类型int值
/// </summary>
public int DbType { get; set; }
/// <summary>
/// 数据库类型，字符串，varchar
/// </summary>
public string DbTypeText { get; set; }
/// <summary>
/// 数据库类型，字符串，varchar(255)
/// </summary>
public string DbTypeTextFull { get; set; }
/// <summary>
/// 最大长度
/// </summary>
public int MaxLength { get; set; }
/// <summary>
/// 主键
/// </summary>
public bool IsPrimary { get; set; }
/// <summary>
/// 自增标识
/// </summary>
public bool IsIdentity { get; set; }
/// <summary>
/// 是否可DBNull
/// </summary>
public bool IsNullable { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Coment { get; set; }
}
}

109
FreeSql/DatabaseModel/DBTableInfo.cs
View File

@@ -1,59 +1,62 @@
using System.Collections.Generic;
using System.Linq;
namespace FreeSql.DatabaseModel {
public class DbTableInfo {
/// <summary>
/// 唯一标识
/// </summary>
public string Id { get; set; }
/// <summary>
/// SqlServer下是Owner、PostgreSQL下是Schema、MySql下是数据库名
/// </summary>
public string Schema { get; set; }
/// <summary>
/// 表名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 表备注，SqlServer下是扩展属性 MS_Description
/// </summary>
public string Comment { get; set; }
/// <summary>
/// 表/视图
/// </summary>
public DbTableType Type { get; set; }
/// <summary>
/// 列
/// </summary>
public List<DbColumnInfo> Columns { get; set; } = new List<DbColumnInfo>();
/// <summary>
/// 自增列
/// </summary>
public List<DbColumnInfo> Identitys { get; set; } = new List<DbColumnInfo>();
/// <summary>
/// 主键/组合
/// </summary>
public List<DbColumnInfo> Primarys { get; set; } = new List<DbColumnInfo>();
/// <summary>
/// 唯一键/组合
/// </summary>
public Dictionary<string, List<DbColumnInfo>> UniquesDict { get; set; } = new Dictionary<string, List<DbColumnInfo>>();
/// <summary>
/// 索引/组合
/// </summary>
public Dictionary<string, List<DbColumnInfo>> IndexesDict { get; set; } = new Dictionary<string, List<DbColumnInfo>>();
/// <summary>
/// 外键
/// </summary>
public Dictionary<string, DbForeignInfo> ForeignsDict { get; set; } = new Dictionary<string, DbForeignInfo>();
namespace FreeSql.DatabaseModel
{
public class DbTableInfo
{
/// <summary>
/// 唯一标识
/// </summary>
public string Id { get; set; }
/// <summary>
/// SqlServer下是Owner、PostgreSQL下是Schema、MySql下是数据库名
/// </summary>
public string Schema { get; set; }
/// <summary>
/// 表名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 表备注，SqlServer下是扩展属性 MS_Description
/// </summary>
public string Comment { get; set; }
/// <summary>
/// 表/视图
/// </summary>
public DbTableType Type { get; set; }
/// <summary>
/// 列
/// </summary>
public List<DbColumnInfo> Columns { get; set; } = new List<DbColumnInfo>();
/// <summary>
/// 自增列
/// </summary>
public List<DbColumnInfo> Identitys { get; set; } = new List<DbColumnInfo>();
/// <summary>
/// 主键/组合
/// </summary>
public List<DbColumnInfo> Primarys { get; set; } = new List<DbColumnInfo>();
/// <summary>
/// 唯一键/组合
/// </summary>
public Dictionary<string, List<DbColumnInfo>> UniquesDict { get; set; } = new Dictionary<string, List<DbColumnInfo>>();
/// <summary>
/// 索引/组合
/// </summary>
public Dictionary<string, List<DbColumnInfo>> IndexesDict { get; set; } = new Dictionary<string, List<DbColumnInfo>>();
/// <summary>
/// 外键
/// </summary>
public Dictionary<string, DbForeignInfo> ForeignsDict { get; set; } = new Dictionary<string, DbForeignInfo>();
public List<List<DbColumnInfo>> Uniques => UniquesDict.Values.ToList();
public List<List<DbColumnInfo>> Indexes => IndexesDict.Values.ToList();
public List<DbForeignInfo> Foreigns => ForeignsDict.Values.ToList();
}
public List<List<DbColumnInfo>> Uniques => UniquesDict.Values.ToList();
public List<List<DbColumnInfo>> Indexes => IndexesDict.Values.ToList();
public List<DbForeignInfo> Foreigns => ForeignsDict.Values.ToList();
}
public enum DbTableType {
TABLE, VIEW, StoreProcedure
}
public enum DbTableType
{
TABLE, VIEW, StoreProcedure
}
}

24
FreeSql/DatabaseModel/DbEnumInfo.cs
View File

@@ -1,16 +1,18 @@
using System.Collections.Generic;
namespace FreeSql.DatabaseModel {
public class DbEnumInfo {
namespace FreeSql.DatabaseModel
{
public class DbEnumInfo
{
/// <summary>
/// 枚举类型标识
/// </summary>
public string Name { get; set; }
/// <summary>
/// 枚举类型标识
/// </summary>
public string Name { get; set; }
/// <summary>
/// 枚举项
/// </summary>
public Dictionary<string, string> Labels { get; set; }
}
/// <summary>
/// 枚举项
/// </summary>
public Dictionary<string, string> Labels { get; set; }
}
}

16
FreeSql/DatabaseModel/DbForeignInfo.cs
View File

@@ -1,11 +1,13 @@
using System.Collections.Generic;
namespace FreeSql.DatabaseModel {
public class DbForeignInfo {
public DbTableInfo Table { get; set; }
public List<DbColumnInfo> Columns { get; set; } = new List<DbColumnInfo>();
public DbTableInfo ReferencedTable { get; set; }
public List<DbColumnInfo> ReferencedColumns { get; set; } = new List<DbColumnInfo>();
namespace FreeSql.DatabaseModel
{
public class DbForeignInfo
{
public DbTableInfo Table { get; set; }
public List<DbColumnInfo> Columns { get; set; } = new List<DbColumnInfo>();
public DbTableInfo ReferencedTable { get; set; }
public List<DbColumnInfo> ReferencedColumns { get; set; } = new List<DbColumnInfo>();
}
}
}

24
FreeSql/DatabaseModel/DbTypeInfo.cs
View File

@@ -1,16 +1,18 @@
using System.Collections.Generic;
namespace FreeSql.DatabaseModel {
public class DbTypeInfo {
namespace FreeSql.DatabaseModel
{
public class DbTypeInfo
{
/// <summary>
/// 类型标识
/// </summary>
public string Name { get; set; }
/// <summary>
/// 类型标识
/// </summary>
public string Name { get; set; }
/// <summary>
/// 枚举项
/// </summary>
public List<(string label, string value)> Labels { get; set; }
}
/// <summary>
/// 枚举项
/// </summary>
public List<(string label, string value)> Labels { get; set; }
}
}

1334
FreeSql/Extensions/EntityUtilExtensions.cs
View File

File diff suppressed because it is too large Load Diff

169
FreeSql/Extensions/FreeSqlGlobalExtensions.cs
View File

@@ -8,84 +8,105 @@ using System.Drawing;
using System.Linq;
using System.Reflection;
public static partial class FreeSqlGlobalExtensions {
public static partial class FreeSqlGlobalExtensions
{
public static FreeSql.ISelect<T> Queryable<T>(this IFreeSql freesql) where T : class => freesql.Select<T>();
public static FreeSql.ISelect<T> Queryable<T>(this IFreeSql freesql) where T : class => freesql.Select<T>();
static Lazy<Dictionary<Type, bool>> dicIsNumberType = new Lazy<Dictionary<Type, bool>>(() => new Dictionary<Type, bool> {
[typeof(sbyte)] = true, [typeof(sbyte?)] = true,
[typeof(short)] = true, [typeof(short?)] = true,
[typeof(int)] = true, [typeof(int?)] = true,
[typeof(long)] = true, [typeof(long?)] = true,
[typeof(byte)] = true, [typeof(byte?)] = true,
[typeof(ushort)] = true, [typeof(ushort?)] = true,
[typeof(uint)] = true, [typeof(uint?)] = true,
[typeof(ulong)] = true, [typeof(ulong?)] = true,
[typeof(double)] = true, [typeof(double?)] = true,
[typeof(float)] = true, [typeof(float?)] = true,
[typeof(decimal)] = true, [typeof(decimal?)] = true
});
public static bool IsNumberType(this Type that) => that == null ? false : dicIsNumberType.Value.ContainsKey(that);
public static bool IsNullableType(this Type that) => that?.FullName.StartsWith("System.Nullable`1[") == true;
public static bool IsAnonymousType(this Type that) => that?.FullName.StartsWith("<>f__AnonymousType") == true;
public static Type NullableTypeOrThis(this Type that) => that?.IsNullableType() == true ? that.GenericTypeArguments.First() : that;
static Lazy<Dictionary<Type, bool>> dicIsNumberType = new Lazy<Dictionary<Type, bool>>(() => new Dictionary<Type, bool>
{
[typeof(sbyte)] = true,
[typeof(sbyte?)] = true,
[typeof(short)] = true,
[typeof(short?)] = true,
[typeof(int)] = true,
[typeof(int?)] = true,
[typeof(long)] = true,
[typeof(long?)] = true,
[typeof(byte)] = true,
[typeof(byte?)] = true,
[typeof(ushort)] = true,
[typeof(ushort?)] = true,
[typeof(uint)] = true,
[typeof(uint?)] = true,
[typeof(ulong)] = true,
[typeof(ulong?)] = true,
[typeof(double)] = true,
[typeof(double?)] = true,
[typeof(float)] = true,
[typeof(float?)] = true,
[typeof(decimal)] = true,
[typeof(decimal?)] = true
});
public static bool IsNumberType(this Type that) => that == null ? false : dicIsNumberType.Value.ContainsKey(that);
public static bool IsNullableType(this Type that) => that?.FullName.StartsWith("System.Nullable`1[") == true;
public static bool IsAnonymousType(this Type that) => that?.FullName.StartsWith("<>f__AnonymousType") == true;
public static Type NullableTypeOrThis(this Type that) => that?.IsNullableType() == true ? that.GenericTypeArguments.First() : that;
/// <summary>
/// 测量两个经纬度的距离，返回单位：米
/// </summary>
/// <param name="that">经纬坐标1</param>
/// <param name="point">经纬坐标2</param>
/// <returns>返回距离（单位：米）</returns>
public static double Distance(this Point that, Point point) {
double radLat1 = (double)(that.Y) * Math.PI / 180d;
double radLng1 = (double)(that.X) * Math.PI / 180d;
double radLat2 = (double)(point.Y) * Math.PI / 180d;
double radLng2 = (double)(point.X) * Math.PI / 180d;
return 2 * Math.Asin(Math.Sqrt(Math.Pow(Math.Sin((radLat1 - radLat2) / 2), 2) + Math.Cos(radLat1) * Math.Cos(radLat2) * Math.Pow(Math.Sin((radLng1 - radLng2) / 2), 2))) * 6378137;
}
/// <summary>
/// 测量两个经纬度的距离，返回单位：米
/// </summary>
/// <param name="that">经纬坐标1</param>
/// <param name="point">经纬坐标2</param>
/// <returns>返回距离（单位：米）</returns>
public static double Distance(this Point that, Point point)
{
double radLat1 = (double)(that.Y) * Math.PI / 180d;
double radLng1 = (double)(that.X) * Math.PI / 180d;
double radLat2 = (double)(point.Y) * Math.PI / 180d;
double radLng2 = (double)(point.X) * Math.PI / 180d;
return 2 * Math.Asin(Math.Sqrt(Math.Pow(Math.Sin((radLat1 - radLat2) / 2), 2) + Math.Cos(radLat1) * Math.Cos(radLat2) * Math.Pow(Math.Sin((radLng1 - radLng2) / 2), 2))) * 6378137;
}
static ConcurrentDictionary<Type, FieldInfo[]> _dicGetFields = new ConcurrentDictionary<Type, FieldInfo[]>();
public static object GetEnum<T>(this IDataReader dr, int index) {
var value = dr.GetString(index);
var t = typeof(T);
var fs = _dicGetFields.GetOrAdd(t, t2 => t2.GetFields());
foreach (var f in fs)
if (f.GetCustomAttribute<DescriptionAttribute>()?.Description == value || f.Name == value) return Enum.Parse(t, f.Name, true);
return null;
}
static ConcurrentDictionary<Type, FieldInfo[]> _dicGetFields = new ConcurrentDictionary<Type, FieldInfo[]>();
public static object GetEnum<T>(this IDataReader dr, int index)
{
var value = dr.GetString(index);
var t = typeof(T);
var fs = _dicGetFields.GetOrAdd(t, t2 => t2.GetFields());
foreach (var f in fs)
if (f.GetCustomAttribute<DescriptionAttribute>()?.Description == value || f.Name == value) return Enum.Parse(t, f.Name, true);
return null;
}
public static string ToDescriptionOrString(this Enum item) {
string name = item.ToString();
var desc = item.GetType().GetField(name)?.GetCustomAttribute<DescriptionAttribute>();
return desc?.Description ?? name;
}
public static long ToInt64(this Enum item) {
return Convert.ToInt64(item);
}
public static IEnumerable<T> ToSet<T>(this long value) {
var ret = new List<T>();
if (value == 0) return ret;
var t = typeof(T);
var fs = _dicGetFields.GetOrAdd(t, t2 => t2.GetFields());
foreach (var f in fs) {
if (f.FieldType != t) continue;
object o = Enum.Parse(t, f.Name, true);
long v = (long)o;
if ((value & v) == v) ret.Add((T)o);
}
return ret;
}
public static string ToDescriptionOrString(this Enum item)
{
string name = item.ToString();
var desc = item.GetType().GetField(name)?.GetCustomAttribute<DescriptionAttribute>();
return desc?.Description ?? name;
}
public static long ToInt64(this Enum item)
{
return Convert.ToInt64(item);
}
public static IEnumerable<T> ToSet<T>(this long value)
{
var ret = new List<T>();
if (value == 0) return ret;
var t = typeof(T);
var fs = _dicGetFields.GetOrAdd(t, t2 => t2.GetFields());
foreach (var f in fs)
{
if (f.FieldType != t) continue;
object o = Enum.Parse(t, f.Name, true);
long v = (long)o;
if ((value & v) == v) ret.Add((T)o);
}
return ret;
}
/// <summary>
/// 将 IEnumable&lt;T&gt; 转成 ISelect&lt;T&gt;，以便使用 FreeSql 的查询功能。此方法用于 Lambad 表达式中，快速进行集合导航的查询。
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="that"></param>
/// <returns></returns>
public static ISelect<TEntity> AsSelect<TEntity>(this IEnumerable<TEntity> that) where TEntity : class {
throw new NotImplementedException();
}
public static ISelect<TEntity> AsSelect<TEntity>(this IEnumerable<TEntity> that, IFreeSql orm = null) where TEntity : class {
return orm?.Select<TEntity>();
}
/// <summary>
/// 将 IEnumable&lt;T&gt; 转成 ISelect&lt;T&gt;，以便使用 FreeSql 的查询功能。此方法用于 Lambad 表达式中，快速进行集合导航的查询。
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="that"></param>
/// <returns></returns>
public static ISelect<TEntity> AsSelect<TEntity>(this IEnumerable<TEntity> that) where TEntity : class
{
throw new NotImplementedException();
}
public static ISelect<TEntity> AsSelect<TEntity>(this IEnumerable<TEntity> that, IFreeSql orm = null) where TEntity : class
{
return orm?.Select<TEntity>();
}
}

163
FreeSql/Extensions/LambadaExpressionExtensions.cs
View File

@@ -9,90 +9,99 @@ using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
namespace System.Linq.Expressions {
public static partial class LambadaExpressionExtensions {
namespace System.Linq.Expressions
{
public static partial class LambadaExpressionExtensions
{
/// <summary>
/// 使用 and 拼接两个 lambda 表达式
/// </summary>
/// <returns></returns>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> exp1, Expression<Func<T, bool>> exp2) => And(exp1, true, exp2);
/// <summary>
/// 使用 and 拼接两个 lambda 表达式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp1"></param>
/// <param name="condition">true 时生效</param>
/// <param name="exp2"></param>
/// <returns></returns>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> exp1, bool condition, Expression<Func<T, bool>> exp2) {
if (condition == false) return exp1;
if (exp1 == null) return exp2;
if (exp2 == null) return exp1;
/// <summary>
/// 使用 and 拼接两个 lambda 表达式
/// </summary>
/// <returns></returns>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> exp1, Expression<Func<T, bool>> exp2) => And(exp1, true, exp2);
/// <summary>
/// 使用 and 拼接两个 lambda 表达式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp1"></param>
/// <param name="condition">true 时生效</param>
/// <param name="exp2"></param>
/// <returns></returns>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> exp1, bool condition, Expression<Func<T, bool>> exp2)
{
if (condition == false) return exp1;
if (exp1 == null) return exp2;
if (exp2 == null) return exp1;
ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
var left = visitor.Replace(exp1.Body);
var right = visitor.Replace(exp2.Body);
var body = Expression.AndAlso(left, right);
return Expression.Lambda<Func<T, bool>>(body, newParameter);
}
var left = visitor.Replace(exp1.Body);
var right = visitor.Replace(exp2.Body);
var body = Expression.AndAlso(left, right);
return Expression.Lambda<Func<T, bool>>(body, newParameter);
}
/// <summary>
/// 使用 or 拼接两个 lambda 表达式
/// </summary>
/// <returns></returns>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> exp1, Expression<Func<T, bool>> exp2) => Or(exp1, true, exp2);
/// <summary>
/// 使用 or 拼接两个 lambda 表达式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp1"></param>
/// <param name="condition">true 时生效</param>
/// <param name="exp2"></param>
/// <returns></returns>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> exp1, bool condition, Expression<Func<T, bool>> exp2) {
if (condition == false) return exp1;
if (exp1 == null) return exp2;
if (exp2 == null) return exp1;
/// <summary>
/// 使用 or 拼接两个 lambda 表达式
/// </summary>
/// <returns></returns>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> exp1, Expression<Func<T, bool>> exp2) => Or(exp1, true, exp2);
/// <summary>
/// 使用 or 拼接两个 lambda 表达式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp1"></param>
/// <param name="condition">true 时生效</param>
/// <param name="exp2"></param>
/// <returns></returns>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> exp1, bool condition, Expression<Func<T, bool>> exp2)
{
if (condition == false) return exp1;
if (exp1 == null) return exp2;
if (exp2 == null) return exp1;
ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
var left = visitor.Replace(exp1.Body);
var right = visitor.Replace(exp2.Body);
var body = Expression.OrElse(left, right);
return Expression.Lambda<Func<T, bool>>(body, newParameter);
}
var left = visitor.Replace(exp1.Body);
var right = visitor.Replace(exp2.Body);
var body = Expression.OrElse(left, right);
return Expression.Lambda<Func<T, bool>>(body, newParameter);
}
/// <summary>
/// 将 lambda 表达式取反
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp"></param>
/// <param name="condition">true 时生效</param>
/// <returns></returns>
public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> exp, bool condition = true) {
if (condition == false) return exp;
if (exp == null) return null;
/// <summary>
/// 将 lambda 表达式取反
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp"></param>
/// <param name="condition">true 时生效</param>
/// <returns></returns>
public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> exp, bool condition = true)
{
if (condition == false) return exp;
if (exp == null) return null;
var candidateExpr = exp.Parameters[0];
var body = Expression.Not(exp.Body);
return Expression.Lambda<Func<T, bool>>(body, candidateExpr);
}
}
var candidateExpr = exp.Parameters[0];
var body = Expression.Not(exp.Body);
return Expression.Lambda<Func<T, bool>>(body, candidateExpr);
}
}
internal class NewExpressionVisitor : ExpressionVisitor {
public ParameterExpression _newParameter { get; private set; }
public NewExpressionVisitor(ParameterExpression param) {
this._newParameter = param;
}
public Expression Replace(Expression exp) {
return this.Visit(exp);
}
protected override Expression VisitParameter(ParameterExpression node) {
return this._newParameter;
}
}
internal class NewExpressionVisitor : ExpressionVisitor
{
public ParameterExpression _newParameter { get; private set; }
public NewExpressionVisitor(ParameterExpression param)
{
this._newParameter = param;
}
public Expression Replace(Expression exp)
{
return this.Visit(exp);
}
protected override Expression VisitParameter(ParameterExpression node)
{
return this._newParameter;
}
}
}

363
FreeSql/FreeSqlBuilder.cs
View File

@@ -5,106 +5,117 @@ using System.Reflection;
using FreeSql.DataAnnotations;
using FreeSql.Internal;
namespace FreeSql {
public class FreeSqlBuilder {
DataType _dataType;
string _masterConnectionString;
string[] _slaveConnectionString;
bool _isAutoSyncStructure = false;
bool _isSyncStructureToLower = false;
bool _isSyncStructureToUpper = false;
bool _isConfigEntityFromDbFirst = false;
bool _isNoneCommandParameter = false;
bool _isLazyLoading = false;
namespace FreeSql
{
public class FreeSqlBuilder
{
DataType _dataType;
string _masterConnectionString;
string[] _slaveConnectionString;
bool _isAutoSyncStructure = false;
bool _isSyncStructureToLower = false;
bool _isSyncStructureToUpper = false;
bool _isConfigEntityFromDbFirst = false;
bool _isNoneCommandParameter = false;
bool _isLazyLoading = false;
StringConvertType _entityPropertyConvertType = StringConvertType.None;
Action<DbCommand> _aopCommandExecuting = null;
Action<DbCommand, string> _aopCommandExecuted = null;
Action<DbCommand> _aopCommandExecuting = null;
Action<DbCommand, string> _aopCommandExecuted = null;
/// <summary>
/// 使用连接串
/// </summary>
/// <param name="dataType">数据库类型</param>
/// <param name="connectionString">数据库连接串</param>
/// <returns></returns>
public FreeSqlBuilder UseConnectionString(DataType dataType, string connectionString) {
_dataType = dataType;
_masterConnectionString = connectionString;
return this;
}
/// <summary>
/// 使用从数据库，支持多个
/// </summary>
/// <param name="slaveConnectionString">从数据库连接串</param>
/// <returns></returns>
public FreeSqlBuilder UseSlave(params string[] slaveConnectionString) {
_slaveConnectionString = slaveConnectionString;
return this;
}
/// <summary>
/// 【开发环境必备】自动同步实体结构到数据库，程序运行中检查实体表是否存在，然后创建或修改
/// </summary>
/// <param name="value">true:运行时检查自动同步结构, false:不同步结构</param>
/// <returns></returns>
public FreeSqlBuilder UseAutoSyncStructure(bool value) {
_isAutoSyncStructure = value;
return this;
}
/// <summary>
/// 转小写同步结构
/// </summary>
/// <param name="value">true:转小写, false:不转</param>
/// <returns></returns>
public FreeSqlBuilder UseSyncStructureToLower(bool value) {
_isSyncStructureToLower = value;
return this;
}
/// <summary>
/// 转大写同步结构
/// </summary>
/// <param name="value">true:转大写, false:不转</param>
/// <returns></returns>
public FreeSqlBuilder UseSyncStructureToUpper(bool value) {
_isSyncStructureToUpper = value;
return this;
}
/// <summary>
/// 使用数据库的主键和自增，适用 DbFirst 模式，无须在实体类型上设置 [Column(IsPrimary)] 或者 ConfigEntity。此功能目前可用于 mysql/sqlserver/postgresql。
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public FreeSqlBuilder UseConfigEntityFromDbFirst(bool value) {
_isConfigEntityFromDbFirst = value;
return this;
}
/// <summary>
/// 不使用命令参数化执行，针对 Insert/Update，也可临时使用 IInsert/IUpdate.NoneParameter()
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public FreeSqlBuilder UseNoneCommandParameter(bool value) {
_isNoneCommandParameter = value;
return this;
}
/// <summary>
/// 延时加载导航属性对象，导航属性需要声明 virtual
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public FreeSqlBuilder UseLazyLoading(bool value) {
_isLazyLoading = value;
return this;
}
/// <summary>
/// 监视数据库命令对象
/// </summary>
/// <param name="executing">执行前</param>
/// <param name="executed">执行后，可监视执行性能</param>
/// <returns></returns>
public FreeSqlBuilder UseMonitorCommand(Action<DbCommand> executing, Action<DbCommand, string> executed = null) {
_aopCommandExecuting = executing;
_aopCommandExecuted = executed;
return this;
}
/// <summary>
/// 使用连接串
/// </summary>
/// <param name="dataType">数据库类型</param>
/// <param name="connectionString">数据库连接串</param>
/// <returns></returns>
public FreeSqlBuilder UseConnectionString(DataType dataType, string connectionString)
{
_dataType = dataType;
_masterConnectionString = connectionString;
return this;
}
/// <summary>
/// 使用从数据库，支持多个
/// </summary>
/// <param name="slaveConnectionString">从数据库连接串</param>
/// <returns></returns>
public FreeSqlBuilder UseSlave(params string[] slaveConnectionString)
{
_slaveConnectionString = slaveConnectionString;
return this;
}
/// <summary>
/// 【开发环境必备】自动同步实体结构到数据库，程序运行中检查实体表是否存在，然后创建或修改
/// </summary>
/// <param name="value">true:运行时检查自动同步结构, false:不同步结构</param>
/// <returns></returns>
public FreeSqlBuilder UseAutoSyncStructure(bool value)
{
_isAutoSyncStructure = value;
return this;
}
/// <summary>
/// 转小写同步结构
/// </summary>
/// <param name="value">true:转小写, false:不转</param>
/// <returns></returns>
public FreeSqlBuilder UseSyncStructureToLower(bool value)
{
_isSyncStructureToLower = value;
return this;
}
/// <summary>
/// 转大写同步结构
/// </summary>
/// <param name="value">true:转大写, false:不转</param>
/// <returns></returns>
public FreeSqlBuilder UseSyncStructureToUpper(bool value)
{
_isSyncStructureToUpper = value;
return this;
}
/// <summary>
/// 使用数据库的主键和自增，适用 DbFirst 模式，无须在实体类型上设置 [Column(IsPrimary)] 或者 ConfigEntity。此功能目前可用于 mysql/sqlserver/postgresql。
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public FreeSqlBuilder UseConfigEntityFromDbFirst(bool value)
{
_isConfigEntityFromDbFirst = value;
return this;
}
/// <summary>
/// 不使用命令参数化执行，针对 Insert/Update，也可临时使用 IInsert/IUpdate.NoneParameter()
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public FreeSqlBuilder UseNoneCommandParameter(bool value)
{
_isNoneCommandParameter = value;
return this;
}
/// <summary>
/// 延时加载导航属性对象，导航属性需要声明 virtual
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public FreeSqlBuilder UseLazyLoading(bool value)
{
_isLazyLoading = value;
return this;
}
/// <summary>
/// 监视数据库命令对象
/// </summary>
/// <param name="executing">执行前</param>
/// <param name="executed">执行后，可监视执行性能</param>
/// <returns></returns>
public FreeSqlBuilder UseMonitorCommand(Action<DbCommand> executing, Action<DbCommand, string> executed = null)
{
_aopCommandExecuting = executing;
_aopCommandExecuted = executed;
return this;
}
/// <summary>
/// 自动转换实体属性名称 Entity Property -> Db Filed
@@ -120,78 +131,92 @@ namespace FreeSql {
}
public IFreeSql Build() => Build<IFreeSql>();
public IFreeSql<TMark> Build<TMark>() {
if (string.IsNullOrEmpty(_masterConnectionString)) throw new Exception("参数 masterConnectionString 不可为空，请检查 UseConnectionString");
IFreeSql<TMark> ret = null;
Type type = null;
switch(_dataType) {
case DataType.MySql:
type = Type.GetType("FreeSql.MySql.MySqlProvider`1,FreeSql.Provider.MySql")?.MakeGenericType(typeof(TMark));
if (type == null) type = Type.GetType("FreeSql.MySql.MySqlProvider`1,FreeSql.Provider.MySqlConnector")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.MySql.dll，可前往 nuget 下载");
break;
case DataType.SqlServer: type = Type.GetType("FreeSql.SqlServer.SqlServerProvider`1,FreeSql.Provider.SqlServer")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.SqlServer.dll，可前往 nuget 下载");
break;
case DataType.PostgreSQL: type = Type.GetType("FreeSql.PostgreSQL.PostgreSQLProvider`1,FreeSql.Provider.PostgreSQL")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.PostgreSQL.dll，可前往 nuget 下载");
break;
case DataType.Oracle: type = Type.GetType("FreeSql.Oracle.OracleProvider`1,FreeSql.Provider.Oracle")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.Oracle.dll，可前往 nuget 下载");
break;
case DataType.Sqlite: type = Type.GetType("FreeSql.Sqlite.SqliteProvider`1,FreeSql.Provider.Sqlite")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.Sqlite.dll，可前往 nuget 下载");
break;
default: throw new Exception("未指定 UseConnectionString");
}
ret = Activator.CreateInstance(type, new object[] { _masterConnectionString, _slaveConnectionString }) as IFreeSql<TMark>;
if (ret != null) {
ret.CodeFirst.IsAutoSyncStructure = _isAutoSyncStructure;
public IFreeSql<TMark> Build<TMark>()
{
if (string.IsNullOrEmpty(_masterConnectionString)) throw new Exception("参数 masterConnectionString 不可为空，请检查 UseConnectionString");
IFreeSql<TMark> ret = null;
Type type = null;
switch (_dataType)
{
case DataType.MySql:
type = Type.GetType("FreeSql.MySql.MySqlProvider`1,FreeSql.Provider.MySql")?.MakeGenericType(typeof(TMark));
if (type == null) type = Type.GetType("FreeSql.MySql.MySqlProvider`1,FreeSql.Provider.MySqlConnector")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.MySql.dll，可前往 nuget 下载");
break;
case DataType.SqlServer:
type = Type.GetType("FreeSql.SqlServer.SqlServerProvider`1,FreeSql.Provider.SqlServer")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.SqlServer.dll，可前往 nuget 下载");
break;
case DataType.PostgreSQL:
type = Type.GetType("FreeSql.PostgreSQL.PostgreSQLProvider`1,FreeSql.Provider.PostgreSQL")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.PostgreSQL.dll，可前往 nuget 下载");
break;
case DataType.Oracle:
type = Type.GetType("FreeSql.Oracle.OracleProvider`1,FreeSql.Provider.Oracle")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.Oracle.dll，可前往 nuget 下载");
break;
case DataType.Sqlite:
type = Type.GetType("FreeSql.Sqlite.SqliteProvider`1,FreeSql.Provider.Sqlite")?.MakeGenericType(typeof(TMark));
if (type == null) throw new Exception("缺少 FreeSql 数据库实现包：FreeSql.Provider.Sqlite.dll，可前往 nuget 下载");
break;
default: throw new Exception("未指定 UseConnectionString");
}
ret = Activator.CreateInstance(type, new object[] { _masterConnectionString, _slaveConnectionString }) as IFreeSql<TMark>;
if (ret != null)
{
ret.CodeFirst.IsAutoSyncStructure = _isAutoSyncStructure;
ret.CodeFirst.IsSyncStructureToLower = _isSyncStructureToLower;
ret.CodeFirst.IsSyncStructureToUpper = _isSyncStructureToUpper;
ret.CodeFirst.IsConfigEntityFromDbFirst = _isConfigEntityFromDbFirst;
ret.CodeFirst.IsNoneCommandParameter = _isNoneCommandParameter;
ret.CodeFirst.IsLazyLoading = _isLazyLoading;
var ado = ret.Ado as Internal.CommonProvider.AdoProvider;
ado.AopCommandExecuting += _aopCommandExecuting;
ado.AopCommandExecuted += _aopCommandExecuted;
ret.CodeFirst.IsSyncStructureToLower = _isSyncStructureToLower;
ret.CodeFirst.IsSyncStructureToUpper = _isSyncStructureToUpper;
ret.CodeFirst.IsConfigEntityFromDbFirst = _isConfigEntityFromDbFirst;
ret.CodeFirst.IsNoneCommandParameter = _isNoneCommandParameter;
ret.CodeFirst.IsLazyLoading = _isLazyLoading;
var ado = ret.Ado as Internal.CommonProvider.AdoProvider;
ado.AopCommandExecuting += _aopCommandExecuting;
ado.AopCommandExecuted += _aopCommandExecuted;
//添加实体属性名全局AOP转换处理
if (_entityPropertyConvertType != StringConvertType.None) {
switch (_entityPropertyConvertType) {
case StringConvertType.Lower:
ret.Aop.ConfigEntityProperty = (s, e) => {
e.ModifyResult.Name = e.Property.Name.ToLower();
};
break;
case StringConvertType.Upper:
ret.Aop.ConfigEntityProperty = (s, e) => {
e.ModifyResult.Name = e.Property.Name.ToUpper();
};
break;
case StringConvertType.PascalCaseToUnderscore:
ret.Aop.ConfigEntityProperty = (s, e) => {
e.ModifyResult.Name = StringUtils.PascalCaseToUnderScore(e.Property.Name);
};
break;
case StringConvertType.PascalCaseToUnderscoreWithLower:
ret.Aop.ConfigEntityProperty = (s, e) => {
e.ModifyResult.Name = StringUtils.PascalCaseToUnderScore(e.Property.Name).ToLower();
};
break;
case StringConvertType.PascalCaseToUnderscoreWithUpper:
ret.Aop.ConfigEntityProperty = (s, e) => {
e.ModifyResult.Name = StringUtils.PascalCaseToUnderScore(e.Property.Name).ToUpper();
};
break;
default:
break;
}
}
}
//添加实体属性名全局AOP转换处理
if (_entityPropertyConvertType != StringConvertType.None)
{
switch (_entityPropertyConvertType)
{
case StringConvertType.Lower:
ret.Aop.ConfigEntityProperty = (s, e) =>
{
e.ModifyResult.Name = e.Property.Name.ToLower();
};
break;
case StringConvertType.Upper:
ret.Aop.ConfigEntityProperty = (s, e) =>
{
e.ModifyResult.Name = e.Property.Name.ToUpper();
};
break;
case StringConvertType.PascalCaseToUnderscore:
ret.Aop.ConfigEntityProperty = (s, e) =>
{
e.ModifyResult.Name = StringUtils.PascalCaseToUnderScore(e.Property.Name);
};
break;
case StringConvertType.PascalCaseToUnderscoreWithLower:
ret.Aop.ConfigEntityProperty = (s, e) =>
{
e.ModifyResult.Name = StringUtils.PascalCaseToUnderScore(e.Property.Name).ToLower();
};
break;
case StringConvertType.PascalCaseToUnderscoreWithUpper:
ret.Aop.ConfigEntityProperty = (s, e) =>
{
e.ModifyResult.Name = StringUtils.PascalCaseToUnderScore(e.Property.Name).ToUpper();
};
break;
default:
break;
}
}
}
return ret;
}
}
return ret;
}
}
}

42
FreeSql/FreeUtil.cs
View File

@@ -6,29 +6,31 @@ using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
public static class FreeUtil {
public static class FreeUtil
{
private static DateTime dt1970 = new DateTime(1970, 1, 1);
private static ThreadLocal<Random> rnd = new ThreadLocal<Random>(() => new Random());
private static readonly int __staticMachine = ((0x00ffffff & Environment.MachineName.GetHashCode()) +
private static DateTime dt1970 = new DateTime(1970, 1, 1);
private static ThreadLocal<Random> rnd = new ThreadLocal<Random>(() => new Random());
private static readonly int __staticMachine = ((0x00ffffff & Environment.MachineName.GetHashCode()) +
#if NETSTANDARD1_5 || NETSTANDARD1_6
1
#else
AppDomain.CurrentDomain.Id
AppDomain.CurrentDomain.Id
#endif
) & 0x00ffffff;
private static readonly int __staticPid = Process.GetCurrentProcess().Id;
private static int __staticIncrement = rnd.Value.Next();
/// <summary>
/// 生成类似Mongodb的ObjectId有序、不重复Guid
/// </summary>
/// <returns></returns>
public static Guid NewMongodbId() {
var now = DateTime.Now;
var uninxtime = (int)now.Subtract(dt1970).TotalSeconds;
int increment = Interlocked.Increment(ref __staticIncrement) & 0x00ffffff;
var rand = rnd.Value.Next(0, int.MaxValue);
var guid = $"{uninxtime.ToString("x8").PadLeft(8, '0')}{__staticMachine.ToString("x8").PadLeft(8, '0').Substring(2, 6)}{__staticPid.ToString("x8").PadLeft(8, '0').Substring(6, 2)}{increment.ToString("x8").PadLeft(8, '0')}{rand.ToString("x8").PadLeft(8, '0')}";
return Guid.Parse(guid);
}
) & 0x00ffffff;
private static readonly int __staticPid = Process.GetCurrentProcess().Id;
private static int __staticIncrement = rnd.Value.Next();
/// <summary>
/// 生成类似Mongodb的ObjectId有序、不重复Guid
/// </summary>
/// <returns></returns>
public static Guid NewMongodbId()
{
var now = DateTime.Now;
var uninxtime = (int)now.Subtract(dt1970).TotalSeconds;
int increment = Interlocked.Increment(ref __staticIncrement) & 0x00ffffff;
var rand = rnd.Value.Next(0, int.MaxValue);
var guid = $"{uninxtime.ToString("x8").PadLeft(8, '0')}{__staticMachine.ToString("x8").PadLeft(8, '0').Substring(2, 6)}{__staticPid.ToString("x8").PadLeft(8, '0').Substring(6, 2)}{increment.ToString("x8").PadLeft(8, '0')}{rand.ToString("x8").PadLeft(8, '0')}";
return Guid.Parse(guid);
}
}

168
FreeSql/Interface/Curd/IDelete.cs
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();
}
}

172
FreeSql/Interface/Curd/IInsert.cs
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();
}
}

48
FreeSql/Interface/Curd/ISelect/ILinqToSql.cs
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;
}
}

472
FreeSql/Interface/Curd/ISelect/ISelect0.cs
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();
}
}

616
FreeSql/Interface/Curd/ISelect/ISelect1.cs
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;
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect10.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect2.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect3.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect4.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect5.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect6.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect7.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect8.cs
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);
}
}

56
FreeSql/Interface/Curd/ISelect/ISelect9.cs
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);
}
}

66
FreeSql/Interface/Curd/ISelect/ISelectFrom.cs
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);
}
}

236
FreeSql/Interface/Curd/ISelect/ISelectGrouping.cs
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; }
}
}

298
FreeSql/Interface/Curd/IUpdate.cs
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();
}
}

746
FreeSql/Interface/IAdo.cs
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
}
}

455
FreeSql/Interface/IAop.cs
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;
}
}

168
FreeSql/Interface/ICodeFirst.cs
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);
}
}

189
FreeSql/Interface/IFreeSql.cs
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; }
}

138
FreeSql/Interface/iDbFirst.cs
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);
}
}

2027
FreeSql/Internal/CommonExpression.cs
View File

File diff suppressed because it is too large Load Diff

1407
FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs
View File

File diff suppressed because it is too large Load Diff

1295
FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs
View File

File diff suppressed because it is too large Load Diff

248
FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderTransaction.cs
View File

@@ -6,126 +6,158 @@ using System.Diagnostics;
using System.Linq;
using System.Threading;
namespace FreeSql.Internal.CommonProvider {
partial class AdoProvider {
namespace FreeSql.Internal.CommonProvider
{
partial class AdoProvider
{
class Transaction2 {
internal Object<DbConnection> Conn;
internal DbTransaction Transaction;
internal DateTime RunTime;
internal TimeSpan Timeout;
class Transaction2
{
internal Object<DbConnection> Conn;
internal DbTransaction Transaction;
internal DateTime RunTime;
internal TimeSpan Timeout;
public Transaction2(Object<DbConnection> conn, DbTransaction tran, TimeSpan timeout) {
Conn = conn;
Transaction = tran;
RunTime = DateTime.Now;
Timeout = timeout;
}
}
public Transaction2(Object<DbConnection> conn, DbTransaction tran, TimeSpan timeout)
{
Conn = conn;
Transaction = tran;
RunTime = DateTime.Now;
Timeout = timeout;
}
}
private Dictionary<int, Transaction2> _trans = new Dictionary<int, Transaction2>();
private object _trans_lock = new object();
private Dictionary<int, Transaction2> _trans = new Dictionary<int, Transaction2>();
private object _trans_lock = new object();
public DbTransaction TransactionCurrentThread => _trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var conn) && conn.Transaction?.Connection != null ? conn.Transaction : null;
public DbTransaction TransactionCurrentThread => _trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var conn) && conn.Transaction?.Connection != null ? conn.Transaction : null;
public void BeginTransaction(TimeSpan timeout) {
if (TransactionCurrentThread != null) return;
public void BeginTransaction(TimeSpan timeout)
{
if (TransactionCurrentThread != null) return;
int tid = Thread.CurrentThread.ManagedThreadId;
Transaction2 tran = null;
Object<DbConnection> conn = null;
int tid = Thread.CurrentThread.ManagedThreadId;
Transaction2 tran = null;
Object<DbConnection> conn = null;
try {
conn = MasterPool.Get();
tran = new Transaction2(conn, conn.Value.BeginTransaction(), timeout);
} catch(Exception ex) {
Trace.WriteLine($"数据库出错（开启事务）{ex.Message} \r\n{ex.StackTrace}");
MasterPool.Return(conn);
throw ex;
}
if (_trans.ContainsKey(tid)) CommitTransaction();
try
{
conn = MasterPool.Get();
tran = new Transaction2(conn, conn.Value.BeginTransaction(), timeout);
}
catch (Exception ex)
{
Trace.WriteLine($"数据库出错（开启事务）{ex.Message} \r\n{ex.StackTrace}");
MasterPool.Return(conn);
throw ex;
}
if (_trans.ContainsKey(tid)) CommitTransaction();
lock (_trans_lock)
_trans.Add(tid, tran);
}
lock (_trans_lock)
_trans.Add(tid, tran);
}
private void AutoCommitTransaction() {
if (_trans.Count > 0) {
Transaction2[] trans = null;
lock (_trans_lock)
trans = _trans.Values.Where(st2 => DateTime.Now.Subtract(st2.RunTime) > st2.Timeout).ToArray();
foreach (Transaction2 tran in trans) CommitTransaction(true, tran);
}
}
private void CommitTransaction(bool isCommit, Transaction2 tran) {
if (tran == null || tran.Transaction == null || tran.Transaction.Connection == null) return;
private void AutoCommitTransaction()
{
if (_trans.Count > 0)
{
Transaction2[] trans = null;
lock (_trans_lock)
trans = _trans.Values.Where(st2 => DateTime.Now.Subtract(st2.RunTime) > st2.Timeout).ToArray();
foreach (Transaction2 tran in trans) CommitTransaction(true, tran);
}
}
private void CommitTransaction(bool isCommit, Transaction2 tran)
{
if (tran == null || tran.Transaction == null || tran.Transaction.Connection == null) return;
if (_trans.ContainsKey(tran.Conn.LastGetThreadId))
lock (_trans_lock)
if (_trans.ContainsKey(tran.Conn.LastGetThreadId))
_trans.Remove(tran.Conn.LastGetThreadId);
if (_trans.ContainsKey(tran.Conn.LastGetThreadId))
lock (_trans_lock)
if (_trans.ContainsKey(tran.Conn.LastGetThreadId))
_trans.Remove(tran.Conn.LastGetThreadId);
Exception ex = null;
var f001 = isCommit ? "提交" : "回滚";
try {
Trace.WriteLine($"线程{tran.Conn.LastGetThreadId}事务{f001}");
if (isCommit) tran.Transaction.Commit();
else tran.Transaction.Rollback();
} catch (Exception ex2) {
ex = ex2;
Trace.WriteLine($"数据库出错（{f001}事务）：{ex.Message} {ex.StackTrace}");
} finally {
ReturnConnection(MasterPool, tran.Conn, ex); //MasterPool.Return(tran.Conn, ex);
}
}
private void CommitTransaction(bool isCommit) {
if (_trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var tran)) CommitTransaction(isCommit, tran);
}
public void CommitTransaction() => CommitTransaction(true);
public void RollbackTransaction() => CommitTransaction(false);
Exception ex = null;
var f001 = isCommit ? "提交" : "回滚";
try
{
Trace.WriteLine($"线程{tran.Conn.LastGetThreadId}事务{f001}");
if (isCommit) tran.Transaction.Commit();
else tran.Transaction.Rollback();
}
catch (Exception ex2)
{
ex = ex2;
Trace.WriteLine($"数据库出错（{f001}事务）：{ex.Message} {ex.StackTrace}");
}
finally
{
ReturnConnection(MasterPool, tran.Conn, ex); //MasterPool.Return(tran.Conn, ex);
}
}
private void CommitTransaction(bool isCommit)
{
if (_trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var tran)) CommitTransaction(isCommit, tran);
}
public void CommitTransaction() => CommitTransaction(true);
public void RollbackTransaction() => CommitTransaction(false);
public void Transaction(Action handler) {
Transaction(handler, TimeSpan.FromSeconds(60));
}
public void Transaction(Action handler, TimeSpan timeout) {
try {
BeginTransaction(timeout);
handler();
CommitTransaction();
} catch (Exception ex) {
RollbackTransaction();
throw ex;
}
}
public void Transaction(Action handler)
{
Transaction(handler, TimeSpan.FromSeconds(60));
}
public void Transaction(Action handler, TimeSpan timeout)
{
try
{
BeginTransaction(timeout);
handler();
CommitTransaction();
}
catch (Exception ex)
{
RollbackTransaction();
throw ex;
}
}
~AdoProvider() {
this.Dispose();
}
bool _isdisposed = false;
public void Dispose() {
if (_isdisposed) return;
try {
Transaction2[] trans = null;
lock (_trans_lock)
trans = _trans.Values.ToArray();
foreach (Transaction2 tran in trans) CommitTransaction(false, tran);
} catch { }
~AdoProvider()
{
this.Dispose();
}
bool _isdisposed = false;
public void Dispose()
{
if (_isdisposed) return;
try
{
Transaction2[] trans = null;
lock (_trans_lock)
trans = _trans.Values.ToArray();
foreach (Transaction2 tran in trans) CommitTransaction(false, tran);
}
catch { }
ObjectPool<DbConnection>[] pools = null;
for (var a = 0; a < 10; a++) {
try {
pools = SlavePools.ToArray();
SlavePools.Clear();
break;
} catch {
}
}
if (pools != null) {
foreach (var pool in pools) {
try { pool.Dispose(); } catch { }
}
}
try { MasterPool.Dispose(); } catch { }
}
}
ObjectPool<DbConnection>[] pools = null;
for (var a = 0; a < 10; a++)
{
try
{
pools = SlavePools.ToArray();
SlavePools.Clear();
break;
}
catch
{
}
}
if (pools != null)
{
foreach (var pool in pools)
{
try { pool.Dispose(); } catch { }
}
}
try { MasterPool.Dispose(); } catch { }
}
}
}

38
FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderUtils.cs
View File

@@ -2,21 +2,25 @@
using System.Collections.Concurrent;
using System.Text.RegularExpressions;
namespace FreeSql.Internal.CommonProvider {
partial class AdoProvider {
public abstract object AddslashesProcessParam(object param, Type mapType);
public string Addslashes(string filter, params object[] parms) {
if (filter == null || parms == null) return string.Empty;
if (parms.Length == 0) return filter;
var nparms = new object[parms.Length];
for (int a = 0; a < parms.Length; a++) {
if (parms[a] == null)
filter = _dicAddslashesReplaceIsNull.GetOrAdd(a, b => new Regex(@"\s*(=|IN)\s*\{" + b + @"\}", RegexOptions.IgnoreCase | RegexOptions.Compiled))
.Replace(filter, $" IS {{{a}}}");
nparms[a] = AddslashesProcessParam(parms[a], null);
}
try { string ret = string.Format(filter, nparms); return ret; } catch { return filter; }
}
static ConcurrentDictionary<int, Regex> _dicAddslashesReplaceIsNull = new ConcurrentDictionary<int, Regex>();
}
namespace FreeSql.Internal.CommonProvider
{
partial class AdoProvider
{
public abstract object AddslashesProcessParam(object param, Type mapType);
public string Addslashes(string filter, params object[] parms)
{
if (filter == null || parms == null) return string.Empty;
if (parms.Length == 0) return filter;
var nparms = new object[parms.Length];
for (int a = 0; a < parms.Length; a++)
{
if (parms[a] == null)
filter = _dicAddslashesReplaceIsNull.GetOrAdd(a, b => new Regex(@"\s*(=|IN)\s*\{" + b + @"\}", RegexOptions.IgnoreCase | RegexOptions.Compiled))
.Replace(filter, $" IS {{{a}}}");
nparms[a] = AddslashesProcessParam(parms[a], null);
}
try { string ret = string.Format(filter, nparms); return ret; } catch { return filter; }
}
static ConcurrentDictionary<int, Regex> _dicAddslashesReplaceIsNull = new ConcurrentDictionary<int, Regex>();
}
}

26
FreeSql/Internal/CommonProvider/AopProvider.cs
View File

@@ -4,16 +4,18 @@ using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
namespace FreeSql.Internal.CommonProvider {
public class AopProvider : IAop {
public EventHandler<Aop.ToListEventArgs> ToList { get; set; }
public EventHandler<Aop.WhereEventArgs> Where { get; set; }
public EventHandler<Aop.ParseExpressionEventArgs> ParseExpression { get; set; }
public EventHandler<Aop.ConfigEntityEventArgs> ConfigEntity { get; set; }
public EventHandler<Aop.ConfigEntityPropertyEventArgs> ConfigEntityProperty { get; set; }
public EventHandler<Aop.CurdBeforeEventArgs> CurdBefore { get; set; }
public EventHandler<Aop.CurdAfterEventArgs> CurdAfter { get; set; }
public EventHandler<Aop.SyncStructureBeforeEventArgs> SyncStructureBefore { get; set; }
public EventHandler<Aop.SyncStructureAfterEventArgs> SyncStructureAfter { get; set; }
}
namespace FreeSql.Internal.CommonProvider
{
public class AopProvider : IAop
{
public EventHandler<Aop.ToListEventArgs> ToList { get; set; }
public EventHandler<Aop.WhereEventArgs> Where { get; set; }
public EventHandler<Aop.ParseExpressionEventArgs> ParseExpression { get; set; }
public EventHandler<Aop.ConfigEntityEventArgs> ConfigEntity { get; set; }
public EventHandler<Aop.ConfigEntityPropertyEventArgs> ConfigEntityProperty { get; set; }
public EventHandler<Aop.CurdBeforeEventArgs> CurdBefore { get; set; }
public EventHandler<Aop.CurdAfterEventArgs> CurdAfter { get; set; }
public EventHandler<Aop.SyncStructureBeforeEventArgs> SyncStructureBefore { get; set; }
public EventHandler<Aop.SyncStructureAfterEventArgs> SyncStructureAfter { get; set; }
}
}

119
FreeSql/Internal/CommonProvider/CodeFirstProvider.cs
View File

@@ -11,65 +11,76 @@ using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract partial class CodeFirstProvider : ICodeFirst {
public abstract partial class CodeFirstProvider : ICodeFirst
{
protected IFreeSql _orm;
protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression;
public CodeFirstProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
_orm = orm;
_commonUtils = commonUtils;
_commonExpression = commonExpression;
}
protected IFreeSql _orm;
protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression;
public CodeFirstProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression)
{
_orm = orm;
_commonUtils = commonUtils;
_commonExpression = commonExpression;
}
public bool IsAutoSyncStructure { get; set; } = false;
public bool IsSyncStructureToLower { get; set; } = false;
public bool IsSyncStructureToUpper { get; set; } = false;
public bool IsConfigEntityFromDbFirst { get; set; } = false;
public bool IsNoneCommandParameter { get; set; } = false;
public bool IsLazyLoading { get; set; } = false;
public bool IsAutoSyncStructure { get; set; } = false;
public bool IsSyncStructureToLower { get; set; } = false;
public bool IsSyncStructureToUpper { get; set; } = false;
public bool IsConfigEntityFromDbFirst { get; set; } = false;
public bool IsNoneCommandParameter { get; set; } = false;
public bool IsLazyLoading { get; set; } = false;
public abstract (int type, string dbtype, string dbtypeFull, bool? isnullable, object defaultValue)? GetDbInfo(Type type);
public abstract (int type, string dbtype, string dbtypeFull, bool? isnullable, object defaultValue)? GetDbInfo(Type type);
public ICodeFirst ConfigEntity<T>(Action<TableFluent<T>> entity) => _commonUtils.ConfigEntity(entity);
public ICodeFirst ConfigEntity(Type type, Action<TableFluent> entity) => _commonUtils.ConfigEntity(type, entity);
public TableAttribute GetConfigEntity(Type type) => _commonUtils.GetConfigEntity(type);
public TableInfo GetTableByEntity(Type type) => _commonUtils.GetTableByEntity(type);
public ICodeFirst ConfigEntity<T>(Action<TableFluent<T>> entity) => _commonUtils.ConfigEntity(entity);
public ICodeFirst ConfigEntity(Type type, Action<TableFluent> entity) => _commonUtils.ConfigEntity(type, entity);
public TableAttribute GetConfigEntity(Type type) => _commonUtils.GetConfigEntity(type);
public TableInfo GetTableByEntity(Type type) => _commonUtils.GetTableByEntity(type);
public string GetComparisonDDLStatements<TEntity>() => this.GetComparisonDDLStatements(typeof(TEntity));
public abstract string GetComparisonDDLStatements(params Type[] entityTypes);
public string GetComparisonDDLStatements<TEntity>() => this.GetComparisonDDLStatements(typeof(TEntity));
public abstract string GetComparisonDDLStatements(params Type[] entityTypes);
static object syncStructureLock = new object();
internal ConcurrentDictionary<string, bool> dicSyced = new ConcurrentDictionary<string, bool>();
public bool SyncStructure<TEntity>() => this.SyncStructure(typeof(TEntity));
public bool SyncStructure(params Type[] entityTypes) {
if (entityTypes == null) return false;
var syncTypes = entityTypes.Where(a => dicSyced.ContainsKey(a.FullName) == false && GetTableByEntity(a)?.DisableSyncStructure == false).ToArray();
if (syncTypes.Any() == false) return false;
var before = new Aop.SyncStructureBeforeEventArgs(entityTypes);
_orm.Aop.SyncStructureBefore?.Invoke(this, before);
Exception exception = null;
string ddl = null;
try {
lock (syncStructureLock) {
ddl = this.GetComparisonDDLStatements(syncTypes);
if (string.IsNullOrEmpty(ddl)) {
foreach (var syncType in syncTypes) dicSyced.TryAdd(syncType.FullName, true);
return true;
}
var affrows = _orm.Ado.ExecuteNonQuery(CommandType.Text, ddl);
foreach (var syncType in syncTypes) dicSyced.TryAdd(syncType.FullName, true);
return affrows > 0;
}
} catch (Exception ex) {
exception = ex;
throw ex;
} finally {
var after = new Aop.SyncStructureAfterEventArgs(before, ddl, exception);
_orm.Aop.SyncStructureAfter?.Invoke(this, after);
}
}
}
static object syncStructureLock = new object();
internal ConcurrentDictionary<string, bool> dicSyced = new ConcurrentDictionary<string, bool>();
public bool SyncStructure<TEntity>() => this.SyncStructure(typeof(TEntity));
public bool SyncStructure(params Type[] entityTypes)
{
if (entityTypes == null) return false;
var syncTypes = entityTypes.Where(a => dicSyced.ContainsKey(a.FullName) == false && GetTableByEntity(a)?.DisableSyncStructure == false).ToArray();
if (syncTypes.Any() == false) return false;
var before = new Aop.SyncStructureBeforeEventArgs(entityTypes);
_orm.Aop.SyncStructureBefore?.Invoke(this, before);
Exception exception = null;
string ddl = null;
try
{
lock (syncStructureLock)
{
ddl = this.GetComparisonDDLStatements(syncTypes);
if (string.IsNullOrEmpty(ddl))
{
foreach (var syncType in syncTypes) dicSyced.TryAdd(syncType.FullName, true);
return true;
}
var affrows = _orm.Ado.ExecuteNonQuery(CommandType.Text, ddl);
foreach (var syncType in syncTypes) dicSyced.TryAdd(syncType.FullName, true);
return affrows > 0;
}
}
catch (Exception ex)
{
exception = ex;
throw ex;
}
finally
{
var after = new Aop.SyncStructureAfterEventArgs(before, ddl, exception);
_orm.Aop.SyncStructureAfter?.Invoke(this, after);
}
}
}
}

233
FreeSql/Internal/CommonProvider/DeleteProvider.cs
View File

@@ -7,119 +7,140 @@ using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract partial class DeleteProvider<T1> : IDelete<T1> where T1 : class {
protected IFreeSql _orm;
protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression;
protected TableInfo _table;
protected Func<string, string> _tableRule;
protected StringBuilder _where = new StringBuilder();
protected int _whereTimes = 0;
protected List<DbParameter> _params = new List<DbParameter>();
protected DbTransaction _transaction;
protected DbConnection _connection;
public abstract partial class DeleteProvider<T1> : IDelete<T1> where T1 : class
{
protected IFreeSql _orm;
protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression;
protected TableInfo _table;
protected Func<string, string> _tableRule;
protected StringBuilder _where = new StringBuilder();
protected int _whereTimes = 0;
protected List<DbParameter> _params = new List<DbParameter>();
protected DbTransaction _transaction;
protected DbConnection _connection;
public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
_orm = orm;
_commonUtils = commonUtils;
_commonExpression = commonExpression;
_table = _commonUtils.GetTableByEntity(typeof(T1));
this.Where(_commonUtils.WhereObject(_table, "", dywhere));
if (_orm.CodeFirst.IsAutoSyncStructure && typeof(T1) != typeof(object)) _orm.CodeFirst.SyncStructure<T1>();
}
public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere)
{
_orm = orm;
_commonUtils = commonUtils;
_commonExpression = commonExpression;
_table = _commonUtils.GetTableByEntity(typeof(T1));
this.Where(_commonUtils.WhereObject(_table, "", dywhere));
if (_orm.CodeFirst.IsAutoSyncStructure && typeof(T1) != typeof(object)) _orm.CodeFirst.SyncStructure<T1>();
}
protected void ClearData() {
_where.Clear();
_whereTimes = 0;
_params.Clear();
}
protected void ClearData()
{
_where.Clear();
_whereTimes = 0;
_params.Clear();
}
public IDelete<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
_connection = _transaction?.Connection;
return this;
}
public IDelete<T1> WithConnection(DbConnection connection) {
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this;
}
public IDelete<T1> WithTransaction(DbTransaction transaction)
{
_transaction = transaction;
_connection = _transaction?.Connection;
return this;
}
public IDelete<T1> WithConnection(DbConnection connection)
{
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this;
}
public int ExecuteAffrows() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var dbParms = _params.ToArray();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Delete, sql, dbParms);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try {
affrows = _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, dbParms);
} catch (Exception ex) {
exception = ex;
throw ex;
} finally {
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
async public Task<int> ExecuteAffrowsAsync() {
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var dbParms = _params.ToArray();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Delete, sql, dbParms);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try {
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, dbParms);
} catch (Exception ex) {
exception = ex;
throw ex;
} finally {
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
public abstract List<T1> ExecuteDeleted();
public abstract Task<List<T1>> ExecuteDeletedAsync();
public int ExecuteAffrows()
{
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var dbParms = _params.ToArray();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Delete, sql, dbParms);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try
{
affrows = _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, dbParms);
}
catch (Exception ex)
{
exception = ex;
throw ex;
}
finally
{
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
async public Task<int> ExecuteAffrowsAsync()
{
var sql = this.ToSql();
if (string.IsNullOrEmpty(sql)) return 0;
var dbParms = _params.ToArray();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Delete, sql, dbParms);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try
{
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, dbParms);
}
catch (Exception ex)
{
exception = ex;
throw ex;
}
finally
{
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
public abstract List<T1> ExecuteDeleted();
public abstract Task<List<T1>> ExecuteDeletedAsync();
public IDelete<T1> Where(Expression<Func<T1, bool>> exp) => this.Where(_commonExpression.ExpressionWhereLambdaNoneForeignObject(null, _table, null, exp?.Body, null));
public IDelete<T1> Where(string sql, object parms = null) {
if (string.IsNullOrEmpty(sql)) return this;
var args = new Aop.WhereEventArgs(sql, parms);
_orm.Aop.Where?.Invoke(this, new Aop.WhereEventArgs(sql, parms));
if (args.IsCancel == true) return this;
public IDelete<T1> Where(Expression<Func<T1, bool>> exp) => this.Where(_commonExpression.ExpressionWhereLambdaNoneForeignObject(null, _table, null, exp?.Body, null));
public IDelete<T1> Where(string sql, object parms = null)
{
if (string.IsNullOrEmpty(sql)) return this;
var args = new Aop.WhereEventArgs(sql, parms);
_orm.Aop.Where?.Invoke(this, new Aop.WhereEventArgs(sql, parms));
if (args.IsCancel == true) return this;
if (++_whereTimes > 1) _where.Append(" AND ");
_where.Append("(").Append(sql).Append(")");
if (parms != null) _params.AddRange(_commonUtils.GetDbParamtersByObject(sql, parms));
return this;
}
public IDelete<T1> Where(T1 item) => this.Where(new[] { item });
public IDelete<T1> Where(IEnumerable<T1> items) => this.Where(_commonUtils.WhereItems(_table, "", items));
public IDelete<T1> WhereExists<TEntity2>(ISelect<TEntity2> select, bool notExists = false) where TEntity2 : class => this.Where($"{(notExists ? "NOT " : "")}EXISTS({select.ToSql("1")})");
public IDelete<T1> WhereDynamic(object dywhere) => this.Where(_commonUtils.WhereObject(_table, "", dywhere));
if (++_whereTimes > 1) _where.Append(" AND ");
_where.Append("(").Append(sql).Append(")");
if (parms != null) _params.AddRange(_commonUtils.GetDbParamtersByObject(sql, parms));
return this;
}
public IDelete<T1> Where(T1 item) => this.Where(new[] { item });
public IDelete<T1> Where(IEnumerable<T1> items) => this.Where(_commonUtils.WhereItems(_table, "", items));
public IDelete<T1> WhereExists<TEntity2>(ISelect<TEntity2> select, bool notExists = false) where TEntity2 : class => this.Where($"{(notExists ? "NOT " : "")}EXISTS({select.ToSql("1")})");
public IDelete<T1> WhereDynamic(object dywhere) => this.Where(_commonUtils.WhereObject(_table, "", dywhere));
public IDelete<T1> AsTable(Func<string, string> tableRule) {
_tableRule = tableRule;
return this;
}
public IDelete<T1> AsType(Type entityType) {
if (entityType == typeof(object)) throw new Exception("IDelete.AsType 参数不支持指定为 object");
if (entityType == _table.Type) return this;
var newtb = _commonUtils.GetTableByEntity(entityType);
_table = newtb ?? throw new Exception("IDelete.AsType 参数错误，请传入正确的实体类型");
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(entityType);
return this;
}
public IDelete<T1> AsTable(Func<string, string> tableRule)
{
_tableRule = tableRule;
return this;
}
public IDelete<T1> AsType(Type entityType)
{
if (entityType == typeof(object)) throw new Exception("IDelete.AsType 参数不支持指定为 object");
if (entityType == _table.Type) return this;
var newtb = _commonUtils.GetTableByEntity(entityType);
_table = newtb ?? throw new Exception("IDelete.AsType 参数错误，请传入正确的实体类型");
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(entityType);
return this;
}
public string ToSql() => _whereTimes <= 0 ? null : new StringBuilder().Append("DELETE FROM ").Append(_commonUtils.QuoteSqlName(_tableRule?.Invoke(_table.DbName) ?? _table.DbName)).Append(" WHERE ").Append(_where).ToString();
}
public string ToSql() => _whereTimes <= 0 ? null : new StringBuilder().Append("DELETE FROM ").Append(_commonUtils.QuoteSqlName(_tableRule?.Invoke(_table.DbName) ?? _table.DbName)).Append(" WHERE ").Append(_where).ToString();
}
}

943
FreeSql/Internal/CommonProvider/InsertProvider.cs
View File

@@ -9,436 +9,545 @@ using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract partial class InsertProvider<T1> : IInsert<T1> where T1 : class {
protected IFreeSql _orm;
protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression;
protected List<T1> _source = new List<T1>();
protected Dictionary<string, bool> _ignore = new Dictionary<string, bool>(StringComparer.CurrentCultureIgnoreCase);
protected TableInfo _table;
protected Func<string, string> _tableRule;
protected bool _noneParameter;
protected DbParameter[] _params;
protected DbTransaction _transaction;
protected DbConnection _connection;
public abstract partial class InsertProvider<T1> : IInsert<T1> where T1 : class
{
protected IFreeSql _orm;
protected CommonUtils _commonUtils;
protected CommonExpression _commonExpression;
protected List<T1> _source = new List<T1>();
protected Dictionary<string, bool> _ignore = new Dictionary<string, bool>(StringComparer.CurrentCultureIgnoreCase);
protected TableInfo _table;
protected Func<string, string> _tableRule;
protected bool _noneParameter;
protected DbParameter[] _params;
protected DbTransaction _transaction;
protected DbConnection _connection;
public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
_orm = orm;
_commonUtils = commonUtils;
_commonExpression = commonExpression;
_table = _commonUtils.GetTableByEntity(typeof(T1));
_noneParameter = _orm.CodeFirst.IsNoneCommandParameter;
if (_orm.CodeFirst.IsAutoSyncStructure && typeof(T1) != typeof(object)) _orm.CodeFirst.SyncStructure<T1>();
}
public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression)
{
_orm = orm;
_commonUtils = commonUtils;
_commonExpression = commonExpression;
_table = _commonUtils.GetTableByEntity(typeof(T1));
_noneParameter = _orm.CodeFirst.IsNoneCommandParameter;
if (_orm.CodeFirst.IsAutoSyncStructure && typeof(T1) != typeof(object)) _orm.CodeFirst.SyncStructure<T1>();
}
protected void ClearData() {
_source.Clear();
_ignore.Clear();
_params = null;
}
protected void ClearData()
{
_source.Clear();
_ignore.Clear();
_params = null;
}
public IInsert<T1> WithTransaction(DbTransaction transaction) {
_transaction = transaction;
_connection = _transaction?.Connection;
return this;
}
public IInsert<T1> WithConnection(DbConnection connection) {
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this;
}
public IInsert<T1> WithTransaction(DbTransaction transaction)
{
_transaction = transaction;
_connection = _transaction?.Connection;
return this;
}
public IInsert<T1> WithConnection(DbConnection connection)
{
if (_transaction?.Connection != connection) _transaction = null;
_connection = connection;
return this;
}
public IInsert<T1> NoneParameter() {
_noneParameter = true;
return this;
}
public IInsert<T1> NoneParameter()
{
_noneParameter = true;
return this;
}
public IInsert<T1> AppendData(T1 source) {
if (source != null) _source.Add(source);
return this;
}
public IInsert<T1> AppendData(T1[] source) {
if (source != null) _source.AddRange(source);
return this;
}
public IInsert<T1> AppendData(IEnumerable<T1> source) {
if (source != null) _source.AddRange(source.Where(a => a != null));
return this;
}
public IInsert<T1> AppendData(T1 source)
{
if (source != null) _source.Add(source);
return this;
}
public IInsert<T1> AppendData(T1[] source)
{
if (source != null) _source.AddRange(source);
return this;
}
public IInsert<T1> AppendData(IEnumerable<T1> source)
{
if (source != null) _source.AddRange(source.Where(a => a != null));
return this;
}
#region 参数化数据限制，或values数量限制
protected List<T1>[] SplitSource(int valuesLimit, int parameterLimit) {
valuesLimit = valuesLimit - 1;
parameterLimit = parameterLimit - 1;
if (_source == null || _source.Any() == false) return new List<T1>[0];
if (_source.Count == 1) return new[] { _source };
if (_noneParameter) {
if (_source.Count < valuesLimit) return new[] { _source };
#region 参数化数据限制，或values数量限制
protected List<T1>[] SplitSource(int valuesLimit, int parameterLimit)
{
valuesLimit = valuesLimit - 1;
parameterLimit = parameterLimit - 1;
if (_source == null || _source.Any() == false) return new List<T1>[0];
if (_source.Count == 1) return new[] { _source };
if (_noneParameter)
{
if (_source.Count < valuesLimit) return new[] { _source };
var execCount = (int)Math.Ceiling(1.0 * _source.Count / valuesLimit);
var ret = new List<T1>[execCount];
for (var a = 0; a < execCount; a++) {
var subSource = new List<T1>();
subSource = _source.GetRange(a * valuesLimit, Math.Min(valuesLimit, _source.Count - a * valuesLimit));
ret[a] = subSource;
}
return ret;
} else {
var colSum = _table.Columns.Count - _ignore.Count;
var takeMax = parameterLimit / colSum;
var pamTotal = colSum * _source.Count;
if (pamTotal < parameterLimit) return new[] { _source };
var execCount = (int)Math.Ceiling(1.0 * _source.Count / valuesLimit);
var ret = new List<T1>[execCount];
for (var a = 0; a < execCount; a++)
{
var subSource = new List<T1>();
subSource = _source.GetRange(a * valuesLimit, Math.Min(valuesLimit, _source.Count - a * valuesLimit));
ret[a] = subSource;
}
return ret;
}
else
{
var colSum = _table.Columns.Count - _ignore.Count;
var takeMax = parameterLimit / colSum;
var pamTotal = colSum * _source.Count;
if (pamTotal < parameterLimit) return new[] { _source };
var execCount = (int)Math.Ceiling(1.0 * pamTotal / takeMax / colSum);
var ret = new List<T1>[execCount];
for (var a = 0; a < execCount; a++) {
var subSource = new List<T1>();
subSource = _source.GetRange(a * takeMax, Math.Min(takeMax, _source.Count - a * takeMax));
ret[a] = subSource;
}
return ret;
}
}
protected int SplitExecuteAffrows(int valuesLimit, int parameterLimit) {
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = 0;
if (ss.Any() == false) {
ClearData();
return ret;
}
if (ss.Length == 1) {
ret = this.RawExecuteAffrows();
ClearData();
return ret;
}
if (_transaction != null) {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret += this.RawExecuteAffrows();
}
} else {
using (var conn = _orm.Ado.MasterPool.Get()) {
_transaction = conn.Value.BeginTransaction();
try {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret += this.RawExecuteAffrows();
}
_transaction.Commit();
} catch {
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
async protected Task<int> SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit) {
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = 0;
if (ss.Any() == false) {
ClearData();
return ret;
}
if (ss.Length == 1) {
ret = await this.RawExecuteAffrowsAsync();
ClearData();
return ret;
}
if (_transaction != null) {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret += await this.RawExecuteAffrowsAsync();
}
} else {
using (var conn = await _orm.Ado.MasterPool.GetAsync()) {
_transaction = conn.Value.BeginTransaction();
try {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret += await this.RawExecuteAffrowsAsync();
}
_transaction.Commit();
} catch {
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
protected long SplitExecuteIdentity(int valuesLimit, int parameterLimit) {
var ss = SplitSource(valuesLimit, parameterLimit);
long ret = 0;
if (ss.Any() == false) {
ClearData();
return ret;
}
if (ss.Length == 1) {
ret = this.RawExecuteIdentity();
ClearData();
return ret;
}
if (_transaction != null) {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
if (a < ss.Length - 1) this.RawExecuteAffrows();
else ret = this.RawExecuteIdentity();
}
} else {
using (var conn = _orm.Ado.MasterPool.Get()) {
_transaction = conn.Value.BeginTransaction();
try {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
if (a < ss.Length - 1) this.RawExecuteAffrows();
else ret = this.RawExecuteIdentity();
}
_transaction.Commit();
} catch {
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
async protected Task<long> SplitExecuteIdentityAsync(int valuesLimit, int parameterLimit) {
var ss = SplitSource(valuesLimit, parameterLimit);
long ret = 0;
if (ss.Any() == false) {
ClearData();
return ret;
}
if (ss.Length == 1) {
ret = await this.RawExecuteIdentityAsync();
ClearData();
return ret;
}
if (_transaction != null) {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync();
else ret = await this.RawExecuteIdentityAsync();
}
} else {
using (var conn = await _orm.Ado.MasterPool.GetAsync()) {
_transaction = conn.Value.BeginTransaction();
try {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync();
else ret = await this.RawExecuteIdentityAsync();
}
_transaction.Commit();
} catch {
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit) {
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = new List<T1>();
if (ss.Any() == false) {
ClearData();
return ret;
}
if (ss.Length == 1) {
ret = this.RawExecuteInserted();
ClearData();
return ret;
}
if (_transaction != null) {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret.AddRange(this.RawExecuteInserted());
}
} else {
using (var conn = _orm.Ado.MasterPool.Get()) {
_transaction = conn.Value.BeginTransaction();
try {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret.AddRange(this.RawExecuteInserted());
}
_transaction.Commit();
} catch {
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
async protected Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit, int parameterLimit) {
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = new List<T1>();
if (ss.Any() == false) {
ClearData();
return ret;
}
if (ss.Length == 1) {
ret = await this.RawExecuteInsertedAsync();
ClearData();
return ret;
}
if (_transaction != null) {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret.AddRange(await this.RawExecuteInsertedAsync());
}
} else {
using (var conn = await _orm.Ado.MasterPool.GetAsync()) {
_transaction = conn.Value.BeginTransaction();
try {
for (var a = 0; a < ss.Length; a++) {
_source = ss[a];
ret.AddRange(await this.RawExecuteInsertedAsync());
}
_transaction.Commit();
} catch {
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
#endregion
var execCount = (int)Math.Ceiling(1.0 * pamTotal / takeMax / colSum);
var ret = new List<T1>[execCount];
for (var a = 0; a < execCount; a++)
{
var subSource = new List<T1>();
subSource = _source.GetRange(a * takeMax, Math.Min(takeMax, _source.Count - a * takeMax));
ret[a] = subSource;
}
return ret;
}
}
protected int SplitExecuteAffrows(int valuesLimit, int parameterLimit)
{
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = 0;
if (ss.Any() == false)
{
ClearData();
return ret;
}
if (ss.Length == 1)
{
ret = this.RawExecuteAffrows();
ClearData();
return ret;
}
if (_transaction != null)
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret += this.RawExecuteAffrows();
}
}
else
{
using (var conn = _orm.Ado.MasterPool.Get())
{
_transaction = conn.Value.BeginTransaction();
try
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret += this.RawExecuteAffrows();
}
_transaction.Commit();
}
catch
{
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
async protected Task<int> SplitExecuteAffrowsAsync(int valuesLimit, int parameterLimit)
{
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = 0;
if (ss.Any() == false)
{
ClearData();
return ret;
}
if (ss.Length == 1)
{
ret = await this.RawExecuteAffrowsAsync();
ClearData();
return ret;
}
if (_transaction != null)
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret += await this.RawExecuteAffrowsAsync();
}
}
else
{
using (var conn = await _orm.Ado.MasterPool.GetAsync())
{
_transaction = conn.Value.BeginTransaction();
try
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret += await this.RawExecuteAffrowsAsync();
}
_transaction.Commit();
}
catch
{
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
protected long SplitExecuteIdentity(int valuesLimit, int parameterLimit)
{
var ss = SplitSource(valuesLimit, parameterLimit);
long ret = 0;
if (ss.Any() == false)
{
ClearData();
return ret;
}
if (ss.Length == 1)
{
ret = this.RawExecuteIdentity();
ClearData();
return ret;
}
if (_transaction != null)
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
if (a < ss.Length - 1) this.RawExecuteAffrows();
else ret = this.RawExecuteIdentity();
}
}
else
{
using (var conn = _orm.Ado.MasterPool.Get())
{
_transaction = conn.Value.BeginTransaction();
try
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
if (a < ss.Length - 1) this.RawExecuteAffrows();
else ret = this.RawExecuteIdentity();
}
_transaction.Commit();
}
catch
{
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
async protected Task<long> SplitExecuteIdentityAsync(int valuesLimit, int parameterLimit)
{
var ss = SplitSource(valuesLimit, parameterLimit);
long ret = 0;
if (ss.Any() == false)
{
ClearData();
return ret;
}
if (ss.Length == 1)
{
ret = await this.RawExecuteIdentityAsync();
ClearData();
return ret;
}
if (_transaction != null)
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync();
else ret = await this.RawExecuteIdentityAsync();
}
}
else
{
using (var conn = await _orm.Ado.MasterPool.GetAsync())
{
_transaction = conn.Value.BeginTransaction();
try
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
if (a < ss.Length - 1) await this.RawExecuteAffrowsAsync();
else ret = await this.RawExecuteIdentityAsync();
}
_transaction.Commit();
}
catch
{
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit)
{
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = new List<T1>();
if (ss.Any() == false)
{
ClearData();
return ret;
}
if (ss.Length == 1)
{
ret = this.RawExecuteInserted();
ClearData();
return ret;
}
if (_transaction != null)
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret.AddRange(this.RawExecuteInserted());
}
}
else
{
using (var conn = _orm.Ado.MasterPool.Get())
{
_transaction = conn.Value.BeginTransaction();
try
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret.AddRange(this.RawExecuteInserted());
}
_transaction.Commit();
}
catch
{
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
async protected Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit, int parameterLimit)
{
var ss = SplitSource(valuesLimit, parameterLimit);
var ret = new List<T1>();
if (ss.Any() == false)
{
ClearData();
return ret;
}
if (ss.Length == 1)
{
ret = await this.RawExecuteInsertedAsync();
ClearData();
return ret;
}
if (_transaction != null)
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret.AddRange(await this.RawExecuteInsertedAsync());
}
}
else
{
using (var conn = await _orm.Ado.MasterPool.GetAsync())
{
_transaction = conn.Value.BeginTransaction();
try
{
for (var a = 0; a < ss.Length; a++)
{
_source = ss[a];
ret.AddRange(await this.RawExecuteInsertedAsync());
}
_transaction.Commit();
}
catch
{
_transaction.Rollback();
throw;
}
_transaction = null;
}
}
ClearData();
return ret;
}
#endregion
protected int RawExecuteAffrows() {
var sql = ToSql();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, _params);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try {
affrows = _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params);
} catch (Exception ex) {
exception = ex;
throw ex;
} finally {
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
async protected Task<int> RawExecuteAffrowsAsync() {
var sql = ToSql();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, _params);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try {
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params);
} catch (Exception ex) {
exception = ex;
throw ex;
} finally {
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
protected abstract long RawExecuteIdentity();
protected abstract Task<long> RawExecuteIdentityAsync();
protected abstract List<T1> RawExecuteInserted();
protected abstract Task<List<T1>> RawExecuteInsertedAsync();
protected int RawExecuteAffrows()
{
var sql = ToSql();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, _params);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try
{
affrows = _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params);
}
catch (Exception ex)
{
exception = ex;
throw ex;
}
finally
{
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
async protected Task<int> RawExecuteAffrowsAsync()
{
var sql = ToSql();
var before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, _params);
_orm.Aop.CurdBefore?.Invoke(this, before);
var affrows = 0;
Exception exception = null;
try
{
affrows = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params);
}
catch (Exception ex)
{
exception = ex;
throw ex;
}
finally
{
var after = new Aop.CurdAfterEventArgs(before, exception, affrows);
_orm.Aop.CurdAfter?.Invoke(this, after);
}
this.ClearData();
return affrows;
}
protected abstract long RawExecuteIdentity();
protected abstract Task<long> RawExecuteIdentityAsync();
protected abstract List<T1> RawExecuteInserted();
protected abstract Task<List<T1>> RawExecuteInsertedAsync();
public abstract int ExecuteAffrows();
public abstract Task<int> ExecuteAffrowsAsync();
public abstract long ExecuteIdentity();
public abstract Task<long> ExecuteIdentityAsync();
public abstract List<T1> ExecuteInserted();
public abstract Task<List<T1>> ExecuteInsertedAsync();
public abstract int ExecuteAffrows();
public abstract Task<int> ExecuteAffrowsAsync();
public abstract long ExecuteIdentity();
public abstract Task<long> ExecuteIdentityAsync();
public abstract List<T1> ExecuteInserted();
public abstract Task<List<T1>> ExecuteInsertedAsync();
public IInsert<T1> IgnoreColumns(Expression<Func<T1, object>> columns) {
var cols = _commonExpression.ExpressionSelectColumns_MemberAccess_New_NewArrayInit(null, columns?.Body, false, null).Distinct();
_ignore.Clear();
foreach (var col in cols) _ignore.Add(col, true);
return this;
}
public IInsert<T1> InsertColumns(Expression<Func<T1, object>> columns) {
var cols = _commonExpression.ExpressionSelectColumns_MemberAccess_New_NewArrayInit(null, columns?.Body, false, null).ToDictionary(a => a, a => true);
_ignore.Clear();
foreach (var col in _table.Columns.Values)
if (cols.ContainsKey(col.Attribute.Name) == false)
_ignore.Add(col.Attribute.Name, true);
return this;
}
public IInsert<T1> IgnoreColumns(Expression<Func<T1, object>> columns)
{
var cols = _commonExpression.ExpressionSelectColumns_MemberAccess_New_NewArrayInit(null, columns?.Body, false, null).Distinct();
_ignore.Clear();
foreach (var col in cols) _ignore.Add(col, true);
return this;
}
public IInsert<T1> InsertColumns(Expression<Func<T1, object>> columns)
{
var cols = _commonExpression.ExpressionSelectColumns_MemberAccess_New_NewArrayInit(null, columns?.Body, false, null).ToDictionary(a => a, a => true);
_ignore.Clear();
foreach (var col in _table.Columns.Values)
if (cols.ContainsKey(col.Attribute.Name) == false)
_ignore.Add(col.Attribute.Name, true);
return this;
}
public IInsert<T1> AsTable(Func<string, string> tableRule) {
_tableRule = tableRule;
return this;
}
public IInsert<T1> AsType(Type entityType) {
if (entityType == typeof(object)) throw new Exception("IInsert.AsType 参数不支持指定为 object");
if (entityType == _table.Type) return this;
var newtb = _commonUtils.GetTableByEntity(entityType);
_table = newtb ?? throw new Exception("IInsert.AsType 参数错误，请传入正确的实体类型");
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(entityType);
return this;
}
public IInsert<T1> AsTable(Func<string, string> tableRule)
{
_tableRule = tableRule;
return this;
}
public IInsert<T1> AsType(Type entityType)
{
if (entityType == typeof(object)) throw new Exception("IInsert.AsType 参数不支持指定为 object");
if (entityType == _table.Type) return this;
var newtb = _commonUtils.GetTableByEntity(entityType);
_table = newtb ?? throw new Exception("IInsert.AsType 参数错误，请传入正确的实体类型");
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(entityType);
return this;
}
public virtual string ToSql() {
if (_source == null || _source.Any() == false) return null;
var sb = new StringBuilder();
sb.Append("INSERT INTO ").Append(_commonUtils.QuoteSqlName(_tableRule?.Invoke(_table.DbName) ?? _table.DbName)).Append("(");
var colidx = 0;
foreach (var col in _table.Columns.Values)
if (col.Attribute.IsIdentity == false && _ignore.ContainsKey(col.Attribute.Name) == false) {
if (colidx > 0) sb.Append(", ");
sb.Append(_commonUtils.QuoteSqlName(col.Attribute.Name));
++colidx;
}
sb.Append(") VALUES");
_params = _noneParameter ? new DbParameter[0] : new DbParameter[colidx * _source.Count];
var specialParams = new List<DbParameter>();
var didx = 0;
foreach (var d in _source) {
if (didx > 0) sb.Append(", ");
sb.Append("(");
var colidx2 = 0;
foreach (var col in _table.Columns.Values)
if (col.Attribute.IsIdentity == false && _ignore.ContainsKey(col.Attribute.Name) == false) {
if (colidx2 > 0) sb.Append(", ");
object val = col.GetMapValue(d);
if (col.Attribute.IsPrimary && col.Attribute.MapType.NullableTypeOrThis() == typeof(Guid) && (val == null || (Guid)val == Guid.Empty))
col.SetMapValue(d, val = FreeUtil.NewMongodbId());
if (_noneParameter)
sb.Append(_commonUtils.GetNoneParamaterSqlValue(specialParams, col.Attribute.MapType, val));
else {
sb.Append(_commonUtils.QuoteWriteParamter(col.Attribute.MapType, _commonUtils.QuoteParamterName($"{col.CsName}_{didx}")));
_params[didx * colidx + colidx2] = _commonUtils.AppendParamter(null, $"{col.CsName}_{didx}", col.Attribute.MapType, val);
}
++colidx2;
}
sb.Append(")");
++didx;
}
if (_noneParameter && specialParams.Any())
_params = specialParams.ToArray();
return sb.ToString();
}
}
public virtual string ToSql()
{
if (_source == null || _source.Any() == false) return null;
var sb = new StringBuilder();
sb.Append("INSERT INTO ").Append(_commonUtils.QuoteSqlName(_tableRule?.Invoke(_table.DbName) ?? _table.DbName)).Append("(");
var colidx = 0;
foreach (var col in _table.Columns.Values)
if (col.Attribute.IsIdentity == false && _ignore.ContainsKey(col.Attribute.Name) == false)
{
if (colidx > 0) sb.Append(", ");
sb.Append(_commonUtils.QuoteSqlName(col.Attribute.Name));
++colidx;
}
sb.Append(") VALUES");
_params = _noneParameter ? new DbParameter[0] : new DbParameter[colidx * _source.Count];
var specialParams = new List<DbParameter>();
var didx = 0;
foreach (var d in _source)
{
if (didx > 0) sb.Append(", ");
sb.Append("(");
var colidx2 = 0;
foreach (var col in _table.Columns.Values)
if (col.Attribute.IsIdentity == false && _ignore.ContainsKey(col.Attribute.Name) == false)
{
if (colidx2 > 0) sb.Append(", ");
object val = col.GetMapValue(d);
if (col.Attribute.IsPrimary && col.Attribute.MapType.NullableTypeOrThis() == typeof(Guid) && (val == null || (Guid)val == Guid.Empty))
col.SetMapValue(d, val = FreeUtil.NewMongodbId());
if (_noneParameter)
sb.Append(_commonUtils.GetNoneParamaterSqlValue(specialParams, col.Attribute.MapType, val));
else
{
sb.Append(_commonUtils.QuoteWriteParamter(col.Attribute.MapType, _commonUtils.QuoteParamterName($"{col.CsName}_{didx}")));
_params[didx * colidx + colidx2] = _commonUtils.AppendParamter(null, $"{col.CsName}_{didx}", col.Attribute.MapType, val);
}
++colidx2;
}
sb.Append(")");
++didx;
}
if (_noneParameter && specialParams.Any())
_params = specialParams.ToArray();
return sb.ToString();
}
}
}

1812
FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs
View File

File diff suppressed because it is too large Load Diff

328
FreeSql/Internal/CommonProvider/SelectProvider/Select10Provider.cs
View File

@@ -5,178 +5,204 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select10Provider<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
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 {
public abstract class Select10Provider<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
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
{
public Select10Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9), typeof(T10));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T8)), Alias = $"SP10h", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T9)), Alias = $"SP10i", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T10)), Alias = $"SP10j", On = null, Type = SelectTableInfoType.From });
}
public Select10Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9), typeof(T10));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T8)), Alias = $"SP10h", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T9)), Alias = $"SP10i", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T10)), Alias = $"SP10j", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> ISelect<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) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> (exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> ISelect<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)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>(exp?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.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) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.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)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.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) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.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)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"),
Expression.Parameter(typeof(T8), "h"),
Expression.Parameter(typeof(T9), "i"),
Expression.Parameter(typeof(T10), "j"));
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"),
Expression.Parameter(typeof(T8), "h"),
Expression.Parameter(typeof(T9), "i"),
Expression.Parameter(typeof(T10), "j"));
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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) {
if (condition == false || exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return condition ? this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)) : this;
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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)
{
if (condition == false || exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return condition ? this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)) : this;
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

1563
FreeSql/Internal/CommonProvider/SelectProvider/Select1Provider.cs
View File

File diff suppressed because it is too large Load Diff

280
FreeSql/Internal/CommonProvider/SelectProvider/Select2Provider.cs
View File

@@ -5,154 +5,180 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select2Provider<T1, T2> : Select0Provider<ISelect<T1, T2>, T1>, ISelect<T1, T2>
where T1 : class
where T2 : class {
public abstract class Select2Provider<T1, T2> : Select0Provider<ISelect<T1, T2>, T1>, ISelect<T1, T2>
where T1 : class
where T2 : class
{
public Select2Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
}
public Select2Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2>.Avg<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2>.Avg<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.AvgAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.AvgAsync<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2)> ISelect<T1, T2>.GroupBy<TKey>(Expression<Func<T1, T2, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2)> ISelect<T1, T2>.GroupBy<TKey>(Expression<Func<T1, T2, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2)>(exp?.Body);
}
TMember ISelect<T1, T2>.Max<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2>.Max<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.MaxAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.MaxAsync<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2>.Min<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2>.Min<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.MinAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.MinAsync<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2> ISelect<T1, T2>.OrderBy<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2> ISelect<T1, T2>.OrderBy<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2> ISelect<T1, T2>.OrderByDescending<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2> ISelect<T1, T2>.OrderByDescending<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2>.Sum<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2>.Sum<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.SumAsync<TMember>(Expression<Func<T1, T2, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2>.SumAsync<TMember>(Expression<Func<T1, T2, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2>.ToList<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2>.ToListAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2>.ToList<TDto>() => (this as ISelect<T1, T2>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2>.ToListAsync<TDto>() => (this as ISelect<T1, T2>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"));
}
List<TReturn> ISelect<T1, T2>.ToList<TReturn>(Expression<Func<T1, T2, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2>.ToListAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2>.ToList<TDto>() => (this as ISelect<T1, T2>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2>.ToListAsync<TDto>() => (this as ISelect<T1, T2>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"));
}
DataTable ISelect<T1, T2>.ToDataTable<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2>.ToDataTable<TReturn>(Expression<Func<T1, T2, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2>.ToSql<TReturn>(Expression<Func<T1, T2, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2>.ToSql<TReturn>(Expression<Func<T1, T2, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2> ISelect<T1, T2>.Where(Expression<Func<T1, T2, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2> ISelect<T1, T2>.Where(Expression<Func<T1, T2, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2> ISelect<T1, T2>.WhereIf(bool condition, Expression<Func<T1, T2, bool>> exp) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2> ISelect<T1, T2>.WhereIf(bool condition, Expression<Func<T1, T2, bool>> exp)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2>.Any(Expression<Func<T1, T2, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2>.Any(Expression<Func<T1, T2, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2>.AnyAsync(Expression<Func<T1, T2, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2>.AnyAsync(Expression<Func<T1, T2, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

286
FreeSql/Internal/CommonProvider/SelectProvider/Select3Provider.cs
View File

@@ -5,157 +5,183 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select3Provider<T1, T2, T3> : Select0Provider<ISelect<T1, T2, T3>, T1>, ISelect<T1, T2, T3>
where T1 : class
where T2 : class
where T3 : class {
public abstract class Select3Provider<T1, T2, T3> : Select0Provider<ISelect<T1, T2, T3>, T1>, ISelect<T1, T2, T3>
where T1 : class
where T2 : class
where T3 : class
{
public Select3Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
}
public Select3Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3>.Avg<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3>.Avg<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3)> ISelect<T1, T2, T3>.GroupBy<TKey>(Expression<Func<T1, T2, T3, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3)> ISelect<T1, T2, T3>.GroupBy<TKey>(Expression<Func<T1, T2, T3, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3)>(exp?.Body);
}
TMember ISelect<T1, T2, T3>.Max<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3>.Max<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3>.Min<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3>.Min<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.MinAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.MinAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.OrderBy<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.OrderBy<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3>.Sum<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3>.Sum<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.SumAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3>.SumAsync<TMember>(Expression<Func<T1, T2, T3, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3>.ToList<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3>.ToList<TDto>() => (this as ISelect<T1, T2, T3>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"));
}
List<TReturn> ISelect<T1, T2, T3>.ToList<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3>.ToList<TDto>() => (this as ISelect<T1, T2, T3>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"));
}
DataTable ISelect<T1, T2, T3>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3>.ToSql<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3>.ToSql<TReturn>(Expression<Func<T1, T2, T3, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.Where(Expression<Func<T1, T2, T3, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.Where(Expression<Func<T1, T2, T3, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.WhereIf(bool condition, Expression<Func<T1, T2, T3, bool>> exp) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3> ISelect<T1, T2, T3>.WhereIf(bool condition, Expression<Func<T1, T2, T3, bool>> exp)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2, T3>.Any(Expression<Func<T1, T2, T3, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3>.Any(Expression<Func<T1, T2, T3, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3>.AnyAsync(Expression<Func<T1, T2, T3, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3>.AnyAsync(Expression<Func<T1, T2, T3, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

292
FreeSql/Internal/CommonProvider/SelectProvider/Select4Provider.cs
View File

@@ -5,160 +5,186 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select4Provider<T1, T2, T3, T4> : Select0Provider<ISelect<T1, T2, T3, T4>, T1>, ISelect<T1, T2, T3, T4>
where T1 : class
where T2 : class
where T3 : class
where T4 : class {
public abstract class Select4Provider<T1, T2, T3, T4> : Select0Provider<ISelect<T1, T2, T3, T4>, T1>, ISelect<T1, T2, T3, T4>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
{
public Select4Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
}
public Select4Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3, T4>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4)> ISelect<T1, T2, T3, T4>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4)> ISelect<T1, T2, T3, T4>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4)>(exp?.Body);
}
TMember ISelect<T1, T2, T3, T4>.Max<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4>.Max<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4>.Min<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4>.Min<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3, T4>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3, T4>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3, T4>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"));
}
Task<TReturn> ISelect<T1, T2, T3, T4>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"));
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3, T4>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3, T4>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.Where(Expression<Func<T1, T2, T3, T4, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.Where(Expression<Func<T1, T2, T3, T4, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, bool>> exp) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4> ISelect<T1, T2, T3, T4>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, bool>> exp)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2, T3, T4>.Any(Expression<Func<T1, T2, T3, T4, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3, T4>.Any(Expression<Func<T1, T2, T3, T4, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3, T4>.AnyAsync(Expression<Func<T1, T2, T3, T4, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3, T4>.AnyAsync(Expression<Func<T1, T2, T3, T4, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

298
FreeSql/Internal/CommonProvider/SelectProvider/Select5Provider.cs
View File

@@ -5,163 +5,189 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select5Provider<T1, T2, T3, T4, T5> : Select0Provider<ISelect<T1, T2, T3, T4, T5>, T1>, ISelect<T1, T2, T3, T4, T5>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class {
public abstract class Select5Provider<T1, T2, T3, T4, T5> : Select0Provider<ISelect<T1, T2, T3, T4, T5>, T1>, ISelect<T1, T2, T3, T4, T5>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class
{
public Select5Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
}
public Select5Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3, T4, T5>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5)> ISelect<T1, T2, T3, T4, T5>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5)> ISelect<T1, T2, T3, T4, T5>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5)>(exp?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4, T5>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"));
}
List<TReturn> ISelect<T1, T2, T3, T4, T5>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"));
}
DataTable ISelect<T1, T2, T3, T4, T5>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4, T5>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.Where(Expression<Func<T1, T2, T3, T4, T5, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.Where(Expression<Func<T1, T2, T3, T4, T5, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, bool>> exp) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5> ISelect<T1, T2, T3, T4, T5>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, bool>> exp)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2, T3, T4, T5>.Any(Expression<Func<T1, T2, T3, T4, T5, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3, T4, T5>.Any(Expression<Func<T1, T2, T3, T4, T5, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3, T4, T5>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3, T4, T5>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

304
FreeSql/Internal/CommonProvider/SelectProvider/Select6Provider.cs
View File

@@ -5,166 +5,192 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select6Provider<T1, T2, T3, T4, T5, T6> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6>, T1>, ISelect<T1, T2, T3, T4, T5, T6>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class
where T6 : class {
public abstract class Select6Provider<T1, T2, T3, T4, T5, T6> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6>, T1>, ISelect<T1, T2, T3, T4, T5, T6>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class
where T6 : class
{
public Select6Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
}
public Select6Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6)> ISelect<T1, T2, T3, T4, T5, T6>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6)> ISelect<T1, T2, T3, T4, T5, T6>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6)>(exp?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"));
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"));
}
DataTable ISelect<T1, T2, T3, T4, T5, T6>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4, T5, T6>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6> ISelect<T1, T2, T3, T4, T5, T6>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2, T3, T4, T5, T6>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3, T4, T5, T6>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

310
FreeSql/Internal/CommonProvider/SelectProvider/Select7Provider.cs
View File

@@ -5,169 +5,195 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select7Provider<T1, T2, T3, T4, T5, T6, T7> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class
where T6 : class
where T7 : class {
public abstract class Select7Provider<T1, T2, T3, T4, T5, T6, T7> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class
where T6 : class
where T7 : class
{
public Select7Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
}
public Select7Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7)> ISelect<T1, T2, T3, T4, T5, T6, T7>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7)> ISelect<T1, T2, T3, T4, T5, T6, T7>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7)>(exp?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"));
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"));
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7> ISelect<T1, T2, T3, T4, T5, T6, T7>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

316
FreeSql/Internal/CommonProvider/SelectProvider/Select8Provider.cs
View File

@@ -5,172 +5,198 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select8Provider<T1, T2, T3, T4, T5, T6, T7, T8> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7, T8>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7, T8>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class
where T6 : class
where T7 : class
where T8 : class {
public abstract class Select8Provider<T1, T2, T3, T4, T5, T6, T7, T8> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7, T8>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7, T8>
where T1 : class
where T2 : class
where T3 : class
where T4 : class
where T5 : class
where T6 : class
where T7 : class
where T8 : class
{
public Select8Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T8)), Alias = $"SP10h", On = null, Type = SelectTableInfoType.From });
}
public Select8Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T8)), Alias = $"SP10h", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8)>(exp?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.OrderBy<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.OrderByDescending<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, T8, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"),
Expression.Parameter(typeof(T8), "h"));
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, T8, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"),
Expression.Parameter(typeof(T8), "h"));
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.WhereIf(bool condition, Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7, T8>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

322
FreeSql/Internal/CommonProvider/SelectProvider/Select9Provider.cs
View File

@@ -5,175 +5,201 @@ using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
namespace FreeSql.Internal.CommonProvider
{
public abstract class Select9Provider<T1, T2, T3, T4, T5, T6, T7, T8, T9> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>
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 {
public abstract class Select9Provider<T1, T2, T3, T4, T5, T6, T7, T8, T9> : Select0Provider<ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>, T1>, ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>
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
{
public Select9Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) {
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T8)), Alias = $"SP10h", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T9)), Alias = $"SP10i", On = null, Type = SelectTableInfoType.From });
}
public Select9Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere)
{
if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure(typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9));
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T2)), Alias = $"SP10b", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T3)), Alias = $"SP10c", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T4)), Alias = $"SP10d", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T5)), Alias = $"SP10e", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T6)), Alias = $"SP10f", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T7)), Alias = $"SP10g", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T8)), Alias = $"SP10h", On = null, Type = SelectTableInfoType.From });
_tables.Add(new SelectTableInfo { Table = _commonUtils.GetTableByEntity(typeof(T9)), Alias = $"SP10i", On = null, Type = SelectTableInfoType.From });
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Avg<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvg<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.AvgAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalAvgAsync<TMember>(column?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TKey>> exp) {
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>(exp?.Body);
}
ISelectGrouping<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.GroupBy<TKey>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TKey>> exp)
{
if (exp == null) return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>(exp?.Body);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.InternalGroupBy<TKey, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>(exp?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Max<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMax<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.MaxAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMaxAsync<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Min<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) return default(TMember);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMin<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.MinAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) return Task.FromResult(default(TMember));
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalMinAsync<TMember>(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderBy(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalOrderByDescending(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
TMember ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Sum<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSum<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column) {
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
Task<TMember> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.SumAsync<TMember>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TMember>> column)
{
if (column == null) this.InternalOrderBy(column?.Body);
for (var a = 0; a < column.Parameters.Count; a++) _tables[a].Parameter = column.Parameters[a];
return this.InternalSumAsync<TMember>(column?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select) {
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
TReturn ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToAggregate<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select)
{
if (select == null) return default(TReturn);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregate<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select) {
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
Task<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToAggregateAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<T1>, ISelectGroupingAggregate<T2>, ISelectGroupingAggregate<T3>, ISelectGroupingAggregate<T4>, ISelectGroupingAggregate<T5>, ISelectGroupingAggregate<T6>, ISelectGroupingAggregate<T7>, ISelectGroupingAggregate<T8>, ISelectGroupingAggregate<T9>, TReturn>> select)
{
if (select == null) return Task.FromResult(default(TReturn));
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToAggregateAsync<TReturn>(select?.Body);
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select) {
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select) {
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TDto>> GetToListDtoSelector<TDto>() {
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"),
Expression.Parameter(typeof(T8), "h"),
Expression.Parameter(typeof(T9), "i"));
}
List<TReturn> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToList<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select)
{
if (select == null) return this.InternalToList<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToList<TReturn>(select?.Body);
}
Task<List<TReturn>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToListAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select)
{
if (select == null) return this.InternalToListAsync<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToListAsync<TReturn>(select?.Body);
}
List<TDto> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToList<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>).ToList(GetToListDtoSelector<TDto>());
Task<List<TDto>> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToListAsync<TDto>() => (this as ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>).ToListAsync(GetToListDtoSelector<TDto>());
Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TDto>> GetToListDtoSelector<TDto>()
{
var ctor = typeof(TDto).GetConstructor(new Type[0]);
return Expression.Lambda<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TDto>>(Expression.New(ctor),
_tables[0].Parameter ?? Expression.Parameter(typeof(T1), "a"),
Expression.Parameter(typeof(T2), "b"),
Expression.Parameter(typeof(T3), "c"),
Expression.Parameter(typeof(T4), "d"),
Expression.Parameter(typeof(T5), "e"),
Expression.Parameter(typeof(T6), "f"),
Expression.Parameter(typeof(T7), "g"),
Expression.Parameter(typeof(T8), "h"),
Expression.Parameter(typeof(T9), "i"));
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select) {
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
DataTable ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToDataTable<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select)
{
if (select == null) return this.InternalToDataTable(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTable(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select) {
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
Task<DataTable> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToDataTableAsync<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select)
{
if (select == null) return this.InternalToDataTableAsync(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToDataTableAsync(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select) {
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
string ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.ToSql<TReturn>(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TReturn>> select)
{
if (select == null) return this.InternalToSql<TReturn>(select?.Body);
for (var a = 0; a < select.Parameters.Count; a++) _tables[a].Parameter = select.Parameters[a];
return this.InternalToSql<TReturn>(select?.Body);
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp) {
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Where(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp)
{
if (exp == null) return this.Where(null);
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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) {
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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)
{
if (condition == false || exp == null) return this;
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null));
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp) {
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
bool ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Any(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp)
{
if (exp == null) return this.Any();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).Any();
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp) {
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
Task<bool> ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>.AnyAsync(Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, bool>> exp)
{
if (exp == null) return this.AnyAsync();
for (var a = 0; a < exp.Parameters.Count; a++) _tables[a].Parameter = exp.Parameters[a];
return this.Where(_commonExpression.ExpressionWhereLambda(_tables, exp?.Body, null)).AnyAsync();
}
}
}

267
FreeSql/Internal/CommonProvider/SelectProvider/SelectGroupingProvider.cs
View File

@@ -7,140 +7,161 @@ using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace FreeSql.Internal.CommonProvider {
public class SelectGroupingProvider<TKey, TValue> : ISelectGrouping<TKey, TValue> {
namespace FreeSql.Internal.CommonProvider
{
public class SelectGroupingProvider<TKey, TValue> : ISelectGrouping<TKey, TValue>
{
internal object _select;
internal ReadAnonymousTypeInfo _map;
internal CommonExpression _comonExp;
internal List<SelectTableInfo> _tables;
public SelectGroupingProvider(object select, ReadAnonymousTypeInfo map, CommonExpression comonExp, List<SelectTableInfo> tables) {
_select = select;
_map = map;
_comonExp = comonExp;
_tables = tables;
}
internal object _select;
internal ReadAnonymousTypeInfo _map;
internal CommonExpression _comonExp;
internal List<SelectTableInfo> _tables;
public SelectGroupingProvider(object select, ReadAnonymousTypeInfo map, CommonExpression comonExp, List<SelectTableInfo> tables)
{
_select = select;
_map = map;
_comonExp = comonExp;
_tables = tables;
}
string getSelectGroupingMapString(Expression[] members) {
if (members.Any() == false) return _map.DbField;
var parentName = ((members.FirstOrDefault() as MemberExpression)?.Expression as MemberExpression)?.Member.Name;
switch (parentName) {
case "Key":
var read = _map;
for (var a = 0; a < members.Length; a++) {
read = read.Childs.Where(z => z.CsName == (members[a] as MemberExpression)?.Member.Name).FirstOrDefault();
if (read == null) return null;
}
return read.DbField;
case "Value":
var tb = _tables.First();
var foridx = 0;
if (members.Length > 1) {
var mem0 = (members.FirstOrDefault() as MemberExpression);
var mem0Name = mem0?.Member.Name;
if (mem0Name?.StartsWith("Item") == true && int.TryParse(mem0Name.Substring(4), out var tryitemidx)) {
if (tryitemidx == 1) foridx++;
else {
//var alias = $"SP10{(char)(96 + tryitemidx)}";
var tmptb = _tables.Where((a,idx) => //a.AliasInit == alias &&
a.Table.Type == mem0.Type && idx == tryitemidx - 1).FirstOrDefault();
if (tmptb != null) {
tb = tmptb;
foridx++;
}
}
}
}
var parmExp = Expression.Parameter(tb.Table.Type, tb.Alias);
Expression retExp = parmExp;
for (var a = foridx; a < members.Length; a++) {
switch (members[a].NodeType) {
case ExpressionType.Call:
retExp = Expression.Call(retExp, (members[a] as MethodCallExpression).Method);
break;
case ExpressionType.MemberAccess:
retExp = Expression.MakeMemberAccess(retExp, (members[a] as MemberExpression).Member);
break;
default:
return null;
}
}
return _comonExp.ExpressionLambdaToSql(retExp, new CommonExpression.ExpTSC { _tables = _tables, tbtype = SelectTableInfoType.From, isQuoteName = true, isDisableDiyParse = true, style = CommonExpression.ExpressionStyle.Where });
}
return null;
}
string getSelectGroupingMapString(Expression[] members)
{
if (members.Any() == false) return _map.DbField;
var parentName = ((members.FirstOrDefault() as MemberExpression)?.Expression as MemberExpression)?.Member.Name;
switch (parentName)
{
case "Key":
var read = _map;
for (var a = 0; a < members.Length; a++)
{
read = read.Childs.Where(z => z.CsName == (members[a] as MemberExpression)?.Member.Name).FirstOrDefault();
if (read == null) return null;
}
return read.DbField;
case "Value":
var tb = _tables.First();
var foridx = 0;
if (members.Length > 1)
{
var mem0 = (members.FirstOrDefault() as MemberExpression);
var mem0Name = mem0?.Member.Name;
if (mem0Name?.StartsWith("Item") == true && int.TryParse(mem0Name.Substring(4), out var tryitemidx))
{
if (tryitemidx == 1) foridx++;
else
{
//var alias = $"SP10{(char)(96 + tryitemidx)}";
var tmptb = _tables.Where((a, idx) => //a.AliasInit == alias &&
a.Table.Type == mem0.Type && idx == tryitemidx - 1).FirstOrDefault();
if (tmptb != null)
{
tb = tmptb;
foridx++;
}
}
}
}
var parmExp = Expression.Parameter(tb.Table.Type, tb.Alias);
Expression retExp = parmExp;
for (var a = foridx; a < members.Length; a++)
{
switch (members[a].NodeType)
{
case ExpressionType.Call:
retExp = Expression.Call(retExp, (members[a] as MethodCallExpression).Method);
break;
case ExpressionType.MemberAccess:
retExp = Expression.MakeMemberAccess(retExp, (members[a] as MemberExpression).Member);
break;
default:
return null;
}
}
return _comonExp.ExpressionLambdaToSql(retExp, new CommonExpression.ExpTSC { _tables = _tables, tbtype = SelectTableInfoType.From, isQuoteName = true, isDisableDiyParse = true, style = CommonExpression.ExpressionStyle.Where });
}
return null;
}
public ISelectGrouping<TKey, TValue> Having(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, bool>> exp) {
var sql = _comonExp.ExpressionWhereLambda(null, exp, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("Having", new[] { typeof(string), typeof(object) });
method.Invoke(_select, new object[] { sql, null });
return this;
}
public ISelectGrouping<TKey, TValue> Having(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, bool>> exp)
{
var sql = _comonExp.ExpressionWhereLambda(null, exp, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("Having", new[] { typeof(string), typeof(object) });
method.Invoke(_select, new object[] { sql, null });
return this;
}
public ISelectGrouping<TKey, TValue> OrderBy<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column) {
var sql = _comonExp.ExpressionWhereLambda(null, column, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("OrderBy", new[] { typeof(string), typeof(object) });
method.Invoke(_select, new object[] { sql, null });
return this;
}
public ISelectGrouping<TKey, TValue> OrderBy<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column)
{
var sql = _comonExp.ExpressionWhereLambda(null, column, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("OrderBy", new[] { typeof(string), typeof(object) });
method.Invoke(_select, new object[] { sql, null });
return this;
}
public ISelectGrouping<TKey, TValue> OrderByDescending<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column) {
var sql = _comonExp.ExpressionWhereLambda(null, column, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("OrderBy", new[] { typeof(string), typeof(object) });
method.Invoke(_select, new object[] { $"{sql} DESC", null });
return this;
}
public ISelectGrouping<TKey, TValue> OrderByDescending<TMember>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TMember>> column)
{
var sql = _comonExp.ExpressionWhereLambda(null, column, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("OrderBy", new[] { typeof(string), typeof(object) });
method.Invoke(_select, new object[] { $"{sql} DESC", null });
return this;
}
public List<TReturn> ToList<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select) {
var map = new ReadAnonymousTypeInfo();
var field = new StringBuilder();
var index = 0;
public List<TReturn> ToList<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select)
{
var map = new ReadAnonymousTypeInfo();
var field = new StringBuilder();
var index = 0;
_comonExp.ReadAnonymousField(null, field, map, ref index, select, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("ToListMapReader", BindingFlags.Instance | BindingFlags.NonPublic);
method = method.MakeGenericMethod(typeof(TReturn));
return method.Invoke(_select, new object[] { (map, field.Length > 0 ? field.Remove(0, 2).ToString() : null) }) as List<TReturn>;
}
public Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select) {
var map = new ReadAnonymousTypeInfo();
var field = new StringBuilder();
var index = 0;
_comonExp.ReadAnonymousField(null, field, map, ref index, select, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("ToListMapReader", BindingFlags.Instance | BindingFlags.NonPublic);
method = method.MakeGenericMethod(typeof(TReturn));
return method.Invoke(_select, new object[] { (map, field.Length > 0 ? field.Remove(0, 2).ToString() : null) }) as List<TReturn>;
}
public Task<List<TReturn>> ToListAsync<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select)
{
var map = new ReadAnonymousTypeInfo();
var field = new StringBuilder();
var index = 0;
_comonExp.ReadAnonymousField(null, field, map, ref index, select, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("ToListMapReaderAsync", BindingFlags.Instance | BindingFlags.NonPublic);
method = method.MakeGenericMethod(typeof(TReturn));
return method.Invoke(_select, new object[] { (map, field.Length > 0 ? field.Remove(0, 2).ToString() : null) }) as Task<List<TReturn>>;
}
public List<TReturn> Select<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select) => ToList(select);
_comonExp.ReadAnonymousField(null, field, map, ref index, select, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("ToListMapReaderAsync", BindingFlags.Instance | BindingFlags.NonPublic);
method = method.MakeGenericMethod(typeof(TReturn));
return method.Invoke(_select, new object[] { (map, field.Length > 0 ? field.Remove(0, 2).ToString() : null) }) as Task<List<TReturn>>;
}
public List<TReturn> Select<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select) => ToList(select);
public string ToSql<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select) {
var map = new ReadAnonymousTypeInfo();
var field = new StringBuilder();
var index = 0;
public string ToSql<TReturn>(Expression<Func<ISelectGroupingAggregate<TKey, TValue>, TReturn>> select)
{
var map = new ReadAnonymousTypeInfo();
var field = new StringBuilder();
var index = 0;
_comonExp.ReadAnonymousField(null, field, map, ref index, select, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("ToSql", new[] { typeof(string) });
return method.Invoke(_select, new object[] { field.Length > 0 ? field.Remove(0, 2).ToString() : null }) as string;
}
_comonExp.ReadAnonymousField(null, field, map, ref index, select, getSelectGroupingMapString);
var method = _select.GetType().GetMethod("ToSql", new[] { typeof(string) });
return method.Invoke(_select, new object[] { field.Length > 0 ? field.Remove(0, 2).ToString() : null }) as string;
}
public ISelectGrouping<TKey, TValue> Skip(int offset) {
var method = _select.GetType().GetMethod("Skip", new[] { typeof(int) });
method.Invoke(_select, new object[] { offset });
return this;
}
public ISelectGrouping<TKey, TValue> Offset(int offset) => this.Skip(offset);
public ISelectGrouping<TKey, TValue> Skip(int offset)
{
var method = _select.GetType().GetMethod("Skip", new[] { typeof(int) });
method.Invoke(_select, new object[] { offset });
return this;
}
public ISelectGrouping<TKey, TValue> Offset(int offset) => this.Skip(offset);
public ISelectGrouping<TKey, TValue> Limit(int limit) {
var method = _select.GetType().GetMethod("Limit", new[] { typeof(int) });
method.Invoke(_select, new object[] { limit });
return this;
}
public ISelectGrouping<TKey, TValue> Take(int limit) => this.Limit(limit);
public ISelectGrouping<TKey, TValue> Limit(int limit)
{
var method = _select.GetType().GetMethod("Limit", new[] { typeof(int) });
method.Invoke(_select, new object[] { limit });
return this;
}
public ISelectGrouping<TKey, TValue> Take(int limit) => this.Limit(limit);
public ISelectGrouping<TKey, TValue> Page(int pageNumber, int pageSize) {
var method = _select.GetType().GetMethod("Page", new[] { typeof(int), typeof(int) });
method.Invoke(_select, new object[] { pageNumber, pageSize });
return this;
}
}
public ISelectGrouping<TKey, TValue> Page(int pageNumber, int pageSize)
{
var method = _select.GetType().GetMethod("Page", new[] { typeof(int), typeof(int) });
method.Invoke(_select, new object[] { pageNumber, pageSize });
return this;
}
}
}

1126
FreeSql/Internal/CommonProvider/UpdateProvider.cs
View File

File diff suppressed because it is too large Load Diff

594
FreeSql/Internal/CommonUtils.cs
View File

@@ -17,293 +17,339 @@ using System.Threading.Tasks;
using System.Xml;
using System.Xml.XPath;
namespace FreeSql.Internal {
public abstract class CommonUtils {
namespace FreeSql.Internal
{
public abstract class CommonUtils
{
public abstract string GetNoneParamaterSqlValue(List<DbParameter> specialParams, Type type, object value);
public abstract DbParameter AppendParamter(List<DbParameter> _params, string parameterName, Type type, object value);
public abstract DbParameter[] GetDbParamtersByObject(string sql, object obj);
public abstract string FormatSql(string sql, params object[] args);
public abstract string QuoteSqlName(string name);
public abstract string TrimQuoteSqlName(string name);
public abstract string QuoteParamterName(string name);
public abstract string IsNull(string sql, object value);
public abstract string StringConcat(string[] objs, Type[] types);
public abstract string Mod(string left, string right, Type leftType, Type rightType);
public abstract string QuoteWriteParamter(Type type, string paramterName);
public abstract string QuoteReadColumn(Type type, string columnName);
public abstract string GetNoneParamaterSqlValue(List<DbParameter> specialParams, Type type, object value);
public abstract DbParameter AppendParamter(List<DbParameter> _params, string parameterName, Type type, object value);
public abstract DbParameter[] GetDbParamtersByObject(string sql, object obj);
public abstract string FormatSql(string sql, params object[] args);
public abstract string QuoteSqlName(string name);
public abstract string TrimQuoteSqlName(string name);
public abstract string QuoteParamterName(string name);
public abstract string IsNull(string sql, object value);
public abstract string StringConcat(string[] objs, Type[] types);
public abstract string Mod(string left, string right, Type leftType, Type rightType);
public abstract string QuoteWriteParamter(Type type, string paramterName);
public abstract string QuoteReadColumn(Type type, string columnName);
public IFreeSql _orm { get; set; }
public ICodeFirst CodeFirst => _orm.CodeFirst;
public TableInfo GetTableByEntity(Type entity) => Utils.GetTableByEntity(entity, this);
public List<DbTableInfo> dbTables { get; set; }
public object dbTablesLock = new object();
public IFreeSql _orm { get; set; }
public ICodeFirst CodeFirst => _orm.CodeFirst;
public TableInfo GetTableByEntity(Type entity) => Utils.GetTableByEntity(entity, this);
public List<DbTableInfo> dbTables { get; set; }
public object dbTablesLock = new object();
public CommonUtils(IFreeSql orm) {
_orm = orm;
}
public CommonUtils(IFreeSql orm)
{
_orm = orm;
}
ConcurrentDictionary<Type, TableAttribute> dicConfigEntity = new ConcurrentDictionary<Type, TableAttribute>();
public ICodeFirst ConfigEntity<T>(Action<TableFluent<T>> entity) {
if (entity == null) return _orm.CodeFirst;
var type = typeof(T);
var table = dicConfigEntity.GetOrAdd(type, new TableAttribute());
var fluent = new TableFluent<T>(table);
entity.Invoke(fluent);
Utils.RemoveTableByEntity(type, this); //remove cache
return _orm.CodeFirst;
}
public ICodeFirst ConfigEntity(Type type, Action<TableFluent> entity) {
if (entity == null) return _orm.CodeFirst;
var table = dicConfigEntity.GetOrAdd(type, new TableAttribute());
var fluent = new TableFluent(type, table);
entity.Invoke(fluent);
Utils.RemoveTableByEntity(type, this); //remove cache
return _orm.CodeFirst;
}
public TableAttribute GetConfigEntity(Type type) {
return dicConfigEntity.TryGetValue(type, out var trytb) ? trytb : null;
}
public TableAttribute GetEntityTableAttribute(Type type) {
TableAttribute attr = null;
if (_orm.Aop.ConfigEntity != null) {
var aope = new Aop.ConfigEntityEventArgs(type);
_orm.Aop.ConfigEntity(_orm, aope);
attr = aope.ModifyResult;
}
if (attr == null) attr = new TableAttribute();
if (dicConfigEntity.TryGetValue(type, out var trytb)) {
if (!string.IsNullOrEmpty(trytb.Name)) attr.Name = trytb.Name;
if (!string.IsNullOrEmpty(trytb.OldName)) attr.OldName = trytb.OldName;
if (!string.IsNullOrEmpty(trytb.SelectFilter)) attr.SelectFilter = trytb.SelectFilter;
if (trytb._DisableSyncStructure != null) attr._DisableSyncStructure = trytb.DisableSyncStructure;
ConcurrentDictionary<Type, TableAttribute> dicConfigEntity = new ConcurrentDictionary<Type, TableAttribute>();
public ICodeFirst ConfigEntity<T>(Action<TableFluent<T>> entity)
{
if (entity == null) return _orm.CodeFirst;
var type = typeof(T);
var table = dicConfigEntity.GetOrAdd(type, new TableAttribute());
var fluent = new TableFluent<T>(table);
entity.Invoke(fluent);
Utils.RemoveTableByEntity(type, this); //remove cache
return _orm.CodeFirst;
}
public ICodeFirst ConfigEntity(Type type, Action<TableFluent> entity)
{
if (entity == null) return _orm.CodeFirst;
var table = dicConfigEntity.GetOrAdd(type, new TableAttribute());
var fluent = new TableFluent(type, table);
entity.Invoke(fluent);
Utils.RemoveTableByEntity(type, this); //remove cache
return _orm.CodeFirst;
}
public TableAttribute GetConfigEntity(Type type)
{
return dicConfigEntity.TryGetValue(type, out var trytb) ? trytb : null;
}
public TableAttribute GetEntityTableAttribute(Type type)
{
TableAttribute attr = null;
if (_orm.Aop.ConfigEntity != null)
{
var aope = new Aop.ConfigEntityEventArgs(type);
_orm.Aop.ConfigEntity(_orm, aope);
attr = aope.ModifyResult;
}
if (attr == null) attr = new TableAttribute();
if (dicConfigEntity.TryGetValue(type, out var trytb))
{
if (!string.IsNullOrEmpty(trytb.Name)) attr.Name = trytb.Name;
if (!string.IsNullOrEmpty(trytb.OldName)) attr.OldName = trytb.OldName;
if (!string.IsNullOrEmpty(trytb.SelectFilter)) attr.SelectFilter = trytb.SelectFilter;
if (trytb._DisableSyncStructure != null) attr._DisableSyncStructure = trytb.DisableSyncStructure;
}
var attrs = type.GetCustomAttributes(typeof(TableAttribute), false);
foreach (var tryattrobj in attrs) {
var tryattr = tryattrobj as TableAttribute;
if (tryattr == null) continue;
if (!string.IsNullOrEmpty(tryattr.Name)) attr.Name = tryattr.Name;
if (!string.IsNullOrEmpty(tryattr.OldName)) attr.OldName = tryattr.OldName;
if (!string.IsNullOrEmpty(tryattr.SelectFilter)) attr.SelectFilter = tryattr.SelectFilter;
if (tryattr._DisableSyncStructure != null) attr._DisableSyncStructure = tryattr.DisableSyncStructure;
}
if (!string.IsNullOrEmpty(attr.Name)) return attr;
if (!string.IsNullOrEmpty(attr.OldName)) return attr;
if (!string.IsNullOrEmpty(attr.SelectFilter)) return attr;
if (attr._DisableSyncStructure != null) return attr;
return null;
}
public ColumnAttribute GetEntityColumnAttribute(Type type, PropertyInfo proto) {
ColumnAttribute attr = null;
if (_orm.Aop.ConfigEntityProperty != null) {
var aope = new Aop.ConfigEntityPropertyEventArgs(type, proto);
_orm.Aop.ConfigEntityProperty(_orm, aope);
attr = aope.ModifyResult;
}
if (attr == null) attr = new ColumnAttribute();
if (dicConfigEntity.TryGetValue(type, out var trytb) && trytb._columns.TryGetValue(proto.Name, out var trycol)) {
if (!string.IsNullOrEmpty(trycol.Name)) attr.Name = trycol.Name;
if (!string.IsNullOrEmpty(trycol.OldName)) attr.OldName = trycol.OldName;
if (!string.IsNullOrEmpty(trycol.DbType)) attr.DbType = trycol.DbType;
if (trycol._IsPrimary != null) attr._IsPrimary = trycol.IsPrimary;
if (trycol._IsIdentity != null) attr._IsIdentity = trycol.IsIdentity;
if (trycol._IsNullable != null) attr._IsNullable = trycol.IsNullable;
if (trycol._IsIgnore != null) attr._IsIgnore = trycol.IsIgnore;
if (trycol._IsVersion != null) attr._IsVersion = trycol.IsVersion;
if (trycol._Uniques != null) attr._Uniques = trycol._Uniques;
if (trycol.MapType != null) attr.MapType = trycol.MapType;
if (trycol.DbDefautValue != null) attr.DbDefautValue = trycol.DbDefautValue;
}
var attrs = proto.GetCustomAttributes(typeof(ColumnAttribute), false);
foreach (var tryattrobj in attrs) {
var tryattr = tryattrobj as ColumnAttribute;
if (tryattr == null) continue;
if (!string.IsNullOrEmpty(tryattr.Name)) attr.Name = tryattr.Name;
if (!string.IsNullOrEmpty(tryattr.OldName)) attr.OldName = tryattr.OldName;
if (!string.IsNullOrEmpty(tryattr.DbType)) attr.DbType = tryattr.DbType;
if (tryattr._IsPrimary != null) attr._IsPrimary = tryattr.IsPrimary;
if (tryattr._IsIdentity != null) attr._IsIdentity = tryattr.IsIdentity;
if (tryattr._IsNullable != null) attr._IsNullable = tryattr.IsNullable;
if (tryattr._IsIgnore != null) attr._IsIgnore = tryattr.IsIgnore;
if (tryattr._IsVersion != null) attr._IsVersion = tryattr.IsVersion;
if (tryattr._Uniques != null) attr._Uniques = tryattr._Uniques;
if (tryattr.MapType != null) attr.MapType = tryattr.MapType;
if (tryattr.DbDefautValue != null) attr.DbDefautValue = tryattr.DbDefautValue;
}
ColumnAttribute ret = null;
if (!string.IsNullOrEmpty(attr.Name)) ret = attr;
if (!string.IsNullOrEmpty(attr.OldName)) ret = attr;
if (!string.IsNullOrEmpty(attr.DbType)) ret = attr;
if (attr._IsPrimary != null) ret = attr;
if (attr._IsIdentity != null) ret = attr;
if (attr._IsNullable != null) ret = attr;
if (attr._IsIgnore != null) ret = attr;
if (attr._IsVersion != null) ret = attr;
if (attr._Uniques != null) ret = attr;
if (attr.MapType != null) ret = attr;
if (attr.DbDefautValue != null) ret = attr;
if (ret != null && ret.MapType == null) ret.MapType = proto.PropertyType;
return ret;
}
}
var attrs = type.GetCustomAttributes(typeof(TableAttribute), false);
foreach (var tryattrobj in attrs)
{
var tryattr = tryattrobj as TableAttribute;
if (tryattr == null) continue;
if (!string.IsNullOrEmpty(tryattr.Name)) attr.Name = tryattr.Name;
if (!string.IsNullOrEmpty(tryattr.OldName)) attr.OldName = tryattr.OldName;
if (!string.IsNullOrEmpty(tryattr.SelectFilter)) attr.SelectFilter = tryattr.SelectFilter;
if (tryattr._DisableSyncStructure != null) attr._DisableSyncStructure = tryattr.DisableSyncStructure;
}
if (!string.IsNullOrEmpty(attr.Name)) return attr;
if (!string.IsNullOrEmpty(attr.OldName)) return attr;
if (!string.IsNullOrEmpty(attr.SelectFilter)) return attr;
if (attr._DisableSyncStructure != null) return attr;
return null;
}
public ColumnAttribute GetEntityColumnAttribute(Type type, PropertyInfo proto)
{
ColumnAttribute attr = null;
if (_orm.Aop.ConfigEntityProperty != null)
{
var aope = new Aop.ConfigEntityPropertyEventArgs(type, proto);
_orm.Aop.ConfigEntityProperty(_orm, aope);
attr = aope.ModifyResult;
}
if (attr == null) attr = new ColumnAttribute();
if (dicConfigEntity.TryGetValue(type, out var trytb) && trytb._columns.TryGetValue(proto.Name, out var trycol))
{
if (!string.IsNullOrEmpty(trycol.Name)) attr.Name = trycol.Name;
if (!string.IsNullOrEmpty(trycol.OldName)) attr.OldName = trycol.OldName;
if (!string.IsNullOrEmpty(trycol.DbType)) attr.DbType = trycol.DbType;
if (trycol._IsPrimary != null) attr._IsPrimary = trycol.IsPrimary;
if (trycol._IsIdentity != null) attr._IsIdentity = trycol.IsIdentity;
if (trycol._IsNullable != null) attr._IsNullable = trycol.IsNullable;
if (trycol._IsIgnore != null) attr._IsIgnore = trycol.IsIgnore;
if (trycol._IsVersion != null) attr._IsVersion = trycol.IsVersion;
if (trycol._Uniques != null) attr._Uniques = trycol._Uniques;
if (trycol.MapType != null) attr.MapType = trycol.MapType;
if (trycol.DbDefautValue != null) attr.DbDefautValue = trycol.DbDefautValue;
}
var attrs = proto.GetCustomAttributes(typeof(ColumnAttribute), false);
foreach (var tryattrobj in attrs)
{
var tryattr = tryattrobj as ColumnAttribute;
if (tryattr == null) continue;
if (!string.IsNullOrEmpty(tryattr.Name)) attr.Name = tryattr.Name;
if (!string.IsNullOrEmpty(tryattr.OldName)) attr.OldName = tryattr.OldName;
if (!string.IsNullOrEmpty(tryattr.DbType)) attr.DbType = tryattr.DbType;
if (tryattr._IsPrimary != null) attr._IsPrimary = tryattr.IsPrimary;
if (tryattr._IsIdentity != null) attr._IsIdentity = tryattr.IsIdentity;
if (tryattr._IsNullable != null) attr._IsNullable = tryattr.IsNullable;
if (tryattr._IsIgnore != null) attr._IsIgnore = tryattr.IsIgnore;
if (tryattr._IsVersion != null) attr._IsVersion = tryattr.IsVersion;
if (tryattr._Uniques != null) attr._Uniques = tryattr._Uniques;
if (tryattr.MapType != null) attr.MapType = tryattr.MapType;
if (tryattr.DbDefautValue != null) attr.DbDefautValue = tryattr.DbDefautValue;
}
ColumnAttribute ret = null;
if (!string.IsNullOrEmpty(attr.Name)) ret = attr;
if (!string.IsNullOrEmpty(attr.OldName)) ret = attr;
if (!string.IsNullOrEmpty(attr.DbType)) ret = attr;
if (attr._IsPrimary != null) ret = attr;
if (attr._IsIdentity != null) ret = attr;
if (attr._IsNullable != null) ret = attr;
if (attr._IsIgnore != null) ret = attr;
if (attr._IsVersion != null) ret = attr;
if (attr._Uniques != null) ret = attr;
if (attr.MapType != null) ret = attr;
if (attr.DbDefautValue != null) ret = attr;
if (ret != null && ret.MapType == null) ret.MapType = proto.PropertyType;
return ret;
}
public string WhereObject(TableInfo table, string aliasAndDot, object dywhere) {
if (dywhere == null) return "";
var type = dywhere.GetType();
var primarys = table.Primarys;
var pk1 = primarys.FirstOrDefault();
if (primarys.Length == 1 && (type == pk1.CsType || type.IsNumberType() && pk1.CsType.IsNumberType())) {
return $"{aliasAndDot}{this.QuoteSqlName(pk1.Attribute.Name)} = {this.FormatSql("{0}", Utils.GetDataReaderValue(pk1.Attribute.MapType, dywhere))}";
} else if (primarys.Length > 0 && (type == table.Type || type.BaseType == table.Type)) {
var sb = new StringBuilder();
var pkidx = 0;
foreach (var pk in primarys) {
if (pkidx > 0) sb.Append(" AND ");
sb.Append(aliasAndDot).Append(this.QuoteSqlName(pk.Attribute.Name));
sb.Append(this.FormatSql(" = {0}", pk.GetMapValue(dywhere)));
++pkidx;
}
return sb.ToString();
} else if (dywhere is IEnumerable) {
var sb = new StringBuilder();
var ie = dywhere as IEnumerable;
var ieidx = 0;
foreach (var i in ie) {
var fw = WhereObject(table, aliasAndDot, i);
if (string.IsNullOrEmpty(fw)) continue;
if (ieidx > 0) sb.Append(" OR ");
sb.Append(fw);
++ieidx;
}
return sb.ToString();
} else {
var sb = new StringBuilder();
var ps = type.GetProperties();
var psidx = 0;
foreach (var p in ps) {
if (table.Columns.TryGetValue(p.Name, out var trycol) == false) continue;
if (psidx > 0) sb.Append(" AND ");
sb.Append(aliasAndDot).Append(this.QuoteSqlName(trycol.Attribute.Name));
sb.Append(this.FormatSql(" = {0}", Utils.GetDataReaderValue(trycol.Attribute.MapType, p.GetValue(dywhere))));
++psidx;
}
if (psidx == 0) return "";
return sb.ToString();
}
}
public string WhereObject(TableInfo table, string aliasAndDot, object dywhere)
{
if (dywhere == null) return "";
var type = dywhere.GetType();
var primarys = table.Primarys;
var pk1 = primarys.FirstOrDefault();
if (primarys.Length == 1 && (type == pk1.CsType || type.IsNumberType() && pk1.CsType.IsNumberType()))
{
return $"{aliasAndDot}{this.QuoteSqlName(pk1.Attribute.Name)} = {this.FormatSql("{0}", Utils.GetDataReaderValue(pk1.Attribute.MapType, dywhere))}";
}
else if (primarys.Length > 0 && (type == table.Type || type.BaseType == table.Type))
{
var sb = new StringBuilder();
var pkidx = 0;
foreach (var pk in primarys)
{
if (pkidx > 0) sb.Append(" AND ");
sb.Append(aliasAndDot).Append(this.QuoteSqlName(pk.Attribute.Name));
sb.Append(this.FormatSql(" = {0}", pk.GetMapValue(dywhere)));
++pkidx;
}
return sb.ToString();
}
else if (dywhere is IEnumerable)
{
var sb = new StringBuilder();
var ie = dywhere as IEnumerable;
var ieidx = 0;
foreach (var i in ie)
{
var fw = WhereObject(table, aliasAndDot, i);
if (string.IsNullOrEmpty(fw)) continue;
if (ieidx > 0) sb.Append(" OR ");
sb.Append(fw);
++ieidx;
}
return sb.ToString();
}
else
{
var sb = new StringBuilder();
var ps = type.GetProperties();
var psidx = 0;
foreach (var p in ps)
{
if (table.Columns.TryGetValue(p.Name, out var trycol) == false) continue;
if (psidx > 0) sb.Append(" AND ");
sb.Append(aliasAndDot).Append(this.QuoteSqlName(trycol.Attribute.Name));
sb.Append(this.FormatSql(" = {0}", Utils.GetDataReaderValue(trycol.Attribute.MapType, p.GetValue(dywhere))));
++psidx;
}
if (psidx == 0) return "";
return sb.ToString();
}
}
public string WhereItems<TEntity>(TableInfo table, string aliasAndDot, IEnumerable<TEntity> items) {
if (items == null || items.Any() == false) return null;
if (table.Primarys.Any() == false) return null;
var its = items.Where(a => a != null).ToArray();
public string WhereItems<TEntity>(TableInfo table, string aliasAndDot, IEnumerable<TEntity> items)
{
if (items == null || items.Any() == false) return null;
if (table.Primarys.Any() == false) return null;
var its = items.Where(a => a != null).ToArray();
var pk1 = table.Primarys.FirstOrDefault();
if (table.Primarys.Length == 1) {
var sbin = new StringBuilder();
sbin.Append(aliasAndDot).Append(this.QuoteSqlName(pk1.Attribute.Name));
var indt = its.Select(a => pk1.GetMapValue(a)).Where(a => a != null).ToArray();
if (indt.Any() == false) return null;
if (indt.Length == 1) sbin.Append(" = ").Append(this.FormatSql("{0}", indt.First()));
else sbin.Append(" IN (").Append(string.Join(",", indt.Select(a => this.FormatSql("{0}", a)))).Append(")");
return sbin.ToString();
}
var dicpk = its.Length > 5 ? new Dictionary<string, bool>() : null;
var sb = its.Length > 5 ? null : new StringBuilder();
var iidx = 0;
foreach (var item in its) {
var filter = "";
foreach (var pk in table.Primarys)
filter += $" AND {aliasAndDot}{this.QuoteSqlName(pk.Attribute.Name)} = {this.FormatSql("{0}", pk.GetMapValue(item))}";
if (string.IsNullOrEmpty(filter)) continue;
if (sb != null) {
sb.Append(" OR (");
sb.Append(filter.Substring(5));
sb.Append(")");
++iidx;
}
if (dicpk != null) {
filter = filter.Substring(5);
if (dicpk.ContainsKey(filter) == false) {
dicpk.Add(filter, true);
++iidx;
}
}
//++iidx;
}
if (iidx == 0) return null;
if (sb == null) {
sb = new StringBuilder();
foreach (var fil in dicpk) {
sb.Append(" OR (");
sb.Append(fil.Key);
sb.Append(")");
}
}
return iidx == 1 ? sb.Remove(0, 5).Remove(sb.Length - 1, 1).ToString() : sb.Remove(0, 4).ToString();
}
var pk1 = table.Primarys.FirstOrDefault();
if (table.Primarys.Length == 1)
{
var sbin = new StringBuilder();
sbin.Append(aliasAndDot).Append(this.QuoteSqlName(pk1.Attribute.Name));
var indt = its.Select(a => pk1.GetMapValue(a)).Where(a => a != null).ToArray();
if (indt.Any() == false) return null;
if (indt.Length == 1) sbin.Append(" = ").Append(this.FormatSql("{0}", indt.First()));
else sbin.Append(" IN (").Append(string.Join(",", indt.Select(a => this.FormatSql("{0}", a)))).Append(")");
return sbin.ToString();
}
var dicpk = its.Length > 5 ? new Dictionary<string, bool>() : null;
var sb = its.Length > 5 ? null : new StringBuilder();
var iidx = 0;
foreach (var item in its)
{
var filter = "";
foreach (var pk in table.Primarys)
filter += $" AND {aliasAndDot}{this.QuoteSqlName(pk.Attribute.Name)} = {this.FormatSql("{0}", pk.GetMapValue(item))}";
if (string.IsNullOrEmpty(filter)) continue;
if (sb != null)
{
sb.Append(" OR (");
sb.Append(filter.Substring(5));
sb.Append(")");
++iidx;
}
if (dicpk != null)
{
filter = filter.Substring(5);
if (dicpk.ContainsKey(filter) == false)
{
dicpk.Add(filter, true);
++iidx;
}
}
//++iidx;
}
if (iidx == 0) return null;
if (sb == null)
{
sb = new StringBuilder();
foreach (var fil in dicpk)
{
sb.Append(" OR (");
sb.Append(fil.Key);
sb.Append(")");
}
}
return iidx == 1 ? sb.Remove(0, 5).Remove(sb.Length - 1, 1).ToString() : sb.Remove(0, 4).ToString();
}
/// <summary>
/// 通过属性的注释文本，通过 xml 读取
/// </summary>
/// <param name="type"></param>
/// <returns>Dict：key=属性名，value=注释</returns>
public static Dictionary<string, string> GetProperyCommentBySummary(Type type) {
var xmlPath = type.Assembly.Location.Replace(".dll", ".xml");
if (File.Exists(xmlPath) == false) return null;
/// <summary>
/// 通过属性的注释文本，通过 xml 读取
/// </summary>
/// <param name="type"></param>
/// <returns>Dict：key=属性名，value=注释</returns>
public static Dictionary<string, string> GetProperyCommentBySummary(Type type)
{
var xmlPath = type.Assembly.Location.Replace(".dll", ".xml");
if (File.Exists(xmlPath) == false) return null;
var dic = new Dictionary<string, string>();
var className = type.IsNested ? $"{type.Namespace}.{type.DeclaringType.Name}.{type.Name}" : $"{type.Namespace}.{type.Name}";
var sReader = new StringReader(File.ReadAllText(xmlPath));
using (var xmlReader = XmlReader.Create(sReader)) {
var xpath = new XPathDocument(xmlReader);
var xmlNav = xpath.CreateNavigator();
var dic = new Dictionary<string, string>();
var className = type.IsNested ? $"{type.Namespace}.{type.DeclaringType.Name}.{type.Name}" : $"{type.Namespace}.{type.Name}";
var sReader = new StringReader(File.ReadAllText(xmlPath));
using (var xmlReader = XmlReader.Create(sReader))
{
var xpath = new XPathDocument(xmlReader);
var xmlNav = xpath.CreateNavigator();
var props = type.GetProperties();
foreach (var prop in props) {
var node = xmlNav.SelectSingleNode($"/doc/members/member[@name='P:{className}.{prop.Name}']/summary");
if (node == null) continue;
var comment = node.InnerXml.Trim(' ', '\r', '\n', '\t');
if (string.IsNullOrEmpty(comment)) continue;
var props = type.GetProperties();
foreach (var prop in props)
{
var node = xmlNav.SelectSingleNode($"/doc/members/member[@name='P:{className}.{prop.Name}']/summary");
if (node == null) continue;
var comment = node.InnerXml.Trim(' ', '\r', '\n', '\t');
if (string.IsNullOrEmpty(comment)) continue;
dic.Add(prop.Name, comment);
}
}
dic.Add(prop.Name, comment);
}
}
return dic;
}
return dic;
}
public static void PrevReheatConnectionPool(ObjectPool<DbConnection> pool, int minPoolSize) {
if (minPoolSize <= 0) minPoolSize = Math.Min(5, pool.Policy.PoolSize);
if (minPoolSize > pool.Policy.PoolSize) minPoolSize = pool.Policy.PoolSize;
var initTestOk = true;
var initStartTime = DateTime.Now;
var initConns = new ConcurrentBag<Object<DbConnection>>();
public static void PrevReheatConnectionPool(ObjectPool<DbConnection> pool, int minPoolSize)
{
if (minPoolSize <= 0) minPoolSize = Math.Min(5, pool.Policy.PoolSize);
if (minPoolSize > pool.Policy.PoolSize) minPoolSize = pool.Policy.PoolSize;
var initTestOk = true;
var initStartTime = DateTime.Now;
var initConns = new ConcurrentBag<Object<DbConnection>>();
try {
var conn = pool.Get();
initConns.Add(conn);
pool.Policy.OnCheckAvailable(conn);
} catch {
initTestOk = false; //预热一次失败，后面将不进行
}
for (var a = 1; initTestOk && a < minPoolSize; a += 10) {
if (initStartTime.Subtract(DateTime.Now).TotalSeconds > 3) break; //预热耗时超过3秒，退出
var b = Math.Min(minPoolSize - a, 10); //每10个预热
var initTasks = new Task[b];
for (var c = 0; c < b; c++) {
initTasks[c] = Task.Run(() => {
try {
var conn = pool.Get();
initConns.Add(conn);
pool.Policy.OnCheckAvailable(conn);
} catch {
initTestOk = false; //有失败，下一组退出预热
}
});
}
Task.WaitAll(initTasks);
}
while (initConns.TryTake(out var conn)) pool.Return(conn);
}
}
try
{
var conn = pool.Get();
initConns.Add(conn);
pool.Policy.OnCheckAvailable(conn);
}
catch
{
initTestOk = false; //预热一次失败，后面将不进行
}
for (var a = 1; initTestOk && a < minPoolSize; a += 10)
{
if (initStartTime.Subtract(DateTime.Now).TotalSeconds > 3) break; //预热耗时超过3秒，退出
var b = Math.Min(minPoolSize - a, 10); //每10个预热
var initTasks = new Task[b];
for (var c = 0; c < b; c++)
{
initTasks[c] = Task.Run(() =>
{
try
{
var conn = pool.Get();
initConns.Add(conn);
pool.Policy.OnCheckAvailable(conn);
}
catch
{
initTestOk = false; //有失败，下一组退出预热
}
});
}
Task.WaitAll(initTasks);
}
while (initConns.TryTake(out var conn)) pool.Return(conn);
}
}
}

130
FreeSql/Internal/Model/ColumnInfo.cs
View File

@@ -4,71 +4,77 @@ using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace FreeSql.Internal.Model {
public class ColumnInfo {
public TableInfo Table { get; set; }
public string CsName { get; set; }
public Type CsType { get; set; }
public ColumnAttribute Attribute { get; set; }
public string Comment { get; internal set; }
namespace FreeSql.Internal.Model
{
public class ColumnInfo
{
public TableInfo Table { get; set; }
public string CsName { get; set; }
public Type CsType { get; set; }
public ColumnAttribute Attribute { get; set; }
public string Comment { get; internal set; }
static ConcurrentDictionary<ColumnInfo, Func<object, object>> _dicGetMapValue = new ConcurrentDictionary<ColumnInfo, Func<object, object>>();
public object GetMapValue(object obj) {
var func = _dicGetMapValue.GetOrAdd(this, col => {
var paramExp = Expression.Parameter(typeof(object));
var returnTarget = Expression.Label(typeof(object));
static ConcurrentDictionary<ColumnInfo, Func<object, object>> _dicGetMapValue = new ConcurrentDictionary<ColumnInfo, Func<object, object>>();
public object GetMapValue(object obj)
{
var func = _dicGetMapValue.GetOrAdd(this, col =>
{
var paramExp = Expression.Parameter(typeof(object));
var returnTarget = Expression.Label(typeof(object));
if (Attribute.MapType == CsType)
return Expression.Lambda<Func<object, object>>(
Expression.Block(
Expression.Return(returnTarget, Expression.Convert(
Expression.MakeMemberAccess(
Expression.TypeAs(paramExp, col.Table.Type),
Table.Properties[col.CsName]
), typeof(object))),
Expression.Label(returnTarget, Expression.Default(typeof(object)))
), new[] { paramExp }).Compile();
if (Attribute.MapType == CsType)
return Expression.Lambda<Func<object, object>>(
Expression.Block(
Expression.Return(returnTarget, Expression.Convert(
Expression.MakeMemberAccess(
Expression.TypeAs(paramExp, col.Table.Type),
Table.Properties[col.CsName]
), typeof(object))),
Expression.Label(returnTarget, Expression.Default(typeof(object)))
), new[] { paramExp }).Compile();
var retExp = Expression.Variable(typeof(object), "ret");
var blockExp = new List<Expression>();
blockExp.AddRange(new Expression[] {
Expression.Assign(retExp, Utils.GetDataReaderValueBlockExpression(Attribute.MapType,
Expression.MakeMemberAccess(
Expression.TypeAs(paramExp, col.Table.Type),
Table.Properties[col.CsName]
)
)),
Expression.Return(returnTarget, retExp),
Expression.Label(returnTarget, Expression.Default(typeof(object)))
});
return Expression.Lambda<Func<object, object>>(Expression.Block(new[] { retExp }, blockExp), new[] { paramExp }).Compile();
});
return func(obj);
}
static ConcurrentDictionary<ColumnInfo, Action<object, object>> _dicSetMapValue = new ConcurrentDictionary<ColumnInfo, Action<object, object>>();
public void SetMapValue(object obj, object val) {
var func = _dicSetMapValue.GetOrAdd(this, col => {
var objExp = Expression.Parameter(typeof(object), "obj");
var valExp = Expression.Parameter(typeof(object), "val");
var retExp = Expression.Variable(typeof(object), "ret");
var blockExp = new List<Expression>();
blockExp.AddRange(new Expression[] {
Expression.Assign(retExp, Utils.GetDataReaderValueBlockExpression(Attribute.MapType,
Expression.MakeMemberAccess(
Expression.TypeAs(paramExp, col.Table.Type),
Table.Properties[col.CsName]
)
)),
Expression.Return(returnTarget, retExp),
Expression.Label(returnTarget, Expression.Default(typeof(object)))
});
return Expression.Lambda<Func<object, object>>(Expression.Block(new[] { retExp }, blockExp), new[] { paramExp }).Compile();
});
return func(obj);
}
static ConcurrentDictionary<ColumnInfo, Action<object, object>> _dicSetMapValue = new ConcurrentDictionary<ColumnInfo, Action<object, object>>();
public void SetMapValue(object obj, object val)
{
var func = _dicSetMapValue.GetOrAdd(this, col =>
{
var objExp = Expression.Parameter(typeof(object), "obj");
var valExp = Expression.Parameter(typeof(object), "val");
if (Attribute.MapType == CsType)
return Expression.Lambda<Action<object, object>>(
Expression.Assign(Expression.MakeMemberAccess(
Expression.TypeAs(objExp, col.Table.Type),
Table.Properties[col.CsName]
), Expression.Convert(
valExp,
Attribute.MapType)), objExp, valExp).Compile();
if (Attribute.MapType == CsType)
return Expression.Lambda<Action<object, object>>(
Expression.Assign(Expression.MakeMemberAccess(
Expression.TypeAs(objExp, col.Table.Type),
Table.Properties[col.CsName]
), Expression.Convert(
valExp,
Attribute.MapType)), objExp, valExp).Compile();
return Expression.Lambda<Action<object, object>>(
Expression.Assign(Expression.MakeMemberAccess(
Expression.TypeAs(objExp, col.Table.Type),
Table.Properties[col.CsName]
), Expression.Convert(
Utils.GetDataReaderValueBlockExpression(Attribute.MapType, valExp),
Attribute.MapType)), objExp, valExp).Compile();
});
func(obj, val);
}
}
return Expression.Lambda<Action<object, object>>(
Expression.Assign(Expression.MakeMemberAccess(
Expression.TypeAs(objExp, col.Table.Type),
Table.Properties[col.CsName]
), Expression.Convert(
Utils.GetDataReaderValueBlockExpression(Attribute.MapType, valExp),
Attribute.MapType)), objExp, valExp).Compile();
});
func(obj, val);
}
}
}

28
FreeSql/Internal/Model/ReadAnonymousTypeInfo.cs
View File

@@ -3,17 +3,19 @@ using System.Collections.Generic;
using System.Reflection;
using System.Text;
namespace FreeSql.Internal.Model {
public class ReadAnonymousTypeInfo {
public PropertyInfo Property { get; set; }
public string CsName { get; set; }
public Type CsType { get; set; }
public Type MapType { get; set; }
public string DbField { get; set; }
public ConstructorInfo Consturctor { get; set; }
public ReadAnonymousTypeInfoConsturctorType ConsturctorType { get; set; }
public List<ReadAnonymousTypeInfo> Childs = new List<ReadAnonymousTypeInfo>();
public TableInfo Table { get; set; }
}
public enum ReadAnonymousTypeInfoConsturctorType { Arguments, Properties }
namespace FreeSql.Internal.Model
{
public class ReadAnonymousTypeInfo
{
public PropertyInfo Property { get; set; }
public string CsName { get; set; }
public Type CsType { get; set; }
public Type MapType { get; set; }
public string DbField { get; set; }
public ConstructorInfo Consturctor { get; set; }
public ReadAnonymousTypeInfoConsturctorType ConsturctorType { get; set; }
public List<ReadAnonymousTypeInfo> Childs = new List<ReadAnonymousTypeInfo>();
public TableInfo Table { get; set; }
}
public enum ReadAnonymousTypeInfoConsturctorType { Arguments, Properties }
}

12
FreeSql/Internal/Model/SelectColumnInfo.cs
View File

@@ -2,9 +2,11 @@
using System.Collections.Generic;
using System.Text;
namespace FreeSql.Internal.Model {
public class SelectColumnInfo {
public ColumnInfo Column { get; set; }
public SelectTableInfo Table { get; set; }
}
namespace FreeSql.Internal.Model
{
public class SelectColumnInfo
{
public ColumnInfo Column { get; set; }
public SelectTableInfo Table { get; set; }
}
}

40
FreeSql/Internal/Model/SelectTableInfo.cs
View File

@@ -1,22 +1,26 @@
using System.Linq.Expressions;
namespace FreeSql.Internal.Model {
public class SelectTableInfo {
public TableInfo Table { get; set; }
namespace FreeSql.Internal.Model
{
public class SelectTableInfo
{
public TableInfo Table { get; set; }
private string _alias;
public string Alias {
get => _alias;
set {
_alias = value;
if (string.IsNullOrEmpty(AliasInit)) AliasInit = value;
}
}
public string AliasInit { get; set; }
public string On { get; set; }
public string NavigateCondition { get; set; }
public ParameterExpression Parameter { get; set; }
public SelectTableInfoType Type { get; set; }
}
public enum SelectTableInfoType { From, LeftJoin, InnerJoin, RightJoin, Parent }
private string _alias;
public string Alias
{
get => _alias;
set
{
_alias = value;
if (string.IsNullOrEmpty(AliasInit)) AliasInit = value;
}
}
public string AliasInit { get; set; }
public string On { get; set; }
public string NavigateCondition { get; set; }
public ParameterExpression Parameter { get; set; }
public SelectTableInfoType Type { get; set; }
}
public enum SelectTableInfoType { From, LeftJoin, InnerJoin, RightJoin, Parent }
}

99
FreeSql/Internal/Model/TableInfo.cs
View File

@@ -3,58 +3,65 @@ using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reflection;
namespace FreeSql.Internal.Model {
public class TableInfo {
public Type Type { get; set; }
public Type TypeLazy { get; set; }
public MethodInfo TypeLazySetOrm { get; set; }
public Dictionary<string, PropertyInfo> Properties { get; set; } = new Dictionary<string, PropertyInfo>(StringComparer.CurrentCultureIgnoreCase);
public Dictionary<string, ColumnInfo> Columns { get; set; } = new Dictionary<string, ColumnInfo>(StringComparer.CurrentCultureIgnoreCase);
public Dictionary<string, ColumnInfo> ColumnsByCs { get; set; } = new Dictionary<string, ColumnInfo>(StringComparer.CurrentCultureIgnoreCase);
public Dictionary<string, ColumnInfo> ColumnsByCsIgnore { get; set; } = new Dictionary<string, ColumnInfo>(StringComparer.CurrentCultureIgnoreCase);
public ColumnInfo[] Primarys { get; set; }
public Dictionary<string, List<ColumnInfo>> Uniques { get; set; }
public string CsName { get; set; }
public string DbName { get; set; }
public string DbOldName { get; set; }
public string SelectFilter { get; set; }
public bool DisableSyncStructure { get; set; }
namespace FreeSql.Internal.Model
{
public class TableInfo
{
public Type Type { get; set; }
public Type TypeLazy { get; set; }
public MethodInfo TypeLazySetOrm { get; set; }
public Dictionary<string, PropertyInfo> Properties { get; set; } = new Dictionary<string, PropertyInfo>(StringComparer.CurrentCultureIgnoreCase);
public Dictionary<string, ColumnInfo> Columns { get; set; } = new Dictionary<string, ColumnInfo>(StringComparer.CurrentCultureIgnoreCase);
public Dictionary<string, ColumnInfo> ColumnsByCs { get; set; } = new Dictionary<string, ColumnInfo>(StringComparer.CurrentCultureIgnoreCase);
public Dictionary<string, ColumnInfo> ColumnsByCsIgnore { get; set; } = new Dictionary<string, ColumnInfo>(StringComparer.CurrentCultureIgnoreCase);
public ColumnInfo[] Primarys { get; set; }
public Dictionary<string, List<ColumnInfo>> Uniques { get; set; }
public string CsName { get; set; }
public string DbName { get; set; }
public string DbOldName { get; set; }
public string SelectFilter { get; set; }
public bool DisableSyncStructure { get; set; }
public ColumnInfo VersionColumn { get; set; }
public ColumnInfo VersionColumn { get; set; }
ConcurrentDictionary<string, TableRef> _refs { get; } = new ConcurrentDictionary<string, TableRef>(StringComparer.CurrentCultureIgnoreCase);
ConcurrentDictionary<string, TableRef> _refs { get; } = new ConcurrentDictionary<string, TableRef>(StringComparer.CurrentCultureIgnoreCase);
internal void AddOrUpdateTableRef(string propertyName, TableRef tbref) {
_refs.AddOrUpdate(propertyName, tbref, (ok, ov) => tbref);
}
public TableRef GetTableRef(string propertyName, bool isThrowException) {
if (_refs.TryGetValue(propertyName, out var tryref) == false) return null;
if (tryref.Exception != null) {
if (isThrowException) throw tryref.Exception;
return null;
}
return tryref;
}
}
internal void AddOrUpdateTableRef(string propertyName, TableRef tbref)
{
_refs.AddOrUpdate(propertyName, tbref, (ok, ov) => tbref);
}
public TableRef GetTableRef(string propertyName, bool isThrowException)
{
if (_refs.TryGetValue(propertyName, out var tryref) == false) return null;
if (tryref.Exception != null)
{
if (isThrowException) throw tryref.Exception;
return null;
}
return tryref;
}
}
public class TableRef {
public PropertyInfo Property { get; set; }
public class TableRef
{
public PropertyInfo Property { get; set; }
public TableRefType RefType { get; set; }
public TableRefType RefType { get; set; }
public Type RefEntityType { get; set; }
/// <summary>
/// 中间表，多对多
/// </summary>
public Type RefMiddleEntityType { get; set; }
public Type RefEntityType { get; set; }
/// <summary>
/// 中间表，多对多
/// </summary>
public Type RefMiddleEntityType { get; set; }
public List<ColumnInfo> Columns { get; set; } = new List<ColumnInfo>();
public List<ColumnInfo> MiddleColumns { get; set; } = new List<ColumnInfo>();
public List<ColumnInfo> RefColumns { get; set; } = new List<ColumnInfo>();
public List<ColumnInfo> Columns { get; set; } = new List<ColumnInfo>();
public List<ColumnInfo> MiddleColumns { get; set; } = new List<ColumnInfo>();
public List<ColumnInfo> RefColumns { get; set; } = new List<ColumnInfo>();
public Exception Exception { get; set; }
}
public enum TableRefType {
OneToOne, ManyToOne, OneToMany, ManyToMany
}
public Exception Exception { get; set; }
}
public enum TableRefType
{
OneToOne, ManyToOne, OneToMany, ManyToMany
}
}

2972
FreeSql/Internal/UtilsExpressionTree.cs
View File

File diff suppressed because it is too large Load Diff