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