public TestDatabaseCreator(
RelationalDatabaseCreatorDependencies dependencies,
JetRelationalConnection relationalConnection,
IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies, relationalConnection, rawSqlCommandBuilder)
{
}
public OracleRelationalConnection(
[NotNull] RelationalConnectionDependencies dependencies,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies)
{
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
public RelationalCommandRunnerTestsBase(string providerName)
{
_model = new Model();
AddEntity <TestEntity>(_model);
AddEntity <TestEntityWithNullableKey>(_model);
var dbProvider = Substitute.For <IDatabaseProvider>();
dbProvider.Name.Returns(providerName);
var services = new ServiceCollection();
services.AddSingleton <IUpsertCommandRunner, TRunner>();
services.AddSingleton <IModel>(_model);
services.AddSingleton(dbProvider);
services.AddSingleton(Substitute.For <IRelationalTypeMappingSource>());
var serviceProvider = services.BuildServiceProvider();
_dbContext = Substitute.For <DbContext, IInfrastructure <IServiceProvider> >();
((IInfrastructure <IServiceProvider>)_dbContext).Instance.Returns(serviceProvider);
var relationalConnection = Substitute.For <IRelationalConnection>();
relationalConnection.DbConnection.Returns(Substitute.For <DbConnection>());
_rawSqlBuilder = Substitute.For <IRawSqlCommandBuilder>();
_rawSqlBuilder.Build(default, default).ReturnsForAnyArgs(
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="HistoryRepository" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// <para>
/// 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.
/// </para>
/// </summary>
/// <param name="databaseCreator"> The database creator. </param>
/// <param name="rawSqlCommandBuilder"> A command builder for building raw SQL commands. </param>
/// <param name="connection"> The connection to the database. </param>
/// <param name="options"> Options for the current context instance. </param>
/// <param name="modelDiffer"> The model differ. </param>
/// <param name="migrationsSqlGenerator"> The SQL generator for Migrations operations. </param>
/// <param name="sqlGenerationHelper"> Helpers for generating update SQL. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="typeMappingSource"> The type mapper. </param>
/// <param name="modelLogger"> The logger for model building events. </param>
public HistoryRepositoryDependencies(
[NotNull] IRelationalDatabaseCreator databaseCreator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] IConventionSetBuilder conventionSetBuilder,
[NotNull] IRelationalTypeMappingSource typeMappingSource,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Model> modelLogger)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(conventionSetBuilder, nameof(conventionSetBuilder));
Check.NotNull(typeMappingSource, nameof(typeMappingSource));
Check.NotNull(modelLogger, nameof(modelLogger));
DatabaseCreator = databaseCreator;
RawSqlCommandBuilder = rawSqlCommandBuilder;
Connection = connection;
Options = options;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerationHelper = sqlGenerationHelper;
ConventionSetBuilder = conventionSetBuilder;
TypeMappingSource = typeMappingSource;
ModelLogger = modelLogger;
}
/// <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 Migrator(
[NotNull] IMigrationsAssembly migrationsAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IRelationalConnection connection,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] IInterceptingLogger <LoggerCategory.Migrations> logger,
[NotNull] IDatabaseProvider databaseProvider)
{
Check.NotNull(migrationsAssembly, nameof(migrationsAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(migrationCommandExecutor, nameof(migrationCommandExecutor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(logger, nameof(logger));
Check.NotNull(databaseProvider, nameof(databaseProvider));
_migrationsAssembly = migrationsAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = migrationCommandExecutor;
_connection = connection;
_sqlGenerationHelper = sqlGenerationHelper;
_logger = logger;
_activeProvider = databaseProvider.InvariantName;
}
/// <summary>
/// Initializes a new instance of the <see cref="PluginMigrator"/> class.
/// </summary>
/// <param name="migrationsSqlGenerator">The migrations SQL generator.</param>
/// <param name="migrationsAssembly">The migrations assembly.</param>
/// <param name="pluginHistoryRepository">The plugin history repository.</param>
/// <param name="rawSqlCommandBuilder">The raw SQL command builder.</param>
/// <param name="migrationCommandExecutor">The migration command executor.</param>
/// <param name="connection">The connection.</param>
/// <param name="sqlGenerationHelper">The SQL generation helper.</param>
/// <param name="currentContext">The current context.</param>
/// <param name="logger">The logger.</param>
/// <param name="commandLogger">The command logger.</param>
/// <param name="databaseProvider">The database provider.</param>
public PluginMigrator(
IMigrationsSqlGenerator migrationsSqlGenerator,
IMigrationsAssembly migrationsAssembly,
IPluginHistoryRepository pluginHistoryRepository,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IMigrationCommandExecutor migrationCommandExecutor,
IRelationalConnection connection,
ISqlGenerationHelper sqlGenerationHelper,
ICurrentDbContext currentContext,
ILoggerFactory loggerFactory,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger,
IDatabaseProvider databaseProvider)
{
MigrationsSqlGenerator = migrationsSqlGenerator;
MigrationsAssembly = migrationsAssembly;
PluginHistoryRepository = pluginHistoryRepository;
RawSqlCommandBuilder = rawSqlCommandBuilder;
MigrationCommandExecutor = migrationCommandExecutor;
Connection = connection;
SqlGenerationHelper = sqlGenerationHelper;
CurrentContext = currentContext;
Logger = loggerFactory.CreateLogger("BlueBoxMoon.Data.EntityFramework.Migrations.PluginMigrator");
CommandLogger = commandLogger;
DatabaseProvider = databaseProvider;
}
public MySqlMigrator(
[NotNull] IMigrationsAssembly migrationsAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IRelationalConnection connection,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] ICurrentDbContext currentContext,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Migrations> logger,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger,
[NotNull] IDatabaseProvider databaseProvider)
: base(
migrationsAssembly,
historyRepository,
databaseCreator,
migrationsSqlGenerator,
rawSqlCommandBuilder,
migrationCommandExecutor,
connection,
sqlGenerationHelper,
currentContext,
logger,
commandLogger,
databaseProvider)
{
_migrationsAssembly = migrationsAssembly;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_currentContext = currentContext;
_commandLogger = commandLogger;
}
private static void ExecuteScript(IRelationalConnection connection, IRawSqlCommandBuilder sqlBuilder, string customSql)
{
var batches = Regex.Split(
Regex.Replace(
customSql,
@"\\\r?\n",
string.Empty,
/// <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 SqliteRelationalConnection(
[NotNull] RelationalConnectionDependencies dependencies,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
_rawSqlCommandBuilder = rawSqlCommandBuilder;
var optionsExtension = dependencies.ContextOptions.Extensions.OfType <SqliteOptionsExtension>().FirstOrDefault();
if (optionsExtension != null)
{
_loadSpatialite = optionsExtension.LoadSpatialite;
if (_loadSpatialite)
{
var relationalOptions = RelationalOptionsExtension.Extract(dependencies.ContextOptions);
if (relationalOptions.Connection != null)
{
// TODO: Provide a better hook to do this for both external connections and ones created by EF
SpatialiteLoader.Load((SqliteConnection)relationalOptions.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 Migrator(
IMigrationsAssembly migrationsAssembly,
IHistoryRepository historyRepository,
IDatabaseCreator databaseCreator,
IMigrationsSqlGenerator migrationsSqlGenerator,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IMigrationCommandExecutor migrationCommandExecutor,
IRelationalConnection connection,
ISqlGenerationHelper sqlGenerationHelper,
ICurrentDbContext currentContext,
IModelRuntimeInitializer modelRuntimeInitializer,
IDiagnosticsLogger <DbLoggerCategory.Migrations> logger,
IRelationalCommandDiagnosticsLogger commandLogger,
IDatabaseProvider databaseProvider)
{
_migrationsAssembly = migrationsAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = migrationCommandExecutor;
_connection = connection;
_sqlGenerationHelper = sqlGenerationHelper;
_currentContext = currentContext;
_modelRuntimeInitializer = modelRuntimeInitializer;
_logger = logger;
_commandLogger = commandLogger;
_activeProvider = databaseProvider.Name;
}
public Migrator(
[NotNull] IMigrationsAssembly migrationsAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] ILogger <Migrator> logger,
[NotNull] IDatabaseProviderServices providerServices)
{
Check.NotNull(migrationsAssembly, nameof(migrationsAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(logger, nameof(logger));
Check.NotNull(providerServices, nameof(providerServices));
_migrationsAssembly = migrationsAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_connection = connection;
_sqlGenerationHelper = sqlGenerationHelper;
_logger = logger;
_activeProvider = providerServices.InvariantName;
}
public TestDatabaseCreator(
RelationalDatabaseCreatorDependencies dependencies,
INpgsqlRelationalConnection 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 SqliteRelationalConnection(
[NotNull] RelationalConnectionDependencies dependencies,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Infrastructure> logger)
: base(dependencies)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_logger = logger;
var optionsExtension = dependencies.ContextOptions.Extensions.OfType <SqliteOptionsExtension>().FirstOrDefault();
if (optionsExtension != null)
{
_loadSpatialite = optionsExtension.LoadSpatialite;
var relationalOptions = RelationalOptionsExtension.Extract(dependencies.ContextOptions);
_commandTimeout = relationalOptions.CommandTimeout;
if (relationalOptions.Connection != null)
{
InitializeDbConnection(relationalOptions.Connection);
}
}
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="HistoryRepository" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// <para>
/// 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.
/// </para>
/// </summary>
/// <param name="databaseCreator"> The database creator. </param>
/// <param name="rawSqlCommandBuilder"> A command builder for building raw SQL commands. </param>
/// <param name="connection"> The connection to the database. </param>
/// <param name="options"> Options for the current context instance. </param>
/// <param name="modelDiffer"> The model differ. </param>
/// <param name="migrationsSqlGenerator"> The SQL generator for Migrations operations. </param>
/// <param name="sqlGenerationHelper"> Helpers for generating update SQL. </param>
/// <param name="coreConventionSetBuilder"> The core convention set to use when creating the model. </param>
/// <param name="conventionSetBuilders"> The convention sets to use when creating the model. </param>
public HistoryRepositoryDependencies(
[NotNull] IRelationalDatabaseCreator databaseCreator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] ICoreConventionSetBuilder coreConventionSetBuilder,
[NotNull] IEnumerable <IConventionSetBuilder> conventionSetBuilders)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(coreConventionSetBuilder, nameof(coreConventionSetBuilder));
Check.NotNull(conventionSetBuilders, nameof(conventionSetBuilders));
DatabaseCreator = databaseCreator;
RawSqlCommandBuilder = rawSqlCommandBuilder;
Connection = connection;
Options = options;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerationHelper = sqlGenerationHelper;
CoreConventionSetBuilder = coreConventionSetBuilder;
ConventionSetBuilder = new CompositeConventionSetBuilder((IReadOnlyList <IConventionSetBuilder>)conventionSetBuilders);
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="HistoryRepository" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// <para>
/// 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.
/// </para>
/// </summary>
/// <param name="databaseCreator"> The database creator. </param>
/// <param name="rawSqlCommandBuilder"> A command builder for building raw SQL commands. </param>
/// <param name="connection"> The connection to the database. </param>
/// <param name="options"> Options for the current context instance. </param>
/// <param name="modelDiffer"> The model differ. </param>
/// <param name="migrationsSqlGenerator"> The SQL generator for Migrations operations. </param>
/// <param name="sqlGenerationHelper"> Helpers for generating update SQL. </param>
public HistoryRepositoryDependencies(
[NotNull] IRelationalDatabaseCreator databaseCreator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlGenerationHelper sqlGenerationHelper)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
DatabaseCreator = databaseCreator;
RawSqlCommandBuilder = rawSqlCommandBuilder;
Connection = connection;
Options = options;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerationHelper = sqlGenerationHelper;
}
/// <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 Migrator(
[NotNull] IMigrationsAssembly migrationsAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IRelationalConnection connection,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] ILogger<Migrator> logger,
[NotNull] IDatabaseProviderServices providerServices)
{
Check.NotNull(migrationsAssembly, nameof(migrationsAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(migrationCommandExecutor, nameof(migrationCommandExecutor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(logger, nameof(logger));
Check.NotNull(providerServices, nameof(providerServices));
_migrationsAssembly = migrationsAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = migrationCommandExecutor;
_connection = connection;
_sqlGenerationHelper = sqlGenerationHelper;
_logger = logger;
_activeProvider = providerServices.InvariantName;
}
public ClickHouseDatabaseCreator(
RelationalDatabaseCreatorDependencies dependencies,
IClickHouseRelationalConnection connection,
IRawSqlCommandBuilder rawSqlCommandBuilder) : base(dependencies)
{
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
public AS400SequenceValueGeneratorFactory(
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IAS400UpdateSqlGenerator sqlGenerator)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_sqlGenerator = sqlGenerator;
}
/// <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 FbDatabaseCreator(
[NotNull] RelationalDatabaseCreatorDependencies dependencies,
[NotNull] IFirebirdRelationalConnection connection,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies)
{
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
public TestDatabaseCreator(
ISqlServerConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
IModel model,
IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(connection, modelDiffer, sqlGenerator, model, rawSqlCommandBuilder)
{
}
/// <summary>
/// Clones this dependency parameter object with one service replaced.
/// </summary>
/// <param name="rawSqlCommandBuilder"> A replacement for the current dependency of this type. </param>
/// <returns> A new parameter object with the given service replaced. </returns>
public HistoryRepositoryDependencies With([NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
=> new HistoryRepositoryDependencies(
DatabaseCreator,
rawSqlCommandBuilder,
Connection,
Options,
ModelDiffer,
MigrationsSqlGenerator,
SqlGenerationHelper);
/// <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 MySqlDatabaseCreator(
[NotNull] RelationalDatabaseCreatorDependencies dependencies,
[NotNull] IMySqlRelationalConnection relationalConnection,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies)
{
_relationalConnection = relationalConnection;
_rawSqlCommandBuilder = 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,
NpgsqlSequenceValueGeneratorState generatorState,
INpgsqlRelationalConnection connection,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalCommandDiagnosticsLogger commandLogger)
{
var type = property.ClrType.UnwrapNullableType().UnwrapEnumType();
if (type == typeof(long))
{
return(new NpgsqlSequenceHiLoValueGenerator <long>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(int))
{
return(new NpgsqlSequenceHiLoValueGenerator <int>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(short))
{
return(new NpgsqlSequenceHiLoValueGenerator <short>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(byte))
{
return(new NpgsqlSequenceHiLoValueGenerator <byte>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(char))
{
return(new NpgsqlSequenceHiLoValueGenerator <char>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(ulong))
{
return(new NpgsqlSequenceHiLoValueGenerator <ulong>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(uint))
{
return(new NpgsqlSequenceHiLoValueGenerator <uint>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(ushort))
{
return(new NpgsqlSequenceHiLoValueGenerator <ushort>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
if (type == typeof(sbyte))
{
return(new NpgsqlSequenceHiLoValueGenerator <sbyte>(rawSqlCommandBuilder, _sqlGenerator, generatorState, connection, commandLogger));
}
throw new ArgumentException(CoreStrings.InvalidValueGeneratorFactoryProperty(
nameof(NpgsqlSequenceValueGeneratorFactory), property.Name, property.DeclaringEntityType.DisplayName()));
}
/// <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;
}
public MySQLDatabaseCreator(
[NotNull] RelationalDatabaseCreatorDependencies dependencies,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(dependencies)
{
_connection = (MySQLServerConnection)dependencies.Connection;
_sqlGenerator = dependencies.MigrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = dependencies.MigrationCommandExecutor;
}
/// <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 SqlServerSequenceValueGeneratorFactory(
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] ISqlServerUpdateSqlGenerator sqlGenerator)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_sqlGenerator = sqlGenerator;
}
public TestDatabaseCreator(
NpgsqlRelationalConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
IMigrationCommandExecutor migrationCommandExecutor,
IModel model,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IExecutionStrategyFactory executionStrategyFactory)
: base(connection, modelDiffer, sqlGenerator, migrationCommandExecutor, model, rawSqlCommandBuilder, executionStrategyFactory)
{
}
public IgnoreForeignKeyMySqlMigrator(IMigrationsAssembly migrationsAssembly,
IHistoryRepository historyRepository,
IDatabaseCreator databaseCreator, IMigrationsSqlGenerator migrationsSqlGenerator,
IRawSqlCommandBuilder rawSqlCommandBuilder, IMigrationCommandExecutor migrationCommandExecutor,
IRelationalConnection connection, ISqlGenerationHelper sqlGenerationHelper,
ICurrentDbContext currentContext, IDiagnosticsLogger <DbLoggerCategory.Migrations> logger,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger, IDatabaseProvider databaseProvider) :
base(migrationsAssembly, historyRepository, databaseCreator, migrationsSqlGenerator, rawSqlCommandBuilder,
migrationCommandExecutor, connection, sqlGenerationHelper, currentContext, logger, commandLogger,
databaseProvider)
{
}
/// <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 AseValueGeneratorSelector(
ValueGeneratorSelectorDependencies dependencies,
IAseSequenceValueGeneratorFactory sequenceFactory,
IAseConnection connection,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> 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 SqliteDatabaseCreator(
[NotNull] SqliteRelationalConnection 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;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
public SqliteDatabaseCreator(
[NotNull] SqliteRelationalConnection 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;
_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 SqlServerValueGeneratorSelector(
ValueGeneratorSelectorDependencies dependencies,
ISqlServerSequenceValueGeneratorFactory sequenceFactory,
ISqlServerConnection connection,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalCommandDiagnosticsLogger commandLogger)
: base(dependencies)
{
_sequenceFactory = sequenceFactory;
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_commandLogger = commandLogger;
}
/// <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 SqlServerDatabaseCreator(
[NotNull] ISqlServerConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IModel model,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(model, connection, modelDiffer, migrationsSqlGenerator, migrationCommandExecutor)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
_connection = connection;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
protected HistoryRepository(
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IRelationalAnnotationProvider annotations,
[NotNull] ISqlGenerationHelper sqlGenerationHelper)
{
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(annotations, nameof(annotations));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_connection = connection;
_modelDiffer = modelDiffer;
_migrationsSqlGenerator = migrationsSqlGenerator;
SqlGenerationHelper = sqlGenerationHelper;
var relationalOptions = RelationalOptionsExtension.Extract(options);
TableName = relationalOptions?.MigrationsHistoryTableName ?? DefaultTableName;
TableSchema = relationalOptions.MigrationsHistoryTableSchema;
_model = new LazyRef<IModel>(
() =>
{
var modelBuilder = new ModelBuilder(new ConventionSet());
modelBuilder.Entity<HistoryRow>(
x =>
{
ConfigureTable(x);
x.ToTable(TableName, TableSchema);
});
return modelBuilder.Model;
});
var entityType = new LazyRef<IEntityType>(() => _model.Value.FindEntityType(typeof(HistoryRow)));
_migrationIdColumnName = new LazyRef<string>(
() => annotations.For(entityType.Value.FindProperty(nameof(HistoryRow.MigrationId))).ColumnName);
_productVersionColumnName = new LazyRef<string>(
() => annotations.For(entityType.Value.FindProperty(nameof(HistoryRow.ProductVersion))).ColumnName);
}
/// <summary>
/// Creates a new instance of <see cref="DataMigrator"/>.
/// </summary>
public DataMigrator(
IHistoryRepository historyRepository,
IDatabaseCreator databaseCreator,
IMigrationsSqlGenerator migrationsSqlGenerator,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalConnection connection,
ILoggerFactory loggerFactory,
IServiceProvider serviceProvider)
{
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_connection = connection;
_serviceProvider = serviceProvider;
_logger = loggerFactory.CreateLogger<DataMigrator>();
}
public SqliteRelationalConnection(
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IDbContextOptions options,
// ReSharper disable once SuggestBaseTypeForParameter
[NotNull] ILogger<SqliteRelationalConnection> logger)
: base(options, logger)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
_rawSqlCommandBuilder = rawSqlCommandBuilder;
var optionsExtension = options.Extensions.OfType<SqliteOptionsExtension>().FirstOrDefault();
if (optionsExtension != null)
{
_enforceForeignKeys = optionsExtension.EnforceForeignKeys;
}
}
public MyHistoryRepository(
IDatabaseCreator databaseCreator,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IRelationalConnection connection,
IDbContextOptions options,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator migrationsSqlGenerator,
IRelationalAnnotationProvider annotations,
ISqlGenerationHelper sqlGenerationHelper)
: base(databaseCreator,
rawSqlCommandBuilder,
connection,
options,
modelDiffer,
migrationsSqlGenerator,
annotations,
sqlGenerationHelper
)
{
}
public TestDatabaseCreator(
ISqlServerConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
IModel model,
IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(connection, modelDiffer, sqlGenerator, model, rawSqlCommandBuilder)
{
}
