Пример #1
0
        public void ListMigrations()
        {
            IVersionInfo currentVersionInfo = this.VersionLoader.VersionInfo;
            long         currentVersion     = currentVersionInfo.Latest();

            _announcer.Heading("Migrations");

            foreach (KeyValuePair <long, IMigrationInfo> migration in MigrationLoader.LoadMigrations())
            {
                string migrationName = migration.Value.GetName();
                bool   isCurrent     = migration.Key == currentVersion;
                string message       = string.Format("{0}{1}",
                                                     migrationName,
                                                     isCurrent ? " (current)" : string.Empty);

                if (isCurrent)
                {
                    _announcer.Emphasize(message);
                }
                else
                {
                    _announcer.Say(message);
                }
            }
        }
Пример #2
0
        public void Rollback(int steps, bool useAutomaticTransactionManagement)
        {
            var availableMigrations  = MigrationLoader.LoadMigrations();
            var migrationsToRollback = new List <IMigrationInfo>();

            foreach (long version in VersionLoader.VersionInfo.AppliedMigrations())
            {
                IMigrationInfo migrationInfo;
                if (availableMigrations.TryGetValue(version, out migrationInfo))
                {
                    migrationsToRollback.Add(migrationInfo);
                }
            }

            using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
            {
                foreach (IMigrationInfo migrationInfo in migrationsToRollback.Take(steps))
                {
                    ApplyMigrationDown(migrationInfo, useAutomaticTransactionManagement && migrationInfo.TransactionBehavior == TransactionBehavior.Default);
                }

                scope.Complete();
            }

            VersionLoader.LoadVersionInfo();

            if (!VersionLoader.VersionInfo.AppliedMigrations().Any())
            {
                VersionLoader.RemoveVersionTable();
            }
        }
Пример #3
0
        public void ListMigrations()
        {
            var currentVersionInfo = this.VersionLoader.VersionInfo;
            var currentVersion     = currentVersionInfo.Latest();

            _announcer.Heading("Migrations");

            foreach (var migration in MigrationLoader.LoadMigrations())
            {
                var migrationName = migration.Value.GetName();
                var status        = GetStatus(migration, currentVersion);
                var statusString  = string.Join(", ", GetStatusStrings(status));
                var message       = $"{migrationName}{(string.IsNullOrEmpty(statusString) ? string.Empty : $" ({statusString})")}";

                var isCurrent  = (status & MigrationStatus.AppliedMask) == MigrationStatus.Current;
                var isBreaking = (status & MigrationStatus.Breaking) == MigrationStatus.Breaking;
                if (isCurrent || isBreaking)
                {
                    _announcer.Emphasize(message);
                }
                else
                {
                    _announcer.Say(message);
                }
            }
Пример #4
0
        public void MigrateUp(bool useAutomaticTransactionManagement)
        {
            var migrations = MigrationLoader.LoadMigrations();

            using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
            {
                ApplyMaintenance(MigrationStage.BeforeAll, useAutomaticTransactionManagement);

                foreach (var pair in migrations)
                {
                    ApplyMaintenance(MigrationStage.BeforeEach, useAutomaticTransactionManagement);
                    ApplyMigrationUp(pair.Value, useAutomaticTransactionManagement && pair.Value.TransactionBehavior == TransactionBehavior.Default);
                    ApplyMaintenance(MigrationStage.AfterEach, useAutomaticTransactionManagement);
                }

                ApplyMaintenance(MigrationStage.BeforeProfiles, useAutomaticTransactionManagement);

                ApplyProfiles();

                ApplyMaintenance(MigrationStage.AfterAll, useAutomaticTransactionManagement);

                scope.Complete();
            }

            VersionLoader.LoadVersionInfo();
        }
Пример #5
0
        public void RollbackToVersion(long version, bool useAutomaticTransactionManagement)
        {
            var availableMigrations  = MigrationLoader.LoadMigrations();
            var migrationsToRollback = new List <IMigrationInfo>();

            foreach (long appliedVersion in VersionLoader.VersionInfo.AppliedMigrations())
            {
                IMigrationInfo migrationInfo;
                if (availableMigrations.TryGetValue(appliedVersion, out migrationInfo))
                {
                    migrationsToRollback.Add(migrationInfo);
                }
            }

            foreach (IMigrationInfo migrationInfo in migrationsToRollback)
            {
                if (version >= migrationInfo.Version)
                {
                    continue;
                }

                ApplyMigrationDown(migrationInfo, useAutomaticTransactionManagement && migrationInfo.TransactionBehavior == TransactionBehavior.Default);
            }

            VersionLoader.LoadVersionInfo();

            if (version == 0 && !VersionLoader.VersionInfo.AppliedMigrations().Any())
            {
                VersionLoader.RemoveVersionTable();
            }
        }
Пример #6
0
        private IEnumerable <IMigrationInfo> GetUpMigrationsToApply(long version)
        {
            var migrations = MigrationLoader.LoadMigrations();

            return(from pair in migrations
                   where IsMigrationStepNeededForUpMigration(pair.Key, version)
                   select pair.Value);
        }
        private IEnumerable <IMigrationInfo> GetUpMigrationsToApply(long startVersion, long targetVersion)
        {
            var migrations = MigrationLoader.LoadMigrations();

            return(from pair in migrations
                   where pair.Key >= startVersion && pair.Key <= targetVersion
                   select pair.Value);
        }
Пример #8
0
        public bool HasMigrationsToApplyUp(long?version = null)
        {
            if (version.HasValue)
            {
                return(GetUpMigrationsToApply(version.Value).Any());
            }

            return(MigrationLoader.LoadMigrations().Any(mi => !VersionLoader.VersionInfo.HasAppliedMigration(mi.Key)));
        }
Пример #9
0
        private IEnumerable <IMigrationInfo> GetDownMigrationsToApply(long targetVersion)
        {
            var migrations = MigrationLoader.LoadMigrations();

            var migrationsToApply = (from pair in migrations
                                     where IsMigrationStepNeededForDownMigration(pair.Key, targetVersion)
                                     select pair.Value);

            return(migrationsToApply.OrderByDescending(x => x.Version));
        }
Пример #10
0
        public void ValidateVersionOrder()
        {
            var unappliedVersions = MigrationLoader.LoadMigrations().Where(kvp => MigrationVersionLessThanGreatestAppliedMigration(kvp.Key)).ToList();

            if (unappliedVersions.Any())
            {
                throw new VersionOrderInvalidException(unappliedVersions);
            }

            _announcer.Say("Version ordering valid.");
        }
        private IEnumerable <IMigrationInfo> GetDownMigrationsToApply(long startVersion, long targetVersion)
        {
            var migrations = MigrationLoader.LoadMigrations();

            var migrationsToApply = (from pair in migrations
                                     where pair.Key <= startVersion && pair.Key >= targetVersion
                                     select pair.Value)
                                    .ToList();

            return(migrationsToApply.OrderByDescending(x => x.Version));
        }
Пример #12
0
        public void MigrateUp(bool useAutomaticTransactionManagement)
        {
            var migrations = MigrationLoader.LoadMigrations();

            foreach (var pair in migrations)
            {
                ApplyMigrationUp(pair.Value, useAutomaticTransactionManagement && pair.Value.TransactionBehavior == TransactionBehavior.Default);
            }

            ApplyProfiles();

            VersionLoader.LoadVersionInfo();
        }
Пример #13
0
        public void RollbackToVersion(long version, bool useAutomaticTransactionManagement)
        {
            var availableMigrations  = MigrationLoader.LoadMigrations();
            var migrationsToRollback = new List <IMigrationInfo>();

            foreach (long appliedVersion in VersionLoader.VersionInfo.AppliedMigrations())
            {
                IMigrationInfo migrationInfo;
                if (availableMigrations.TryGetValue(appliedVersion, out migrationInfo))
                {
                    migrationsToRollback.Add(migrationInfo);
                }
            }

            using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
            {
                try
                {
                    foreach (IMigrationInfo migrationInfo in migrationsToRollback)
                    {
                        if (version >= migrationInfo.Version)
                        {
                            continue;
                        }

                        ApplyMigrationDown(migrationInfo, useAutomaticTransactionManagement && migrationInfo.TransactionBehavior == TransactionBehavior.Default);
                    }

                    scope.Complete();
                }
                catch
                {
                    if (scope.IsActive)
                    {
                        scope.Cancel();  // SQLAnywhere needs explicit call to rollback transaction
                    }
                    throw;
                }
            }

            VersionLoader.LoadVersionInfo();

            if (version == 0 && !VersionLoader.VersionInfo.AppliedMigrations().Any())
            {
                VersionLoader.RemoveVersionTable();
            }
        }
        public void MigrateUp(bool useAutomaticTransactionManagement)
        {
            var migrations = MigrationLoader.LoadMigrations();

            using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
            {
                try
                {
                    ApplyMaintenance(MigrationStage.BeforeAll, useAutomaticTransactionManagement);

                    foreach (var pair in migrations)
                    {
                        ApplyMaintenance(MigrationStage.BeforeEach, useAutomaticTransactionManagement);
                        ApplyMigrationUp(pair.Value, useAutomaticTransactionManagement && pair.Value.TransactionBehavior == TransactionBehavior.Default);
                        ApplyMaintenance(MigrationStage.AfterEach, useAutomaticTransactionManagement);
                    }

                    ApplyMaintenance(MigrationStage.BeforeProfiles, useAutomaticTransactionManagement);

                    ApplyProfiles();

                    ApplyMaintenance(MigrationStage.AfterAll, useAutomaticTransactionManagement);

                    scope.Complete();
                }
                catch
                {
                    if (scope.IsActive)
                    {
                        scope.Cancel();  // SQLAnywhere needs explicit call to rollback transaction
                    }
                    throw;
                }
            }

            VersionLoader.LoadVersionInfo();
        }