/// <summary>
/// Run the given list of migrations
/// </summary>
/// <param name="migrations">Migrations to run, must be sorted</param>
/// <param name="direction">Direction of mgirations</param>
protected virtual void RunMigrations(IEnumerable <MigrationData> migrations, MigrationDirection direction)
{
// Migrations must be sorted
// this.CurrentMigration is updated by MigrateStep
var originalMigration = this.CurrentMigration;
var oldMigration = this.CurrentMigration;
this.NotNullLogger.BeginSequence(originalMigration, migrations.Last());
try
{
foreach (var newMigration in migrations)
{
this.MigrateStep(oldMigration, newMigration, direction);
oldMigration = newMigration;
}
this.NotNullLogger.EndSequence(originalMigration, this.CurrentMigration);
}
catch (Exception e)
{
this.NotNullLogger.EndSequenceWithError(e, originalMigration, this.CurrentMigration);
throw;
}
}
private static void ApplyMigrations(NpgsqlConnection connection, MigrationDirection direction)
{
foreach (var(_, name) in MigrationManager.EnumerateMigrations(direction, Config.Value.MigrationsPath))
{
connection.Execute(File.ReadAllText(name));
}
}
internal void Execute(IDbConnection connection, IDbTransaction transaction, MigrationDirection direction, IDbCommandExecutor commandExecutor)
{
Debug.Assert(connection.State == ConnectionState.Open);
var context = new RuntimeContext(connection, transaction, commandExecutor, _providerMetadata);
Database database = GetDatabaseContainingMigrationChanges(direction, context);
var translator = new CommandsToSqlTranslator(_provider);
foreach (string commandText in translator.TranslateToSql(database, context))
{
IDbCommand command = connection.CreateCommand();
command.CommandTimeout = 0; // do not timeout; the client is responsible for not causing lock-outs
command.Transaction = transaction;
command.CommandText = commandText;
try
{
commandExecutor.ExecuteNonQuery(command);
}
catch (DbException x)
{
Log.Error("An error occurred: {0}{1}while trying to execute:{1}{2}", x.Message, Environment.NewLine, command.CommandText);
throw;
}
}
}
internal void Execute(IDbConnection connection, IDbTransaction transaction, MigrationDirection direction, IDbCommandExecutor commandExecutor)
{
Debug.Assert(connection.State == ConnectionState.Open);
var context = new RuntimeContext(connection, transaction, commandExecutor, _providerMetadata);
Database database = GetDatabaseContainingMigrationChanges(direction, context);
var translator = new CommandsToSqlTranslator(_provider);
foreach (string commandText in translator.TranslateToSql(database, context))
{
//MigSharp uses ADO, not SMO to run SQL. ADO does not support the 'GO' statement in SQL as it is not TSQL.
//We split SQL on 'GO' and run as individual statements
var separatedByGoStatements = new List<string>(goStatementRegex.Split(commandText));
separatedByGoStatements.RemoveAll(r => String.IsNullOrEmpty(r.Trim()));
foreach (var statement in separatedByGoStatements)
{
IDbCommand command = connection.CreateCommand();
command.CommandTimeout = 0; // do not timeout; the client is responsible for not causing lock-outs
command.Transaction = transaction;
command.CommandText = statement;
try
{
commandExecutor.ExecuteNonQuery(command);
}
catch (DbException x)
{
Log.Error("An error occurred: {0}{1}while trying to execute:{1}{2}", x.Message, Environment.NewLine, command.CommandText);
throw;
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AfterMigrationEventArgs"/> class.
/// </summary>
/// <param name="version">The version.</param>
/// <param name="migration">The migration.</param>
/// <param name="direction">The direction.</param>
/// <param name="success">if set to <c>true</c> the migration succeeded.</param>
public AfterMigrationEventArgs(long version, IMigration migration, MigrationDirection direction, bool success)
{
Version = version;
Migration = migration;
Direction = direction;
Success = success;
}
public void GroupAndExecuteMigrations(List <RecognizedMigrationFile> recognizedTypes,
string connectionString, MigrationDirection direction = MigrationDirection.Up)
{
try
{
var isAttachedDbFile = this.IsAttachDbFilename(connectionString);
this.dbService.CreateConnection(connectionString, this.providerName);
this.dbService.Open();
var groups = this.Group(recognizedTypes);
foreach (var group in groups)
{
var last = this.GetLast(group.Value);
this.RunMigration(last, direction);
var queries = this.GetMigrationQueriesWithSemicolonDelimiter(isAttachedDbFile);
this.ExecuteQueries(queries);
schema.ClearMigrations();
}
}
catch (Exception e)
{
throw e;
}
finally
{
this.dbService.Close();
schema.ClearMigrations();
}
}
public ExecuteEmbeddedAutoSqlScriptExpression([NotNull] IEmbeddedResourceProvider embeddedResourceProvider, Type migrationType, IList <string> databaseNames, MigrationDirection direction)
{
_embeddedResourceProvider = embeddedResourceProvider;
MigrationType = migrationType;
DatabaseNames = databaseNames;
Direction = direction;
}
// ReSharper disable once UnusedMember.Local
public ExecuteEmbeddedAutoSqlScriptExpression(IAssemblyCollection assemblyCollection, Type migrationType, IList <string> databaseNames, MigrationDirection direction)
{
_embeddedResourceProvider = new DefaultEmbeddedResourceProvider(assemblyCollection);
MigrationType = migrationType;
DatabaseNames = databaseNames;
Direction = direction;
}
/// <summary>
/// Instantiate and execute a single migration
/// </summary>
/// <param name="direction">Diretion to run the migration in</param>
/// <param name="migrationData"><see cref="MigrationData"/> describing to migration to instantiate and execute</param>
/// <param name="connection">Connection to use to execute the migration</param>
protected virtual void RunMigration(MigrationDirection direction, MigrationData migrationData, TConnection connection)
{
var migration = this.CreateMigration(migrationData);
var data = new MigrationRunData <TConnection>(connection, this.Logger ?? NullLogger.Instance, direction);
migration.RunMigration(data);
}
/// <summary>
/// Initializes a new instance of the <see cref="AfterMigrationEventArgs"/> class.
/// </summary>
/// <param name="version">The version.</param>
/// <param name="migration">The migration.</param>
/// <param name="direction">The direction.</param>
/// <param name="success">if set to <c>true</c> the migration succeeded.</param>
public AfterMigrationEventArgs(long version, IMigration migration, MigrationDirection direction, bool success)
{
Version = version;
Migration = migration;
Direction = direction;
Success = success;
}
// migration
public void DoMigrationsFromMemory(string connectionString, MigrationDirection direction = MigrationDirection.Up)
{
var isAttachedDbFile = this.IsAttachDbFilename(connectionString);
var queries = this.GetMigrationQueriesWithSemicolonDelimiter(isAttachedDbFile);
this.OpenConnectionAndExecuteQueries(queries, connectionString);
schema.ClearMigrations();
}
public MigrationStepMetadata(MigrationDirection direction, bool useModuleNameAsDefaultSchema, IEnumerable<IMigrationMetadata> migrationMetadatas)
{
if (!migrationMetadatas.Any()) throw new ArgumentException("No migrations provided.", "migrationMetadatas");
_moduleName = migrationMetadatas.Select(m => m.ModuleName).Distinct().Single();
_direction = direction;
_useModuleNameAsDefaultSchema = useModuleNameAsDefaultSchema;
_migrationMetadatas = migrationMetadatas;
}
public void DoMigrationsForTypes(Type[] assemblyTypes,
string connectionString, MigrationDirection direction = MigrationDirection.Up)
{
var recognizedTypes = this.FindTypes <Migration>(assemblyTypes);
if (recognizedTypes.Count > 0)
{
this.GroupAndExecuteMigrations(recognizedTypes, connectionString, direction);
}
}
private void ApplyMigration(MigrationDirection direction)
{
if (direction == MigrationDirection.Up)
{
Up();
}
else
{
Down();
}
}
public MigrationInfo(MigrationDirection direction, string scriptFolder, string targetSchema, string targetTablespace, IList<string> targetEnvironment,
long? targetVersion, bool useStored = false, bool forced = false)
{
Direction = direction;
ScriptFolder = scriptFolder;
TargetSchema = targetSchema;
TargetTablespace = targetTablespace;
TargetEnvironment = targetEnvironment;
TargetVersion = targetVersion;
UseStored = useStored;
Forced = forced;
}
public MigrationStepMetadata(MigrationDirection direction, bool useModuleNameAsDefaultSchema, IEnumerable <IMigrationMetadata> migrationMetadatas)
{
if (!migrationMetadatas.Any())
{
throw new ArgumentException("No migrations provided.", "migrationMetadatas");
}
_moduleName = migrationMetadatas.Select(m => m.ModuleName).Distinct().Single();
_direction = direction;
_useModuleNameAsDefaultSchema = useModuleNameAsDefaultSchema;
_migrationMetadatas = migrationMetadatas;
}
public MigrationInfo(MigrationDirection direction, string scriptFolder, string targetSchema, string targetTablespace, IList <string> targetEnvironment,
long?targetVersion, bool useStored = false, bool forced = false)
{
Direction = direction;
ScriptFolder = scriptFolder;
TargetSchema = targetSchema;
TargetTablespace = targetTablespace;
TargetEnvironment = targetEnvironment;
TargetVersion = targetVersion;
UseStored = useStored;
Forced = forced;
}
public void RunMigration(RecognizedMigrationFile recognizedType, MigrationDirection direction = MigrationDirection.Up)
{
var migration = this.CreateInstance <Migration>(recognizedType.Type);
if (direction == MigrationDirection.Up)
{
migration.Up();
}
else
{
migration.Down();
}
}
private static string GetRollbackMigrationFilePath(string migrationFilePath, MigrationDirection direction, string upExtension, string downExtension)
{
if (direction == MigrationDirection.None)
{
throw new ArgumentException("direction is None.");
}
var dir = Path.GetDirectoryName(migrationFilePath);
var name = GetMigrationName(migrationFilePath);
var extension = direction == MigrationDirection.Down ? upExtension : downExtension;
var result = Path.Combine(dir, name + "." + extension.TrimStart('.'));
return(result);
}
/// <summary>
/// Migrates the specified provider name.
/// </summary>
/// <param name="thisProviderName">Name of the provider.</param>
/// <param name="direction">The direction.</param>
public void Migrate(string thisProviderName, MigrationDirection direction)
{
Provider = DataService.GetInstance(thisProviderName);
// actually do migration, this is a hack since there isn't
// an ExecuteTransaction that takes a single cmd. Will
// probably be refactored to generated a single QueryCommand
// per MigrationStep but for now this works.
QueryCommand cmd = BuildCommands(direction);
QueryCommandCollection cmds = new QueryCommandCollection();
cmds.Add(cmd);
DataService.ExecuteTransaction(cmds);
}
/// <summary>
/// Initialises a new instance of the <see cref="MigrationRunData{TConnection}"/> class
/// </summary>
/// <param name="connection">Connection to use to run the migration</param>
/// <param name="logger">Logger to use to log SQL statements run, and other messages</param>
/// <param name="direction">Direction to run the migration in</param>
public MigrationRunData(TConnection connection, IMigrationLogger logger, MigrationDirection direction)
{
if (connection == null)
{
throw new ArgumentNullException(nameof(connection));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.Connection = connection;
this.Logger = logger;
this.Direction = direction;
}
public static IEnumerable <(int id, string name)> EnumerateMigrations(MigrationDirection direction, string path = "Migrations")
{
var result = Directory
.EnumerateFiles(path, "*.sql", SearchOption.TopDirectoryOnly)
.Select(item => (item, Path.GetFileNameWithoutExtension(item).ToLower()))
.Where(item =>
{
var(_, name) = item;
return(direction switch
{
MigrationDirection.Up when name.EndsWith(UpEndsWith) => true,
MigrationDirection.Down when name.EndsWith(DownEndsWith) => true,
_ => false
});
})
public void Update(IMigrationMetadata metadata, IDbConnection connection, IDbTransaction transaction, MigrationDirection direction, IDbCommandExecutor commandExecutor)
{
Debug.Assert(!(metadata is BootstrapMetadata));
if (direction == MigrationDirection.Up)
{
_history.Insert(metadata.Timestamp, metadata.ModuleName, metadata.Tag);
}
else
{
Debug.Assert(direction == MigrationDirection.Down);
Debug.Assert(_history.Contains(metadata.Timestamp, metadata.ModuleName), "Only migrations that were applied previously are being undone.");
_history.Delete(metadata.Timestamp, metadata.ModuleName);
}
StoreChanges(connection, transaction, commandExecutor);
}
protected Database GetDatabaseContainingMigrationChanges(MigrationDirection direction, IMigrationContext context)
{
var database = new Database(context);
if (direction == MigrationDirection.Up)
{
_migration.Up(database);
}
else
{
Debug.Assert(direction == MigrationDirection.Down);
var migration = _migration as IReversibleMigration;
if (migration == null)
{
throw new InvalidOperationException("Cannot downgrade an irreversible migration."); // this should never happen
}
migration.Down(database);
}
return database;
}
protected Database GetDatabaseContainingMigrationChanges(MigrationDirection direction, IMigrationContext context)
{
var database = new Database(context);
if (direction == MigrationDirection.Up)
{
_migration.Up(database);
}
else
{
Debug.Assert(direction == MigrationDirection.Down);
var migration = _migration as IReversibleMigration;
if (migration == null)
{
throw new InvalidOperationException("Cannot downgrade an irreversible migration."); // this should never happen
}
migration.Down(database);
}
return(database);
}
internal void Execute(IDbConnection connection, IDbTransaction transaction, MigrationDirection direction, IDbCommandExecutor commandExecutor)
{
Debug.Assert(connection.State == ConnectionState.Open);
var context = new RuntimeContext(connection, transaction, commandExecutor, _providerMetadata);
Database database = GetDatabaseContainingMigrationChanges(direction, context);
var translator = new CommandsToSqlTranslator(_provider);
foreach (string commandText in translator.TranslateToSql(database, context))
{
IDbCommand command = connection.CreateCommand();
command.CommandTimeout = 0; // do not timeout; the client is responsible for not causing lock-outs
command.Transaction = transaction;
command.CommandText = commandText;
try
{
commandExecutor.ExecuteNonQuery(command);
}
catch (DbException x)
{
Log.Error("An error occurred: {0}{1}while trying to execute:{1}{2}{1}{3}", x.Message, Environment.NewLine, command.CommandText,_migration.GetType().ToString());
throw new Exception(String.Format("An error occurred: {0}{1}while trying to execute:{1}{2}{1}Migration: {3}", x.Message, Environment.NewLine, command.CommandText, _migration.GetType()));
}
}
}
public void Update(IMigrationMetadata metadata, IDbConnection connection, IDbTransaction transaction, MigrationDirection direction, IDbCommandExecutor commandExecutor)
{
PersistedVersioning versioning = GetPersistedVersioning(connection, transaction, commandExecutor);
versioning.Update(metadata, connection, transaction, direction, commandExecutor);
}
public void EndMigration(MigrationData migration, MigrationDirection direction) { }
/// <summary>
/// Invoked when an individual migration is started
/// </summary>
/// <param name="migration">Migration being started</param>
/// <param name="direction">Direction of the migration</param>
public void BeginMigration(MigrationData migration, MigrationDirection direction)
{
var term = direction == MigrationDirection.Up ? "migrating" : "reverting";
this.WriteHeader($"{this.name}: {migration.Version}: {migration.FullName} {term}");
}
/// <summary>
/// Invoked when an individual migration is completed successfully
/// </summary>
/// <param name="migration">Migration which completed</param>
/// <param name="direction">Direction of the migration</param>
public void EndMigration(MigrationData migration, MigrationDirection direction)
{
Console.WriteLine();
}
public void DoMigrationOnlyFor(string migrationFileName, string assemblyPath,
string connectionString, string engine = "InnoDB", MigrationDirection direction = MigrationDirection.Up)
{
executor.DoMigrationOnlyFor(migrationFileName, assemblyPath, connectionString, engine, direction);
}
public void DoMigrationsForAssembly(string assemblyPath,
string connectionString, string engine = "InnoDB", MigrationDirection direction = MigrationDirection.Up)
{
executor.DoMigrationsForAssembly(assemblyPath, connectionString, engine, direction);
}
public void Migrate(MigrationDirection direction)
{
switch (direction) {
case MigrationDirection.Up:
Announce("migrating");
break;
case MigrationDirection.Down:
Announce("reverting");
break;
}
var time = Benchmark.Measure(delegate() {
if (direction == MigrationDirection.Up) {
Up();
} else {
Down();
}
});
switch (direction) {
case MigrationDirection.Up:
Announce(string.Format("migrated ({0})", time.Total.TotalSeconds));
Write("");
break;
case MigrationDirection.Down:
Announce(string.Format("reverted ({0})", time.Total.TotalSeconds));
Write("");
break;
}
}
/// <summary>
/// Invoked when an individual migration is started
/// </summary>
/// <param name="migration">Migration being started</param>
/// <param name="direction">Direction of the migration</param>
public void BeginMigration(MigrationData migration, MigrationDirection direction)
{
var term = direction == MigrationDirection.Up ? "migrating" : "reverting";
this.WriteHeader("{0}: {1} {2}", migration.Version, migration.FullName, term);
}
public static MigrationInfo MigrationInfo(MigrationDirection? direction = null)
{
return new MigrationInfo(direction ?? Value<MigrationDirection>(), String(), String(), String(), ListOf(String()), null);
}
public ScheduledMigrationMetadata(long timestamp, string moduleName, string tag, MigrationDirection direction)
: base(timestamp, moduleName, tag)
{
_direction = direction;
}
public void EndMigrationWithError(Exception exception, MigrationData migration, MigrationDirection direction) { }
/// <summary>
/// Invoked when an individual migration is completed successfully
/// </summary>
/// <param name="migration">Migration which completed</param>
/// <param name="direction">Direction of the migration</param>
public void EndMigration(MigrationData migration, MigrationDirection direction)
{
TestContext.WriteLine($"{this.name}:");
}
public ScheduledMigrationMetadata(long timestamp, string moduleName, string tag, string migrationName, DateTime? appliedDate, MigrationDirection direction)
: base(timestamp, moduleName, tag, migrationName, appliedDate)
{
_direction = direction;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
public MigrationEventArgs(IMigrationMetadata metadata, MigrationDirection direction)
{
_metadata = metadata;
_direction = direction;
}
// migration
public void DoMigrationsFromMemory(string connectionString, string engine = null, MigrationDirection direction = MigrationDirection.Up)
{
var queries = this.GetMigrationQueries(engine);
this.OpenConnectionAndExecuteQueries(queries, connectionString);
schema.ClearMigrations();
}
public ApplicableMigration(ImportedMigration migration, MigrationDirection direction)
{
_migration = migration;
_direction = direction;
}
public void DoMigrationsForAssembly(string assemblyPath,
string connectionString, string engine = null, MigrationDirection direction = MigrationDirection.Up)
{
var recognizedTypes = this.FindTypes <Migration>(assemblyPath);
if (recognizedTypes.Count > 0)
{
this.GroupAndExecuteMigrations(recognizedTypes, connectionString, engine, direction);
}
}
public void DoMigrationsForTypes(Type[] assemblyTypes,
string connectionString, string engine = "InnoDB", MigrationDirection direction = MigrationDirection.Up)
{
executor.DoMigrationsForTypes(assemblyTypes, connectionString, engine, direction);
}
/// <summary>
/// Invoked when an individual migration is completed successfully
/// </summary>
/// <param name="migration">Migration which completed</param>
/// <param name="direction">Direction of the migration</param>
public void EndMigration(MigrationData migration, MigrationDirection direction)
{
Console.WriteLine();
}
/// <summary>
/// Invoked when an individual migration is started
/// </summary>
/// <param name="migration">Migration being started</param>
/// <param name="direction">Direction of the migration</param>
public void BeginMigration(MigrationData migration, MigrationDirection direction)
{
var term = direction == MigrationDirection.Up ? "migrating" : "reverting";
this.WriteHeader("{0}: {1} {2}", migration.Version, migration.FullName, term);
}
/// <summary>
/// Invoked when an individual migration fails with an error
/// </summary>
/// <param name="exception">Exception which was encountered</param>
/// <param name="migration">Migration which failed</param>
/// <param name="direction">Direction of the migration</param>
public void EndMigrationWithError(Exception exception, MigrationData migration, MigrationDirection direction)
{
this.WriteError($"{this.name}: {migration.Version}: {migration.FullName} ERROR {exception.Message}");
}
/// <summary>
/// Invoked when an individual migration fails with an error
/// </summary>
/// <param name="exception">Exception which was encountered</param>
/// <param name="migration">Migration which failed</param>
/// <param name="direction">Direction of the migration</param>
public void EndMigrationWithError(Exception exception, MigrationData migration, MigrationDirection direction)
{
this.WriteError("{0}: {1} ERROR {2}", migration.Version, migration.FullName, exception.Message);
}
/// <summary>
/// Applies the specified <paramref name="migration"/> within the
/// specified <paramref name="context"/>.
/// </summary>
/// <param name="migration">The migration to apply.</param>
/// <param name="direction">The migration direction.</param>
/// <param name="context">The context.</param>
protected virtual void ApplyMigration(IMigration migration, MigrationDirection direction, MigrationContext context)
{
//
// Notify environment
//
var beforeArgs = new BeforeMigrationEventArgs(migration.GetVersion(), migration, direction);
OnBeforeMigration(beforeArgs);
if (beforeArgs.Cancel) throw new Exception("environment cancelled migration");
//
// Generate model
//
Database model = new Database(context);
//
// Send SQL statements on flush notification
//
model.FlushChanges += delegate(object sender, EventArgs e)
{
foreach (string sql in context.SqlProvider.GenerateSqlCommands(model))
{
// Notify environment
var beforeSqlArgs = new BeforeSqlEventArgs(sql);
OnBeforeSql(beforeSqlArgs);
if (beforeSqlArgs.Cancel) throw new Exception("environment cancelled migration");
// Execute
SqlProcessor.ProcessMigrationStatement(context, sql);
// Notify environment
var afterSqlArgs = new AfterSqlEventArgs(sql, true);
OnAfterSql(afterSqlArgs);
}
};
//
// Run migration
//
if (direction == MigrationDirection.Up)
migration.Up(model);
else
migration.Down(model);
//
// Flush changes
//
model.Flush();
//
// Memorize migration
//
HistoryRepository.AddItem(context,
new MigrationHistoryItem()
{
Date = DateTime.Now,
Direction = direction,
Version = migration.GetVersion()
}
);
//
// Notify enviroment
//
var afterArgs = new AfterMigrationEventArgs(migration.GetVersion(), migration, direction, true);
OnAfterMigration(afterArgs);
}
public void RunMigration(RecognizedMigrationFile last, MigrationDirection direction = MigrationDirection.Up)
{
this.assemblyService.RunMigration(last, direction);
}
public void BeginMigration(MigrationData migration, MigrationDirection direction) { }
public void GroupAndExecuteMigrations(List <RecognizedMigrationFile> recognizedTypes,
string connectionString, string engine = null, MigrationDirection direction = MigrationDirection.Up)
{
try
{
this.dbService.CreateConnection(connectionString);
this.dbService.Open();
var groups = this.Group(recognizedTypes);
foreach (var group in groups)
{
var last = this.GetLast(group.Value);
this.RunMigration(last, direction);
var queries = this.GetMigrationQueries(engine);
this.ExecuteQueries(queries);
schema.ClearMigrations();
}
}
catch (Exception e)
{
throw e;
}
finally
{
this.dbService.Close();
schema.ClearMigrations();
}
}
public MigrationException(Migration migration, MigrationDirection direction, Exception ex)
{
this.migration = migration;
this.direction = direction;
this.ex = ex;
}
public void DoMigrationOnlyFor(string migrationFileName, string assemblyPath, string connectionString, string engine = null, MigrationDirection direction = MigrationDirection.Up)
{
var recognizedType = this.FindType <Migration>(assemblyPath, migrationFileName);
if (recognizedType != null)
{
this.RunMigration(recognizedType, direction);
this.DoMigrationsFromMemory(connectionString, engine, direction);
}
}
/// <summary>
/// Invoked when an individual migration fails with an error
/// </summary>
/// <param name="exception">Exception which was encountered</param>
/// <param name="migration">Migration which failed</param>
/// <param name="direction">Direction of the migration</param>
public void EndMigrationWithError(Exception exception, MigrationData migration, MigrationDirection direction)
{
this.WriteError("{0}: {1} ERROR {2}", migration.Version, migration.FullName, exception.Message);
}
