C# Migrator.Migrate方法代码示例

 public static void CreateDatabase(string dbName, string relativePath)
 {
     string dbFilePath = GetAbsoluteDatabaseFilePath(dbName, relativePath);
     string connectionString = ConnectionString(dbFilePath);
     Migrator migrator = new Migrator(connectionString);
     #if DEBUG
     migrator.Migrate(runner => runner.MigrateDown(0));
     #endif
     migrator.Migrate(runner => runner.MigrateUp());
     DapperExtensions.DapperExtensions.DefaultMapper = typeof(PluralizedAutoClassMapper<>);
 }

        public override bool Execute()
        {
            using (var store = new DocumentStore())
            {
                store.ConfigureUsingConnectionString(ConnectionString);
                store.Initialize();

                var migrator = new Migrator();
                foreach (var item in Migrations)
                {
                    var assembly = Assembly.LoadFrom(item.GetMetadata("FullPath"));
                    migrator.Migrate(store, assembly, ToVersion);
                }
            }

            if (ToVersion > 0)
            {
                Log.LogMessage("Migrated to version " + ToVersion + ".");
            }
            else
            {
                Log.LogMessage("Migrated to maximum version.");
            }
            return true;
        }

        public void Can_Export_Database_Into_Export_File()
        {
            var migrator = new Migrator();
            migrator.Migrate();

            var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, BlogMLExportWorker.ExportFileName);
            var exportFile = new FileInfo(path);

            Assert.True(exportFile.Exists);
        }

        public void create_database_and_apply_all_migrations()
        {
            Mock<ISupplyMigrations> source = SetupSource();

            Mock<ICommandDatabases> handler = SetupHandler(new DatabaseVersion {Type = DatabaseVersionType.NotCreated});
            Mock<ICompareMigrations> comparer = SetupComparer();
            var migrator = new Migrator(source.Object, comparer.Object, handler.Object);
            migrator.Migrate();
            handler.Verify(h => h.Create(), Times.Once);
            handler.Verify(h => h.CreateMigrationHistoryTable(), Times.Never);
            handler.Verify(h => h.ExecuteMigration(It.IsAny<Migration>()), Times.Exactly(2));
        }

        public void Can_Deserialize_Exported_File()
        {
            var migrator = new Migrator();
            migrator.Migrate();

            var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, BlogMLExportWorker.ExportFileName);
            var file = new FileStream(path, FileMode.Open);
            var blog = BlogMLSerializer.Deserialize(file);

            Assert.NotNull(blog);
            Assert.NotEqual(0, blog.Posts.Count);
            Assert.NotEqual(0, blog.Categories.Count);
        }

        public void Initialise(IConfigSource configSource)
        {
            IConfig config = configSource.Configs["EventRecorder"];
            m_connectionString = config.GetString("ConnectionString");

            if (m_connectionString == null)
                throw new Exception("No ConnectionString parameter found in [EventRecorder] config for MySQLRecorder");

            //            m_log.DebugFormat("[MYSQL EVENT RECORDER]: Got connection string '{0}'", m_connectionString);

            Migrator migrator = new Migrator(m_connectionString);
            migrator.Migrate(runner => runner.MigrateUp());
        }

        public void apply_no_migrations()
        {
            Mock<ISupplyMigrations> source = SetupSource();

            Mock<ICommandDatabases> handler =
                SetupHandler(new DatabaseVersion {Type = DatabaseVersionType.VersionNumber, Number = "1"});
            Mock<ICompareMigrations> comparer = SetupComparer();
            var migrator = new Migrator(source.Object, comparer.Object, handler.Object);
            migrator.Migrate();
            handler.Verify(h => h.Create(), Times.Never);
            handler.Verify(h => h.CreateMigrationHistoryTable(), Times.Never);
            handler.Verify(h => h.ExecuteMigration(It.IsAny<Migration>()), Times.Never);
        }

        public void Exports_Post_Category_Relations()
        {
            var migrator = new Migrator();
            migrator.Migrate();

            var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, BlogMLExportWorker.ExportFileName);
            var file = new FileStream(path, FileMode.Open);
            var blog = BlogMLSerializer.Deserialize(file);

            var post = blog.Posts[0];
            var categories = post.Categories;

            Assert.NotNull(categories);
            Assert.NotEmpty(categories);
        }

		public static void MigrateSettings(bool createTargetCategoryAndFields,
		                                   bool migrateFieldValues,
		                                   IMemento newState,
		                                   IMemento oldState)
		{
			Migrator migrator = new Migrator();

			if (createTargetCategoryAndFields)
			{
				migrator.EnsureTargetCategory(newState.CategoryName);
				migrator.EnsureFields(newState.CategoryName, new MigrationInfo(oldState, newState).AllFields);
			}

			if (migrateFieldValues)
			{
				migrator.Migrate(new MigrationInfo(oldState, newState));
			}
		}

        private static void DoManatee(InputParameters settings)
        {
            // Export
            if(settings.Command == Command.Export)
            {
                Logger.WriteLine(ConsoleColor.Green, "Exporting migrations from connection {0}", settings.Connection);

                var deriver = new MigrationExporter(settings.MigrationFolder, settings.Connection, settings.Table);
                deriver.DoExport();
                return;
            }

            // Generate
            if (settings.Command == Command.Gen)
            {
                Logger.WriteLine(ConsoleColor.Green, "Generating new migration file");

                var fileName = string.Format("{0}_{1}.json", DateTime.Now.ToString("yyyyMMdd_HHmm"), settings.Name);
                var content = @"{
            up: {

            },
            down: {
            }
            }";
                var outputPath = Path.Combine(settings.MigrationFolder, fileName);
                File.WriteAllText(outputPath, content, Encoding.UTF8);

                Logger.WriteLine("Generated new file: {0}", fileName);
                return;
            }

            var migrator = new Migrator(settings.MigrationFolder, settings.Connection);

            // List
            if(settings.Command == Command.List)
            {
                Logger.WriteLine(ConsoleColor.Green, "Listing migrations from Folder {0} and connection {1}", settings.MigrationFolder, settings.Connection);
                Logger.WriteLine("    Current Version: {0}", migrator.CurrentVersion);
                int counter = 0;
                foreach(var migration in migrator.Migrations)
                {
                    counter++;
                    bool isCurrent = migrator.CurrentVersion == counter;
                    var msg = string.Format("    {0}: {1}{2}", counter, migration.Key, isCurrent ? " (current)" : string.Empty);
                    if (isCurrent)
                        Logger.WriteLine(ConsoleColor.Green, msg);
                    else
                        Logger.WriteLine("    {0}: {1}", counter, migration.Key);
                }
                return;
            }

            // Execute
            if(settings.Command == Command.Goto)
            {
                Logger.WriteLine(ConsoleColor.Green, "Executing migrations from Folder {0} and connection {1}", settings.MigrationFolder, settings.Connection);

                var destinationVersion = DetermineVersion(settings, migrator);
                destinationVersion = Math.Min(destinationVersion, migrator.Migrations.Count);
                Logger.WriteLine("    Current Version: {0}", migrator.CurrentVersion);
                Logger.WriteLine("    Going to Version: {0}", destinationVersion);

                migrator.Migrate(destinationVersion);
                Logger.WriteLine(ConsoleColor.Yellow, "Migrations successful");
            }
        }

        public void migration_must_be_done_in_a_lock()
        {
            using (Sequence.Create())
            {
                Mock<ISupplyMigrations> source = SetupSource();

                Mock<ICommandDatabases> handler =
                    SetupHandler(new DatabaseVersion { Type = DatabaseVersionType.VersionNumber, Number = "-1" });
                Mock<ICompareMigrations> comparer = SetupComparer();

                Mock<ILocker> locker = SetupLocker();

                locker.Setup(x => x.Lock()).InSequence(Times.Exactly(1));
                handler.Setup(x => x.ExecuteMigration(It.IsAny<Migration>())).InSequence(Times.Exactly(2));
                locker.Setup(x => x.Release()).InSequence(Times.Exactly(1));

                var migrator = new Migrator(source.Object, comparer.Object, handler.Object, locker.Object);
                migrator.Migrate();
                handler.Verify(h => h.Create(), Times.Never);
                handler.Verify(h => h.CreateMigrationHistoryTable(), Times.Never);
            }
        }

 public void migrate_with_full_connection_string()
 {
     database = "db_" + Guid.NewGuid().ToString("N");
     var migrator = new Migrator(SetupSource().Object, new NumberComparer(),
         new SqlServerCommander(CreateDatabaseConnection));
     migrator.Migrate();
     using (IDbConnection connection = CreateConnection())
     {
         connection.Open();
         using (IDbCommand cmd = connection.CreateCommand())
         {
             cmd.CommandText = string.Format("select count(*) from sys.databases where name='{0}'", database);
             object result = cmd.ExecuteScalar();
             Assert.AreEqual(1, result);
         }
     }
 }