数据库DB2的帮助类

 关于IBM DB2数据库的帮助类，通常是指在Java、.NET或其他编程语言中为简化DB2数据库操作而封装的一系列方法和功能的类库。这些帮助类通常会提供连接管理、SQL执行、事务处理等功能，并对DB2特有的API进行了抽象和封装。

例如，在Java环境下，可以创建一个DB2数据库连接帮助类，它可能包含如下核心功能：

1.建立连接：
        使用com.ibm.db2.jcc.DB2Driver加载驱动并注册到JDBC DriverManager。
        使用正确的URL、用户名和密码来建立到DB2数据库的连接。
2.关闭连接：
        提供一个方法来确保资源正确释放，如关闭数据库连接、Statement和ResultSet。
3.执行SQL查询与命令：
        封装executeQuery、executeUpdate等方法，处理SELECT、INSERT、UPDATE、DELETE等操作。
4.事务处理：
        开启、提交和回滚事务的方法。
5.错误处理：
        异常捕获和处理机制，确保程序能够优雅地处理数据库操作中的错误。
6.实用工具方法：
        可能还包括预编译SQL语句（PreparedStatement）的封装、结果集的遍历与转换成对象列表等。

示例代码：

using System;
using System.Data;
using IBM.Data.DB2;
using IBM.Data.DB2Types;
using System.Collections.Generic;

namespace Lvl.Db.Helper
{
    /// <summary>
    /// DB2数据库操作类
    /// </summary>
    public static class Db2Helper
    {
        #region 通用方法
        /// <summary>
        /// 创建一个连接对象
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <returns></returns>
        public static DB2Connection CreateConnection(string connectionString)
        {
            return new DB2Connection(connectionString);
        }
        #endregion

        #region 执行SQL语句,返回受影响的行数
        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(string connectionString, string commandText)
        {
            return ExecuteNonQuery(connectionString, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(DB2Connection connection, string commandText)
        {
            return ExecuteNonQuery(connection, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(DB2Transaction transaction, string commandText)
        {
            return ExecuteNonQuery(transaction, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(string connectionString, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteNonQuery(connectionString, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(DB2Connection connection, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteNonQuery(connection, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(DB2Transaction transaction, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteNonQuery(transaction, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(string connectionString, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                return ExecuteNonQuery(connection, commandText, commandType, commandParameters);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(DB2Connection connection, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, connection, (DB2Transaction)null, commandType, commandText, commandParameters);
                try
                {
                    return new NonQueryResult(cmd.ExecuteNonQuery(), cmd);
                }
                catch (Exception ex)
                {
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }

            }
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回受影响的行数</returns>
        public static NonQueryResult ExecuteNonQuery(DB2Transaction transaction, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = transaction.Connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
                try
                {
                    return new NonQueryResult(cmd.ExecuteNonQuery(), cmd);
                }
                catch (Exception ex)
                {
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }
            }
        }

        #endregion 执行SQL语句,返回受影响的行数

        #region 执行SQL语句,返回结果的第一行第一列

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(string connectionString, string commandText)
        {
            return ExecuteScalar(connectionString, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(DB2Connection connection, string commandText)
        {
            return ExecuteScalar(connection, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(DB2Transaction transaction, string commandText)
        {
            return ExecuteScalar(transaction, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(string connectionString, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteScalar(connectionString, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(DB2Connection connection, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteScalar(connection, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(DB2Transaction transaction, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteScalar(transaction, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(string connectionString, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                return ExecuteScalar(connection, commandText, commandType, commandParameters);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(DB2Connection connection, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, connection, (DB2Transaction)null, commandType, commandText, commandParameters);
                try
                {
                    return new ScalerResult(cmd.ExecuteScalar(), cmd);
                }
                catch (Exception ex)
                {
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }
            }
        }


        /// <summary>
        /// 执行SQL语句,返回结果的第一行第一列
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static ScalerResult ExecuteScalar(DB2Transaction transaction, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = transaction.Connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
                try
                {
                    return new ScalerResult(cmd.ExecuteScalar(), cmd);
                }
                catch (Exception ex)
                {
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }

            }
        }

        #endregion 执行SQL语句,返回结果的第一行第一列

        #region 执行SQL语句,返回一个数据读取器

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回结果的第一行第一列</returns>
        public static DbReader ExecuteReader(string connectionString, string commandText)
        {
            return ExecuteReader(connectionString, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(DB2Connection connection, string commandText)
        {
            return ExecuteReader(connection, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(DB2Transaction transaction, string commandText)
        {
            return ExecuteReader(transaction, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(string connectionString, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteReader(connectionString, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(DB2Connection connection, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteReader(connection, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(DB2Transaction transaction, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteReader(transaction, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(string connectionString, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            DB2Connection connection = new DB2Connection(connectionString);
            return ExecuteReader(connection, null, commandText, commandType, commandParameters, DbConnectionOwnership.Internal);

        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(DB2Connection connection, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            return ExecuteReader(connection, (DB2Transaction)null, commandText, commandType, commandParameters, DbConnectionOwnership.External);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据读取器</returns>
        public static DbReader ExecuteReader(DB2Transaction transaction, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            return ExecuteReader(transaction.Connection, transaction, commandText, commandType, commandParameters, DbConnectionOwnership.External);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据读取器
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <param name="connectionOwnership">数据库命令的连接类型</param>
        /// <returns>返回一个数据读取器</returns>
        internal static DbReader ExecuteReader(DB2Connection connection, DB2Transaction transaction, string commandText, CommandType commandType, DB2Parameter[] commandParameters, DbConnectionOwnership connectionOwnership)
        {
            DB2Command cmd = connection.CreateCommand();
            try
            {
                DbTools.PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters);
                if (connectionOwnership == DbConnectionOwnership.External)
                {
                    return new DbReader(cmd.ExecuteReader(), cmd);
                }
                else
                {
                    return new DbReader(cmd.ExecuteReader(CommandBehavior.CloseConnection), cmd);
                }
            }
            catch (Exception ex)
            {
                connection.Close();
                DbTools.WriteDbException(ex, cmd);
                throw ex;
            }
        }
        #endregion 执行SQL语句,返回一个数据读取器

        #region 执行SQL语句,返回一个数据表

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(string connectionString, string commandText)
        {
            return ExecuteDataTable(connectionString, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(DB2Connection connection, string commandText)
        {
            return ExecuteDataTable(connection, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(DB2Transaction transaction, string commandText)
        {
            return ExecuteDataTable(transaction, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(string connectionString, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteDataTable(connectionString, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(DB2Connection connection, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteDataTable(connection, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(DB2Transaction transaction, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteDataTable(transaction, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(string connectionString, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                return ExecuteDataTable(connection, commandText, commandType, commandParameters);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(DB2Connection connection, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, connection, (DB2Transaction)null, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    DataTable dt = new DataTable();
                    try
                    {
                        da.Fill(dt);
                        return new DataTableResult(dt, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据表
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult ExecuteDataTable(DB2Transaction transaction, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = transaction.Connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    DataTable dt = new DataTable();
                    try
                    {
                        da.Fill(dt);
                        return new DataTableResult(dt, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }
        #endregion 执行SQL语句,返回一个数据表

        #region 执行SQL语句,填充一个数据表

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(string connectionString, DataTable dt, string commandText)
        {
            return FillDataTable(connectionString, dt, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(DB2Connection connection, DataTable dt, string commandText)
        {
            return FillDataTable(connection, dt, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(DB2Transaction transaction, DataTable dt, string commandText)
        {
            return FillDataTable(transaction, dt, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(string connectionString, DataTable dt, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataTable(connectionString, dt, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(DB2Connection connection, DataTable dt, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataTable(connection, dt, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(DB2Transaction transaction, DataTable dt, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataTable(transaction, dt, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(string connectionString, DataTable dt, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                return FillDataTable(connection, dt, commandText, commandType, commandParameters);
            }
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(DB2Connection connection, DataTable dt, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, connection, (DB2Transaction)null, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    try
                    {
                        da.Fill(dt);
                        return new DataTableResult(dt, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }

        /// <summary>
        /// 执行SQL语句,填充一个数据表
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="dt">要填充的数据表</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据表</returns>
        public static DataTableResult FillDataTable(DB2Transaction transaction, DataTable dt, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = transaction.Connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    try
                    {
                        da.Fill(dt);
                        return new DataTableResult(dt, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }
        #endregion 执行SQL语句,返回一个数据表

        #region 执行SQL语句,返回一个数据集

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(string connectionString, string commandText)
        {
            return ExecuteDataSet(connectionString, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(DB2Connection connection, string commandText)
        {
            return ExecuteDataSet(connection, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(DB2Transaction transaction, string commandText)
        {
            return ExecuteDataSet(transaction, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(string connectionString, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteDataSet(connectionString, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(DB2Connection connection, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteDataSet(connection, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(DB2Transaction transaction, string commandText, params DB2Parameter[] commandParameters)
        {
            return ExecuteDataSet(transaction, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(string connectionString, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                return ExecuteDataSet(connection, commandText, commandType, commandParameters);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(DB2Connection connection, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, connection, (DB2Transaction)null, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        da.Fill(ds);
                        return new DataSetResult(ds, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }

                }
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult ExecuteDataSet(DB2Transaction transaction, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = transaction.Connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        da.Fill(ds);
                        return new DataSetResult(ds, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }

                }
            }
        }
        /// <summary>
        /// 执行SQL语句,返回结果填充一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string connectionString, string commandText)
        {
            return FillDataSet(ds, connectionString, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, DB2Connection connection, string commandText)
        {
            return FillDataSet(ds, connection, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, DB2Transaction transaction, string commandText)
        {
            return FillDataSet(ds, transaction, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string connectionString, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataSet(ds, connectionString, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, DB2Connection connection, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataSet(ds, connection, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, DB2Transaction transaction, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataSet(ds, transaction, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string connectionString, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                return FillDataSet(ds, connection, commandText, commandType, commandParameters);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, DB2Connection connection, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, connection, (DB2Transaction)null, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    try
                    {
                        if (ds == null)
                        {
                            throw new Exception("要填充的数据集不能为空");
                        }
                        da.Fill(ds);
                        return new DataSetResult(ds, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, DB2Transaction transaction, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = transaction.Connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    try
                    {
                        if (ds == null)
                        {
                            throw new Exception("要填充的数据集不能为空");
                        }
                        da.Fill(ds);
                        return new DataSetResult(ds, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }

        /// <summary>
        /// 执行SQL语句,返回结果填充一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, string connectionString, string commandText)
        {
            return FillDataSet(ds, srcTable, connectionString, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, DB2Connection connection, string commandText)
        {
            return FillDataSet(ds, srcTable, connection, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, DB2Transaction transaction, string commandText)
        {
            return FillDataSet(ds, srcTable, transaction, commandText, CommandType.Text, null);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, string connectionString, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataSet(ds, srcTable, connectionString, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, DB2Connection connection, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataSet(ds, srcTable, connection, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, DB2Transaction transaction, string commandText, params DB2Parameter[] commandParameters)
        {
            return FillDataSet(ds, srcTable, transaction, commandText, CommandType.StoredProcedure, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, string connectionString, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                return FillDataSet(ds, srcTable, connection, commandText, commandType, commandParameters);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, DB2Connection connection, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, connection, (DB2Transaction)null, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    try
                    {
                        if (ds == null)
                        {
                            throw new Exception("要填充的数据集不能为空");
                        }
                        da.Fill(ds, srcTable);
                        return new DataSetResult(ds, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }

        /// <summary>
        /// 执行SQL语句,返回一个数据集
        /// </summary>
        /// <param name="ds">要填充的数据集</param>
        /// <param name="srcTable">要填充的数据集的表的名称</param>
        /// <param name="transaction">数据库连接上的事务</param>
        /// <param name="commandType">数据库命令的类型</param>
        /// <param name="commandText">数据库命令的文本</param>
        /// <param name="commandParameters">数据库命令的参数</param>
        /// <returns>返回一个数据集</returns>
        public static DataSetResult FillDataSet(DataSet ds, string srcTable, DB2Transaction transaction, string commandText, CommandType commandType, params DB2Parameter[] commandParameters)
        {
            using (DB2Command cmd = transaction.Connection.CreateCommand())
            {
                DbTools.PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
                using (DB2DataAdapter da = new DB2DataAdapter(cmd))
                {
                    try
                    {
                        if (ds == null)
                        {
                            throw new Exception("要填充的数据集不能为空");
                        }
                        da.Fill(ds, srcTable);
                        return new DataSetResult(ds, cmd);
                    }
                    catch (Exception ex)
                    {
                        DbTools.WriteDbException(ex, cmd);
                        throw ex;
                    }
                }
            }
        }

        #endregion 执行SQL语句,返回一个数据集

        #region 执行事务
        /// <summary>
        /// 执行一系列的事务
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commands">数据库命令</param>
        public static void ExecuteTransaction(string connectionString, List<string> commands)
        {
            using (DB2Connection conn = CreateConnection(connectionString))
            {
                ExecuteTransaction(conn, commands);
            }
        }

        /// <summary>
        /// 执行一系列的事务
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="commands">数据库命令</param>
        public static void ExecuteTransaction(DB2Connection connection, List<string> commands)
        {
            bool connisopen = true;
            if (connection.State != ConnectionState.Open)
            {
                connisopen = false;
                connection.Open();
            }

            using (IDbCommand cmd = connection.CreateCommand())
            using (IDbTransaction trans = connection.BeginTransaction())
            {
                try
                {
                    ExecuteTransaction((DB2Transaction)trans, commands);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }
                finally
                {
                    if (connisopen == false)
                    {
                        connection.Close();
                    }
                }
            }
        }

        /// <summary>
        /// 在一个事务上执行SQL语句.执行完后不提交,出错后也不回滚,需要手动处理
        /// </summary>
        /// <param name="transaction">数据库事务</param>
        /// <param name="commands">要执行的命令列表</param>
        public static void ExecuteTransaction(DB2Transaction transaction, List<string> commands)
        {
            using (IDbCommand cmd = transaction.Connection.CreateCommand())
            {
                try
                {
                    foreach (string command in commands)
                    {
                        DbTools.PrepareCommand(cmd, transaction.Connection, transaction, CommandType.Text, command, null);
                        cmd.ExecuteNonQuery();
                    }
                }
                catch (Exception ex)
                {
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }
            }
        }

        /// <summary>
        /// 执行一系列的事务
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commands">数据库命令</param>
        public static void ExecuteTransaction(string connectionString, List<Lvl.Db.DbCommand> commands)
        {
            using (DB2Connection conn = new DB2Connection(connectionString))
            {
                ExecuteTransaction(conn, commands);
            }
        }

        /// <summary>
        /// 执行一系列的事务
        /// </summary>
        /// <param name="connection">数据库连接对象</param>
        /// <param name="commands">数据库命令</param>
        public static void ExecuteTransaction(DB2Connection connection, List<Lvl.Db.DbCommand> commands)
        {
            bool connisopen = true;
            if (connection.State != ConnectionState.Open)
            {
                connisopen = false;
                connection.Open();
            }

            using (IDbCommand cmd = connection.CreateCommand())
            using (IDbTransaction trans = connection.BeginTransaction())
            {
                try
                {
                    ExecuteTransaction((DB2Transaction)trans, commands);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }
                finally
                {
                    if (connisopen == false)
                    {
                        connection.Close();
                    }
                }
            }
        }

        /// <summary>
        /// 在一个事务上执行SQL语句.执行完后不提交,出错后也不回滚,需要手动处理
        /// </summary>
        /// <param name="transaction">数据库事务</param>
        /// <param name="commands">要执行的命令列表</param>
        public static void ExecuteTransaction(DB2Transaction transaction, List<Lvl.Db.DbCommand> commands)
        {
            using (IDbCommand cmd = transaction.Connection.CreateCommand())
            {
                try
                {
                    foreach (Lvl.Db.DbCommand command in commands)
                    {
                        DbTools.PrepareCommand(cmd, transaction.Connection, transaction, command.CommandType, command.CommandText, command.Parameters);
                        cmd.ExecuteNonQuery();
                    }
                }
                catch (Exception ex)
                {
                    DbTools.WriteDbException(ex, cmd);
                    throw ex;
                }
            }
        }

        #endregion

        #region 返回数据库架构信息

        /// <summary>
        /// 返回数据库的架构信息
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <returns>数据库的架构信息</returns>    
        public static DataTable GetSchema(string connectionString)
        {
            return GetSchema(connectionString, null, null);
        }

        /// <summary>
        /// 返回数据库的架构信息
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="collectionName">要返回的字段</param>
        /// <returns>数据库的架构信息</returns>    
        public static DataTable GetSchema(string connectionString, string collectionName)
        {
            return GetSchema(connectionString, collectionName, null);
        }

        /// <summary>
        /// 返回数据库的架构信息
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="collectionName">要返回的字段</param>
        /// <param name="restrictionValues">要返回的字段的约束</param>
        /// <returns>数据库的架构信息</returns>    
        public static DataTable GetSchema(string connectionString, string collectionName, string[] restrictionValues)
        {
            using (DB2Connection connection = new DB2Connection(connectionString))
            {
                connection.Open();
                if (string.IsNullOrEmpty(collectionName))
                {
                    return connection.GetSchema();
                }
                else if (!string.IsNullOrEmpty(collectionName) && restrictionValues == null)
                {
                    return connection.GetSchema(collectionName);
                }
                else
                {
                    return connection.GetSchema(collectionName, restrictionValues);
                }
            }
        }

        /// <summary>
        /// 返回数据库的架构信息
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <returns>数据库的架构信息</returns>
        public static DataTable GetSchema(DB2Connection connection)
        {
            return GetSchema(connection, null, null);
        }

        /// <summary>
        /// 返回数据库的架构信息
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="collectionName">要返回的字段</param>
        /// <returns>数据库的架构信息</returns>
        public static DataTable GetSchema(DB2Connection connection, string collectionName)
        {
            return GetSchema(connection, collectionName, null);
        }

        /// <summary>
        /// 返回数据库的架构信息
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="collectionName">要返回的字段</param>
        /// <param name="restrictionValues">要返回的字段的约束</param>
        /// <returns>数据库的架构信息</returns>
        public static DataTable GetSchema(DB2Connection connection, string collectionName, string[] restrictionValues)
        {
            bool isOpend = true;
            if (connection.State != ConnectionState.Open)
            {
                isOpend = false;
                connection.Open();
            }
            DataTable dt = null;
            if (string.IsNullOrEmpty(collectionName))
            {
                dt = connection.GetSchema();
            }
            else if (!string.IsNullOrEmpty(collectionName) && restrictionValues == null)
            {
                dt = connection.GetSchema(collectionName);
            }
            else
            {
                dt = connection.GetSchema(collectionName, restrictionValues);
            }
            if (!isOpend)
            {
                connection.Close();
            }
            return dt;
        }
        #endregion 返回数据库架构信息
    }
}