public override Expression Resolve (ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("inputParameter", inputParameter); ArgumentUtility.CheckNotNull ("expressionToBeResolved", expressionToBeResolved); return Source.Resolve (inputParameter, expressionToBeResolved, clauseGenerationContext); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("queryModel", queryModel); queryModel.BodyClauses.Add(new FilterClause(GetResolvedPredicate(clauseGenerationContext))); return queryModel; }
protected override QueryModel ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); var clause = new WhereClause (GetResolvedPredicate (clauseGenerationContext)); queryModel.BodyClauses.Add (clause); return queryModel; }
protected 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 QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("queryModel", queryModel); queryModel.BodyClauses.Add(new SkipTakeClause(Skip, Take)); return queryModel; }
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 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; }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("queryModel", queryModel); var updateClause = queryModel.BodyClauses.First(x => x as IModifyExpressionNode != null) as IModifyExpressionNode; updateClause.CollectionType = CollectionToModify; 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); }
public override Expression Resolve( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("inputParameter", inputParameter); Utils.CheckNotNull("expressionToBeResolved", expressionToBeResolved); var resolvedSelector = GetResolvedAdaptedSelector(clauseGenerationContext); return ReplacingExpressionTreeVisitor.Replace(inputParameter, resolvedSelector, expressionToBeResolved); }
public Expression GetResolvedLetExpression(ClauseGenerationContext clauseGenerationContext) { if (!IsLetNode) throw new InvalidOperationException("This node is not a 'let' node."); return _resolvedLetExpression.GetOrCreate( r => r.GetResolvedExpression(_letConstruction.Arguments[1], Selector.Parameters[0], clauseGenerationContext)); }
public override Expression Resolve ( ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext) { return QuerySourceExpressionNodeUtility.ReplaceParameterWithReference ( this, 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 Expression GetResolvedOptionalElementSelector (ClauseGenerationContext clauseGenerationContext) { if (OptionalElementSelector == null) return null; return _cachedElementSelector.GetOrCreate ( r => r.GetResolvedExpression (OptionalElementSelector.Body, OptionalElementSelector.Parameters[0], clauseGenerationContext)); }
protected override QueryModel 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); return queryModel; }
private MainFromClause CreateMainFromClause (ClauseGenerationContext clauseGenerationContext) { var fromClause = new MainFromClause ( AssociatedIdentifier, QuerySourceElementType, ParsedExpression); clauseGenerationContext.AddContextInfo (this, fromClause); return fromClause; }
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) { Utils.CheckNotNull("queryModel", queryModel); queryModel.BodyClauses.Add(new RemoveAndReturnClause( queryModel.MainFromClause.ItemName, (Type)Collection.Value, KeySelector != null ? GetResolvedKeyPredicate(clauseGenerationContext) : null)); return queryModel; }
protected override QueryModel 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.Asc)); 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 = TransparentIdentifierRemovingExpressionTreeVisitor.ReplaceTransparentIdentifiers (resolvedExpression); return resolvedExpression; }
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); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("queryModel", queryModel); queryModel.BodyClauses.Add(new UpdateAndReturnClause(GetResolvedPredicate(clauseGenerationContext), queryModel.MainFromClause.ItemName, WithSelector.Parameters[0].Type, KeySelector != null ? GetResolvedKeyPredicate(clauseGenerationContext) : null, Command.Value.ToString())); return queryModel; }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("queryModel", queryModel); var lastClause = queryModel.BodyClauses.LastOrDefault(); SkipTakeClause skipTakeClause = lastClause as SkipTakeClause; if (skipTakeClause != null) skipTakeClause.TakeCount = Count; else queryModel.BodyClauses.Add(new SkipTakeClause(null, Count)); return queryModel; }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("queryModel", queryModel); var groupByClause = new GroupByClause(GetResolvedSelector(clauseGenerationContext),Selector,intoIdentifier); queryModel.BodyClauses.Add(groupByClause); clauseGenerationContext.AddContextInfo(this, groupByClause); queryModel.SelectClause.Selector = GetResolvedAdaptedSelector(clauseGenerationContext); return queryModel; }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { Utils.CheckNotNull("queryModel", queryModel); queryModel.BodyClauses.Add(new UpsertAndReturnClause( GetResolvedSearchPredicate(clauseGenerationContext), GetResolvedInsertPredicate(clauseGenerationContext), GetResolvedUpdatePredicate(clauseGenerationContext), queryModel.MainFromClause.ItemName, UpdateType.Value as Type )); return queryModel; }
protected override QueryModel ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull ("queryModel", queryModel); var previousFetchRequest = clauseGenerationContext.GetContextInfo (Source) as FetchRequestBase; if (previousFetchRequest == null) throw new NotSupportedException ("ThenFetchMany must directly follow another Fetch request."); var innerFetchRequest = CreateFetchRequest(); innerFetchRequest = previousFetchRequest.GetOrAddInnerFetchRequest (innerFetchRequest); // Store a mapping between this node and the innerFetchRequest so that a later ThenFetch... node may add its request to the innerFetchRequest. clauseGenerationContext.AddContextInfo (this, innerFetchRequest); return queryModel; }
/// <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); } }
/// <summary> /// Replaces the given parameter with a back-reference to the <see cref="IQuerySource"/> corresponding to <paramref name="referencedNode"/>. /// </summary> /// <param name="referencedNode">The referenced node.</param> /// <param name="parameterToReplace">The parameter to replace with a <see cref="QuerySourceReferenceExpression"/>.</param> /// <param name="expression">The expression in which to replace the parameter.</param> /// <param name="context">The clause generation context.</param> /// <returns><paramref name="expression"/>, with <paramref name="parameterToReplace"/> replaced with a <see cref="QuerySourceReferenceExpression"/> /// pointing to the clause corresponding to <paramref name="referencedNode"/>.</returns> public static Expression ReplaceParameterWithReference ( IQuerySourceExpressionNode referencedNode, ParameterExpression parameterToReplace, Expression expression, ClauseGenerationContext context) { ArgumentUtility.CheckNotNull ("referencedNode", referencedNode); ArgumentUtility.CheckNotNull ("parameterToReplace", parameterToReplace); ArgumentUtility.CheckNotNull ("expression", expression); ArgumentUtility.CheckNotNull ("context", context); var clause = GetQuerySourceForNode (referencedNode, context); var referenceExpression = new QuerySourceReferenceExpression (clause); return ReplacingExpressionTreeVisitor.Replace (parameterToReplace, referenceExpression, expression); }
public Expression GetResolvedKeySelector(ClauseGenerationContext clauseGenerationContext) { return(_cachedSelector.GetOrCreate(r => r.GetResolvedExpression(KeySelector.Body, KeySelector.Parameters[0], clauseGenerationContext))); }
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext) { return(new MinResultOperator()); }
protected override QueryModel 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); return(queryModel); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { // The resolved inner key selector has a back-reference to the clause, so we need to create the clause with a dummy selector before we can // get the real inner key selector. JoinClause joinClause = CreateJoinClause(clauseGenerationContext); queryModel.BodyClauses.Add(joinClause); var selectClause = queryModel.SelectClause; selectClause.Selector = GetResolvedResultSelector(clauseGenerationContext); return(queryModel); }
protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext) { ArgumentUtility.CheckNotNull("queryModel", queryModel); queryModel.SelectClause.Selector = GetResolvedSelector(clauseGenerationContext); return(queryModel); }
public Expression GetResolvedResultSelector(ClauseGenerationContext clauseGenerationContext) { return(_cachedResultSelector.GetOrCreate(r => r.GetResolvedExpression( QuerySourceExpressionNodeUtility.ReplaceParameterWithReference(this, ResultSelector.Parameters[1], ResultSelector.Body, clauseGenerationContext), ResultSelector.Parameters[0], clauseGenerationContext))); }