/// <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 VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index) { string targetIdentifierString = _visitor.Query.CreateIdentifier(_visitor.ItemNameOverride); IList <EntityConstrain> entityConstrains = null; StrongEntityAccessor entityAccessor = (from accessor in _visitor.Query.GetQueryComponentNavigator().FindAllComponents <StrongEntityAccessor>() let constrains = accessor.Elements.OfType <EntityConstrain>() from constrain in constrains let predicate = constrain.Predicate as Literal where predicate != null let predicateUri = (Uri)predicate.Value let identifier = constrain.Value as Identifier where identifier != null let identifierString = _visitor.Query.RetrieveIdentifier(identifier.Name) where (identifierString == targetIdentifierString) || ((_fromExpression != null) && (constrain.TargetExpression.EqualsTo(_fromExpression))) where (entityConstrains = constrains.Where(item => (item.Predicate is Literal) && (((Uri)((Literal)item.Predicate).Value).AbsoluteUri == predicateUri.AbsoluteUri)).ToList()).Count > 0 select accessor).FirstOrDefault(); if (entityAccessor != null) { foreach (EntityConstrain entityConstrain in entityConstrains) { int indexOf = entityAccessor.Elements.IndexOf(entityConstrain); entityAccessor.Elements.RemoveAt(indexOf); OptionalPattern optional = new OptionalPattern(); optional.Patterns.Add(entityConstrain); entityAccessor.Elements.Insert(indexOf, optional); } } Call call = new Call(MethodNames.Bound); _result = call; }
private System.Linq.Expressions.Expression VisitPredicateMethodCallUnsafe(System.Linq.Expressions.MethodCallExpression expression, Uri predicate, StrongEntityAccessor entityAccessor) { _query.AddEntityAccessor(entityAccessor); Identifier memberIdentifier = new Identifier(_query.CreateVariableName(predicate.GetFragmentOrLastSegment())); EntityConstrain constrain = new EntityConstrain(); constrain.Predicate = new Literal(predicate); constrain.Value = memberIdentifier; if (!entityAccessor.Elements.Contains(constrain)) { entityAccessor.Elements.Add(constrain); } if (constrain.ShouldBeOptional(_currentComponent)) { entityAccessor.Elements.Remove(constrain); OptionalPattern optional = new OptionalPattern(); optional.Patterns.Add(constrain); entityAccessor.Elements.Add(optional); } HandleComponent(memberIdentifier); _lastComponent = memberIdentifier; return(expression); }
/// <summary>Visits an unary expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitUnary(System.Linq.Expressions.UnaryExpression expression) { MethodNames operatorName; System.Linq.Expressions.ExpressionType expressionType = expression.NodeType; switch (expression.NodeType) { case System.Linq.Expressions.ExpressionType.Convert: case System.Linq.Expressions.ExpressionType.TypeAs: return(Visit(expression.Operand)); default: string methodName = Enum.GetNames(typeof(MethodNames)).Where(item => item == expressionType.ToString()).FirstOrDefault(); if (!System.String.IsNullOrEmpty(methodName)) { operatorName = (MethodNames)Enum.Parse(typeof(MethodNames), methodName); } else { return(base.VisitUnary(expression)); } break; } UnaryOperator unaryOperator = new UnaryOperator(operatorName); HandleComponent(unaryOperator); Visit(expression.Operand); CleanupComponent(_lastComponent); _lastComponent = unaryOperator; return(expression); }
private void VisitContainsResultOperator(ContainsResultOperator containsResultOperator, Remotion.Linq.QueryModel queryModel, int index) { if (_query.IsSubQuery) { _visitor.Visit(containsResultOperator.Item); QueryComponent item = _visitor.RetrieveComponent(); if (item is IExpression) { Filter filter = new Filter(new BinaryOperator(MethodNames.Equal, _mainFromComponent.About, (IExpression)item)); if (!_mainFromComponent.Elements.Contains(filter)) { _mainFromComponent.Elements.Add(filter); } } EntityConstrain constrain = new EntityConstrain( new Identifier(_mainFromComponent.About.Name + "_p"), new Identifier(_mainFromComponent.About.Name + "_o"), containsResultOperator.Item); if (!_mainFromComponent.Elements.Contains(constrain)) { _mainFromComponent.Elements.Add(constrain); } Call call = new Call(MethodNames.Any); call.Arguments.Add(_query); _result = call; } else { throw new NotSupportedException(System.String.Format("Cannot perform 'Contains' operation on top level query.")); } }
public override AbstractExprTreePattern GetPattern(QueryComponent queryComponent) { switch (queryComponent) { case QueryComponent.Top: //top { return new PatternTopSkipOrderBy(); } case QueryComponent.Skip: //skip { return new PatternTopSkipOrderBy(); } case QueryComponent.OrderBy: //OrderBy { return new PatternTopSkipOrderBy(); } case QueryComponent.SelectSingleEntity: //select single entity { return new PatternSelectSingleEntity(); } case QueryComponent.SimpleProjection: //Simple projection { return new PatternSimpleProjection(); } default: { throw new NotImplementedException(); } } }
public override AbstractExprTreePattern GetPattern(QueryComponent queryComponent) { switch (queryComponent) { case QueryComponent.Top: //top { return(new PatternTopSkipOrderBy()); } case QueryComponent.Skip: //skip { return(new PatternTopSkipOrderBy()); } case QueryComponent.OrderBy: //OrderBy { return(new PatternTopSkipOrderBy()); } case QueryComponent.SelectSingleEntity: //select single entity { return(new PatternSelectSingleEntity()); } case QueryComponent.SimpleProjection: //Simple projection { return(new PatternSimpleProjection()); } default: { throw new NotImplementedException(); } } }
private void OverrideSelector(QueryComponent component, System.Linq.Expressions.Expression selector) { if ((component is Identifier) && (selector is System.Linq.Expressions.MemberExpression)) { System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)selector; if (!(memberExpression.Member is PropertyInfo)) { throw new NotSupportedException(System.String.Format("Selection on members of type '{0}' are not supported.", memberExpression.Member.MemberType)); } PropertyInfo propertyInfo = (PropertyInfo)memberExpression.Member; if (typeof(IEntity).IsAssignableFrom(propertyInfo.DeclaringType)) { _propertyMapping = _entityContext.Mappings.FindPropertyMapping((PropertyInfo)memberExpression.Member); if (typeof(IEntity).IsAssignableFrom(_propertyMapping.ReturnType)) { OverrideEntitySelector((Identifier)component); } else { OverrideLiteralSelector(this.GetEntityAccessor((FromClauseBase)FindQuerySource(memberExpression).ReferencedQuerySource)); } } } else if (component is StrongEntityAccessor) { _propertyMapping = IdentifierPropertyMapping.Default; OverrideIdentifierSelector((StrongEntityAccessor)component); } }
internal NonEntityQueryModelVisitor(EntityQueryVisitor queryVisitor, IExpression mainFromComponent = null) { _visitor = queryVisitor; _from = null; _mainFromComponent = mainFromComponent; _bodies = new List <QueryComponent>(); }
/// <summary>Visits a select clause.</summary> /// <param name="selectClause">Select clause to be visited.</param> /// <param name="queryModel">Query model containing given select clause.</param> public override void VisitSelectClause(SelectClause selectClause, Remotion.Linq.QueryModel queryModel) { queryModel.MainFromClause.Accept(this, queryModel); QuerySourceReferenceExpression querySource = FindQuerySource(selectClause.Selector); _visitor.Visit(selectClause.Selector); QueryComponent component = _visitor.RetrieveComponent(); _query = _visitor.Query; _mainFromComponent = _query.FindAllComponents <StrongEntityAccessor>().Where(item => item.SourceExpression == querySource.ReferencedQuerySource).First(); if (_query.Subject == null) { _query.Subject = _mainFromComponent.About; UnboundConstrain genericConstrain = new UnboundConstrain(new Identifier("s"), new Identifier("p"), new Identifier("o"), _mainFromComponent.SourceExpression.FromExpression); _mainFromComponent.Elements.Insert(0, genericConstrain); _mainFromComponent.UnboundGraphName = null; _query.Select.Add(genericConstrain); } _subject = _query.Subject; _query.Select.Add(_mainFromComponent); VisitBodyClauses(queryModel.BodyClauses, queryModel); VisitResultOperators(queryModel.ResultOperators, queryModel); OverrideSelector(component, selectClause.Selector); }
/// <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> /// Saves a component which does not have an associated artefact. /// </summary> /// <param name="conceptRef"> /// the concept which identifies the component /// </param> /// <param name="value"> /// the value /// </param> public void SaveComponent(string conceptRef, string value) { IDimension dimension = Utils.GetComponentByName(this._keyFamily, conceptRef); IConceptObject concept = this.GetCachedConcept(dimension); this.RemoveComponent(dimension); var qc = new QueryComponent(dimension, concept, value); this.UpdateComponentIndex(dimension, qc); }
private void SafeVisitExpression(System.Linq.Expressions.Expression expression) { Stack <IQueryComponentNavigator> currentStack = _currentComponent; QueryComponent lastComponent = _lastComponent; _currentComponent = new Stack <IQueryComponentNavigator>(); Visit(expression); _currentComponent = currentStack; _lastComponent = lastComponent; }
/// <summary> /// Saves a component which has an associated artefact (all of them should have). /// </summary> /// <param name="dimension"> /// the dimemnsion /// </param> /// <param name="codes"> /// the codes /// </param> public void SaveComponent(IDimension dimension, List <ICode> codes) { IConceptObject concept = this.GetCachedConcept(dimension); this.RemoveComponent(dimension); var qc = new QueryComponent(dimension, concept, codes); this._codeTreeMap[dimension].CheckCodes(codes); this.UpdateComponentIndex(dimension, qc); }
private string AppendCustomLines(string toReturn, QueryComponent stage) { var lines = SqlQueryBuilderHelper.GetCustomLinesSQLForStage(this, stage).ToArray(); if (lines.Any()) { toReturn += Environment.NewLine; toReturn += string.Join(Environment.NewLine, lines.Select(l => l.Text)); } return(toReturn); }
/// <summary>Visits a where clause.</summary> /// <param name="whereClause">Where 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.</param> public override void VisitWhereClause(WhereClause whereClause, Remotion.Linq.QueryModel queryModel, int index) { _visitor.Visit(whereClause.Predicate); QueryComponent queryComponent = _visitor.RetrieveComponent(); if (queryComponent != null) { _bodies.Add(queryComponent); } base.VisitWhereClause(whereClause, queryModel, index); }
/// <summary>Visits an Uri property expression called on <see cref="EntityId" />.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected virtual System.Linq.Expressions.Expression VisitEntityIdUri(System.Linq.Expressions.MemberExpression expression) { bool isInSelectScenario = (_currentComponent.Count == 0); StrongEntityAccessor entityAccessor = (isInSelectScenario ? this.GetEntityAccessor(GetMemberTarget(expression)) : this.GetEntityAccessor(GetSourceExpression(expression))); _query.AddEntityAccessor(entityAccessor); if (isInSelectScenario) { _lastComponent = entityAccessor; } else { foreach (var entityConstrain in entityAccessor.Elements.OfType <EntityConstrain>()) { if (entityConstrain.Value is Identifier) { Identifier identifier = (Identifier)entityConstrain.Value; string constrainIdentifier = _query.RetrieveIdentifier(identifier.Name); string propertyIdentifier = null; Type propertyType = null; if (expression.Expression is System.Linq.Expressions.MemberExpression) { PropertyInfo propertyInfo = (PropertyInfo)((System.Linq.Expressions.MemberExpression)expression.Expression).Member; propertyIdentifier = _query.CreateIdentifier(propertyInfo.Name); propertyType = propertyInfo.PropertyType; } else if (expression.Expression is Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression) { Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression querySource = (Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression)expression.Expression; propertyIdentifier = querySource.ReferencedQuerySource.ItemName; propertyType = querySource.ReferencedQuerySource.ItemType; } if ((constrainIdentifier == propertyIdentifier) && (identifier.NativeType == propertyType)) { _lastComponent = identifier; break; } } } if (_lastComponent == null) { _lastComponent = entityAccessor.About; } HandleComponent(_lastComponent); } return(expression); }
private void VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index) { if (_query.IsSubQuery) { Call call = new Call(MethodNames.Any); call.Arguments.Add(_query); _result = call; } else { _query.QueryForm = QueryForms.Ask; } }
/// <summary>Visits a where clause.</summary> /// <param name="whereClause">Where 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.</param> public override void VisitWhereClause(WhereClause whereClause, Remotion.Linq.QueryModel queryModel, int index) { _visitor.ConstantFromClause = _auxFromComponent; _visitor.Visit(whereClause.Predicate); QueryComponent queryComponent = _visitor.RetrieveComponent(); IQueryComponentNavigator queryComponentNavigator = queryComponent.GetQueryComponentNavigator(); if (queryComponentNavigator != null) { queryComponentNavigator.ReplaceComponent(Identifier.Current, _subject); } if (queryComponent is QueryElement) { if ((!(queryComponent is EntityConstrain)) && (!_query.Elements.Contains((QueryElement)queryComponent))) { _query.Elements.Add((QueryElement)queryComponent); } } else if (!_query.FindAllComponents <Filter>().Any(item => item.Expression == queryComponent)) { Filter filter = new Filter((IExpression)queryComponent); StrongEntityAccessor targetEntityAccessor = null; if ((_subject != _mainFromComponent.About) && (queryComponentNavigator.Contains(_subject))) { targetEntityAccessor = (from entityAccessor in _query.FindAllComponents <StrongEntityAccessor>() from constrain in entityAccessor.FindAllComponents <EntityConstrain>() where (constrain.GetType() == typeof(EntityConstrain)) && (_subject.Equals(constrain.Value)) select entityAccessor).FirstOrDefault(); } if (targetEntityAccessor == null) { IEnumerable <StrongEntityAccessor> targetEntityAccessorExression = _query.Elements.OfType <StrongEntityAccessor>(); if ((_query.IsSubQuery) || (whereClause.Predicate is Remotion.Linq.Clauses.Expressions.SubQueryExpression)) { targetEntityAccessorExression = targetEntityAccessorExression.Except(new StrongEntityAccessor[] { _query.Elements.OfType <StrongEntityAccessor>().LastOrDefault() }); } targetEntityAccessor = targetEntityAccessorExression.LastOrDefault() ?? _mainFromComponent; } if ((!targetEntityAccessor.Elements.Contains(queryComponent)) && (!targetEntityAccessor.Elements.Contains(filter))) { targetEntityAccessor.Elements.Add(filter); } } _auxFromComponent = null; base.VisitWhereClause(whereClause, queryModel, index); }
/// <summary>Visits an <see cref="EntityExtensions.Is(RomanticWeb.Entities.IEntity,System.Uri)" /> method call.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Returns visited expression.</returns> protected virtual System.Linq.Expressions.Expression VisitIsMethodCall(System.Linq.Expressions.MethodCallExpression expression) { object objectValue = ((System.Linq.Expressions.ConstantExpression)expression.Arguments[1]).Value; if (objectValue != null) { if (objectValue is Uri) { objectValue = new EntityId[] { new EntityId((Uri)objectValue) }; } else if (objectValue is EntityId) { objectValue = new EntityId[] { (EntityId)objectValue }; } else if ((objectValue is IEnumerable) && (objectValue.GetType().FindItemType() == typeof(Uri))) { objectValue = ((IEnumerable)objectValue).Cast <Uri>().Select(item => new EntityId(item)); } if ((objectValue is IEnumerable) && (objectValue.GetType().FindItemType() == typeof(EntityId))) { var types = (IEnumerable <EntityId>)objectValue; int count = types.Count(); if (count > 0) { StrongEntityAccessor entityAccessor = this.GetEntityAccessor(this.GetSourceExpression(expression.Arguments[0])); if (entityAccessor != null) { EntityTypeConstrain constrain = new EntityTypeConstrain( types.Select(item => item.Uri).First(), entityAccessor.SourceExpression.FromExpression, (count > 1 ? types.Skip(1).Select(item => item.Uri).ToArray() : new Uri[0])); entityAccessor.Elements.Add(constrain); HandleComponent(constrain); _lastComponent = constrain; } } return(expression); } else { return(base.VisitMethodCall(expression)); } } else { return(base.VisitMethodCall(expression)); } }
/// <summary>Visits order by clauses.</summary> /// <param name="orderings">Order by clauses to be visited.</param> /// <param name="queryModel">Query model containing given body clause.</param> /// <param name="orderByClause">First order by clause.</param> protected override void VisitOrderings(ObservableCollection <Ordering> orderings, QueryModel queryModel, OrderByClause orderByClause) { foreach (Ordering ordering in orderings) { _visitor.Visit(ordering.Expression); QueryComponent component = _visitor.RetrieveComponent(); if (component is IExpression) { IExpression expression = (IExpression)component; if (!_query.OrderBy.ContainsKey(expression)) { _query.OrderBy[expression] = (ordering.OrderingDirection == OrderingDirection.Desc); } } } }
/// <summary> /// Setter for the time dimension /// </summary> /// <param name="startYear"> /// The start year /// </param> /// <param name="endYear"> /// The end year /// </param> /// <param name="startDate"> /// The start date /// </param> /// <param name="endDate"> /// The end date /// </param> public void SetTimeComponent(string startDate, string endDate) { IDimension dimension = this.KeyFamily.TimeDimension; IConceptObject concept = this.GetCachedConcept(dimension); if (dimension == null) { throw new NsiClientException(Resources.ExceptionNoTimeDimension); } this.RemoveComponent(dimension); if (!string.IsNullOrEmpty(startDate)) { var qc = new QueryComponent(dimension, concept, startDate, endDate); this.UpdateComponentIndex(dimension, qc); } }
private void CleanupComponent(QueryComponent component) { IQueryComponentNavigator queryComponentNavigator = _lastComponent.GetQueryComponentNavigator(); if (queryComponentNavigator != null) { while ((_currentComponent.Count > 0) && (!_currentComponent.Peek().Equals(queryComponentNavigator))) { _currentComponent.Pop(); } if (_currentComponent.Count > 0) { _currentComponent.Pop(); } } }
private DbService(SqlConnection connection, ILogger logger = null, bool useNLog = false) { Lock = new object(); Connection = connection; Logger = logger ?? (useNLog ? new NLogWrapper(LogManager.GetCurrentClassLogger()) : null); // TODO: modifiy CurrentClass Logger -> append Type-Parameter Logger?.Info($"Creating DbService for entity {typeof(T).FullName}"); ModelBuilder = new ModelBuilder(typeof(T), logger, useNLog); EntityModel = ModelBuilder.EntityModel; QueryComponent = new QueryComponent <T>(this, EntityModel); DataManipulationComponent = new DataManipulationComponent <T>(this, EntityModel); ScriptGenerator = ModelBuilder.ScriptGenerator; EntityParser = new EntityParser <T>(EntityModel); }
/// <summary>Visits a binary expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitBinary(System.Linq.Expressions.BinaryExpression expression) { MethodNames operatorName; System.Linq.Expressions.ExpressionType expressionType = expression.NodeType; switch (expression.NodeType) { case System.Linq.Expressions.ExpressionType.OrElse: expressionType = System.Linq.Expressions.ExpressionType.Or; goto default; case System.Linq.Expressions.ExpressionType.AndAlso: expressionType = System.Linq.Expressions.ExpressionType.And; goto default; default: string methodName = Enum.GetNames(typeof(MethodNames)).Where(item => item == expressionType.ToString()).FirstOrDefault(); if (!System.String.IsNullOrEmpty(methodName)) { operatorName = (MethodNames)Enum.Parse(typeof(MethodNames), methodName); } else { return(base.VisitBinary(expression)); } break; } BinaryOperator binaryOperator = new BinaryOperator(operatorName); HandleComponent(binaryOperator); Visit(expression.Left); CleanupComponent(_lastComponent); Visit(expression.Right); CleanupComponent(_lastComponent); _lastComponent = binaryOperator; return(expression); }
private void VisitContainsResultOperator(ContainsResultOperator containsResultOperator, Remotion.Linq.QueryModel queryModel, int index) { Call call = new Call(MethodNames.In); System.Linq.Expressions.Expression expression = _visitor.TransformUnaryExpression(containsResultOperator.Item); Identifier targetIdentifier = Identifier.Current; if (expression is System.Linq.Expressions.MemberExpression) { System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)expression; _visitor.Visit(expression); QueryComponent component = _visitor.RetrieveComponent(); if (component is Identifier) { targetIdentifier = (Identifier)component; } } call.Arguments.Add(targetIdentifier); _result = call; }
/// <summary>Visits a constant expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitConstant(System.Linq.Expressions.ConstantExpression expression) { if ((expression.Value is IEnumerable) && (!(expression.Value is string))) { List list = new List(); IEnumerable value = (IEnumerable)expression.Value; foreach (object item in value) { if (item is IEntity) { list.Values.Add(new Literal(((IEntity)item).Id.Uri)); } else if (item is EntityId) { list.Values.Add(new Literal(((EntityId)item).Uri)); } else { list.Values.Add(new Literal(ResolveRelativeUriIfNecessery(item))); } } _lastComponent = list; } else if (expression.Value is IEntity) { HandleComponent(_lastComponent = new Literal(((IEntity)expression.Value).Id.Uri)); } else if (expression.Value != null) { HandleComponent(_lastComponent = new Literal(ResolveRelativeUriIfNecessery(expression.Value))); } else { Type valueType = FindLiteralType(); HandleComponent(_lastComponent = new Literal(valueType)); } return(expression); }
/// <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); }
/// <summary>Visits an entity identifier member.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected virtual System.Linq.Expressions.Expression VisitEntityId(EntityIdentifierExpression expression) { if (_currentComponent.Count > 0) { StrongEntityAccessor entityAccessor = this.GetEntityAccessor(expression.Target); HandleComponent(_lastComponent = entityAccessor.About); if (_currentComponent.Peek() is BinaryOperatorNavigator) { BinaryOperator binaryOperator = ((BinaryOperatorNavigator)_currentComponent.Peek()).NavigatedComponent; Filter filter = new Filter(binaryOperator); _query.AddEntityAccessor(entityAccessor); entityAccessor.Elements.Add(filter); _currentComponent.Push(filter.GetQueryComponentNavigator()); _lastComponent = filter; } } else { _lastComponent = this.GetEntityAccessor(expression.Target).About; } return(expression); }
/// <summary>Visits an entity member.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected virtual System.Linq.Expressions.Expression VisitEntityProperty(EntityPropertyExpression expression) { StrongEntityAccessor entityAccessor = this.GetEntityAccessor(expression.Target); _query.AddEntityAccessor(entityAccessor); Identifier memberIdentifier = null; EntityConstrain constrain = _query.FindAllComponents <EntityConstrain>() .FirstOrDefault(item => (item.GetType() == typeof(EntityConstrain) && (item.TargetExpression.EqualsTo(expression.Expression)))); if (constrain == null) { memberIdentifier = (_query.FindAllComponents <StrongEntityAccessor>() .Where(item => item.SourceExpression.FromExpression.EqualsTo(expression.Expression)) .Select(item => item.About).FirstOrDefault()) ?? (new Identifier(_query.CreateVariableName(expression.Name), expression.EntityProperty.PropertyType)); constrain = new EntityConstrain(new Literal(expression.PropertyMapping.Uri), memberIdentifier, expression.Expression); if (!entityAccessor.Elements.Contains(constrain)) { entityAccessor.Elements.Add(constrain); } } else { if (constrain.ShouldBeOptional(_currentComponent)) { entityAccessor.Elements.Remove(constrain); OptionalPattern optional = new OptionalPattern(); optional.Patterns.Add(constrain); entityAccessor.Elements.Add(optional); } memberIdentifier = (Identifier)constrain.Value; } HandleComponent(memberIdentifier); _lastComponent = memberIdentifier; return(expression); }
private void HandleComponent(QueryComponent component) { if (_currentComponent.Count > 0) { if (_currentComponent.Peek().CanAddComponent(component)) { if (!_currentComponent.Peek().ContainsComponent(component)) { _currentComponent.Peek().AddComponent(component); } } else { _currentComponent.Pop(); } } IQueryComponentNavigator queryComponentNavigator = component.GetQueryComponentNavigator(); if (queryComponentNavigator != null) { _currentComponent.Push(queryComponentNavigator); } }
public abstract AbstractExprTreePattern GetPattern(QueryComponent queryComponent);