/// <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 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); }
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 TSqlGenerator(IDbCommandFactory commandFactory) { _commandFactory = commandFactory; }
public override IDbCommand CreateLastInsertIdCommand(string tableName, IDbCommandFactory commandFactory) { return null; }
public DbCommandExecutor(ISqlCommandLogger sqlCommandLogger, IDbCommandFactory commandFactory) { _sqlCommandLogger = sqlCommandLogger; _commandFactory = commandFactory; }
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; }