/// <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 DbContextDependencies(
[NotNull] IChangeDetector changeDetector,
[NotNull] IDbSetInitializer dbSetInitializer,
[NotNull] IEntityFinderSource entityFinderSource,
[NotNull] IEntityGraphAttacher entityGraphAttacher,
[NotNull] IModel model,
[NotNull] IAsyncQueryProvider queryProvider,
[NotNull] IStateManager stateManager)
{
Check.NotNull(changeDetector, nameof(changeDetector));
Check.NotNull(dbSetInitializer, nameof(dbSetInitializer));
Check.NotNull(entityFinderSource, nameof(entityFinderSource));
Check.NotNull(entityGraphAttacher, nameof(entityGraphAttacher));
Check.NotNull(model, nameof(model));
Check.NotNull(queryProvider, nameof(queryProvider));
Check.NotNull(stateManager, nameof(stateManager));
ChangeDetector = changeDetector;
DbSetInitializer = dbSetInitializer;
EntityFinderSource = entityFinderSource;
EntityGraphAttacher = entityGraphAttacher;
Model = model;
QueryProvider = queryProvider;
StateManager = stateManager;
}
public AsyncInterceptingProvider(
IAsyncQueryProvider underlyingProvider,
IReadOnlyCollection <Func <Expression, Expression> > visitors)
: base(underlyingProvider, visitors)
{
AsyncUnderlyingProvider = underlyingProvider;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public EntityQueryable([NotNull] IAsyncQueryProvider queryProvider)
{
Check.NotNull(queryProvider, nameof(queryProvider));
_queryProvider = queryProvider;
Expression = Expression.Constant(this);
}
private NavigationRewritingExpressionVisitor(
EntityQueryModelVisitor queryModelVisitor, IAsyncQueryProvider entityQueryProvider, NavigationRewritingExpressionVisitor parentvisitor)
: this(queryModelVisitor)
{
_entityQueryProvider = entityQueryProvider;
_parentvisitor = parentvisitor;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public EntityQueryable([NotNull] IAsyncQueryProvider queryProvider, [NotNull] Expression expression)
{
Check.NotNull(queryProvider, nameof(queryProvider));
Check.NotNull(expression, nameof(expression));
_queryProvider = queryProvider;
Expression = expression;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public TemporalAsOfQueryRootExpression(
IAsyncQueryProvider queryProvider,
IEntityType entityType,
DateTime pointInTime)
: base(queryProvider, entityType)
{
PointInTime = pointInTime;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public TemporalContainedInQueryRootExpression(
IAsyncQueryProvider queryProvider,
IEntityType entityType,
DateTime from,
DateTime to)
: base(queryProvider, entityType, from, to)
{
}
public AsyncQueryable(IQueryProvider queryProvider, Expression expression)
{
QueryProvider = queryProvider.AsAsyncQueryProvider()
?? throw new ArgumentNullException(nameof(queryProvider));
Expression = expression
?? throw new ArgumentNullException(nameof(expression));
}
private async IAsyncEnumerator <T> GetAsyncEnumeratorInternal(IAsyncQueryProvider provider, CancellationToken cancellationToken = default)
{
var enumerable = (IEnumerable <T>) await provider.ExecuteAsync <Task <object> >(_expression, cancellationToken);
foreach (var element in enumerable)
{
yield return(element);
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public EntityQueryable([NotNull] IAsyncQueryProvider queryProvider, [NotNull] IEntityType entityType)
{
Check.NotNull(queryProvider, nameof(queryProvider));
Check.NotNull(entityType, nameof(entityType));
_queryProvider = queryProvider;
_entityType = entityType;
Expression = Expression.Constant(this);
}
private IAsyncQueryProvider GetQueryProvider()
{
if (queryProvider == null)
{
queryProvider = currentDbContext.GetDependencies().QueryProvider;
}
return(queryProvider);
}
/// <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 EntityQueryable([NotNull] IAsyncQueryProvider queryProvider, [NotNull] IParameterizedQuery definingParameterizedQuery, [NotNull] object definingParameter)
{
Check.NotNull(queryProvider, nameof(queryProvider));
Check.NotNull(definingParameterizedQuery, nameof(definingParameterizedQuery));
Check.NotNull(definingParameter, nameof(definingParameter));
DefiningParameterizedQuery = definingParameterizedQuery;
DefiningParameter = definingParameter;
}
/// <summary>
/// Creates a new instance of the <see cref="QueryRootExpression" /> class with associated query provider.
/// </summary>
/// <param name="asyncQueryProvider"> The query provider associated with this query root. </param>
/// <param name="entityType"> The entity type this query root represents. </param>
public QueryRootExpression(IAsyncQueryProvider asyncQueryProvider, IEntityType entityType)
{
Check.NotNull(asyncQueryProvider, nameof(asyncQueryProvider));
Check.NotNull(entityType, nameof(entityType));
QueryProvider = asyncQueryProvider;
EntityType = entityType;
Type = typeof(IQueryable <>).MakeGenericType(entityType.ClrType);
}
protected static object ExecuteAsync <TResult>(IAsyncQueryProvider asyncQueryProvider, Expression expression)
{
return(ExecuteAsync1.MakeGenericMethod(typeof(TResult)).Invoke(
asyncQueryProvider,
new object[]
{
expression
}));
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public TemporalRangeQueryRootExpression(
IAsyncQueryProvider queryProvider,
IEntityType entityType,
DateTime from,
DateTime to)
: base(queryProvider, entityType)
{
From = from;
To = to;
}
protected override Expression VisitConstant(ConstantExpression constantExpression)
{
if (_entityQueryProvider == null)
{
_entityQueryProvider
= (constantExpression.Value as IQueryable)?.Provider as IAsyncQueryProvider;
}
return(constantExpression);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public FromSqlQueryRootExpression(
[NotNull] IAsyncQueryProvider queryProvider, [NotNull] IEntityType entityType, [NotNull] string sql, [NotNull] Expression argument)
: base(queryProvider, entityType)
{
Check.NotEmpty(sql, nameof(sql));
Check.NotNull(argument, nameof(argument));
Sql = sql;
Argument = argument;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public FromSqlQueryRootExpression(
IAsyncQueryProvider queryProvider,
IEntityType entityType,
string sql,
Expression argument)
: base(queryProvider, entityType)
{
Sql = sql;
Argument = argument;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public static ConstantExpression CreateEntityQueryableExpression(
[NotNull] this IAsyncQueryProvider entityQueryProvider, [NotNull] Type type)
{
Check.NotNull(entityQueryProvider, nameof(entityQueryProvider));
Check.NotNull(type, nameof(type));
return(Expression.Constant(
_createEntityQueryableMethod
.MakeGenericMethod(type)
.Invoke(
null, new object[] { entityQueryProvider })));
}
/// <summary>
/// This constructor is called by Provider.CreateQuery().
/// </summary>
/// <param name="provider"></param>
/// <param name="expression"></param>
public Query(IAsyncQueryProvider provider, Expression expression)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (!typeof(IAsyncQueryable <T>).GetTypeInfo().IsAssignableFrom(expression.Type))
{
throw new ArgumentOutOfRangeException(nameof(expression));
}
this.Provider = provider ?? throw new ArgumentNullException(nameof(provider));
this.Expression = expression;
}
/// <summary>
/// Create a new rewrite query provider.
/// </summary>
/// <param name="provider">The actual query provider.</param>
/// <param name="rewriter">The rewriter to rewrite the query.</param>
public RewriteAsyncQueryProvider(IAsyncQueryProvider provider, ExpressionVisitor rewriter)
{
if (provider is null)
{
throw new ArgumentNullException(nameof(provider));
}
if (rewriter is null)
{
throw new ArgumentNullException(nameof(rewriter));
}
Provider = provider;
Rewriter = rewriter;
}
internal CouchDatabase(IFlurlClient flurlClient, CouchOptions options, QueryContext queryContext)
{
_flurlClient = flurlClient;
_options = options;
_queryContext = queryContext;
var queryOptimizer = new QueryOptimizer();
var queryTranslator = new QueryTranslator(options);
var querySender = new QuerySender(flurlClient, queryContext);
var queryCompiler = new QueryCompiler(queryOptimizer, queryTranslator, querySender);
_queryProvider = new CouchQueryProvider(queryCompiler);
Security = new CouchSecurity(NewRequest);
LocalDocuments = new LocalDocuments(flurlClient, queryContext);
}
private async Task <object> ExecuteExpressionAsync <T>(CancellationToken cancellationToken)
{
IAsyncQueryProvider provider = this.dbContext.GetService <IAsyncQueryProvider>();
var queryResult = new List <T>();
using (var enumerator = provider.ExecuteAsync <T>(this.linqExpression).GetEnumerator())
{
while (await enumerator.MoveNext(cancellationToken))
{
queryResult.Add(enumerator.Current);
}
}
return(queryResult);
}
protected override Expression VisitConstant(ConstantExpression node)
{
if (_entityQueryProvider == null)
{
_entityQueryProvider
= (node.Value as IQueryable)?.Provider as IAsyncQueryProvider;
var parent = _parentvisitor;
while (parent != null)
{
parent._entityQueryProvider = _entityQueryProvider;
parent = parent._parentvisitor;
}
}
return(node);
}
/// <summary>
/// Create a new query to rewrite.
/// </summary>
/// <param name="query">The actual query.</param>
/// <param name="rewriter">The rewriter to rewrite the query.</param>
protected RewriteAsyncQuery(IAsyncQueryable query, ExpressionVisitor rewriter)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (rewriter == null)
{
throw new ArgumentNullException(nameof(rewriter));
}
elementType = query.ElementType;
expression = query.Expression;
// replace query provider for further chaining
provider = new RewriteAsyncQueryProvider(query.Provider, rewriter);
}
internal CouchDatabase(IFlurlClient flurlClient, CouchOptions options, QueryContext queryContext, string?discriminator)
{
_feedChangeLineStartPattern = new Regex(@"{""seq");
_flurlClient = flurlClient;
_options = options;
_queryContext = queryContext;
_discriminator = discriminator;
var queryOptimizer = new QueryOptimizer();
var queryTranslator = new QueryTranslator(options);
var querySender = new QuerySender(flurlClient, queryContext);
var queryCompiler = new QueryCompiler(queryOptimizer, queryTranslator, querySender, _discriminator);
_queryProvider = new CouchQueryProvider(queryCompiler);
Security = new CouchSecurity(NewRequest);
LocalDocuments = new LocalDocuments(flurlClient, queryContext);
}
private async static Task <TResult> Execute <TSource, TResult>(IQueryable <TSource> source, string methodName)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
IAsyncQueryProvider provider = source.Provider as IAsyncQueryProvider;
if (provider == null)
{
throw new NotSupportedException();
}
MethodInfo method = typeof(AsyncQueryExtensions).GetMethod(methodName)
.MakeGenericMethod(typeof(TSource));
return(await provider.ExecuteAsync <TResult>(
Expression.Call(null, method, source.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 DbContextDependencies(
[NotNull] IChangeDetector changeDetector,
[NotNull] IDbSetSource setSource,
[NotNull] IEntityFinderSource entityFinderSource,
[NotNull] IEntityGraphAttacher entityGraphAttacher,
[NotNull] IModel model,
[NotNull] IAsyncQueryProvider queryProvider,
[NotNull] IStateManager stateManager,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Infrastructure> infrastuctureLogger)
{
ChangeDetector = changeDetector;
SetSource = setSource;
EntityFinderSource = entityFinderSource;
EntityGraphAttacher = entityGraphAttacher;
Model = model;
QueryProvider = queryProvider;
StateManager = stateManager;
UpdateLogger = updateLogger;
InfrastructureLogger = infrastuctureLogger;
}
/// <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 ParameterExtractingExpressionVisitor(
[NotNull] IEvaluatableExpressionFilter evaluatableExpressionFilter,
[NotNull] IParameterValues parameterValues,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Query> logger,
[NotNull] DbContext context,
bool parameterize,
bool generateContextAccessors = false)
{
_evaluatableExpressionFilter = evaluatableExpressionFilter;
_parameterValues = parameterValues;
_logger = logger;
_parameterize = parameterize;
_generateContextAccessors = generateContextAccessors;
_queryProvider = context.GetDependencies().QueryProvider;
if (_generateContextAccessors)
{
_contextParameterReplacingExpressionVisitor
= new ContextParameterReplacingExpressionVisitor(context.GetType());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryDataHelper" /> class.
/// </summary>
/// <param name="dbContext"> <see cref="DbContext" /> against which the requested query will be executed. </param>
/// <param name="request"> The <see cref="QueryDataRequest" /> object from the client containing the query. </param>
/// <param name="customValueMappers"> Custom value mappers. </param>
public QueryDataHelper(
DbContext dbContext,
QueryDataRequest request,
IEnumerable <IInfoCarrierValueMapper> customValueMappers)
{
this.dbContext = dbContext;
this.valueMappers = customValueMappers.Concat(StandardValueMappers.Mappers);
this.dbContext.ChangeTracker.QueryTrackingBehavior = request.TrackingBehavior;
IAsyncQueryProvider provider = this.dbContext.GetService <IAsyncQueryProvider>();
// UGLY: this resembles Remote.Linq.Expressions.ExpressionExtensions.PrepareForExecution()
// but excludes PartialEval (otherwise simple queries like db.Set<X>().First() are executed
// prematurely)
this.linqExpression = request.Query
.ReplaceNonGenericQueryArgumentsByGenericArguments()
.ReplaceResourceDescriptorsByQueryable(
this.typeResolver,
provider: type => (IQueryable)Activator.CreateInstance(typeof(EntityQueryable <>).MakeGenericType(type), provider))
.ToLinqExpression(this.typeResolver);
// Replace NullConditionalExpressionStub MethodCallExpression with NullConditionalExpression
this.linqExpression = Utils.ReplaceNullConditional(this.linqExpression, false);
}
