internal override int ExecuteMultiCommands(IDbCommand[] dbcommands, SafeLevel level)
        {
            int rInt = 0;

            if (_isTransaction)
            {
                foreach (IDbCommand dbcommand in dbcommands)
                {
                    _trconnection.SetupCommand(dbcommand);
                    rInt += dbcommand.ExecuteNonQuery();
                }
            }
            else
            {
                TransactionConnection transaction = GetTransactionConnection();
                transaction.ResetTransaction(level);
                try {
                    foreach (IDbCommand dbcommand in dbcommands)
                    {
                        transaction.SetupCommand(dbcommand);
                        rInt += dbcommand.ExecuteNonQuery();
                    }
                    transaction.Commit();
                }
                catch (Exception ex) {
                    transaction.Rollback();
                    throw ex;
                }
            }
            return(rInt);
        }
        internal override object ExecuteScalar(IDbCommand dbcommand, SafeLevel level)
        {
            object result = null;

            if (_isTransaction)
            {
                _trconnection.SetupCommand(dbcommand);
                result = dbcommand.ExecuteScalar();
            }
            else
            {
                TransactionConnection transaction = GetTransactionConnection();
                transaction.ResetTransaction(level);
                try {
                    transaction.SetupCommand(dbcommand);
                    result = dbcommand.ExecuteScalar();
                    transaction.Commit();
                }
                catch (Exception ex) {
                    transaction.Rollback();
                    throw ex;
                }
            }
            return(result);
        }
        internal override DataSet QueryDataSet(IDbCommand dbcommand, SafeLevel level)
        {
            DataSet ds = new DataSet();

            if (_isTransaction)
            {
                _trconnection.SetupCommand(dbcommand);
                IDbDataAdapter adapter = _dataBase.CreateDataAdapter(dbcommand);
                adapter.Fill(ds);
            }
            else
            {
                TransactionConnection transaction = GetTransactionConnection();
                transaction.ResetTransaction(level);
                try {
                    transaction.SetupCommand(dbcommand);
                    IDbDataAdapter adapter = _dataBase.CreateDataAdapter(dbcommand);
                    adapter.Fill(ds);
                    transaction.Commit();
                }
                catch (Exception ex) {
                    transaction.Rollback();
                    throw ex;
                }
            }
            return(ds);
        }
        internal override object ExecuteInsertCommand(IDbCommand dbcommand, IDbCommand indentityCommand, SafeLevel level)
        {
            object result = null;

            if (_isTransaction)
            {
                _trconnection.SetupCommand(dbcommand);
                dbcommand.ExecuteNonQuery();
                if (indentityCommand != null)
                {
                    _trconnection.SetupCommand(indentityCommand);
                    object obj = indentityCommand.ExecuteScalar();
                    if (obj != null)
                    {
                        result = obj;
                    }
                }
            }
            else
            {
                TransactionConnection transaction = GetTransactionConnection();
                transaction.ResetTransaction(level);
                try {
                    transaction.SetupCommand(dbcommand);
                    dbcommand.ExecuteNonQuery();
                    if (indentityCommand != null)
                    {
                        transaction.SetupCommand(indentityCommand);
                        object obj = indentityCommand.ExecuteScalar();
                        if (obj != null)
                        {
                            result = obj;
                        }
                    }
                    transaction.Commit();
                }
                catch (Exception ex) {
                    transaction.Rollback();
                    throw ex;
                }
            }
            return(result);
        }
        internal override IEnumerable QueryDataReader(IDataDefine source, IDbCommand dbcommand, Region region, SafeLevel level)
        {
            int start;
            int size;

            if (region != null)
            {
                start = region.Start;
                size  = region.Size;
            }
            else
            {
                start = 0;
                size  = int.MaxValue;
            }
            if (_isTransaction)
            {
                _trconnection.SetupCommand(dbcommand);
                using (IDataReader reader = dbcommand.ExecuteReader()) {
                    int index = 0;
                    int count = 0;
                    while (reader.Read())
                    {
                        if (index >= start)
                        {
                            count++;
                            object item = source.LoadData(this, reader);
                            yield return(item);

                            if (count >= size)
                            {
                                dbcommand.Cancel();
                                break;
                            }
                        }
                        index++;
                    }
                }
            }
            else
            {
                TransactionConnection transaction = GetTransactionConnection();
                transaction.ResetTransaction(level);
                transaction.SetupCommand(dbcommand);
                using (IDataReader reader = dbcommand.ExecuteReader()) {
                    int index = 0;
                    int count = 0;
                    while (reader.Read())
                    {
                        if (index >= start)
                        {
                            count++;
                            object item = source.LoadData(this, reader);
                            yield return(item);

                            if (count >= size)
                            {
                                dbcommand.Cancel();
                                break;
                            }
                        }
                        index++;
                    }
                }
                transaction.Commit();
            }
        }