public IReadOnlyList <HistoryRow> GetAppliedMigrations(MyCatRelationalConnection connection)
{
var rows = new List <HistoryRow>();
if (Exists(connection))
{
var command = _rawSqlCommandBuilder.Build(GetAppliedMigrationsSql);
using (var reader = command.ExecuteReader(connection))
{
while (reader.DbDataReader.Read())
{
rows.Add(new HistoryRow(reader.DbDataReader.GetString(0), reader.DbDataReader.GetString(1)));
}
}
}
return(rows);
}
public virtual void CommitSchema(MyCatRelationalConnection _connection)
{
var csb = new MyCatConnectionStringBuilder(_connection.ConnectionString);
using (var client = new HttpClient()
{
BaseAddress = new Uri("http://" + csb.Server + ":7066")
})
{
var task = client.PostAsync("/", new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("Username", csb.UserID),
new KeyValuePair <string, string>("Password", csb.Password),
new KeyValuePair <string, string>("Database", csb.Database),
new KeyValuePair <string, string>("DataNodes", Newtonsoft.Json.JsonConvert.SerializeObject(DbContextOptions.FindExtension <MyCatOptionsExtension>().DataNodes)),
new KeyValuePair <string, string>("Schema", Newtonsoft.Json.JsonConvert.SerializeObject(Schema)),
}));
task.Wait();
}
}
public async Task <IReadOnlyList <HistoryRow> > GetAppliedMigrationsAsync(
MyCatRelationalConnection connection,
CancellationToken cancellationToken = default(CancellationToken))
{
var rows = new List <HistoryRow>();
if (await ExistsAsync(connection, cancellationToken))
{
var command = _rawSqlCommandBuilder.Build(GetAppliedMigrationsSql);
using (var reader = await command.ExecuteReaderAsync(connection, cancellationToken: cancellationToken))
{
while (await reader.DbDataReader.ReadAsync(cancellationToken))
{
rows.Add(new HistoryRow(reader.DbDataReader.GetString(0), reader.DbDataReader.GetString(1)));
}
}
}
return(rows);
}
/// <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 MyCatMigrator(
[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,
[NotNull] IDbContextOptions options,
[NotNull] MyCatSchemaGenerator schemaCreator)
: base(migrationsAssembly, historyRepository, databaseCreator, migrationsSqlGenerator, rawSqlCommandBuilder, migrationCommandExecutor, connection, sqlGenerationHelper, logger, 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 = (MyCatHistoryRepository)historyRepository;
_databaseCreator = (MyCatDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = migrationCommandExecutor;
_connection = (MyCatRelationalConnection)connection;
_sqlGenerationHelper = sqlGenerationHelper;
_logger = logger;
_activeProvider = providerServices.InvariantName;
_options = options;
_schemaCreator = schemaCreator;
}
public MyCatHistoryRepository(
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IRawSqlCommandBuilder sqlCommandBuilder,
[NotNull] MyCatRelationalConnection connection,
[NotNull] IDbContextOptions options,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] MyCatMigrationsSqlGenerationHelper migrationsSqlGenerationHelper,
[NotNull] MyCatAnnotationProvider annotations,
[NotNull] ISqlGenerationHelper SqlGenerationHelper)
: base(
databaseCreator,
sqlCommandBuilder,
connection,
options,
modelDiffer,
migrationsSqlGenerationHelper,
annotations,
SqlGenerationHelper)
{
_connection = connection;
_databaseCreator = (MyCatDatabaseCreator)databaseCreator;
_rawSqlCommandBuilder = sqlCommandBuilder;
}
public async Task <bool> ExistsAsync(MyCatRelationalConnection conn, CancellationToken cancellationToken = default(CancellationToken))
{
return(await _databaseCreator.ExistsAsync(conn, cancellationToken) &&
InterpretExistsResult(
await _rawSqlCommandBuilder.Build(ExistsSql).ExecuteScalarAsync(conn, cancellationToken: cancellationToken)));
}
public bool Exists(MyCatRelationalConnection conn)
{
return(_databaseCreator.Exists(conn) &&
InterpretExistsResult(
_rawSqlCommandBuilder.Build(ExistsSql).ExecuteScalar(conn)));
}
