protected override void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex) { var subQueryModel = subQueryExpression.QueryModel; MoveResultOperatorsToParent(queryModel, subQueryModel); base.FlattenSubQuery(subQueryExpression, fromClause, queryModel, destinationIndex); }
/// <summary>Visits a type binary expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitTypeBinary(System.Linq.Expressions.TypeBinaryExpression expression) { var classMappings = MappingsRepository.FindMappedClasses(expression.TypeOperand); if (classMappings.Any()) { Remotion.Linq.Clauses.FromClauseBase sourceExpression = GetSourceExpression(expression.Expression); StrongEntityAccessor entityAccessor = _query.FindAllComponents <StrongEntityAccessor>().FirstOrDefault(item => item.SourceExpression == sourceExpression); if (entityAccessor == null) { entityAccessor = this.GetEntityAccessor(sourceExpression); _query.Elements.Add(entityAccessor); } EntityTypeConstrain typeConstrain = this.CreateTypeConstrain(expression.TypeOperand, entityAccessor.SourceExpression.FromExpression); _lastComponent = typeConstrain; if ((_currentComponent.Count > 0) && (_currentComponent.Peek() is BinaryOperatorNavigator)) { HandleComponent(typeConstrain); } else if (!entityAccessor.Elements.Contains(typeConstrain)) { entityAccessor.Elements.Add(typeConstrain); } } else { return(base.VisitTypeBinary(expression)); } return(expression); }
private void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel) { // Move the result operator up if (queryModel.ResultOperators.Count != 0) { throw new NotImplementedException(); } var groupBy = (GroupResultOperator) subQueryExpression.QueryModel.ResultOperators[0]; // Replace the outer select clause... queryModel.SelectClause.TransformExpressions(s => GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryExpression.QueryModel)); queryModel.SelectClause.TransformExpressions( s => new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryExpression.QueryModel.MainFromClause).Swap (s)); MainFromClause innerMainFromClause = subQueryExpression.QueryModel.MainFromClause; CopyFromClauseData(innerMainFromClause, fromClause); foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses) { queryModel.BodyClauses.Add(bodyClause); } queryModel.ResultOperators.Add(groupBy); }
/// <summary>Visits a member expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitMember(System.Linq.Expressions.MemberExpression expression) { if ((expression.Member.Name == "Id") && (typeof(IEntity).IsAssignableFrom(expression.Member.DeclaringType))) { Remotion.Linq.Clauses.FromClauseBase target = GetMemberTarget(expression); if (target != null) { return(VisitEntityId(new EntityIdentifierExpression(expression, target))); } ExceptionHelper.ThrowInvalidCastException(typeof(IEntity), expression.Member.DeclaringType); } else if (expression.Member is PropertyInfo) { IPropertyMapping propertyMapping = _entityContext.Mappings.FindPropertyMapping((PropertyInfo)expression.Member); if (propertyMapping != null) { Remotion.Linq.Clauses.FromClauseBase target = GetMemberTarget(expression); if (target != null) { return(VisitEntityProperty(new EntityPropertyExpression(expression, propertyMapping, target, (_itemNameOverride ?? expression.Member.Name)))); } ExceptionHelper.ThrowInvalidCastException(typeof(IEntity), expression.Member.DeclaringType); } else { return(VisitProperty(expression)); } } return(base.VisitMember(expression)); }
/// <summary>Visits a sub-query expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitSubQuery(SubQueryExpression expression) { Remotion.Linq.Clauses.FromClauseBase sourceExpression = (Remotion.Linq.Clauses.FromClauseBase)((QuerySourceReferenceExpression)expression.QueryModel.SelectClause.Selector).ReferencedQuerySource; StrongEntityAccessor entityAccessor = (sourceExpression.FromExpression is System.Linq.Expressions.ConstantExpression ? null : this.GetEntityAccessor(sourceExpression)); if (entityAccessor != null) { Query query = _query.CreateSubQuery(entityAccessor.About); query.AddEntityAccessor(entityAccessor); EntityQueryModelVisitor queryModelVisitor = new EntityQueryModelVisitor(query, _entityContext); queryModelVisitor.VisitQueryModel(expression.QueryModel); _lastComponent = queryModelVisitor.Result; HandleComponent(_lastComponent); } else { NonEntityQueryModelVisitor queryModelVisitor = new NonEntityQueryModelVisitor(this, ConstantFromClause); Stack <IQueryComponentNavigator> currentComponent = _currentComponent; _currentComponent = new Stack <IQueryComponentNavigator>(); queryModelVisitor.VisitQueryModel(expression.QueryModel); _currentComponent = currentComponent; _lastComponent = queryModelVisitor.Result; HandleComponent(_lastComponent); } return(expression); }
/// <summary>Visits an <see cref="EntityExtensions.Predicate" /> method call.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Returns visited expression.</returns> protected virtual System.Linq.Expressions.Expression VisitPredicateMethodCall(System.Linq.Expressions.MethodCallExpression expression) { object objectValue = ((System.Linq.Expressions.ConstantExpression)expression.Arguments[1]).Value; if (objectValue is Uri) { Uri predicate = (Uri)objectValue; if (!predicate.IsAbsoluteUri) { predicate = new Uri(_entityContext.BaseUriSelector.SelectBaseUri(new EntityId(predicate)), predicate.ToString()); } Visit(expression.Arguments[0]); StrongEntityAccessor entityAccessor = null; Remotion.Linq.Clauses.FromClauseBase sourceExpression = null; if (expression.Arguments[0] is System.Linq.Expressions.MemberExpression) { System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)expression.Arguments[0]; if (memberExpression.Member is PropertyInfo) { PropertyInfo propertyInfo = (PropertyInfo)memberExpression.Member; sourceExpression = new AdditionalFromClause(propertyInfo.Name, propertyInfo.PropertyType, memberExpression); _query.AddEntityAccessor(entityAccessor = this.GetEntityAccessor(sourceExpression)); } else { return(base.VisitMethodCall(expression)); } } else { entityAccessor = this.GetEntityAccessor(GetSourceExpression(expression.Arguments[0])); } if (entityAccessor != null) { return(VisitPredicateMethodCallInternal(expression, predicate, entityAccessor)); } return(expression); } else { return(base.VisitMethodCall(expression)); } }
private Remotion.Linq.Clauses.FromClauseBase GetSourceExpression(System.Linq.Expressions.Expression expression) { Remotion.Linq.Clauses.FromClauseBase result = null; System.Linq.Expressions.Expression currentExpression = expression; bool isChange = false; while (currentExpression != null) { if (currentExpression is System.Linq.Expressions.MemberExpression) { System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)currentExpression; if (!(memberExpression.Member is PropertyInfo)) { throw CreateUnhandledItemException <System.Linq.Expressions.MemberExpression>(memberExpression, "GetSourceExpression"); } currentExpression = memberExpression.Expression; isChange = true; } else if (currentExpression is Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression) { result = (Remotion.Linq.Clauses.FromClauseBase)((Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression)currentExpression).ReferencedQuerySource; if (!typeof(IQueryable).IsAssignableFrom(result.FromExpression.Type)) { Stack <IQueryComponentNavigator> currentComponent = _currentComponent; _currentComponent = new Stack <IQueryComponentNavigator>(); Visit(result.FromExpression); _currentComponent = currentComponent; isChange = true; } break; } if (isChange) { isChange = false; } else { break; } } return(result); }
private static void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex) { if (!CheckFlattenable(subQueryExpression.QueryModel)) return; var mainFromClause = subQueryExpression.QueryModel.MainFromClause; CopyFromClauseData(mainFromClause, fromClause); var innerSelectorMapping = new QuerySourceMapping(); innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector); queryModel.TransformExpressions((ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false))); InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex); CopyResultOperators(subQueryExpression.QueryModel.ResultOperators, queryModel); var innerBodyClauseMapping = new QuerySourceMapping(); innerBodyClauseMapping.AddMapping(mainFromClause, new QuerySourceReferenceExpression(fromClause)); queryModel.TransformExpressions((ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false))); }
internal static Remotion.Linq.Clauses.FromClauseBase TransformFromExpression(this IQueryVisitor visitor, Remotion.Linq.Clauses.FromClauseBase sourceExpression) { Remotion.Linq.Clauses.FromClauseBase result = sourceExpression; System.Linq.Expressions.Expression expression = visitor.TransformUnaryExpression(sourceExpression.FromExpression); if (expression != sourceExpression.FromExpression) { object item; if (!TransformedExpressionsCache.TryGetValue(sourceExpression, out item)) { TransformedExpressionsCache[sourceExpression] = result = new AdditionalFromClause(sourceExpression.ItemName, sourceExpression.ItemType, (System.Linq.Expressions.MemberExpression)expression); } else { result = (AdditionalFromClause)item; } } return(result); }
internal Remotion.Linq.Clauses.FromClauseBase GetMemberTarget(System.Linq.Expressions.MemberExpression expression) { Remotion.Linq.Clauses.FromClauseBase result = null; System.Linq.Expressions.MemberExpression memberExpression = expression.Expression as System.Linq.Expressions.MemberExpression; if ((memberExpression == null) && ((memberExpression = ((IQueryVisitor)this).TransformUnaryExpression(expression.Expression) as System.Linq.Expressions.MemberExpression) != null)) { SafeVisitExpression(memberExpression); } if (memberExpression is System.Linq.Expressions.MemberExpression) { if (memberExpression.Member is PropertyInfo) { PropertyInfo propertyInfo = (PropertyInfo)memberExpression.Member; string itemName = propertyInfo.Name.CamelCase(); StrongEntityAccessor entityAccessor = _query.FindAllComponents <StrongEntityAccessor>().Where(item => item.SourceExpression.FromExpression == memberExpression).FirstOrDefault(); if (entityAccessor != null) { itemName = _query.RetrieveIdentifier(entityAccessor.About.Name); } else { SafeVisitExpression(memberExpression); } result = new AdditionalFromClause(itemName, propertyInfo.PropertyType.FindItemType(), memberExpression); } else { throw CreateUnhandledItemException <System.Linq.Expressions.MemberExpression>(expression, "GetMemberTarget"); } } else { result = GetSourceExpression(expression); } return(result); }
/// <summary>Visits a query source expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited.</returns> protected override System.Linq.Expressions.Expression VisitQuerySourceReference(QuerySourceReferenceExpression expression) { Remotion.Linq.Clauses.FromClauseBase sourceExpression = GetSourceExpression(expression); StrongEntityAccessor entityAccessor = this.GetEntityAccessor(sourceExpression); if (entityAccessor != null) { _query.AddEntityAccessor(entityAccessor); _lastComponent = _query; } else { _lastComponent = (from entityConstrain in _query.FindAllComponents <EntityConstrain>() where entityConstrain.GetType() == typeof(EntityConstrain) let identifier = entityConstrain.Value as Identifier let targetExpression = ((IQueryVisitor)this).TransformFromExpression(sourceExpression).FromExpression where (identifier != null) && (targetExpression != null) && (entityConstrain.TargetExpression.EqualsTo(targetExpression)) select identifier).FirstOrDefault(); HandleComponent(_lastComponent); } return(expression); }
public PagingRewriterSelectClauseVisitor(FromClauseBase querySource) { this.querySource = querySource; }
protected virtual void FlattenSubQuery ( SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex) { ArgumentUtility.CheckNotNull ("subQueryExpression", subQueryExpression); ArgumentUtility.CheckNotNull ("fromClause", fromClause); ArgumentUtility.CheckNotNull ("queryModel", queryModel); CheckFlattenable (subQueryExpression.QueryModel); var innerMainFromClause = subQueryExpression.QueryModel.MainFromClause; CopyFromClauseData (innerMainFromClause, fromClause); var innerSelectorMapping = new QuerySourceMapping(); innerSelectorMapping.AddMapping (fromClause, subQueryExpression.QueryModel.SelectClause.Selector); queryModel.TransformExpressions (ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences (ex, innerSelectorMapping, false)); InsertBodyClauses (subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex); var innerBodyClauseMapping = new QuerySourceMapping(); innerBodyClauseMapping.AddMapping (innerMainFromClause, new QuerySourceReferenceExpression (fromClause)); queryModel.TransformExpressions (ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences (ex, innerBodyClauseMapping, false)); }
protected void CopyFromClauseData (FromClauseBase source, FromClauseBase destination) { ArgumentUtility.CheckNotNull ("source", source); ArgumentUtility.CheckNotNull ("destination", destination); destination.FromExpression = source.FromExpression; destination.ItemName = source.ItemName; destination.ItemType = source.ItemType; }
internal static EntityTypeConstrain CreateTypeConstrain(this IQueryVisitor visitor, Remotion.Linq.Clauses.FromClauseBase sourceExpression) { EntityTypeConstrain result = null; Type entityType = sourceExpression.ItemType.FindEntityType(); if ((entityType != null) && (entityType != typeof(IEntity))) { result = visitor.CreateTypeConstrain(entityType, sourceExpression.FromExpression); } return(result); }
protected void CopyFromClauseData(FromClauseBase source, FromClauseBase destination) { destination.FromExpression = source.FromExpression; destination.ItemName = source.ItemName; destination.ItemType = source.ItemType; }
/// <summary>Visits a from clause.</summary> /// <param name="fromClause">From clause to be visited.</param> /// <param name="queryModel">Query model containing given from clause.</param> /// <param name="index">Index of the where clause in the query model. In case of the main from clause this value is -1.</param> protected virtual void VisitQuerableFromClause(FromClauseBase fromClause, Remotion.Linq.QueryModel queryModel, int index) { if ((typeof(IQueryable).IsAssignableFrom(fromClause.FromExpression.Type)) && (fromClause.FromExpression.Type.GetGenericArguments().Length > 0) && (fromClause.FromExpression.Type.GetGenericArguments()[0] != typeof(IEntity))) { this.GetEntityAccessor(fromClause); } }
internal static StrongEntityAccessor GetEntityAccessor(this IQueryVisitor visitor, Remotion.Linq.Clauses.FromClauseBase sourceExpression) { StrongEntityAccessor entityAccessor = null; if (typeof(IEntity).GetTypeInfo().IsAssignableFrom(sourceExpression.ItemType)) { sourceExpression = visitor.TransformFromExpression(sourceExpression); entityAccessor = visitor.Query.FindAllComponents <StrongEntityAccessor>().FirstOrDefault(item => item.SourceExpression.EqualsTo(sourceExpression)); if (entityAccessor == null) { Identifier identifier = visitor.Query.FindAllComponents <EntityConstrain>() .Where(item => (item.TargetExpression.EqualsTo(sourceExpression.FromExpression)) && (item.Value is Identifier)) .Select(item => (Identifier)item.Value) .FirstOrDefault() ?? new Identifier(visitor.Query.CreateVariableName(sourceExpression.ItemName), sourceExpression.ItemType.FindEntityType()); entityAccessor = new StrongEntityAccessor(identifier, sourceExpression); entityAccessor.UnboundGraphName = entityAccessor.About; EntityTypeConstrain constrain = visitor.CreateTypeConstrain(sourceExpression); if ((constrain != null) && (!entityAccessor.Elements.Contains(constrain))) { entityAccessor.Elements.Add(constrain); } } } return(entityAccessor); }