public SqlServerProcessor(SqlConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
     : base(generator, announcer, options)
 {
     Connection = connection;
     connection.Open();
     Transaction = connection.BeginTransaction();
 }

 public PostgresProcessor(NpgsqlConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
     : base(generator, announcer, options)
 {
     Connection = connection;
     connection.Open();
     Transaction = connection.BeginTransaction();
 }

 public JetProcessor(OleDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
     : base(generator, announcer, options)
 {
     Connection = connection;
     connection.Open();
     BeginTransaction();
 }

 protected GenericProcessorBase(IDbConnection connection, IDbFactory factory
                                , IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
     : base(generator, announcer, options)
 {
     Connection = connection;
     Factory = factory;
 }

 public override IMigrationProcessor Create(string connectionString, IAnnouncer announcer, IMigrationProcessorOptions options)
 {
     var factory = new MigrationDbFactory();
     var connection = factory.CreateConnection(connectionString);
     var generator = new SqliteGenerator() { compatabilityMode = CompatabilityMode.STRICT };
     return new NzbDroneSqliteProcessor(connection, generator, announcer, options, factory);
 }

 public AzureProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
     : base(generator, announcer, options)
 {
     this.factory = factory;
      Connection = connection;
      connection.Open();
 }

        public override IMigrationProcessor Create(string connectionString, IAnnouncer announcer, IMigrationProcessorOptions options)
        {
            var factory = new HanaDbFactory();
            
            var connection = factory.CreateConnection(connectionString);

            return new HanaProcessor(connection, new HanaGenerator(), announcer, options, factory);
        }

        public HtmlValidatorRunnerContext(IAnnouncer announcer)
        {
            if (announcer == null)
                throw new ArgumentNullException("announcer");

            this.Announcer = announcer;
            this.TotalTimeStopwatch = StopwatchProvider.Current.NewStopwatch();
        }

 public SqlServerProcessor(DbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
     : base(generator, announcer, options)
 {
     this.factory = factory;
     Connection = connection;
     connection.Open();
     BeginTransaction();
 }

        public OracleProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
            : base(generator, announcer, options)
        {
            Connection = connection;

            //oracle does not support ddl transactions
            //this.Transaction = this.Connection.BeginTransaction();
        }

        public JetProcessor(OleDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
            : base(generator, announcer, options)
        {
            Connection = connection;

            // Prefetch connectionstring as after opening the security info could no longer be present
            // for instance on sql server
            connectionString = connection.ConnectionString;
        }

 public MigrationRunner(IMigrationConventions conventions, IMigrationProcessor processor, IAnnouncer announcer, IStopWatch stopWatch)
 {
     _announcer = announcer;
     SilentlyFail = false;
     CaughtExceptions = null;
     Conventions = conventions;
     Processor = processor;
     _stopWatch = stopWatch;
 }

        public PostgresProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
            : base(generator, announcer, options)
        {
            this.factory = factory;
            Connection = connection;
            connection.Open();

            Announcer.Say("Beginning Transaction");
            Transaction = Connection.BeginTransaction();
        }

 public ConnectionStringManager(INetConfigManager configManager, IAnnouncer announcer, string connection, string configPath, string assemblyLocation,
                                string database)
 {
     this.connection = connection;
     this.configPath = configPath;
     this.database = database;
     this.assemblyLocation = assemblyLocation;
     notUsingConfig = true;
     this.configManager = configManager;
     this.announcer = announcer;
 }

        public override IMigrationProcessor Create(string connectionString, IAnnouncer announcer, IMigrationProcessorOptions options)
        {
            var factory = new PostgresDbFactory();

            var connection =
                factory.CreateConnection(connectionString.StartsWith("pgpass=", StringComparison.OrdinalIgnoreCase)
                    ? GetPgConnectionString(connectionString)
                    : connectionString);

            return new PostgresProcessor(connection,
                new PostgresGenerator(LowerCaseIdentifiers(options.ProviderSwitches)), announcer, options, factory);
        }

        public static void Update(IAnnouncer announcer, MigrationProcessorType type, string connectionString, Assembly migrationAssembly)
        {
            var context = new RunnerContext(announcer);
            var options = new ProcessorOptions();

            var factory = GetProcessorFactory(type);
            var processor = factory.Create(connectionString, announcer, options);

            var runner = new MigrationRunner(migrationAssembly, context, processor);

            runner.MigrateUp();
        }

        protected GenericProcessorBase(IDbConnection connection, IDbFactory factory
                                       , IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
            : base(generator, announcer, options)
        {
            Connection = connection;

            // Prefetch connectionstring as after opening the security info could no longer be present
            // for instance on sql server
            connectionString = connection.ConnectionString;
            
            Factory = factory;
        }

 public MigrationVersionRunner(IMigrationConventions conventions, IMigrationProcessor processor, IMigrationLoader loader, Assembly assembly, string @namespace, IAnnouncer announcer)
 {
     _migrationConventions = conventions;
     _migrationProcessor = processor;
     _migrationAssembly = assembly;
     _migrationLoader = loader;
     _namespace = @namespace;
     _announcer = announcer;
     _migrationRunner = new MigrationRunner(conventions, processor, announcer, new StopWatch());
     _versionTableMetaData = loader.GetVersionTableMetaData(assembly);
     _versionMigration = new VersionMigration(_versionTableMetaData);
 }

        private static IMigrationProcessor BuildMigrationProcessor(string database, string connection, int timeout, IAnnouncer announcer, bool previewOnly)
        {
            var processorFactoryProvider = new MigrationProcessorFactoryProvider();
            var processorFactory = processorFactoryProvider.GetFactory(database);

            var processorOptions = new ProcessorOptions
            {
                Timeout = timeout,
                PreviewOnly = previewOnly
            };

            var processor = processorFactory.Create(connection, announcer, processorOptions);
            return processor;
        }

        private IMigrationVersionRunner CreateRunner(IAnnouncer announcer)
        {
            var migrationConventions = new MigrationConventions();
            var processor = ProcessorFactory.GetFactory(_databaseProvider)
                .Create(_connectionString, announcer, new ProcessorOptions { PreviewOnly = false });

            return new MigrationVersionRunner(new MigrationConventions(),
                                                    processor,
                                                    new MigrationLoader(migrationConventions),
                                                    typeof(M001InitialVersion).Assembly,
                                                    null,
                                                    announcer,
                                                    null);
        }