private void AddPostExecuteTransformerForCount() { // Count results have to be summed. No null case to take into account. var elementType = Model.ResultTypeOverride; var inputListType = typeof(IEnumerable <>).MakeGenericType(elementType); var inputList = Expression.Parameter(inputListType, "inputList"); // Sum has no suitable generic overload, throw in Sum on int, then the code using it // will check and adjust it if it is long instead of int (GetAggregateMethodCall does that). var aggregateCall = GetAggregateMethodCall(ReflectionCache.EnumerableMethods.SumOnInt, inputListType, elementType, inputList); _hqlTree.AddPostExecuteTransformer(Expression.Lambda(aggregateCall, inputList)); }
public void Process(AggregateResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree) { var inputExpr = ((StreamedSequenceInfo)queryModelVisitor.PreviousEvaluationType).ItemExpression; var inputType = inputExpr.Type; var paramExpr = Expression.Parameter(inputType, "item"); var accumulatorFunc = Expression.Lambda( ReplacingExpressionVisitor.Replace(inputExpr, paramExpr, resultOperator.Func.Body), resultOperator.Func.Parameters[0], paramExpr); // NH-3850: changed from list transformer (working on IEnumerable<object>) to post execute // transformer (working on IEnumerable<inputType>) for globally aggregating polymorphic results // instead of aggregating results for each class separately and yielding only the first. // If the aggregation relies on ordering, final result will still be wrong due to // polymorphic results being union-ed without re-ordering. (This is a limitation of all polymorphic // queries, this is not specific to LINQ provider.) var inputList = Expression.Parameter(typeof(IEnumerable <>).MakeGenericType(inputType), "inputList"); var aggregate = ReflectionCache.EnumerableMethods.AggregateDefinition.MakeGenericMethod(inputType); MethodCallExpression call = Expression.Call( aggregate, inputList, accumulatorFunc ); tree.AddPostExecuteTransformer(Expression.Lambda(call, inputList)); // There is no more a list transformer yielding an IList<resultType>, but this aggregate case // have inputType = resultType, so no further action is required. }
protected static void AddClientSideEval(MethodInfo target, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree) { target = target.MakeGenericMethod(queryModelVisitor.CurrentEvaluationType.DataType); var parameter = Expression.Parameter(queryModelVisitor.PreviousEvaluationType.DataType, null); var lambda = Expression.Lambda( Expression.Call( target, parameter), parameter); tree.AddPostExecuteTransformer(lambda); }
protected static void AddClientSideEval(MethodInfo target, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree) { target = target.MakeGenericMethod(queryModelVisitor.CurrentEvaluationType.DataType); var parameter = Expression.Parameter(queryModelVisitor.PreviousEvaluationType.DataType, null); var lambda = Expression.Lambda( Expression.Call( target, parameter), parameter); tree.AddPostExecuteTransformer(lambda); }
protected static void AddClientSideEval(MethodInfo target, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree) { var type = queryModelVisitor.Model.SelectClause.Selector.Type; target = target.MakeGenericMethod(type); var parameter = Expression.Parameter(typeof(IQueryable<>).MakeGenericType(type), null); var lambda = Expression.Lambda( Expression.Call( target, parameter), parameter); tree.AddPostExecuteTransformer(lambda); }
protected static void AddClientSideEval(MethodInfo target, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree) { var type = queryModelVisitor.Model.ResultTypeOverride ?? queryModelVisitor.Model.SelectClause.Selector.Type; target = target.MakeGenericMethod(type); var parameter = Expression.Parameter(typeof(IQueryable <>).MakeGenericType(type), null); var lambda = Expression.Lambda( Expression.Call( target, parameter), parameter); tree.AddPostExecuteTransformer(lambda); }
public void Process(AnyResultOperator anyOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree) { if (tree.IsRoot) { tree.AddTakeClause(tree.TreeBuilder.Constant(1)); Expression <Func <IEnumerable <object>, bool> > x = l => l.Any(); tree.AddListTransformer(x); // NH-3850: Queries with polymorphism yields many results which must be combined. Expression <Func <IEnumerable <bool>, bool> > px = l => l.Any(r => r); tree.AddPostExecuteTransformer(px); } else { tree.SetRoot(tree.TreeBuilder.Exists((HqlQuery)tree.Root)); } }
public void Process(AllResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree) { tree.AddWhereClause(tree.TreeBuilder.BooleanNot( HqlGeneratorExpressionVisitor.Visit(resultOperator.Predicate, queryModelVisitor.VisitorParameters). ToBooleanExpression())); if (tree.IsRoot) { tree.AddTakeClause(tree.TreeBuilder.Constant(1)); Expression <Func <IEnumerable <object>, bool> > x = l => !l.Any(); tree.AddListTransformer(x); // NH-3850: Queries with polymorphism yields many results which must be combined. Expression <Func <IEnumerable <bool>, bool> > px = l => l.All(r => r); tree.AddPostExecuteTransformer(px); } else { tree.SetRoot(tree.TreeBuilder.BooleanNot(tree.TreeBuilder.Exists((HqlQuery)tree.Root))); } }