/// <summary> /// Clones this <see cref="QueryModel"/>, returning a new <see cref="QueryModel"/> equivalent to this instance, but with its clauses being /// clones of this instance's clauses. Any <see cref="QuerySourceReferenceExpression"/> in the cloned clauses that points back to another clause /// in this <see cref="QueryModel"/> (including its subqueries) is adjusted to point to the respective clones in the cloned /// <see cref="QueryModel"/>. Any subquery nested in the <see cref="QueryModel"/> is also cloned. /// </summary> /// <param name="querySourceMapping">The <see cref="QuerySourceMapping"/> defining how to adjust instances of /// <see cref="QuerySourceReferenceExpression"/> in the cloned <see cref="QueryModel"/>. If there is a <see cref="QuerySourceReferenceExpression"/> /// that points out of the <see cref="QueryModel"/> being cloned, specify its replacement via this parameter. At the end of the cloning process, /// this object maps all the clauses in this original <see cref="QueryModel"/> to the clones created in the process. /// </param> public QueryModel Clone(QuerySourceMapping querySourceMapping) { ArgumentUtility.CheckNotNull("querySourceMapping", querySourceMapping); var cloneContext = new CloneContext(querySourceMapping); var queryModelBuilder = new QueryModelBuilder(); queryModelBuilder.AddClause(MainFromClause.Clone(cloneContext)); foreach (var bodyClause in BodyClauses) { queryModelBuilder.AddClause(bodyClause.Clone(cloneContext)); } queryModelBuilder.AddClause(SelectClause.Clone(cloneContext)); foreach (var resultOperator in ResultOperators) { var resultOperatorClone = resultOperator.Clone(cloneContext); queryModelBuilder.AddResultOperator(resultOperatorClone); } var clone = queryModelBuilder.Build(); var cloningExpressionVisitor = new CloningExpressionVisitor(cloneContext.QuerySourceMapping); clone.TransformExpressions(cloningExpressionVisitor.Visit); clone.ResultTypeOverride = ResultTypeOverride; return(clone); }
private static void ApplyParentOrderings( IEnumerable <Ordering> parentOrderings, QueryModel queryModel, QuerySourceMapping querySourceMapping, bool reverseOrdering) { var orderByClause = queryModel.BodyClauses.OfType <OrderByClause>().LastOrDefault(); if (orderByClause == null) { queryModel.BodyClauses.Add(orderByClause = new OrderByClause()); } foreach (var ordering in parentOrderings) { var newExpression = CloningExpressionVisitor .AdjustExpressionAfterCloning(ordering.Expression, querySourceMapping); if (newExpression is MethodCallExpression methodCallExpression && methodCallExpression.Method.IsEFPropertyMethod()) { newExpression = new NullConditionalExpression( methodCallExpression.Arguments[0], methodCallExpression.Arguments[0], methodCallExpression); } orderByClause.Orderings .Add(new Ordering(newExpression, ordering.OrderingDirection)); } if (reverseOrdering) { foreach (var ordering in orderByClause.Orderings) { ordering.OrderingDirection = ordering.OrderingDirection == OrderingDirection.Asc ? OrderingDirection.Desc : OrderingDirection.Asc; } } }
private static void LiftOrderBy( IQuerySource querySource, Expression targetExpression, QueryModel fromQueryModel, QueryModel toQueryModel, List <Expression> subQueryProjection) { var canRemove = !fromQueryModel.ResultOperators .Any(r => r is SkipResultOperator || r is TakeResultOperator); foreach (var orderByClause in fromQueryModel.BodyClauses.OfType <OrderByClause>().ToArray()) { var outerOrderByClause = new OrderByClause(); foreach (var ordering in orderByClause.Orderings) { int projectionIndex; var orderingExpression = ordering.Expression; if (ordering.Expression.RemoveConvert() is NullConditionalExpression nullConditionalExpression) { orderingExpression = nullConditionalExpression.AccessOperation; } QuerySourceReferenceExpression orderingExpressionQsre = null; string orderingExpressionName = null; if (orderingExpression.RemoveConvert() is MemberExpression memberExpression && memberExpression.Expression.RemoveConvert() is QuerySourceReferenceExpression memberQsre && memberQsre.ReferencedQuerySource == querySource) { orderingExpressionQsre = memberQsre; orderingExpressionName = memberExpression.Member.Name; } if (orderingExpression.RemoveConvert() is MethodCallExpression methodCallExpression && methodCallExpression.IsEFProperty() && methodCallExpression.Arguments[0].RemoveConvert() is QuerySourceReferenceExpression methodCallQsre && methodCallQsre.ReferencedQuerySource == querySource) { orderingExpressionQsre = methodCallQsre; orderingExpressionName = (string)((ConstantExpression)methodCallExpression.Arguments[1]).Value; } if (orderingExpressionQsre != null && orderingExpressionName != null) { projectionIndex = subQueryProjection .FindIndex( e => { var expressionWithoutConvert = e.RemoveConvert(); var projectionExpression = (expressionWithoutConvert as NullConditionalExpression)?.AccessOperation ?? expressionWithoutConvert; if (projectionExpression is MethodCallExpression methodCall && methodCall.Method.IsEFPropertyMethod()) { var properyQsre = (QuerySourceReferenceExpression)methodCall.Arguments[0].RemoveConvert(); var propertyName = (string)((ConstantExpression)methodCall.Arguments[1]).Value; return(properyQsre.ReferencedQuerySource == orderingExpressionQsre.ReferencedQuerySource && propertyName == orderingExpressionName); } if (projectionExpression is MemberExpression projectionMemberExpression) { var projectionMemberQsre = (QuerySourceReferenceExpression)projectionMemberExpression.Expression.RemoveConvert(); return(projectionMemberQsre.ReferencedQuerySource == orderingExpressionQsre.ReferencedQuerySource && projectionMemberExpression.Member.Name == orderingExpressionName); } return(false); }); } else { projectionIndex = subQueryProjection // Do NOT use orderingExpression variable here .FindIndex(e => _expressionEqualityComparer.Equals(e.RemoveConvert(), ordering.Expression.RemoveConvert())); } if (projectionIndex == -1) { projectionIndex = subQueryProjection.Count; subQueryProjection.Add( Expression.Convert( // Workaround re-linq#RMLNQ-111 - When this is fixed the Clone can go away CloningExpressionVisitor.AdjustExpressionAfterCloning( ordering.Expression, new QuerySourceMapping()), typeof(object))); } var newExpression = Expression.Call( targetExpression, AnonymousObject.GetValueMethodInfo, Expression.Constant(projectionIndex)); outerOrderByClause.Orderings .Add(new Ordering(newExpression, ordering.OrderingDirection)); } toQueryModel.BodyClauses.Add(outerOrderByClause); if (canRemove) { fromQueryModel.BodyClauses.Remove(orderByClause); } } }
private Expression Rewrite( int correlatedCollectionIndex, QueryModel collectionQueryModel, INavigation navigation, bool trackingQuery, QuerySourceReferenceExpression originQuerySource, bool forceListResult) { var querySourceReferenceFindingExpressionTreeVisitor = new QuerySourceReferenceFindingExpressionTreeVisitor(); var originalCorrelationPredicate = collectionQueryModel.BodyClauses.OfType <WhereClause>().Single(c => c.Predicate is NullConditionalEqualExpression); collectionQueryModel.BodyClauses.Remove(originalCorrelationPredicate); originalCorrelationPredicate.TransformExpressions(querySourceReferenceFindingExpressionTreeVisitor.Visit); var parentQuerySourceReferenceExpression = querySourceReferenceFindingExpressionTreeVisitor.QuerySourceReferenceExpression; querySourceReferenceFindingExpressionTreeVisitor = new QuerySourceReferenceFindingExpressionTreeVisitor(); querySourceReferenceFindingExpressionTreeVisitor.Visit(((NullConditionalEqualExpression)originalCorrelationPredicate.Predicate).InnerKey); var currentKey = BuildKeyAccess(navigation.ForeignKey.Properties, querySourceReferenceFindingExpressionTreeVisitor.QuerySourceReferenceExpression); // PK of the parent qsre var originKey = BuildKeyAccess(_queryCompilationContext.Model.FindEntityType(originQuerySource.Type).FindPrimaryKey().Properties, originQuerySource); // principal side of the FK relationship between parent and this collection var outerKey = BuildKeyAccess(navigation.ForeignKey.PrincipalKey.Properties, parentQuerySourceReferenceExpression); var parentQuerySource = parentQuerySourceReferenceExpression.ReferencedQuerySource; // ordering priority for parent: // - user specified orderings // - parent PK // - principal side of the FK between parent and child // ordering priority for child: // - user specified orderings on parent (from join) // - parent PK (from join) // - dependent side of the FK between parent and child // - customer specified orderings on child var parentOrderings = new List <Ordering>(); var exisingParentOrderByClause = _parentQueryModel.BodyClauses.OfType <OrderByClause>().LastOrDefault(); if (exisingParentOrderByClause != null) { parentOrderings.AddRange(exisingParentOrderByClause.Orderings); } var originEntityType = _queryCompilationContext.Model.FindEntityType(originQuerySource.Type); foreach (var property in originEntityType.FindPrimaryKey().Properties) { TryAddPropertyToOrderings(property, originQuerySource, parentOrderings); } foreach (var property in navigation.ForeignKey.PrincipalKey.Properties) { TryAddPropertyToOrderings(property, parentQuerySourceReferenceExpression, parentOrderings); } _parentOrderings.AddRange(parentOrderings); // if selector contains multiple correlated collections, visiting the first one changes that collections QM (changing it's type) // which makes the parent QM inconsistent temporarily. QM's type is different but the CorrelateCollections method that fixes the result type // is not part of the QM and it's added only when the entire Selector is replaced - i.e. after all it's components have been visited // since when we clone the parent QM, we don't care about it's original selector anyway (it's being discarded) // we avoid cloning the selector in the first place and avoid all the potential problem with temporarily mismatched types of the subqueries inside var parentSelectClause = _parentQueryModel.SelectClause; _parentQueryModel.SelectClause = new SelectClause(Expression.Default(parentSelectClause.Selector.Type)); var querySourceMapping = new QuerySourceMapping(); var clonedParentQueryModel = _parentQueryModel.Clone(querySourceMapping); _parentQueryModel.SelectClause = parentSelectClause; _queryCompilationContext.UpdateMapping(querySourceMapping); _queryCompilationContext.CloneAnnotations(querySourceMapping, clonedParentQueryModel); var clonedParentQuerySourceReferenceExpression = (QuerySourceReferenceExpression)querySourceMapping.GetExpression(parentQuerySource); var clonedParentQuerySource = clonedParentQuerySourceReferenceExpression.ReferencedQuerySource; var parentItemName = parentQuerySource.HasGeneratedItemName() ? navigation.DeclaringEntityType.DisplayName()[0].ToString().ToLowerInvariant() : parentQuerySource.ItemName; collectionQueryModel.MainFromClause.ItemName = $"{parentItemName}.{navigation.Name}"; var collectionQuerySourceReferenceExpression = new QuerySourceReferenceExpression(collectionQueryModel.MainFromClause); var subQueryProjection = new List <Expression>(); subQueryProjection.AddRange(parentOrderings.Select(o => CloningExpressionVisitor.AdjustExpressionAfterCloning(o.Expression, querySourceMapping))); var joinQuerySourceReferenceExpression = CreateJoinToParentQuery( clonedParentQueryModel, clonedParentQuerySourceReferenceExpression, collectionQuerySourceReferenceExpression, navigation.ForeignKey, collectionQueryModel, subQueryProjection); ApplyParentOrderings( parentOrderings, clonedParentQueryModel, querySourceMapping); LiftOrderBy( joinQuerySourceReferenceExpression, clonedParentQueryModel, collectionQueryModel); clonedParentQueryModel.SelectClause.Selector = Expression.New( MaterializedAnonymousObject.AnonymousObjectCtor, Expression.NewArrayInit( typeof(object), subQueryProjection.Select(e => Expression.Convert(e, typeof(object))))); clonedParentQueryModel.ResultTypeOverride = typeof(IQueryable <>).MakeGenericType(clonedParentQueryModel.SelectClause.Selector.Type); var newOriginKey = CloningExpressionVisitor .AdjustExpressionAfterCloning(originKey, querySourceMapping); var newOriginKeyElements = ((NewArrayExpression)(((NewExpression)newOriginKey).Arguments[0])).Expressions; var remappedOriginKeyElements = RemapOriginKeyExpressions(newOriginKeyElements, joinQuerySourceReferenceExpression, subQueryProjection); var tupleCtor = typeof(Tuple <, ,>).MakeGenericType( collectionQueryModel.SelectClause.Selector.Type, typeof(MaterializedAnonymousObject), typeof(MaterializedAnonymousObject)).GetConstructors().FirstOrDefault(); var navigationParameter = Expression.Parameter(typeof(INavigation), "n"); var correlateSubqueryMethod = _queryCompilationContext.IsAsyncQuery ? _correlateSubqueryAsyncMethodInfo : _correlateSubqueryMethodInfo; Expression resultCollectionFactoryExpressionBody; if (forceListResult || navigation.ForeignKey.DeclaringEntityType.ClrType != collectionQueryModel.SelectClause.Selector.Type) { var resultCollectionType = typeof(List <>).MakeGenericType(collectionQueryModel.SelectClause.Selector.Type); var resultCollectionCtor = resultCollectionType.GetTypeInfo().GetDeclaredConstructor(new Type[] { }); correlateSubqueryMethod = correlateSubqueryMethod.MakeGenericMethod( collectionQueryModel.SelectClause.Selector.Type, typeof(List <>).MakeGenericType(collectionQueryModel.SelectClause.Selector.Type)); resultCollectionFactoryExpressionBody = Expression.New(resultCollectionCtor); trackingQuery = false; } else { correlateSubqueryMethod = correlateSubqueryMethod.MakeGenericMethod( collectionQueryModel.SelectClause.Selector.Type, navigation.GetCollectionAccessor().CollectionType); resultCollectionFactoryExpressionBody = Expression.Convert( Expression.Call( Expression.Call(_getCollectionAccessorMethodInfo, navigationParameter), _createCollectionMethodInfo), navigation.GetCollectionAccessor().CollectionType); } var resultCollectionFactoryExpression = Expression.Lambda( resultCollectionFactoryExpressionBody, navigationParameter); collectionQueryModel.SelectClause.Selector = Expression.New( tupleCtor, new Expression[] { collectionQueryModel.SelectClause.Selector, currentKey, Expression.New( MaterializedAnonymousObject.AnonymousObjectCtor, Expression.NewArrayInit( typeof(object), remappedOriginKeyElements)) }); var collectionModelSelectorType = collectionQueryModel.SelectClause.Selector.Type; // Enumerable or OrderedEnumerable collectionQueryModel.ResultTypeOverride = collectionQueryModel.BodyClauses.OfType <OrderByClause>().Any() ? typeof(IOrderedEnumerable <>).MakeGenericType(collectionModelSelectorType) : typeof(IEnumerable <>).MakeGenericType(collectionModelSelectorType); var lambda = (Expression)Expression.Lambda(new SubQueryExpression(collectionQueryModel)); if (_queryCompilationContext.IsAsyncQuery) { lambda = Expression.Convert( lambda, typeof(Func <>).MakeGenericType( typeof(IAsyncEnumerable <>).MakeGenericType(collectionModelSelectorType))); } // since we cloned QM, we need to check if it's query sources require materialization (e.g. TypeIs operation for InMemory) _queryCompilationContext.FindQuerySourcesRequiringMaterialization(_queryModelVisitor, collectionQueryModel); var correlationPredicate = CreateCorrelationPredicate(navigation); var arguments = new List <Expression> { Expression.Constant(correlatedCollectionIndex), Expression.Constant(navigation), resultCollectionFactoryExpression, outerKey, Expression.Constant(trackingQuery), lambda, correlationPredicate }; if (_queryCompilationContext.IsAsyncQuery) { arguments.Add(_cancellationTokenParameter); } var result = Expression.Call( Expression.Property( EntityQueryModelVisitor.QueryContextParameter, nameof(QueryContext.QueryBuffer)), correlateSubqueryMethod, arguments); if (_queryCompilationContext.IsAsyncQuery) { var taskResultExpression = new TaskBlockingExpressionVisitor().Visit(result); return(taskResultExpression); } return(result); }
/// <summary> /// Clones this <see cref="QueryModel"/>, returning a new <see cref="QueryModel"/> equivalent to this instance, but with its clauses being /// clones of this instance's clauses. Any <see cref="QuerySourceReferenceExpression"/> in the cloned clauses that points back to another clause /// in this <see cref="QueryModel"/> (including its subqueries) is adjusted to point to the respective clones in the cloned /// <see cref="QueryModel"/>. Any subquery nested in the <see cref="QueryModel"/> is also cloned. /// </summary> /// <param name="querySourceMapping">The <see cref="QuerySourceMapping"/> defining how to adjust instances of /// <see cref="QuerySourceReferenceExpression"/> in the cloned <see cref="QueryModel"/>. If there is a <see cref="QuerySourceReferenceExpression"/> /// that points out of the <see cref="QueryModel"/> being cloned, specify its replacement via this parameter. At the end of the cloning process, /// this object maps all the clauses in this original <see cref="QueryModel"/> to the clones created in the process. /// </param> public QueryModel Clone (QuerySourceMapping querySourceMapping) { ArgumentUtility.CheckNotNull ("querySourceMapping", querySourceMapping); var cloneContext = new CloneContext (querySourceMapping); var queryModelBuilder = new QueryModelBuilder(); queryModelBuilder.AddClause (MainFromClause.Clone (cloneContext)); foreach (var bodyClause in BodyClauses) queryModelBuilder.AddClause (bodyClause.Clone (cloneContext)); queryModelBuilder.AddClause (SelectClause.Clone (cloneContext)); foreach (var resultOperator in ResultOperators) { var resultOperatorClone = resultOperator.Clone (cloneContext); queryModelBuilder.AddResultOperator (resultOperatorClone); } var clone = queryModelBuilder.Build (); var cloningExpressionVisitor = new CloningExpressionVisitor (cloneContext.QuerySourceMapping); clone.TransformExpressions (cloningExpressionVisitor.Visit); clone.ResultTypeOverride = ResultTypeOverride; return clone; }