string DealParame(string par, string typeStr, out string typeStr2)
{
typeStr2 = typeStr;
//字段会返回替换符
bool needPar = par.IndexOf("{") <= -1;//是否需要参数化处理
if (!needPar)
{
par = par.Replace("{VirtualField}", "");
return(par);
}
if (needPar)
{
if (par.ToUpper() == "NULL")
{
typeStr2 = "";
if (typeStr == "=")
{
par = " IS NULL ";
}
else if (typeStr == "<>")
{
par = " IS NOT NULL ";
}
}
else
{
QueryParames.Add("parame" + parIndex, par);
par = "@parame" + parIndex;
parIndex += 1;
}
}
return(par);
}
public CRLExpression.CRLExpression DealParame(CRLExpression.CRLExpression par1, string typeStr, out string typeStr2)
{
var par = par1.Data + "";
typeStr2 = typeStr;
//todo 非关系型数据库不参数化
if (dbContext.DataBaseArchitecture == DataBaseArchitecture.NotRelation)
{
return(par1);
}
if (par1.Data is CRLExpression.MethodCallObj)
{
var method = par1.Data as CRLExpression.MethodCallObj;
var _DBAdapter = DBAdapter.DBAdapterBase.GetDBAdapterBase(dbContext);
var dic = MethodAnalyze.GetMethos(_DBAdapter);
if (!dic.ContainsKey(method.MethodName))
{
throw new CRLException("LambdaQuery不支持方法" + method.MethodName);
}
int newParIndex = parIndex;
par = dic[method.MethodName](method, ref newParIndex, AddParame);
parIndex = newParIndex;
}
//字段会返回替换符
bool needPar = par1.Type == CRLExpression.CRLExpressionType.Value;//是否需要参数化处理
if (!needPar)
{
par1.Data = par;
return(par1);
}
if (needPar)
{
if (par.ToUpper() == "NULL")
{
typeStr2 = "";
if (typeStr == "=")
{
par = " IS NULL ";
}
else if (typeStr == "<>")
{
par = " IS NOT NULL ";
}
}
else
{
QueryParames.Add("par" + parIndex, par);
par = "@par" + parIndex;
parIndex += 1;
}
}
par1.Data = par;
return(par1);
}
public override int Update <TModel>(List <TModel> objs)
{
if (!objs.Any())
{
return(0);
}
var table = TypeCache.GetTable(typeof(TModel));
var primaryKey = table.PrimaryKey;
int index = 0;
var db = GetDBHelper();
var sb = new StringBuilder();
foreach (var obj in objs)
{
var c = GetUpdateField(obj);
if (c.Count == 0)
{
continue;
}
var c2 = new ParameCollection();
foreach (var kv in c)
{
var a = table.FieldsDic.TryGetValue(kv.Key, out var field);
var key = kv.Key;
var val = kv.Value;
if (a)
{
key = field.MapingName;
}
c2.Add(key, val);
}
index += 1;
var keyValue = primaryKey.GetValue(obj);
var keyParme = _DBAdapter.GetParamName(primaryKey.MapingName, index);
var where = $" where {_DBAdapter.KeyWordFormat(primaryKey.MapingName)}={keyParme}";
db.AddParam(keyParme, keyValue);
var setString = string.Join(",", c2.Select(b => string.Format("{0}='{1}'", _DBAdapter.KeyWordFormat(b.Key), b.Value)));
string sql = _DBAdapter.GetUpdateSql(table.TableName, setString, where);
sb.AppendLine(sql + ";");
if (sb.Length > MaxSqlLength)
{
db.Execute(sb.ToString());
sb.Clear();
}
}
if (sb.Length > 1)
{
db.Execute(sb.ToString());
}
return(objs.Count);
}
public string BinaryExpressionHandler(Expression left, Expression right, ExpressionType type)
{
StringBuilder sb = new StringBuilder();
sb.Append("(");
string needParKey = "=,>,<,>=,<=,<>";
string leftPar = RouteExpressionHandler(left);//like {0}id{1}
string typeStr = ExpressionTypeCast(type);
var isRight = needParKey.IndexOf(typeStr) > -1;
string rightPar = RouteExpressionHandler(right, isRight);
//按运算符判断
bool or = leftPar.IndexOf('&') > -1 || leftPar.IndexOf('|') > -1 || rightPar.IndexOf('&') > -1 || rightPar.IndexOf('|') > -1;
isRight = needParKey.IndexOf(typeStr) > -1 && !or;
string appendLeft = leftPar;
if (left is MemberExpression)//处理虚拟字段条件
{
var fieldName = string.Format(leftPar, "", "");
var filed = TypeCache.GetProperties(typeof(T), true)[fieldName];
if (filed == null)
{
throw new Exception("找不到字段 " + typeof(T).Name + " " + fieldName);
}
if (!string.IsNullOrEmpty(filed.VirtualField))
{
appendLeft = filed.VirtualField;
}
}
sb.Append(appendLeft);//字段名称
var isRightFiled = rightPar.StartsWith("{FIELD}");
//需要作参数处理
if (isRight && !isRightFiled)
{
//去掉替换符
string value = string.Format(rightPar, "");
if (value.ToLower() == "true" || value.ToLower() == "false")
{
value = value.ToLower() == "true" ? "1" : "0";
}
//参数加上前辍
//QueryParames.Add(string.Format(leftPar, "", parIndex.ToString()), value);
QueryParames.Add("parame" + parIndex, value);
}
if (rightPar.ToUpper() == "NULL")
{
if (typeStr == "=")
{
rightPar = " IS NULL ";
}
else if (typeStr == "<>")
{
rightPar = " IS NOT NULL ";
}
}
else
{
sb.Append(typeStr);
if (isRight)
{
if (isRightFiled)
{
rightPar = rightPar.Replace("{FIELD}", "{0}");
}
else
{
//参数加上前辍
//rightPar = "@" + string.Format(leftPar,"", parIndex.ToString());
rightPar = "@parame" + parIndex;
}
}
}
parIndex += 1;
sb.Append(rightPar);
sb.Append(")");
return(sb.ToString());
}
/// <summary>
/// 解析选择的字段
/// </summary>
/// <param name="isSelect">查询字段时按属性名生成别名</param>
/// <param name="expressionBody"></param>
/// <param name="withTablePrefix">是否生按表生成前辍,关联时用 如Table__Name</param>
/// <param name="types"></param>
/// <returns></returns>
SelectFieldInfo _GetSelectField(bool isSelect, Expression expressionBody, bool withTablePrefix, params Type[] types)
{
var allFields = new Dictionary <Type, IgnoreCaseDictionary <Attribute.FieldAttribute> >();
allFields.Add(__MainType, TypeCache.GetProperties(__MainType, true));
foreach (var t in types)
{
if (!allFields.ContainsKey(t))
{
allFields.Add(t, TypeCache.GetProperties(t, true));
}
}
List <Attribute.FieldAttribute> resultFields = new List <Attribute.FieldAttribute>();
if (expressionBody is ParameterExpression)//选择所有字段
{
foreach (var item in allFields[expressionBody.Type].Values)
{
var item2 = item.Clone();
item2.SetFieldQueryScript2(__DBAdapter, GetPrefix(item2.ModelType), false, "");
resultFields.Add(item2);
}
var selectFieldItem = new SelectFieldInfo(resultFields, new ParameCollection(), GetQueryFieldsString(resultFields));
return(selectFieldItem);
}
else if (expressionBody is NewExpression)//按匿名对象
{
#region 匿名对象
var newExpression = expressionBody as NewExpression;
for (int i = 0; i < newExpression.Arguments.Count(); i++)
{
var item = newExpression.Arguments[i];
var memberName = newExpression.Members[i].Name;
if (item is MethodCallExpression)//group用
{
var methodCallExpression = item as MethodCallExpression;
string methodMember;
var methodQuery = getSelectMethodCall(methodCallExpression, out methodMember, i);
var f = new Attribute.FieldAttribute()
{
ModelType = __MainType
};
f.SetFieldQueryScript2(__DBAdapter, "", withTablePrefix, memberName, methodQuery);
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = memberName, FieldName = methodMember, MethodName = methodCallExpression.Method.Name
};
resultFields.Add(f);
}
else if (item is BinaryExpression)
{
var field = getSeletctBinary(item);
var f = new Attribute.FieldAttribute()
{
ModelType = __MainType
};
f.SetFieldQueryScript2(__DBAdapter, "", withTablePrefix, memberName, field);
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = memberName, FieldName = field, MethodName = ""
};
resultFields.Add(f);
}
else if (item is ConstantExpression)//常量
{
var constantExpression = item as ConstantExpression;
var f = new Attribute.FieldAttribute()
{
ModelType = __MainType
};
var value = constantExpression.Value + "";
if (!value.IsNumber())
{
value = string.Format("'{0}'", value);
}
f.SetFieldQueryScript2(__DBAdapter, "", withTablePrefix, memberName, value);
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = memberName, FieldName = value, MethodName = ""
};
resultFields.Add(f);
}
else if (item is MemberExpression)
{
var memberExpression = item as MemberExpression;//转换为属性访问表达式
if (memberExpression.Expression.NodeType == ExpressionType.Constant)
{
string parName = "@par" + i;
newExpressionParame.Add(parName, i);
var obj = ConstantValueVisitor.GetParameExpressionValue(item);
var f2 = new Attribute.FieldAttribute()
{
ModelType = __MainType
};
f2.SetFieldQueryScript2(__DBAdapter, "", withTablePrefix, memberName, parName);
f2.FieldQuery = new Attribute.FieldQuery()
{
MemberName = memberName, FieldName = parName, MethodName = ""
};
resultFields.Add(f2);
__Visitor.AddParame(parName, obj);
continue;
}
else if (memberExpression.Member.ReflectedType.Name.StartsWith("<>f__AnonymousType"))
{
//按匿名对象属性,视图关联时用
var f2 = new Attribute.FieldAttribute()
{
MemberName = memberExpression.Member.Name
};
f2.SetFieldQueryScript2(__DBAdapter, GetPrefix(memberExpression.Expression.Type), withTablePrefix, memberName);
resultFields.Add(f2);
continue;
}
//按属性
if (!allFields[memberExpression.Expression.Type].ContainsKey(memberExpression.Member.Name))
{
throw new CRLException("找不到可筛选的属性" + memberExpression.Member.Name + " 在" + memberExpression.Expression.Type);
}
var f = allFields[memberExpression.Expression.Type][memberExpression.Member.Name].Clone();
if (memberName != memberExpression.Member.Name)//按有别名算
{
f.SetFieldQueryScript2(__DBAdapter, GetPrefix(f.ModelType), withTablePrefix, memberName);
}
else
{
//字段名和属性名不一样时才生成别名
//todo 属性别名不一样时,查询应返回属性名
string fieldName = "";
if (isSelect)//查询字段时按属性名生成别名
{
if (!string.IsNullOrEmpty(f.MapingName))
{
fieldName = f.MemberName;
}
}
f.SetFieldQueryScript2(__DBAdapter, GetPrefix(f.ModelType), withTablePrefix, fieldName);
}
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = memberName, FieldName = f.MapingName, MethodName = ""
};
resultFields.Add(f);
}
else
{
throw new CRLException("不支持此语法解析:" + item);
}
}
#endregion
var selectFieldItem = new SelectFieldInfo(resultFields, newExpressionParame, GetQueryFieldsString(resultFields));
return(selectFieldItem);
}
else if (expressionBody is MethodCallExpression)
{
#region 方法
var method = expressionBody as MethodCallExpression;
var f = new Attribute.FieldAttribute()
{
ModelType = __MainType
};
string methodMember;
var methodQuery = getSelectMethodCall(expressionBody, out methodMember, 0);
f.SetFieldQueryScript2(__DBAdapter, "", withTablePrefix, "", methodQuery);
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = methodMember, FieldName = methodMember, MethodName = method.Method.Name
};
resultFields.Add(f);
#endregion
var selectFieldItem = new SelectFieldInfo(resultFields, newExpressionParame, GetQueryFieldsString(resultFields));
return(selectFieldItem);
}
else if (expressionBody is BinaryExpression)
{
var field = getSeletctBinary(expressionBody);
var f = new Attribute.FieldAttribute()
{
ModelType = __MainType
};
f.SetFieldQueryScript2(__DBAdapter, "", withTablePrefix, "", field);
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = f.MemberName, FieldName = field, MethodName = ""
};
resultFields.Add(f);
var selectFieldItem = new SelectFieldInfo(resultFields, new ParameCollection(), GetQueryFieldsString(resultFields));
return(selectFieldItem);
}
else if (expressionBody is ConstantExpression)
{
var constant = (ConstantExpression)expressionBody;
var f = new Attribute.FieldAttribute()
{
ModelType = __MainType
};
f.SetFieldQueryScript2(__DBAdapter, "", withTablePrefix, "", constant.Value + "");
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = f.MemberName, FieldName = constant.Value + "", MethodName = ""
};
resultFields.Add(f);
var selectFieldItem = new SelectFieldInfo(resultFields, new ParameCollection(), GetQueryFieldsString(resultFields));
return(selectFieldItem);
}
else if (expressionBody is UnaryExpression)
{
var unaryExpression = expressionBody as UnaryExpression;
return(_GetSelectField(false, unaryExpression.Operand, withTablePrefix, types));
}
else if (expressionBody is MemberExpression)//按成员
{
#region MemberExpression
var mExp = (MemberExpression)expressionBody;
if (mExp.Expression.Type.BaseType == typeof(object))
{
//按匿名对象属性,视图关联时用
var f2 = new Attribute.FieldAttribute()
{
MemberName = mExp.Member.Name
};
f2.SetFieldQueryScript2(__DBAdapter, GetPrefix(mExp.Expression.Type), withTablePrefix, mExp.Member.Name);
resultFields.Add(f2);
return(new SelectFieldInfo(resultFields, new ParameCollection(), GetQueryFieldsString(resultFields)));
}
if (!allFields[mExp.Expression.Type].ContainsKey(mExp.Member.Name))
{
throw new CRLException("找不到可筛选的属性" + mExp.Member.Name + " 在" + mExp.Expression.Type);
}
var f = allFields[mExp.Expression.Type][mExp.Member.Name].Clone();
f.SetFieldQueryScript2(__DBAdapter, GetPrefix(f.ModelType), withTablePrefix, "");
f.FieldQuery = new Attribute.FieldQuery()
{
MemberName = f.MemberName, FieldName = f.MapingName, MethodName = ""
};
resultFields.Add(f);
return(new SelectFieldInfo(resultFields, new ParameCollection(), GetQueryFieldsString(resultFields)));
#endregion
}
else
{
throw new CRLException("不支持此语法解析:" + expressionBody);
}
}
