public void UpgradeDatabase()
        {
            var assembly = System.Reflection.Assembly.GetExecutingAssembly();
            var announcer = new TextWriterAnnouncer(s => Log.Debug(s));
            var context = new RunnerContext(announcer)
            {
                Namespace = "Causal.Server.Migrations"
            };

            var providerName = ConfigurationManager.ConnectionStrings["CausalContext"].ProviderName;
            MigrationProcessorFactory factory;
            if (providerName.Equals("Npgsql", StringComparison.InvariantCultureIgnoreCase))
            {
                factory = new FluentMigrator.Runner.Processors.Postgres.PostgresProcessorFactory();
            }
            else if (providerName.Equals("System.Data.SqlClient", StringComparison.InvariantCultureIgnoreCase))
            {
                factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
            }
            else
            {
                throw new Exception("Unknown provider for connection string CausalContext");
            }

            var options = new ProcessorOptions { PreviewOnly = false };
            var processor = factory.Create(ConfigurationManager.ConnectionStrings["CausalContext"].ConnectionString, announcer, options);
            var migrator = new MigrationRunner(assembly, context, processor);

            migrator.MigrateUp(true);
        }

        public static void RunMigrations(string connectionString, string migration)
        {
            // var announcer = new NullAnnouncer();
            var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
            var assembly = Assembly.GetExecutingAssembly();

            var migrationContext = new RunnerContext(announcer)
            {
                Namespace = "Azimuth.Migrations",
                WorkingDirectory = "Migrations"
            };

            var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
            var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
            var processor = factory.Create(connectionString, announcer, options);
            var runner = new MigrationRunner(assembly, migrationContext, processor);

            switch (migration)
            {
                case "Run migrations":
                    runner.MigrateUp(true);
                    break;
                case "Drop all tables":
                    runner.RollbackToVersion(201408091845);
                    runner.Rollback(1);
                    break;
            }
        }

        public static void Run(IContainer settingsContainer)
        {
            var connectionString = settingsContainer.GetInstance<string>("DefaultConnection");

            Announcer announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
            announcer.ShowSql = true;

            Assembly assembly = typeof(CreateTableEstacionamento).Assembly;

            IRunnerContext migrationContext = new RunnerContext(announcer);

            var options = new ProcessorOptions
            {
                PreviewOnly = false,  // set to true to see the SQL
                Timeout = 60
            };

            try
            {
                var factory = settingsContainer.GetInstance<MigrationProcessorFactory>(); //new FluentMigrator.Runner.Processors.SQLite.SQLiteProcessorFactory();
                var processor = factory.Create(connectionString, announcer, options);

                var runner = new MigrationRunner(assembly, migrationContext, processor);
                runner.MigrateUp(true);
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException("connectionString: " + connectionString, ex);
            }
        }

        public void StartMigration()
        {
            var consoleAnnouncer = new TextWriterAnnouncer(System.Console.Out)
                                        {
                                            ShowElapsedTime = true,
                                            ShowSql = true
                                        };
             var runnerContext = new RunnerContext(consoleAnnouncer)
             {

                 Database= DataBaseType,
                 Connection=connStr,
                 Target=assemblyPath,
                 PreviewOnly= false,
                 Namespace=string.Empty,
                 Task=string.Empty,
                 Version=0,
                 Steps=1,
                 WorkingDirectory = currentPath,
                 Profile=string.Empty,
                 Timeout=0,
                 ConnectionStringConfigPath=string.Empty
             };
             TaskExecutor tskMigration = new TaskExecutor(runnerContext);
             tskMigration.Execute();
        }

 public void Rollback(bool showSql = false)
 {
     using (var announcer = new TextWriterAnnouncer(Console.Out) { ShowSql = showSql })
     {
         var runner = CreateRunner(announcer);
         runner.RollbackToVersion(0);
     }
 }

 public void MigrateToLatest(bool showSql = false)
 {
     using (var announcer = new TextWriterAnnouncer(Console.Out) { ShowSql = showSql })
     {
         var runner = CreateRunner(announcer);
         runner.MigrateUp();
     }
 }

 public Migrator(DatabaseConfig databaseConfig)
 {
     _databaseConfig = databaseConfig;
     NamespaceContainingMigrations = "Habanero.Test.Migrations";
     AssemblyContainingMigrations = Assembly.GetExecutingAssembly();
     MigrationProcessorFactory = GetMigrationProcessorFactory(databaseConfig);
     Announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
     _databaseInitialiser = new DatabaseInitialiser(databaseConfig);
 }

 public void SetUp()
 {
     _stringWriter = new StringWriter();
     _announcer = new TextWriterAnnouncer(_stringWriter)
                      {
                          ShowElapsedTime = true,
                          ShowSql = true
                      };
 }

 public void Migrate(Action<IMigrationRunner> runnerAction)
 {
     var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 };
     var factory = new FluentMigrator.Runner.Processors.MigrationProcessorFactoryProvider().GetFactory(_dbType);
     var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
     var migrationContext = new RunnerContext(announcer);
     var processor = factory.Create(_connectionString, announcer, options);
     var runner = new MigrationRunner(_migrationAssembly, migrationContext, processor);
     runnerAction(runner);
 }

 public void Migrate(Action<IMigrationRunner> runnerAction)
 {
     var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 };
     var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
     var assembly = Assembly.GetExecutingAssembly();
     var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
     var migrationContext = new RunnerContext(announcer);
     var processor = factory.Create(this._connectionString, announcer, options);
     var runner = new MigrationRunner(assembly, migrationContext, processor);
     runnerAction(runner);
 }

 private static TaskExecutor MakeTask(string task)
 {
     var announcer = new TextWriterAnnouncer(System.Console.Out);
     var runnerContext = new RunnerContext(announcer)
     {
         Database = "Firebird",
         Connection = IntegrationTestOptions.Firebird.ConnectionString,
         Targets = new[] { Assembly.GetExecutingAssembly().Location },
         Namespace = "FluentMigrator.Tests.Integration.Migrations.Firebird.FirstVersion",
         Task = task,
     };
     return new TaskExecutor(runnerContext);
 }

 protected TaskExecutor MakeTask(string task, string migrationsNamespace)
 {
     var announcer = new TextWriterAnnouncer(System.Console.Out);
     var runnerContext = new RunnerContext(announcer)
     {
         Database = "Firebird",
         Connection = IntegrationTestOptions.Firebird.ConnectionString,
         Targets = new[] { Assembly.GetExecutingAssembly().Location },
         Namespace = migrationsNamespace,
         Task = task
     };
     return new TaskExecutor(runnerContext);
 }

 IMigrationProcessor InitializeProcessor()
 {
     dynamic options = _configuration.MigrationEngineOptions;
     writer = new StringWriter();
     var announcer = new TextWriterAnnouncer(writer);
     var processorFactory = ProcessorFactory.GetFactory(options.DatabaseType);
     var processor = processorFactory.Create(_configuration.ConnectionString,announcer, new ProcessorOptions
     {
         PreviewOnly = false,
         Timeout = options.Timeout
     });
     return processor;
 }

        public static void MigrateToLatest()
        {
            var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
            var migrationAssembly=  Assembly.GetExecutingAssembly();
            var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
            var migrationContext = new RunnerContext(announcer);
            var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
            var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 };
            var processor = factory.Create(connectionString, announcer, options);

            var runner = new MigrationRunner(migrationAssembly, migrationContext, processor);
            runner.MigrateUp();
        }

        public void MigrateToLatest()
        {
            var announcer = new TextWriterAnnouncer(s => Debug.WriteLine(s));
            var assembly = Assembly.GetExecutingAssembly();

            var migrationContext = new RunnerContext(announcer);
            var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
            var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory();
            using (var processor = factory.Create(connectionString, announcer, options))
            {
                var runner = new MigrationRunner(assembly, migrationContext, processor);
                runner.MigrateUp(true);
            }
        }

        protected static void ExecuteWithSqlServer2014(Action<IMigrationProcessor> test, bool tryRollback)
        {

            var serverOptions = IntegrationTestOptions.SqlServer2014;

            if (!serverOptions.IsEnabled)
                return;

            var announcer = new TextWriterAnnouncer(System.Console.Out);
            announcer.Heading("Testing Migration against MS SQL Server 2014");
            var generator = new SqlServer2014Generator();

            ExecuteWithSqlServer(serverOptions, announcer, generator, test, tryRollback);
        }

        protected static void ExecuteWithMySql(Action<IMigrationProcessor> test, IntegrationTestOptions.DatabaseServerOptions serverOptions)
        {
            if (!serverOptions.IsEnabled)
                return;

            var announcer = new TextWriterAnnouncer(System.Console.Out);
            announcer.Heading("Testing Migration against MySQL Server");

            using (var connection = new MySqlConnection(serverOptions.ConnectionString))
            {
                var processor = new MySqlProcessor(connection, new MySqlGenerator(), announcer, new ProcessorOptions(), new MySqlDbFactory());
                test(processor);
            }
        }

        public Migrator(string connectionString, params Assembly[] assemblies)
        {
            var announcer = new TextWriterAnnouncer(Console.Write);

            IAssemblyCollection assemblyCollection = new AssemblyCollection(assemblies);

            var migrationContext = new RunnerContext(announcer);

            var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 };
            PostgresProcessorFactory factory = new PostgresProcessorFactory();

            IMigrationProcessor processor = factory.Create(connectionString, announcer, options);
            runner = new MigrationRunner(assemblyCollection, migrationContext, processor);
        }

        public void MigrateToLatest()
        {
            var asm = Assembly.GetExecutingAssembly();
            var announcer = new TextWriterAnnouncer((str) =>
            {
                Debug.WriteLine(str);
            });
            var context = new RunnerContext(announcer);
            var options = new MigrationOptions();
            var factory = new SqlServer2012ProcessorFactory();
            var processor = factory.Create(this._connectionString, announcer, options);
            var runner = new MigrationRunner(asm, context, processor);

            runner.MigrateUp(true);
        }

        private void Execute(string task)
        {
            tbAnnouncer.Clear();

            var version = (int)numVersion.Value;
            var steps = (int)numSteps.Value;
            var tags = new List<string>();
            var profile = tbProfile.Text;
            foreach (var item in lbTags.SelectedItems)
            {
                tags.Add(item.ToString());
            }

            var announcer = new TextWriterAnnouncer(new TextBoxStreamWriter(tbAnnouncer));
            announcer.Heading("Migrate database");

            var runnerContext = new RunnerContext(announcer)
            {
                Database = "SqlServer2008",
                Connection = ConfigurationManager.ConnectionStrings["FluentMigrator"].ConnectionString,

                Target = "DatabaseProject.dll",
                PreviewOnly = false,
                Namespace = "DatabaseProject",
                NestedNamespaces = true,
                Task = task,
                Version = version,
                Steps = steps,
                Tags = tags,
                //WorkingDirectory = "C:\\temp",
                Profile = profile,
                Timeout = 30,
                TransactionPerSession = true
            };

            var executor = new TaskExecutor(runnerContext);


            try
            {
                executor.Execute();
            }
            catch (Exception ex)
            {
                tbAnnouncer.AppendText("Exception: " + ex.Message);
            }

        }