private QueryModel ApplyAllNodes(IExpressionNode node, ClauseGenerationContext clauseGenerationContext) { QueryModel queryModel = null; if (node.Source != null) queryModel = ApplyAllNodes(node.Source, clauseGenerationContext); return node.Apply(queryModel, clauseGenerationContext); }
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); var clause = new WhereClause (GetResolvedPredicate (clauseGenerationContext)); queryModel.BodyClauses.Add (clause); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { queryModel.BodyClauses.Add(new WhereMissingClause(GetResolvedPredicate(clauseGenerationContext))); return queryModel; }
public override Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("inputParameter", inputParameter); ArgumentUtility.CheckNotNull("expressionToBeResolved", expressionToBeResolved); ArgumentUtility.CheckNotNull("clauseGenerationContext", clauseGenerationContext); return Source.Resolve(inputParameter, expressionToBeResolved, clauseGenerationContext); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { queryModel.BodyClauses.Add(new UseKeysClause(Keys)); return queryModel; }
public override Expression Resolve( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) => Source.Resolve( inputParameter, expressionToBeResolved, clauseGenerationContext);
public override Expression Resolve (ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("inputParameter", inputParameter); ArgumentUtility.CheckNotNull ("expressionToBeResolved", expressionToBeResolved); // no data streams out from this node, so we cannot resolve any expressions throw CreateResolveNotSupportedException (); }
public override Expression Resolve (ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("inputParameter", inputParameter); ArgumentUtility.CheckNotNull ("expressionToBeResolved", expressionToBeResolved); // UnionResultOperator is a query source, so expressions reolve their input parameter with the UnionResultOperator created by this node. return QuerySourceExpressionNodeUtility.ReplaceParameterWithReference (this, inputParameter, expressionToBeResolved, clauseGenerationContext); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); var resultOperator = CreateResultOperator (clauseGenerationContext); queryModel.ResultOperators.Add (resultOperator); return queryModel; }
public Expression GetResolvedOptionalElementSelector (ClauseGenerationContext clauseGenerationContext) { if (_optionalElementSelector == null) return null; return _cachedElementSelector.GetOrCreate ( r => r.GetResolvedExpression (_optionalElementSelector.Body, _optionalElementSelector.Parameters[0], clauseGenerationContext)); }
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { //NOTE: Do not seal ApplyNodeSpecificSemantics() in ResultOperatorExpressionNodeBase. It is overridden by e.g. Fetch-operators. ArgumentUtility.CheckNotNull ("queryModel", queryModel); var resultOperator = CreateResultOperator (clauseGenerationContext); queryModel.ResultOperators.Add (resultOperator); }
protected sealed override QueryModel WrapQueryModelAfterEndOfQuery (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); // Result operators can safely be appended to the previous query model even after another result operator, so do not wrap the previous // query model. return queryModel; }
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); var clause = new OrderByClause(); clause.Orderings.Add (new Ordering (GetResolvedKeySelector (clauseGenerationContext), OrderingDirection.Desc)); queryModel.BodyClauses.Add (clause); }
public override Expression Resolve (ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("inputParameter", inputParameter); ArgumentUtility.CheckNotNull ("expressionToBeResolved", expressionToBeResolved); // this simply streams its input data to the output without modifying its structure, so we resolve by passing on the data to the previous node return Source.Resolve (inputParameter, expressionToBeResolved, clauseGenerationContext); }
public QueryModel Apply (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { if (queryModel != null) throw new ArgumentException ("QueryModel has to be null because MainSourceExpressionNode marks the start of a query.", "queryModel"); var mainFromClause = CreateMainFromClause (clauseGenerationContext); var defaultSelectClause = new SelectClause (new QuerySourceReferenceExpression (mainFromClause)); return new QueryModel (mainFromClause, defaultSelectClause) { ResultTypeOverride = QuerySourceType }; }
public QueryModel Apply (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); queryModel = WrapQueryModelAfterEndOfQuery (queryModel, clauseGenerationContext); ApplyNodeSpecificSemantics (queryModel, clauseGenerationContext); SetResultTypeOverride (queryModel); return queryModel; }
public override Expression Resolve ( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { return QuerySourceExpressionNodeUtility.ReplaceParameterWithReference ( this, inputParameter, expressionToBeResolved, clauseGenerationContext); }
public override Expression Resolve (ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("inputParameter", inputParameter); ArgumentUtility.CheckNotNull ("expressionToBeResolved", expressionToBeResolved); var convertExpression = Expression.Convert (inputParameter, SearchedItemType); var expressionWithCast = ReplacingExpressionVisitor.Replace (inputParameter, convertExpression, expressionToBeResolved); return Source.Resolve (inputParameter, expressionWithCast, clauseGenerationContext); }
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); var orderByClause = GetOrderByClause (queryModel); if (orderByClause == null) throw new NotSupportedException ("ThenByDescending expressions must follow OrderBy, OrderByDescending, ThenBy, or ThenByDescending expressions."); orderByClause.Orderings.Add (new Ordering (GetResolvedKeySelector (clauseGenerationContext), OrderingDirection.Desc)); }
public override Expression Resolve( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { Check.NotNull(inputParameter, nameof(inputParameter)); Check.NotNull(expressionToBeResolved, nameof(expressionToBeResolved)); return Source.Resolve(inputParameter, expressionToBeResolved, clauseGenerationContext); }
protected override void ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { var queryAnnotationResultOperator = (QueryAnnotationResultOperator)clauseGenerationContext.GetContextInfo(Source); ((IncludeQueryAnnotation)queryAnnotationResultOperator.Annotation) .AppendToNavigationPath(_navigationPropertyPathLambda.GetComplexPropertyAccess()); clauseGenerationContext.AddContextInfo(this, queryAnnotationResultOperator); }
private MainFromClause CreateMainFromClause (ClauseGenerationContext clauseGenerationContext) { var fromClause = new MainFromClause ( AssociatedIdentifier, QuerySourceElementType, ParsedExpression); clauseGenerationContext.AddContextInfo (this, fromClause); return fromClause; }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { var includeResultOperator = (IncludeResultOperator)clauseGenerationContext.GetContextInfo(Source); includeResultOperator.AppendToNavigationPath(_navigationPropertyPathLambda.GetComplexPropertyAccess()); clauseGenerationContext.AddContextInfo(this, includeResultOperator); return queryModel; }
public Expression GetResolvedExpression ( Expression unresolvedExpression, ParameterExpression parameterToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("unresolvedExpression", unresolvedExpression); ArgumentUtility.CheckNotNull ("parameterToBeResolved", parameterToBeResolved); var sourceNode = _currentNode.Source; var resolvedExpression = sourceNode.Resolve (parameterToBeResolved, unresolvedExpression, clauseGenerationContext); resolvedExpression = TransparentIdentifierRemovingExpressionVisitor.ReplaceTransparentIdentifiers (resolvedExpression); return resolvedExpression; }
public override Expression Resolve (ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("inputParameter", inputParameter); ArgumentUtility.CheckNotNull ("expressionToBeResolved", expressionToBeResolved); ArgumentUtility.CheckNotNull ("clauseGenerationContext", clauseGenerationContext); // we modify the structure of the stream of data coming into this node by our result selector, // so we first resolve the result selector, then we substitute the result for the inputParameter in the expressionToBeResolved var resolvedResultSelector = GetResolvedResultSelector (clauseGenerationContext); return ReplacingExpressionTreeVisitor.Replace (inputParameter, resolvedResultSelector, expressionToBeResolved); }
protected override QueryModel ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { var previousFetchRequest = clauseGenerationContext.GetContextInfo (Source) as FetchRequestBase; if (previousFetchRequest == null) throw new ParserException ("ThenFetchMany must directly follow another Fetch request."); FetchRequestBase innerFetchRequest = new FetchManyRequest (RelationMember); innerFetchRequest = previousFetchRequest.GetOrAddInnerFetchRequest (innerFetchRequest); clauseGenerationContext.AddContextInfo (this, innerFetchRequest); return queryModel; }
public Expression Resolve (ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("inputParameter", inputParameter); ArgumentUtility.CheckNotNull ("expressionToBeResolved", expressionToBeResolved); // query sources resolve into references that point back to the respective clauses return QuerySourceExpressionNodeUtility.ReplaceParameterWithReference ( this, inputParameter, expressionToBeResolved, clauseGenerationContext); }
public Expression GetResolvedResultSelector (ClauseGenerationContext clauseGenerationContext) { return _cachedResultSelector.GetOrCreate ( r => r.GetResolvedExpression ( QuerySourceExpressionNodeUtility.ReplaceParameterWithReference ( this, _resultSelector.Parameters[1], _resultSelector.Body, clauseGenerationContext), _resultSelector.Parameters[0], clauseGenerationContext)); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { var navigationPropertyPath = Source.Resolve( _navigationPropertyPathLambda.Parameters[0], _navigationPropertyPathLambda.Body, clauseGenerationContext); var includeResultOperator = new IncludeResultOperator(navigationPropertyPath); clauseGenerationContext.AddContextInfo(this, includeResultOperator); return includeResultOperator; }
/// <summary> /// Gets the <see cref="IQuerySource"/> corresponding to the given <paramref name="node"/>, throwing an <see cref="InvalidOperationException"/> /// if no such clause has been registered in the given <paramref name="context"/>. /// </summary> /// <param name="node">The node for which the <see cref="IQuerySource"/> should be returned.</param> /// <param name="context">The clause generation context.</param> /// <returns>The <see cref="IQuerySource"/> corresponding to <paramref name="node"/>.</returns> public static IQuerySource GetQuerySourceForNode (IQuerySourceExpressionNode node, ClauseGenerationContext context) { try { return (IQuerySource) context.GetContextInfo (node); } catch (KeyNotFoundException ex) { var message = string.Format ( "Cannot retrieve an IQuerySource for the given {0}. Be sure to call Apply before calling methods that require IQuerySources, and pass in " + "the same QuerySourceClauseMapping to both.", node.GetType().Name); throw new InvalidOperationException (message, ex); } }
public override Expression Resolve( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { // this simply streams its input data to the output without modifying its structure, so we resolve by passing on the data to the previous node return(Source.Resolve(inputParameter, expressionToBeResolved, clauseGenerationContext)); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new AggregateFromSeedResultOperator(Seed, GetResolvedFunc(clauseGenerationContext), OptionalResultSelector)); }
protected override void ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); queryModel.SelectClause.Selector = GetResolvedSelector(clauseGenerationContext); }
protected abstract QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext);
public Expression GetResolvedPredicate(ClauseGenerationContext clauseGenerationContext) { return(_cachedPredicate.GetOrCreate(r => r.GetResolvedExpression(Predicate.Body, Predicate.Parameters[0], clauseGenerationContext))); }
public LambdaExpression GetResolvedFunc(ClauseGenerationContext clauseGenerationContext) { // '(total, current) => total + current' becomes 'total => total + [current]' return(_cachedFunc.GetOrCreate( r => Expression.Lambda(r.GetResolvedExpression(Func.Body, Func.Parameters[1], clauseGenerationContext), Func.Parameters[0]))); }
public override Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { throw CreateResolveNotSupportedException(); }
public override Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("inputParameter", inputParameter); ArgumentUtility.CheckNotNull("expressionToBeResolved", expressionToBeResolved); // this simply streams its input data to the output without modifying its structure, so we resolve by passing on the data to the previous node return(Source.Resolve(inputParameter, expressionToBeResolved, clauseGenerationContext)); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); var resolvedCollectionSelector = GetResolvedCollectionSelector(clauseGenerationContext); var clause = new AdditionalFromClause(ResultSelector.Parameters[1].Name, ResultSelector.Parameters[1].Type, resolvedCollectionSelector); queryModel.BodyClauses.Add(clause); clauseGenerationContext.AddContextInfo(this, clause); var selectClause = queryModel.SelectClause; selectClause.Selector = GetResolvedResultSelector(clauseGenerationContext); return(queryModel); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new IntersectResultOperator(Source2)); }
protected abstract ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext);
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new OfTypeResultOperator(SearchedItemType)); }
/// <summary> /// Wraps the <paramref name="queryModel"/> into a subquery after a node that indicates the end of the query ( /// <see cref="ResultOperatorExpressionNodeBase"/> or <see cref="GroupByExpressionNode"/>). Override this method /// when implementing a <see cref="IExpressionNode"/> that does not need a subquery to be created if it occurs after the query end. /// </summary> /// <remarks> /// <para> /// When an ordinary node follows a result operator or group node, it cannot simply append its clauses to the <paramref name="queryModel"/> /// because semantically, the result operator (or grouping) must be executed _before_ the clause. Therefore, in such scenarios, we wrap /// the current query model into a <see cref="SubQueryExpression"/> that we put into the <see cref="MainFromClause"/> of a new /// <see cref="QueryModel"/>. /// </para> /// <para> /// This method also changes the <see cref="Source"/> of this node because logically, all <see cref="Resolve"/> operations must be handled /// by the new <see cref="MainFromClause"/> holding the <see cref="SubQueryExpression"/>. For example, consider the following call chain: /// <code> /// MainSource (...) /// .Select (x => x) /// .Distinct () /// .Select (x => x) /// </code> /// /// Naively, the last Select node would resolve (via Distinct and Select) to the <see cref="MainFromClause"/> created by the initial MainSource. /// After this method is executed, however, that <see cref="MainFromClause"/> is part of the sub query, and a new <see cref="MainFromClause"/> /// has been created to hold it. Therefore, we replace the chain as follows: /// <code> /// MainSource (MainSource (...).Select (x => x).Distinct ()) /// .Select (x => x) /// </code> /// /// Now, the last Select node resolves to the new <see cref="MainFromClause"/>. /// </para> /// </remarks> protected virtual QueryModel WrapQueryModelAfterEndOfQuery(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); var sourceAsResultOperatorNode = Source as ResultOperatorExpressionNodeBase; if (sourceAsResultOperatorNode != null) { return(WrapQueryModel(queryModel, sourceAsResultOperatorNode.AssociatedIdentifier, clauseGenerationContext)); } else { return(queryModel); } }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { var clause = new WhereClause(GetResolvedPredicate(clauseGenerationContext)); queryModel.BodyClauses.Add(clause); return(queryModel); }
private QueryModel WrapQueryModel(QueryModel queryModel, string associatedIdentifier, ClauseGenerationContext clauseGenerationContext) { var subQueryExpression = new SubQueryExpression(queryModel); // change the Source of this node so that Resolve will later correctly go to the new main from clause we create for the sub query var newMainSourceNode = new MainSourceExpressionNode(associatedIdentifier, subQueryExpression); Source = newMainSourceNode; return(newMainSourceNode.Apply(null, clauseGenerationContext)); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new ContainsResultOperator(Item)); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new MaxResultOperator()); }
public abstract Expression Resolve( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext);
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { var castItemType = CastItemType; return(new CastResultOperator(castItemType)); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); var clause = new WhereClause(GetResolvedPredicate(clauseGenerationContext)); queryModel.BodyClauses.Add(clause); return(queryModel); }
public override Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("inputParameter", inputParameter); ArgumentUtility.CheckNotNull("expressionToBeResolved", expressionToBeResolved); var convertExpression = Expression.Convert(inputParameter, SearchedItemType); var expressionWithCast = ReplacingExpressionTreeVisitor.Replace(inputParameter, convertExpression, expressionToBeResolved); return(Source.Resolve(inputParameter, expressionWithCast, clauseGenerationContext)); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new ExceptResultOperator(_source2)); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); var clause = new OrderByClause(); clause.Orderings.Add(new Ordering(GetResolvedKeySelector(clauseGenerationContext), OrderingDirection.Asc)); queryModel.BodyClauses.Add(clause); return(queryModel); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new LastResultOperator(ParsedExpression.Method.Name.EndsWith("OrDefault"))); }
public Expression GetResolvedKeySelector(ClauseGenerationContext clauseGenerationContext) { return(_cachedSelector.GetOrCreate(r => r.GetResolvedExpression(KeySelector.Body, KeySelector.Parameters[0], clauseGenerationContext))); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); var orderByClause = GetOrderByClause(queryModel); if (orderByClause == null) { throw new ParserException("ThenByDescending expressions must follow OrderBy, OrderByDescending, ThenBy, or ThenByDescending expressions."); } orderByClause.Orderings.Add(new Ordering(GetResolvedKeySelector(clauseGenerationContext), OrderingDirection.Asc)); return(queryModel); }
protected sealed override QueryModel WrapQueryModelAfterEndOfQuery(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); // Result operators can safely be appended to the previous query model even after another result operator, so do not wrap the previous // query model. return(queryModel); }
public override Expression Resolve( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { // no data streams out from this node, so we cannot resolve any expressions throw CreateResolveNotSupportedException(); }
public Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { // query sources resolve into references that point back to the respective clauses return(QuerySourceExpressionNodeUtility.ReplaceParameterWithReference( this, inputParameter, expressionToBeResolved, clauseGenerationContext)); }