public bool HasSubscriptionStructures(DataSource source) { using (DatabaseConnectionFactory.Create(source)) { return DatabaseGateway.GetScalarUsing<int>(source, SubscriptionQueries.HasSubscriptionStructures()) == 1; } }
public IDbConnectionConfiguration Get(DataSource dataSource) { Guard.AgainstNull(dataSource, "dataSource"); if (!dbConnectionConfigurations.ContainsKey(dataSource.Key)) { lock(padlock) { if (!dbConnectionConfigurations.ContainsKey(dataSource.Key)) { var settings = ConfigurationManager.ConnectionStrings[dataSource.Name]; if (settings == null) { throw new InvalidOperationException( string.Format(DataResources.ConnectionStringMissing, dataSource.Name)); } dbConnectionConfigurations.Add(dataSource.Key, new DbConnectionConfiguration(dataSource, settings.ProviderName, settings.ConnectionString)); } } } return dbConnectionConfigurations[dataSource.Key]; }
public IDbConnection CreateConnection(DataSource source) { var dbConnectionConfiguration = _dbConnectionConfigurationProvider.Get(source); if (!_dbProviderFactories.ContainsKey(source.Key)) { lock(padlock) { if (!_dbProviderFactories.ContainsKey(source.Key)) { var factory = DbProviderFactories.GetFactory(dbConnectionConfiguration.ProviderName); _dbProviderFactories.Add(source.Key, factory); _log.Verbose(string.Format(DataResources.DbProviderFactoryCached, dbConnectionConfiguration.ProviderName)); } } } var dbProviderFactory = _dbProviderFactories[source.Key]; var connection = dbProviderFactory.CreateConnection(); connection.ConnectionString = dbConnectionConfiguration.ConnectionString; _log.Verbose(string.Format(DataResources.DbConnectionCreated, source.Name)); return connection; }
public IDbConnectionConfiguration Get(DataSource source) { Guard.AgainstNull(source, "source"); var settings = ConfigurationManager.ConnectionStrings[source.Name]; if (settings != null) { return new DbConnectionConfiguration(source, settings.ProviderName, settings.ConnectionString); } foreach (var provider in dbConnectionConfigurationProviders) { var configuration = provider.Get(source); if (configuration == null) { continue; } return configuration; } throw new InvalidOperationException( string.Format( "The required connection string with name '{0}' is not specified in the application configuration file and has not been registered with any of the providers.", source.Name)); }
public IDbCommand CreateCommandUsing(DataSource source, IDbConnection connection, IQuery query) { var command = connection.CreateCommand(); command.CommandTimeout = commandTimeout; query.Prepare(source, command); return command; }
public DbConnectionConfiguration(DataSource dataSource, string providerName, string connectionString) { Guard.AgainstNull(dataSource, "dataSource"); Guard.AgainstNullOrEmptyString(providerName, "providerName"); Guard.AgainstNullOrEmptyString(connectionString, "connectionString"); Name = dataSource.Name; ProviderName = providerName; ConnectionString = connectionString; }
public IDatabaseConnection Add(DataSource source, IDatabaseConnection connection) { Infrastructure.Guard.AgainstNull(connection, "connection"); Guard(); connections.Add(source.Key, connection); return connection; }
public IDatabaseConnection Get(DataSource source) { Guard(); if (!connections.ContainsKey(source.Key)) { throw new ApplicationException(string.Format(DataResources.ThreadStaticDatabaseConnectionCacheMissingEntry, source.Name)); } return connections[source.Key]; }
public void Prepare(DataSource source, IDbCommand command) { Guard.AgainstNull(source, "source"); Guard.AgainstNull(command, "command"); command.CommandText = procedure; command.CommandType = CommandType.StoredProcedure; foreach (var pair in parameterValues) { command.Parameters.Add(pair.Key.CreateDataParameter(source.DbDataParameterFactory, pair.Value)); } }
public IDatabaseConnection Create(DataSource source) { if (_databaseConnectionCache.Contains(source)) { var existingDatabaseConnection = new ExistingDatabaseConnection(_databaseConnectionCache.Get(source)); _log.Verbose(string.Format(DataResources.ExistingDatabaseConnectionReturned, source.Name)); return existingDatabaseConnection; } var databaseConnection = new DatabaseConnection(source, _dbConnectionFactory.CreateConnection(source), _dbCommandFactory, _databaseConnectionCache); _log.Verbose(string.Format(DataResources.DatabaseConnectionCreated, source.Name)); return databaseConnection; }
public IDbConnectionConfiguration Get(DataSource source) { try { var store = managementConfiguration.DataStoreRepository().Get(source.Name); return store == null ? null : new DbConnectionConfiguration(source, store.ProviderName, store.ConnectionString); } catch { return null; } }
public DatabaseConnection(DataSource dataSource, IDbConnection connection, IDbCommandFactory dbCommandFactory, IDatabaseConnectionCache databaseConnectionCache, bool ownedConnection = true, IDbTransaction currentTransaction = null) { Guard.AgainstNull(dataSource, "dataSource"); Guard.AgainstNull(connection, "connection"); Guard.AgainstNull(dbCommandFactory, "dbCommandFactory"); Guard.AgainstNull(databaseConnectionCache, "databaseConnectionCache"); _dataSource = dataSource; _dbCommandFactory = dbCommandFactory; _databaseConnectionCache = databaseConnectionCache; Connection = connection; _ownedConnection = ownedConnection; Transaction = currentTransaction; _ownedTransaction = currentTransaction == null; _log = Log.For(this); _log.Verbose(string.Format(DataResources.DbConnectionCreated, dataSource.Name)); try { if (connection.State == ConnectionState.Closed) { Connection.Open(); _log.Verbose(string.Format(DataResources.DbConnectionOpened, dataSource.Name)); } else { _log.Verbose(string.Format(DataResources.DbConnectionAlreadyOpen, dataSource.Name)); } } catch (Exception ex) { _log.Error(string.Format(DataResources.DbConnectionOpenException, dataSource.Name, ex.Message)); throw; } databaseConnectionCache.Add(dataSource, this); }
public DataTable All(DataSource source) { return DatabaseGateway.GetDataTableFor(source, ScheduleQueries.All()); }
public bool Contains(DataSource source) { Guard(); return connections.ContainsKey(source.Key); }
public DataTable MessageTypes(DataSource source, string uri) { return DatabaseGateway.GetDataTableFor(source, SubscriptionQueries.MessageTypes(uri)); }
public DataTable All(DataSource source) { return DatabaseGateway.GetDataTableFor(source, SubscriptionRequestQueries.All()); }
public void Remove(DataSource source) { Guard(); connections.Remove(source.Key); }
public DataTable AllUris(DataSource source) { return DatabaseGateway.GetDataTableFor(source, SubscriptionQueries.AllUris()); }
public bool HasScheduleStructures(DataSource source) { return _databaseGateway.GetScalarUsing<int>(source, _queryFactory.HasScheduleStructures()) == 1; }