public CosmosSqlDatabase( [NotNull] DatabaseDependencies dependencies, DocumentCollectionUpdaterFactory documentCollectionFactory) : base(dependencies) { _documentCollectionFactory = documentCollectionFactory; }
public InfoCarrierDatabase( DatabaseDependencies dependencies, IDbContextOptions options) : base(dependencies) { this.infoCarrierClient = options.Extensions.OfType <InfoCarrierOptionsExtension>().First().InfoCarrierClient; }
public CosmosDatabase( DatabaseDependencies dependencies, CosmosClient cosmosClient) : base(dependencies) { _cosmosClient = cosmosClient; }
public MongoDbDatabase( [NotNull] DatabaseDependencies databaseDependencies, [NotNull] IMongoDbConnection mongoDbConnection) : base(Check.NotNull(databaseDependencies, nameof(databaseDependencies))) { _mongoDbConnection = Check.NotNull(mongoDbConnection, nameof(mongoDbConnection)); }
/// <summary> /// Initializes a new instance of the <see cref="RelationalDatabase" /> class. /// </summary> /// <param name="dependencies">Parameter object containing dependencies for the base of this service.</param> /// <param name="relationalDependencies">Parameter object containing relational dependencies for this service.</param> public RelationalDatabase( DatabaseDependencies dependencies, RelationalDatabaseDependencies relationalDependencies) : base(dependencies) { RelationalDependencies = relationalDependencies; }
public CosmosSqlDatabase( [NotNull] DatabaseDependencies dependencies, CosmosClient cosmosClient, IDocumentCollectionFactory documentCollectionFactory) : base(dependencies) { _cosmosClient = cosmosClient; _documentCollectionFactory = documentCollectionFactory; }
/// <summary> /// Initializes a new instance of hte <see cref="MongoDbDatabase"/> class. /// </summary> /// <param name="databaseDependencies">Parameter object containing dependencies for this service.</param> /// <param name="mongoDbConnection">A <see cref="IMongoDbConnection"/> used to communicate with the MongoDB instance.</param> /// <param name="mongoDbWriteModelFactorySelector">The <see cref="IMongoDbWriteModelFactorySelector"/> to use to create /// <see cref="IMongoDbWriteModelFactory{TEntity}"/> instances.</param> public MongoDbDatabase( [NotNull] DatabaseDependencies databaseDependencies, [NotNull] IMongoDbConnection mongoDbConnection, [NotNull] IMongoDbWriteModelFactorySelector mongoDbWriteModelFactorySelector) : base(Check.NotNull(databaseDependencies, nameof(databaseDependencies))) { _mongoDbConnection = Check.NotNull(mongoDbConnection, nameof(mongoDbConnection)); _mongoDbWriteModelFactorySelector = Check.NotNull(mongoDbWriteModelFactorySelector, nameof(mongoDbWriteModelFactorySelector)); }
public CosmosDatabase( DatabaseDependencies dependencies, CosmosClient cosmosClient, ILoggingOptions loggingOptions) : base(dependencies) { _cosmosClient = cosmosClient; if (loggingOptions.IsSensitiveDataLoggingEnabled) { _sensitiveLoggingEnabled = true; } }
public static string ToSql <TEntity>(this IQueryable <TEntity> query, DbContext dbCtx) { IQueryModelGenerator modelGenerator = dbCtx.GetService <IQueryModelGenerator>(); QueryModel queryModel = modelGenerator.ParseQuery(query.Expression); DatabaseDependencies databaseDependencies = dbCtx.GetService <DatabaseDependencies>(); QueryCompilationContext queryCompilationContext = databaseDependencies.QueryCompilationContextFactory.Create(false); RelationalQueryModelVisitor modelVisitor = (RelationalQueryModelVisitor)queryCompilationContext.CreateQueryModelVisitor(); modelVisitor.CreateQueryExecutor <TEntity>(queryModel); var sql = modelVisitor.Queries.First().ToString(); return(sql); }
/// <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 CosmosDatabaseWrapper( [NotNull] DatabaseDependencies dependencies, [NotNull] CosmosClientWrapper cosmosClient, [NotNull] ILoggingOptions loggingOptions) : base(dependencies) { _cosmosClient = cosmosClient; if (loggingOptions.IsSensitiveDataLoggingEnabled) { _sensitiveLoggingEnabled = 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 HarmonyDatabase( DatabaseDependencies dependencies, IDataObjectProvider dataProvider, IServiceProvider serviceProvider, IDbContextOptions options, IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger) : base(dependencies) { //_store = storeCache.GetStore(options); _updateLogger = updateLogger; _dataObjectProvider = dataProvider; _serviceProvider = serviceProvider; }
public void Save_changes_returns_requested_document_count() { var queryCompilationContextFactory = Mock.Of <IQueryCompilationContextFactory>(); var mockMongoDbConnection = new Mock <IMongoDbConnection>(); var mockStateManager = new Mock <IStateManager>(); var mockMongoCollection = new Mock <IMongoCollection <SimpleRecord> >(); var mockValueGenerationManager = new Mock <IValueGenerationManager>(); var mockInternalEntityEntryNotifier = new Mock <IInternalEntityEntryNotifier>(); mockStateManager.SetupGet(stateManager => stateManager.ValueGeneration) .Returns(() => mockValueGenerationManager.Object); mockStateManager.SetupGet(stateManager => stateManager.Notify) .Returns(() => mockInternalEntityEntryNotifier.Object); mockMongoDbConnection.Setup(mockedMongoDbConnection => mockedMongoDbConnection.GetCollection <SimpleRecord>()) .Returns(() => mockMongoCollection.Object); mockMongoCollection.Setup(mongoCollection => mongoCollection.BulkWrite( It.IsAny <IEnumerable <WriteModel <SimpleRecord> > >(), It.IsAny <BulkWriteOptions>(), It.IsAny <CancellationToken>())) .Returns((IEnumerable <WriteModel <SimpleRecord> > list, BulkWriteOptions options, CancellationToken token) => new BulkWriteResult <SimpleRecord> .Acknowledged( list.Count(), matchedCount: 0, deletedCount: list.OfType <DeleteOneModel <SimpleRecord> >().Count(), insertedCount: list.OfType <InsertOneModel <SimpleRecord> >().Count(), modifiedCount: list.OfType <ReplaceOneModel <SimpleRecord> >().Count(), processedRequests: list, upserts: new List <BulkWriteUpsert>())); var databaseDepedencies = new DatabaseDependencies(queryCompilationContextFactory); var mongoDbDatabase = new MongoDbDatabase(databaseDepedencies, mockMongoDbConnection.Object); var model = new Model(new CoreConventionSetBuilder().CreateConventionSet()); EntityType entityType = model.AddEntityType(typeof(SimpleRecord)); entityType.Builder .GetOrCreateProperties(typeof(SimpleRecord).GetTypeInfo().GetProperties(), ConfigurationSource.Convention); entityType.Builder .MongoDb(ConfigurationSource.Convention) .FromCollection(collectionName: "simpleRecords"); IReadOnlyList <InternalEntityEntry> entityEntries = new[] { EntityState.Added, EntityState.Deleted, EntityState.Modified } .Select(entityState => { var entityEntry = new InternalClrEntityEntry(mockStateManager.Object, entityType, new SimpleRecord()); entityEntry.SetEntityState(entityState, acceptChanges: true); return(entityEntry); }) .ToList(); Assert.Equal(entityEntries.Count, mongoDbDatabase.SaveChanges(entityEntries)); }
/// <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 FileContextDatabase( [NotNull] DatabaseDependencies dependencies, [NotNull] IFileContextStoreCache storeCache, [NotNull] IDbContextOptions options, [NotNull] IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger) : base(dependencies) { Check.NotNull(storeCache, nameof(storeCache)); Check.NotNull(options, nameof(options)); Check.NotNull(updateLogger, nameof(updateLogger)); _store = storeCache.GetStore(options.Extensions.OfType <FileContextOptionsExtension>().First()); _updateLogger = updateLogger; }
/// <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 InMemoryDatabase( [NotNull] DatabaseDependencies dependencies, [NotNull] IInMemoryStoreSource storeSource, [NotNull] IDbContextOptions options, [NotNull] ILogger <InMemoryDatabase> logger) : base(dependencies) { Check.NotNull(storeSource, nameof(storeSource)); Check.NotNull(options, nameof(options)); Check.NotNull(logger, nameof(logger)); _store = storeSource.GetStore(options); _logger = logger; }
/// <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 InMemoryDatabase( DatabaseDependencies dependencies, IInMemoryStoreCache storeCache, IDbContextOptions options, IDesignTimeModel designTimeModel, IUpdateAdapterFactory updateAdapterFactory, IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger) : base(dependencies) { _store = storeCache.GetStore(options); _designTimeModel = designTimeModel; _updateAdapterFactory = updateAdapterFactory; _updateLogger = updateLogger; }
/// <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 InMemoryDatabase( [NotNull] DatabaseDependencies dependencies, [NotNull] IInMemoryStoreSource storeSource, [NotNull] IDbContextOptions options, [NotNull] IInterceptingLogger <LoggerCategory.Update> updateLogger) : base(dependencies) { Check.NotNull(storeSource, nameof(storeSource)); Check.NotNull(options, nameof(options)); Check.NotNull(updateLogger, nameof(updateLogger)); _store = storeSource.GetStore(options); _updateLogger = updateLogger; }
/// <summary> /// Initializes a new instance of the <see cref="LiteDBDatabase"/> class. /// 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 LiteDBDatabase( [NotNull] DatabaseDependencies dependencies, [NotNull] ILiteDBStoreCache storeCache, [NotNull] IDbContextOptions options, [NotNull] IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger) : base(dependencies) { Check.NotNull(storeCache, nameof(storeCache)); Check.NotNull(options, nameof(options)); Check.NotNull(updateLogger, nameof(updateLogger)); _store = storeCache.GetStore(options); _updateLogger = updateLogger; }
public static string ToSql <TEntity>(this IQueryable <TEntity> query) where TEntity : class { QueryCompiler queryCompiler = (QueryCompiler)QueryCompilerField.GetValue(query.Provider); QueryModelGenerator modelGenerator = (QueryModelGenerator)QueryModelGeneratorField.GetValue(queryCompiler); Remotion.Linq.QueryModel queryModel = modelGenerator.ParseQuery(query.Expression); IDatabase database = (IDatabase)DataBaseField.GetValue(queryCompiler); DatabaseDependencies databaseDependencies = (DatabaseDependencies)DatabaseDependenciesField.GetValue(database); QueryCompilationContext queryCompilationContext = databaseDependencies.QueryCompilationContextFactory.Create(false); RelationalQueryModelVisitor modelVisitor = (RelationalQueryModelVisitor)queryCompilationContext.CreateQueryModelVisitor(); modelVisitor.CreateQueryExecutor <TEntity>(queryModel); string sql = modelVisitor.Queries.First().ToString(); return(sql); }
public GDbDatabase( DatabaseDependencies databaseDependencies, IGDbStoreCache gDbStoreCache, IDbContextOptions dbContextOptions, IDiagnosticsLogger <DbLoggerCategory.Update> diagnosticsLogger, IGDbQueryExecutorFactory gDbQueryBuilderFactory) : base( databaseDependencies) { _gDbStore = gDbStoreCache .GetStore( dbContextOptions, gDbQueryBuilderFactory); _diagnosticsLogger = diagnosticsLogger; }
/// <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 InMemoryDatabase( [NotNull] DatabaseDependencies dependencies, [NotNull] IInMemoryStoreCache storeCache, [NotNull] IDbContextOptions options, [NotNull] IUpdateAdapterFactory updateAdapterFactory, [NotNull] IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger) : base(dependencies) { Check.NotNull(storeCache, nameof(storeCache)); Check.NotNull(options, nameof(options)); Check.NotNull(updateAdapterFactory, nameof(updateAdapterFactory)); Check.NotNull(updateLogger, nameof(updateLogger)); _store = storeCache.GetStore(options); _updateAdapterFactory = updateAdapterFactory; _updateLogger = updateLogger; }
/// <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 InMemoryDatabase( DatabaseDependencies dependencies, IInMemoryStoreCache storeCache, IDbContextOptions options, ICurrentDbContext context, IUpdateAdapterFactory updateAdapterFactory, IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger) : base(dependencies) { Check.NotNull(storeCache, nameof(storeCache)); Check.NotNull(options, nameof(options)); Check.NotNull(updateAdapterFactory, nameof(updateAdapterFactory)); Check.NotNull(updateLogger, nameof(updateLogger)); _store = storeCache.GetStore(options); _getDesignModel = () => context.Context.DesignTimeModel; _updateAdapterFactory = updateAdapterFactory; _updateLogger = updateLogger; }
/// <summary> /// Initializes a new instance of the <see cref="Database" /> class. /// </summary> /// <param name="dependencies">Parameter object containing dependencies for this service.</param> protected Database(DatabaseDependencies dependencies) { Dependencies = dependencies; }
public IndexedDbDatabase(DatabaseDependencies dependencies) : base(dependencies) { }
protected LocalDbDatabase(DatabaseDependencies dependencies) : base(dependencies) { }
public SimpleDatabase(DatabaseDependencies dependencies) : base(dependencies) { }
public RocksDbDatabase(DatabaseDependencies dependencies) : base(dependencies) { }