private static void PrintNode(BinaryExpression expression, int indent) { PrintNode(expression.Left, indent + 1); PrintSingle(expression, indent); PrintNode(expression.Right, indent + 1); }
static NSLayoutConstraint CompileConstraint(BinaryExpression expr, UIView constrainedView) { var rel = NSLayoutRelation.Equal; switch (expr.NodeType) { case ExpressionType.Equal: rel = NSLayoutRelation.Equal; break; case ExpressionType.LessThanOrEqual: rel = NSLayoutRelation.LessThanOrEqual; break; case ExpressionType.GreaterThanOrEqual: rel = NSLayoutRelation.GreaterThanOrEqual; break; default: throw new NotSupportedException("Not a valid relationship for a constrain."); } var left = GetViewAndAttribute(expr.Left); if (left.Item1 != constrainedView) { left.Item1.TranslatesAutoresizingMaskIntoConstraints = false; } var right = GetRight(expr.Right); return NSLayoutConstraint.Create( left.Item1, left.Item2, rel, right.Item1, right.Item2, right.Item3, right.Item4); }
public ContainmentWhereFragment(ISerializer serializer, BinaryExpression binary) { _serializer = serializer; var visitor = new FindMembers(); visitor.Visit(binary.Left); var members = visitor.Members; if (members.Count > 1) { var dict = new Dictionary<string, object>(); var member = members.Last(); var value = MartenExpressionParser.Value(binary.Right); dict.Add(member.Name, value); members.Reverse().Skip(1).Each(m => { dict = new Dictionary<string, object> { { m.Name, dict}}; }); _dictionary = dict; } else { _dictionary = new Dictionary<string, object>(); var member = members.Single(); var value = MartenExpressionParser.Value(binary.Right); _dictionary.Add(member.Name, value); } }
protected override Expression VisitBinary(BinaryExpression node) { switch(node.NodeType) { case ExpressionType.Equal: case ExpressionType.NotEqual: if(_model.IsEntity(node.Left.Type) || _model.IsEntity(node.Right.Type)) { //visit children and replace with EntitiesEqual var newLeft = Visit(node.Left); var newRight = Visit(node.Right); var method = node.NodeType == ExpressionType.Equal ? EntityCacheHelper.EntitiesEqualMethod : EntityCacheHelper.EntitiesNotEqualMethod; return Expression.Call(null, method, newLeft, newRight); }//if // compare both args, to cover expr like 'p.Name == null' if (node.Left.Type == typeof(string) && node.Right.Type == typeof(string) && _caseMode == StringCaseMode.CaseInsensitive) { var baseLeft = base.Visit(node.Left); var baseRight = base.Visit(node.Right); Expression result = Expression.Call(EntityCacheHelper.StringStaticEquals3Method, baseLeft, baseRight, EntityCacheHelper.ConstInvariantCultureIgnoreCase); if (node.NodeType == ExpressionType.NotEqual) result = Expression.Not(result); return result; } break; }//switch return base.VisitBinary(node); }
protected override Expression VisitBinary(BinaryExpression binaryExpression) { if (binaryExpression.NodeType == ExpressionType.Or || binaryExpression.NodeType == ExpressionType.And || binaryExpression.NodeType == ExpressionType.OrElse || binaryExpression.NodeType == ExpressionType.AndAlso && binaryExpression.Type.GetUnwrappedNullableType() == typeof(bool)) { var left = this.Visit(binaryExpression.Left); var right = this.Visit(binaryExpression.Right); if (left.Type.GetUnwrappedNullableType() == typeof(bool) && (left is BitBooleanExpression)) { left = Expression.Equal(left, Expression.Constant(true)); } if (right.Type.GetUnwrappedNullableType() == typeof(bool) && (right is BitBooleanExpression)) { right = Expression.Equal(right, Expression.Constant(false)); } if (left != binaryExpression.Left || right != binaryExpression.Right) { return Expression.MakeBinary(binaryExpression.NodeType, left, right); } } return base.VisitBinary(binaryExpression); }
protected override Expression VisitBinary(BinaryExpression binaryExpression) { using (this.AcquireDisableCompareContext()) { return base.VisitBinary(binaryExpression); } }
protected override Expression VisitBinary(BinaryExpression binaryExpr) { ResourceProperty resourceProperty = null; object obj = null; if (!ExpressionHelper.ContainsComparisonOperator(binaryExpr)) { if (!ExpressionHelper.ContainsLogicalOperator(binaryExpr)) { this.IsCompleteExpressionParsed = false; } } else { if (!ExpressionHelper.GetPropertyNameAndValue(binaryExpr, out resourceProperty, out obj)) { TraceHelper.Current.DebugMessage("Expression is too complex to execute"); this.IsCompleteExpressionParsed = false; } else { this.FilterProperties.Add(new KeyValuePair<ResourceProperty, object>(resourceProperty, obj)); } } return base.VisitBinary(binaryExpr); }
protected override Expression VisitBinary(BinaryExpression node) { if (node == null) { throw new ArgumentNullException("node"); } var allowedProperties = new[] { "Project", "Definition", "Number", "Reason", "Quality", "Status", "RequestedBy", "RequestedFor", "StartTime", "FinishTime", "BuildFinished" }; if (node.NodeType == ExpressionType.OrElse) { throw new NotSupportedException("Logical OR operators are not supported for Build Custom filters"); } if (node.Left is MemberExpression && node.Right is ConstantExpression) { var fieldName = (node.Left as MemberExpression).Member.Name; var value = (node.Right as ConstantExpression).Value; if (!allowedProperties.ToList().Contains(fieldName)) { throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "You can only filter by the following properties: {0}. (e.g. /Builds/$filter=Number gt 100 and Quality eq 'Healthy') ", string.Join(", ", allowedProperties))); } this.AddFilterNode(fieldName, value, FilterNode.ParseFilterExpressionType(node.NodeType), FilterNodeRelationship.And); } else if (node.Left.NodeType == ExpressionType.Conditional) { throw new NotSupportedException("Only equality and inequality operators between fields and constant expressions are allowed with Build Custom filters"); } return base.VisitBinary(node); }
internal static string GetValueFromEqualsExpression(BinaryExpression be, Type memberDeclaringType, string memberName) { if (be.NodeType != ExpressionType.Equal) throw new Exception("There is a bug in this program."); if (be.Left.NodeType == ExpressionType.MemberAccess) { MemberExpression me = (MemberExpression)be.Left; if (IsSameTypeOrSubType(me.Member.DeclaringType, memberDeclaringType) && me.Member.Name == memberName) { return GetValueFromExpression(be.Right); } } else if (be.Right.NodeType == ExpressionType.MemberAccess) { MemberExpression me = (MemberExpression)be.Right; if (IsSameTypeOrSubType(me.Member.DeclaringType, memberDeclaringType) && me.Member.Name == memberName) { return GetValueFromExpression(be.Left); } } // We should have returned by now. throw new Exception("There is a bug in this program."); }
public static void CreateDictionaryForSearch(BinaryExpression binary, IDictionary<string, object> dict) { var expressionValue = binary.Right.Value(); var memberExpression = binary.Left; CreateDictionaryForSearch(dict, memberExpression, expressionValue); }
protected override Expression VisitBinary(BinaryExpression node) { // a ?? b == null <-> a == null && b == null if (node.NodeType == ExpressionType.Coalesce) { var current = ResultExpression; ResultExpression = null; Visit(node.Left); var left = ResultExpression; ResultExpression = null; Visit(node.Right); var right = ResultExpression; var coalesce = CombineExpressions(left, right, ExpressionType.AndAlso); ResultExpression = current; AddToResult(coalesce); } // a && b == null <-> a == null && b != false || a != false && b == null // this transformation would produce a query that is too complex // so we just wrap the whole expression into IsNullExpression instead. if ((node.NodeType == ExpressionType.AndAlso) || (node.NodeType == ExpressionType.OrElse)) { AddToResult(new IsNullExpression(node)); } return node; }
protected override Expression VisitBinary(BinaryExpression node) { // rewrite not equal if (node.NodeType == ExpressionType.NotEqual) { return Visit(Expression.MakeUnary(ExpressionType.Not, Expression.MakeBinary(ExpressionType.Equal, node.Left, node.Right), node.Type)); } // handle _query.Append("("); Visit(node.Left); switch (node.NodeType) { case ExpressionType.AndAlso: _query.Append(" AND "); break; case ExpressionType.OrElse: _query.Append(" OR "); break; case ExpressionType.Equal: _query.Append(":"); break; } Visit(node.Right); _query.Append(")"); // done return node; }
protected override Expression VisitBinary(BinaryExpression node) { var relation = string.Empty; switch (node.NodeType) { case ExpressionType.Equal: relation = " = "; break; case ExpressionType.NotEqual: relation = " <> "; break; case ExpressionType.GreaterThan: relation = " > "; break; case ExpressionType.GreaterThanOrEqual: relation = " >= "; break; case ExpressionType.LessThan: relation = " < "; break; case ExpressionType.LessThanOrEqual: relation = " <= "; break; case ExpressionType.Add: relation = " + "; break; case ExpressionType.Subtract: relation = " - "; break; default: break; } this.Condition = GetRelationCondition(relation, node); return node; }
protected override Expression VisitBinary(BinaryExpression node) { // Go and visit the left hand side of this expression this.Visit(node.Left); // Add the operator in the middle switch (node.NodeType) { case ExpressionType.Equal: this.sql.Append("="); break; case ExpressionType.And: case ExpressionType.AndAlso: case ExpressionType.Or: case ExpressionType.OrElse: this.sql.Append(","); break; default: throw new Exception ( "Operator Not Known => " + node.NodeType ); } // Operator needs a space after it. this.sql.Append(" "); // Now visit the right hand side of this expression. this.Visit(node.Right); return node; }
protected override Expression VisitBinary(BinaryExpression binaryExpression) { var nodeType = binaryExpression.NodeType; if (nodeType == ExpressionType.Equal || nodeType == ExpressionType.NotEqual) { var left = this.Visit(binaryExpression.Left).StripAndGetConstant(); var right = this.Visit(binaryExpression.Right).StripAndGetConstant(); if (left != null && right != null) { if (left.Value == null && right.Value == null) { return Expression.Constant(true); } if (left.Value == null || right.Value == null) { return Expression.Constant(false); } } if (left != null && left.Value == null) { return new SqlFunctionCallExpression(binaryExpression.Type, nodeType == ExpressionType.Equal ? SqlFunction.IsNull : SqlFunction.IsNotNull, binaryExpression.Right); } else if (right != null && right.Value == null) { return new SqlFunctionCallExpression(binaryExpression.Type, nodeType == ExpressionType.Equal ? SqlFunction.IsNull : SqlFunction.IsNotNull, binaryExpression.Left); } } return base.VisitBinary(binaryExpression); }
protected override Expression VisitBinary(BinaryExpression b) { b = base.VisitBinary(b) as BinaryExpression; switch (b.NodeType) { case ExpressionType.Add: case ExpressionType.AddChecked: if (b.Left.Type.Equals(typeof(String))) return Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, b.Left, Expressor.ToString(b.Right))); if (b.Right.Type.Equals(typeof(String))) return Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, Expressor.ToString(b.Left), b.Right)); return b; case ExpressionType.ArrayIndex: if (b.Type == Types.Byte) { } return b; case ExpressionType.Equal: case ExpressionType.NotEqual: default: return b; } }
protected override Expression VisitBinary(BinaryExpression node) { base.Visit(node.Right); switch (node.NodeType) { case ExpressionType.Equal: _expressionFragments.Push(" == "); break; case ExpressionType.NotEqual: _expressionFragments.Push(" != "); break; case ExpressionType.LessThan: _expressionFragments.Push(" < "); break; case ExpressionType.LessThanOrEqual: _expressionFragments.Push(" <= "); break; case ExpressionType.GreaterThan: _expressionFragments.Push(" > "); break; case ExpressionType.GreaterThanOrEqual: _expressionFragments.Push(" >= "); break; default: _isValidXeroObjectPath = false; return null; } base.Visit(node.Left); return node; }
protected override Expression VisitBinary(BinaryExpression binaryExpression) { var left = this.Visit(binaryExpression.Left); var right = this.Visit(binaryExpression.Right); if (left.Type.GetUnwrappedNullableType().IsEnum) { if (!right.Type.GetUnwrappedNullableType().IsEnum) { right = Expression.Convert(Expression.Call(null, MethodInfoFastRef.EnumToObjectMethod, Expression.Constant(left.Type.GetUnwrappedNullableType()), Expression.Convert(right, typeof(int))), left.Type); } } else if (right.Type.GetUnwrappedNullableType().IsEnum) { if (!left.Type.GetUnwrappedNullableType().IsEnum) { left = Expression.Convert(Expression.Call(null, MethodInfoFastRef.EnumToObjectMethod, Expression.Constant(right.Type.GetUnwrappedNullableType()), Expression.Convert(left, typeof(int))), right.Type); } } if (left != binaryExpression.Left || right != binaryExpression.Right) { return Expression.MakeBinary(binaryExpression.NodeType, left, right); } return binaryExpression; }
protected override Expression VisitBinary(BinaryExpression b) { this.Visit(b.Left); switch (b.NodeType) { case ExpressionType.And | ExpressionType.AndAlso: sb.Append(" and "); break; case ExpressionType.Or: sb.Append(" OR"); break; case ExpressionType.Equal: sb.Append(" = "); break; case ExpressionType.NotEqual: sb.Append(" != "); break; case ExpressionType.LessThan: sb.Append(" < "); break; case ExpressionType.LessThanOrEqual: sb.Append(" <= "); break; case ExpressionType.GreaterThan: sb.Append(" > "); break; case ExpressionType.GreaterThanOrEqual: sb.Append(" >= "); break; default: throw new NotSupportedException(string.Format("The binary operator '{0}' is not supported by SimpleDB.", b.NodeType)); } this.Visit(b.Right); return b; }
protected override Expression VisitBinary(BinaryExpression binary) { if (_operators.ContainsKey(binary.NodeType)) { var fragment = _parent.buildSimpleWhereClause(_mapping, binary); _register.Peek()(fragment); return null; } if ((binary.NodeType == ExpressionType.AndAlso) || (binary.NodeType == ExpressionType.OrElse)) { var separator = binary.NodeType == ExpressionType.AndAlso ? "and" : "or"; var compound = new CompoundWhereFragment(separator); _register.Peek()(compound); _register.Push(child => compound.Add(child)); Visit(binary.Left); Visit(binary.Right); _register.Pop(); return null; } throw new NotSupportedException($"Marten does not support the BinaryExpression {binary} (yet)."); }
protected override Expression VisitBinary(BinaryExpression node) { if (node.NodeType != ExpressionType.ArrayIndex) return base.VisitBinary(node); // rewrite... return Visit(node.Left).Array(Visit(node.Right)); }
static Expression SimpleProduct(Expression left, Expression right, BinaryExpression product) { // ensure "left" is no quotient if(left.NodeType == ExpressionType.Divide) { BinaryExpression leftQuotient = (BinaryExpression)left; Expression nominator = SimpleProduct(right, leftQuotient.Left, null); return SimpleQuotient(nominator, leftQuotient.Right, null); } // ensure "right" is no quotient if(right.NodeType == ExpressionType.Divide) { BinaryExpression rightQuotient = (BinaryExpression)right; Expression nominator = SimpleProduct(left, rightQuotient.Left, null); return SimpleQuotient(nominator, rightQuotient.Right, null); } // ensure "right" is no product while(right.NodeType == ExpressionType.Multiply) { BinaryExpression rightProduct = (BinaryExpression)right; left = Expression.Multiply(left, rightProduct.Right); right = rightProduct.Left; } if((product == null) || (left != product.Left) || (right != product.Right)) { return Expression.Multiply(left, right); } return product; }
protected List<Microsoft.Z3.BoolExpr> VisitBinary(BinaryExpression b) { // Use recursion to generate Z3 constraints for each operand of the binary expression // left side -> create a Z3 expression representing the left side Expression left = Visit(b.Left); // right side -> creat a Z3 expression representing the right side Expression right = Visit(b.Right); // Put those into a Z3 format ExpressionType op = b.NodeType; using (Context ctx = new Context()) { if (op == ExpressionType.LessThan) { // ctx.MkLt(left, right); } } Console.WriteLine(b.ToString()); // TODO - return a Z3 expression return null; }
/// <summary> /// 将二元符号转换成T-SQL可识别的操作符 /// </summary> protected override Expression VisitBinary(BinaryExpression b) { if (b == null) { return null; } var isReverse = false; var left = b.Left; var right = b.Right; // 先解析字段 if (b.Left.NodeType != ExpressionType.MemberAccess && (b.Left.NodeType == ExpressionType.MemberAccess || b.Right.NodeType == ExpressionType.MemberAccess)) { left = b.Right; right = b.Left; isReverse = true; } left = base.Visit(left); right = base.Visit(right); var conversion = base.Visit(b.Conversion); var contidion = isReverse ? (left != b.Right || right != b.Left) : (left != b.Left || right != b.Right); // 说明进过了换算 if (contidion || conversion != b.Conversion) { if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null) { return Expression.Coalesce(left, right, conversion as LambdaExpression); } else { // 两边类型不同时,需要进行转换 if (left.Type != right.Type) { right = Expression.Convert(right, left.Type); } b = Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method); } } // 清除状态(与或状态,不清除) if (b.NodeType != ExpressionType.And && b.NodeType != ExpressionType.Or) { CurrentFieldName = null; CurrentDbParameter = null; } return b; }
protected override Expression VisitBinary(BinaryExpression node) { Visit(node.Left); ColumnName += node.NodeType; Visit(node.Right); return node; }
/// <summary> /// Validates whether the binary expression is valid AND / OR expression. /// </summary> /// <param name="binaryExpression">Binary conjuctive expression.</param> public static void ValidateConjunctiveExpression(BinaryExpression binaryExpression) { Utils.ThrowIfNull(binaryExpression, "binaryExpression"); ExpressionHelper.ValidateConjuctiveNode(binaryExpression.Left); ExpressionHelper.ValidateConjuctiveNode(binaryExpression.Right); }
protected override Expression VisitBinary(BinaryExpression node) { if (node.NodeType == ExpressionType.Equal && node.Left.ToString() == "element.Id") { try { var stringEqualsMethod = typeof(string).GetMethod( "Equals", new[] { typeof(string), typeof(string), typeof(StringComparison) }); var newExpression = Expression.Call( stringEqualsMethod, node.Left, node.Right, Expression.Constant(StringComparison.OrdinalIgnoreCase)); return newExpression; } catch { return base.VisitBinary(node); } } return base.VisitBinary(node); }
protected override Expression VisitBinary(BinaryExpression node) { string operatorName; if (node.Method == null) { operatorName = string.Format(" {0} ", node.NodeType.GetName()); } else { // VisitBinary should be called only for operators but its possible // that we don't know this special C# operators name var name = TypeNameConverter.GetCSharpOperatorName(node.Method); if (name != null) operatorName = string.Format(" {0} ", name); else operatorName = node.Method.Name; } // BinaryExpression consists of 3 parts: left operator right _rep = string.Format("{0}{1}{2}", Print(node.Left), operatorName, Print(node.Right)); if (!_isHighLevel) _rep = string.Format("({0})", _rep); return node; }
private static bool CheckShortCircuitOr(BinaryExpression expression, StringBuilder queryBuilder, Action<Expression> visitExpression) { if (expression.NodeType == ExpressionType.Or || expression.NodeType == ExpressionType.OrElse) { var ceLeft = expression.Left as ConstantExpression; var ceRight = expression.Right as ConstantExpression; if (ceLeft != null && (ceLeft.Type == typeof(bool) || ceLeft.Type == typeof(bool?))) { if (true.Equals(ceLeft.Value)) queryBuilder.Append("true "); else visitExpression(expression.Right); return true; } else if (ceRight != null && (ceRight.Type == typeof(bool) || ceRight.Type == typeof(bool?))) { if (true.Equals(ceRight.Value)) queryBuilder.Append("true "); else visitExpression(expression.Left); return true; } } return false; }
private static bool CheckShortCircuitAnd(BinaryExpression expression, StringBuilder queryBuilder, Action<Expression> visitExpression) { if (expression.NodeType == ExpressionType.And || expression.NodeType == ExpressionType.AndAlso) { var ceLeft = expression.Left as ConstantExpression; var ceRight = expression.Right as ConstantExpression; if (ceLeft != null && ceLeft.Type == typeof(bool)) { if ((bool)ceLeft.Value) visitExpression(expression.Right); else queryBuilder.Append("false "); return true; } else if (ceRight != null && ceRight.Type == typeof(bool)) { if ((bool)ceRight.Value) visitExpression(expression.Left); else queryBuilder.Append("false "); return true; } } return false; }
protected override LE.Expression VisitBinary(LE.BinaryExpression be, LE.Expression leftExpr, LE.Expression rightExpr) { if (be.NodeType == LE.ExpressionType.AndAlso || be.NodeType == LE.ExpressionType.OrElse) { return(LE.Expression.AndAlso(leftExpr, rightExpr)); } return(base.VisitBinary(be, leftExpr, rightExpr)); }
public void CanConstantExpressionBeNull() { ConstantExpression c2 = Expression.Constant(null); ConstantExpression c1 = Expression.Constant(null); BinaryExpression a = Expression.Equal(c1, c2); Assert.Pass(); }
public static void Main() { // Numeric comparison var user1 = new User { Age = 13, Name = "Adam" }; var user2 = new User { Age = 33, Name = "John" }; var user3 = new User { Age = 53, Name = "DBag" }; // Equal, NotEqual, GreaterThanOrEqual, GreaterThan, LessThan, LessThanOrEqual var rule = new Rule("Age", "LessThanOrEqual", "33"); Func <User, bool> compiledRule = CompileUserRule <User>(rule); Console.WriteLine("Rule: " + rule.MemberName + " " + rule.Operator + " " + rule.TargetValue); Console.WriteLine("Evaluating Rule:"); Console.WriteLine("\tuser1: Name: " + user1.Name + ", Age: " + user1.Age + " : " + compiledRule(user1)); Console.WriteLine("\tuser2: Name: " + user2.Name + ", Age: " + user2.Age + " : " + compiledRule(user2)); Console.WriteLine("\tuser3: Name: " + user3.Name + ", Age: " + user3.Age + " : " + compiledRule(user3)); // Search within a string var mystring = new simpleString { searchValue = "I got ants!" }; rule = new Rule("searchValue", "Contains", "ants"); Func <simpleString, bool> compiledStringRule = CompileStringRule <simpleString>(rule); compiledStringRule = CompileStringRule <simpleString>(rule); Console.WriteLine("\nRule: " + rule.MemberName + " " + rule.Operator + " " + rule.TargetValue); Console.WriteLine("Evaluating Rule:"); Console.WriteLine("\tsearchValue: \"" + mystring.searchValue + "\" : " + compiledStringRule(mystring)); mystring.searchValue = "If you see something, say something."; Console.WriteLine("\tsearchValue: \"" + mystring.searchValue + "\" : " + compiledStringRule(mystring)); // Dynamic rule creation and execution Console.WriteLine("\nDynamically constructed rule with simple math expression:"); System.Linq.Expressions.BinaryExpression binaryExpression = System.Linq.Expressions.Expression.MakeBinary( System.Linq.Expressions.ExpressionType.Divide, System.Linq.Expressions.Expression.Constant(1000), System.Linq.Expressions.Expression.Constant(20) ); Console.WriteLine("\tRule: " + binaryExpression.ToString()); // Compile the expression. var compiledExpression = Expression.Lambda <Func <int> >(binaryExpression).Compile(); // Execute the expression. Console.WriteLine("\tResult of rule execution: " + compiledExpression()); Console.WriteLine("\nHit any key to exit"); Console.ReadKey(); }
protected override Expression VisitBinary(System.Linq.Expressions.BinaryExpression node) { if (node.NodeType == ExpressionType.Equal && node.Method == null && node.Left.Type == typeof(XElement)) { return(Expression.Equal(this.Visit(node.Left), this.Visit(node.Right), node.IsLiftedToNull, methodInfoForAreEqual)); } return(base.Visit(node)); }
private Expression Convert( LinqExp.BinaryExpression linqBinary, Func <Expression, Expression, MethodInfo, Expression> factory) { return(factory.Invoke( ConvertExp(linqBinary.Left), ConvertExp(linqBinary.Right), linqBinary.Method)); }
/// <summary> /// 表达式路由 /// </summary> /// <param name="exp"></param> /// <returns></returns> string ExpressionRouter(System.Linq.Expressions.Expression exp) { //获取实体列的特性 List <EntityPropColumnAttributes> columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>(); string sb = string.Empty; if (exp is System.Linq.Expressions.BinaryExpression)//二元运算符 { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp); return(BinarExpressionProvider(be.Left, be.Right, be.NodeType)); } else if (exp is System.Linq.Expressions.MemberExpression)//成员 { System.Linq.Expressions.MemberExpression me = ((System.Linq.Expressions.MemberExpression)exp); return(me.Member.Name); } else if (exp is System.Linq.Expressions.NewArrayExpression)//数组 { System.Linq.Expressions.NewArrayExpression ae = ((System.Linq.Expressions.NewArrayExpression)exp); StringBuilder tmpstr = new StringBuilder(); foreach (System.Linq.Expressions.Expression ex in ae.Expressions) { tmpstr.Append(ExpressionRouter(ex)); tmpstr.Append(","); } return(tmpstr.ToString(0, tmpstr.Length - 1)); } else if (exp is System.Linq.Expressions.MethodCallExpression)//方法 { return(MethodExpression(exp)); } else if (exp is System.Linq.Expressions.ConstantExpression) { System.Linq.Expressions.ConstantExpression ce = ((System.Linq.Expressions.ConstantExpression)exp); if (ce.Value == null) { return("null"); } else if (ce.Value is ValueType) { return(ce.Value.ToString()); } else if (ce.Value is string || ce.Value is DateTime || ce.Value is char) { //return string.Format("'{0}'", ce.Value.ToString()); return(string.Format("{0}", ce.Value.ToString())); } } else if (exp is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression ue = ((System.Linq.Expressions.UnaryExpression)exp); return(ExpressionRouter(ue.Operand)); } return(null); }
public Expression Parse(Linq.Expression linqExpression) { if (linqExpression is Linq.ConstantExpression) { Linq.ConstantExpression cexpr = (Linq.ConstantExpression)linqExpression; if (!(cexpr.Value is double)) { throw new Exception("Can't parse a non-numeric constant"); } return(new NumberExpression((double)cexpr.Value)); } else if (linqExpression is Linq.ParameterExpression) { Linq.ParameterExpression pexpr = (Linq.ParameterExpression)linqExpression; return(new VariableExpression(pexpr.Name)); } else if (linqExpression is Linq.MethodCallExpression) { Linq.MethodCallExpression mexpr = (Linq.MethodCallExpression)linqExpression; IList <Expression> arguments = new List <Expression>(); foreach (Linq.Expression arg in mexpr.Arguments) { arguments.Add(Parse(arg)); } if (!exists(mexpr.Method)) { throw new Exception("Method name doesn't exist in the scope"); } if (mexpr.Method.Equals(powMethod)) { return(new BinaryExpression(Binary.Power, arguments[0], arguments[1])); } string name = get(mexpr.Method); return(new FunctionExpression(name, arguments)); } else if (linqExpression is Linq.BinaryExpression) { Linq.BinaryExpression bexpr = (Linq.BinaryExpression)linqExpression; Expression left = Parse(bexpr.Left); Expression right = Parse(bexpr.Right); return(new BinaryExpression(getOperator(bexpr.NodeType), left, right)); } throw new Exception("Can't parse expression"); }
protected override Linq.Expression VisitBinary(Linq.BinaryExpression node) { if (node.NodeType == Linq.ExpressionType.ArrayIndex) { _ = new ArrayIndex(this.Current) { Array = this.VisitCacheParse(node.Left), Index = this.VisitCacheParse(node.Right), }; } else { Binary binary; if (node.IsReferenceComparison()) { if (node.NodeType == Linq.ExpressionType.Equal) { binary = new ReferenceEqual(this.Current); } else { binary = new ReferenceNotEqual(this.Current); } } else { binary = Binary.Create(this.Current, node.NodeType); if (node.Method is MethodInfo method) { binary.Method = this.VisitMethod(method); } if (node.Conversion is LambdaExpression lambda) { binary.Conversion = new Lambda(this.VisitCache(lambda)); } if (node.IsLiftedToNull) { binary.LiftToNull = true; } } binary.Left = this.VisitCacheParse(node.Left); binary.Right = this.VisitCacheParse(node.Right); } return(node); }
/// <summary> /// 右边表达式路由 /// </summary> /// <param name="exp"></param> /// <returns></returns> object RightExpressionRouter(System.Linq.Expressions.Expression exp) { string sb = string.Empty; if (exp is System.Linq.Expressions.BinaryExpression) { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp); return(BinarExpressionProvider(be.Left, be.Right, be.NodeType)); } else if (exp is System.Linq.Expressions.MethodCallExpression)//方法 { return(MethodExpression(exp)); } else { return(System.Linq.Expressions.Expression.Lambda(exp).Compile().DynamicInvoke()); } }
/// <summary> /// 获取Lambda表达式返回的结果 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="func"></param> /// <returns></returns> public CoreFrameworkEntity GetLambdaEntity <T>(System.Linq.Expressions.Expression <Func <T, bool> > func) { listPara.Clear(); CoreFrameworkEntity lambdaEntity = new CoreFrameworkEntity(); // 二元运算符表达式 if (func.Body is System.Linq.Expressions.BinaryExpression) { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)func.Body); lambdaEntity.where = BinarExpressionProvider(be.Left, be.Right, be.NodeType); lambdaEntity.paraList = listPara; } // 单纯的静态方法 if (func.Body is System.Linq.Expressions.MethodCallExpression) { System.Linq.Expressions.MethodCallExpression be = ((System.Linq.Expressions.MethodCallExpression)func.Body); lambdaEntity.where = ExpressionRouter(be); lambdaEntity.paraList = listPara; } return(lambdaEntity); }
protected override Expression VisitBinary(System.Linq.Expressions.BinaryExpression node) { int currentTabs; if (tabs.Count > 0) { currentTabs = tabs[tabs.Count - 1]; tabs.RemoveAt(tabs.Count - 1); } else { currentTabs = 0; } for (int i = 0; i < currentTabs; i++) { Console.Write("\t"); } Console.WriteLine("VisitBinary {0}", node.NodeType.ToString()); if (node.Right != null && (node.Right is System.Linq.Expressions.BinaryExpression || node.Right is System.Linq.Expressions.ParameterExpression || node.Right is System.Linq.Expressions.ConstantExpression)) { tabs.Add(currentTabs + 1); } if (node.Left != null && (node.Left is System.Linq.Expressions.BinaryExpression || node.Left is System.Linq.Expressions.ParameterExpression || node.Left is System.Linq.Expressions.ConstantExpression)) { tabs.Add(currentTabs + 1); } return(base.VisitBinary(node)); }
protected internal override Expression VisitBinary(BinaryExpression node) { if (node.NodeType == ExpressionType.ArrayIndex) { Visit(node.Left); Out('['); Visit(node.Right); Out(']'); } else { string op; switch (node.NodeType) { // AndAlso and OrElse were unintentionally changed in // CLR 4. We changed them to "AndAlso" and "OrElse" to // be 3.5 compatible, but it turns out 3.5 shipped with // "&&" and "||". Oops. case ExpressionType.AndAlso: op = "AndAlso"; break; case ExpressionType.OrElse: op = "OrElse"; break; case ExpressionType.Assign: op = "="; break; case ExpressionType.Equal: op = "=="; break; case ExpressionType.NotEqual: op = "!="; break; case ExpressionType.GreaterThan: op = ">"; break; case ExpressionType.LessThan: op = "<"; break; case ExpressionType.GreaterThanOrEqual: op = ">="; break; case ExpressionType.LessThanOrEqual: op = "<="; break; case ExpressionType.Add: case ExpressionType.AddChecked: op = "+"; break; case ExpressionType.AddAssign: case ExpressionType.AddAssignChecked: op = "+="; break; case ExpressionType.Subtract: case ExpressionType.SubtractChecked: op = "-"; break; case ExpressionType.SubtractAssign: case ExpressionType.SubtractAssignChecked: op = "-="; break; case ExpressionType.Divide: op = "/"; break; case ExpressionType.DivideAssign: op = "/="; break; case ExpressionType.Modulo: op = "%"; break; case ExpressionType.ModuloAssign: op = "%="; break; case ExpressionType.Multiply: case ExpressionType.MultiplyChecked: op = "*"; break; case ExpressionType.MultiplyAssign: case ExpressionType.MultiplyAssignChecked: op = "*="; break; case ExpressionType.LeftShift: op = "<<"; break; case ExpressionType.LeftShiftAssign: op = "<<="; break; case ExpressionType.RightShift: op = ">>"; break; case ExpressionType.RightShiftAssign: op = ">>="; break; case ExpressionType.And: op = IsBool(node) ? "And" : "&"; break; case ExpressionType.AndAssign: op = IsBool(node) ? "&&=" : "&="; break; case ExpressionType.Or: op = IsBool(node) ? "Or" : "|"; break; case ExpressionType.OrAssign: op = IsBool(node) ? "||=" : "|="; break; case ExpressionType.ExclusiveOr: op = "^"; break; case ExpressionType.ExclusiveOrAssign: op = "^="; break; case ExpressionType.Power: op = "**"; break; // This was changed in .NET Core from ^ to ** case ExpressionType.PowerAssign: op = "**="; break; case ExpressionType.Coalesce: op = "??"; break; default: throw new InvalidOperationException(); } Out('('); Visit(node.Left); Out(' '); Out(op); Out(' '); Visit(node.Right); Out(')'); } return(node); }
protected override System.Linq.Expressions.Expression VisitBinaryExpression(System.Linq.Expressions.BinaryExpression expression) { this.currentParts.Push(new StringBuilder()); query.Append("("); VisitExpression(expression.Left); //bool localInverseActive = false; switch (expression.NodeType) { case ExpressionType.Equal: currentPart.Append("eq"); break; case ExpressionType.NotEqual: currentPart.Append("ne"); inverseMode = true; break; case ExpressionType.GreaterThan: currentPart.Append("gt"); //constant expression uses this to decide how to output the value break; case ExpressionType.GreaterThanOrEqual: currentPart.Append("ge"); //constant expression uses this to decide how to output the value break; case ExpressionType.LessThan: currentPart.Append("lt"); //constant expression uses this to decide how to output the value break; case ExpressionType.LessThanOrEqual: currentPart.Append("le"); //constant expression uses this to decide how to output the value break; case ExpressionType.AndAlso: case ExpressionType.And: query.Append(" AND "); break; case ExpressionType.OrElse: case ExpressionType.Or: query.Append(" OR "); break; case ExpressionType.Not: query.Append(""); break; } bracketsEnabled = true; VisitExpression(expression.Right); inverseMode = false; //specific case where exact matches are required, we will insert the + or - at the start and a proximity of 0 //may need to relocate this logic if (expression.Left is MemberExpression && expression.Right is ConstantExpression && ((ConstantExpression)expression.Right).Value is string) { if ((expression.NodeType == ExpressionType.NotEqual && !inverseMode) || (expression.NodeType == ExpressionType.Equal && inverseMode)) { query.Insert(query.Length - 2, " NOT "); } else { currentPart.Insert(0, "+"); } //currentPart.Insert(0, (expression.NodeType == ExpressionType.Equal) && !inverseMode || ( // (expression.NodeType == ExpressionType.NotEqual) & inverseMode & localInverseActive) ? "+" : "-"); } //if (localInverseActive) // inverseMode = !inverseMode; query.Append(currentPart); query.Append(")"); currentParts.Pop(); return(expression); }
public BinaryExpressionProxy(BinaryExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
protected virtual void VisitBinary(BinaryExpression binary) { Visit(binary.Left); Visit(binary.Right); Visit(binary.Conversion); }
protected virtual Expression VisitBinary(BinaryExpression node) { throw new NotImplementedException(); }
/// <summary> /// 获得主键相等表达式 /// </summary> /// <param name="entity"></param> /// <returns></returns> protected linq.Expression <Func <T, bool> > GetKeyEqualsExpression(T entity) { linq.BinaryExpression binary = linq.Expression.Equal(linq.Expression.Property(ParaModel, InfoKey), linq.Expression.Constant(GetKeyValue(entity))); return(linq.Expression.Lambda <Func <T, bool> >(binary, ParaModel)); }
private Expression ConvertImplicit(LinqExp.BinaryExpression linqBinary, Func <Expression, Expression, Expression> factory) { return(factory.Invoke(ConvertExp(linqBinary.Left), ConvertExp(linqBinary.Right))); }
internal virtual Expression VisitComparison(BinaryExpression expression) { return(this.VisitBinary(EntityExpressionVisitor.RemoveUnnecessaryConverts(expression))); }
protected internal override Expression VisitBinary(BinaryExpression node) { if (node.NodeType == ExpressionType.ArrayIndex) { ParenthesizedVisit(node, node.Left); Out("["); Visit(node.Right); Out("]"); } else { bool parenthesizeLeft = NeedsParentheses(node, node.Left); bool parenthesizeRight = NeedsParentheses(node, node.Right); string op; bool isChecked = false; Flow beforeOp = Flow.Space; switch (node.NodeType) { case ExpressionType.Assign: op = "="; break; case ExpressionType.Equal: op = "=="; break; case ExpressionType.NotEqual: op = "!="; break; case ExpressionType.AndAlso: op = "&&"; beforeOp = Flow.NewLine; break; case ExpressionType.OrElse: op = "||"; beforeOp = Flow.NewLine; break; case ExpressionType.GreaterThan: op = ">"; break; case ExpressionType.LessThan: op = "<"; break; case ExpressionType.GreaterThanOrEqual: op = ">="; break; case ExpressionType.LessThanOrEqual: op = "<="; break; case ExpressionType.Add: op = "+"; break; case ExpressionType.AddAssign: op = "+="; break; case ExpressionType.AddAssignChecked: op = "+="; isChecked = true; break; case ExpressionType.AddChecked: op = "+"; isChecked = true; break; case ExpressionType.Subtract: op = "-"; break; case ExpressionType.SubtractAssign: op = "-="; break; case ExpressionType.SubtractAssignChecked: op = "-="; isChecked = true; break; case ExpressionType.SubtractChecked: op = "-"; isChecked = true; break; case ExpressionType.Divide: op = "/"; break; case ExpressionType.DivideAssign: op = "/="; break; case ExpressionType.Modulo: op = "%"; break; case ExpressionType.ModuloAssign: op = "%="; break; case ExpressionType.Multiply: op = "*"; break; case ExpressionType.MultiplyAssign: op = "*="; break; case ExpressionType.MultiplyAssignChecked: op = "*="; isChecked = true; break; case ExpressionType.MultiplyChecked: op = "*"; isChecked = true; break; case ExpressionType.LeftShift: op = "<<"; break; case ExpressionType.LeftShiftAssign: op = "<<="; break; case ExpressionType.RightShift: op = ">>"; break; case ExpressionType.RightShiftAssign: op = ">>="; break; case ExpressionType.And: op = "&"; break; case ExpressionType.AndAssign: op = "&="; break; case ExpressionType.Or: op = "|"; break; case ExpressionType.OrAssign: op = "|="; break; case ExpressionType.ExclusiveOr: op = "^"; break; case ExpressionType.ExclusiveOrAssign: op = "^="; break; case ExpressionType.Power: op = "**"; break; case ExpressionType.PowerAssign: op = "**="; break; //TODO: need to handle conversion lambda case ExpressionType.Coalesce: op = "??"; break; default: throw new InvalidOperationException(); } if (isChecked) { Out(Flow.Break, "checked(", Flow.None); } if (parenthesizeLeft) { Out("(", Flow.None); } Visit(node.Left); if (parenthesizeLeft) { Out(Flow.None, ")", Flow.Break); } Out(beforeOp, op, Flow.Space | Flow.Break); if (parenthesizeRight) { Out("(", Flow.None); } Visit(node.Right); if (parenthesizeRight) { Out(Flow.None, ")", Flow.Break); } } return(node); }
protected override Expression VisitBinary(BinaryExpression node) { base.VisitBinary(node); if (fieldMatchingOperators.TryGetValue(node.NodeType, out var fieldMatchingOperator)) { var right = stack.Pop(); var left = stack.Pop(); var leftField = left as FieldReferenceExpression; var leftValue = left as ValueExpression; var rightField = right as FieldReferenceExpression; var rightValue = right as ValueExpression; if (leftValue != null && rightValue != null) { throw new InvalidOperationException( $"one of expression's sides should be field reference expression, [{node}]"); } if (leftField != null && rightValue != null) { if (rightValue.Value == null) { stack.Push(new IsEmptyExpression { Field = leftField, Not = fieldMatchingOperator == JqlFieldMatchingType.NotEquals }); } else { stack.Push(new FieldMatchingExpression { Field = leftField, Value = rightValue, Operator = fieldMatchingOperator }); } } else if (leftValue != null && rightField != null) { if (leftValue.Value == null) { stack.Push(new IsEmptyExpression { Field = rightField, Not = fieldMatchingOperator == JqlFieldMatchingType.NotEquals }); } else { stack.Push(new FieldMatchingExpression { Field = rightField, Value = leftValue, Operator = fieldMatchingOperator }); } } else if (leftField != null && rightField != null && leftField.Source != rightField.Source) { if (issueFunction.HasValue) { throw new InvalidOperationException( $"only one filter which defines the parent-child relationship is allowed, [{node}]"); } var parent = FieldBySource(parentQuerySource, leftField, rightField); var child = FieldBySource(queryBuilder.Source, leftField, rightField); if (parent == null || child == null) { throw new InvalidOperationException( $"at least one of the fields has an unsupported query source, [{node}]"); } if (fieldMatchingOperator != JqlFieldMatchingType.Equals) { throw new InvalidOperationException( $"the parent-child relationship must be defined by [Equal] operator only, [{node}]"); } if (string.Equals(parent.Field, "parent", StringComparison.InvariantCultureIgnoreCase)) { issueFunction = JqlIssueFunction.SubTasksOf; } else if (string.Equals(child.Field, "parent", StringComparison.InvariantCultureIgnoreCase)) { issueFunction = JqlIssueFunction.ParentsOf; } else { throw new InvalidOperationException( $"the parent-child relationship must be defined using [.Parent] field, [{node}]"); } } else if (leftField != null && rightField != null && leftField.Source == rightField.Source) { throw new InvalidOperationException( $"one of expression's sides should be constant expression, [{node}]"); } else { throw new InvalidOperationException($"unsupported binary expression, operator [{node.NodeType}]"); } } else if (logicalOperators.TryGetValue(node.NodeType, out var logicalOperator)) { var right = stack.Pop(); var left = stack.Pop(); stack.Push(new Ast.BinaryExpression { Left = left, Right = right, Operator = logicalOperator }); } else { throw new InvalidOperationException($"unsupported binary expression, operator [{node.NodeType}]"); } return(node); }
private static SysLE.Expression SysExpressionWhere_Analyize(SysLE.Expression exp, StringBuilder builder) { if (exp == null) { return(null); } SysLE.BinaryExpression binEx = exp as SysLE.BinaryExpression; if (binEx != null) { SysExpressionWhere_Analyize(binEx.Left, builder); } switch (exp.NodeType) { case SysLE.ExpressionType.Parameter: { SysLE.ParameterExpression param = (SysLE.ParameterExpression)exp; builder.Append("(" + param.Name); return(null); } case SysLE.ExpressionType.MemberAccess: { SysLE.MemberExpression mexp = (SysLE.MemberExpression)exp; builder.Append("(" + mexp.Member.Name); return(null); } case SysLE.ExpressionType.Constant: { SysLE.ConstantExpression cex = (SysLE.ConstantExpression)exp; if (cex.Value is string) { builder.Append("'" + cex.Value.ToString() + "') "); } else { builder.Append(cex.Value.ToString() + ")"); } return(null); } default: { if (exp.NodeType == SysLE.ExpressionType.Equal) { builder.Append("="); } else if (exp.NodeType == SysLE.ExpressionType.NotEqual) { builder.Append("<>"); } else if (exp.NodeType == SysLE.ExpressionType.LessThan) { builder.Append("<"); } else if (exp.NodeType == SysLE.ExpressionType.LessThanOrEqual) { builder.Append("<="); } else if (exp.NodeType == SysLE.ExpressionType.GreaterThan) { builder.Append(">"); } else if (exp.NodeType == SysLE.ExpressionType.GreaterThanOrEqual) { builder.Append(">="); } else if (exp.NodeType == SysLE.ExpressionType.AndAlso || exp.NodeType == SysLE.ExpressionType.And) { builder.Append("and"); } else if (exp.NodeType == SysLE.ExpressionType.OrElse || exp.NodeType == SysLE.ExpressionType.Or) { builder.Append("or"); } } break; } if (binEx != null) { SysExpressionWhere_Analyize(binEx.Right, builder); } return(binEx); }