/// <summary>
/// Executes the body of a multi-statement transaction.
/// </summary>
/// <param name="transactionBody">The code to execute within the transaction</param>
void Exec(Action transactionBody)
{
bool connectionCreated = false;
try
{
if (Transaction == null)
{
lock (this)
{
if (Transaction == null)
{
Transaction = CreateCommandFactory(false);
connectionCreated = true;
}
}
}
transactionBody();
}
finally
{
if (connectionCreated)
{
Transaction.Complete();
Transaction = null;
}
}
}
public ValuesController(IQueryBuilder queryBuilder,
IDbConnectionFactory connectionFactory,
IDbCommandFactory commandFactory)
{
_queryBuilder = queryBuilder;
_connectionFactory = connectionFactory;
_commandFactory = commandFactory;
}
public GenericRepository(DbContext context, IDbCommandExecutionService dbCommandExecutionService,
IDbCommandFactory dbCommandFactory)
{
this.context = context;
this.dbSet = context.Set <TEntity>();
this.dbCommandExecutionService = dbCommandExecutionService;
this.dbCommandFactory = dbCommandFactory;
}
/// <summary>
/// Executes an INSERT, UPDATE, or DELETE statement.
/// </summary>
/// <param name="sql">The SQL to execute</param>
/// <returns>
/// The number of rows affected by the statement
/// </returns>
internal int ExecuteNonQuery(string sql)
{
using (IDbCommandFactory c = GetCommandFactory())
using (IDbCommand cmd = c.GetCommand(sql))
{
return(cmd.ExecuteNonQuery());
}
}
public static void Create(string connectionString, IDbCommandFactory commandFactory)
{
var sqlCommandTexts = ReadCreateDatabaseCommands();
var commands = sqlCommandTexts.Select(commandFactory.CreateCommand);
var sqlCommandExecutor = new DbCommandExecutor(new NullSqlCommandLogger(), commandFactory);
sqlCommandExecutor.ExecuteNonQuery(commands, connectionString);
}
public static void Create(string connectionString, IDbCommandFactory commandFactory)
{
var sqlCommandTexts = ReadCreateDatabaseCommands();
var commands = sqlCommandTexts.Select(commandFactory.CreateCommand);
var sqlCommandExecutor = new DbCommandExecutor(new NullSqlCommandLogger(), commandFactory);
sqlCommandExecutor.ExecuteNonQuery(commands, connectionString);
}
public void AppendTo(DbCommand command, IDbCommandFactory commandFactory)
{
if (IsEmpty)
{
return;
}
command.CommandText += " " + CommandString;
AppendParameters(command, commandFactory);
}
public void AppendTo(DbCommand command, IDbCommandFactory commandFactory)
{
if (IsEmpty)
{
return;
}
command.CommandText += " " + CommandString;
AppendParameters(command, commandFactory);
}
/// <summary>
/// Executes a query
/// </summary>
/// <typeparam name="T">The type of data produced by the query.</typeparam>
/// <param name="query">The query to be executed</param>
/// <returns>The rows (if any) that satisfy the query</returns>
/// <seealso cref="ExecuteSelect"/>
internal IEnumerable <T> ExecuteQuery <T>(IDataQuery <T> query)
{
using (IDbCommandFactory c = GetCommandFactory())
using (IDbCommand cmd = c.GetCommand(query.Text))
using (IDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
yield return(query.CreateInstance(reader));
}
}
}
private void InsertAtMarker(DbCommand command, string marker, IDbCommandFactory commandFactory, string prefix)
{
if (IsEmpty)
{
command.CommandText = command.CommandText.Replace(marker, "");
return;
}
command.CommandText = command.CommandText.Replace(marker, prefix + CommandString);
AppendParameters(command, commandFactory);
}
private void InsertAtMarker(DbCommand command, string marker, IDbCommandFactory commandFactory, string prefix)
{
if (IsEmpty)
{
command.CommandText = command.CommandText.Replace(marker, "");
return;
}
command.CommandText = command.CommandText.Replace(marker, prefix + CommandString);
AppendParameters(command, commandFactory);
}
public DatabaseContextFactory(IDbConnectionFactory dbConnectionFactory, IDbCommandFactory dbCommandFactory, IDatabaseContextCache databaseContextCache)
{
Guard.AgainstNull(dbConnectionFactory, "dbConnectionFactory");
Guard.AgainstNull(dbCommandFactory, "dbCommandFactory");
Guard.AgainstNull(databaseContextCache, "databaseContextCache");
_dbConnectionFactory = dbConnectionFactory;
_dbCommandFactory = dbCommandFactory;
_databaseContextCache = databaseContextCache;
DatabaseContext.Assign(databaseContextCache);
}
public DatabaseConnectionFactory(IDbConnectionFactory dbConnectionFactory, IDbCommandFactory dbCommandFactory,
IDatabaseConnectionCache databaseConnectionCache)
{
Guard.AgainstNull(dbConnectionFactory, "dbConnectionFactory");
Guard.AgainstNull(dbCommandFactory, "dbCommandFactory");
Guard.AgainstNull(databaseConnectionCache, "databaseConnectionCache");
_dbConnectionFactory = dbConnectionFactory;
_databaseConnectionCache = databaseConnectionCache;
_dbCommandFactory = dbCommandFactory;
_log = Log.For(this);
}
/// <summary>
/// Executes a query that is expected to return no more than one row.
/// </summary>
/// <typeparam name="T">The type of data in the query field.</typeparam>
/// <param name="sql">The query text</param>
/// <param name="defaultValue">The default value to be returned in cases
/// where nothing was found, or a database null was found.</param>
/// <returns>The selected value (or <paramref name="defaultValue"/> if not found)</returns>
/// <remarks>There is no error if the select actually relates to multiple rows
/// (in that case, you just get the first row that was selected).</remarks>
/// <seealso cref="ExecuteQuery"/>
internal T ExecuteSelect <T>(string sql, T defaultValue = default(T)) where T : IConvertible
{
using (IDbCommandFactory c = GetCommandFactory())
using (IDbCommand cmd = c.GetCommand(sql))
{
object o = cmd.ExecuteScalar();
if (o == null || o == DBNull.Value)
{
return(defaultValue);
}
return((T)Convert.ChangeType(o, typeof(T)));
}
}
public DataStoreDatabaseContextFactory(
IConnectionConfigurationProvider connectionConfigurationProvider,
IDbConnectionFactory dbConnectionFactory,
IDbCommandFactory dbCommandFactory,
IDatabaseContextCache databaseContextCache,
IDataStoreQuery dataStoreQuery)
: base(
connectionConfigurationProvider,
dbConnectionFactory,
dbCommandFactory,
databaseContextCache)
{
Guard.AgainstNull(dataStoreQuery, nameof(dataStoreQuery));
_dataStoreQuery = dataStoreQuery;
}
public void SetUp()
{
_commandFactory = Substitute.For <IDbCommandFactory>();
_logger = Substitute.For <ISqlCommandLogger>();
_executor = new DbCommandExecutor(_logger, _commandFactory);
_command = new TestDbCommand();
_connection = new TestDbConnection();
_command.StubScalarResult = 1;
_command.StubDataReader = new TestDbDataReader()
{
ResultSet = new ResultSet(new[] { new Row(new[] { new ColumnValue("Id", 1), }), })
};
_commandFactory.CreateConnection().Returns(_connection);
}
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 DatabaseContext(IDbConnection dbConnection, IDbCommandFactory dbCommandFactory)
{
Guard.AgainstNull(dbConnection, "dbConnection");
Guard.AgainstNull(dbCommandFactory, "dbCommandFactory");
_dbCommandFactory = dbCommandFactory;
_dispose = true;
Key = Guid.NewGuid();
Connection = dbConnection;
var log = Log.For(this);
try
{
if (dbConnection.State == ConnectionState.Closed)
{
Connection.Open();
log.Verbose(string.Format(DataResources.VerboseDbConnectionOpened, dbConnection.Database));
}
else
{
log.Verbose(string.Format(DataResources.VerboseDbConnectionAlreadyOpen, dbConnection.Database));
}
}
catch (Exception ex)
{
log.Error(string.Format(DataResources.DbConnectionOpenException, dbConnection.Database, ex.Message));
throw;
}
GuardedDatabaseContextStore().Add(this);
}
public TSqlGenerator CreateSqlGenerator(IDbCommandFactory dbCommandFactory)
{
return new SqlCe4TSqlGenerator(dbCommandFactory);
}
public AdminRepository(IDbCommandExecutionService dbCommandExecutionService,
IDbCommandFactory dbCommandFactory)
{
_dbCommandExecutionService = dbCommandExecutionService;
_dbCommandFactory = dbCommandFactory;
}
public abstract IDbCommand CreateLastInsertIdCommand(string tableName, IDbCommandFactory commandFactory);
public override IDbCommand CreateLastInsertIdCommand(string tableName, IDbCommandFactory commandFactory)
{
return commandFactory.Create(null, "SELECT last_insert_rowid()");
}
public void InsertWithSpaceAtMarker(DbCommand command, string marker, IDbCommandFactory commandFactory)
{
InsertAtMarker(command, marker, commandFactory, " ");
}
public UnitOfWork(ContextClass context, IDbCommandExecutionService dbCommandExecutionService, IDbCommandFactory dbCommandFactory)
{
this.context = context;
this.dbCommandExecutionService = dbCommandExecutionService;
this.dbCommandFactory = dbCommandFactory;
}
public override IDbCommand CreateLastInsertIdCommand(string tableName, IDbCommandFactory commandFactory)
{
return commandFactory.Create(null, "SELECT LAST_INSERT_ID() FROM " + tableName);
}
/// <summary>
/// Creates a new instance of <see cref="SqlDatabase"/>
/// </summary>
/// <param name="connectionString">The database connection string.</param>
/// <exception cref="ArgumentNullException">The supplied connection string is undefined</exception>
protected SqlDatabase(string connectionString)
{
ConnectionString = connectionString ?? throw new ArgumentNullException(nameof(ConnectionString));
Transaction = null;
}
public DatabaseWrapper(IDbCommandFactory commandFactory)
{
this.commandFactory = commandFactory;
}
public SqlCeTSqlGenerator(IDbCommandFactory commandFactory) : base(commandFactory)
{
_commandFactory = commandFactory;
}
public override IDbCommand CreateGetTableMetadataCommand(string tableName, IDbCommandFactory commandFactory)
{
return null;
}
public TransactionScope(IDbCommandFactory commandFactory, TransactionReference transaction, ConnectionScope connectionScope)
{
_commandFactory = commandFactory;
Transaction = transaction;
ConnectionScope = connectionScope;
}
public void SetUp()
{
_commandFactory = Substitute.For<IDbCommandFactory>();
_logger = Substitute.For<ISqlCommandLogger>();
_executor = new DbCommandExecutor(_logger, _commandFactory);
_command = new TestDbCommand();
_connection = new TestDbConnection();
_command.StubScalarResult = 1;
_command.StubDataReader = new TestDbDataReader() { ResultSet = new ResultSet(new[] { new Row(new[] { new ColumnValue("Id", 1), }), }) };
_commandFactory.CreateConnection().Returns(_connection);
}
public override IDbCommand CreateGetTableMetadataCommand(string tableName, IDbCommandFactory commandFactory)
{
var parameters = new[] { new Parameter("tableName", tableName) };
var sql = string.Format("SELECT * FROM `information_schema`.`COLUMNS` WHERE `TABLE_NAME` = {0}tableName", parameterPrefix);
return commandFactory.Create(parameters, sql);
}
public SqlCe4TSqlGenerator(IDbCommandFactory commandFactory)
: base(commandFactory)
{
_commandFactory = commandFactory;
}
public ConnectionScope(IDbCommandFactory dbCommandFactory, DbConnection connection)
{
Connection = connection;
_dbCommandFactory = dbCommandFactory;
}
private void AppendParameters(DbCommand command, IDbCommandFactory commandFactory)
{
var dbParameters = CommandParameters.Select(commandFactory.CreateParameter).ToArray();
command.Parameters.AddRange(dbParameters);
}
public TSqlGenerator CreateSqlGenerator(IDbCommandFactory dbCommandFactory)
{
throw new System.NotImplementedException();
}
public override IDbCommand CreateLastInsertIdCommand(string tableName, IDbCommandFactory commandFactory)
{
return commandFactory.Create(null, "select @@identity");
}
public abstract IDbCommand CreateGetTableMetadataCommand(string tableName, IDbCommandFactory commandFactory);
public static IDbCommandFactory CommandFactory(IDbCommandFactory commandFactory)
{
return(commandFactory);
}
public override IDbCommand CreateGetTableMetadataCommand(string tableName, IDbCommandFactory commandFactory)
{
var parameters = new[] { new Parameter("tableName", tableName) };
var sql = string.Format("select * from information_schema.columns where table_name = {0}tableName", parameterPrefix);
return commandFactory.Create(parameters, sql);
}
public TSqlGenerator CreateSqlGenerator(IDbCommandFactory dbCommandFactory)
{
return(new TSqlGenerator(dbCommandFactory));
}
public StockAppUnitOfWork(StockAppContext context, IDbCommandExecutionService dbCommandExecutionService, IDbCommandFactory dbCommandFactory)
{
_context = context;
_dbCommandExecutionService = dbCommandExecutionService;
_dbCommandFactory = dbCommandFactory;
}
public ConnectionScope(IDbCommandFactory dbCommandFactory, DbConnection connection)
{
Connection = connection;
_dbCommandFactory = dbCommandFactory;
}
public TSqlGenerator(IDbCommandFactory commandFactory)
{
_commandFactory = commandFactory;
}
public void InsertWithSpaceAtMarker(DbCommand command, string marker, IDbCommandFactory commandFactory)
{
InsertAtMarker(command, marker, commandFactory, " ");
}
private void AppendParameters(DbCommand command, IDbCommandFactory commandFactory)
{
var dbParameters = CommandParameters.Select(commandFactory.CreateParameter).ToArray();
command.Parameters.AddRange(dbParameters);
}
public override IDbCommand CreateLastInsertIdCommand(string tableName, IDbCommandFactory commandFactory)
{
return null;
}
public DbCommandExecutor(ISqlCommandLogger sqlCommandLogger, IDbCommandFactory commandFactory)
{
_sqlCommandLogger = sqlCommandLogger;
_commandFactory = commandFactory;
}
public TSqlGenerator CreateSqlGenerator(IDbCommandFactory dbCommandFactory)
{
throw new System.NotImplementedException();
}
public TransactionScope(IDbCommandFactory commandFactory, TransactionReference transaction, ConnectionScope connectionScope)
{
_commandFactory = commandFactory;
Transaction = transaction;
ConnectionScope = connectionScope;
}
public DbCommandGenerator(ITableMetadataProvider tableMetadataProvider, IDbCommandFactory commandFactory)
{
this.TableMetadataProvider = tableMetadataProvider;
this.CommandFactory = commandFactory;
}
public StockDataUnitOfWork(StockDataContext context, IDbCommandExecutionService dbCommandExecutionService, IDbCommandFactory dbCommandFactory)
{
_context = context;
_dbCommandExecutionService = dbCommandExecutionService;
_dbCommandFactory = dbCommandFactory;
}
public ShopOwnerRepository(IDbCommandExecutionService dbCommandExecutionService,
IDbCommandFactory dbCommandFactory)
{
_dbCommandExecutionService = dbCommandExecutionService;
_dbCommandFactory = dbCommandFactory;
}
