public ICollection <MigrationReference> FindMigrations()
{
List <MigrationReference> refs = new List <MigrationReference>();
foreach (Type type in assembly.GetTypes())
{
if (type.IsPublic && type.IsClass && !type.IsAbstract && typeof(IDatabaseMigration).IsAssignableFrom(type))
{
object[] attrs = type.GetCustomAttributes(typeof(MigrationAttribute), false);
if (attrs.Length == 0)
{
throw new Exception("Found migration type that has no version information. See type " + type.FullName);
}
MigrationAttribute att = (MigrationAttribute)attrs[0];
MigrationReference mref = new MigrationReference(att.Version, type.Name, "", String.Empty);
mref.Reference = type;
refs.Add(mref);
}
}
refs.Sort(delegate(MigrationReference mr1, MigrationReference mr2) { return(mr1.Version.CompareTo(mr2.Version)); });
return(refs);
}
/// <summary>
/// Returns the version of the migration
/// <see cref = "MigrationAttribute">MigrationAttribute</see>.
/// </summary>
/// <param name = "t">Migration type.</param>
/// <returns>Version number sepcified in the attribute</returns>
public static long GetMigrationVersion(Type t)
{
MigrationAttribute attrib = (MigrationAttribute)
Attribute.GetCustomAttribute(t, typeof(MigrationAttribute));
return(attrib.Version);
}
private void RemoveMigration(IMigration migration, MigrationAttribute attr) {
// we're removing this one
_logger.MigrateDown(Current, migration.Name);
if (! DryRun) {
migration.Down();
_provider.MigrationUnApplied(attr.Version);
_provider.Commit();
migration.AfterDown();
}
}
static IExecutableSqlMigration CreateExecutableSqlMigration(MigrationAttribute attribute, ISqlMigration instance)
{
var sequenceNumber = attribute.SequenceNumber;
var branchSpecification = attribute.OptionalBranchSpecification ?? "master";
var id = $"{sequenceNumber}-{branchSpecification}";
var sql = instance.Sql;
var description = attribute.Description;
return(new ExecutableSqlMigration(id, sql, description, sequenceNumber, branchSpecification, instance));
}
private void ApplyMigration(IMigration migration, MigrationAttribute attr) {
// we're adding this one
_logger.MigrateUp(Current, migration.Name);
if (! DryRun) {
migration.Up();
_provider.MigrationApplied(attr.Version);
_provider.Commit();
migration.AfterUp();
}
}
private async Task <MigrationDefinition> CreateDefinitionAsync(
MigrationAttribute attribute,
Type @type,
CancellationToken cancellationToken)
{
var migration = await migrationFactory.CreateAsync(type, cancellationToken);
return(new MigrationDefinition(
attribute.Version,
attribute.GetTags(),
migration));
}
private void ApplyMigration(IMigration migration, MigrationAttribute attr)
{
// we're adding this one
_logger.MigrateUp(Current, migration.Name);
if (!DryRun)
{
migration.Up();
_provider.MigrationApplied(attr.Version);
_provider.Commit();
migration.AfterUp();
}
}
private void RemoveMigration(IMigration migration, MigrationAttribute attr)
{
// we're removing this one
_logger.MigrateDown(Current, migration.Name);
if (!DryRun)
{
migration.Down();
_provider.MigrationUnApplied(attr.Version);
_provider.Commit();
migration.AfterDown();
}
}
/// <summary>
/// Инициализация
/// </summary>
/// <param name="type">Тип, из которого извлекается информация о миграции</param>
public MigrationInfo(Type type)
{
Require.IsNotNull(type, "Не задан обрабатываемый класс");
Require.That(typeof(IMigration).IsAssignableFrom(type), "Класс миграции должен реализовывать интерфейс IMigration");
MigrationAttribute attribute = type.GetCustomAttribute <MigrationAttribute>();
Require.IsNotNull(attribute, "Не найден атрибут Migration");
Type = type;
Version = attribute.Version;
Ignore = attribute.Ignore;
WithoutTransaction = attribute.WithoutTransaction;
}
public int Compare(Type x, Type y)
{
MigrationAttribute attribOfX = (MigrationAttribute)Attribute.GetCustomAttribute(x, typeof(MigrationAttribute));
MigrationAttribute attribOfY = (MigrationAttribute)Attribute.GetCustomAttribute(y, typeof(MigrationAttribute));
if (_ascending)
{
return(attribOfX.Version.CompareTo(attribOfY.Version));
}
else
{
return(attribOfY.Version.CompareTo(attribOfX.Version));
}
}
public override void Migrate(IMigration migration)
{
_provider.BeginTransaction();
MigrationAttribute attr = (MigrationAttribute)Attribute.GetCustomAttribute(migration.GetType(), typeof(MigrationAttribute));
if (_provider.AppliedMigrations.Contains(attr.Version))
{
RemoveMigration(migration, attr);
}
else
{
ApplyMigration(migration, attr);
}
}
public static void Sql(this Migration migration, MigrationBuilder migrationBuilder)
{
if (migration == null)
{
throw new ArgumentNullException(nameof(migration));
}
MigrationAttribute attr = migration.GetType().GetCustomAttribute <MigrationAttribute>()
?? throw new InvalidOperationException();
string sql = File.ReadAllText($"migrations/{attr.Id}.sql");
migrationBuilder.Sql(sql);
}
private static long FindLatestMigration()
{
return(((IEnumerable <Type>) typeof(M1_Baseline).Assembly.GetTypes()).Where <Type>((Type x) => {
if (!x.IsClass)
{
return false;
}
return x.Namespace == typeof(M1_Baseline).Namespace;
}).Select <Type, long>((Type x) => {
MigrationAttribute attribute = x.GetAttribute <MigrationAttribute>(false);
if (attribute == null)
{
return (long)-1;
}
return attribute.Version;
}).OrderByDescending <long, long>((long x) => x).First <long>());
}
void ApplyMigration(IMigration migration, MigrationAttribute attr)
{
// we're adding this one
_logger.MigrateUp(Current, migration.Name);
if (!DryRun)
{
var tProvider = _provider as TransformationProvider;
if (tProvider != null)
{
tProvider.CurrentMigration = migration;
}
migration.Up();
_provider.MigrationApplied(attr.Version, attr.Scope);
_provider.Commit();
migration.AfterUp();
}
}
/// <summary>
/// Collect migrations in one <c>Assembly</c>.
/// </summary>
/// <param name = "asm">The <c>Assembly</c> to browse.</param>
/// <returns>The migrations collection</returns>
public static List <Type> GetMigrationTypes(Assembly asm)
{
List <Type> migrations = new List <Type>();
foreach (Type t in asm.GetExportedTypes())
{
MigrationAttribute attrib =
(MigrationAttribute)Attribute.GetCustomAttribute(t, typeof(MigrationAttribute));
if (attrib != null && typeof(IMigration).IsAssignableFrom(t) && !attrib.Ignore)
{
migrations.Add(t);
}
}
migrations.Sort(new MigrationTypeComparer(true));
return(migrations);
}
private void RemoveMigration(IMigration migration, MigrationAttribute attr)
{
// we're removing this one
_logger.MigrateDown(Current, migration.Name);
if (!DryRun)
{
var tProvider = _provider as TransformationProvider;
if (tProvider != null)
{
tProvider.CurrentMigration = migration;
}
migration.Down();
_provider.MigrationUnApplied(attr.Version, attr.Scope);
_provider.Commit();
migration.AfterDown();
}
}
public MigrationMetadata(Type type, MigrationAttribute attribute)
{
Type = type;
Attribute = attribute;
}
public static string GetMigrationId(this MigrationBuilder migrationBuilder, Type t)
{
MigrationAttribute MyAttribute = (MigrationAttribute)Attribute.GetCustomAttribute(t, typeof(MigrationAttribute));
return(MyAttribute.Id);
}
