MySQL 帮助类 MySQLHelper

Wesley13
• 阅读 508
  1  /// <summary>
  2     /// MySqlHelper操作类
  3     /// </summary>
  4     public sealed partial class MySQLHelper
  5     {
  6         public static readonly string DBConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings[""].ToString();
  7         /// <summary>
  8         /// 批量操作每批次记录数
  9         /// </summary>
 10         public static int BatchSize = 2000;
 11 
 12         /// <summary>
 13         /// 超时时间
 14         /// </summary>
 15         public static int CommandTimeOut = 600;
 16 
 17         /// <summary>
 18         ///初始化MySqlHelper实例
 19         /// </summary>
 20         /// <param name="connectionString">数据库连接字符串</param>
 21         public MySQLHelper(string connectionString)
 22         {
 23             this.ConnectionString = connectionString;
 24         }
 25 
 26         /// <summary>
 27         /// 数据库连接字符串
 28         /// </summary>
 29         public string ConnectionString { get; set; }
 30 
 31         #region 实例方法
 32 
 33         #region ExecuteNonQuery
 34 
 35         /// <summary>
 36         /// 执行SQL语句,返回影响的行数
 37         /// </summary>
 38         /// <param name="commandText">SQL语句</param>
 39         /// <param name="parms">查询参数</param>
 40         /// <returns>返回影响的行数</returns>
 41         public int ExecuteNonQuery(string commandText, params MySqlParameter[] parms)
 42         {
 43             return ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parms);
 44         }
 45 
 46         /// <summary>
 47         /// 执行SQL语句,返回影响的行数
 48         /// </summary>
 49         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
 50         /// <param name="commandText">SQL语句或存储过程名称</param>
 51         /// <param name="parms">查询参数</param>
 52         /// <returns>返回影响的行数</returns>
 53         public int ExecuteNonQuery(CommandType commandType, string commandText, params MySqlParameter[] parms)
 54         {
 55             return ExecuteNonQuery(ConnectionString, commandType, commandText, parms);
 56         }
 57 
 58         #endregion ExecuteNonQuery
 59 
 60         #region ExecuteScalar
 61 
 62         /// <summary>
 63         /// 执行SQL语句,返回结果集中的第一行第一列
 64         /// </summary>
 65         /// <typeparam name="T">返回对象类型</typeparam>
 66         /// <param name="commandText">SQL语句</param>
 67         /// <param name="parms">查询参数</param>
 68         /// <returns>返回结果集中的第一行第一列</returns>
 69         public T ExecuteScalar<T>(string commandText, params MySqlParameter[] parms)
 70         {
 71             return ExecuteScalar<T>(ConnectionString, commandText, parms);
 72         }
 73 
 74         /// <summary>
 75         /// 执行SQL语句,返回结果集中的第一行第一列
 76         /// </summary>
 77         /// <param name="commandText">SQL语句</param>
 78         /// <param name="parms">查询参数</param>
 79         /// <returns>返回结果集中的第一行第一列</returns>
 80         public object ExecuteScalar(string commandText, params MySqlParameter[] parms)
 81         {
 82             return ExecuteScalar(ConnectionString, CommandType.Text, commandText, parms);
 83         }
 84 
 85         /// <summary>
 86         /// 执行SQL语句,返回结果集中的第一行第一列
 87         /// </summary>
 88         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
 89         /// <param name="commandText">SQL语句或存储过程名称</param>
 90         /// <param name="parms">查询参数</param>
 91         /// <returns>返回结果集中的第一行第一列</returns>
 92         public object ExecuteScalar(CommandType commandType, string commandText, params MySqlParameter[] parms)
 93         {
 94             return ExecuteScalar(ConnectionString, commandType, commandText, parms);
 95         }
 96 
 97         #endregion ExecuteScalar
 98 
 99         #region ExecuteDataReader
100 
101         /// <summary>
102         /// 执行SQL语句,返回只读数据集
103         /// </summary>
104         /// <param name="commandText">SQL语句</param>
105         /// <param name="parms">查询参数</param>
106         /// <returns>返回只读数据集</returns>
107         private MySqlDataReader ExecuteDataReader(string commandText, params MySqlParameter[] parms)
108         {
109             return ExecuteDataReader(ConnectionString, CommandType.Text, commandText, parms);
110         }
111 
112         /// <summary>
113         /// 执行SQL语句,返回只读数据集
114         /// </summary>
115         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
116         /// <param name="commandText">SQL语句或存储过程名称</param>
117         /// <param name="parms">查询参数</param>
118         /// <returns>返回只读数据集</returns>
119         private MySqlDataReader ExecuteDataReader(CommandType commandType, string commandText, params MySqlParameter[] parms)
120         {
121             return ExecuteDataReader(ConnectionString, commandType, commandText, parms);
122         }
123         #endregion
124 
125         #region ExecuteDataRow
126 
127         /// <summary>
128         /// 执行SQL语句,返回结果集中的第一行
129         /// </summary>
130         /// <param name="commandText">SQL语句</param>
131         /// <param name="parms">查询参数</param>
132         /// <returns>返回结果集中的第一行</returns>
133         public DataRow ExecuteDataRow(string commandText, params MySqlParameter[] parms)
134         {
135             return ExecuteDataRow(ConnectionString, CommandType.Text, commandText, parms);
136         }
137 
138         /// <summary>
139         /// 执行SQL语句,返回结果集中的第一行
140         /// </summary>
141         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
142         /// <param name="commandText">SQL语句或存储过程名称</param>
143         /// <param name="parms">查询参数</param>
144         /// <returns>返回结果集中的第一行</returns>
145         public DataRow ExecuteDataRow(CommandType commandType, string commandText, params MySqlParameter[] parms)
146         {
147             return ExecuteDataRow(ConnectionString, commandType, commandText, parms);
148         }
149 
150         #endregion ExecuteDataRow
151 
152         #region ExecuteDataTable
153 
154         /// <summary>
155         /// 执行SQL语句,返回结果集中的第一个数据表
156         /// </summary>
157         /// <param name="commandText">SQL语句</param>
158         /// <param name="parms">查询参数</param>
159         /// <returns>返回结果集中的第一个数据表</returns>
160         public DataTable ExecuteDataTable(string commandText, params MySqlParameter[] parms)
161         {
162             return ExecuteDataTable(ConnectionString, CommandType.Text, commandText, parms);
163         }
164 
165         /// <summary>
166         /// 执行SQL语句,返回结果集中的第一个数据表
167         /// </summary>
168         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
169         /// <param name="commandText">SQL语句或存储过程名称</param>
170         /// <param name="parms">查询参数</param>
171         /// <returns>返回结果集中的第一个数据表</returns>
172         public DataTable ExecuteDataTable(CommandType commandType, string commandText, params MySqlParameter[] parms)
173         {
174             return ExecuteDataSet(ConnectionString, commandType, commandText, parms).Tables[0];
175         }
176 
177         #endregion ExecuteDataTable
178 
179         #region ExecuteDataSet
180 
181         /// <summary>
182         /// 执行SQL语句,返回结果集
183         /// </summary>
184         /// <param name="commandText">SQL语句</param>
185         /// <param name="parms">查询参数</param>
186         /// <returns>返回结果集</returns>
187         public DataSet ExecuteDataSet(string commandText, params MySqlParameter[] parms)
188         {
189             return ExecuteDataSet(ConnectionString, CommandType.Text, commandText, parms);
190         }
191 
192         /// <summary>
193         /// 执行SQL语句,返回结果集
194         /// </summary>
195         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
196         /// <param name="commandText">SQL语句或存储过程名称</param>
197         /// <param name="parms">查询参数</param>
198         /// <returns>返回结果集</returns>
199         public DataSet ExecuteDataSet(CommandType commandType, string commandText, params MySqlParameter[] parms)
200         {
201             return ExecuteDataSet(ConnectionString, commandType, commandText, parms);
202         }
203 
204         #endregion ExecuteDataSet
205 
206         #region 批量操作
207 
208         /// <summary>
209         /// 使用MySqlDataAdapter批量更新数据
210         /// </summary>
211         /// <param name="table">数据表</param>
212         public void BatchUpdate(DataTable table)
213         {
214             BatchUpdate(ConnectionString, table);
215         }
216 
217         /// <summary>
218         ///大批量数据插入,返回成功插入行数
219         /// </summary>
220         /// <param name="table">数据表</param>
221         /// <returns>返回成功插入行数</returns>
222         public int BulkInsert(DataTable table)
223         {
224             return BulkInsert(ConnectionString, table);
225         }
226 
227         #endregion 批量操作
228 
229         #endregion 实例方法
230 
231         #region 静态方法
232 
233         private static void PrepareCommand(MySqlCommand command, MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, MySqlParameter[] parms)
234         {
235             if (connection.State != ConnectionState.Open) connection.Open();
236 
237             command.Connection = connection;
238             command.CommandTimeout = CommandTimeOut;
239             // 设置命令文本(存储过程名或SQL语句)
240             command.CommandText = commandText;
241             // 分配事务
242             if (transaction != null)
243             {
244                 command.Transaction = transaction;
245             }
246             // 设置命令类型.
247             command.CommandType = commandType;
248             if (parms != null && parms.Length > 0)
249             {
250                 //预处理MySqlParameter参数数组,将为NULL的参数赋值为DBNull.Value;
251                 foreach (MySqlParameter parameter in parms)
252                 {
253                     if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
254                     {
255                         parameter.Value = DBNull.Value;
256                     }
257                 }
258                 command.Parameters.AddRange(parms);
259             }
260         }
261 
262         #region ExecuteNonQuery
263 
264         /// <summary>
265         /// 执行SQL语句,返回影响的行数
266         /// </summary>
267         /// <param name="connectionString">数据库连接字符串</param>
268         /// <param name="commandText">SQL语句</param>
269         /// <param name="parms">查询参数</param>
270         /// <returns>返回影响的行数</returns>
271         public static int ExecuteNonQuery(string connectionString, string commandText, params MySqlParameter[] parms)
272         {
273             using (MySqlConnection connection = new MySqlConnection(connectionString))
274             {
275                 return ExecuteNonQuery(connection, CommandType.Text, commandText, parms);
276             }
277         }
278 
279         /// <summary>
280         /// 执行SQL语句,返回影响的行数
281         /// </summary>
282         /// <param name="connectionString">数据库连接字符串</param>
283         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
284         /// <param name="commandText">SQL语句或存储过程名称</param>
285         /// <param name="parms">查询参数</param>
286         /// <returns>返回影响的行数</returns>
287         public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
288         {
289             using (MySqlConnection connection = new MySqlConnection(connectionString))
290             {
291                 return ExecuteNonQuery(connection, commandType, commandText, parms);
292             }
293         }
294 
295         /// <summary>
296         /// 执行SQL语句,返回影响的行数
297         /// </summary>
298         /// <param name="connection">数据库连接</param>
299         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
300         /// <param name="commandText">SQL语句或存储过程名称</param>
301         /// <param name="parms">查询参数</param>
302         /// <returns>返回影响的行数</returns>
303         public static int ExecuteNonQuery(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
304         {
305             return ExecuteNonQuery(connection, null, commandType, commandText, parms);
306         }
307 
308         /// <summary>
309         /// 执行SQL语句,返回影响的行数
310         /// </summary>
311         /// <param name="transaction">事务</param>
312         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
313         /// <param name="commandText">SQL语句或存储过程名称</param>
314         /// <param name="parms">查询参数</param>
315         /// <returns>返回影响的行数</returns>
316         public static int ExecuteNonQuery(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
317         {
318             return ExecuteNonQuery(transaction.Connection, transaction, commandType, commandText, parms);
319         }
320 
321         /// <summary>
322         /// 执行SQL语句,返回影响的行数
323         /// </summary>
324         /// <param name="connection">数据库连接</param>
325         /// <param name="transaction">事务</param>
326         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
327         /// <param name="commandText">SQL语句或存储过程名称</param>
328         /// <param name="parms">查询参数</param>
329         /// <returns>返回影响的行数</returns>
330         private static int ExecuteNonQuery(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
331         {
332             MySqlCommand command = new MySqlCommand();
333             PrepareCommand(command, connection, transaction, commandType, commandText, parms);
334             int retval = command.ExecuteNonQuery();
335             command.Parameters.Clear();
336             return retval;
337         }
338 
339         #endregion ExecuteNonQuery
340 
341         #region ExecuteScalar
342 
343         /// <summary>
344         /// 执行SQL语句,返回结果集中的第一行第一列
345         /// </summary>
346         /// <typeparam name="T">返回对象类型</typeparam>
347         /// <param name="connectionString">数据库连接字符串</param>
348         /// <param name="commandText">SQL语句</param>
349         /// <param name="parms">查询参数</param>
350         /// <returns>返回结果集中的第一行第一列</returns>
351         public static T ExecuteScalar<T>(string connectionString, string commandText, params MySqlParameter[] parms)
352         {
353             object result = ExecuteScalar(connectionString, commandText, parms);
354             if (result != null)
355             {
356                 return (T)Convert.ChangeType(result, typeof(T)); ;
357             }
358             return default(T);
359         }
360 
361         /// <summary>
362         /// 执行SQL语句,返回结果集中的第一行第一列
363         /// </summary>
364         /// <param name="connectionString">数据库连接字符串</param>
365         /// <param name="commandText">SQL语句</param>
366         /// <param name="parms">查询参数</param>
367         /// <returns>返回结果集中的第一行第一列</returns>
368         public static object ExecuteScalar(string connectionString, string commandText, params MySqlParameter[] parms)
369         {
370             using (MySqlConnection connection = new MySqlConnection(connectionString))
371             {
372                 return ExecuteScalar(connection, CommandType.Text, commandText, parms);
373             }
374         }
375 
376         /// <summary>
377         /// 执行SQL语句,返回结果集中的第一行第一列
378         /// </summary>
379         /// <param name="connectionString">数据库连接字符串</param>
380         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
381         /// <param name="commandText">SQL语句或存储过程名称</param>
382         /// <param name="parms">查询参数</param>
383         /// <returns>返回结果集中的第一行第一列</returns>
384         public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
385         {
386             using (MySqlConnection connection = new MySqlConnection(connectionString))
387             {
388                 return ExecuteScalar(connection, commandType, commandText, parms);
389             }
390         }
391 
392         /// <summary>
393         /// 执行SQL语句,返回结果集中的第一行第一列
394         /// </summary>
395         /// <param name="connection">数据库连接</param>
396         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
397         /// <param name="commandText">SQL语句或存储过程名称</param>
398         /// <param name="parms">查询参数</param>
399         /// <returns>返回结果集中的第一行第一列</returns>
400         public static object ExecuteScalar(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
401         {
402             return ExecuteScalar(connection, null, commandType, commandText, parms);
403         }
404 
405         /// <summary>
406         /// 执行SQL语句,返回结果集中的第一行第一列
407         /// </summary>
408         /// <param name="transaction">事务</param>
409         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
410         /// <param name="commandText">SQL语句或存储过程名称</param>
411         /// <param name="parms">查询参数</param>
412         /// <returns>返回结果集中的第一行第一列</returns>
413         public static object ExecuteScalar(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
414         {
415             return ExecuteScalar(transaction.Connection, transaction, commandType, commandText, parms);
416         }
417 
418         /// <summary>
419         /// 执行SQL语句,返回结果集中的第一行第一列
420         /// </summary>
421         /// <param name="connection">数据库连接</param>
422         /// <param name="transaction">事务</param>
423         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
424         /// <param name="commandText">SQL语句或存储过程名称</param>
425         /// <param name="parms">查询参数</param>
426         /// <returns>返回结果集中的第一行第一列</returns>
427         private static object ExecuteScalar(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
428         {
429             MySqlCommand command = new MySqlCommand();
430             PrepareCommand(command, connection, transaction, commandType, commandText, parms);
431             object retval = command.ExecuteScalar();
432             command.Parameters.Clear();
433             return retval;
434         }
435 
436         #endregion ExecuteScalar
437 
438         #region ExecuteDataReader
439 
440         /// <summary>
441         /// 执行SQL语句,返回只读数据集
442         /// </summary>
443         /// <param name="connection">数据库连接</param>
444         /// <param name="commandText">SQL语句</param>
445         /// <param name="parms">查询参数</param>
446         /// <returns>返回只读数据集</returns>
447         private static MySqlDataReader ExecuteDataReader(string connectionString, string commandText, params MySqlParameter[] parms)
448         {
449             MySqlConnection connection = new MySqlConnection(connectionString);
450             return ExecuteDataReader(connection, null, CommandType.Text, commandText, parms);
451         }
452 
453         /// <summary>
454         /// 执行SQL语句,返回只读数据集
455         /// </summary>
456         /// <param name="connection">数据库连接</param>
457         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
458         /// <param name="commandText">SQL语句或存储过程名称</param>
459         /// <param name="parms">查询参数</param>
460         /// <returns>返回只读数据集</returns>
461         private static MySqlDataReader ExecuteDataReader(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
462         {
463             MySqlConnection connection = new MySqlConnection(connectionString);
464             return ExecuteDataReader(connection, null, commandType, commandText, parms);
465         }
466 
467         /// <summary>
468         /// 执行SQL语句,返回只读数据集
469         /// </summary>
470         /// <param name="connection">数据库连接</param>
471         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
472         /// <param name="commandText">SQL语句或存储过程名称</param>
473         /// <param name="parms">查询参数</param>
474         /// <returns>返回只读数据集</returns>
475         private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
476         {
477             return ExecuteDataReader(connection, null, commandType, commandText, parms);
478         }
479 
480         /// <summary>
481         /// 执行SQL语句,返回只读数据集
482         /// </summary>
483         /// <param name="transaction">事务</param>
484         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
485         /// <param name="commandText">SQL语句或存储过程名称</param>
486         /// <param name="parms">查询参数</param>
487         /// <returns>返回只读数据集</returns>
488         private static MySqlDataReader ExecuteDataReader(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
489         {
490             return ExecuteDataReader(transaction.Connection, transaction, commandType, commandText, parms);
491         }
492 
493         /// <summary>
494         /// 执行SQL语句,返回只读数据集
495         /// </summary>
496         /// <param name="connection">数据库连接</param>
497         /// <param name="transaction">事务</param>
498         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
499         /// <param name="commandText">SQL语句或存储过程名称</param>
500         /// <param name="parms">查询参数</param>
501         /// <returns>返回只读数据集</returns>
502         private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
503         {
504             MySqlCommand command = new MySqlCommand();
505             PrepareCommand(command, connection, transaction, commandType, commandText, parms);
506             return command.ExecuteReader(CommandBehavior.CloseConnection);
507         }
508 
509         #endregion
510 
511         #region ExecuteDataRow
512 
513         /// <summary>
514         /// 执行SQL语句,返回结果集中的第一行
515         /// </summary>
516         /// <param name="connectionString">数据库连接字符串</param>
517         /// <param name="commandText">SQL语句</param>
518         /// <param name="parms">查询参数</param>
519         /// <returns>,返回结果集中的第一行</returns>
520         public static DataRow ExecuteDataRow(string connectionString, string commandText, params MySqlParameter[] parms)
521         {
522             DataTable dt = ExecuteDataTable(connectionString, CommandType.Text, commandText, parms);
523             return dt.Rows.Count > 0 ? dt.Rows[0] : null;
524         }
525 
526         /// <summary>
527         /// 执行SQL语句,返回结果集中的第一行
528         /// </summary>
529         /// <param name="connectionString">数据库连接字符串</param>
530         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
531         /// <param name="commandText">SQL语句或存储过程名称</param>
532         /// <param name="parms">查询参数</param>
533         /// <returns>,返回结果集中的第一行</returns>
534         public static DataRow ExecuteDataRow(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
535         {
536             DataTable dt = ExecuteDataTable(connectionString, commandType, commandText, parms);
537             return dt.Rows.Count > 0 ? dt.Rows[0] : null;
538         }
539 
540         /// <summary>
541         /// 执行SQL语句,返回结果集中的第一行
542         /// </summary>
543         /// <param name="connection">数据库连接</param>
544         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
545         /// <param name="commandText">SQL语句或存储过程名称</param>
546         /// <param name="parms">查询参数</param>
547         /// <returns>,返回结果集中的第一行</returns>
548         public static DataRow ExecuteDataRow(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
549         {
550             DataTable dt = ExecuteDataTable(connection, commandType, commandText, parms);
551             return dt.Rows.Count > 0 ? dt.Rows[0] : null;
552         }
553 
554         /// <summary>
555         /// 执行SQL语句,返回结果集中的第一行
556         /// </summary>
557         /// <param name="transaction">事务</param>
558         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
559         /// <param name="commandText">SQL语句或存储过程名称</param>
560         /// <param name="parms">查询参数</param>
561         /// <returns>,返回结果集中的第一行</returns>
562         public static DataRow ExecuteDataRow(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
563         {
564             DataTable dt = ExecuteDataTable(transaction, commandType, commandText, parms);
565             return dt.Rows.Count > 0 ? dt.Rows[0] : null;
566         }
567 
568         #endregion ExecuteDataRow
569 
570         #region ExecuteDataTable
571 
572         /// <summary>
573         /// 执行SQL语句,返回结果集中的第一个数据表
574         /// </summary>
575         /// <param name="connectionString">数据库连接字符串</param>
576         /// <param name="commandText">SQL语句</param>
577         /// <param name="parms">查询参数</param>
578         /// <returns>返回结果集中的第一个数据表</returns>
579         public static DataTable ExecuteDataTable(string connectionString, string commandText, params MySqlParameter[] parms)
580         {
581             return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms).Tables[0];
582         }
583 
584         /// <summary>
585         /// 执行SQL语句,返回结果集中的第一个数据表
586         /// </summary>
587         /// <param name="connectionString">数据库连接字符串</param>
588         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
589         /// <param name="commandText">SQL语句或存储过程名称</param>
590         /// <param name="parms">查询参数</param>
591         /// <returns>返回结果集中的第一个数据表</returns>
592         public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
593         {
594             return ExecuteDataSet(connectionString, commandType, commandText, parms).Tables[0];
595         }
596 
597         /// <summary>
598         /// 执行SQL语句,返回结果集中的第一个数据表
599         /// </summary>
600         /// <param name="connection">数据库连接</param>
601         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
602         /// <param name="commandText">SQL语句或存储过程名称</param>
603         /// <param name="parms">查询参数</param>
604         /// <returns>返回结果集中的第一个数据表</returns>
605         public static DataTable ExecuteDataTable(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
606         {
607             return ExecuteDataSet(connection, commandType, commandText, parms).Tables[0];
608         }
609 
610         /// <summary>
611         /// 执行SQL语句,返回结果集中的第一个数据表
612         /// </summary>
613         /// <param name="transaction">事务</param>
614         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
615         /// <param name="commandText">SQL语句或存储过程名称</param>
616         /// <param name="parms">查询参数</param>
617         /// <returns>返回结果集中的第一个数据表</returns>
618         public static DataTable ExecuteDataTable(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
619         {
620             return ExecuteDataSet(transaction, commandType, commandText, parms).Tables[0];
621         }
622 
623         /// <summary>
624         /// 执行SQL语句,返回结果集中的第一个数据表
625         /// </summary>
626         /// <param name="connectionString">数据库连接字符串</param>
627         /// <param name="tableName">数据表名称</param>
628         /// <returns>返回结果集中的第一个数据表</returns>
629         public static DataTable ExecuteEmptyDataTable(string connectionString, string tableName)
630         {
631             return ExecuteDataSet(connectionString, CommandType.Text, string.Format("select * from {0} where 1=-1", tableName)).Tables[0];
632         }
633 
634         #endregion ExecuteDataTable
635 
636         #region ExecuteDataSet
637 
638         /// <summary>
639         /// 执行SQL语句,返回结果集
640         /// </summary>
641         /// <param name="connectionString">数据库连接字符串</param>
642         /// <param name="commandText">SQL语句</param>
643         /// <param name="parms">查询参数</param>
644         /// <returns>返回结果集</returns>
645         public static DataSet ExecuteDataSet(string connectionString, string commandText, params MySqlParameter[] parms)
646         {
647             return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms);
648         }
649 
650         /// <summary>
651         /// 执行SQL语句,返回结果集
652         /// </summary>
653         /// <param name="connectionString">数据库连接字符串</param>
654         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
655         /// <param name="commandText">SQL语句或存储过程名称</param>
656         /// <param name="parms">查询参数</param>
657         /// <returns>返回结果集</returns>
658         public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
659         {
660             using (MySqlConnection connection = new MySqlConnection(connectionString))
661             {
662                 return ExecuteDataSet(connection, commandType, commandText, parms);
663             }
664         }
665 
666         /// <summary>
667         /// 执行SQL语句,返回结果集
668         /// </summary>
669         /// <param name="connection">数据库连接</param>
670         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
671         /// <param name="commandText">SQL语句或存储过程名称</param>
672         /// <param name="parms">查询参数</param>
673         /// <returns>返回结果集</returns>
674         public static DataSet ExecuteDataSet(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
675         {
676             return ExecuteDataSet(connection, null, commandType, commandText, parms);
677         }
678 
679         /// <summary>
680         /// 执行SQL语句,返回结果集
681         /// </summary>
682         /// <param name="transaction">事务</param>
683         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
684         /// <param name="commandText">SQL语句或存储过程名称</param>
685         /// <param name="parms">查询参数</param>
686         /// <returns>返回结果集</returns>
687         public static DataSet ExecuteDataSet(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
688         {
689             return ExecuteDataSet(transaction.Connection, transaction, commandType, commandText, parms);
690         }
691 
692         /// <summary>
693         /// 执行SQL语句,返回结果集
694         /// </summary>
695         /// <param name="connection">数据库连接</param>
696         /// <param name="transaction">事务</param>
697         /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
698         /// <param name="commandText">SQL语句或存储过程名称</param>
699         /// <param name="parms">查询参数</param>
700         /// <returns>返回结果集</returns>
701         private static DataSet ExecuteDataSet(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
702         {
703             MySqlCommand command = new MySqlCommand();
704 
705             PrepareCommand(command, connection, transaction, commandType, commandText, parms);
706             MySqlDataAdapter adapter = new MySqlDataAdapter(command);
707 
708             DataSet ds = new DataSet();
709             adapter.Fill(ds);
710             if (commandText.IndexOf("@") > 0)
711             {
712                 commandText = commandText.ToLower();
713                 int index = commandText.IndexOf("where ");
714                 if (index < 0)
715                 {
716                     index = commandText.IndexOf("\nwhere");
717                 }
718                 if (index > 0)
719                 {
720                     ds.ExtendedProperties.Add("SQL", commandText.Substring(0, index - 1));  //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
721                 }
722                 else
723                 {
724                     ds.ExtendedProperties.Add("SQL", commandText);  //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
725                 }
726             }
727             else
728             {
729                 ds.ExtendedProperties.Add("SQL", commandText);  //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
730             }
731 
732             foreach (DataTable dt in ds.Tables)
733             {
734                 dt.ExtendedProperties.Add("SQL", ds.ExtendedProperties["SQL"]);
735             }
736 
737             command.Parameters.Clear();
738             return ds;
739         }
740 
741         #endregion ExecuteDataSet
742 
743         #region 批量操作
744 
745         /// <summary>
746         ///使用MySqlDataAdapter批量更新数据
747         /// </summary>
748         /// <param name="connectionString">数据库连接字符串</param>
749         /// <param name="table">数据表</param>
750         public static void BatchUpdate(string connectionString, DataTable table)
751         {
752             MySqlConnection connection = new MySqlConnection(connectionString);
753 
754             MySqlCommand command = connection.CreateCommand();
755             command.CommandTimeout = CommandTimeOut;
756             command.CommandType = CommandType.Text;
757             MySqlDataAdapter adapter = new MySqlDataAdapter(command);
758             MySqlCommandBuilder commandBulider = new MySqlCommandBuilder(adapter);
759             commandBulider.ConflictOption = ConflictOption.OverwriteChanges;
760 
761             MySqlTransaction transaction = null;
762             try
763             {
764                 connection.Open();
765                 transaction = connection.BeginTransaction();
766                 //设置批量更新的每次处理条数
767                 adapter.UpdateBatchSize = BatchSize;
768                 //设置事物
769                 adapter.SelectCommand.Transaction = transaction;
770 
771                 if (table.ExtendedProperties["SQL"] != null)
772                 {
773                     adapter.SelectCommand.CommandText = table.ExtendedProperties["SQL"].ToString();
774                 }
775                 adapter.Update(table);
776                 transaction.Commit();/////提交事务
777             }
778             catch (MySqlException ex)
779             {
780                 if (transaction != null) transaction.Rollback();
781                 throw ex;
782             }
783             finally
784             {
785                 connection.Close();
786                 connection.Dispose();
787             }
788         }
789 
790         /// <summary>
791         ///大批量数据插入,返回成功插入行数
792         /// </summary>
793         /// <param name="connectionString">数据库连接字符串</param>
794         /// <param name="table">数据表</param>
795         /// <returns>返回成功插入行数</returns>
796         public static int BulkInsert(string connectionString, DataTable table)
797         {
798             if (string.IsNullOrEmpty(table.TableName)) throw new Exception("请给DataTable的TableName属性附上表名称");
799             if (table.Rows.Count == 0) return 0;
800             int insertCount = 0;
801             string tmpPath = Path.GetTempFileName();
802             string csv = DataTableToCsv(table);
803             File.WriteAllText(tmpPath, csv);
804             using (MySqlConnection conn = new MySqlConnection(connectionString))
805             {
806                 MySqlTransaction tran = null;
807                 try
808                 {
809                     conn.Open();
810                     tran = conn.BeginTransaction();
811                     MySqlBulkLoader bulk = new MySqlBulkLoader(conn)
812                     {
813                         FieldTerminator = ",",
814                         FieldQuotationCharacter = '"',
815                         EscapeCharacter = '"',
816                         LineTerminator = "\r\n",
817                         FileName = tmpPath,
818                         NumberOfLinesToSkip = 0,
819                         TableName = table.TableName,
820                     };
821                     bulk.Columns.AddRange(table.Columns.Cast<DataColumn>().Select(colum => colum.ColumnName).ToList());
822                     insertCount = bulk.Load();
823                     tran.Commit();
824                 }
825                 catch (MySqlException ex)
826                 {
827                     if (tran != null) tran.Rollback();
828                     throw ex;
829                 }
830             }
831             File.Delete(tmpPath);
832             return insertCount;
833         }
834 
835         /// <summary>
836         ///将DataTable转换为标准的CSV
837         /// </summary>
838         /// <param name="table">数据表</param>
839         /// <returns>返回标准的CSV</returns>
840         private static string DataTableToCsv(DataTable table)
841         {
842             //以半角逗号(即,)作分隔符,列为空也要表达其存在。
843             //列内容如存在半角逗号(即,)则用半角引号(即"")将该字段值包含起来。
844             //列内容如存在半角引号(即")则应替换成半角双引号("")转义,并用半角引号(即"")将该字段值包含起来。
845             StringBuilder sb = new StringBuilder();
846             DataColumn colum;
847             foreach (DataRow row in table.Rows)
848             {
849                 for (int i = 0; i < table.Columns.Count; i++)
850                 {
851                     colum = table.Columns[i];
852                     if (i != 0) sb.Append(",");
853                     if (colum.DataType == typeof(string) && row[colum].ToString().Contains(","))
854                     {
855                         sb.Append("\"" + row[colum].ToString().Replace("\"", "\"\"") + "\"");
856                     }
857                     else sb.Append(row[colum].ToString());
858                 }
859                 sb.AppendLine();
860             }
861 
862             return sb.ToString();
863         }
864 
865         #endregion 批量操作
866 
867         #endregion 静态方法
868     }
点赞
收藏
评论区
推荐文章
blmius blmius
2年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
Jacquelyn38 Jacquelyn38
2年前
2020年前端实用代码段,为你的工作保驾护航
有空的时候,自己总结了几个代码段,在开发中也经常使用,谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
皕杰报表之UUID
​在我们用皕杰报表工具设计填报报表时,如何在新增行里自动增加id呢?能新增整数排序id吗?目前可以在新增行里自动增加id,但只能用uuid函数增加UUID编码,不能新增整数排序id。uuid函数说明:获取一个UUID,可以在填报表中用来创建数据ID语法:uuid()或uuid(sep)参数说明:sep布尔值,生成的uuid中是否包含分隔符'',缺省为
Stella981 Stella981
2年前
Python3:sqlalchemy对mysql数据库操作,非sql语句
Python3:sqlalchemy对mysql数据库操作,非sql语句python3authorlizmdatetime2018020110:00:00coding:utf8'''
Stella981 Stella981
2年前
KVM调整cpu和内存
一.修改kvm虚拟机的配置1、virsheditcentos7找到“memory”和“vcpu”标签,将<namecentos7</name<uuid2220a6d1a36a4fbb8523e078b3dfe795</uuid
Easter79 Easter79
2年前
Twitter的分布式自增ID算法snowflake (Java版)
概述分布式系统中,有一些需要使用全局唯一ID的场景,这种时候为了防止ID冲突可以使用36位的UUID,但是UUID有一些缺点,首先他相对比较长,另外UUID一般是无序的。有些时候我们希望能使用一种简单一些的ID,并且希望ID能够按照时间有序生成。而twitter的snowflake解决了这种需求,最初Twitter把存储系统从MySQL迁移
Wesley13 Wesley13
2年前
mysql设置时区
mysql设置时区mysql\_query("SETtime\_zone'8:00'")ordie('时区设置失败,请联系管理员!');中国在东8区所以加8方法二:selectcount(user\_id)asdevice,CONVERT\_TZ(FROM\_UNIXTIME(reg\_time),'08:00','0
Wesley13 Wesley13
2年前
00:Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork),斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟,已经成为Web应用程序的首选开发语言。Java是简单易学,完全面向对象,安全可靠,与平台无关的编程语言。
Wesley13 Wesley13
2年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
为什么mysql不推荐使用雪花ID作为主键
作者:毛辰飞背景在mysql中设计表的时候,mysql官方推荐不要使用uuid或者不连续不重复的雪花id(long形且唯一),而是推荐连续自增的主键id,官方的推荐是auto_increment,那么为什么不建议采用uuid,使用uuid究
Python进阶者 Python进阶者
1个月前
Excel中这日期老是出来00:00:00,怎么用Pandas把这个去除
大家好,我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下:这日期老是出来00:00:00,怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下:pd.toexcel之前把这