protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (_methodsToExclude.Any(method => QueryableUtility.IsQueryableMethod(node, method)))
{
return(Visit(node.Arguments[0]));
}
return(base.VisitMethodCall(node));
}
private Expression GetInnerExpression(Expression expression)
{
// First replace the this IQueryable with the enumerable query
expression = QueryableUtility.ReplaceQueryableExpression(_enumerableQuery, expression);
// Evaluate the closure variables
return(new ClosureEvaluator().Visit(expression));
}
private IQueryable CreateQuery(Type elementType, System.Linq.Expressions.Expression expression)
{
Type[] typeArguments = new Type[] { elementType };
IList <IEnumerable <TVal> > subQueries = this._subQueries;
if (QueryableUtility.IsQueryableMethod(expression, "Where") || QueryableUtility.IsOrderingMethod(expression))
{
subQueries = this.GetSubQueries(expression);
}
object[] parameters = new object[] { this._queryables, this._equalityComparer, subQueries, expression, this._logger, this._ignoreFailures };
return((IQueryable)typeof(AggregateQuery <>).MakeGenericType(typeArguments).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance).Single <ConstructorInfo>().Invoke(parameters));
}
public TResult Execute <TResult>(Expression expression)
{
var results = (from queryable in _queryables
select TryExecute <TResult>(queryable, expression)).AsQueryable();
if (QueryableUtility.IsQueryableMethod(expression, "Count"))
{
// HACK: This is in correct since we aren't removing duplicates but count is mostly for paging
// so we don't care *that* much
return((TResult)(object)results.Cast <int>().Sum());
}
return(TryExecute <TResult>(results, expression));
}
public IQueryable CreateQuery(System.Linq.Expressions.Expression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
Type elementType = QueryableUtility.FindGenericType(typeof(IQueryable <>), expression.Type);
if (elementType == null)
{
throw new ArgumentException(string.Empty, "expression");
}
return(this.CreateQuery(elementType, expression));
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (QueryableUtility.IsOrderingMethod(node))
{
this._inOrderExpression = true;
Expression <Func <TElement, IComparable> > operand = (Expression <Func <TElement, IComparable> >)((UnaryExpression)this.Visit(node.Arguments[1])).Operand;
Ordering <TElement, TElement> item = new Ordering <TElement, TElement>();
item.Descending = node.Method.Name.EndsWith("Descending", StringComparison.OrdinalIgnoreCase);
item.Extractor = operand.Compile();
this._orderings.Push(item);
this._inOrderExpression = false;
}
return(base.VisitMethodCall(node));
}
private IQueryable CreateQuery(Type elementType, Expression expression)
{
var queryType = typeof(AggregateQuery <>).MakeGenericType(elementType);
var ctor = queryType.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance).Single();
var subQueries = _subQueries;
// Only update subqueries for ordering and where clauses
if (QueryableUtility.IsQueryableMethod(expression, "Where") ||
QueryableUtility.IsOrderingMethod(expression))
{
subQueries = GetSubQueries(expression);
}
return((IQueryable)ctor.Invoke(new object[] { _queryables, _equalityComparer, subQueries, expression, _logger, _ignoreFailures }));
}
public IQueryable CreateQuery(Expression expression)
{
// Copied logic from EnumerableQuery
if (expression == null)
{
throw new ArgumentNullException("expression");
}
Type elementType = QueryableUtility.FindGenericType(typeof(IQueryable <>), expression.Type);
if (elementType == null)
{
throw new ArgumentException(String.Empty, "expression");
}
return(CreateQuery(elementType, expression));
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (QueryableUtility.IsOrderingMethod(node))
{
_inOrderExpression = true;
// The lambdas are wrapped in a unary expression
var unaryExpression = (UnaryExpression)Visit(node.Arguments[1]);
var lambda = (Expression <Func <TElement, IComparable> >)unaryExpression.Operand;
// Push the sort expression on the stack so we can compare later
_orderings.Push(new Ordering <TElement> {
Descending = node.Method.Name.EndsWith("Descending", StringComparison.OrdinalIgnoreCase),
Extractor = lambda.Compile()
});
_inOrderExpression = false;
}
return(base.VisitMethodCall(node));
}
private Expression GetInnerExpression(Expression expression)
{
return(QueryableUtility.ReplaceQueryableExpression(_query, expression));
}
protected override Expression VisitMethodCall(MethodCallExpression node) => (!Enumerable.Any <string>(this._methodsToExclude, method => QueryableUtility.IsQueryableMethod(node, method)) ? base.VisitMethodCall(node) : this.Visit(node.Arguments[0]));
public TResult Execute <TResult>(System.Linq.Expressions.Expression expression)
{
IQueryable <TResult> queryable = (from queryable in this._queryables select((AggregateQuery <TVal>) this).TryExecute <TResult>(queryable, expression)).AsQueryable <TResult>();
return(!QueryableUtility.IsQueryableMethod(expression, "Count") ? this.TryExecute <TResult>(queryable, expression) : ((TResult)queryable.Cast <int>().Sum()));
}
