CRLExpression.CRLExpression MethodCallExpressionHandler(Expression exp, ExpressionType?nodeType = null, bool firstLevel = false)
{
#region methodCall
MethodCallExpression mcExp = (MethodCallExpression)exp;
var arguments = new List <object>();
var allArguments = mcExp.Arguments;
int argsIndex = 0;
Expression firstArgs;
bool isLambdaQueryJoinExt = false;
if (mcExp.Method.IsStatic) //区分静态方法还是实例方法
{
firstArgs = allArguments[0]; //like b.Name.IsNull("22")
argsIndex = 1;
if (firstArgs.Type.Name.Contains("LambdaQueryJoin"))
{
isLambdaQueryJoinExt = true;
}
}
else
{
firstArgs = mcExp.Object;//like b.Id.ToString()
}
#region 缓存处理 效率并不高
//MethodCallExpressionCacheItem methodCache;
//string key = "";
//if (SettingConfig.UseLambdaCache&& false)
//{
// key = __PrefixsAllKey + mcExp + nodeType;
// var exists = MethodCallExpressionCache.TryGetValue(key, out methodCache);
// if (exists)
// {
// if (!methodCache.isConstantMethod)
// {
// var methodCall = methodCache.CRLExpression.Data as CRLExpression.MethodCallObj;
// if (methodCall.Args.Count > 0)
// {
// for (int i = argsIndex; i < allArguments.Count; i++)
// {
// bool isConstant1;
// var obj = GetParameExpressionValue(allArguments[i], out isConstant1);
// arguments.Add(obj);
// }
// methodCall.Args = arguments;
// }
// }
// methodCache.CRLExpression.SqlOut = "";
// return methodCache.CRLExpression;
// }
//}
#endregion
#region MethodCallExpression
//bool isConstantMethod = false;
MemberExpression memberExpression;
string methodField = "";
string memberName = "";
string methodName = mcExp.Method.Name;
if (firstArgs is ParameterExpression || isLambdaQueryJoinExt)
{
var exp2 = mcExp.Arguments[1] as UnaryExpression;
var type = exp2.Operand.GetType();
var p = type.GetProperty("Body");
var exp3 = p.GetValue(exp2.Operand, null) as Expression;
methodField = RouteExpressionHandler(exp3).SqlOut;
memberName = "";
}
else if (firstArgs is UnaryExpression)//like a.Code.Count()
{
memberExpression = (firstArgs as UnaryExpression).Operand as MemberExpression;
memberName = memberExpression.Member.Name;
var field = TypeCache.GetProperties(memberExpression.Expression.Type, true)[memberName];
memberName = __DBAdapter.FieldNameFormat(field);
methodField = FormatFieldPrefix(memberExpression.Expression.Type, memberName);
}
else if (firstArgs is BinaryExpression)
{
var be = firstArgs as BinaryExpression;
methodField = BinaryExpressionHandler(be.Left, be.Right, be.NodeType).Data.ToString();
}
else if (firstArgs is MemberExpression)
{
//like a.Code
memberExpression = firstArgs as MemberExpression;
memberName = memberExpression.Member.Name;
var type = memberExpression.Expression.Type;
if (type.IsSubclassOf(typeof(IModel)))
{
var field = TypeCache.GetProperties(type, true)[memberExpression.Member.Name];
memberName = __DBAdapter.FieldNameFormat(field);
}
if (memberExpression.Expression.NodeType == ExpressionType.Parameter)
{
methodField = FormatFieldPrefix(memberExpression.Expression.Type, memberName);
//var allConstant = true;
for (int i = argsIndex; i < allArguments.Count; i++)
{
bool isConstant2;
var obj = GetParameExpressionValue(allArguments[i], out isConstant2);
arguments.Add(obj);
}
}
else
{
//like Convert.ToDateTime(times)
var obj = ConstantValueVisitor.GetParameExpressionValue(firstArgs);
arguments.Add(obj);
for (int i = argsIndex; i < allArguments.Count; i++)
{
bool isConstant2;
var obj2 = GetParameExpressionValue(allArguments[i], out isConstant2);
arguments.Add(obj2);
}
}
}
else if (firstArgs is ConstantExpression)//按常量
{
//like DateTime.Parse("2016-02-11 12:56"),
//isConstantMethod = true;
var obj = ConstantValueVisitor.GetParameExpressionValue(firstArgs);
arguments.Add(obj);
}
//else
//{
// throw new CRLException("不支持此语法解析:" + args);
//}
if (nodeType == null)
{
nodeType = ExpressionType.Equal;
}
if (string.IsNullOrEmpty(methodField))
{
//当是常量转换方法
var method = mcExp.Method;
object obj;
if (mcExp.Method.IsStatic)//like DateTime.Parse("2016-02-11")
{
obj = method.Invoke(null, arguments.ToArray());
}
else//like time.AddDays(1)
{
if (arguments.Count == 0)
{
throw new Exception("未能解析" + exp);
}
var args1 = arguments.First();
arguments.RemoveAt(0);
obj = method.Invoke(args1, arguments.ToArray());
}
var exp2 = new CRLExpression.CRLExpression()
{
Type = CRLExpression.CRLExpressionType.Value, Data = obj
};
//var cache = new MethodCallExpressionCacheItem() { CRLExpression = exp2, argsIndex = argsIndex, isConstantMethod = isConstantMethod, isStatic = mcExp.Method.IsStatic };
//MethodCallExpressionCache[key] = cache;
return(exp2);
}
var methodInfo = new CRLExpression.MethodCallObj()
{
Args = arguments, ExpressionType = nodeType.Value, MemberName = memberName, MethodName = methodName, MemberQueryName = methodField
};
methodInfo.ReturnType = mcExp.Type;
#endregion
var exp4 = new CRLExpression.CRLExpression()
{
Type = CRLExpression.CRLExpressionType.MethodCall, Data = methodInfo
};
//if (SettingConfig.UseLambdaCache && false)
//{
// var cache2 = new MethodCallExpressionCacheItem() { CRLExpression = exp4, argsIndex = argsIndex, isConstantMethod = isConstantMethod };
// MethodCallExpressionCache[key] = cache2;
//}
return(exp4);
#endregion
}
private Expression Comparison()
{
var left = Additive();
while (CurrentTokenKind == QueryExpressionTokenKind.Keyword)
{
var op = (string)TokenData;
ExpressionType?expression = null;
switch (op.ToLowerInvariant())
{
case "eq":
expression = ExpressionType.Equal;
break;
case "ne":
expression = ExpressionType.NotEqual;
break;
case "gt":
expression = ExpressionType.GreaterThan;
break;
case "ge":
expression = ExpressionType.GreaterThanOrEqual;
break;
case "lt":
expression = ExpressionType.LessThan;
break;
case "le":
expression = ExpressionType.LessThanOrEqual;
break;
case "has":
NextToken();
var flag = Expression.Convert(Additive(), typeof(Enum));
left = Expression.Call(null, HasFlagMethodInfo, left, flag);
return(left);
case "in":
NextToken();
var collection = List(left.Type) ?? CommonExpr();
// TODO: cache
left = Expression.Call(null, ContainsMethodInfo.MakeGenericMethod(left.Type), collection, left);
return(left);
}
if (expression == null)
{
break;
}
NextToken();
var right = Additive();
left = Expression.MakeBinary(expression.Value, Promote(left, right), Promote(right, left));
}
return(left);
}
/// <summary>
/// 访问常量
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
protected override Expression VisitConstant(ConstantExpression c)
{
//如果左值是访问成员，类似与p=>p.ID == 1
if (m_left != null && m_left.NodeType == ExpressionType.MemberAccess)
{
//in操作无法参数化，如果value是数组
if (c.Type.IsArray)
{
Array array = (Array)c.Value;
string str = string.Empty;
foreach (var o in array)
{
switch (Type.GetTypeCode(o.GetType()))
{
case TypeCode.Boolean:
str += (bool)o ? "1" : "0";
break;
case TypeCode.DateTime:
str += string.Format("'{0}'", ((DateTime)o).ToString("yyyy-MM-dd HH:mm:ss"));
break;
case TypeCode.String:
case TypeCode.Object: //guid
str += string.Format("'{0}'", o);
break;
default:
str += o.ToString();
break;
}
str += ",";
}
this.Write(str.TrimEnd(','));
}
else
{
this.Write("@p" + m_parameters.Count);
m_parameters.Add(c.Value);
if (c.Value == null) //如果value为null
{
MemberExpression member = (MemberExpression)m_left;
if (m_binaryType.HasValue)
{
switch (m_binaryType)
{
case ExpressionType.Equal:
this.Write(string.Format(" OR [{0}] IS NULL", member.Member.Name));
break;
case ExpressionType.NotEqual:
this.Write(string.Format(" OR [{0}] IS NOT NULL", member.Member.Name));
break;
}
m_binaryType = null;
}
}
}
}
else
{
//如果存在p => true或者p => false
if (c.Value.Equals(true))
{
this.Write("1=1");
}
else if (c.Value.Equals(false))
{
this.Write("1=0");
}
}
//访问完右值之后清空左值
m_left = null;
return(c);
}
public void Add(string leftOperand, ExpressionType optr, string rightOperand, bool isParametized = false, ExpressionType?linkingOperator = null)
{
var unit = new PredicateUnit
{
LeftOperand = leftOperand,
Operator = optr,
RightOperand = rightOperand,
IsRightOperandParameter = isParametized,
LinkingOperator = linkingOperator
};
predicateUnits.Add(unit);
}
internal IQuery <TEntity> Where(string leftOperand, ExpressionType predicateOperator, string rightOperand, bool isParametized = false, ExpressionType?linkingOperator = null)
{
if (this.PredicateParts == null)
{
this.PredicateParts = new PredicateUnits();
}
var parameterName = string.Empty;
if (isParametized)
{
parameterName = this.ParameterNameGenerator.GetNextParameterName("param");
Parameters.Add(parameterName, rightOperand);
this.PredicateParts.Add(leftOperand, predicateOperator, parameterName, isParametized, linkingOperator);
}
else
{
this.PredicateParts.Add(leftOperand, predicateOperator, rightOperand, isParametized, linkingOperator);
}
return(this);
}
protected override Expression VisitConstant(ConstantExpression c)
{
//如果左值是访问成员，类似与p=>p.ID == 1
if (m_left != null && m_left.NodeType == ExpressionType.MemberAccess)
{
if (c.Value == null)
{
this.Write("NULL");
MemberExpression member = (MemberExpression)m_left;
if (m_binaryType.HasValue)
{
switch (m_binaryType)
{
case ExpressionType.Equal:
this.Write(string.Format(" OR [{0}] IS NULL", member.Member.Name));
break;
case ExpressionType.NotEqual:
this.Write(string.Format(" OR [{0}] IS NOT NULL", member.Member.Name));
break;
}
m_binaryType = null;
}
}
else if (c.Type == typeof(DateTime) || c.Type == typeof(Guid))
{
this.Write("'"); //new DateTime(\"
this.Write(c.Value.ToString());
this.Write("'"); //\"
}
else if (c.Type.IsArray) //如果value是数组
{
Array array = (Array)c.Value;
string str = string.Empty;
foreach (var o in array)
{
switch (Type.GetTypeCode(o.GetType()))
{
case TypeCode.Boolean:
str += (bool)o ? "1" : "0";
break;
case TypeCode.DateTime:
str += string.Format("'{0}'", ((DateTime)o).ToString("yyyy-MM-dd HH:mm:ss"));
break;
case TypeCode.String:
case TypeCode.Object:
str += string.Format("'{0}'", o);
break;
default:
str += o.ToString();
break;
}
str += ",";
}
this.Write(str.TrimEnd(','));
}
else
{
switch (Type.GetTypeCode(c.Value.GetType()))
{
case TypeCode.Boolean:
this.Write(((bool)c.Value) ? "1" : "0");
break;
case TypeCode.Single:
case TypeCode.Double:
string str = c.Value.ToString();
if (!str.Contains('.'))
{
str += ".0";
}
this.Write(str);
break;
case TypeCode.DateTime:
this.Write("'"); //new DateTime(\"
this.Write(c.Value.ToString());
this.Write("'"); //\"
break;
case TypeCode.String:
this.Write("'");
this.Write(c.Value.ToString().Replace("'", "\""));
this.Write("'");
break;
default:
this.Write(c.Value.ToString());
break;
}
}
}
else
{
//如果存在p => true或者p => false
if (c.Value.Equals(true))
{
this.Write("1=1");
}
else if (c.Value.Equals(false))
{
this.Write("1=0");
}
}
m_left = null;
return(c);
}
public static IEnumerable <TExpression> GetExpressions <TExpression>(this IEnumerable <Expression> source, ExpressionType?type = null) where TExpression : Expression
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
foreach (var expr in source)
{
var texpr = expr as TExpression;
if (texpr != null && (type == null || texpr.NodeType == type))
{
yield return(texpr);
}
}
}
protected void VisitCallExpression(Expression expression, ExpressionType?parentNodeType = null)
{
var m = (MethodCallExpression)expression;
bool evaluateCall = true;
if (Members != null && Members.Any() && m.Object is MemberExpression)
{
var memberExp = m.Object as MemberExpression;
var rootType = ReflectionHelper.RootTypeForExpression(memberExp);
var like = "LIKE";
var concat = " + ";
if (rootType != null && rootType.Equals(this.Type))
{
if (m.Method.DeclaringType == typeof(string))
{
switch (m.Method.Name)
{
case "StartsWith":
Buffer.Append("(");
this.Visit(m.Object);
Buffer.Append(String.Format(" {0} ", like));
this.Visit(m.Arguments[0]);
Buffer.Append(String.Format(" {0} '%')", concat));
return;
case "EndsWith":
Buffer.Append("(");
this.Visit(m.Object);
Buffer.Append(String.Format(" {0} '%' {1} ", like, concat));
this.Visit(m.Arguments[0]);
Buffer.Append(")");
return;
case "Contains":
Buffer.Append("(");
this.Visit(m.Object);
Buffer.Append(String.Format(" {0} '%' {1} ", like, concat));
this.Visit(m.Arguments[0]);
Buffer.Append(String.Format(" {0} '%')", concat));
return;
case "ToUpper":
Buffer.Append("UPPER(");
this.Visit(m.Object);
Buffer.Append(")");
return;
case "ToLower":
Buffer.Append("LOWER(");
this.Visit(m.Object);
Buffer.Append(")");
return;
case "Replace":
Buffer.Append("REPLACE(");
this.Visit(m.Object);
Buffer.Append(", ");
this.Visit(m.Arguments[0]);
Buffer.Append(", ");
this.Visit(m.Arguments[1]);
Buffer.Append(")");
return;
case "Trim":
Buffer.Append("RTRIM(LTRIM(");
this.Visit(m.Object);
Buffer.Append("))");
return;
}
}
}
else
{
if (m.Arguments.Any())
{
var argumentType = ReflectionHelper.RootTypeForExpression(m.Arguments[0]);
if (ReflectionHelper.HasInterface(m.Method.DeclaringType, typeof(System.Collections.IList)) && argumentType.Equals(this.Type))
{
evaluateCall = false;
switch (m.Method.Name)
{
case "Contains":
Visit(m.Arguments[0]);
Buffer.Append(" IN ");
ListToSet(Evaluate(Reduce(m.Object)) as System.Collections.IList);
break;
}
}
}
}
}
if (evaluateCall)
{
var method = Expression.Call(Reduce(m.Object), m.Method, ReduceArgumentList(m.Arguments)); //rebuilds this into a new
var result = Evaluate(method);
var isDirectBooleanAccess = result is Boolean &&
(parentNodeType == null || (parentNodeType != null && parentNodeType.Value != ExpressionType.Equal && parentNodeType.Value != ExpressionType.NotEqual));
if (isDirectBooleanAccess)
{
WriteLiteralValue(result);
}
else
{
WriteParameter(Evaluate(method));
}
}
}
internal static VBExpressionMetadata CreateMetadata(bool isInMultiline = false, ExpressionType?expressionType = null, bool returnBlock = false) => new VBExpressionMetadata
{
IsInMutiline = isInMultiline,
ExpressionType = expressionType,
ReturnBkock = returnBlock
};
CRLExpression.CRLExpression MemberExpressionHandler(Expression exp, ExpressionType?nodeType = null, bool firstLevel = false)
{
#region MemberExpression
//区分 属性表达带替换符{0} 变量值不带
MemberExpression mExp = (MemberExpression)exp;
if (mExp.Expression != null && mExp.Expression.NodeType == ExpressionType.Parameter) //like b.Name==b.Name1 或b.Name
{
#region MemberParameter
var fieldName = mExp.Member.Name;
var type = mExp.Expression.Type;
if (mExp.Member.ReflectedType.Name.StartsWith("<>f__AnonymousType"))//按匿名类
{
//var queryField = FormatFieldPrefix(type, fieldName);
var exp2 = new CRLExpression.CRLExpression()
{
Type = CRLExpression.CRLExpressionType.Name, Data = fieldName, MemberType = type
};
//MemberExpressionCache[key] = exp2;
return(exp2);
}
CRL.Attribute.FieldAttribute field;
var a = TypeCache.GetProperties(type, true).TryGetValue(fieldName, out field);
if (!a)
{
throw new CRLException("类型 " + type.Name + "." + fieldName + " 未设置Mapping,请检查查询条件");
}
//if (!string.IsNullOrEmpty(field.VirtualField))//按虚拟字段
//{
// //return filed.VirtualField;
// var queryField = field.VirtualField.Replace("{" + type.FullName + "}", Prefixs[type]);//替换前辍
// var exp2 = new CRLExpression.CRLExpression() { Type = CRLExpression.CRLExpressionType.Name, Data = queryField, MemberType = type };
// //MemberExpressionCache[key] = exp2;
// return exp2;
//}
//var fieldStr = FormatFieldPrefix(type, field.MapingName);//格式化为别名
//return field;
if (firstLevel)
{
var exp2 = exp.Equal(Expression.Constant(true));
return(RouteExpressionHandler(exp2));
}
if (field.DefaultCRLExpression != null)
{
var c2 = field.DefaultCRLExpression;
c2.Data = __DBAdapter.FieldNameFormat(field);
return(c2);
}
var fieldStr = __DBAdapter.FieldNameFormat(field);
var exp3 = new CRLExpression.CRLExpression()
{
Type = CRLExpression.CRLExpressionType.Name, Data = fieldStr, MemberType = type
};
field.DefaultCRLExpression = exp3;
return(exp3);
#endregion
}
else
{
//string key = mExp.ToString() + firstLevel;
//CRLExpression.CRLExpression val;
//var a1 = MemberExpressionCache.TryGetValue(key, out val);
//if (a1)
//{
// return val;
//}
#region 值
bool isConstant;
var obj = GetParameExpressionValue(mExp, out isConstant);
if (obj is Enum)
{
obj = (int)obj;
}
else if (obj is Boolean)//sql2000需要转换
{
obj = Convert.ToInt32(obj);
}
var exp4 = new CRLExpression.CRLExpression()
{
Type = CRLExpression.CRLExpressionType.Value, Data = obj, IsConstantValue = isConstant
};
//if (isConstant)
//{
// MemberExpressionCache[key] = exp4;
//}
return(exp4);
#endregion
}
#endregion
}
protected dynamic VisitMember(MemberExpression m, bool columnOnly)
{
if (m.Expression != null && m.Expression.NodeType == ExpressionType.Constant && (_overridedNodeType == null))
{
VisitConstantFixed(m.Expression as ConstantExpression, m.Member?.Name);
return(m);
}
else if (m.Expression != null && m.Expression.NodeType == ExpressionType.Parameter && (_overridedNodeType == null))
{
_overridedNodeType = null;
var cl = m.Expression.Type;
var prop = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(cl).First(x => x.Name == m.Member.Name);
var name = prop.GetPropertyName();
var table = cl.GetCustomAttribute <Table>()?.Name ?? cl.Name;
var columnName = string.Format("[{0}].[{1}]", table, name);
if (columnOnly)
{
return(columnName);
}
sb.Append(columnName);
return(m);
}
else if (m.Expression != null && (m.Expression.NodeType == ExpressionType.MemberAccess))
{
_overridedNodeType = null;
var key = string.Join("", m.ToString().Split('.').Take(m.ToString().Split('.').Length - 1));
var cl = m.Expression.Type;
var prop = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(cl).First(x => x.Name == m.Member.Name);
var name = prop.GetPropertyName();
var table = cl.GetCustomAttribute <Table>()?.Name ?? cl.Name;
var randomTableName = JoinClauses.ContainsKey(key) ? JoinClauses[key].Item1 : RandomKey();
var primaryId = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(cl).First(x => x.ContainAttribute <PrimaryKey>()).GetPropertyName();
var columnName = string.Format("[{0}].[{1}]", randomTableName, name);
if (columnOnly)
{
return(columnName);
}
sb.Append(columnName);
if (JoinClauses.ContainsKey(key))
{
return(m);
}
// Ok lets build inner join
var parentType = (m.Expression as MemberExpression).Expression.Type;
var parentTable = parentType.GetCustomAttribute <Table>()?.Name ?? parentType.Name;
prop = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(parentType).FirstOrDefault(x => x.ContainAttribute <ForeignKey>() && x.GetCustomAttribute <ForeignKey>().Type == cl);
var v = "";
if (prop != null)
{
v += string.Format("LEFT JOIN [{0}] {1} ON [{2}].[{3}] = [{4}].[{5}]", table, randomTableName, randomTableName, primaryId, parentTable, prop.GetPropertyName());
}
else
{
prop = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(cl).FirstOrDefault(x => x.ContainAttribute <ForeignKey>() && x.GetCustomAttribute <ForeignKey>().Type == parentType);
if (prop != null)
{
v += string.Format("LEFT JOIN [{0}] {1} ON [{2}].[{3}] = [{4}].[{5}]", table, randomTableName, randomTableName, prop.GetPropertyName(), parentTable, primaryId);
}
}
JoinClauses.Add(key, new Tuple <string, string>(randomTableName, v));
return(m);
}
else if (m.Expression != null && _overridedNodeType == ExpressionType.MemberAccess)
{
_overridedNodeType = null;
var key = string.Join("", m.ToString().Split('.').Take(m.ToString().Split('.').Length - 1));
var cl = m.Expression.Type;
var prop = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(cl).First(x => x.Name == m.Member.Name);
var table = cl.GetCustomAttribute <Table>()?.Name ?? cl.Name;
var randomTableName = JoinClauses.ContainsKey(key) ? JoinClauses[key].Item1 : RandomKey();
var primaryId = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(cl).First(x => x.ContainAttribute <PrimaryKey>()).GetPropertyName();
if (JoinClauses.ContainsKey(key))
{
return(m);
}
// Ok lets build inner join
var parentType = (m as MemberExpression).Type.GetActualType();
var parentTable = parentType.GetCustomAttribute <Table>()?.Name ?? parentType.Name;
prop = FastDeepCloner.DeepCloner.GetFastDeepClonerProperties(parentType).FirstOrDefault(x => x.ContainAttribute <ForeignKey>() && x.GetCustomAttribute <ForeignKey>().Type == cl);
var v = "";
if (prop != null)
{
v += string.Format("INNER JOIN [{0}] {1} ON [{2}].[{3}] = [{4}].[{5}]", parentTable, randomTableName, table, primaryId, randomTableName, prop.GetPropertyName());
}
else
{
throw new NotSupportedException(string.Format("CLASS STRUCTURE IS NOT SUPPORTED MEMBER{0}", m.Member.Name));
}
if (!string.IsNullOrEmpty(v))
{
JoinClauses.Add(key, new Tuple <string, string>(randomTableName, v));
}
return(m);
}
throw new NotSupportedException(string.Format("The member '{0}' is not supported", m.Member.Name));
}
static Expression ParseTillTerminator(ref TokenParser parser, string terminatorChars,
bool throwOnTerminator,
bool throwOnEnd,
out char?token)
{
ExpressionOperatorGroup left = default;
token = null;
while (true)
{
if (parser.TryConsumeAny(terminatorChars.AsSpan(), out var consumedToken))
{
if (throwOnTerminator || left.Empty)
{
throw new ExpressionParseException($"Unexpected '{token}'", parser.Position - 1);
}
token = consumedToken;
return(left.ToExpression());
}
parser.SkipWhitespace();
if (parser.Length == 0)
{
if (throwOnEnd || left.Empty)
{
throw new ExpressionParseException("Unexpected end of expression", parser.Position);
}
return(left.ToExpression());
}
ExpressionType?op = null;
if (left.NotEmpty)
{
if (parser.TryConsume('?'))
{
var truePart = ParseTillTerminator(ref parser, ":",
false, true, out _);
// pass through the current parsing rules to consume the rest
var falsePart = ParseTillTerminator(ref parser, terminatorChars, throwOnTerminator, throwOnEnd,
out token);
return(new ConditionalExpression(left.ToExpression(), truePart, falsePart));
}
// We expect a binary operator here
if (!TryParseOperator(ref parser, out var sop))
{
throw new ExpressionParseException("Unexpected token", parser.Position);
}
op = sop;
}
// We expect an expression to be parsed (either due to expecting a binary operator or parsing the first part
var applyNegation = false;
while (parser.TryConsume('!'))
{
applyNegation = !applyNegation;
}
var applyUnaryMinus = false;
while (parser.TryConsume('-'))
{
applyUnaryMinus = !applyUnaryMinus;
}
Expression?parsed;
if (parser.TryConsume('('))
{
parsed = ParseTillTerminator(ref parser, ")", false, true, out _);
}
else if (parser.TryParseCall(out var functionName))
{
var parameterList = new List <Expression>();
while (true)
{
parameterList.Add(ParseTillTerminator(ref parser, ",)", false, true, out var closingToken));
if (closingToken == ')')
{
break;
}
if (closingToken != ',')
{
throw new ExpressionParseException("Unexpected end of the expression", parser.Position);
}
}
parsed = new FunctionCallExpression(functionName.ToString(), parameterList);
}
else if (TryParseAtomic(ref parser, out parsed))
{
// do nothing
}
else
{
throw new ExpressionParseException("Unexpected token", parser.Position);
}
// Parse any following member accesses
while (parser.TryConsume('.'))
{
if (!parser.TryParseIdentifier(out var memberName))
{
throw new ExpressionParseException("Unexpected token", parser.Position);
}
parsed = new MemberAccessExpression(parsed, memberName.ToString());
}
// Apply ! operator
if (applyNegation)
{
parsed = new UnaryExpression(parsed, ExpressionType.Not);
}
if (applyUnaryMinus)
{
if (parsed is ConstantExpression constexpr)
{
parsed = new ConstantExpression(-constexpr.Constant);
}
else
{
parsed = new UnaryExpression(parsed, ExpressionType.UnaryMinus);
}
}
if (left.Empty)
{
left.AppendFirst(parsed);
}
else
{
left.AppendWithOperator(parsed, op !.Value);
}
}
}
/// <summary>
/// 根据ExpressionType格式化相应的符号类型
/// </summary>
/// <param name="nodeType"></param>
/// <returns></returns>
internal static string FormatBinaryOperator(ExpressionType?nodeType)
{
ExpressionType valueOrDefault = nodeType.GetValueOrDefault();
if (nodeType.HasValue)
{
if (valueOrDefault <= ExpressionType.LessThanOrEqual)
{
switch (valueOrDefault)
{
case ExpressionType.Add:
case ExpressionType.AddChecked:
return("+");
case ExpressionType.And:
case ExpressionType.AndAlso:
return("AND");
default:
switch (valueOrDefault)
{
case ExpressionType.Divide:
return(" / ");
case ExpressionType.Equal:
return(" = ");
case ExpressionType.GreaterThan:
return(" > ");
case ExpressionType.GreaterThanOrEqual:
return(" >= ");
case ExpressionType.LessThan:
return(" < ");
case ExpressionType.LessThanOrEqual:
return(" <= ");
}
break;
}
}
else
{
switch (valueOrDefault)
{
case ExpressionType.Multiply:
case ExpressionType.MultiplyChecked:
return("*");
default:
switch (valueOrDefault)
{
case ExpressionType.NotEqual:
return("<>");
case ExpressionType.Or:
case ExpressionType.OrElse:
return("OR");
case ExpressionType.Subtract:
case ExpressionType.SubtractChecked:
return("-");
case ExpressionType.Modulo:
return("%");
}
break;
}
}
}
return("" + nodeType);
}
public ExpressionTypeParseRule(ExpressionType?expressionType, Func <Texpression, bool> isApplicable, Func <Texpression, ExpressionParseEventArgs, string> parseFunction)
{
_expressionType = expressionType;
_isApplicable = isApplicable;
_parseFunction = parseFunction;
}
protected override Expression VisitBinary(BinaryExpression node)
{
sb.Append("(");
prev_op = node.NodeType;
var tmp = invert;
this.Visit(node.Left);
switch (node.NodeType)
{
case ExpressionType.AndAlso:
sb.Append(invert ? " OR " : " AND ");
break;
case ExpressionType.OrElse:
sb.Append(invert ? " AND " : " OR ");
break;
case ExpressionType.Equal:
if (IsNullConstant(node.Right))
{
sb.Append(invert ? " IS NOT " : " IS ");
}
else
{
if (boolean)
{
sb.Append(" = ");
}
else
{
sb.Append(invert ? " <> " : " = ");
}
}
break;
case ExpressionType.NotEqual:
if (IsNullConstant(node.Right))
{
sb.Append(invert ? " IS " : " IS NOT ");
}
else
{
if (boolean)
{
sb.Append(" = ");
invert = invert ^ true;
}
else
{
sb.Append(invert ? " = " : " != ");
}
}
break;
case ExpressionType.LessThan:
sb.Append(invert ? " >= " : " < ");
break;
case ExpressionType.LessThanOrEqual:
sb.Append(invert ? " > " : " <= ");
break;
case ExpressionType.GreaterThan:
sb.Append(invert ? " <= " : " > ");
break;
case ExpressionType.GreaterThanOrEqual:
sb.Append(invert ? " < " : " >= ");
break;
default:
throw new NotSupportedException(string.Format("The binary operator '{0}' is not supported", node.NodeType));
}
this.Visit(node.Right);
invert = tmp;
sb.Append(")");
return(node);
}
internal void Deconstruct(out bool isInMultiline, out ExpressionType?expressionType, out bool returnBlock)
{
isInMultiline = IsInMutiline;
expressionType = ExpressionType;
returnBlock = ReturnBkock;
}
public void SetInClause(IEnumerable values)
{
_operator = BinaryConditionItem.InOperator;
_parameters.Add(values);
}
protected Expression VisitBinary_Bak(BinaryExpression b)
{
this.Write("(");
if (b.NodeType == ExpressionType.Power)
{
this.Write("POWER(");
this.VisitValue(b.Left);
this.Write(", ");
this.VisitValue(b.Right);
this.Write(")");
// return b;
}
else if (b.NodeType == ExpressionType.Coalesce)
{
this.Write("COALESCE(");
this.VisitValue(b.Left);
this.Write(", ");
Expression right = b.Right;
while (right.NodeType == ExpressionType.Coalesce)
{
BinaryExpression rb = (BinaryExpression)right;
this.VisitValue(rb.Left);
this.Write(", ");
right = rb.Right;
}
this.VisitValue(right);
this.Write(")");
// return b;
}
else if (b.NodeType == ExpressionType.LeftShift)
{
this.Write("(");
this.VisitValue(b.Left);
this.Write(" * POWER(2, ");
this.VisitValue(b.Right);
this.Write("))");
// return b;
}
else if (b.NodeType == ExpressionType.RightShift)
{
this.Write("(");
this.VisitValue(b.Left);
this.Write(" / POWER(2, ");
this.VisitValue(b.Right);
this.Write("))");
//return b;
}
else
{
//if (b.Left is MemberExpression)
//{
// if (((MemberExpression)b.Left).Type == typeof(bool) && (bizRead == BizExpSqlType.bizWhere))
// {
// this.Write("(" + ((MemberExpression)b.Left).Member.Name + " = 1)");
// }
// else
// {
// this.Visit(b.Left);
// }
//}
//else
//{
this.Visit(b.Left);
//}
this.Write(" ");
this.Write(GetOperator(b.NodeType));
m_binaryType = b.NodeType;
this.Write(" ");
this.Visit(b.Right);
}
this.Write(")");
return(b);
}
