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)));
}
