自用类库整理之SqlHelper和MySqlHelper
自用的SQLHelper和MySqlHelper，除一些通用方法外，封装了一些很实用的批量操作方法，简单介绍下
SqlHelper
- ExecuteEmptyDataTable
获取空表结构，主要用于需要构造DataTable进行大批量数据插入时使用 - BulkInsert
大批量数据插入,使用SqlBulkCopy进行大批量数据导入,仅提供了DataTable方式,需要DataReader的请自行重载 - 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实现，非常在意性能的慎用
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("\nwhere"); } 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, @"[\w\s.=,']*from", "select top 1 1 from", RegexOptions.IgnoreCase); existsSql = Regex.Replace(existsSql, @"set[\w\s.=,']* 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 静态方法 } }
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 } }
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; } } }
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("\nwhere"); } 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 = "\r\n", 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 静态方法 } }
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 } }
最后附上文件源码及相关DLL:SQL.rar
注：此文章属懒惰的肥兔原创，版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接
若您觉得这篇文章还不错请点击下右下角的推荐，有了您的支持才能激发作者更大的写作热情，非常感谢。
如有问题，可以通过[email protected]联系我。