protected BaseMigrate(IList<long> availableMigrations, ITransformationProvider provider, ILogger logger)
{
_provider = provider;
_availableMigrations = availableMigrations;
_original = new List<long> (_provider.AppliedMigrations.ToArray()); //clone
_logger = logger;
}
public static void RenameColumnWithSchema(this ITransformationProvider database, string oldtable, string oldcolumn, string newcolumn)
{
if (TableExistsWithSchema(database, oldtable))
{
database.ExecuteNonQuery(string.Format("sp_rename '{0}.{1}', '{2}', 'COLUMN'", oldtable, oldcolumn, newcolumn));
}
}
protected BaseMigrate(List <long> availableMigrations, ITransformationProvider provider, ILogger logger)
{
_provider = provider;
_availableMigrations = availableMigrations;
_original = new List <long>(_provider.AppliedMigrations.ToArray()); //clone
_logger = logger;
}
public virtual void Execute(ITransformationProvider provider)
{
foreach (var action in this.Actions)
{
action.Execute(provider);
}
}
public static void AddIndex(
this ITransformationProvider transformation,
string tableName,
params string[] columns)
{
transformation.AddIndex(tableName, false, columns);
}
public static ITransformationProvider AddManyToManyJoiningTable(this ITransformationProvider database, string schema, string lhsTableName, string lhsKey, string rhsTableName, string rhsKey, string joiningTableName)
{
string joiningTableWithSchema = TransformationProviderUtility.FormatTableName(schema, joiningTableName);
string joinLhsKey = Inflector.Singularize(lhsTableName) + "Id";
string joinRhsKey = Inflector.Singularize(rhsTableName) + "Id";
database.AddTable(joiningTableWithSchema,
new Column(joinLhsKey, DbType.Guid, ColumnProperty.NotNull),
new Column(joinRhsKey, DbType.Guid, ColumnProperty.NotNull));
string pkName = "PK_" + joiningTableName;
pkName = ShortenKeyNameToBeSuitableForOracle(pkName);
database.AddPrimaryKey(pkName, joiningTableWithSchema, joinLhsKey, joinRhsKey);
string lhsTableNameWithSchema = TransformationProviderUtility.FormatTableName(schema, lhsTableName);
string rhsTableNameWithSchema = TransformationProviderUtility.FormatTableName(schema, rhsTableName);
string lhsFkName = TransformationProviderUtility.CreateForeignKeyName(lhsTableName, joiningTableName);
database.AddForeignKey(lhsFkName, joiningTableWithSchema, joinLhsKey, lhsTableNameWithSchema, lhsKey, ForeignKeyConstraintType.NoAction);
string rhsFkName = TransformationProviderUtility.CreateForeignKeyName(rhsTableName, joiningTableName);
database.AddForeignKey(rhsFkName, joiningTableWithSchema, joinRhsKey, rhsTableNameWithSchema, rhsKey, ForeignKeyConstraintType.NoAction);
return(database);
}
public static void ChangeColumnSizeWithSchema(this ITransformationProvider database, string table, ColumnInfo column)
{
if (ColumnExistsWithSchema(database, table, column.Name))
{
database.ExecuteNonQuery(string.Format("ALTER TABLE {0} ALTER COLUMN {1} {2}({3})", table, column.Name, column.Type, column.Size));
}
}
/// <summary>
/// New table expression.
/// </summary>
/// <example>
/// Database.ChangeTable("Roles", t => {
/// t.ChangeColumn("Description").Text; // Changes description field data type.
/// t.RemoveColumn("Name"); // Removes name field.
/// t.Integer("Priority"); // Adds priority integer field.
/// });
/// </example>
/// <param name="transformationProvider">The transformation provider.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="tableDefinition">The table change expressions.</param>
public static void ChangeTable(this ITransformationProvider transformationProvider, String tableName, Action <ChangeTable> tableDefinition)
{
var table = new ChangeTable(tableName);
tableDefinition(table);
table.Migrate(transformationProvider);
}
public static void RemoveTableWithSchema(this ITransformationProvider database, string table)
{
if (TableExistsWithSchema(database, table))
{
database.ExecuteNonQuery(string.Format("DROP TABLE {0}", table));
}
}
public TransformationPresenter(
ITransformationProvider provider,
IAsyncOperationLocker locker)
{
_provider = provider;
_locker = locker;
}
public static int GetLastInsertedId(this ITransformationProvider migration)
{
var query = "SELECT @@IDENTITY";
var result = migration.ExecuteScalar(query);
return(int.Parse(result.ToString()));
}
protected BaseMigrate(List<long> availableMigrations, ITransformationProvider provider, ILogger logger)
{
this.provider = provider;
this.availableMigrations = availableMigrations;
this.original = new List<long>(this.provider.AppliedMigrations.ToArray()); // clone
this.logger = logger;
}
public void CreateAndDropHiLoTable(ITransformationProvider database)
{
database.CreateHiLoTable();
Assert.IsTrue(database.TableExists(TransformationProviderHiLoExtensions.HI_LO_TABLE_NAME));
database.RemoveHiLoTable();
Assert.IsFalse(database.TableExists(TransformationProviderHiLoExtensions.HI_LO_TABLE_NAME));
}
public static void RenameTableWithSchema(this ITransformationProvider database, string oldtable, string newtable)
{
if (TableExistsWithSchema(database, oldtable))
{
database.ExecuteNonQuery(string.Format("sp_rename '{0}', '{1}'", oldtable, newtable));
}
}
public Migrator(ITransformationProvider provider, Assembly migrationAssembly, bool trace, ILogger logger) {
_provider = provider;
Logger = logger;
_migrationLoader = new MigrationLoader(provider, migrationAssembly, trace);
_migrationLoader.CheckForDuplicatedVersion();
}
/// <summary>
/// Инициализация
/// </summary>
public Migrator(ITransformationProvider provider, Assembly asm)
{
Require.IsNotNull(provider, "Не задан провайдер трансформации");
this.provider = provider;
Require.IsNotNull(asm, "Не задана сборка с миграциями");
migrationAssembly = new MigrationAssembly(asm);
}
/// <summary>
/// Инициализация
/// </summary>
public Migrator(ITransformationProvider provider, Assembly asm)
{
Require.IsNotNull(provider, "Не задан провайдер трансформации");
this.provider = provider;
Require.IsNotNull(asm, "Не задана сборка с миграциями");
migrationAssembly = new MigrationAssembly(asm);
}
protected BaseMigrate(List<long> availableMigrations, ITransformationProvider provider, ILogger logger, string schemainfoname)
{
_provider = provider;
_provider.SchemaInfoName(schemainfoname);
_availableMigrations = availableMigrations;
_original = new List<long> (_provider.AppliedMigrations.ToArray()); //clone
_logger = logger;
}
public void CanLoad_SQLiteProvider()
{
ITransformationProvider provider = ProviderFactory.Create(ProviderTypes.SQLite,
ConfigurationManager.AppSettings[
"SQLiteConnectionString"], null);
Assert.IsNotNull(provider);
}
public static void AddForeignKey(this ITransformationProvider migration, string foreignTable, string foreignColumn, string primaryTable, string primaryColumn)
{
migration.AddForeignKey(migration.ForeignKeyName(foreignTable, foreignColumn, primaryTable, primaryColumn),
foreignTable,
foreignColumn,
primaryTable,
primaryColumn);
}
public MigrateAnywhere(List<long> availableMigrations, ITransformationProvider provider, ILogger logger)
: base(availableMigrations, provider, logger) {
_current = 0;
if (provider.AppliedMigrations.Count > 0) {
_current = provider.AppliedMigrations[provider.AppliedMigrations.Count - 1];
}
_goForward = false;
}
public void CanLoad_OracleProvider()
{
ITransformationProvider provider = ProviderFactory.Create("Oracle",
ConfigurationManager.AppSettings[
"OracleConnectionString"]);
Assert.IsNotNull(provider);
}
public static void AddForeignKey(this ITransformationProvider migration, string foreignTable, string primaryTable)
{
migration.AddForeignKey(migration.ForeignKeyName(foreignTable, primaryTable),
foreignTable,
primaryTable + "Id",
primaryTable,
"Id");
}
public void CanLoad_PostgreSQLProvider()
{
ITransformationProvider provider = ProviderFactory.Create("PostgreSQL",
ConfigurationManager.AppSettings[
"NpgsqlConnectionString"], null);
Assert.IsNotNull(provider);
}
public Migrator(ITransformationProvider provider, ILogger logger, MigrationLoader migrationLoader)
{
_provider = provider;
Logger = logger;
_migrationLoader = migrationLoader;
_migrationLoader.CheckForDuplicatedVersion();
}
public void CanLoad_SqlServerProvider()
{
ITransformationProvider provider = ProviderFactory.Create("SqlServer",
ConfigurationManager.AppSettings[
"SqlServerConnectionString"], null);
Assert.IsNotNull(provider);
}
public Migrator(ITransformationProvider provider, bool trace, ILogger logger, params Type[] migrationTypes)
{
_provider = provider;
Logger = logger;
_migrationLoader = new MigrationLoader(provider, trace, migrationTypes);
_migrationLoader.CheckForDuplicatedVersion();
}
public override void Execute(ITransformationProvider provider)
{
var columnsAccessors = Actions.OfType<ColumnAddAction>();
Actions = Actions.Except(columnsAccessors.OfType<IAction>()).ToList();
provider.AddTable(this.Name, columnsAccessors.Select(x => x.ToColumn()).ToArray());
base.Execute(provider);
}
public Migrator(ITransformationProvider provider, bool trace, ILogger logger, params Assembly[] assemblies)
{
this.provider = provider;
Logger = logger;
migrationLoader = new MigrationLoader(provider, trace, assemblies);
migrationLoader.CheckForDuplicatedVersion();
}
/// <summary>
/// Removes foreign key and foreign key column if specified.
/// </summary>
/// <param name="database">The database.</param>
public override void Migrate(ITransformationProvider database)
{
database.RemoveConstraint(ForeignKeyTable, Name);
if (GenerateColumn)
{
database.RemoveColumn(ForeignKeyTable, GetColumn().Name);
}
}
public static void RemoveTableIfExists(
this ITransformationProvider transformation,
string table)
{
if (transformation.TableExists(table))
{
transformation.RemoveTable(table);
}
}
/// <summary>
/// Removes foreign key and foreign key column if specified.
/// </summary>
/// <param name="database">The database.</param>
public override void Migrate(ITransformationProvider database)
{
database.RemoveConstraint(ForeignKeyTable, Name);
if (GenerateColumn)
{
database.RemoveColumn(ForeignKeyTable, GetColumn().Name);
}
}
public void InstanceForProvider()
{
ITransformationProvider localProv = _provider["sqlserver"];
Assert.IsTrue(localProv is SqlServerTransformationProvider);
ITransformationProvider localProv2 = _provider["foo"];
Assert.IsTrue(localProv2 is NoOpTransformationProvider);
}
/// <summary>
/// Создать миграцию по номеру версии
/// </summary>
/// <param name="migrationInfo">Информация о миграции</param>
/// <param name="provider">Провайдер СУБД для установки в качестве текущего провайдера миграции</param>
public IMigration InstantiateMigration(MigrationInfo migrationInfo, ITransformationProvider provider)
{
Require.IsNotNull(provider, "Не задан провайдер СУБД");
Require.IsNotNull(migrationInfo.Type, "Не задан класс миграции");
var migration = (IMigration)Activator.CreateInstance(migrationInfo.Type);
migration.Database = provider;
return(migration);
}
/// <summary>
/// Adds foreign key and foreign key column if specified.
/// </summary>
/// <param name="database">The database.</param>
public override void Migrate(ITransformationProvider database)
{
if (GenerateColumn)
{
database.AddColumn(ForeignKeyTable, GetColumn());
}
database.AddForeignKey(Name, ForeignKeyTable,
new[] {ForeignKeyColumn}, PrimaryKeyTable, new[] {PrimaryKeyColumn}, DeleteConstraint, UpdateConstraint);
}
/// <summary>
/// Adds foreign key and foreign key column if specified.
/// </summary>
/// <param name="database">The database.</param>
public override void Migrate(ITransformationProvider database)
{
if (GenerateColumn)
{
database.AddColumn(ForeignKeyTable, GetColumn());
}
database.AddForeignKey(Name, ForeignKeyTable,
new[] { ForeignKeyColumn }, PrimaryKeyTable, new[] { PrimaryKeyColumn }, DeleteConstraint, UpdateConstraint);
}
public MigrateAnywhere(List <long> availableMigrations, ITransformationProvider provider, ILogger logger)
: base(availableMigrations, provider, logger)
{
_current = 0;
if (provider.AppliedMigrations.Count > 0)
{
_current = provider.AppliedMigrations[provider.AppliedMigrations.Count - 1];
}
_goForward = false;
}
public static void RemoveIndex(
this ITransformationProvider transformation,
string tableName,
params string[] columns)
{
var indexName = GetIndexName(tableName, columns);
var sql = GetRemoveIndexSql(tableName, indexName);
transformation.ExecuteNonQuery(sql);
}
public static void AddForeignKey(this ITransformationProvider provider, string foreignTable, string primaryTable,
ForeignKeyConstraint constraint = ForeignKeyConstraint.NoAction)
{
provider.AddForeignKey(foreignTable.ForeignKeyNameTo(primaryTable),
foreignTable,
primaryTable.ForeignId(),
primaryTable,
"Id",
constraint);
}
public static void ExecuteNonQueryNoTimeout(ITransformationProvider p_provider, string p_sqlStatement)
{
var command = p_provider.GetCommand();
command.CommandType = CommandType.Text;
// 1-24-13 AMB: Changed from 600 (10 minutes) to 1800 (30 minutes)
command.CommandTimeout = 1800;
command.CommandText = p_sqlStatement;
Console.WriteLine("Executing: {0}", command.CommandText);
command.ExecuteNonQuery();
}
public ConditionByProvider(ITransformationProvider current)
{
if (current == null)
{
throw new ArgumentNullException(nameof(current));
}
currentProvider = current;
isExecuted = false;
}
public DbMigrator(MigratorOptions options)
{
var provider = ProviderFactory.Create(options.Provider, options.ConnectionString);
_migrationLoader = new MigrationLoader(provider, options.MigrationTypes, false);
_migrationLoader.CheckForDuplicatedVersion();
_provider = provider;
Logger = new Logger(false, new ConsoleWriter());
_options = options;
provider.Writer = _options.Commands;
}
public static void RemoveColumnWithSchema(this ITransformationProvider database, string table, string column)
{
if (!ColumnExistsWithSchema(database, table, column))
{
return;
}
database.DeleteColumnConstraints(table, column);
database.ExecuteNonQuery(string.Format("ALTER TABLE {0} DROP COLUMN {1} ", table, column));
}
public MigrationLoader(ITransformationProvider provider, Assembly migrationAssembly, bool trace) {
_provider = provider;
AddMigrations(migrationAssembly);
if (trace) {
provider.Logger.Trace("Loaded migrations:");
foreach (Type t in _migrationsTypes) {
provider.Logger.Trace("{0} {1}", GetMigrationVersion(t).ToString().PadLeft(5), StringUtils.ToHumanName(t.Name));
}
}
}
public void Create(ITransformationProvider provider)
{
provider.AddColumn(_toTable, _column.Name, _column.ColumnType, _column.ColumnProperty, _column.DefaultValue);
if (_column.ForeignKey != null)
{
provider.AddForeignKey(
"FK_" + _toTable + "_" + _column.Name + "_" + _column.ForeignKey.PrimaryTable + "_" +
_column.ForeignKey.PrimaryKey,
_toTable, _column.Name, _column.ForeignKey.PrimaryTable, _column.ForeignKey.PrimaryKey, _column.Constraint);
}
}
public MigrationLoader(ITransformationProvider provider, bool trace, params Assembly[] migrationAssemblies)
{
this.provider = provider;
AddMigrations(migrationAssemblies);
if (trace)
{
provider.Logger.Trace("Loaded migrations:");
foreach (var m in migrationsTypes)
{
provider.Logger.Trace("{0} {1}", m.Version.ToString().PadLeft(5), StringUtils.ToHumanName(m.Type.Name));
}
}
}
protected BaseMigrate(string scope, List<long> availableMigrations, ITransformationProvider provider, ILogger logger)
{
_provider = provider;
_availableMigrations = availableMigrations;
_scope = scope;
_original = new List<long>(); //clone
foreach (var appliedMigration in _provider.AppliedMigrations)
{
if (scope == appliedMigration.Key)
_original.Add(appliedMigration.Value);
}
_original.Sort();
_logger = logger;
}
public MigrateAnywhere(string scope, List<long> availableMigrations, ITransformationProvider provider, ILogger logger)
: base(scope, availableMigrations, provider, logger)
{
_current = 0;
if (provider.AppliedMigrations.Count > 0) {
foreach (var appliedMigration in provider.AppliedMigrations)
{
if (appliedMigration.Key != scope)
continue;
if (_current < appliedMigration.Value)
_current = appliedMigration.Value;
}
}
_goForward = false;
}
/// <summary>
/// Расширяет таблицу SchemaInfo полем AssemblyKey.
/// Использутеся при переходе от старой версии
///
/// Должно быть удалено в будущем
/// </summary>
/// <param name="provider"></param>
public static void Update1To3(ITransformationProvider provider)
{
provider.AddTable(
"SchemaTmp",
new Column("Version", DbType.Int64, ColumnProperty.PrimaryKey),
new Column("AssemblyKey", DbType.String.WithSize(200), ColumnProperty.PrimaryKey, "''"));
string sql = provider.FormatSql(
"INSERT INTO {0:NAME} ({1:NAME}) SELECT {1:NAME} FROM {2:NAME}",
"SchemaTmp", "Version", "SchemaInfo");
provider.ExecuteNonQuery(sql);
provider.RemoveTable("SchemaInfo");
provider.RenameTable("SchemaTmp", "SchemaInfo");
}
public abstract void Execute(ITransformationProvider migration);
public void Create(ITransformationProvider provider)
{
provider.AddTable(_newTable);
}
/// <summary>
/// Changes existing column.
/// </summary>
/// <param name="database">The database.</param>
public override void Migrate(ITransformationProvider database)
{
var column = GetColumn();
database.ChangeColumn(TableName, column.Name, column.ColumnType, false);
}
public void Create(ITransformationProvider provider)
{
provider.RenameTable(_oldName, _newName);
}
public void Create(ITransformationProvider provider)
{
provider.RemoveTable(_tableName);
}
public override void Execute(ITransformationProvider provider)
{
provider.RemoveConstraint(this.Table.Name, this.Name);
}
public Migrator(ITransformationProvider provider, bool trace, params Assembly[] assemblies)
: this(provider, trace, new Logger(trace, new ConsoleWriter()), assemblies)
{
}
public Migrator(ITransformationProvider provider, Assembly migrationAssembly, bool trace)
: this(provider, migrationAssembly, trace, new Logger(trace, new ConsoleWriter()))
{
}
public void Execute(ITransformationProvider provider)
{
provider.RenameTable(FromName, ToName);
}
/// <summary>
/// Removes table column.
/// </summary>
/// <param name="database">The database.</param>
public override void Migrate(ITransformationProvider database)
{
database.RemoveColumn(TableName, Name);
}
