private static void InnerExecuteQuery <T>(GenericRecordList <T> rl, IDbCommand command, string description, bool transformParameters) where T : ITypedRecord <T> { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); IDatabaseAccessProvider provider = DatabaseAccess.GetProviderForTransaction(cmd.Transaction); provider.ExecuteQuery(new ManagedCommand(provider.TransactionManager, cmd), rl, description, transformParameters, false); }
public static int ExecuteNonQueryDontCleanParameters(IDbCommand command, string description, bool isApplication, bool skipLog) { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); Command wrapperCommand = new Command(GetExecutionForConnection(cmd.Connection), cmd); return(wrapperCommand.ExecuteNonQueryWithoutTransformParametersSyntax(description, isApplication, skipLog)); }
public static object ExecuteScalarDontCleanParameters(IDbCommand command, bool skipLog) { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); Command wrapperCommand = new Command(GetExecutionForConnection(cmd.Connection), cmd); return(wrapperCommand.ExecuteScalarWithoutTransformParametersSyntax(skipLog)); }
public static DataSet CreateAndFillDataSet(IDbCommand command, IDbDataAdapter adapter, string description, bool isApplication) { // Save the values before execution because sometimes the drivers clears them from the IDbCommand when an exception occurs IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); IDbConnection conn = cmd.Connection; IDbTransaction trans = cmd.Transaction; IDatabaseAccessProvider provider = null; bool hasProvider = trans != null && DatabaseAccess.TryGetProviderForTransaction(trans, out provider); IExecutionService executionService = hasProvider ? provider.DatabaseServices.ExecutionService : GetExecutionForConnection(conn); ITransactionManager manager = provider.TransactionManager; try { DataSet dataSet; { dataSet = new DataSet(); adapter.SelectCommand = cmd; adapter.Fill(dataSet); } return(dataSet); } catch (DbException e) { executionService.OnExecuteException(e, cmd, null, conn, trans, manager); throw; } }
public static IDataReader ExecuteReader(IDbCommand command, string description, bool isApplication, bool transformParameters, bool skipLog) { try { // Save the values before execution because sometimes the drivers clears them from the IDbCommand when an exception occurs IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); IDbConnection conn = cmd.Connection; IDbTransaction trans = cmd.Transaction; IDatabaseAccessProvider provider = null; bool hasProvider = trans != null && DatabaseAccess.TryGetProviderForTransaction(trans, out provider); IExecutionService executionService = hasProvider ? provider.DatabaseServices.ExecutionService : GetExecutionForConnection(conn); ITransactionManager manager = provider.TransactionManager; IDataReader reader = null; try { if (transformParameters) { TransformParameters(cmd); } reader = executionService.ExecuteReader(cmd); // NOTE: This reader will be closed automatically by the transaction manager at the end of the request manager.AssociateReader(trans, reader); } catch (DbException e) { executionService.OnExecuteException(e, cmd, reader, conn, trans, manager); throw; } return(reader); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public void CloseTransaction(IDbTransaction transaction) { IDbTransaction trans = ADOAdaptersUtils.GetADOTransaction(transaction); IDatabaseServices databaseServices = DBHelper.GetDatabaseServicesForConnection(trans.Connection); databaseServices.TransactionService.CloseTransaction(trans); }
public static bool isConnectedUser(IDbTransaction transaction, string userName) { IDbTransaction trans = ADOAdaptersUtils.GetADOTransaction(transaction); IDatabaseServices databaseServices = DBHelper.GetDatabaseServicesForConnection(trans.Connection); return(DBCompatibilityReflectionUtils.IsConnectedUser(transaction.Connection, userName, databaseServices.ExecutionService)); }
public IDbTransaction CreateTransaction(string connectionName, string connectionString) { try { if (!String.IsNullOrEmpty(connectionName)) { IDatabaseServices databaseServices = AdaptersUtils.GetDatabaseServices(GetDatabaseKind(connectionName), new ConnectionString(connectionString)); ITransactionManager baseTransactionManager = GetProviderFromConnectionNameOrMain(connectionName).TransactionManager; ITransactionService transactionService = databaseServices.TransactionService; IDbConnection connection = transactionService.CreateConnection(); return(ADOAdaptersUtils.AdapterTransaction(transactionService.CreateTransaction(connection))); } else { return(CreateTransaction(connectionString)); } } catch (ConnectionNotFoundException e) { throw new DBConnectionNotFoundException(e.Message); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } catch (InvalidTransactionReleaseException e) { throw new InvalidReleaseException(e.Message); } }
public IDbTransaction GetReadOnlyTransaction() { try { return(ADOAdaptersUtils.AdapterTransaction(TransactionManager.GetReadOnlyTransaction())); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public virtual IDbTransaction GetPrivateTransaction() { try { return(ADOAdaptersUtils.AdapterTransaction(DBAccess.MainProvider.GetCommitableTransaction().DriverTransaction)); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public void CleanParameterSyntax(IDbCommand command) { try { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); DBHelper.TransformParameters(cmd); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public static IDbCommand CreateCommand(IDbTransaction transaction) { try { IDbTransaction trans = ADOAdaptersUtils.GetADOTransaction(transaction); return(ADOAdaptersUtils.AdapterCommand(GetExecutionForConnection(trans.Connection).CreateCommand(trans, ""))); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public virtual void RollbackTransaction(IDbTransaction transaction) { try { IDbTransaction trans = ADOAdaptersUtils.GetADOTransaction(transaction); GetProviderFromConnectionNameOrMain(null).TransactionManager.RollbackTransaction(trans); } catch (InvalidCommitOrRollbackTransactionException e) { throw new InvalidCommitOrRollbackException(e.Message); } }
public IDbTransaction CreateTransaction(ConnectionString connectionString) { try { IDatabaseServices databaseServices = AdaptersUtils.GetDatabaseServices(DatabaseKind, connectionString); return(ADOAdaptersUtils.AdapterTransaction(databaseServices.TransactionService.CreateTransaction(GetConnection(connectionString)))); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public static IDbCommand CreateCommand(IDbConnection connection, string sql) { try { DatabaseConnection conn = new DatabaseConnection(GetExecutionForConnection(connection).DatabaseServices, connection); return(ADOAdaptersUtils.AdapterCommand(conn.CreateCommand(sql).DriverCommand)); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public static int ExecuteNonQuery(IDbCommand command, bool skipLog) { try { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); Command wrappedCommand = new Command(GetExecutionForConnection(cmd.Connection), cmd); return(wrappedCommand.ExecuteNonQuery(skipLog)); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public static IDbDataParameter AddParameter(IDbCommand cmd, string name, DbType dbType, object paramValue, DBKind dbKind, bool magicReplace) { IExecutionService executionService = GetExecutionForKind(dbKind); if (magicReplace) { paramValue = executionService.TransformRuntimeToDatabaseValue(dbType, paramValue); } return(ADOAdaptersUtils.AdapterParameter(executionService.CreateParameter(ADOAdaptersUtils.GetADOCommand(cmd), name, dbType, paramValue))); }
public static object ExecuteScalar(IDbCommand command) { try { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); Command wrapperCommand = new Command(GetExecutionForConnection(cmd.Connection), cmd); return(wrapperCommand.ExecuteScalar()); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public IDbTransaction GetPrivateTransaction(string connectionName) { try { return(ADOAdaptersUtils.AdapterTransaction(GetProviderFromConnectionNameOrMain(connectionName).TransactionManager.GetCommitableTransaction())); } catch (ConnectionNotFoundException e) { throw new DBConnectionNotFoundException(e.Message); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } catch (InvalidTransactionReleaseException e) { throw new InvalidReleaseException(e.Message); } }
public static IDataReader ExecuteStoredProcedure(IDbCommand command, DBKind dbKind, string readerVarName, bool skipLog) { try { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); TransformParameters(cmd); IDataReader reader = GetExecutionForKind(dbKind).ExecuteStoredProcedureWithResultSet(cmd, readerVarName); DatabaseAccess.GetProviderForTransaction(cmd.Transaction).TransactionManager.AssociateReader(cmd.Transaction, reader); return(reader); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public void ReleaseTransaction(string connectionName, IDbTransaction transaction) { try { IDbTransaction trans = ADOAdaptersUtils.GetADOTransaction(transaction); GetProviderFromConnectionNameOrMain(connectionName).TransactionManager.ReleaseTransaction(trans); } catch (ConnectionNotFoundException e) { throw new DBConnectionNotFoundException(e.Message); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } catch (InvalidTransactionReleaseException e) { throw new InvalidReleaseException(e.Message); } }
public static IDbDataParameter AddParameterWithDirection(IDbCommand command, string name, DbType dbType, ParameterDirection direction) { try { Command cmd = new Command(DatabaseAccess.ForSystemDatabase.DatabaseServices.ExecutionService, ADOAdaptersUtils.GetADOCommand(command)); return(ADOAdaptersUtils.AdapterParameter(cmd.CreateParameterWithDirection(name, dbType, direction).DriverParameter)); } catch (ConnectionNotFoundException e) { throw new DBConnectionNotFoundException(e.Message); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } catch (InvalidTransactionReleaseException e) { throw new InvalidReleaseException(e.Message); } }
public bool isConnectedUser(string userName) { try { using (Transaction requestTransaction = DBAccess.MainProvider.GetRequestTransaction()) { // ReSharper disable once JoinDeclarationAndInitializer IDbTransaction trans; trans = ADOAdaptersUtils.AdapterTransaction(requestTransaction.DriverTransaction); return(isConnectedUser(trans, userName)); } } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } }
public IDbDataParameter AddParameter(string connectionName, IDbCommand command, string name, DbType dbType, object paramValue) { try { IDbCommand cmd = ADOAdaptersUtils.GetADOCommand(command); IDatabaseServices databaseServices = GetProviderFromConnectionNameOrMain(connectionName).DatabaseServices; Command wrappedCommand = new Command(databaseServices.ExecutionService, cmd); return(ADOAdaptersUtils.AdapterParameter(wrappedCommand.CreateParameter(name, dbType, paramValue).DriverParameter)); } catch (ConnectionNotFoundException e) { throw new DBConnectionNotFoundException(e.Message); } catch (InvalidDatabaseAccessException e) { throw new InvalidDBTransactionManagerAccess(e.Message); } catch (InvalidTransactionReleaseException e) { throw new InvalidReleaseException(e.Message); } }
public static void SetParamDirection(IDbDataParameter parameter, ParameterDirection direction) { IDbDataParameter param = ADOAdaptersUtils.GetADOParameter(parameter); IExecutionService executionToUse = GetExecutionForKind(DBKind.Oracle); { Assembly oracleClient = Assembly.Load("Oracle.ManagedDataAccess.Client"); Type oracleParameterType = oracleClient.GetType("Oracle.ManagedDataAccess.Client.OracleParameter"); if (!oracleParameterType.IsInstanceOfType(param)) { executionToUse = GetExecutionForKind(DBKind.SqlServer); } } executionToUse.SetParameterDirection(param, direction); }
public virtual IDbDataParameter AddParameter(IDbCommand cmd, string name, DbType dbType, object paramValue) { Command command = new Command(TransactionManager.TransactionService.DatabaseServices.ExecutionService, cmd); return(ADOAdaptersUtils.AdapterParameter(command.CreateParameter(name, dbType, paramValue).DriverParameter)); }
public static IDbDataParameter AddParameter(IDbCommand cmd, string name, DbType dbType, ObjectKey key, DBKind dbKind) { Command command = new Command(GetExecutionForKind(dbKind).DatabaseServices.ExecutionService, ADOAdaptersUtils.GetADOCommand(cmd)); return(ADOAdaptersUtils.AdapterParameter(command.CreateParameter(name, dbType, key).DriverParameter)); }
public void AssociateReader(IDbTransaction trans, IDataReader reader, string schema) { DBAccess.InnerGetProviderForTransaction(ADOAdaptersUtils.GetADOTransaction(trans), schema).TransactionManager.AssociateReader(ADOAdaptersUtils.GetADOTransaction(trans), reader); }