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