public SWPTransactionDBConnection(string connectionName)
 {
     _database   = SWPDBHelper.DBFromConnectionName(connectionName);
     _connection = _database.CreateConnection();
     _connection.Open();
     _transaction = _connection.BeginTransaction();
 }
        protected override DataSet Select(
            DataSet ds,
            string selectStoredProcedure,
            params SWPGenericDbParameter[] parameters)
        {
            if (null == _dbTransactionConnection)
            {
                SWPDBHelper.StoredProcDataSet(
                    _dbConnectionName,
                    ds,
                    selectStoredProcedure,
                    TableName,
                    parameters);
            }

            else
            {
                ds = SelectTransaction(
                    ds,
                    selectStoredProcedure,
                    CommandType.StoredProcedure,
                    parameters);
            }

            return(ds);
        }
 protected virtual DbDataReader SqlStringReaderSelect(string selectText)
 {
     return(SWPDBHelper.SqlStringDataReader(
                _dbConnectionName,
                selectText,
                CommandType.Text));
 }
 protected virtual DbDataReader SqlStringReaderSelect(
     string selectText,
     params SWPGenericDbParameter[] parameters)
 {
     return(SWPDBHelper.SqlStringDataReader(
                _dbConnectionName,
                selectText,
                parameters));
 }
        public SWPTransactionDBConnection(
            SWPConnectionTextFormatType connectionTextFormatType,
            string connectionNameOrText)

        {
            _database = SWPDBHelper.DBConnection(
                connectionTextFormatType,
                connectionNameOrText);
            _connection = _database.CreateConnection();
            _connection.Open();
            _transaction = _connection.BeginTransaction();
        }
 protected virtual DataSet SqlStringSelect(
     DataSet ds,
     string selectText,
     params SWPGenericDbParameter[] parameters)
 {
     return(SWPDBHelper.SqlStringDataSet(
                _dbConnectionName,
                ds,
                selectText,
                TableName,
                parameters));
 }
        protected override DataSet SqlStringSelect(
            DataSet ds,
            string commandText,
            params SWPGenericDbParameter[] parameters)
        {
            if (null == _dbTransactionConnection)
            {
                SWPDBHelper.SqlStringDataSet(
                    _dbConnectionName,
                    ds,
                    commandText,
                    TableName,
                    parameters);
            }

            else
            {
                SelectTransaction(ds, commandText, CommandType.Text, parameters);
            }

            return(ds);
        }
        private void ProcessCommand(
            string storedProcedureName,
            DataTable table,
            DataRowVersion dataRowVersion,
            DbParameter [] parameters)
        {
            string       candidateColumnName;
            bool         parmSet;
            Database     db = null;
            DbCommand    command;
            DbConnection conn = null;

            if (table == null)
            {
                return;
            }

            try
            {
                if (_dbTransactionConnection == null)
                {
                    db = SWPDBHelper.DBConnection(
                        _connectionTextFormatType,
                        _dbConnectionName);
                    command = db.GetStoredProcCommand(storedProcedureName);
                    conn    = db.CreateConnection();
                    conn.Open();
                    command.Connection = conn;
                }

                else
                {
                    command = _dbTransactionConnection.TransactionDatabase.GetStoredProcCommand(
                        storedProcedureName);
                }

                command.CommandType = CommandType.StoredProcedure;
                foreach (DataRow row in table.Rows)
                {
                    command.Parameters.Clear();
                    PopulateCommandWithParameters(command, parameters);
                    foreach (DbParameter commandParameter in command.Parameters)
                    {
                        parmSet = false;
                        // Skip the @ character
                        candidateColumnName = ColumnName(_dbConnectionName, commandParameter.ParameterName);

                        // we want to be case insensitive so lets
                        // do this by hand
                        foreach (DataColumn column in table.Columns)
                        {
                            if (String.Compare(
                                    column.ColumnName,
                                    candidateColumnName,
                                    true) == 0)
                            {
                                commandParameter.Value = row[column, dataRowVersion];
                                parmSet = true;

                                break;
                            }
                        }

                        if (!parmSet)
                        {
                            throw new Exception(
                                      "No matching column found for parameter: " +
                                      commandParameter.ParameterName);
                        }
                    }

                    command.ExecuteNonQuery();
                }
            }

            finally
            {
                if (conn != null)
                {
                    if (conn.State == ConnectionState.Open)
                    {
                        conn.Close();
                    }

                    conn = null;
                }
            }
        }
 protected virtual DbDataReader ReaderSelect(string selectText)
 {
     return(SWPDBHelper.StoredProcDataReader(
                _dbConnectionName,
                selectText));
 }