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);
}
