public static DatabaseConnectionWrapper GetConnection(Database db) { Transaction current = Transaction.Current; if (current == (Transaction)null) { return((DatabaseConnectionWrapper)null); } Dictionary <string, DatabaseConnectionWrapper> dictionary; lock (TransactionScopeConnections.transactionConnections) { if (!TransactionScopeConnections.transactionConnections.TryGetValue(current, out dictionary)) { dictionary = new Dictionary <string, DatabaseConnectionWrapper>(); TransactionScopeConnections.transactionConnections.Add(current, dictionary); current.TransactionCompleted += new TransactionCompletedEventHandler(TransactionScopeConnections.OnTransactionCompleted); } } DatabaseConnectionWrapper connectionWrapper; lock (dictionary) { if (!dictionary.TryGetValue(db.ConnectionString, out connectionWrapper)) { connectionWrapper = new DatabaseConnectionWrapper(db.GetNewOpenConnection()); dictionary.Add(db.ConnectionString, connectionWrapper); } connectionWrapper.AddRef(); } return(connectionWrapper); }
public RefCountingDataReaderForAsync(DatabaseConnectionWrapper connection, DbDataReader innerReader) : base(innerReader) { Guard.ArgumentNotNull((object)connection, nameof(connection)); Guard.ArgumentNotNull((object)innerReader, nameof(innerReader)); this.connectionWrapper = connection; this.connectionWrapper.AddRef(); }
public virtual async Task <int> ExecuteNonQueryAsync(DbCommand command) { using (DatabaseConnectionWrapper openConnection = await this.GetOpenConnectionAsync()) { Database.PrepareCommand(command, openConnection.Connection); return(await this.DoExecuteNonQueryAsync(command)); } }
public virtual int ExecuteNonQuery(DbCommand command) { using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection()) { Database.PrepareCommand(command, openConnection.Connection); return(this.DoExecuteNonQuery(command)); } }
public virtual void LoadDataSet(DbCommand command, DataSet dataSet, string[] tableNames) { using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection()) { Database.PrepareCommand(command, openConnection.Connection); this.DoLoadDataSet((IDbCommand)command, dataSet, tableNames); } }
/// <summary> /// Create a new <see cref='RefCountingDataReader'/> that wraps /// the given <paramref name="innerReader"/> and properly /// cleans the refcount on the given <paramref name="connection"/> /// when done. /// </summary> /// <param name="connection">Connection to close.</param> /// <param name="innerReader">Reader to do the actual work.</param> public RefCountingDataReader(DatabaseConnectionWrapper connection, IDataReader innerReader) : base(innerReader) { Guard.ArgumentNotNull(connection, "connection"); Guard.ArgumentNotNull(innerReader, "innerReader"); connectionWrapper = connection; connectionWrapper.AddRef(); }
/// <summary> /// Create a new <see cref='RefCountingDataReader'/> that wraps /// the given <paramref name="innerReader"/> and properly /// cleans the refcount on the given <paramref name="connection"/> /// when done. /// </summary> /// <param name="connection">Connection to close.</param> /// <param name="innerReader">Reader to do the actual work.</param> public RefCountingDataReader(DatabaseConnectionWrapper connection, IDataReader innerReader) : base(innerReader) { Guard.ArgumentNotNull(connection, "connection"); Guard.ArgumentNotNull(innerReader, "innerReader"); connectionWrapper = connection; connectionWrapper.AddRef(); }
public virtual IDataReader ExecuteReader(DbCommand command) { using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection()) { Database.PrepareCommand(command, openConnection.Connection); IDataReader innerReader = this.DoExecuteReader(command, CommandBehavior.Default); return(this.CreateWrappedReader(openConnection, innerReader)); } }
public virtual async Task <DbDataReader> ExecuteReaderAsync(DbCommand command) { using (DatabaseConnectionWrapper openConnection = await this.GetOpenConnectionAsync()) { Database.PrepareCommand(command, openConnection.Connection); DbDataReader innerReader = await this.DoExecuteReaderAsync(command, CommandBehavior.CloseConnection); return(this.CreateWrappedReaderForAsync(openConnection, innerReader)); } }
public virtual async Task <object> ExecuteScalarAsync(DbCommand command) { if (command == null) { throw new ArgumentNullException(nameof(command)); } using (DatabaseConnectionWrapper openConnection = await this.GetOpenConnectionAsync()) { Database.PrepareCommand(command, openConnection.Connection); return(await this.DoExecuteScalarAsync(command)); } }
public virtual object ExecuteScalar(DbCommand command) { if (command == null) { throw new ArgumentNullException(nameof(command)); } using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection()) { Database.PrepareCommand(command, openConnection.Connection); return(this.DoExecuteScalar((IDbCommand)command)); } }
/// <summary> /// Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/> /// instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method /// returns null. /// </summary> /// <param name="db"></param> /// <returns>Either a <see cref="DbConnection"/> instance or null.</returns> public static DatabaseConnectionWrapper GetConnection(Database db) { Transaction currentTransaction = Transaction.Current; if (currentTransaction == null) { return(null); } Dictionary <string, DatabaseConnectionWrapper> connectionList; DatabaseConnectionWrapper connection; lock (transactionConnections) { if (!transactionConnections.TryGetValue(currentTransaction, out connectionList)) { // We don't have a list for this transaction, so create a new one connectionList = new Dictionary <string, DatabaseConnectionWrapper>(); transactionConnections.Add(currentTransaction, connectionList); // We need to know when this previously unknown transaction is completed too currentTransaction.TransactionCompleted += OnTransactionCompleted; } } lock (connectionList) { // Next we'll see if there is already a connection. If not, we'll create a new connection and add it // to the transaction's list of connections. // This collection should only be modified by the thread where the transaction scope was created // while the transaction scope is active. // However there's no documentation to confirm this, so we err on the safe side and lock. if (!connectionList.TryGetValue(db.ConnectionString, out connection)) { // we're betting the cost of acquiring a new finer-grained lock is less than // that of opening a new connection, and besides this allows threads to work in parallel var dbConnection = db.GetNewOpenConnection(); connection = new DatabaseConnectionWrapper(dbConnection); connectionList.Add(db.ConnectionString, connection); } connection.AddRef(); } return(connection); }
public int UpdateDataSet( DataSet dataSet, string tableName, DbCommand insertCommand, DbCommand updateCommand, DbCommand deleteCommand, UpdateBehavior updateBehavior, int?updateBatchSize) { using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection()) { if (updateBehavior == UpdateBehavior.Transactional && Transaction.Current == (Transaction)null) { DbTransaction transaction = Database.BeginTransaction(openConnection.Connection); try { int num = this.UpdateDataSet(dataSet, tableName, insertCommand, updateCommand, deleteCommand, transaction, updateBatchSize); Database.CommitTransaction((IDbTransaction)transaction); return(num); } catch { Database.RollbackTransaction((IDbTransaction)transaction); throw; } } else { if (insertCommand != null) { Database.PrepareCommand(insertCommand, openConnection.Connection); } if (updateCommand != null) { Database.PrepareCommand(updateCommand, openConnection.Connection); } if (deleteCommand != null) { Database.PrepareCommand(deleteCommand, openConnection.Connection); } return(this.DoUpdateDataSet(updateBehavior, dataSet, tableName, (IDbCommand)insertCommand, (IDbCommand)updateCommand, (IDbCommand)deleteCommand, updateBatchSize)); } } }
/// <summary> /// Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/> /// instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method /// returns null. /// </summary> /// <param name="db"></param> /// <returns>Either a <see cref="DbConnection"/> instance or null.</returns> public static DatabaseConnectionWrapper GetConnection(Database db) { Transaction currentTransaction = Transaction.Current; if (currentTransaction == null) return null; Dictionary<string, DatabaseConnectionWrapper> connectionList; DatabaseConnectionWrapper connection; lock (transactionConnections) { if (!transactionConnections.TryGetValue(currentTransaction, out connectionList)) { // We don't have a list for this transaction, so create a new one connectionList = new Dictionary<string, DatabaseConnectionWrapper>(); transactionConnections.Add(currentTransaction, connectionList); // We need to know when this previously unknown transaction is completed too currentTransaction.TransactionCompleted += OnTransactionCompleted; } } lock (connectionList) { // Next we'll see if there is already a connection. If not, we'll create a new connection and add it // to the transaction's list of connections. // This collection should only be modified by the thread where the transaction scope was created // while the transaction scope is active. // However there's no documentation to confirm this, so we err on the safe side and lock. if (!connectionList.TryGetValue(db.ConnectionString, out connection)) { // we're betting the cost of acquiring a new finer-grained lock is less than // that of opening a new connection, and besides this allows threads to work in parallel var dbConnection = db.GetNewOpenConnection(); connection = new DatabaseConnectionWrapper(dbConnection); connectionList.Add(db.ConnectionString, connection); } connection.AddRef(); } return connection; }
public void DiscoverParameters(DbCommand command) { if (command == null) { throw new ArgumentNullException(nameof(command)); } using (DatabaseConnectionWrapper openConnection = this.GetOpenConnection()) { using (DbCommand commandByCommandType = this.CreateCommandByCommandType(command.CommandType, command.CommandText)) { commandByCommandType.Connection = openConnection.Connection; this.DeriveParameters(commandByCommandType); foreach (ICloneable parameter in commandByCommandType.Parameters) { IDataParameter dataParameter = (IDataParameter)parameter.Clone(); command.Parameters.Add((object)dataParameter); } } } }
internal RefCountingOracleDataReaderWrapper(DatabaseConnectionWrapper connection, OracleDataReader innerReader) : base(innerReader) { this.connection = connection; this.connection.AddRef(); }
/// <summary> /// All data readers get wrapped in objects so that they properly manage connections. /// Some derived Database classes will need to create a different wrapper, so this /// method is provided so that they can do this. /// </summary> /// <param name="connection">Connection + refcount.</param> /// <param name="innerReader">The reader to wrap.</param> /// <returns>The new reader.</returns> protected virtual IDataReader CreateWrappedReader(DatabaseConnectionWrapper connection, IDataReader innerReader) { return new RefCountingDataReader(connection, innerReader); }
private int ExecuteNonQueryFanout(DatabaseConnectionWrapper wrapper, DbCommand command) { long? federationKey = 0; while (federationKey != null) { ExecuteFederationCommand(wrapper.Connection,FederationType.Member,federationKey,false); DoExecuteNonQueryWithRetry(command); using (DbCommand fCommand = _dbProviderFactory.CreateCommand()) { fCommand.CommandText = "SELECT CAST(range_high as bigint) FROM sys.federation_member_distributions"; PrepareCommand(fCommand,wrapper.Connection); object key = DoExecuteScalarWithRetry(fCommand); if (key != DBNull.Value) { federationKey = Convert.ToInt64(key); } else { federationKey = null; } } } return 0; }
protected virtual IDataReader CreateWrappedReader( DatabaseConnectionWrapper connection, IDataReader innerReader) { return((IDataReader) new RefCountingDataReader(connection, innerReader)); }
protected virtual DbDataReader CreateWrappedReaderForAsync( DatabaseConnectionWrapper connection, DbDataReader innerReader) { return((DbDataReader) new RefCountingDataReaderForAsync(connection, innerReader)); }
/// <summary> /// All data readers get wrapped in objects so that they properly manage connections. /// Some derived Database classes will need to create a different wrapper, so this /// method is provided so that they can do this. /// </summary> /// <param name="connection">Connection + refcount.</param> /// <param name="innerReader">The reader to wrap.</param> /// <returns>The new reader.</returns> protected override IDataReader CreateWrappedReader(DatabaseConnectionWrapper connection, IDataReader innerReader) { // TODO : properly manage refcount //return new OracleDataReaderWrapper((OracleDataReader)innerReader); return new RefCountingOracleDataReaderWrapper(connection, (OracleDataReader)innerReader); }