public AccessSchemaProvider(IConnectionProvider connectionProvider)
		{
			if (connectionProvider == null)
				throw new ArgumentNullException("connectionProvider");

			_connectionProvider = connectionProvider;
		}

 public GetCitiesNames(
     IConnectionProvider connectionProvider, 
     IEventAggregator eventAggregator)
 {
     _connectionProvider = connectionProvider;
     _eventAggregator = eventAggregator;
 }

    protected virtual string Execute(IQuery query,
      IDictionary<string, string> parameters, IConnectionProvider provider) {
      using (IDbConnection connection = provider.CreateConnection())
      using (var builder = new CommandBuilder(connection)) {
        builder
          .SetText(query.QueryText)
          .SetType(GetCommandType(query.Options))
          .SetTimeout(query.Options
            .GetInteger(Strings.kCommandTimeoutOption, 30));

        BindParameters(builder, query.Parameters, parameters);

        string preferred_json_collection = query.Options
          .GetString(Strings.kJsonCollectionOption,
            Strings.kDefaultJsonCollection);

        IDbCommand cmd = builder.Build();
        connection.Open();
        string response =
          (query.QueryMethod == QueryMethod.Get)
            ? ExecuteReader(cmd, query, preferred_json_collection)
            : ExecuteNonQuery(cmd, query, preferred_json_collection);
        connection.Close();
        return response;
      }
    }

 public ClusterHeartBeat(Cluster cluster, IConnectionProvider provider, TimeSpan pollingInterval)
 {
     Cluster = cluster;
     NodeChecks = new Dictionary<INode, IFixedSizeStack<ConnectivityCheck>>();
     ConnectionProvider = provider;
     PollingInterval = pollingInterval;
 }

 /// <summary>Executes <see cref="UpdateStatement"/>. Bulk updates are executed in multiple round trips - one update at a time.</summary>
 public int Execute(UpdateStatement update, DbmsType dbms, IConnectionProvider conn, out CommandExecutionStatistics lastExecutedCommandInfo, int cmdTimeout = 30)
 {
     if (IsBulkUpdate(update))
         return ExecuteBulkUpdate(update, dbms, conn, out lastExecutedCommandInfo, cmdTimeout);
     else
         return ExecuteSingleTableUpdate(update, dbms, conn, out lastExecutedCommandInfo, cmdTimeout);
 }

 public GetReservationsForUser(
     IConnectionProvider connectionProvider, 
     IEventAggregator eventAggregator)
 {
     _connectionProvider = connectionProvider;
     _eventAggregator = eventAggregator;
 }

 private ISchemaProvider GetExpectedSchemaProvider(IConnectionProvider connectionProvider)
 {
     var serverVersion = GetServerVersion(connectionProvider);
     if (!string.IsNullOrEmpty(serverVersion) && serverVersion.StartsWith("5"))
         return new MysqlSchemaProvider(connectionProvider, new MysqlSchemaDataProvider50(connectionProvider));
     return new MysqlSchemaProvider(connectionProvider, new MysqlSchemaDataProvider40(connectionProvider));
 }

        public override bool TryGetProvider(string connectionString, out IConnectionProvider provider, out Exception exception)
        {
            try
            {
                var _ = new SqlConnectionStringBuilder(connectionString);
            }
            catch (KeyNotFoundException ex)
            {
                exception = ex;
                provider = null;
                return false;
            }
            catch (FormatException ex)
            {
                exception = ex;
                provider = null;
                return false;
            }
            catch (ArgumentException ex)
            {
                exception = ex;
                provider = null;
                return false;
            }

            provider = new SqlConnectionProvider(connectionString);
            exception = null;
            return true;
        }

 private static IEntityDAO GetDao(IConnectionProvider conn, IEntity entity, IEntityDaoFactory daoFactory)
 {
     if (daoFactory != null)
         return daoFactory.GetEntityDAO(entity, conn);
     else
         return DefaultDaoFactory.GetEntityDAO(entity, conn);
 }

 public void SetUp()
 {
     provider = MockRepository.GenerateMock<IConnectionProvider>();
     connection = MockRepository.GenerateMock<IDbConnection>();
     command = MockRepository.GenerateMock<IDbCommand>();
     reader = MockRepository.GenerateMock<IDataReader>();
 }

		public ESSession(IConnectionProvider connectionProvider)
		{
			if (Current != null)
				throw new ElasticSearchException("Cannot create a new session while there is one already active.");
			ConnectionProvider = connectionProvider;
			Current = this;
		}

 private static bool EnsureOpenConnection(IConnectionProvider conn)
 {
     bool connIsOpennedLocally = !conn.IsOpen;
     if (connIsOpennedLocally)
         conn.OpenConnection();
     return connIsOpennedLocally;
 }

        /// <summary>
        /// Creates and executes query using the given ConnectionProvider.
        /// </summary>
        /// <param name="conn">Connection provider.</param>
        /// <param name="cmdText">Command text.</param>
        /// <param name="parameters">Command parameters.</param>
        /// <param name="cmdType">Command type (stored procedure or text).</param>
        /// <param name="cmdTimeout">Set timeout for specified command.</param>
        /// <param name="dataTableName">Name of the datatable that will be returned. May be null.</param>
        /// <returns>DataTable containing retrieved data.</returns>
        public static DataTable ExecuteQuery(IConnectionProvider conn, string cmdText, DbParameterCollection parameters, CommandType cmdType, string dataTableName, int cmdTimeout)
        {
            IDbCommand cmd = CreateCommand(conn.DBMS, cmdText, parameters, cmdType, cmdTimeout);
            cmd.Connection = conn.Connection;
            IDataAdapterBuilder builder = DbmsComponentFactory.GetComponent<IDataAdapterBuilder>(conn.DBMS);
            IDataAdapter adapter = builder.BuildAdapter(cmd);
            bool connIsOpennedLocally = EnsureOpenConnection(conn);
            try
            {
                AssignExistingPendingTransactionToCommand(conn, cmd);

                // Execute query.
                DataSet data = new DataSet();
                data.Locale = CultureInfo.InvariantCulture;
                adapter.Fill(data);
                PopulateOutputParameterValues(parameters, cmd);

                DataTable table = (data.Tables.Count > 0)
                    ? data.Tables[0]
                    : new DataTable() { Locale = CultureInfo.InvariantCulture };
                if (!string.IsNullOrEmpty(dataTableName))
                    table.TableName = dataTableName;

                return table;
            }
            finally
            {
                CloseConnectionIfLocal(conn, connIsOpennedLocally);
                cmd.Dispose();
                IDisposable disposableAdapter = adapter as IDisposable;
                if (disposableAdapter != null)
                    disposableAdapter.Dispose();
            }
        }

 public FlumeSession(IConnectionProvider connectionProvider)
 {
     if (Current != null)
         throw new BrokenCollectorException("Cannot create a new session while there is one already active.");
     ConnectionProvider = connectionProvider;
     Current = this;
 }

 public AttributeTypeRepository(IConnectionProvider connectionProvider, IDataTypeConverter dataTypeConverter,
                                IEntityAttributeTypeRepository entityAttributeTypeRepository)
 {
     _connectionProvider = connectionProvider;
     _dataTypeConverter = dataTypeConverter;
     _entityAttributeTypeRepository = entityAttributeTypeRepository;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AgentUpdater"/> class.
 /// </summary>
 /// <param name="connectionProvider">The connection provider.</param>
 /// <param name="versionProvider">The version provider.</param>
 /// <param name="updateSource">The update source.</param>
 /// <param name="agents">The agents.</param>
 /// <param name="log">The log.</param>
 public AgentUpdater(IConnectionProvider connectionProvider, IVersionProvider versionProvider, IUpdateSource updateSource, AgentsCollection agents, ILog log)
 {
     this.connectionProvider = connectionProvider;
     this.versionProvider = versionProvider;
     this.updateSource = updateSource;
     this.agents = agents;
     this.log = log;
 }

 public MigrationInitializer(IConfiguration configuration, IDatabaseProvider databaseProvider, ISchemaProvider schemaProvider, ICommonTransformations commonTransformations, IConnectionProvider connectionProvider)
 {
   _configuration = configuration;
   _commonTransformations = commonTransformations;
   _databaseProvider = databaseProvider;
   _schemaProvider = schemaProvider;
   _connectionProvider = connectionProvider;
 }

 internal AdoAdapter(IConnectionProvider connectionProvider) : this()
 {
     _connectionProvider = connectionProvider;
     _schema = DatabaseSchema.Get(_connectionProvider, _providerHelper);
     _relatedFinder = new Lazy<AdoAdapterRelatedFinder>(CreateRelatedFinder);
     _commandOptimizer = ProviderHelper.GetCustomProvider<CommandOptimizer>(_connectionProvider) ??
                         new CommandOptimizer();
 }

 public SearchConnections(
     IConnectionProvider connectionProvider,
     IEventAggregator eventAggregator,
     ConnectionsSearchData connectionsSearchData)
 {
     _connectionProvider = connectionProvider;
     _eventAggregator = eventAggregator;
     _connectionsSearchData = connectionsSearchData;
 }

 public RemoveReservation(
     IConnectionProvider connectionProvider,
     RESERVATION reservationToRemove, 
     IEventAggregator eventAggregator)
 {
     _connectionProvider = connectionProvider;
     _reservationToRemove = reservationToRemove;
     _eventAggregator = eventAggregator;
 }