public void Replaces_QuerySourceReferenceExpressions () { var expression = new QuerySourceReferenceExpression (_oldFromClause); var result = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences (expression, _querySourceMapping, true); Assert.That (((QuerySourceReferenceExpression) result).ReferencedQuerySource, Is.SameAs (_newFromClause)); }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> protected override Expression VisitQuerySourceReference( QuerySourceReferenceExpression expression) { AddQuerySource(expression.ReferencedQuerySource); return base.VisitQuerySourceReference(expression); }
public void Resolve_ReplacesParameter_WithProjection () { var node = new SelectManyExpressionNode ( CreateParseInfo(), _collectionSelector, ExpressionHelper.CreateLambdaExpression<int, int, AnonymousType> ((a, b) => new AnonymousType (a, b))); node.Apply (QueryModel, ClauseGenerationContext); var clause = (FromClauseBase) QueryModel.BodyClauses[0]; var expression = ExpressionHelper.CreateLambdaExpression<AnonymousType, bool> (i => i.a > 5 && i.b > 6); var result = node.Resolve (expression.Parameters[0], expression.Body, ClauseGenerationContext); var selectManySourceReference = new QuerySourceReferenceExpression (clause); // new AnonymousType (SourceReference, selectManySourceReference).a > 5 && new AnonymousType (SourceReference, selectManySourceReference).b > 6 var newAnonymousTypeExpression = Expression.New ( typeof (AnonymousType).GetConstructor (new[] { typeof (int), typeof (int) }), SourceReference, selectManySourceReference); var anonymousTypeMemberAExpression = Expression.MakeMemberAccess (newAnonymousTypeExpression, typeof (AnonymousType).GetProperty ("a")); var anonymousTypeMemberBExpression = Expression.MakeMemberAccess (newAnonymousTypeExpression, typeof (AnonymousType).GetProperty ("b")); var expectedResult = Expression.MakeBinary ( ExpressionType.AndAlso, Expression.MakeBinary (ExpressionType.GreaterThan, anonymousTypeMemberAExpression, Expression.Constant (5)), Expression.MakeBinary (ExpressionType.GreaterThan, anonymousTypeMemberBExpression, Expression.Constant (6))); ExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
protected internal override Expression VisitQuerySourceReference (QuerySourceReferenceExpression expression) { if (_querySourceMapping.ContainsMapping (expression.ReferencedQuerySource)) return _querySourceMapping.GetExpression (expression.ReferencedQuerySource); return expression; }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { if (!_reachable) { if (_originQuerySourceReferenceExpression == null) { _originQuerySourceReferenceExpression = expression; } if (expression.ReferencedQuerySource.Equals(_targetQuerySource)) { _reachable = true; } else { var fromClauseBase = expression.ReferencedQuerySource as FromClauseBase; if (fromClauseBase != null) { VisitExpression(fromClauseBase.FromExpression); } } if (!_reachable) { _originQuerySourceReferenceExpression = null; } } return expression; }
public void GetExpressionMapping () { var querySourceReferenceExpression = new QuerySourceReferenceExpression (_source); _context.AddExpressionMapping (querySourceReferenceExpression, new SqlTableReferenceExpression (_sqlTable)); Assert.That ( ((SqlTableReferenceExpression) _context.GetExpressionMapping (querySourceReferenceExpression)).SqlTable, Is.SameAs (_sqlTable)); }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { if (expression.ReferencedQuerySource == _groupBy) { return _groupBy.ElementSelector; } return base.VisitQuerySourceReferenceExpression(expression); }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { if (_results.AggregatingClauses.Contains(expression.ReferencedQuerySource as GroupJoinClause)) { _groupJoin = expression.ReferencedQuerySource as GroupJoinClause; } return base.VisitQuerySourceReferenceExpression(expression); }
protected internal override Expression VisitQuerySourceReference (QuerySourceReferenceExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); if (_querySourceMapping.ContainsMapping (expression.ReferencedQuerySource)) return _querySourceMapping.GetExpression (expression.ReferencedQuerySource); return expression; }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { if (_model.FindEntityType(expression.Type) != null) { _querySourceReferenceExpressions.Add(expression); } return expression; }
protected override void ModifyFetchQueryModel(QueryModel fetchQueryModel) { ArgumentUtility.CheckNotNull<QueryModel>("fetchQueryModel", fetchQueryModel); System.Linq.Expressions.MemberExpression fromExpression = System.Linq.Expressions.Expression.MakeMemberAccess(new QuerySourceReferenceExpression(fetchQueryModel.MainFromClause), base.RelationMember); AdditionalFromClause additionalFromClause = new AdditionalFromClause(fetchQueryModel.GetNewName("#fetch"), this._relatedObjectType, fromExpression); fetchQueryModel.BodyClauses.Add(additionalFromClause); QuerySourceReferenceExpression selector = new QuerySourceReferenceExpression(additionalFromClause); SelectClause selectClause = new SelectClause(selector); fetchQueryModel.SelectClause = selectClause; }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { var innerSelector = GetSubQuerySelectorOrNull(expression); if (innerSelector != null) { return TransparentIdentifierRemovingExpressionTreeVisitor.ReplaceTransparentIdentifiers(VisitExpression(innerSelector)); } return base.VisitQuerySourceReferenceExpression(expression); }
public void Initialization () { var referenceExpression = new QuerySourceReferenceExpression (SourceClause); Assert.That (referenceExpression.Type, Is.SameAs (typeof (int))); #if !NET_3_5 Assert.That (referenceExpression.NodeType, Is.EqualTo (ExpressionType.Extension)); #else Assert.That (referenceExpression.NodeType, Is.EqualTo (QuerySourceReferenceExpression.ExpressionType)); #endif }
public void TryGetExpressiontMappingFromHierarchy () { var querySourceReferenceExpression = new QuerySourceReferenceExpression (_source); var sqlTableReferenceExpression = new SqlTableReferenceExpression (_sqlTable); _context.AddExpressionMapping (querySourceReferenceExpression, sqlTableReferenceExpression); Expression result = _context.GetExpressionMapping (querySourceReferenceExpression); Assert.That (result, Is.SameAs (sqlTableReferenceExpression)); }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { var innerSelector = GetSubQuerySelectorOrNull(expression); if (innerSelector != null) { return VisitExpression(innerSelector); } return base.VisitQuerySourceReferenceExpression(expression); }
public void SetUp () { _mapping = new QuerySourceMapping (); _clause1 = ExpressionHelper.CreateMainFromClause_Int (); _clause2 = ExpressionHelper.CreateMainFromClause_Int (); _clause3 = ExpressionHelper.CreateMainFromClause_Int (); _querySourceReferenceExpression1 = new QuerySourceReferenceExpression (_clause1); _querySourceReferenceExpression2 = new QuerySourceReferenceExpression (_clause2); _querySourceReferenceExpression3 = new QuerySourceReferenceExpression (_clause3); }
public void TrivialExpression_WithEqualsTrue_ButNotReferenceEquals () { var searchedExpression1 = new QuerySourceReferenceExpression (ExpressionHelper.CreateMainFromClause<Cook>()); var searchedExpression2 = new QuerySourceReferenceExpression (searchedExpression1.ReferencedQuerySource); var inputParameter = Expression.Parameter (typeof (Cook), "input"); var result = AccessorFindingExpressionTreeVisitor.FindAccessorLambda (searchedExpression1, searchedExpression2, inputParameter); Expression<Func<Cook, Cook>> expectedResult = input => input; ExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public void Nested() { // where this.Convert(r).Name == "x" var queryRef = new QuerySourceReferenceExpression(new MainFromClause("i", typeof(Record), Expression.Constant("r"))); var call = Expression.Call(Expression.Constant(this), GetType().GetMethod("Convert"), queryRef); var prop = Expression.Property(call, "Name"); var result = visitor.VisitExpression(prop); Assert.That(result, Is.EqualTo(new LuceneQueryFieldExpression(typeof(string), "Name"))); }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { var propertyInfo = parent.Member as PropertyInfo; if (propertyInfo == null) { throw new NotSupportedException("Only MemberExpression of type PropertyInfo may be used on QuerySourceReferenceExpression."); } queryField = new LuceneQueryFieldExpression(propertyInfo.PropertyType, propertyInfo.Name); return base.VisitQuerySourceReferenceExpression(expression); }
/// <summary> /// Modifies the given query model for fetching, adding an <see cref="AdditionalFromClause"/> and changing the <see cref="SelectClause.Selector"/> to /// retrieve the result of the <see cref="AdditionalFromClause"/>. /// For example, a fetch request such as <c>FetchMany (x => x.Orders)</c> will be transformed into a <see cref="AdditionalFromClause"/> selecting /// <c>y.Orders</c> (where <c>y</c> is what the query model originally selected) and a <see cref="SelectClause"/> selecting the result of the /// <see cref="AdditionalFromClause"/>. /// This method is called by <see cref="FetchRequestBase.CreateFetchQueryModel"/> in the process of creating the new fetch query model. /// </summary> protected override void ModifyFetchQueryModel (QueryModel fetchQueryModel) { ArgumentUtility.CheckNotNull ("fetchQueryModel", fetchQueryModel); var fromExpression = Expression.MakeMemberAccess (new QuerySourceReferenceExpression (fetchQueryModel.MainFromClause), RelationMember); var memberFromClause = new AdditionalFromClause (fetchQueryModel.GetNewName ("#fetch"), _relatedObjectType, fromExpression); fetchQueryModel.BodyClauses.Add (memberFromClause); var newSelector = new QuerySourceReferenceExpression (memberFromClause); var newSelectClause = new SelectClause (newSelector); fetchQueryModel.SelectClause = newSelectClause; }
/// <summary> /// If the querySource is a subquery, return the SelectClause's selector if it's /// NewExpression. Otherwise, return null. /// </summary> private static NewExpression GetSubQuerySelectorOrNull(QuerySourceReferenceExpression querySource) { var fromClause = querySource.ReferencedQuerySource as MainFromClause; if (fromClause == null) return null; var subQuery = fromClause.FromExpression as SubQueryExpression; if (subQuery == null) return null; return subQuery.QueryModel.SelectClause.Selector as NewExpression; }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { var fromClauseBase = expression.ReferencedQuerySource as FromClauseBase; if (fromClauseBase != null && fromClauseBase.FromExpression is QuerySourceReferenceExpression && expression.Type == fromClauseBase.FromExpression.Type) { return fromClauseBase.FromExpression; } return base.VisitQuerySourceReferenceExpression(expression); }
public virtual EntityTrackingInfo Create( QueryCompilationContext queryCompilationContext, QuerySourceReferenceExpression querySourceReferenceExpression, IEntityType entityType) { var trackingInfo = new EntityTrackingInfo( _keyValueFactorySource, queryCompilationContext, querySourceReferenceExpression, entityType); return trackingInfo; }
protected override Expression VisitQuerySourceReferenceExpression(QuerySourceReferenceExpression expression) { if (!IsMemberOfModel(expression)) { return base.VisitQuerySourceReferenceExpression(expression); } if (expression.IsGroupingElementOf(_groupBy)) { return _groupBy.ElementSelector; } return base.VisitQuerySourceReferenceExpression(expression); }
public void Replaces_SubQueryExpressions_WithCorrectCloneContext () { var subQueryModel = ExpressionHelper.CreateQueryModel<Cook> (); var referencedClause = ExpressionHelper.CreateMainFromClause_Int (); subQueryModel.SelectClause.Selector = new QuerySourceReferenceExpression (referencedClause); var expression = new SubQueryExpression (subQueryModel); var newReferenceExpression = new QuerySourceReferenceExpression (ExpressionHelper.CreateMainFromClause_Int ()); _querySourceMapping.AddMapping (referencedClause, newReferenceExpression); var result = CloningExpressionTreeVisitor.AdjustExpressionAfterCloning (expression, _querySourceMapping); var newSubQuerySelectClause = ((SubQueryExpression) result).QueryModel.SelectClause; Assert.That (newSubQuerySelectClause.Selector, Is.SameAs (newReferenceExpression)); }
public void SetUp () { _context = SqlStatementModelObjectMother.CreateSqlPreparationContext(); var querySource = ExpressionHelper.CreateMainFromClause<Cook>(); _sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner); _context.AddExpressionMapping (new QuerySourceReferenceExpression(querySource), new SqlTableReferenceExpression(_sqlTable)); _querySourceReferenceExpression = new QuerySourceReferenceExpression (querySource); _stage = new DefaultSqlPreparationStage ( CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), new UniqueIdentifierGenerator()); }
public virtual EntityTrackingInfo Create( QueryCompilationContext queryCompilationContext, QuerySourceReferenceExpression querySourceReferenceExpression, IEntityType entityType) { var trackingInfo = new EntityTrackingInfo( _entityKeyFactorySource, _clrPropertyGetterSource, queryCompilationContext, querySourceReferenceExpression, entityType); return trackingInfo; }
/// <summary> /// If the querySource is a subquery, return the SelectClause's selector if it's /// NewExpression. Otherwise, return null. /// </summary> private Expression GetSubQuerySelectorOrNull(QuerySourceReferenceExpression expression) { if (expression.ReferencedQuerySource != querySource) return null; var fromClause = expression.ReferencedQuerySource as FromClauseBase; if (fromClause == null) return null; var subQuery = fromClause.FromExpression as SubQueryExpression; if (subQuery == null) return null; return subQuery.QueryModel.SelectClause.Selector; }
public virtual QuerySourceReferenceExpression FindResultQuerySourceReferenceExpression( [NotNull] Expression expression, [NotNull] IQuerySource targetQuerySource) { Check.NotNull(expression, nameof(expression)); Check.NotNull(targetQuerySource, nameof(targetQuerySource)); _targetQuerySource = targetQuerySource; _originQuerySourceReferenceExpression = null; _reachable = false; VisitExpression(expression); return _reachable ? _originQuerySourceReferenceExpression : null; }
public void SetUp () { _querySource = ExpressionHelper.CreateMainFromClause_Int (); _sourceExpression = new QuerySourceReferenceExpression (_querySource); var originalFunc = ExpressionHelper.CreateLambdaExpression<int, int, int> ((total, i) => total + i); _func = Expression.Lambda ( ReplacingExpressionTreeVisitor.Replace (originalFunc.Parameters[1], _sourceExpression, originalFunc.Body), originalFunc.Parameters[0]); _resultSelector = ExpressionHelper.CreateLambdaExpression<int, string> (total => total.ToString ()); _seed = Expression.Constant (12); _resultOperatorWithoutResultSelector = new AggregateFromSeedResultOperator (_seed, _func, null); _resultOperatorWithResultSelector = new AggregateFromSeedResultOperator (_seed, _func, _resultSelector); }
/// <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); }