public JoinExpression VisitJoin(MethodCallExpression expression) { // Handle the default Queryable extension Join if (IsDeclaring(expression, typeof(Queryable), typeof(Enumerable))) { // Resolve the sources ASourceExpression outer = Visit <ASourceExpression>(expression.Arguments[0]); ASourceExpression inner = Visit <ASourceExpression>(expression.Arguments[1]); // Set the active expressions (so fields calls can find their expression) sources = new[] { outer, inner }; // Create the predicate LambdaExpression outerLambda = (LambdaExpression)StripQuotes(expression.Arguments[2]); LambdaExpression innerLambda = (LambdaExpression)StripQuotes(expression.Arguments[3]); FieldExpression outerField = Visit <FieldExpression>(outerLambda.Body); FieldExpression innerField = Visit <FieldExpression>(innerLambda.Body); APredicateExpression predicate = new CompositeExpression(outerField, innerField, CompositeOperator.Equal); // Decode the result selector IEnumerable <FieldExpression> fields = DecodeJoinSelector(expression.Arguments[4], outer.Fields, inner.Fields); // Create the expression return(new JoinExpression(outer, inner, predicate, fields, JoinType.Inner)); } // Handle the default SqlQueryableHelper extension Join if (IsDeclaring(expression, typeof(SqlQueryableHelper))) { // Resolve the sources ASourceExpression outer = Visit <ASourceExpression>(expression.Arguments[0]); ASourceExpression inner = Visit <ASourceExpression>(expression.Arguments[1]); // Set the active expressions (so fields calls can find their expression) sources = new[] { outer, inner }; // Create the predicate LambdaExpression predicateLambda = (LambdaExpression)StripQuotes(expression.Arguments[2]); APredicateExpression predicate = Visit <APredicateExpression>(predicateLambda.Body); // Decode the result selector IEnumerable <FieldExpression> fields = DecodeJoinSelector(expression.Arguments[3], outer.Fields, inner.Fields); // Resolve the join type ConstantExpression joinType = (ConstantExpression)expression.Arguments[4]; // Create the expression return(new JoinExpression(outer, inner, predicate, fields, (JoinType)joinType.Value)); } throw new MethodTranslationException(expression.Method); }
private WhereExpression VisitWhere(MethodCallExpression expression) { // Handle the default Queryable extension Where if (IsDeclaring(expression, typeof(Queryable), typeof(Enumerable))) { ASourceExpression source = Visit <ASourceExpression>(expression.Arguments[0]); LambdaExpression lambda = (LambdaExpression)StripQuotes(expression.Arguments[1]); APredicateExpression predicate = Visit <APredicateExpression>(lambda.Body); return(new WhereExpression(source, predicate)); } throw new MethodTranslationException(expression.Method); }
/// <summary> /// Initializes a new instance of <see cref="WhereExpression"/> filtering the specified source. /// </summary> /// <param name="source">The source expression to select from.</param> public WhereExpression(ASourceExpression source, APredicateExpression predicate) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (predicate == null) { throw new ArgumentNullException(nameof(predicate)); } Source = source; Predicate = predicate; Fields = new FieldExpressions(this, source.Fields); Expressions = new[] { source }; }
/// <summary> /// Initializes a new instance of <see cref="JoinExpression"/> with the specified sources. /// </summary> /// <param name="outer">The outer source expression to aggregate.</param> /// <param name="inner">The inner source expression to aggregate.</param> /// <param name="predicate">The optional predicate to condition the join on.</param> /// <param name="fields">The fields to select from the sources. If null, all fields are selected.</param> /// <param name="joinType">The type of join to perform.</param> public JoinExpression(ASourceExpression outer, ASourceExpression inner, APredicateExpression predicate = null, IEnumerable <FieldExpression> fields = null, JoinType joinType = JoinType.Inner) { if (outer == null) { throw new ArgumentNullException(nameof(outer)); } if (inner == null) { throw new ArgumentNullException(nameof(inner)); } Outer = outer; Inner = inner; Predicate = predicate ?? new BooleanExpression(true); JoinType = joinType; fields = fields ?? outer.Fields.Concat(inner.Fields); Fields = new FieldExpressions(this, fields); Expressions = new[] { outer, inner }; }
private AggregateExpression VisitCount(MethodCallExpression expression) { if (IsDeclaring(expression, typeof(Queryable), typeof(Enumerable), typeof(SqlQueryableHelper))) { // Map the source ASourceExpression source = Visit <ASourceExpression>(expression.Arguments[0]); // Resolve the optional predicate if (expression.Arguments.Count > 1) { LambdaExpression lambda = (LambdaExpression)StripQuotes(expression.Arguments[1]); APredicateExpression predicate = Visit <APredicateExpression>(lambda.Body); source = new WhereExpression(source, predicate); } // Resolve the field to be counted (must be done after the source has been manipulated) FieldExpression field = source.Fields.First(); // Create the expression return(new AggregateExpression(source, field, AggregateFunction.Count)); } throw new MethodTranslationException(expression.Method); }