zoukankan      html  css  js  c++  java
  • 自用类库整理之SqlHelper和MySqlHelper

    自用类库整理之SqlHelper和MySqlHelper

    自用的SQLHelper和MySqlHelper,除一些通用方法外,封装了一些很实用的批量操作方法,简单介绍下

    SqlHelper

    • ExecuteEmptyDataTable
      获取空表结构,主要用于需要构造DataTable进行大批量数据插入时使用
    • BulkInsert
      大批量数据插入,使用SqlBulkCopy进行大批量数据导入,仅提供了DataTable方式,需要DataReader的请自行重载
    • BatchDelete、BatchUpdate
      批量数据更新、插入,使用SqlDataAdapter实现,需要进行较大数据量更新、插入时可以使用此方法,性能还不错BatchUpdate,BatchDelete:分批次批量删除、更新数据,此方法应用场景较少,用于需要删除、更新大量数据的同时不造成数据库阻塞且不影响数据库订阅、复制延时等
    • ExecutePageDataTable
      通用的分页方法,提供了CTE表达式的支持
    • SqlHelperExtension.cs(ExecuteObject、ExecuteObjects)
      提供了泛型获取对象方法支持,依赖依赖AutoMapper.dll实现,非常在意性能的慎用
    • SqlHelperSchemaExtension.cs
      SqlServer获取数据库、表、索引信息的封装,可以用来辅助写自己的代码生成器,查看数据库索引之类的

    MySqlHelper

    • ExecuteEmptyDataTable
      获取空表结构,主要用于需要构造DataTable进行大批量数据插入时使用
    • BulkInsert
      使用MySqlBulkLoader进行大批量数据导入,仅提供了DataTable方式,需要DataReader的请自行重载
    • BatchUpdate
      批量数据更新、插入,使用MySqlDataAdapter实现,需要进行较大数据量更新、插入时可以使用此方法,性能还不错
    • MySqlHelperExtension.csExecuteObject、ExecuteObjects
      提供了泛型获取对象方法支持,依赖依赖AutoMapper.dll实现,非常在意性能的慎用
     SqlHelper.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Data.SqlClient;
    using System.Data;
    using System.Text.RegularExpressions;

    namespace Helpers
    {
    /// <summary>
    /// SqlHelper操作类
    /// </summary>
    public sealed partial class SqlHelper
    {
    /// <summary>
    /// 批量操作每批次记录数
    /// </summary>
    public static int BatchSize = 2000;

    /// <summary>
    /// 超时时间
    /// </summary>
    public static int CommandTimeOut = 600;

    /// <summary>
    ///初始化SqlHelper实例
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    public SqlHelper(string connectionString)
    {
    this.ConnectionString = connectionString;
    }

    /// <summary>
    /// 数据库连接字符串
    /// </summary>
    public string ConnectionString { get; set; }

    #region 实例方法

    #region ExecuteNonQuery

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public int ExecuteNonQuery(string commandText, params SqlParameter[] parms)
    {
    return ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public int ExecuteNonQuery(CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteNonQuery(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteNonQuery

    #region ExecuteScalar

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <typeparam name="T">返回对象类型</typeparam>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public T ExecuteScalar<T>(string commandText, params SqlParameter[] parms)
    {
    return ExecuteScalar<T>(ConnectionString, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public object ExecuteScalar(string commandText, params SqlParameter[] parms)
    {
    return ExecuteScalar(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public object ExecuteScalar(CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteScalar(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteScalar

    #region ExecuteDataReader

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private SqlDataReader ExecuteDataReader(string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataReader(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private SqlDataReader ExecuteDataReader(CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataReader(ConnectionString, commandType, commandText, parms);
    }
    #endregion

    #region ExecuteDataRow

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行</returns>
    public DataRow ExecuteDataRow(string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataRow(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行</returns>
    public DataRow ExecuteDataRow(CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataRow(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteDataRow

    #region ExecuteDataTable

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public DataTable ExecuteDataTable(string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataTable(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public DataTable ExecuteDataTable(CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(ConnectionString, commandType, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="sql">SQL语句</param>
    /// <param name="order">排序SQL,如"ORDER BY ID DESC"</param>
    /// <param name="pageSize">每页记录数</param>
    /// <param name="pageIndex">页索引</param>
    /// <param name="parms">查询参数</param>
    /// <param name="query">查询SQL</param>
    /// <returns></returns>
    public DataTable ExecutePageDataTable(string sql, string order, int pageSize, int pageIndex, SqlParameter[] parms = null, string query = null, string cte = null)
    {
    return ExecutePageDataTable(sql, order, pageSize, pageIndex, parms, query, cte);
    }
    #endregion ExecuteDataTable

    #region ExecuteDataSet

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public DataSet ExecuteDataSet(string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public DataSet ExecuteDataSet(CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteDataSet

    #region 批量操作

    /// <summary>
    /// 大批量数据插入
    /// </summary>
    /// <param name="table">数据表</param>
    public void BulkInsert(DataTable table)
    {
    BulkInsert(ConnectionString, table);
    }

    /// <summary>
    /// 使用MySqlDataAdapter批量更新数据
    /// </summary>
    /// <param name="table">数据表</param>
    public void BatchUpdate(DataTable table)
    {
    BatchUpdate(ConnectionString, table);
    }

    /// <summary>
    /// 分批次批量删除数据
    /// </summary>
    /// <param name="sql">SQL语句</param>
    /// <param name="batchSize">每批次删除记录行数</param>
    /// <param name="interval">批次执行间隔(秒)</param>
    public void BatchDelete(string sql, int batchSize = 1000, int interval = 1)
    {
    BatchDelete(ConnectionString, sql, batchSize, interval);
    }

    /// <summary>
    /// 分批次批量更新数据
    /// </summary>
    /// <param name="sql">SQL语句</param>
    /// <param name="batchSize">每批次更新记录行数</param>
    /// <param name="interval">批次执行间隔(秒)</param>
    public void BatchUpdate(string sql, int batchSize = 1000, int interval = 1)
    {
    BatchUpdate(ConnectionString, sql, batchSize, interval);
    }

    #endregion 批量操作

    #endregion 实例方法

    #region 静态方法

    private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] parms)
    {
    if (connection.State != ConnectionState.Open) connection.Open();

    command.Connection = connection;
    command.CommandTimeout = CommandTimeOut;
    // 设置命令文本(存储过程名或SQL语句)
    command.CommandText = commandText;
    // 分配事务
    if (transaction != null)
    {
    command.Transaction = transaction;
    }
    // 设置命令类型.
    command.CommandType = commandType;
    if (parms != null && parms.Length > 0)
    {
    //预处理SqlParameter参数数组,将为NULL的参数赋值为DBNull.Value;
    foreach (SqlParameter parameter in parms)
    {
    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
    {
    parameter.Value = DBNull.Value;
    }
    }
    command.Parameters.AddRange(parms);
    }
    }

    #region ExecuteNonQuery

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(string connectionString, string commandText, params SqlParameter[] parms)
    {
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
    return ExecuteNonQuery(connection, CommandType.Text, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
    return ExecuteNonQuery(connection, commandType, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteNonQuery(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteNonQuery(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    private static int ExecuteNonQuery(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    SqlCommand command = new SqlCommand();
    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    int retval = command.ExecuteNonQuery();
    command.Parameters.Clear();
    return retval;
    }

    #endregion ExecuteNonQuery

    #region ExecuteScalar

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <typeparam name="T">返回对象类型</typeparam>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static T ExecuteScalar<T>(string connectionString, string commandText, params SqlParameter[] parms)
    {
    object result = ExecuteScalar(connectionString, commandText, parms);
    if (result != null)
    {
    return (T)Convert.ChangeType(result, typeof(T)); ;
    }
    return default(T);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(string connectionString, string commandText, params SqlParameter[] parms)
    {
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
    return ExecuteScalar(connection, CommandType.Text, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
    return ExecuteScalar(connection, commandType, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteScalar(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteScalar(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    private static object ExecuteScalar(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    SqlCommand command = new SqlCommand();
    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    object retval = command.ExecuteScalar();
    command.Parameters.Clear();
    return retval;
    }

    #endregion ExecuteScalar

    #region ExecuteDataReader

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static SqlDataReader ExecuteDataReader(string connectionString, string commandText, params SqlParameter[] parms)
    {
    SqlConnection connection = new SqlConnection(connectionString);
    return ExecuteDataReader(connection, null, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static SqlDataReader ExecuteDataReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    SqlConnection connection = new SqlConnection(connectionString);
    return ExecuteDataReader(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static SqlDataReader ExecuteDataReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataReader(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static SqlDataReader ExecuteDataReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataReader(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static SqlDataReader ExecuteDataReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    SqlCommand command = new SqlCommand();
    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    return command.ExecuteReader(CommandBehavior.CloseConnection);
    }

    #endregion

    #region ExecuteDataRow

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(string connectionString, string commandText, params SqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(connectionString, CommandType.Text, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(connectionString, commandType, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(connection, commandType, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(transaction, commandType, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    #endregion ExecuteDataRow

    #region ExecuteDataTable

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(string connectionString, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(connectionString, commandType, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(connection, commandType, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(transaction, commandType, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 获取空表结构
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="tableName">数据表名称</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteEmptyDataTable(string connectionString, string tableName)
    {
    return ExecuteDataSet(connectionString, CommandType.Text, string.Format("select * from {0} where 1=-1", tableName)).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="sql">SQL语句</param>
    /// <param name="order">排序SQL,如"ORDER BY ID DESC"</param>
    /// <param name="pageSize">每页记录数</param>
    /// <param name="pageIndex">页索引</param>
    /// <param name="parms">查询参数</param>
    /// <param name="query">查询SQL</param>
    /// <param name="cte">CTE表达式</param>
    /// <returns></returns>
    public static DataTable ExecutePageDataTable(string connectionString, string sql, string order, int pageSize, int pageIndex, SqlParameter[] parms = null, string query = null, string cte = null)
    {
    string psql = string.Format(@"
    {3}
    SELECT *
    FROM (
    SELECT ROW_NUMBER() OVER (ORDER BY {1}) RowNumber,*
    FROM (
    {0}
    ) t
    WHERE 1 = 1 {2}
    ) t
    WHERE RowNumber BETWEEN @RowNumber_Begin
    AND @RowNumber_End", sql, order, query, cte);

    List<SqlParameter> paramlist = new List<SqlParameter>()
    {
    new SqlParameter("@RowNumber_Begin", SqlDbType.Int){ Value = (pageIndex - 1) * pageSize + 1 },
    new SqlParameter("@RowNumber_End", SqlDbType.Int){ Value = pageIndex * pageSize }
    };
    if (parms != null) paramlist.AddRange(parms);
    return ExecuteDataTable(connectionString, psql, paramlist.ToArray());
    }

    #endregion ExecuteDataTable

    #region ExecuteDataSet

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(string connectionString, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
    return ExecuteDataSet(connection, commandType, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    return ExecuteDataSet(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    private static DataSet ExecuteDataSet(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
    {
    SqlCommand command = new SqlCommand();

    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    SqlDataAdapter adapter = new SqlDataAdapter(command);

    DataSet ds = new DataSet();
    adapter.Fill(ds);
    if (commandText.IndexOf("@") > 0)
    {
    commandText = commandText.ToLower();
    int index = commandText.IndexOf("where ");
    if (index < 0)
    {
    index = commandText.IndexOf(" where");
    }
    if (index > 0)
    {
    ds.ExtendedProperties.Add("SQL", commandText.Substring(0, index - 1)); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
    }
    else
    {
    ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
    }
    }
    else
    {
    ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
    }

    foreach (DataTable dt in ds.Tables)
    {
    dt.ExtendedProperties.Add("SQL", ds.ExtendedProperties["SQL"]);
    }

    command.Parameters.Clear();
    return ds;
    }

    #endregion ExecuteDataSet

    #region 批量操作

    /// <summary>
    /// 大批量数据插入
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="table">数据表</param>
    public static void BulkInsert(string connectionString, DataTable table)
    {
    if (string.IsNullOrEmpty(table.TableName)) throw new Exception("DataTable.TableName属性不能为空");
    using (SqlBulkCopy bulk = new SqlBulkCopy(connectionString))
    {
    bulk.BatchSize = BatchSize;
    bulk.BulkCopyTimeout = CommandTimeOut;
    bulk.DestinationTableName = table.TableName;
    foreach (DataColumn col in table.Columns)
    {
    bulk.ColumnMappings.Add(col.ColumnName, col.ColumnName);
    }
    bulk.WriteToServer(table);
    bulk.Close();
    }
    }

    /// <summary>
    /// 使用MySqlDataAdapter批量更新数据
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="table">数据表</param>
    public static void BatchUpdate(string connectionString, DataTable table)
    {
    SqlConnection connection = new SqlConnection(connectionString);

    SqlCommand command = connection.CreateCommand();
    command.CommandTimeout = CommandTimeOut;
    command.CommandType = CommandType.Text;
    SqlDataAdapter adapter = new SqlDataAdapter(command);
    SqlCommandBuilder commandBulider = new SqlCommandBuilder(adapter);
    commandBulider.ConflictOption = ConflictOption.OverwriteChanges;

    SqlTransaction transaction = null;
    try
    {
    connection.Open();
    transaction = connection.BeginTransaction();
    //设置批量更新的每次处理条数
    adapter.UpdateBatchSize = BatchSize;
    //设置事物
    adapter.SelectCommand.Transaction = transaction;

    if (table.ExtendedProperties["SQL"] != null)
    {
    adapter.SelectCommand.CommandText = table.ExtendedProperties["SQL"].ToString();
    }
    adapter.Update(table);
    transaction.Commit();/////提交事务
    }
    catch (SqlException ex)
    {
    if (transaction != null) transaction.Rollback();
    throw ex;
    }
    finally
    {
    connection.Close();
    connection.Dispose();
    }
    }

    /// <summary>
    /// 分批次批量删除数据
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="sql">SQL语句</param>
    /// <param name="batchSize">每批次更新记录行数</param>
    /// <param name="interval">批次执行间隔(秒)</param>
    public static void BatchDelete(string connectionString, string sql, int batchSize = 1000, int interval = 1)
    {
    sql = sql.ToLower();

    if (batchSize < 1000) batchSize = 1000;
    if (interval < 1) interval = 1;
    while (ExecuteScalar(connectionString, sql.Replace("delete", "select top 1 1")) != null)
    {
    ExecuteNonQuery(connectionString, CommandType.Text, sql.Replace("delete", string.Format("delete top ({0})", batchSize)));
    System.Threading.Thread.Sleep(interval * 1000);
    }
    }

    /// <summary>
    /// 分批次批量更新数据
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="sql">SQL语句</param>
    /// <param name="batchSize">每批次更新记录行数</param>
    /// <param name="interval">批次执行间隔(秒)</param>
    public static void BatchUpdate(string connectionString, string sql, int batchSize = 1000, int interval = 1)
    {
    if (batchSize < 1000) batchSize = 1000;
    if (interval < 1) interval = 1;
    string existsSql = Regex.Replace(sql, @"[ws.=,']*from", "select top 1 1 from", RegexOptions.IgnoreCase);
    existsSql = Regex.Replace(existsSql, @"set[ws.=,']* where", "where", RegexOptions.IgnoreCase);
    existsSql = Regex.Replace(existsSql, @"update", "select top 1 1 from", RegexOptions.IgnoreCase);
    while (ExecuteScalar<int>(connectionString, existsSql) != 0)
    {
    ExecuteNonQuery(connectionString, CommandType.Text, Regex.Replace(sql, "update", string.Format("update top ({0})", batchSize), RegexOptions.IgnoreCase));
    System.Threading.Thread.Sleep(interval * 1000);
    }
    }

    #endregion 批量操作

    #endregion 静态方法
    }
    }

    SqlHelper.cs

     SqlHelperExtension.cs

    using System;
    using System.Configuration;
    using System.Data;
    using System.Data.SqlClient;
    using System.Linq;
    using System.Collections.Generic;
    using System.Threading;
    using System.Text.RegularExpressions;
    namespace Helpers
    {
    /// <summary>
    /// SqlHelper扩展(依赖AutoMapper.dll)
    /// </summary>
    public sealed partial class SqlHelper
    {

    #region 实例方法

    public T ExecuteObject<T>(string commandText, params SqlParameter[] parms)
    {
    return ExecuteObject<T>(this.ConnectionString, commandText, parms);
    }

    public List<T> ExecuteObjects<T>(string commandText, params SqlParameter[] parms)
    {
    return ExecuteObjects<T>(this.ConnectionString, commandText, parms);
    }

    #endregion

    #region 静态方法

    public static T ExecuteObject<T>(string connectionString, string commandText, params SqlParameter[] parms)
    {
    //DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
    //return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader()).FirstOrDefault();
    using (SqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
    {
    return AutoMapper.Mapper.DynamicMap<List<T>>(reader).FirstOrDefault();
    }
    }

    public static List<T> ExecuteObjects<T>(string connectionString, string commandText, params SqlParameter[] parms)
    {
    //DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
    //return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader());
    using (SqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
    {
    return AutoMapper.Mapper.DynamicMap<List<T>>(reader);
    }
    }

    #endregion
    }

    }

    SqlHelperExtension.cs

     SqlHelperSchemaExtension.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Data;
    using System.Data.SqlClient;

    namespace Helpers
    {
    public sealed partial class SqlHelper
    {
    #region Schema 数据库结构
    /// <summary>
    /// 执行指定数据库连接字符串的命令,返回服务器数据库名称数组
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <returns></returns>
    public string[] GetDatabases(string connectionString)
    {
    string sql = "select name from sys.databases where name not in ('master','model','msdb','tempdb')";
    DataTable dt = ExecuteDataTable(connectionString, sql);
    return dt.Rows.Cast<DataRow>().Select(row => row["name"].ToString()).ToArray();
    }
    /// <summary>
    /// 执行指定数据库连接字符串的命令,返回指定数据库的表信息
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="database"></param>
    /// <returns></returns>
    public List<DbTable> GetDbTables(string connectionString, string database)
    {
    #region SQL
    string sql = string.Format(@"SELECT
    obj.name tablename,
    schem.name schemname,
    idx.rows,
    CAST
    (
    CASE
    WHEN (SELECT COUNT(1) FROM sys.indexes WHERE object_id= obj.OBJECT_ID AND is_primary_key=1) >=1 THEN 1
    ELSE 0
    END
    AS BIT) HasPrimaryKey
    from {0}.sys.objects obj
    inner join {0}.dbo.sysindexes idx on obj.object_id=idx.id and idx.indid<=1
    INNER JOIN {0}.sys.schemas schem ON obj.schema_id=schem.schema_id
    where type='U'
    order by obj.name", database);
    #endregion
    DataTable dt = ExecuteDataTable(connectionString.Replace("master", database), sql);
    return dt.Rows.Cast<DataRow>().Select(row => new DbTable
    {
    TableName = row.Field<string>("tablename"),
    SchemaName = row.Field<string>("schemname"),
    Rows = row.Field<int>("rows"),
    HasPrimaryKey = row.Field<bool>("HasPrimaryKey")
    }).ToList();
    }
    /// <summary>
    /// 执行指定数据库连接字符串的命令,返回指定数据库、表的字段信息
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="database"></param>
    /// <param name="tableName"></param>
    /// <param name="schema"></param>
    /// <returns></returns>
    public List<DbColumn> GetDbColumns(string connectionString, string database, string tableName, string schema = "dbo")
    {
    #region SQL
    string sql = string.Format(@"
    WITH indexCTE AS
    (
    SELECT
    ic.column_id,
    ic.index_column_id,
    ic.object_id
    FROM {0}.sys.indexes idx
    INNER JOIN {0}.sys.index_columns ic ON idx.index_id = ic.index_id AND idx.object_id = ic.object_id
    WHERE idx.object_id =OBJECT_ID(@tableName) AND idx.is_primary_key=1
    )
    select
    colm.column_id ColumnID,
    CAST(CASE WHEN indexCTE.column_id IS NULL THEN 0 ELSE 1 END AS BIT) IsPrimaryKey,
    colm.name ColumnName,
    systype.name ColumnType,
    colm.is_identity IsIdentity,
    colm.is_nullable IsNullable,
    cast(colm.max_length as int) ByteLength,
    (
    case
    when systype.name='nvarchar' and colm.max_length>0 then colm.max_length/2
    when systype.name='nchar' and colm.max_length>0 then colm.max_length/2
    when systype.name='ntext' and colm.max_length>0 then colm.max_length/2
    else colm.max_length
    end
    ) CharLength,
    cast(colm.precision as int) Precision,
    cast(colm.scale as int) Scale,
    prop.value Remark
    from {0}.sys.columns colm
    inner join {0}.sys.types systype on colm.system_type_id=systype.system_type_id and colm.user_type_id=systype.user_type_id
    left join {0}.sys.extended_properties prop on colm.object_id=prop.major_id and colm.column_id=prop.minor_id
    LEFT JOIN indexCTE ON colm.column_id=indexCTE.column_id AND colm.object_id=indexCTE.object_id
    where colm.object_id=OBJECT_ID(@tableName)
    order by colm.column_id", database);
    #endregion
    SqlParameter param = new SqlParameter("@tableName", SqlDbType.NVarChar, 100) { Value = string.Format("{0}.{1}.{2}", database, schema, tableName) };
    DataTable dt = ExecuteDataTable(connectionString, sql, param);
    return dt.Rows.Cast<DataRow>().Select(row => new DbColumn()
    {
    ColumnID = row.Field<int>("ColumnID"),
    IsPrimaryKey = row.Field<bool>("IsPrimaryKey"),
    ColumnName = row.Field<string>("ColumnName"),
    ColumnType = row.Field<string>("ColumnType"),
    IsIdentity = row.Field<bool>("IsIdentity"),
    IsNullable = row.Field<bool>("IsNullable"),
    ByteLength = row.Field<int>("ByteLength"),
    CharLength = row.Field<int>("CharLength"),
    Scale = row.Field<int>("Scale"),
    Remark = row["Remark"].ToString()
    }).ToList();
    }
    /// <summary>
    /// 执行指定数据库连接字符串的命令,返回指定数据库、表的索引信息
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="database"></param>
    /// <param name="tableName"></param>
    /// <param name="schema"></param>
    /// <returns></returns>
    public List<DbIndex> GetDbIndexs(string connectionString, string database, string tableName, string schema = "dbo")
    {
    #region SQL
    string sql = string.Format(@"
    select
    idx.name IndexName
    ,idx.type_desc IndexType
    ,idx.is_primary_key IsPrimaryKey
    ,idx.is_unique IsUnique
    ,idx.is_unique_constraint IsUniqueConstraint
    ,STUFF(
    (
    SELECT ','+c.name from {0}.sys.index_columns ic
    inner join {0}.sys.columns c on ic.column_id=c.column_id and ic.object_id=c.object_id
    WHERE ic.is_included_column = 0 and ic.index_id=idx.index_id AND ic.object_id=idx.object_id
    ORDER BY ic.key_ordinal
    FOR XML PATH('')
    ),1,1,'') IndexColumns
    ,STUFF(
    (
    SELECT ','+c.name from {0}.sys.index_columns ic
    inner join {0}.sys.columns c on ic.column_id=c.column_id and ic.object_id=c.object_id
    WHERE ic.is_included_column = 1 and ic.index_id=idx.index_id AND ic.object_id=idx.object_id
    ORDER BY ic.key_ordinal
    FOR XML PATH('')
    ),1,1,'') IncludeColumns
    from {0}.sys.indexes idx
    where object_id =OBJECT_ID(@tableName)", database);
    #endregion
    SqlParameter param = new SqlParameter("@tableName", SqlDbType.NVarChar, 100) { Value = string.Format("{0}.{1}.{2}", database, schema, tableName) };
    DataTable dt = ExecuteDataTable(connectionString, sql, param);
    return dt.Rows.Cast<DataRow>().Select(row => new DbIndex()
    {
    IndexName = row.Field<string>("IndexName"),
    IndexType = row.Field<string>("IndexType"),
    IsPrimaryKey = row.Field<bool>("IsPrimaryKey"),
    IsUnique = row.Field<bool>("IsUnique"),
    IsUniqueConstraint = row.Field<bool>("IsUniqueConstraint"),
    IndexColumns = row.Field<string>("IndexColumns"),
    IncludeColumns = row.Field<string>("IncludeColumns")
    }).ToList();
    }
    #endregion
    }

    /// <summary>
    /// 表索引结构
    /// </summary>
    public sealed class DbIndex
    {
    /// <summary>
    /// 索引名称
    /// </summary>
    public string IndexName { get; set; }
    /// <summary>
    /// 索引类型
    /// </summary>
    public string IndexType { get; set; }
    /// <summary>
    /// 是否为主键
    /// </summary>
    public bool IsPrimaryKey { get; set; }

    /// <summary>
    /// 是否唯一索引
    /// </summary>
    public bool IsUnique { get; set; }
    /// <summary>
    /// 是否唯一约束
    /// </summary>
    public bool IsUniqueConstraint { get; set; }
    /// <summary>
    /// 索引列
    /// </summary>
    public string IndexColumns { get; set; }

    /// <summary>
    /// 覆盖索引列
    /// </summary>
    public string IncludeColumns { get; set; }
    }

    /// <summary>
    /// 表结构
    /// </summary>
    public sealed class DbTable
    {
    /// <summary>
    /// 表名称
    /// </summary>
    public string TableName { get; set; }
    /// <summary>
    /// 表的架构
    /// </summary>
    public string SchemaName { get; set; }
    /// <summary>
    /// 表的记录数
    /// </summary>
    public int Rows { get; set; }

    /// <summary>
    /// 是否含有主键
    /// </summary>
    public bool HasPrimaryKey { get; set; }
    }

    /// <summary>
    /// 表字段结构
    /// </summary>
    public sealed class DbColumn
    {
    /// <summary>
    /// 字段ID
    /// </summary>
    public int ColumnID { get; set; }

    /// <summary>
    /// 是否主键
    /// </summary>
    public bool IsPrimaryKey { get; set; }

    /// <summary>
    /// 字段名称
    /// </summary>
    public string ColumnName { get; set; }

    /// <summary>
    /// 字段类型
    /// </summary>
    public string ColumnType { get; set; }

    /// <summary>
    /// 数据库类型对应的C#类型
    /// </summary>
    public string CSharpType
    {
    get
    {
    return SqlMap.MapCsharpType(ColumnType);
    }
    }

    /// <summary>
    ///
    /// </summary>
    public Type CommonType
    {
    get
    {
    return SqlMap.MapCommonType(ColumnType);
    }
    }

    /// <summary>
    /// 字节长度
    /// </summary>
    public int ByteLength { get; set; }

    /// <summary>
    /// 字符长度
    /// </summary>
    public int CharLength { get; set; }

    /// <summary>
    /// 小数位
    /// </summary>
    public int Scale { get; set; }

    /// <summary>
    /// 是否自增列
    /// </summary>
    public bool IsIdentity { get; set; }

    /// <summary>
    /// 是否允许空
    /// </summary>
    public bool IsNullable { get; set; }

    /// <summary>
    /// 描述
    /// </summary>
    public string Remark { get; set; }
    }

    public class SqlMap
    {
    public static string MapCsharpType(string dbtype)
    {
    if (string.IsNullOrEmpty(dbtype)) return dbtype;
    dbtype = dbtype.ToLower();
    string csharpType = "object";
    switch (dbtype)
    {
    case "bigint": csharpType = "long"; break;
    case "binary": csharpType = "byte[]"; break;
    case "bit": csharpType = "bool"; break;
    case "char": csharpType = "string"; break;
    case "date": csharpType = "DateTime"; break;
    case "datetime": csharpType = "DateTime"; break;
    case "datetime2": csharpType = "DateTime"; break;
    case "datetimeoffset": csharpType = "DateTimeOffset"; break;
    case "decimal": csharpType = "decimal"; break;
    case "float": csharpType = "double"; break;
    case "image": csharpType = "byte[]"; break;
    case "int": csharpType = "int"; break;
    case "money": csharpType = "decimal"; break;
    case "nchar": csharpType = "string"; break;
    case "ntext": csharpType = "string"; break;
    case "numeric": csharpType = "decimal"; break;
    case "nvarchar": csharpType = "string"; break;
    case "real": csharpType = "Single"; break;
    case "smalldatetime": csharpType = "DateTime"; break;
    case "smallint": csharpType = "short"; break;
    case "smallmoney": csharpType = "decimal"; break;
    case "sql_variant": csharpType = "object"; break;
    case "sysname": csharpType = "object"; break;
    case "text": csharpType = "string"; break;
    case "time": csharpType = "TimeSpan"; break;
    case "timestamp": csharpType = "byte[]"; break;
    case "tinyint": csharpType = "byte"; break;
    case "uniqueidentifier": csharpType = "Guid"; break;
    case "varbinary": csharpType = "byte[]"; break;
    case "varchar": csharpType = "string"; break;
    case "xml": csharpType = "string"; break;
    default: csharpType = "object"; break;
    }
    return csharpType;
    }

    public static Type MapCommonType(string dbtype)
    {
    if (string.IsNullOrEmpty(dbtype)) return Type.Missing.GetType();
    dbtype = dbtype.ToLower();
    Type commonType = typeof(object);
    switch (dbtype)
    {
    case "bigint": commonType = typeof(long); break;
    case "binary": commonType = typeof(byte[]); break;
    case "bit": commonType = typeof(bool); break;
    case "char": commonType = typeof(string); break;
    case "date": commonType = typeof(DateTime); break;
    case "datetime": commonType = typeof(DateTime); break;
    case "datetime2": commonType = typeof(DateTime); break;
    case "datetimeoffset": commonType = typeof(DateTimeOffset); break;
    case "decimal": commonType = typeof(decimal); break;
    case "float": commonType = typeof(double); break;
    case "image": commonType = typeof(byte[]); break;
    case "int": commonType = typeof(int); break;
    case "money": commonType = typeof(decimal); break;
    case "nchar": commonType = typeof(string); break;
    case "ntext": commonType = typeof(string); break;
    case "numeric": commonType = typeof(decimal); break;
    case "nvarchar": commonType = typeof(string); break;
    case "real": commonType = typeof(Single); break;
    case "smalldatetime": commonType = typeof(DateTime); break;
    case "smallint": commonType = typeof(short); break;
    case "smallmoney": commonType = typeof(decimal); break;
    case "sql_variant": commonType = typeof(object); break;
    case "sysname": commonType = typeof(object); break;
    case "text": commonType = typeof(string); break;
    case "time": commonType = typeof(TimeSpan); break;
    case "timestamp": commonType = typeof(byte[]); break;
    case "tinyint": commonType = typeof(byte); break;
    case "uniqueidentifier": commonType = typeof(Guid); break;
    case "varbinary": commonType = typeof(byte[]); break;
    case "varchar": commonType = typeof(string); break;
    case "xml": commonType = typeof(string); break;
    default: commonType = typeof(object); break;
    }
    return commonType;
    }
    }
    }

    SqlHelperSchemaExtension.cs

     MySqlHelper.cs

    using System;
    using System.Data;
    using System.IO;
    using System.Linq;
    using System.Text;
    using MySql.Data.MySqlClient;

    namespace Helpers
    {
    /// <summary>
    /// MySqlHelper操作类
    /// </summary>
    public sealed partial class MySqlHelper
    {
    /// <summary>
    /// 批量操作每批次记录数
    /// </summary>
    public static int BatchSize = 2000;

    /// <summary>
    /// 超时时间
    /// </summary>
    public static int CommandTimeOut = 600;

    /// <summary>
    ///初始化MySqlHelper实例
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    public MySqlHelper(string connectionString)
    {
    this.ConnectionString = connectionString;
    }

    /// <summary>
    /// 数据库连接字符串
    /// </summary>
    public string ConnectionString { get; set; }

    #region 实例方法

    #region ExecuteNonQuery

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public int ExecuteNonQuery(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public int ExecuteNonQuery(CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteNonQuery(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteNonQuery

    #region ExecuteScalar

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <typeparam name="T">返回对象类型</typeparam>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public T ExecuteScalar<T>(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteScalar<T>(ConnectionString, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public object ExecuteScalar(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteScalar(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public object ExecuteScalar(CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteScalar(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteScalar

    #region ExecuteDataReader

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private MySqlDataReader ExecuteDataReader(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataReader(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private MySqlDataReader ExecuteDataReader(CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataReader(ConnectionString, commandType, commandText, parms);
    }
    #endregion

    #region ExecuteDataRow

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行</returns>
    public DataRow ExecuteDataRow(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataRow(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行</returns>
    public DataRow ExecuteDataRow(CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataRow(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteDataRow

    #region ExecuteDataTable

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public DataTable ExecuteDataTable(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataTable(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public DataTable ExecuteDataTable(CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(ConnectionString, commandType, commandText, parms).Tables[0];
    }

    #endregion ExecuteDataTable

    #region ExecuteDataSet

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public DataSet ExecuteDataSet(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(ConnectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public DataSet ExecuteDataSet(CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(ConnectionString, commandType, commandText, parms);
    }

    #endregion ExecuteDataSet

    #region 批量操作

    /// <summary>
    /// 使用MySqlDataAdapter批量更新数据
    /// </summary>
    /// <param name="table">数据表</param>
    public void BatchUpdate(DataTable table)
    {
    BatchUpdate(ConnectionString, table);
    }

    /// <summary>
    ///大批量数据插入,返回成功插入行数
    /// </summary>
    /// <param name="table">数据表</param>
    /// <returns>返回成功插入行数</returns>
    public int BulkInsert(DataTable table)
    {
    return BulkInsert(ConnectionString, table);
    }

    #endregion 批量操作

    #endregion 实例方法

    #region 静态方法

    private static void PrepareCommand(MySqlCommand command, MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, MySqlParameter[] parms)
    {
    if (connection.State != ConnectionState.Open) connection.Open();

    command.Connection = connection;
    command.CommandTimeout = CommandTimeOut;
    // 设置命令文本(存储过程名或SQL语句)
    command.CommandText = commandText;
    // 分配事务
    if (transaction != null)
    {
    command.Transaction = transaction;
    }
    // 设置命令类型.
    command.CommandType = commandType;
    if (parms != null && parms.Length > 0)
    {
    //预处理MySqlParameter参数数组,将为NULL的参数赋值为DBNull.Value;
    foreach (MySqlParameter parameter in parms)
    {
    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
    {
    parameter.Value = DBNull.Value;
    }
    }
    command.Parameters.AddRange(parms);
    }
    }

    #region ExecuteNonQuery

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    using (MySqlConnection connection = new MySqlConnection(connectionString))
    {
    return ExecuteNonQuery(connection, CommandType.Text, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    using (MySqlConnection connection = new MySqlConnection(connectionString))
    {
    return ExecuteNonQuery(connection, commandType, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteNonQuery(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    public static int ExecuteNonQuery(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteNonQuery(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回影响的行数
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回影响的行数</returns>
    private static int ExecuteNonQuery(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    MySqlCommand command = new MySqlCommand();
    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    int retval = command.ExecuteNonQuery();
    command.Parameters.Clear();
    return retval;
    }

    #endregion ExecuteNonQuery

    #region ExecuteScalar

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <typeparam name="T">返回对象类型</typeparam>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static T ExecuteScalar<T>(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    object result = ExecuteScalar(connectionString, commandText, parms);
    if (result != null)
    {
    return (T)Convert.ChangeType(result, typeof(T)); ;
    }
    return default(T);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    using (MySqlConnection connection = new MySqlConnection(connectionString))
    {
    return ExecuteScalar(connection, CommandType.Text, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    using (MySqlConnection connection = new MySqlConnection(connectionString))
    {
    return ExecuteScalar(connection, commandType, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteScalar(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    public static object ExecuteScalar(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteScalar(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行第一列
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一行第一列</returns>
    private static object ExecuteScalar(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    MySqlCommand command = new MySqlCommand();
    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    object retval = command.ExecuteScalar();
    command.Parameters.Clear();
    return retval;
    }

    #endregion ExecuteScalar

    #region ExecuteDataReader

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static MySqlDataReader ExecuteDataReader(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    MySqlConnection connection = new MySqlConnection(connectionString);
    return ExecuteDataReader(connection, null, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static MySqlDataReader ExecuteDataReader(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    MySqlConnection connection = new MySqlConnection(connectionString);
    return ExecuteDataReader(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataReader(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static MySqlDataReader ExecuteDataReader(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataReader(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回只读数据集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回只读数据集</returns>
    private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    MySqlCommand command = new MySqlCommand();
    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    return command.ExecuteReader(CommandBehavior.CloseConnection);
    }

    #endregion

    #region ExecuteDataRow

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(connectionString, CommandType.Text, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(connectionString, commandType, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(connection, commandType, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一行
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>,返回结果集中的第一行</returns>
    public static DataRow ExecuteDataRow(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    DataTable dt = ExecuteDataTable(transaction, commandType, commandText, parms);
    return dt.Rows.Count > 0 ? dt.Rows[0] : null;
    }

    #endregion ExecuteDataRow

    #region ExecuteDataTable

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(connectionString, commandType, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(connection, commandType, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteDataTable(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(transaction, commandType, commandText, parms).Tables[0];
    }

    /// <summary>
    /// 执行SQL语句,返回结果集中的第一个数据表
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="tableName">数据表名称</param>
    /// <returns>返回结果集中的第一个数据表</returns>
    public static DataTable ExecuteEmptyDataTable(string connectionString, string tableName)
    {
    return ExecuteDataSet(connectionString, CommandType.Text, string.Format("select * from {0} where 1=-1", tableName)).Tables[0];
    }

    #endregion ExecuteDataTable

    #region ExecuteDataSet

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandText">SQL语句</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    using (MySqlConnection connection = new MySqlConnection(connectionString))
    {
    return ExecuteDataSet(connection, commandType, commandText, parms);
    }
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(connection, null, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    public static DataSet ExecuteDataSet(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    return ExecuteDataSet(transaction.Connection, transaction, commandType, commandText, parms);
    }

    /// <summary>
    /// 执行SQL语句,返回结果集
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="transaction">事务</param>
    /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
    /// <param name="commandText">SQL语句或存储过程名称</param>
    /// <param name="parms">查询参数</param>
    /// <returns>返回结果集</returns>
    private static DataSet ExecuteDataSet(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
    {
    MySqlCommand command = new MySqlCommand();

    PrepareCommand(command, connection, transaction, commandType, commandText, parms);
    MySqlDataAdapter adapter = new MySqlDataAdapter(command);

    DataSet ds = new DataSet();
    adapter.Fill(ds);
    if (commandText.IndexOf("@") > 0)
    {
    commandText = commandText.ToLower();
    int index = commandText.IndexOf("where ");
    if (index < 0)
    {
    index = commandText.IndexOf(" where");
    }
    if (index > 0)
    {
    ds.ExtendedProperties.Add("SQL", commandText.Substring(0, index - 1)); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
    }
    else
    {
    ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
    }
    }
    else
    {
    ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
    }

    foreach (DataTable dt in ds.Tables)
    {
    dt.ExtendedProperties.Add("SQL", ds.ExtendedProperties["SQL"]);
    }

    command.Parameters.Clear();
    return ds;
    }

    #endregion ExecuteDataSet

    #region 批量操作

    /// <summary>
    ///使用MySqlDataAdapter批量更新数据
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="table">数据表</param>
    public static void BatchUpdate(string connectionString, DataTable table)
    {
    MySqlConnection connection = new MySqlConnection(connectionString);

    MySqlCommand command = connection.CreateCommand();
    command.CommandTimeout = CommandTimeOut;
    command.CommandType = CommandType.Text;
    MySqlDataAdapter adapter = new MySqlDataAdapter(command);
    MySqlCommandBuilder commandBulider = new MySqlCommandBuilder(adapter);
    commandBulider.ConflictOption = ConflictOption.OverwriteChanges;

    MySqlTransaction transaction = null;
    try
    {
    connection.Open();
    transaction = connection.BeginTransaction();
    //设置批量更新的每次处理条数
    adapter.UpdateBatchSize = BatchSize;
    //设置事物
    adapter.SelectCommand.Transaction = transaction;

    if (table.ExtendedProperties["SQL"] != null)
    {
    adapter.SelectCommand.CommandText = table.ExtendedProperties["SQL"].ToString();
    }
    adapter.Update(table);
    transaction.Commit();/////提交事务
    }
    catch (MySqlException ex)
    {
    if (transaction != null) transaction.Rollback();
    throw ex;
    }
    finally
    {
    connection.Close();
    connection.Dispose();
    }
    }

    /// <summary>
    ///大批量数据插入,返回成功插入行数
    /// </summary>
    /// <param name="connectionString">数据库连接字符串</param>
    /// <param name="table">数据表</param>
    /// <returns>返回成功插入行数</returns>
    public static int BulkInsert(string connectionString, DataTable table)
    {
    if (string.IsNullOrEmpty(table.TableName)) throw new Exception("请给DataTable的TableName属性附上表名称");
    if (table.Rows.Count == 0) return 0;
    int insertCount = 0;
    string tmpPath = Path.GetTempFileName();
    string csv = DataTableToCsv(table);
    File.WriteAllText(tmpPath, csv);
    using (MySqlConnection conn = new MySqlConnection(connectionString))
    {
    MySqlTransaction tran = null;
    try
    {
    conn.Open();
    tran = conn.BeginTransaction();
    MySqlBulkLoader bulk = new MySqlBulkLoader(conn)
    {
    FieldTerminator = ",",
    FieldQuotationCharacter = '"',
    EscapeCharacter = '"',
    LineTerminator = " ",
    FileName = tmpPath,
    NumberOfLinesToSkip = 0,
    TableName = table.TableName,
    };
    bulk.Columns.AddRange(table.Columns.Cast<DataColumn>().Select(colum => colum.ColumnName).ToList());
    insertCount = bulk.Load();
    tran.Commit();
    }
    catch (MySqlException ex)
    {
    if (tran != null) tran.Rollback();
    throw ex;
    }
    }
    File.Delete(tmpPath);
    return insertCount;
    }

    /// <summary>
    ///将DataTable转换为标准的CSV
    /// </summary>
    /// <param name="table">数据表</param>
    /// <returns>返回标准的CSV</returns>
    private static string DataTableToCsv(DataTable table)
    {
    //以半角逗号(即,)作分隔符,列为空也要表达其存在。
    //列内容如存在半角逗号(即,)则用半角引号(即"")将该字段值包含起来。
    //列内容如存在半角引号(即")则应替换成半角双引号("")转义,并用半角引号(即"")将该字段值包含起来。
    StringBuilder sb = new StringBuilder();
    DataColumn colum;
    foreach (DataRow row in table.Rows)
    {
    for (int i = 0; i < table.Columns.Count; i++)
    {
    colum = table.Columns[i];
    if (i != 0) sb.Append(",");
    if (colum.DataType == typeof(string) && row[colum].ToString().Contains(","))
    {
    sb.Append(""" + row[colum].ToString().Replace(""", """") + """);
    }
    else sb.Append(row[colum].ToString());
    }
    sb.AppendLine();
    }

    return sb.ToString();
    }

    #endregion 批量操作

    #endregion 静态方法
    }
    }

    MySqlHelper.cs

     MySqlHelperExtension.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using MySql.Data.MySqlClient;
    using System.Data;

    namespace Helpers
    {
    /// <summary>
    /// MySqlHelper扩展(依赖AutoMapper.dll)
    /// </summary>
    public sealed partial class MySqlHelper
    {
    #region 实例方法

    public T ExecuteObject<T>(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteObject<T>(this.ConnectionString, commandText, parms);
    }

    public List<T> ExecuteObjects<T>(string commandText, params MySqlParameter[] parms)
    {
    return ExecuteObjects<T>(this.ConnectionString, commandText, parms);
    }

    #endregion

    #region 静态方法

    public static T ExecuteObject<T>(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    //DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
    //return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader()).FirstOrDefault();
    using (MySqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
    {
    return AutoMapper.Mapper.DynamicMap<List<T>>(reader).FirstOrDefault();
    }
    }

    public static List<T> ExecuteObjects<T>(string connectionString, string commandText, params MySqlParameter[] parms)
    {
    //DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
    //return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader());
    using (MySqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
    {
    return AutoMapper.Mapper.DynamicMap<List<T>>(reader);
    }
    }

    #endregion
    }


    }

    MySqlHelperExtension.cs

    最后附上文件源码及相关DLL:SQL.rar

     
    分类: C#
  • 相关阅读:
    vue自定义指令
    ZOJ Problem Set–2104 Let the Balloon Rise
    ZOJ Problem Set 3202 Secondprice Auction
    ZOJ Problem Set–1879 Jolly Jumpers
    ZOJ Problem Set–2405 Specialized FourDigit Numbers
    ZOJ Problem Set–1874 Primary Arithmetic
    ZOJ Problem Set–1970 All in All
    ZOJ Problem Set–1828 Fibonacci Numbers
    要怎么样调整状态呢
    ZOJ Problem Set–1951 Goldbach's Conjecture
  • 原文地址:https://www.cnblogs.com/Leo_wl/p/3287979.html
Copyright © 2011-2022 走看看