public static IConfigureHost WithSqlStorages(this IConfigureHost host,IDbFactory connection ,Action<StoragesConfiguration> cfgAction)
 {
     cfgAction.MustNotBeNull();
     var cfg=new StoragesConfiguration(host,connection);
     cfgAction(cfg);
     return host;
 }

		protected override ConnectionSettingsWidget CreateConnectionSettingsWidget (IDbFactory factory)
		{
			connectionWidget = new ConnectionSettingsWidget (factory);
			connectionWidget.ShowSettings (factory.GetDefaultConnectionSettings ());
			connectionWidget.EnableTestButton = false;
			return connectionWidget;
		}

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

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

		protected void SetUp(IDbFactory dbFactory)
		{
			this.Factory = dbFactory;
			this.Connection = this.Factory.CreateConnection(IntegrationTestOptions.Oracle.ConnectionString);
			this.Processor = new OracleProcessor(this.Connection, new OracleGenerator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions(), this.Factory);
			this.Connection.Open();
		}

		public NpgsqlCreateDatabaseDialog (IDbFactory factory):base(factory)
		{
			createDBWidget = new NpgsqlCreateDatabaseWidget ();
			Notebook.AppendPage (createDBWidget, 
			                     new Label (AddinCatalog.GetString ("Database Properties")));
			Notebook.ShowTabs = true;
			Gtk.Notebook nb = Notebook;
			
			nb.SwitchPage += delegate(object o, SwitchPageArgs args) {
				if (nb.CurrentPage == 1)
					if (!connectionWidget.ValidateFields ())
					{
						nb.CurrentPage = 0;
						MessageService.ShowError (this, 
							AddinCatalog.GetString ("Set the connection properties before the database properties."));
					} else {
						Initialize (factory);
						if (DatabaseConnection.ConnectionPool.HasErrors) {
							MessageService.ShowError (DatabaseConnection.ConnectionPool.Error);
							nb.CurrentPage = 0;
							return;
						}
						createDBWidget.Initialize ((NpgsqlSchemaProvider)DatabaseConnection.SchemaProvider);
					}
			};
			
			Notebook.ShowAll ();
		}

 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 DatabaseConnectionSettingsDialog (IDbFactory factory, DatabaseConnectionSettings settings)
			: this (factory, true)
		{
			if (settings == null)
				throw new ArgumentNullException ("settings");

			settingsWidget.ShowSettings (settings);
			settingsWidget.AppendDatabase (settings);
		}

        public UnitOfWork(IDbFactory dbFactory)
        {
            if (dbFactory == null)
            {
                throw new ArgumentNullException("dbFactory");
            }

            _dbFactory = dbFactory;
        }

		internal SqliteConnectionSettingsWidget (IDbFactory factory, bool isEditMode)
			: base (factory, isEditMode)
		{
			EnableServerEntry = false;
			EnablePortEntry = false;
			EnableUsernameEntry = false;
			EnablePasswordEntry = false;
			EnableRefreshButton = false;
			EnableOpenButton = true;
		}

        public DbDatabasePopulator(IDbFactory dbFactory, string connectionString)
        {
            if (dbFactory == null)
                throw new ArgumentNullException("dbFactory");
            if (connectionString == null)
                throw new ArgumentNullException("connectionString");

            this.dbFactory = dbFactory;
            this.connectionString = connectionString;
        }

        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();
        }

		private void Initialize (IDbFactory factory)
		{
			if (DatabaseConnection != null)
				DatabaseConnection.ConnectionPool.Close ();
			DatabaseConnectionSettings settings = new DatabaseConnectionSettings(connectionWidget.ConnectionSettings);
			settings.Database = "mysql"; 
			// Create Context, Pool, Connection 
			DatabaseConnectionContext ctx = new DatabaseConnectionContext (settings, true);
			ctx.ConnectionPool.Initialize ();
			this.DatabaseConnection = ctx;
		}

        public static void ReceiveFromClientsBySql(this DispatchServerConfiguration cfg,IDbFactory connection,string table=CommunicatorTable,string dbSchema=CommunicatorSchema)
        {
            new ClientToServerRowCreator(connection).WithTableName(table, dbSchema).IfExists(TableExistsAction.Ignore).Create();
            var configReceiver = new ConfigReceiver(connection);
           
            cfg.EndpointUpdatesNotifier=configReceiver;

            var fromClient = new ReceiverFromClient(connection);
           
            cfg.MessageNotifier = fromClient;
        }

		/// <summary>
		/// Initializes an instance of <see cref="DbAdministratorBase"/> with the connection string.
		/// </summary>
		/// <param name="connectionString">Connection string to the SQL server without initial catalog</param>
		/// <param name="databaseName">Catalog name</param>
        /// <param name="factory">The factory to use.</param>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="connectionString"/> is a null reference (Nothing in Visual Basic)
		/// </exception>
        public DbAdministratorBase(string connectionString, string databaseName, IDbFactory factory)
        {
			if (connectionString==null)
				throw new ArgumentNullException("connectionString");
			if (databaseName==null)
				throw new ArgumentNullException("databaseName");
			if(factory==null)
				throw new ArgumentNullException("factory");
			this.connectionString=connectionString.TrimEnd(';');
			this.databaseName=databaseName;
			this.factory=factory;
		}

		public CreateDatabaseDialog (IDbFactory factory)
		{
			this.Build();
			
			settingsWidget = CreateConnectionSettingsWidget (factory);
			vboxConnection.PackStart (settingsWidget, true, true, 0);
			
			settingsWidget.NeedsValidation += Validate;
			settingsWidget.EnableRefreshButton = false;
			
			ShowAll ();
		}

        bool IGuiProvider.ShowEditConnectionDialog(IDbFactory factory, DatabaseConnectionSettings settings, out DatabaseConnectionSettings newSettings)
        {
            DatabaseConnectionSettingsDialog dlg = new  DatabaseConnectionSettingsDialog(factory, settings);
            bool result = RunDialog (dlg);
            if (result)
                newSettings = dlg.ConnectionSettings;
            else
                newSettings = null;

            Console.WriteLine("start edit connection dialog");
            return result;
        }

        public OracleTestTable(string table, IDbConnection connection, string schema, IDbFactory factory, params string[] columnDefinitions)
        {
            Connection = connection;
            Factory = factory;
            _schema = schema;

            if (Connection.State != ConnectionState.Open)
                Connection.Open();

            Name = table;
            Create(columnDefinitions);
        }

		
		public bool ShowEditConnectionDialog (IDbFactory factory, 
		                                      DatabaseConnectionSettings settings, 
		                                      out DatabaseConnectionSettings newSettings)
		{
			DatabaseConnectionSettingsDialog dlg = new DatabaseConnectionSettingsDialog (factory, settings);
			bool result = RunDialog (dlg);
			if (result)
				newSettings = dlg.ConnectionSettings;
			else
				newSettings = null;
			return result;

        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;
        }