public override EntityQueryModelVisitor Create(
QueryCompilationContext queryCompilationContext,
EntityQueryModelVisitor parentEntityQueryModelVisitor)
=> new RelationalQueryModelVisitor(
Model,
QueryOptimizer,
NavigationRewritingExpressionVisitorFactory,
SubQueryMemberPushDownExpressionVisitor,
QuerySourceTracingExpressionVisitorFactory,
EntityResultFindingExpressionVisitorFactory,
TaskBlockingExpressionVisitor,
MemberAccessBindingExpressionVisitorFactory,
OrderingExpressionVisitorFactory,
ProjectionExpressionVisitorFactory,
EntityQueryableExpressionVisitorFactory,
QueryAnnotationExtractor,
ResultOperatorHandler,
EntityMaterializerSource,
ExpressionPrinter,
RelationalAnnotationProvider,
IncludeExpressionVisitorFactory,
SqlTranslatingExpressionVisitorFactory,
CompositePredicateExpressionVisitorFactory,
QueryFlatteningExpressionVisitorFactory,
ShapedQueryFindingExpressionVisitorFactory,
ContextOptions,
(RelationalQueryCompilationContext)Check.NotNull(queryCompilationContext, nameof(queryCompilationContext)),
(RelationalQueryModelVisitor)parentEntityQueryModelVisitor);
/// <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>
public RequiresMaterializationExpressionVisitor(
[NotNull] IModel model,
[NotNull] EntityQueryModelVisitor queryModelVisitor)
{
_model = model;
_queryModelVisitor = queryModelVisitor;
}
public virtual ExpressionVisitor Create(
EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
=> new RelationalProjectionExpressionVisitor(
_sqlTranslatingExpressionVisitorFactory,
_entityMaterializerSource,
(RelationalQueryModelVisitor)Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)),
Check.NotNull(querySource, nameof(querySource)));
/// <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>
public virtual ExpressionVisitor Create(
EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
=> new InMemoryEntityQueryableExpressionVisitor(
_model,
_materializerFactory,
Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)),
querySource);
public override EntityQueryModelVisitor CreateQueryModelVisitor(EntityQueryModelVisitor parentEntityQueryModelVisitor)
{
var relationalQueryModelVisitor
= (RelationalQueryModelVisitor)base.CreateQueryModelVisitor(parentEntityQueryModelVisitor);
_relationalQueryModelVisitors.Add(relationalQueryModelVisitor);
return relationalQueryModelVisitor;
}
/// <summary>
/// Creates a new ExpressionVisitor.
/// </summary>
/// <param name="queryModelVisitor"> The query model visitor. </param>
/// <param name="querySource"> The query source. </param>
/// <returns>
/// An ExpressionVisitor.
/// </returns>
public virtual ExpressionVisitor Create(
EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
=> new RelationalEntityQueryableExpressionVisitor(
_model,
_selectExpressionFactory,
_materializerFactory,
_shaperCommandContextFactory,
_relationalAnnotationProvider,
(RelationalQueryModelVisitor)Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)),
querySource);
public override ExpressionVisitor Create(EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
{
return new MaterializingRelationalEntityQueryableExpressionVisitor(
_model,
_selectExpressionFactory,
_materializerFactory,
_shaperCommandContextFactory,
_relationalAnnotationProvider,
(RelationalQueryModelVisitor)queryModelVisitor,
querySource); ;
}
public override EntityQueryModelVisitor CreateQueryModelVisitor(
EntityQueryModelVisitor parentEntityQueryModelVisitor)
{
var relationalQueryModelVisitor
= new RelationalQueryModelVisitor(
this, (RelationalQueryModelVisitor)parentEntityQueryModelVisitor);
_relationalQueryModelVisitors.Add(relationalQueryModelVisitor);
return relationalQueryModelVisitor;
}
/// <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>
public InMemoryEntityQueryableExpressionVisitor(
[NotNull] IModel model,
[NotNull] IMaterializerFactory materializerFactory,
[NotNull] EntityQueryModelVisitor entityQueryModelVisitor,
[CanBeNull] IQuerySource querySource)
: base(Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor)))
{
Check.NotNull(model, nameof(model));
Check.NotNull(materializerFactory, nameof(materializerFactory));
_model = model;
_materializerFactory = materializerFactory;
_querySource = querySource;
}
public override EntityQueryModelVisitor Create(QueryCompilationContext queryCompilationContext,
EntityQueryModelVisitor parentEntityQueryModelVisitor)
{
var visitor = base.Create(queryCompilationContext, parentEntityQueryModelVisitor);
var fieldInfo = typeof(EntityQueryModelVisitor).GetField("_modelExpressionApplyingExpressionVisitor", BindingFlags.NonPublic | BindingFlags.Instance);
if (fieldInfo != null)
{
fieldInfo.SetValue(visitor,
new ScopeFilterModelExpressionApplyingExpressionVisitor(queryCompilationContext,
Dependencies.QueryModelGenerator, visitor, _store));
}
return(visitor);
}
private static Expression HandleCast(
EntityQueryModelVisitor entityQueryModelVisitor, CastResultOperator castResultOperator)
{
var resultItemTypeInfo
= entityQueryModelVisitor.Expression.Type
.GetSequenceType().GetTypeInfo();
return(castResultOperator.CastItemType.GetTypeInfo()
.IsAssignableFrom(resultItemTypeInfo)
? entityQueryModelVisitor.Expression
: Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider
.Cast.MakeGenericMethod(castResultOperator.CastItemType),
entityQueryModelVisitor.Expression));
}
/// <summary>
/// Handles the result operator.
/// </summary>
/// <param name="entityQueryModelVisitor"> The entity query model visitor. </param>
/// <param name="resultOperator"> The result operator. </param>
/// <param name="queryModel"> The query model. </param>
/// <returns>
/// An compiled query expression fragment representing the result operator.
/// </returns>
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor));
Check.NotNull(resultOperator, nameof(resultOperator));
Check.NotNull(queryModel, nameof(queryModel));
if (!_handlers.TryGetValue(resultOperator.GetType(), out var handler))
{
throw new NotImplementedException(resultOperator.GetType().ToString());
}
return(handler(entityQueryModelVisitor, resultOperator, queryModel));
}
public virtual void FindQuerySourcesRequiringMaterialization(
[NotNull] EntityQueryModelVisitor queryModelVisitor, [NotNull] QueryModel queryModel)
{
Check.NotNull(queryModelVisitor, nameof(queryModelVisitor));
Check.NotNull(queryModel, nameof(queryModel));
_querySourcesRequiringMaterialization
= _requiresMaterializationExpressionVisitorFactory
.Create(queryModelVisitor)
.FindQuerySourcesRequiringMaterialization(queryModel);
foreach (var groupJoinClause in queryModel.BodyClauses.OfType <GroupJoinClause>())
{
_querySourcesRequiringMaterialization.Add(groupJoinClause.JoinClause);
}
}
public LiteDBEntityQueryableExpressionVisitor(
EntityQueryModelVisitor entityQueryModelVisitor,
IModel model,
ILiteDBAnnotationsProvider annotationsProvider,
IFindExpressionFactory findExpressionFactory,
IMaterializerFactory materializerFactory,
IShaperCommandContextFactory shaperCommandContextFactory,
IValueBufferFromBsonShaperFactory valueBufferShaperFactory)
: base(entityQueryModelVisitor)
{
_model = model;
_annotationsProvider = annotationsProvider;
_findExpressionFactory = findExpressionFactory;
_materializerFactory = materializerFactory;
_shaperCommandContextFactory = shaperCommandContextFactory;
_valueBufferShaperFactory = valueBufferShaperFactory;
}
public override EntityQueryModelVisitor Create(QueryCompilationContext queryCompilationContext,
EntityQueryModelVisitor parentEntityQueryModelVisitor)
=> new MyEntityQueryModelVisitor(QueryOptimizer,
NavigationRewritingExpressionVisitorFactory,
SubQueryMemberPushDownExpressionVisitor,
QuerySourceTracingExpressionVisitorFactory,
EntityResultFindingExpressionVisitorFactory,
TaskBlockingExpressionVisitor,
MemberAccessBindingExpressionVisitorFactory,
OrderingExpressionVisitorFactory,
ProjectionExpressionVisitorFactory,
EntityQueryableExpressionVisitorFactory,
QueryAnnotationExtractor,
ResultOperatorHandler,
EntityMaterializerSource,
ExpressionPrinter,
queryCompilationContext);
public override EntityQueryModelVisitor Create(QueryCompilationContext queryCompilationContext,
EntityQueryModelVisitor parentEntityQueryModelVisitor)
=> new MyEntityQueryModelVisitor(QueryOptimizer,
NavigationRewritingExpressionVisitorFactory,
SubQueryMemberPushDownExpressionVisitor,
QuerySourceTracingExpressionVisitorFactory,
EntityResultFindingExpressionVisitorFactory,
TaskBlockingExpressionVisitor,
MemberAccessBindingExpressionVisitorFactory,
OrderingExpressionVisitorFactory,
ProjectionExpressionVisitorFactory,
EntityQueryableExpressionVisitorFactory,
QueryAnnotationExtractor,
ResultOperatorHandler,
EntityMaterializerSource,
ExpressionPrinter,
queryCompilationContext);
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor));
Check.NotNull(resultOperator, nameof(resultOperator));
Check.NotNull(queryModel, nameof(queryModel));
ResultHandler handler;
if (!_handlers.TryGetValue(resultOperator.GetType(), out handler))
{
throw new NotImplementedException(resultOperator.GetType().ToString());
}
return handler(entityQueryModelVisitor, resultOperator, queryModel);
}
private static Expression HandleContains(
EntityQueryModelVisitor entityQueryModelVisitor,
ContainsResultOperator containsResultOperator,
QueryModel queryModel)
{
var item
= entityQueryModelVisitor
.ReplaceClauseReferences(
containsResultOperator.Item,
queryModel.MainFromClause);
return(CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.Contains
.MakeGenericMethod(entityQueryModelVisitor.Expression.Type.GetSequenceType()),
entityQueryModelVisitor.Expression,
item));
}
private void AnalyzeTestExpression(Expression expression)
{
var querySourceReferenceExpression = expression as QuerySourceReferenceExpression;
if (querySourceReferenceExpression != null)
{
_querySource = querySourceReferenceExpression.ReferencedQuerySource;
_propertyName = null;
return;
}
var memberExpression = expression as MemberExpression;
if (memberExpression != null)
{
var querySourceInstance = memberExpression.Expression as QuerySourceReferenceExpression;
if (querySourceInstance != null)
{
_querySource = querySourceInstance.ReferencedQuerySource;
_propertyName = memberExpression.Member.Name;
return;
}
}
var methodCallExpression = expression as MethodCallExpression;
if (methodCallExpression != null && EntityQueryModelVisitor.IsPropertyMethod(methodCallExpression.Method))
{
var querySourceCaller = methodCallExpression.Arguments[0] as QuerySourceReferenceExpression;
if (querySourceCaller != null)
{
var propertyNameExpression = methodCallExpression.Arguments[1] as ConstantExpression;
if (propertyNameExpression != null)
{
_querySource = querySourceCaller.ReferencedQuerySource;
_propertyName = (string)propertyNameExpression.Value;
return;
}
}
}
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (EntityQueryModelVisitor.IsPropertyMethod(node.Method))
{
var propertyNameExpression = node.Arguments[1] as ConstantExpression;
if (propertyNameExpression != null && (string)propertyNameExpression.Value == _propertyName)
{
var querySource = node.Arguments[0] as QuerySourceReferenceExpression;
if (querySource != null)
{
_canRemoveNullCheck = querySource.ReferencedQuerySource == _querySource;
return(node);
}
}
}
return(base.VisitMethodCall(node));
}
private static Expression HandleAll(
EntityQueryModelVisitor entityQueryModelVisitor,
AllResultOperator allResultOperator,
QueryModel queryModel)
{
var sequenceType
= entityQueryModelVisitor.Expression.Type.GetSequenceType();
var predicate
= entityQueryModelVisitor
.ReplaceClauseReferences(
allResultOperator.Predicate,
queryModel.MainFromClause);
return(CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.All
.MakeGenericMethod(sequenceType),
entityQueryModelVisitor.Expression,
Expression.Lambda(predicate, entityQueryModelVisitor.CurrentParameter)));
}
private static Expression HandleSetOperation(
EntityQueryModelVisitor entityQueryModelVisitor,
Expression secondSource,
MethodInfo setMethodInfo)
{
var source2 = entityQueryModelVisitor.ReplaceClauseReferences(secondSource);
var resultType = entityQueryModelVisitor.Expression.Type.GetSequenceType();
var sourceType = source2.Type.GetSequenceType();
while (!resultType.GetTypeInfo().IsAssignableFrom(sourceType.GetTypeInfo()))
{
resultType = resultType.GetTypeInfo().BaseType;
}
return(Expression.Call(
setMethodInfo.MakeGenericMethod(resultType),
entityQueryModelVisitor.Expression,
source2));
}
private static Expression HandleAll(
EntityQueryModelVisitor entityQueryModelVisitor,
AllResultOperator allResultOperator,
QueryModel queryModel)
{
var predicate
= entityQueryModelVisitor
.ReplaceClauseReferences(
allResultOperator.Predicate,
queryModel.MainFromClause);
return CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.All
.MakeGenericMethod(typeof(QuerySourceScope)),
entityQueryModelVisitor.CreateScope(
entityQueryModelVisitor.Expression,
entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType,
queryModel.MainFromClause),
Expression.Lambda(predicate, EntityQueryModelVisitor.QuerySourceScopeParameter));
}
private static Expression HandleAll(
EntityQueryModelVisitor entityQueryModelVisitor,
AllResultOperator allResultOperator,
QueryModel queryModel)
{
var sequenceType
= entityQueryModelVisitor.Expression.Type.GetSequenceType();
var predicate
= entityQueryModelVisitor
.ReplaceClauseReferences(
allResultOperator.Predicate,
queryModel.MainFromClause);
return CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.All
.MakeGenericMethod(sequenceType),
entityQueryModelVisitor.Expression,
Expression.Lambda(predicate, entityQueryModelVisitor.CurrentParameter));
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
Check.NotNull(node, nameof(node));
if (EntityQueryModelVisitor.IsPropertyMethod(node.Method))
{
var newArg0 = Visit(node.Arguments[0]);
if (newArg0 != node.Arguments[0])
{
return(Expression.Call(
node.Method,
newArg0,
node.Arguments[1]));
}
return(node);
}
return(base.VisitMethodCall(node));
}
/// <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>
public ModelExpressionApplyingExpressionVisitor(
[NotNull] QueryCompilationContext queryCompilationContext,
[NotNull] IQueryModelGenerator queryModelGenerator,
[NotNull] EntityQueryModelVisitor entityQueryModelVisitor)
{
Check.NotNull(queryCompilationContext, nameof(queryCompilationContext));
Check.NotNull(queryModelGenerator, nameof(queryModelGenerator));
Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor));
_queryCompilationContext = queryCompilationContext;
_queryModelGenerator = queryModelGenerator;
_entityQueryModelVisitor = entityQueryModelVisitor;
_parameterExtractingExpressionVisitor = new ParameterExtractingExpressionVisitor(
((QueryModelGenerator)queryModelGenerator).EvaluatableExpressionFilter,
_parameters,
_queryCompilationContext.ContextType,
_queryCompilationContext.Logger,
parameterize: false,
generateContextAccessors: true);
}
/// <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>
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
var relationalQueryModelVisitor
= (RelationalQueryModelVisitor)entityQueryModelVisitor;
var selectExpression
= relationalQueryModelVisitor
.TryGetQuery(queryModel.MainFromClause);
var handlerContext
= new HandlerContext(
_resultOperatorHandler,
_model,
_relationalAnnotationProvider,
_sqlTranslatingExpressionVisitorFactory,
_selectExpressionFactory,
relationalQueryModelVisitor,
resultOperator,
queryModel,
selectExpression);
Func <HandlerContext, Expression> resultHandler;
if (relationalQueryModelVisitor.RequiresClientEval ||
relationalQueryModelVisitor.RequiresClientSelectMany ||
relationalQueryModelVisitor.RequiresClientJoin ||
relationalQueryModelVisitor.RequiresClientFilter ||
relationalQueryModelVisitor.RequiresClientOrderBy ||
relationalQueryModelVisitor.RequiresClientResultOperator ||
!_resultHandlers.TryGetValue(resultOperator.GetType(), out resultHandler) ||
selectExpression == null)
{
return(handlerContext.EvalOnClient());
}
return(resultHandler(handlerContext));
}
/// <summary>
/// Determines all query sources that require materialization.
/// </summary>
/// <param name="queryModelVisitor"> The query model visitor. </param>
/// <param name="queryModel"> The query model. </param>
public virtual void FindQuerySourcesRequiringMaterialization(
[NotNull] EntityQueryModelVisitor queryModelVisitor, [NotNull] QueryModel queryModel)
{
Check.NotNull(queryModelVisitor, nameof(queryModelVisitor));
Check.NotNull(queryModel, nameof(queryModel));
var requiresMaterializationExpressionVisitor
= _requiresMaterializationExpressionVisitorFactory
.Create(queryModelVisitor);
_querySourcesRequiringMaterialization = requiresMaterializationExpressionVisitor
.FindQuerySourcesRequiringMaterialization(queryModel);
var groupJoinMaterializationExpressionVisitor = new RequiresMaterializationForGroupJoinExpressionVisitor();
var groupJoinMaterializationQueryModelVistor = new RequiresMaterializationForGroupJoinQueryModelVisitor(
groupJoinMaterializationExpressionVisitor,
_querySourcesRequiringMaterialization,
requiresMaterializationExpressionVisitor);
groupJoinMaterializationExpressionVisitor.QueryModelVisitor = groupJoinMaterializationQueryModelVistor;
groupJoinMaterializationQueryModelVistor.VisitQueryModel(queryModel);
}
private static Expression HandleLast(
EntityQueryModelVisitor entityQueryModelVisitor,
ChoiceResultOperatorBase choiceResultOperator)
{
if (entityQueryModelVisitor.Expression is MethodCallExpression methodCallExpression &&
(methodCallExpression.Method
.MethodIsClosedFormOf(entityQueryModelVisitor.LinqOperatorProvider.Select) ||
methodCallExpression.Method
.MethodIsClosedFormOf(AsyncLinqOperatorProvider.SelectAsyncMethod)))
{
// Push Last down below Select
return
(methodCallExpression.Update(
methodCallExpression.Object,
new[]
{
Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.ToSequence
.MakeGenericMethod(methodCallExpression.Arguments[0].Type.GetSequenceType()),
Expression.Lambda(
CallWithPossibleCancellationToken(
(choiceResultOperator.ReturnDefaultWhenEmpty
? entityQueryModelVisitor.LinqOperatorProvider.LastOrDefault
: entityQueryModelVisitor.LinqOperatorProvider.Last)
.MakeGenericMethod(methodCallExpression.Arguments[0].Type.GetSequenceType()),
methodCallExpression.Arguments[0]))),
methodCallExpression.Arguments[1]
}));
}
return(CallWithPossibleCancellationToken(
(choiceResultOperator.ReturnDefaultWhenEmpty
? entityQueryModelVisitor.LinqOperatorProvider.LastOrDefault
: entityQueryModelVisitor.LinqOperatorProvider.Last)
.MakeGenericMethod(entityQueryModelVisitor.Expression.Type.GetSequenceType()),
entityQueryModelVisitor.Expression));
}
public override Expression HandleResultOperator(EntityQueryModelVisitor entityQueryModelVisitor, ResultOperatorBase resultOperator, QueryModel queryModel)
{
if (_resultHandlers.TryGetValue(resultOperator.GetType(), out var resultHandler))
{
var relationalQueryModelVisitor = (RelationalQueryModelVisitor)entityQueryModelVisitor;
var selectExpression
= relationalQueryModelVisitor
.TryGetQuery(queryModel.MainFromClause);
var handlerContext
= new HandlerContext(
_resultOperatorHandler,
_model,
_sqlTranslatingExpressionVisitorFactory,
_selectExpressionFactory,
relationalQueryModelVisitor,
resultOperator,
queryModel,
selectExpression);
if (relationalQueryModelVisitor.RequiresClientEval ||
relationalQueryModelVisitor.RequiresClientSelectMany ||
relationalQueryModelVisitor.RequiresClientJoin ||
relationalQueryModelVisitor.RequiresClientFilter ||
relationalQueryModelVisitor.RequiresClientOrderBy ||
relationalQueryModelVisitor.RequiresClientResultOperator ||
relationalQueryModelVisitor.RequiresStreamingGroupResultOperator ||
selectExpression == null)
{
return(handlerContext.EvalOnClient());
}
return(resultHandler(handlerContext));
}
return(base.HandleResultOperator(entityQueryModelVisitor, resultOperator, queryModel));
}
private Expression TryRemoveNullCheck(ConditionalExpression node)
{
var binaryTest = node.Test as BinaryExpression;
if (binaryTest == null ||
binaryTest.NodeType != ExpressionType.NotEqual)
{
return(null);
}
var rightConstant = binaryTest.Right as ConstantExpression;
if (rightConstant == null ||
rightConstant.Value != null)
{
return(null);
}
var ifFalseConstant = node.IfFalse as ConstantExpression;
if (ifFalseConstant == null ||
ifFalseConstant.Value != null)
{
return(null);
}
var ifTrueMemberExpression = node.IfTrue.RemoveConvert() as MemberExpression;
var correctMemberExpression = ifTrueMemberExpression != null &&
ifTrueMemberExpression.Expression == binaryTest.Left;
var ifTruePropertyMethodCallExpression = node.IfTrue.RemoveConvert() as MethodCallExpression;
var correctPropertyMethodCallExpression = ifTruePropertyMethodCallExpression != null &&
EntityQueryModelVisitor.IsPropertyMethod(ifTruePropertyMethodCallExpression.Method) &&
ifTruePropertyMethodCallExpression.Arguments[0] == binaryTest.Left;
return(correctMemberExpression || correctPropertyMethodCallExpression ? node.IfTrue : null);
}
private static Expression HandleSkip(
EntityQueryModelVisitor entityQueryModelVisitor,
SkipResultOperator skipResultOperator)
{
var countExpression
= new DefaultQueryExpressionVisitor(entityQueryModelVisitor)
.Visit(skipResultOperator.Count);
if (entityQueryModelVisitor.Expression is MethodCallExpression methodCallExpression &&
(methodCallExpression.Method
.MethodIsClosedFormOf(entityQueryModelVisitor.LinqOperatorProvider.Select) ||
methodCallExpression.Method
.MethodIsClosedFormOf(AsyncLinqOperatorProvider.SelectAsyncMethod)))
{
// Push Skip down below Select
return
(methodCallExpression.Update(
methodCallExpression.Object,
new[]
{
Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.Skip
.MakeGenericMethod(methodCallExpression.Arguments[0].Type.GetSequenceType()),
methodCallExpression.Arguments[0],
countExpression),
methodCallExpression.Arguments[1]
}));
}
return(Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.Skip
.MakeGenericMethod(entityQueryModelVisitor.Expression.Type.GetSequenceType()),
entityQueryModelVisitor.Expression,
countExpression));
}
public virtual Expression HandleResultOperator(
EntityQueryModelVisitor entityQueryModelVisitor,
ResultOperatorBase resultOperator,
QueryModel queryModel)
{
Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor));
Check.NotNull(resultOperator, nameof(resultOperator));
Check.NotNull(queryModel, nameof(queryModel));
var relationalQueryModelVisitor
= (RelationalQueryModelVisitor)entityQueryModelVisitor;
var selectExpression
= relationalQueryModelVisitor
.TryGetQuery(queryModel.MainFromClause);
var handlerContext
= new HandlerContext(
_resultOperatorHandler,
relationalQueryModelVisitor,
resultOperator,
queryModel,
selectExpression);
Func <HandlerContext, Expression> resultHandler;
if (relationalQueryModelVisitor.RequiresClientFilter ||
relationalQueryModelVisitor.RequiresClientResultOperator ||
!_resultHandlers.TryGetValue(resultOperator.GetType(), out resultHandler) ||
selectExpression == null)
{
return(handlerContext.EvalOnClient);
}
return(resultHandler(handlerContext));
}
private static Expression HandleGroup(
EntityQueryModelVisitor entityQueryModelVisitor,
GroupResultOperator groupResultOperator,
QueryModel queryModel)
{
var keySelector
= entityQueryModelVisitor
.ReplaceClauseReferences(
groupResultOperator.KeySelector,
queryModel.MainFromClause);
var elementSelector
= entityQueryModelVisitor
.ReplaceClauseReferences(
groupResultOperator.ElementSelector,
queryModel.MainFromClause);
var expression
= Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.GroupBy
.MakeGenericMethod(
entityQueryModelVisitor.Expression.Type.GetSequenceType(),
keySelector.Type,
elementSelector.Type),
entityQueryModelVisitor.Expression,
Expression.Lambda(keySelector, entityQueryModelVisitor.CurrentParameter),
Expression.Lambda(elementSelector, entityQueryModelVisitor.CurrentParameter));
entityQueryModelVisitor.CurrentParameter
= Expression.Parameter(expression.Type.GetSequenceType(), groupResultOperator.ItemName);
entityQueryModelVisitor
.AddOrUpdateMapping(groupResultOperator, entityQueryModelVisitor.CurrentParameter);
return(expression);
}
/// <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 VisitMethodCall(MethodCallExpression node)
{
Check.NotNull(node, nameof(node));
if (!EntityQueryModelVisitor.IsPropertyMethod(node.Method))
{
base.VisitMethodCall(node);
}
return
(_queryModelVisitor.BindNavigationPathPropertyExpression(
node,
(ps, qs) =>
{
return RewriteNavigationProperties(
ps.ToList(),
qs,
node.Arguments[0],
(string)(node.Arguments[1] as ConstantExpression).Value,
node.Type,
e => Expression.Call(node.Method, e, node.Arguments[1]));
})
?? base.VisitMethodCall(node));
}
/// <summary>
/// Determines all query sources that require materialization.
/// </summary>
/// <param name="queryModelVisitor"> The query model visitor. </param>
/// <param name="queryModel"> The query model. </param>
public virtual void FindQuerySourcesRequiringMaterialization(
[NotNull] EntityQueryModelVisitor queryModelVisitor, [NotNull] QueryModel queryModel)
{
Check.NotNull(queryModelVisitor, nameof(queryModelVisitor));
Check.NotNull(queryModel, nameof(queryModel));
_querySourcesRequiringMaterialization
= _requiresMaterializationExpressionVisitorFactory
.Create(queryModelVisitor)
.FindQuerySourcesRequiringMaterialization(queryModel);
var groupJoinClauses = queryModel.BodyClauses.OfType <GroupJoinClause>().ToList();
if (groupJoinClauses.Any())
{
_querySourcesRequiringMaterialization.Add(queryModel.MainFromClause);
foreach (var groupJoinClause in groupJoinClauses)
{
_querySourcesRequiringMaterialization.Add(groupJoinClause.JoinClause);
var subQueryInnerSequence = groupJoinClause.JoinClause.InnerSequence as SubQueryExpression;
if (subQueryInnerSequence != null)
{
var subQuerySourcesRequiringMaterialization
= _requiresMaterializationExpressionVisitorFactory
.Create(queryModelVisitor)
.FindQuerySourcesRequiringMaterialization(subQueryInnerSequence.QueryModel);
foreach (var subQuerySource in subQuerySourcesRequiringMaterialization)
{
_querySourcesRequiringMaterialization.Add(subQuerySource);
}
}
}
}
}
/// <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>
public DefaultQueryExpressionVisitor([NotNull] EntityQueryModelVisitor entityQueryModelVisitor)
{
Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor));
_entityQueryModelVisitor = entityQueryModelVisitor;
}
private static Expression HandleAny(EntityQueryModelVisitor entityQueryModelVisitor)
=> CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.Any
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression);
public override EntityQueryModelVisitor CreateQueryModelVisitor(
EntityQueryModelVisitor parentEntityQueryModelVisitor)
{
return new AtsQueryModelVisitor(this);
}
protected override Expression VisitSubQuery(SubQueryExpression expression)
{
Check.NotNull(expression, nameof(expression));
var subQueryModel = expression.QueryModel;
if (subQueryModel.IsIdentityQuery() &&
subQueryModel.ResultOperators.Count == 1)
{
var contains = subQueryModel.ResultOperators.First() as ContainsResultOperator;
if (contains != null)
{
var fromExpression = subQueryModel.MainFromClause.FromExpression;
if (fromExpression.NodeType == ExpressionType.Parameter ||
fromExpression.NodeType == ExpressionType.Constant ||
fromExpression.NodeType == ExpressionType.ListInit ||
fromExpression.NodeType == ExpressionType.NewArrayInit)
{
var memberItem = contains.Item as MemberExpression;
if (memberItem != null)
{
var aliasExpression = VisitMember(memberItem) as AliasExpression;
return(aliasExpression != null
? new InExpression(aliasExpression, new[] { fromExpression })
: null);
}
var methodCallItem = contains.Item as MethodCallExpression;
if (methodCallItem != null &&
EntityQueryModelVisitor.IsPropertyMethod(methodCallItem.Method))
{
var aliasExpression = (AliasExpression)VisitMethodCall(methodCallItem);
return(new InExpression(aliasExpression, new[] { fromExpression }));
}
}
}
}
else if (!(subQueryModel.GetOutputDataInfo() is StreamedSequenceInfo))
{
if (_inProjection &&
!(subQueryModel.GetOutputDataInfo() is StreamedScalarValueInfo))
{
return(null);
}
var querySourceReferenceExpression
= subQueryModel.SelectClause.Selector as QuerySourceReferenceExpression;
if (querySourceReferenceExpression == null ||
_inProjection ||
!_queryModelVisitor.QueryCompilationContext
.QuerySourceRequiresMaterialization(querySourceReferenceExpression.ReferencedQuerySource))
{
var queryModelVisitor
= (RelationalQueryModelVisitor)_queryModelVisitor.QueryCompilationContext
.CreateQueryModelVisitor(_queryModelVisitor);
queryModelVisitor.VisitSubQueryModel(subQueryModel);
if (queryModelVisitor.Queries.Count == 1 &&
!queryModelVisitor.RequiresClientFilter &&
!queryModelVisitor.RequiresClientProjection &&
!queryModelVisitor.RequiresClientResultOperator)
{
var selectExpression = queryModelVisitor.Queries.First();
selectExpression.Alias = string.Empty; // anonymous
var containsResultOperator
= subQueryModel.ResultOperators.LastOrDefault() as ContainsResultOperator;
if (containsResultOperator != null)
{
var itemExpression = Visit(containsResultOperator.Item) as AliasExpression;
if (itemExpression != null)
{
return(new InExpression(itemExpression, selectExpression));
}
}
return(selectExpression);
}
}
}
return(null);
}
private static Expression HandleMax(EntityQueryModelVisitor entityQueryModelVisitor)
=> HandleAggregate(entityQueryModelVisitor, "Max");
/// <summary>
/// Creates a new <see cref="EntityQueryModelVisitor" />.
/// </summary>
/// <param name="queryCompilationContext">
/// Compilation context for the query.
/// </param>
/// <param name="parentEntityQueryModelVisitor">
/// The visitor for the outer query.
/// </param>
/// <returns> The new created visitor. </returns>
public abstract EntityQueryModelVisitor Create(
QueryCompilationContext queryCompilationContext,
EntityQueryModelVisitor parentEntityQueryModelVisitor);
public virtual EntityQueryModelVisitor CreateQueryModelVisitor(
[CanBeNull] EntityQueryModelVisitor parentEntityQueryModelVisitor)
=> _entityQueryModelVisitorFactory.Create(this, parentEntityQueryModelVisitor);
/// <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>
public virtual RequiresMaterializationExpressionVisitor Create(EntityQueryModelVisitor queryModelVisitor)
=> new RequiresMaterializationExpressionVisitor(_model, queryModelVisitor);
private static Expression HandleCast(
EntityQueryModelVisitor entityQueryModelVisitor, CastResultOperator castResultOperator)
{
var resultItemTypeInfo
= entityQueryModelVisitor.Expression.Type
.GetSequenceType().GetTypeInfo();
if (castResultOperator.CastItemType.GetTypeInfo()
.IsAssignableFrom(resultItemTypeInfo))
{
return entityQueryModelVisitor.Expression;
}
return Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider
.Cast.MakeGenericMethod(castResultOperator.CastItemType),
entityQueryModelVisitor.Expression);
}
public override EntityQueryModelVisitor CreateQueryModelVisitor(EntityQueryModelVisitor parentEntityQueryModelVisitor)
=> new InMemoryQueryModelVisitor(this);
private static Expression HandleDefaultIfEmpty(
EntityQueryModelVisitor entityQueryModelVisitor,
DefaultIfEmptyResultOperator defaultIfEmptyResultOperator,
QueryModel queryModel)
{
if (defaultIfEmptyResultOperator.OptionalDefaultValue == null)
{
return Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.DefaultIfEmpty
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression);
}
var optionalDefaultValue
= entityQueryModelVisitor
.ReplaceClauseReferences(
defaultIfEmptyResultOperator.OptionalDefaultValue,
queryModel.MainFromClause);
return Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.DefaultIfEmptyArg
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression,
optionalDefaultValue);
}
/// <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>
public virtual ExpressionVisitor Create(EntityQueryModelVisitor queryModelVisitor)
=> new DefaultQueryExpressionVisitor(queryModelVisitor);
private static Expression HandleGroup(
EntityQueryModelVisitor entityQueryModelVisitor,
GroupResultOperator groupResultOperator,
QueryModel queryModel)
{
var keySelector
= entityQueryModelVisitor
.ReplaceClauseReferences(
groupResultOperator.KeySelector,
queryModel.MainFromClause);
var elementSelector
= entityQueryModelVisitor
.ReplaceClauseReferences(
groupResultOperator.ElementSelector,
queryModel.MainFromClause);
return Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.GroupBy
.MakeGenericMethod(
typeof(QuerySourceScope),
groupResultOperator.KeySelector.Type,
groupResultOperator.ElementSelector.Type),
entityQueryModelVisitor.CreateScope(
entityQueryModelVisitor.Expression,
entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType,
queryModel.MainFromClause),
Expression.Lambda(keySelector, EntityQueryModelVisitor.QuerySourceScopeParameter),
Expression.Lambda(elementSelector, EntityQueryModelVisitor.QuerySourceScopeParameter));
}
protected EntityQueryableExpressionTreeVisitor([NotNull] EntityQueryModelVisitor entityQueryModelVisitor)
: base(Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor)))
{
}
private static Expression HandleSum(EntityQueryModelVisitor entityQueryModelVisitor)
=> HandleAggregate(entityQueryModelVisitor, "Sum");
private static Expression HandleAverage(EntityQueryModelVisitor entityQueryModelVisitor)
=> HandleAggregate(entityQueryModelVisitor, "Average");
private static Expression HandleSingle(
EntityQueryModelVisitor entityQueryModelVisitor, ChoiceResultOperatorBase choiceResultOperator)
=> CallWithPossibleCancellationToken(
(choiceResultOperator.ReturnDefaultWhenEmpty
? entityQueryModelVisitor.LinqOperatorProvider.SingleOrDefault
: entityQueryModelVisitor.LinqOperatorProvider.Single)
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression);
private static Expression HandleTake(
EntityQueryModelVisitor entityQueryModelVisitor, TakeResultOperator takeResultOperator)
=> Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.Take
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression, takeResultOperator.Count);
private static Expression HandleOfType(
EntityQueryModelVisitor entityQueryModelVisitor,
OfTypeResultOperator ofTypeResultOperator)
=> Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.OfType
.MakeGenericMethod(ofTypeResultOperator.SearchedItemType),
entityQueryModelVisitor.Expression);
/// <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>
public virtual ExpressionVisitor Create(
QuerySourceMapping querySourceMapping,
EntityQueryModelVisitor queryModelVisitor,
bool inProjection)
=> new MemberAccessBindingExpressionVisitor(querySourceMapping, queryModelVisitor, inProjection);
private static Expression HandleAggregate(EntityQueryModelVisitor entityQueryModelVisitor, string methodName)
=> CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.GetAggregateMethod(
methodName,
entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression);
private static Expression HandleContains(
EntityQueryModelVisitor entityQueryModelVisitor,
ContainsResultOperator containsResultOperator,
QueryModel queryModel)
{
var item = entityQueryModelVisitor
.ReplaceClauseReferences(
containsResultOperator.Item,
queryModel.MainFromClause);
return CallWithPossibleCancellationToken(
entityQueryModelVisitor.LinqOperatorProvider.Contains
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression,
item);
}
/// <summary>
///
/// </summary>
/// <param name="entityQueryModelVisitor"></param>
/// <param name="querySource"></param>
/// <returns></returns>
public virtual ExpressionVisitor Create(
EntityQueryModelVisitor entityQueryModelVisitor, IQuerySource querySource)
=> new CypherProjectionExpressionVisitor(
Dependencies,
(CypherQueryModelVisitor)Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor)),
Check.NotNull(querySource, nameof(querySource)));
private static Expression HandleDistinct(EntityQueryModelVisitor entityQueryModelVisitor)
=> Expression.Call(
entityQueryModelVisitor.LinqOperatorProvider.Distinct
.MakeGenericMethod(entityQueryModelVisitor.StreamedSequenceInfo.ResultItemType),
entityQueryModelVisitor.Expression);
