public BaseExpressionVisitor(IProviderOption providerOption)
{
SpliceField = new StringBuilder();
this.FieldList = new List <string>();
this.Param = new DynamicParameters();
this.providerOption = providerOption;
}
public BaseExpressionVisitor(SqlProvider provider)
{
SpliceField = new StringBuilder();
this.Param = new DynamicParameters();
this.Provider = provider;
this.providerOption = provider.ProviderOption;
}
/// <inheritdoc />
/// <summary>
/// 执行解析
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public UpdateExpression(LambdaExpression expression, IProviderOption providerOption) : base(providerOption)
{
this._sqlCmd = new StringBuilder(100);
this.Param = new DynamicParameters();
this.providerOption = providerOption;
//update不需要重命名
providerOption.IsAsName = false;
//当前定义的查询返回对象
this.entity = EntityCache.QueryEntity(expression.Body.Type);
//字段数组
string[] fieldArr = ((MemberInitExpression)expression.Body).Bindings.AsList().Select(x => entity.FieldPairs[x.Member.Name]).ToArray();
//开始解析对象
Visit(expression);
//开始拼接成查询字段
for (var i = 0; i < fieldArr.Length; i++)
{
if (_sqlCmd.Length != 0)
{
_sqlCmd.Append(",");
}
string field = fieldArr[i];
var ParamName = base.FieldList[i];
_sqlCmd.Append($"{providerOption.CombineFieldName(field)}={ParamName}");
}
this.Param.AddDynamicParams(base.Param);
_sqlCmd.Insert(0, " SET ");
}
/// <summary>
/// 写入导航属性到实体(单条)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="dbCon"></param>
/// <returns></returns>
private static T SetNavigation <T>(this T data, IDbConnection dbCon, IProviderOption providerOption)
{
if (providerOption.NavigationList.Any())
{
//写入值方法
var setValueMethod = typeof(MapperExtension).GetMethod("SetValue");
foreach (var navigation in providerOption.NavigationList)
{
var navigationExpression = new NavigationExpression(navigation.MemberAssign.Expression);
//根据得知的映射列表获取条件值
foreach (var mapp in providerOption.MappingList)
{
//根据映射的键设置实际的值
if (navigationExpression.SqlCmd.IndexOf($"= {mapp.Key}") != -1)
{
string param = $"{providerOption.ParameterPrefix}{mapp.Value}";
navigationExpression.SqlCmd = navigationExpression.SqlCmd.Replace($"= {mapp.Key}", $"= {param}");
//获取实体类的值
object paramValue = EntityCache.QueryEntity(typeof(T)).Properties.FirstOrDefault(x => x.Name == mapp.Value).GetValue(data);
navigationExpression.Param.Add(param, paramValue);
}
}
setValueMethod
.MakeGenericMethod(new Type[] { typeof(T), navigationExpression.ReturnType })
.Invoke(null, new object[] { data, dbCon, navigationExpression.SqlCmd, navigationExpression.Param, navigation.MemberAssignName });
}
}
return(data);
}
public BaseExpressionVisitor(IProviderOption providerOption, bool IsAsName = true)
{
this.FieldList = new List <string>();
this.Param = new DynamicParameters();
this.providerOption = providerOption;
this.IsAsName = IsAsName;
}
/// <summary>
/// 解析条件对象
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="prefix">参数标记</param>
/// <param name="providerOption"></param>
public WhereExpression(LambdaExpression expression, string prefix, IProviderOption providerOption, bool IsAsName = true) : base(providerOption, IsAsName)
{
this._sqlCmd = new StringBuilder(100);
this.Param = new DynamicParameters();
this.providerOption = providerOption;
//开始解析对象
Visit(expression);
//开始拼接成条件
this._sqlCmd.Append(base.SpliceField);
this.SqlCmd = " AND " + this._sqlCmd.ToString();
if (string.IsNullOrEmpty(prefix))
{
this.Param.AddDynamicParams(base.Param);
}
else
{
//加上参数标记
foreach (var paramName in base.Param.ParameterNames)
{
string newName = paramName + prefix;
object value = this.Param.Get <object>(paramName);
this.SqlCmd = this.SqlCmd.Replace(paramName, newName);
this.Param.Add(newName, value);
}
}
}
public GroupExpression(LambdaExpression expression, string prefix, IProviderOption providerOption) : base(providerOption)
{
this._sqlCmd = new StringBuilder(100);
this.Param = new DynamicParameters();
this.providerOption = providerOption;
//当前定义的查询返回对象
this.entity = EntityCache.QueryEntity(expression.Body.Type);
//执行解析
Visit(expression);
//分组指定字段
if (base.FieldList.Any())
{
//开始拼接成分组字段
for (var i = 0; i < base.FieldList.Count; i++)
{
if (_sqlCmd.Length != 0)
{
_sqlCmd.Append(",");
}
_sqlCmd.Append(base.FieldList[i]);
}
}
else
{
_sqlCmd.Append(base.SpliceField);
}
}
/// <summary>
/// 获取asname
/// </summary>
/// <param name="IsAsName"></param>
/// <returns></returns>
public string GetAsName(IProviderOption providerOption, bool IsAsName = true, bool IsSuffix = true)
{
string asName = string.Empty;
if (IsAsName)
{
asName = this.AsName;
//如果没有as name，则需要给表带上标记
if (asName.Equals(this.Name))
{
asName = providerOption.CombineFieldName(asName);
}
//是否需要后缀
if (IsSuffix)
{
asName += ".";
}
}
return(asName);
}
/// <inheritdoc />
/// <summary>
/// 执行解析
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public UpdateExpression(LambdaExpression expression, IProviderOption providerOption) : base(providerOption, false)
{
this._sqlCmd = new StringBuilder(100);
this.Param = new DynamicParameters();
this.providerOption = providerOption;
//当前定义的查询返回对象
this.entity = EntityCache.QueryEntity(expression.Body.Type);
//字段数组
string[] fieldArr = ((MemberInitExpression)expression.Body).Bindings.AsList().Select(x => entity.FieldPairs[x.Member.Name]).ToArray();
//开始解析对象
Visit(expression);
//开始拼接成查询字段
for (var i = 0; i < fieldArr.Length; i++)
{
if (_sqlCmd.Length != 0)
{
_sqlCmd.Append(",");
}
string field = fieldArr[i];
string value = base.FieldList[i];
//判断是不是包含字段的值，如果是就不放入Param中
if (value.Contains(entity.AsName) || value == providerOption.GetDate())
{
_sqlCmd.Append(field + "=" + value);
}
else
{
var ParamName = $"UPDATE_{field}_{i}";
_sqlCmd.Append($"{providerOption.CombineFieldName(field)}={providerOption.ParameterPrefix + ParamName}");
Param.Add(ParamName, value == "NULL" ? null : value);
}
}
//加入条件参数
Param.AddDynamicParams(base.Param);
_sqlCmd.Insert(0, " SET ");
}
public static List <T> Query_1 <T>(this IDbConnection conn, string sql, IProviderOption providerOption, object param = null, IDbTransaction transaction = null)
{
return(QueryRowImpl <T>(conn, sql, param, transaction).SetNavigationList(conn, providerOption));
}
/// <summary>
/// 只用来查询返回匿名对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connection"></param>
/// <returns></returns>
public static T QueryFirst_1 <T>(this IDbConnection conn, string sql, IProviderOption providerOption, object param = null, IDbTransaction transaction = null)
{
return(QueryRowImpl <T>(conn, sql, param, transaction).FirstOrDefault().SetNavigation(conn, providerOption));
}
/// <summary>
/// 写入导航属性到实体(列表)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="DbCon"></param>
/// <returns></returns>
private static List <T> SetNavigationList <T>(this List <T> data, IDbConnection dbCon, IProviderOption providerOption)
{
if (providerOption.NavigationList.Any())
{
var setListMethod = typeof(MapperExtension).GetMethod("SetListValue");
foreach (var navigation in providerOption.NavigationList)
{
StringBuilder sqlBuilder = new StringBuilder();
var navigationExpression = new NavigationExpression(navigation.MemberAssign.Expression);
//参数数
int paramCount = 0;
//根据得知的映射列表获取条件值
foreach (var mapp in providerOption.MappingList)
{
//根据映射的键设置实际的值
if (navigationExpression.SqlCmd.IndexOf($"= {mapp.Key}") != -1)
{
foreach (var item in data)
{
string param = $"{providerOption.ParameterPrefix}{mapp.Value}_{paramCount++}";
sqlBuilder.Append(navigationExpression.SqlCmd.Replace($"= {mapp.Key}", $"= {param}") + $";{Environment.NewLine}");
//获取实体类的值
object paramValue = EntityCache.QueryEntity(typeof(T)).Properties.FirstOrDefault(x => x.Name == mapp.Value).GetValue(item);
navigationExpression.Param.Add(param, paramValue);
}
}
}
setListMethod
.MakeGenericMethod(new Type[] { typeof(T), navigationExpression.ReturnType })
.Invoke(null, new object[] { data, dbCon, sqlBuilder.ToString(), navigationExpression.Param,
navigation.MemberAssignName });
}
}
return(data);
}
public ResolveExpression(IProviderOption providerOption) : base(providerOption)
{
}
/// <summary>
/// 列表返回
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="DbCon"></param>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static IEnumerable <T> Querys <T>(this IDbConnection DbCon, string sql, object param, IDbTransaction transaction, IProviderOption providerOption)
{
return(DbCon.Query <T>(sql, param, transaction));
}
/// <summary>
/// 单个返回
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="DbCon"></param>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static T QueryFirstOrDefaults <T>(this IDbConnection DbCon, string sql, object param, IDbTransaction transaction, IProviderOption providerOption)
{
return(DbCon.QueryFirstOrDefault <T>(sql, param, transaction));
}
/// <summary>
/// 执行解析
/// </summary>
/// <param name="expression"></param>
/// <param name="prefix">字段前缀</param>
/// <param name="providerOption"></param>
public SelectExpression(LambdaExpression expression, string prefix, IProviderOption providerOption) : base(providerOption)
{
this._sqlCmd = new StringBuilder(100);
this.Param = new DynamicParameters();
this.providerOption = providerOption;
//当前定义的查询返回对象
this.entity = EntityCache.QueryEntity(expression.Body.Type);
//字段数组
string[] fieldArr;
//判断是不是实体类
if (expression.Body is MemberInitExpression)
{
var bingings = ((MemberInitExpression)expression.Body).Bindings;
List <string> fieldList = new List <string>();
foreach (var bind in bingings)
{
if (bind is MemberAssignment)
{
//必须存在实体类中
if (entity.FieldPairs.Any(x => x.Key.Equals(bind.Member.Name)))
{
var assignment = (bind as MemberAssignment);
//判断是列表还是不是系统函数
if (assignment.Expression.Type.FullName.Contains("System.Collections.Generic.List") ||
assignment.Expression.Type.BaseType.FullName.Contains("Kogel.Dapper.Extension.IBaseEntity"))
{
providerOption.NavigationList.Add(new NavigationMemberAssign()
{
MemberAssign = assignment,
MemberAssignName = bind.Member.Name
});
}
else
{
fieldList.Add(entity.FieldPairs[bind.Member.Name]);
}
}
}
}
fieldArr = fieldList.ToArray();
}
else//匿名类（暂时不支持子导航属性查询）
{
//List<string> fieldList = new List<string>();
//var bingings = expression.Body as NewExpression;
// //Expression.Lambda
//for (var i = 0; i < bingings.Arguments.Count; i++)
//{
// var bind = bingings.Arguments[i];
// //判断是列表还是不是系统函数
// if (bind.Type.FullName.Contains("System.Collections.Generic.List") || bind.Type.Namespace != "System")
// {
// //providerOption.NavigationList.Add(new NavigationMemberAssign()
// //{
// // MemberAssign = bind,
// // MemberAssignName = bind.Member.Name
// //});
// }
// else
// {
// //fieldList.Add(entity.FieldPairs[bind.Member.Name]);
// }
//}
fieldArr = entity.Properties.Select(x => x.Name).ToArray();
}
//开始解析对象
Visit(expression);
if (!expression.Body.NodeType.Equals(ExpressionType.MemberAccess))
{
//开始拼接成查询字段
for (var i = 0; i < fieldArr.Length; i++)
{
if (i < base.FieldList.Count)
{
if (_sqlCmd.Length != 0)
{
_sqlCmd.Append(",");
}
_sqlCmd.Append(base.FieldList[i] + " as " + fieldArr[i]);
//记录隐射对象
providerOption.MappingList.Add(base.FieldList[i], fieldArr[i]);
}
}
}
else
{
//单个字段返回
_sqlCmd.Append(base.FieldList[0]);
}
this.Param.AddDynamicParams(base.Param);
}
