public NLINQ.Expression Transform(System.Linq.Expressions.Expression expression) { Visit(Evaluator.PartialEval(expression)); if (tree == null) tree = new NLINQ.QueryExpression(from, new NLINQ.QueryBody(clauses, new NLINQ.SelectClause(from.Identifier), null)); return tree; }
public virtual OrderByCriteria Update(OrderByCriteria criterium, Expression expression, bool ascending) { if (criterium.Expression != expression || criterium.Ascending != ascending) return new OrderByCriteria(expression, ascending); return criterium; }
public virtual UnaryExpression Update(UnaryExpression u, Expression operand, UnaryExpressionType unaryExpressionType) { if (u.Expression != operand || u.Type != unaryExpressionType) { return new UnaryExpression(unaryExpressionType, operand); } return u; }
public virtual TypedNew Update(TypedNew nex, string type, Expression[] args) { if (args != nex.Parameters || nex.Type != type) { return new TypedNew(type, args); } return nex; }
public virtual TernaryExpression Update(TernaryExpression c, Expression test, Expression ifTrue, Expression ifFalse) { if (test != c.LeftExpression || ifTrue != c.MiddleExpression || ifFalse != c.RightExpression) { return new TernaryExpression(test, ifTrue, ifFalse); } return c; }
public MethodCall(Identifier identifier, Expression[] parameters, Identifier anonIndentifier, Identifier indexIdentifier, Expression lambdaExpression) { this.identifier = identifier; this.parameters = parameters; this.anonIndentifier = anonIndentifier; this.indexIdentifier = indexIdentifier; this.lambdaExpression = lambdaExpression; }
public virtual MethodCall Update(MethodCall m, Identifier target, Identifier methodName, Expression[] args) { if (target != m.AnonIdentifier || methodName != m.Identifier || args != m.Parameters) { return new MethodCall(methodName, (Expression[])args, m.AnonIdentifier, m.IndexIdentifier, m.LambdaExpression); } return m; }
public JoinClause(string type, Identifier identifier, Expression inIdentifier, Expression on, Expression equals, Identifier into) { this.type = type; this.identifier = identifier; this.inIdentifier = inIdentifier; this.on = on; this.equals = equals; this.into = into; }
public override Expression Visit(Expression exp) { foreach (IVisitor<Expression> visitor in visitors) { TraceHelper.TraceEvent(traceSource, System.Diagnostics.TraceEventType.Start, 1, "{0} process begin...", visitor.GetType().Name); exp = visitor.Visit(exp); TraceHelper.TraceEvent(traceSource, System.Diagnostics.TraceEventType.Start, 1, "{0} process succeed...", visitor.GetType().Name); } return exp; }
public ComplexColumnExpression(TableAlias alias, Expression innerExpression, Identifier columnAlias) : base(alias, null, columnAlias) { Expression = innerExpression; }
public DateAdd(Identifier identifier, Expression expression, Expression result) : base(DateAddIdentifier, identifier, expression, result) { }
public DatePart(Identifier part, Expression expressionToCast) : base(DatePartIdentifier, new Expression[] { part, expressionToCast }) { }
public Indexer(Expression innerExpression, Expression parameter) { this.innerExpression = innerExpression; this.parameter = parameter; }
public MethodCall(Expression target, Identifier methodName, Expression[] parameters) { this.Target = target; this.MethodName = methodName; Parameters = parameters; }
public virtual AnonymousParameter Update(AnonymousParameter original, Identifier identifier, Expression expression) { if (original.Expression != expression || original.Identifier != identifier) return new AnonymousParameter(identifier, expression); return original; }
public NLinq.Expressions.Expression Visit(MethodCallExpression call) { if (call.Method.IsStatic && (call.Method.DeclaringType == typeof(Enumerable) || call.Method.DeclaringType == typeof(Queryable)) || call.Method.DeclaringType == typeof(ContextExtensions)) { NLinq.Expressions.Expression subExpression = Visit(call.Arguments[0]); switch (call.Method.Name) { case "Skip": case "Take": if (tree == null) { if (subExpression == null) subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null)); tree = new NLINQ.MemberExpression(new MethodCall(call.Method.Name, Visit(call.Arguments[1])), subExpression); } else tree = new NLINQ.MemberExpression(new MethodCall(call.Method.Name, Visit(call.Arguments[1])), tree); return tree; case "Cast": return subExpression; case "FirstOrDefault": case "LastOrDefault": case "Last": case "First": string methodName = call.Method.Name; if (call.Method.Name.EndsWith("OrDefault")) methodName = methodName.Substring(0, call.Method.Name.Length - 9); if (tree == null) { if (subExpression == null) subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null)); tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(methodName)), subExpression); } else tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(methodName)), tree); break; case "Select": SelectOrGroupClause select = new SelectClause(Visit(call.Arguments[1])); tree = new QueryExpression(from, new QueryBody(clauses, select, null)); identifiers["#First"].Text = "e" + identifiers["#First"].GetHashCode(); identifiers.Clear(); identifiers["#First"] = new Identifier("e0"); clauses = new ClauseList(); from = new FromClause(null, identifiers["#First"], tree); return tree; case "SelectMany": //Select the result of the join (a load reference) FromClause from2 = null; Identifier newElement = null; select = null; if (call.Arguments.Count == 2) newElement = new Identifier("e1"); if (call.Arguments.Count == 3) newElement = new Identifier(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Parameters[1].Name); from2 = new FromClause(call.Method.GetGenericArguments()[1].FullName, newElement, Visit(call.Arguments[1])); if (call.Arguments.Count == 2) { //System.Linq.Expressions.LambdaExpression lambda = ((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[1]).Operand); identifiers["#First"].Text = "e" + identifiers["#First"].GetHashCode(); //newElement = new Identifier("e0"); identifiers.Clear(); newElement.Text = "e0"; identifiers.Add("#First", newElement); identifiers.Add(newElement.Text, newElement); select = new SelectClause(newElement); } //Select a property of the select many if (call.Arguments.Count == 3) { //newElement = new Identifier(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Parameters[1].Name); identifiers.Add(newElement.Text, newElement); Identifier src = new Identifier(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Parameters[0].Name); if (!identifiers.ContainsKey(src.Text)) identifiers.Add(src.Text, identifiers["#First"]); select = new SelectClause(Visit(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Body)); if (((SelectClause)select).Expression == null) select = null; } if (call.Arguments.Count > 3) throw new NotSupportedException(); //from2 = new FromClause(call.Method.GetGenericArguments()[1].FullName, newElement, Visit(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[1]).Operand).Body)); clauses.Add(from2); tree = new QueryExpression(from, new QueryBody(clauses, select, null)); break; case "Avg": case "Sum": if (subExpression == null) subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null)); tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(call.Method.Name)), subExpression); return tree; case "Count": case "Any": if (call.Arguments.Count > 1) { if (subExpression != null) { var param = ((System.Linq.Expressions.LambdaExpression)call.Arguments[1]).Parameters[0]; var paramIdent = new Identifier(param.Name); identifiers.Add(param.Name, paramIdent); subExpression = new QueryExpression(new FromClause(param.Type.FullName, paramIdent, subExpression), new QueryBody(new ClauseList(new List<QueryBodyClause>() { new WhereClause(Visit(call.Arguments[1])) }), new SelectClause(paramIdent), null)); } else clauses.Add(new WhereClause(Visit(call.Arguments[1]))); } if (subExpression == null) subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null)); tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(call.Method.Name)), subExpression); return tree; case "Intersect": break; case "Where": clauses.Add(new WhereClause(Visit(call.Arguments[1]))); tree = null; if (from == null) from = new FromClause(null, identifiers["#First"], subExpression); break; case "OrderBy": NLINQ.Expression m = Visit(call.Arguments[1]); clauses.Add(new OrderByClause(new OrderByCriteria(m, true))); break; case "ThenBy": break; case "Infer": var inferQuery = new QueryTranslator(from.Type); var result = inferQuery.Visit(call.Arguments[1]); var first = inferQuery.identifiers["#First"]; NLINQ.MemberExpression me = (NLINQ.MemberExpression)result; while (me.Previous != first) me = (NLINQ.MemberExpression)me.Previous; me.Previous = null; if (inferQuery.tree != null) result = inferQuery.tree; InferredRelationShips.Add(result.ToString()); tree = subExpression; return subExpression; } } if (call.Method.DeclaringType == typeof(string) || call.Method.DeclaringType == typeof(DateTime)) { NLinq.Expressions.Expression source = Visit(call.Object); List<NLinq.Expressions.Expression> parameters = new List<NLinq.Expressions.Expression>(); foreach (var arg in call.Arguments) { var param = Visit(arg); if (param != null) parameters.Add(param); } return new NLinq.Expressions.MemberExpression( new NLinq.Expressions.MethodCall(new NLinq.Expressions.Identifier(call.Method.Name), parameters.ToArray()), source); } return null; }
public FromClause(string type, Identifier identifier, Expression expression) { this.type = type; this.identifier = identifier; this.expression = expression; }
public Like(Expression lhs, Expression rhs) : base(LikeIdentifier, lhs, rhs) { }
public WhereClause(Expression expression) { this.expression = expression; }
public IsNull(Expression nullable) : base(IsNullIdentifier, nullable) { }
public MethodCall(Identifier identifier, Expression[] parameters) { this.identifier = identifier; this.parameters = parameters; }
public ComplexColumnExpression(TableAlias alias, Expression innerExpression, string columnAlias) : base(alias, null, columnAlias) { Expression = innerExpression; }
public BinaryExpression(BinaryExpressionType type, Expression leftExpression, Expression rightExpression) { this.type = type; this.leftExpression = leftExpression; this.rightExpression = rightExpression; }
private Field[] GetFields(Expression expression) { FieldExtractionVisitor fev = new FieldExtractionVisitor(driver); fev.Visit(expression); return fev.Fields.ToArray(); }
public override Expression Visit(Expression exp) { previousIsDateTime = false; return base.Visit(exp); }
public ComplexColumnExpression(TableAlias alias, Expression innerExpression) : this(alias, innerExpression, (string)null) { }
public InPredicate(Expression[] values) : base(InPredicateIdentifier, values) { }
public Exists(Expression expression) : base(ExistsIdentifier, expression) { }
public Cast(Expression expressionToCast, DbType type) : base(CastIdentifier, new Expression[] { expressionToCast }) { Type = type; }
public OrderByCriteria(Expression expression, bool ascending) { this.expression = expression; this.ascending = ascending; }