public SqlServerDatabase(
[NotNull] IModel model,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IEntityMaterializerSource entityMaterializerSource,
[NotNull] IClrAccessorSource <IClrPropertyGetter> clrPropertyGetterSource,
[NotNull] ISqlServerConnection connection,
[NotNull] ICommandBatchPreparer batchPreparer,
[NotNull] IBatchExecutor batchExecutor,
[NotNull] IDbContextOptions options,
[NotNull] ILoggerFactory loggerFactory,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
[NotNull] IMethodCallTranslator compositeMethodCallTranslator,
[NotNull] IMemberTranslator compositeMemberTranslator,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(
model,
entityKeyFactorySource,
entityMaterializerSource,
clrPropertyGetterSource,
connection,
batchPreparer,
batchExecutor,
options,
loggerFactory,
valueBufferFactoryFactory,
compositeMethodCallTranslator,
compositeMemberTranslator,
typeMapper,
relationalExtensions)
{
}
public SqlServerSender(ISqlServerConnection connection, ISqlServerCommand command)
{
_connection = connection;
_connection.Open();
_command = command;
}
public TestDatabaseCreator(
RelationalDatabaseCreatorDependencies dependencies,
ISqlServerConnection connection,
IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies, connection, rawSqlCommandBuilder)
{
}
/// <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 SqlServerCompiledQueryCacheKeyGenerator(
CompiledQueryCacheKeyGeneratorDependencies dependencies,
RelationalCompiledQueryCacheKeyGeneratorDependencies relationalDependencies,
ISqlServerConnection sqlServerConnection)
: base(dependencies, relationalDependencies)
{
_sqlServerConnection = sqlServerConnection;
}
public SqlServerDatabase(
[NotNull] DbContext context,
[NotNull] IRelationalDataStoreCreator dataStoreCreator,
[NotNull] ISqlServerConnection connection,
[NotNull] IMigrator migrator,
[NotNull] ILoggerFactory loggerFactory)
: base(context, dataStoreCreator, connection, migrator, loggerFactory)
{
}
public SqlServerSagaPersistance(ISqlServerConnection sqlServerConnection, IDateTimeProvider dateTimeProvider, SqlServerOptions sqlServerOptions)
{
this.instances = new Dictionary <Guid, string>();
this.sqlServerConnection = sqlServerConnection;
this.dateTimeProvider = dateTimeProvider;
this.sqlServerOptions = sqlServerOptions;
this.weakInMemorySagaPersistance = new WeakInMemorySagaPersistance(
TimeSpan.FromSeconds(15));
}
public TestDatabaseCreator(
ISqlServerConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
ISqlStatementExecutor statementExecutor,
IModel model)
: base(connection, modelDiffer, sqlGenerator, statementExecutor, model)
{
}
/// <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 SqlServerDatabaseCreator(
RelationalDatabaseCreatorDependencies dependencies,
ISqlServerConnection connection,
IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies)
{
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
/// <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 SqlServerQueryCompilationContextFactory(
QueryCompilationContextDependencies dependencies,
RelationalQueryCompilationContextDependencies relationalDependencies,
ISqlServerConnection sqlServerConnection)
{
Dependencies = dependencies;
RelationalDependencies = relationalDependencies;
_sqlServerConnection = sqlServerConnection;
}
public TestDatabaseCreator(
ISqlServerConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
IModel model,
IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(connection, modelDiffer, sqlGenerator, model, rawSqlCommandBuilder)
{
}
/// <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 ValueGenerator Create(IProperty property, SqlServerSequenceValueGeneratorState generatorState, ISqlServerConnection connection)
{
Check.NotNull(property, nameof(property));
Check.NotNull(generatorState, nameof(generatorState));
Check.NotNull(connection, nameof(connection));
var type = property.ClrType.UnwrapNullableType().UnwrapEnumType();
if (type == typeof(long))
{
return new SqlServerSequenceHiLoValueGenerator<long>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(int))
{
return new SqlServerSequenceHiLoValueGenerator<int>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(short))
{
return new SqlServerSequenceHiLoValueGenerator<short>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(byte))
{
return new SqlServerSequenceHiLoValueGenerator<byte>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(char))
{
return new SqlServerSequenceHiLoValueGenerator<char>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(ulong))
{
return new SqlServerSequenceHiLoValueGenerator<ulong>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(uint))
{
return new SqlServerSequenceHiLoValueGenerator<uint>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(ushort))
{
return new SqlServerSequenceHiLoValueGenerator<ushort>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
if (type == typeof(sbyte))
{
return new SqlServerSequenceHiLoValueGenerator<sbyte>(_rawSqlCommandBuilder, _sqlGenerator, generatorState, connection);
}
throw new ArgumentException(CoreStrings.InvalidValueGeneratorFactoryProperty(
nameof(SqlServerSequenceValueGeneratorFactory), property.Name, property.DeclaringEntityType.DisplayName()));
}
public SqlServerQueryContextFactory(
[NotNull] IStateManager stateManager,
[NotNull] IEntityKeyFactorySource entityKeyFactorySource,
[NotNull] IClrCollectionAccessorSource collectionAccessorSource,
[NotNull] IClrAccessorSource <IClrPropertySetter> propertySetterSource,
[NotNull] ISqlServerConnection connection,
[NotNull] ILoggerFactory loggerFactory)
: base(stateManager, entityKeyFactorySource, collectionAccessorSource, propertySetterSource, connection, loggerFactory)
{
}
/// <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 SqlServerCompiledQueryCacheKeyGenerator(
CompiledQueryCacheKeyGeneratorDependencies dependencies,
RelationalCompiledQueryCacheKeyGeneratorDependencies relationalDependencies,
ISqlServerConnection sqlServerConnection)
: base(dependencies, relationalDependencies)
{
Check.NotNull(sqlServerConnection, nameof(sqlServerConnection));
_sqlServerConnection = sqlServerConnection;
}
public TestDatabaseCreator(
ISqlServerConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
IMigrationCommandExecutor migrationCommandExecutor,
IModel model,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IExecutionStrategyFactory executionStrategyFactory)
: base(connection, modelDiffer, sqlGenerator, migrationCommandExecutor, model, rawSqlCommandBuilder, executionStrategyFactory)
{
}
public SqlServerDatabaseCreator(
[NotNull] ISqlServerConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlStatementExecutor statementExecutor,
[NotNull] IModel model)
: base(model, connection, modelDiffer, migrationsSqlGenerator, statementExecutor)
{
_connection = connection;
_migrationsSqlGenerator = migrationsSqlGenerator;
}
public SqlServerDatabaseCreator(
[NotNull] ISqlServerConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlStatementExecutor statementExecutor,
[NotNull] IModel model)
: base(model, connection, modelDiffer, migrationsSqlGenerator, statementExecutor)
{
_connection = connection;
_migrationsSqlGenerator = migrationsSqlGenerator;
}
/// <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 SqlServerValueGeneratorSelector(
[NotNull] ValueGeneratorSelectorDependencies dependencies,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection)
: base(dependencies)
{
Check.NotNull(sequenceFactory, nameof(sequenceFactory));
Check.NotNull(connection, nameof(connection));
_sequenceFactory = sequenceFactory;
_connection = connection;
}
public SqlServerValueGeneratorSelector(
[NotNull] ISqlServerValueGeneratorCache cache,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection)
: base(cache)
{
Check.NotNull(sequenceFactory, nameof(sequenceFactory));
Check.NotNull(connection, nameof(connection));
_sequenceFactory = sequenceFactory;
_connection = connection;
}
public SagaStore(ISqlServerConnection con, IDateTimeProvider dateTimeProvider, SqlServerOptions sqlServerOptions)
{
_con = con;
_dateTimeProvider = dateTimeProvider;
_sqlServerOptions = sqlServerOptions;
_serializerSettings = new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = TypeNameHandling.All,
DateFormatHandling = DateFormatHandling.IsoDateFormat
};
}
/// <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 SqlServerQueryCompilationContextFactory(
QueryCompilationContextDependencies dependencies,
RelationalQueryCompilationContextDependencies relationalDependencies,
ISqlServerConnection sqlServerConnection)
{
Check.NotNull(dependencies, nameof(dependencies));
Check.NotNull(relationalDependencies, nameof(relationalDependencies));
_dependencies = dependencies;
_relationalDependencies = relationalDependencies;
_sqlServerConnection = sqlServerConnection;
}
public SqlServerValueGeneratorSelector(
[NotNull] ISqlServerValueGeneratorCache cache,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection)
: base(cache)
{
Check.NotNull(sequenceFactory, nameof(sequenceFactory));
Check.NotNull(connection, nameof(connection));
_sequenceFactory = sequenceFactory;
_connection = connection;
}
public virtual ValueGenerator Create(
[NotNull] IProperty property,
[NotNull] SqlServerSequenceValueGeneratorState generatorState,
[NotNull] ISqlServerConnection connection)
{
Check.NotNull(property, nameof(property));
Check.NotNull(generatorState, nameof(generatorState));
Check.NotNull(connection, nameof(connection));
if (property.ClrType.UnwrapNullableType() == typeof(long))
{
return(new SqlServerSequenceValueGenerator <long>(_executor, generatorState, connection));
}
if (property.ClrType.UnwrapNullableType() == typeof(int))
{
return(new SqlServerSequenceValueGenerator <int>(_executor, generatorState, connection));
}
if (property.ClrType.UnwrapNullableType() == typeof(short))
{
return(new SqlServerSequenceValueGenerator <short>(_executor, generatorState, connection));
}
if (property.ClrType.UnwrapNullableType() == typeof(byte))
{
return(new SqlServerSequenceValueGenerator <byte>(_executor, generatorState, connection));
}
if (property.ClrType.UnwrapNullableType() == typeof(ulong))
{
return(new SqlServerSequenceValueGenerator <ulong>(_executor, generatorState, connection));
}
if (property.ClrType.UnwrapNullableType() == typeof(uint))
{
return(new SqlServerSequenceValueGenerator <uint>(_executor, generatorState, connection));
}
if (property.ClrType.UnwrapNullableType() == typeof(ushort))
{
return(new SqlServerSequenceValueGenerator <ushort>(_executor, generatorState, connection));
}
if (property.ClrType.UnwrapNullableType() == typeof(sbyte))
{
return(new SqlServerSequenceValueGenerator <sbyte>(_executor, generatorState, connection));
}
throw new ArgumentException(Internal.Strings.InvalidValueGeneratorFactoryProperty(
nameof(SqlServerSequenceValueGeneratorFactory), property.Name, property.EntityType.DisplayName()));
}
public SqlServerValueGeneratorSelector(
[NotNull] ISqlServerValueGeneratorCache cache,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection,
[NotNull] IRelationalMetadataExtensionProvider relationalExtensions)
: base(cache, relationalExtensions)
{
Check.NotNull(sequenceFactory, nameof(sequenceFactory));
Check.NotNull(connection, nameof(connection));
_sequenceFactory = sequenceFactory;
_connection = connection;
}
/// <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 SqlServerValueGeneratorSelector(
ValueGeneratorSelectorDependencies dependencies,
ISqlServerSequenceValueGeneratorFactory sequenceFactory,
ISqlServerConnection connection,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalCommandDiagnosticsLogger commandLogger)
: base(dependencies)
{
_sequenceFactory = sequenceFactory;
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_commandLogger = commandLogger;
}
public SqlServerValueGeneratorSelector(
[NotNull] ValueGeneratorSelectorDependencies dependencies,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
: base(dependencies)
{
_sequenceFactory = sequenceFactory;
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_commandLogger = commandLogger;
}
public SqlServerValueGeneratorSelector(
[NotNull] ISqlServerValueGeneratorCache cache,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection,
[NotNull] IRelationalAnnotationProvider relationalExtensions)
: base(cache, relationalExtensions)
{
Check.NotNull(sequenceFactory, nameof(sequenceFactory));
Check.NotNull(connection, nameof(connection));
_sequenceFactory = sequenceFactory;
_connection = connection;
}
/// <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 SqlServerSequenceHiLoValueGenerator(
IRawSqlCommandBuilder rawSqlCommandBuilder,
ISqlServerUpdateSqlGenerator sqlGenerator,
SqlServerSequenceValueGeneratorState generatorState,
ISqlServerConnection connection,
IRelationalCommandDiagnosticsLogger commandLogger)
: base(generatorState)
{
_sequence = generatorState.Sequence;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_sqlGenerator = sqlGenerator;
_connection = connection;
_commandLogger = commandLogger;
}
public SqlServerDatabaseCreator(
[NotNull] ISqlServerConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IModel model,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(model, connection, modelDiffer, migrationsSqlGenerator)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
_connection = connection;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
public SqlServerSequenceValueGenerator(
[NotNull] SqlStatementExecutor executor,
[NotNull] SqlServerSequenceValueGeneratorState generatorState,
[NotNull] ISqlServerConnection connection)
: base(generatorState)
{
Check.NotNull(executor, nameof(executor));
Check.NotNull(generatorState, nameof(generatorState));
Check.NotNull(connection, nameof(connection));
_sequenceName = generatorState.SequenceName;
_executor = executor;
_connection = connection;
}
/// <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 SqlServerSequenceHiLoValueGenerator(
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] ISqlServerUpdateSqlGenerator sqlGenerator,
[NotNull] SqlServerSequenceValueGeneratorState generatorState,
[NotNull] ISqlServerConnection connection,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
: base(generatorState)
{
_sequence = generatorState.Sequence;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_sqlGenerator = sqlGenerator;
_connection = connection;
_commandLogger = commandLogger;
}
public SqlServerDatabaseCreator(
[NotNull] ISqlServerConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IModel model,
[NotNull] ISqlCommandBuilder sqlCommandBuilder)
: base(model, connection, modelDiffer, migrationsSqlGenerator)
{
Check.NotNull(sqlCommandBuilder, nameof(sqlCommandBuilder));
_connection = connection;
_migrationsSqlGenerator = migrationsSqlGenerator;
_sqlCommandBuilder = sqlCommandBuilder;
}
/// <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 SqlServerValueGeneratorSelector(
[NotNull] ValueGeneratorSelectorDependencies dependencies,
[NotNull] ISqlServerSequenceValueGeneratorFactory sequenceFactory,
[NotNull] ISqlServerConnection connection,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies)
{
Check.NotNull(sequenceFactory, nameof(sequenceFactory));
Check.NotNull(connection, nameof(connection));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
_sequenceFactory = sequenceFactory;
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
public SqlServerHistoryRepository(
[NotNull] ISqlServerConnection connection,
[NotNull] IRelationalDataStoreCreator creator,
[NotNull] DbContext context,
[NotNull] ISqlServerSqlGenerator sqlGenerator)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(creator, nameof(creator));
Check.NotNull(context, nameof(context));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_connection = connection;
_creator = creator;
_contextType = context.GetType();
_sql = sqlGenerator;
}
public SqlServerHistoryRepository(
[NotNull] ISqlServerConnection connection,
[NotNull] ISqlServerDataStoreCreator creator,
[NotNull] DbContext context,
[NotNull] ISqlServerSqlGenerator sqlGenerator)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(creator, nameof(creator));
Check.NotNull(context, nameof(context));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_connection = connection;
_creator = creator;
_contextType = context.GetType();
_sql = sqlGenerator;
}
public SqlServerDataStoreCreator(
[NotNull] ISqlServerConnection connection,
[NotNull] ISqlServerModelDiffer modelDiffer,
[NotNull] ISqlServerMigrationSqlGenerator sqlGenerator,
[NotNull] SqlStatementExecutor statementExecutor)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(statementExecutor, nameof(statementExecutor));
_connection = connection;
_modelDiffer = modelDiffer;
_sqlGenerator = sqlGenerator;
_statementExecutor = statementExecutor;
}
public SqlServerDataStoreCreator(
[NotNull] ISqlServerConnection connection,
[NotNull] IModelDiffer modelDiffer,
[NotNull] IMigrationSqlGenerator sqlGenerator,
[NotNull] ISqlStatementExecutor statementExecutor)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(statementExecutor, nameof(statementExecutor));
_connection = connection;
_modelDiffer = modelDiffer;
_sqlGenerator = sqlGenerator;
_statementExecutor = statementExecutor;
}
/// <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 SqlServerSequenceHiLoValueGenerator(
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] ISqlServerUpdateSqlGenerator sqlGenerator,
[NotNull] SqlServerSequenceValueGeneratorState generatorState,
[NotNull] ISqlServerConnection connection)
: base(generatorState)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(connection, nameof(connection));
_sequence = generatorState.Sequence;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_sqlGenerator = sqlGenerator;
_connection = connection;
}
public SqlServerDatabaseFactory(
[NotNull] DbContext context,
[NotNull] ISqlServerDataStoreCreator dataStoreCreator,
[NotNull] ISqlServerConnection connection,
[NotNull] Migrator migrator,
[NotNull] ILoggerFactory loggerFactory)
{
Check.NotNull(context, nameof(context));
Check.NotNull(dataStoreCreator, nameof(dataStoreCreator));
Check.NotNull(connection, nameof(connection));
Check.NotNull(migrator, nameof(migrator));
Check.NotNull(loggerFactory, nameof(loggerFactory));
_context = context;
_dataStoreCreator = dataStoreCreator;
_connection = connection;
_migrator = migrator;
_loggerFactory = loggerFactory;
}
public TestDatabaseCreator(
ISqlServerConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
ISqlStatementExecutor statementExecutor,
IModel model)
: base(connection, modelDiffer, sqlGenerator, statementExecutor, model)
{
}
public TestDatabaseCreator(
ISqlServerConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
IModel model,
IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(connection, modelDiffer, sqlGenerator, model, rawSqlCommandBuilder)
{
}