批量插入

最新推荐文章于 2023-10-10 15:48:17 发布
最新推荐文章于 2023-10-10 15:48:17 发布
阅读量413 收藏
点赞数
分类专栏： c# oracle sql server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LanSeTianKong12/article/details/103081689
版权

Oracle数据批量插入

     System.Data.OracleClient不支持批量插入，因此只能使用Oracle.DataAccess组件来作为提供者。

/// <summary>
    /// Oracle.Data.Access 组件提供的用于批量操作的方法。
    /// </summary>
    public sealed class OracleAccessBatcher : IBatcherProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        public void Insert(DataTable dataTable, int batchSize = 10000)
        {
            Checker.ArgumentNull(dataTable, "dataTable");
            if (dataTable.Rows.Count == 0)
            {
                return;
            }
            using (var connection = ServiceContext.Database.CreateConnection())
            {
                try
                {
                    connection.TryOpen();
                    using (var command = ServiceContext.Database.Provider.DbProviderFactory.CreateCommand())
                    {
                        if (command == null)
                        {
                            throw new BatcherException(new ArgumentException("command"));
                        }
                        command.Connection = connection;
                        command.CommandText = GenerateInserSql(ServiceContext.Database, command, dataTable);
                        command.ExecuteNonQuery();
                    }
                }
                catch (Exception exp)
                {
                    throw new BatcherException(exp);
                }
                finally
                {
                    connection.TryClose();
                }
            }
        }

        /// <summary>
        /// 生成插入数据的sql语句。
        /// </summary>
        /// <param name="database"></param>
        /// <param name="command"></param>
        /// <param name="table"></param>
        /// <returns></returns>
        private string GenerateInserSql(IDatabase database, DbCommand command, DataTable table)
        {
            var names = new StringBuilder();
            var values = new StringBuilder();
            //将一个DataTable的数据转换为数组的数组
            var data = table.ToArray();

            //设置ArrayBindCount属性
            command.GetType().GetProperty("ArrayBindCount").SetValue(command, table.Rows.Count, null);

            var syntax = database.Provider.GetService<ISyntaxProvider>();
            for (var i = 0; i < table.Columns.Count; i++)
            {
                var column = table.Columns[i];

                var parameter = database.Provider.DbProviderFactory.CreateParameter();
                if (parameter == null)
                {
                    continue;
                }
                parameter.ParameterName = column.ColumnName;
                parameter.Direction = ParameterDirection.Input;
                parameter.DbType = column.DataType.GetDbType();
                parameter.Value = data[i];

                if (names.Length > 0)
                {
                    names.Append(",");
                    values.Append(",");
                }
                names.AppendFormat("{0}", DbUtility.FormatByQuote(syntax, column.ColumnName));
                values.AppendFormat("{0}{1}", syntax.ParameterPrefix, column.ColumnName);

                command.Parameters.Add(parameter);
            }
            return string.Format("INSERT INTO {0}({1}) VALUES ({2})", DbUtility.FormatByQuote(syntax, table.TableName), names, values);
        }
    }

SqlServer数据批量插入

    SqlServer的批量插入很简单，使用SqlBulkCopy就可以，以下是该类的实现：

/// <summary>
    /// 提供数据批量处理的方法。
    /// </summary>
    public interface IBatcherProvider : IProviderService
    {
        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        void Insert(DataTable dataTable, int batchSize = 10000);
    }
/// <summary>
    /// 为 System.Data.SqlClient 提供的用于批量操作的方法。
    /// </summary>
    public sealed class MsSqlBatcher : IBatcherProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        public void Insert(DataTable dataTable, int batchSize = 10000)
        {
            Checker.ArgumentNull(dataTable, "dataTable");
            if (dataTable.Rows.Count == 0)
            {
                return;
            }
            using (var connection = (SqlConnection)ServiceContext.Database.CreateConnection())
            {
                try
                {
                    connection.TryOpen();
                    //给表名加上前后导符
                    var tableName = DbUtility.FormatByQuote(ServiceContext.Database.Provider.GetService<ISyntaxProvider>(), dataTable.TableName);
                    using (var bulk = new SqlBulkCopy(connection, SqlBulkCopyOptions.KeepIdentity, null)
                        {
                            DestinationTableName = tableName, 
                            BatchSize = batchSize
                        })
                    {
                        //循环所有列，为bulk添加映射
                        dataTable.EachColumn(c => bulk.ColumnMappings.Add(c.ColumnName, c.ColumnName), c => !c.AutoIncrement);
                        bulk.WriteToServer(dataTable);
                        bulk.Close();
                    }
                }
                catch (Exception exp)
                {
                    throw new BatcherException(exp);
                }
                finally
                {
                    connection.TryClose();
                }
            }
        }
    }

 

     SqlBulkCopy的ColumnMappings中列的名称受大小写敏感限制，因此在构造DataTable的时候应请注意列名要与表一致。

     以上没有使用事务，使用事务在性能上会有一定的影响，如果要使用事务，可以设置SqlBulkCopyOptions.UseInternalTransaction。

MySql数据批量插入

/// <summary>
    /// 为 MySql.Data 组件提供的用于批量操作的方法。
    /// </summary>
    public sealed class MySqlBatcher : IBatcherProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 将 <see cref="DataTable"/> 的数据批量插入到数据库中。
        /// </summary>
        /// <param name="dataTable">要批量插入的 <see cref="DataTable"/>。</param>
        /// <param name="batchSize">每批次写入的数据量。</param>
        public void Insert(DataTable dataTable, int batchSize = 10000)
        {
            Checker.ArgumentNull(dataTable, "dataTable");
            if (dataTable.Rows.Count == 0)
            {
                return;
            }
            using (var connection = ServiceContext.Database.CreateConnection())
            {
                try
                {
                    connection.TryOpen();
                    using (var command = ServiceContext.Database.Provider.DbProviderFactory.CreateCommand())
                    {
                        if (command == null)
                        {
                            throw new BatcherException(new ArgumentException("command"));
                        }
                        command.Connection = connection;

                        command.CommandText = GenerateInserSql(ServiceContext.Database, command, dataTable);
                        if (command.CommandText == string.Empty)
                        {
                            return;
                        }
                        command.ExecuteNonQuery();
                    }
                }
                catch (Exception exp)
                {
                    throw new BatcherException(exp);
                }
                finally
                {
                    connection.TryClose();
                }
            }
        }

        /// <summary>
        /// 生成插入数据的sql语句。
        /// </summary>
        /// <param name="database"></param>
        /// <param name="command"></param>
        /// <param name="table"></param>
        /// <returns></returns>
        private string GenerateInserSql(IDatabase database, DbCommand command, DataTable table)
        {
            var names = new StringBuilder();
            var values = new StringBuilder();
            var types = new List<DbType>();
            var count = table.Columns.Count;
            var syntax = database.Provider.GetService<ISyntaxProvider>();
            table.EachColumn(c =>
                {
                    if (names.Length > 0)
                    {
                        names.Append(",");
                    }
                    names.AppendFormat("{0}", DbUtility.FormatByQuote(syntax, c.ColumnName));
                    types.Add(c.DataType.GetDbType());
                });

            var i = 0;
            foreach (DataRow row in table.Rows)
            {
                if (i > 0)
                {
                    values.Append(",");
                }
                values.Append("(");
                for (var j = 0; j < count; j++)
                {
                    if (j > 0)
                    {
                        values.Append(", ");
                    }
                    var isStrType = IsStringType(types[j]);
                    var parameter = CreateParameter(database.Provider, isStrType, types[j], row[j], syntax.ParameterPrefix, i, j);
                    if (parameter != null)
                    {
                        values.Append(parameter.ParameterName);
                        command.Parameters.Add(parameter);
                    }
                    else if (isStrType)
                    {
                        values.AppendFormat("'{0}'", row[j]);
                    }
                    else
                    {
                        values.Append(row[j]);
                    }
                }
                values.Append(")");
                i++;
            }
            return string.Format("INSERT INTO {0}({1}) VALUES {2}", DbUtility.FormatByQuote(syntax, table.TableName), names, values);
        }

        /// <summary>
        /// 判断是否为字符串类别。
        /// </summary>
        /// <param name="dbType"></param>
        /// <returns></returns>
        private bool IsStringType(DbType dbType)
        {
            return dbType == DbType.AnsiString || dbType == DbType.AnsiStringFixedLength || dbType == DbType.String || dbType == DbType.StringFixedLength;
        }

        /// <summary>
        /// 创建参数。
        /// </summary>
        /// <param name="provider"></param>
        /// <param name="isStrType"></param>
        /// <param name="dbType"></param>
        /// <param name="value"></param>
        /// <param name="parPrefix"></param>
        /// <param name="row"></param>
        /// <param name="col"></param>
        /// <returns></returns>
        private DbParameter CreateParameter(IProvider provider, bool isStrType, DbType dbType, object value, char parPrefix, int row, int col)
        {
            //如果生成全部的参数，则速度会很慢，因此，只有数据类型为字符串(包含'号)和日期型时才添加参数
            if ((isStrType && value.ToString().IndexOf('\'') != -1) || dbType == DbType.DateTime)
            {
                var name = string.Format("{0}p_{1}_{2}", parPrefix, row, col);
                var parameter = provider.DbProviderFactory.CreateParameter();
                parameter.ParameterName = name;
                parameter.Direction = ParameterDirection.Input;
                parameter.DbType = dbType;
                parameter.Value = value;
                return parameter;
            }
            return null;
        }
    }
[Test]
        public void TestBatchInsert()
        {
            Console.WriteLine(TimeWatcher.Watch(() =>
                InvokeTest(database =>
                    {
                        var table = new DataTable("Batcher");
                        table.Columns.Add("Id", typeof(int));
                        table.Columns.Add("Name1", typeof(string));
                        table.Columns.Add("Name2", typeof(string));
                        table.Columns.Add("Name3", typeof(string));
                        table.Columns.Add("Name4", typeof(string));

                        //构造100000条数据
                        for (var i = 0; i < 100000; i++)
                        {
                            table.Rows.Add(i, i.ToString(), i.ToString(), i.ToString(), i.ToString());
                        }

                        //获取 IBatcherProvider
                        var batcher = database.Provider.GetService<IBatcherProvider>();
                        if (batcher == null)
                        {
                            Console.WriteLine("不支持批量插入。");
                        }
                        else
                        {
                            batcher.Insert(table);
                        }

                        //输出batcher表的数据量
                        var sql = new SqlCommand("SELECT COUNT(1) FROM Batcher");
                        Console.WriteLine("当前共有 {0} 条数据", database.ExecuteScalar(sql));

                    })));
        }

使用SqlBulkCopy将DataTable中的数据批量插入数据库中

#region 使用SqlBulkCopy将DataTable中的数据批量插入数据库中  
      /// <summary>  
      /// 使用SqlBulkCopy将DataTable中的数据批量插入数据库中  
      /// </summary>  
      /// <param name="strTableName">数据库中对应的表名</param>  
      /// <param name="dtData">数据集</param>  
      public void SqlBulkCopyInsert(string strTableName, DataTable dtData)  
      {  
          string ConStr = connectionString;// 数据库连接字符串  
  
          try  
          {  
              using (SqlBulkCopy sqlRevdBulkCopy = new SqlBulkCopy(ConStr))//引用SqlBulkCopy  
              {  
                  sqlRevdBulkCopy.DestinationTableName = strTableName;//数据库中对应的表名  
  
                  sqlRevdBulkCopy.NotifyAfter = dtData.Rows.Count;//有几行数据  
  
                  sqlRevdBulkCopy.WriteToServer(dtData);//数据导入数据库  
  
                  sqlRevdBulkCopy.Close();//关闭连接  
              }  
          }  
          catch (Exception ex)  
          {  
              WriteErrorLog(ex.Message + "数据库处理出错654行。SqlBulkCopyInsert");  
              throw (ex);  
          }  
      }  
      #endregion  

使用SqlBulkCopy将DataTable中的数据批量插入数据库中
//BCP copy  
    SqlConnection conn = new SqlConnection();  
    conn.ConnectionString = "server=.;uid=dmkj_hpc;pwd=#$wlh*&1110h%c;database=DMKJ_SMS";  
    conn.Open();  
  
    SqlTransaction sqlbulkTransaction = conn.BeginTransaction();  
  
    //请在插入数据的同时检查约束，如果发生错误调用sqlbulkTransaction事务  
    SqlBulkCopy copy = new SqlBulkCopy(conn, SqlBulkCopyOptions.CheckConstraints, sqlbulkTransaction);  
  
  
    copy.DestinationTableName = "T_SMS_SendInfo";  
    foreach (DataColumn dc in dataTable.Columns)  
    {  
        copy.ColumnMappings.Add(dc.ColumnName, dc.ColumnName);  
  
    }  
    try  
    {  
        copy.WriteToServer(dataTable);  
        sqlbulkTransaction.Commit();  
    }  
    catch (Exception ex)  
    {  
        sqlbulkTransaction.Rollback();  
        Console.WriteLine(ex.ToString());  
    }  
    finally  
    {  
        copy.Close();  
        conn.Close();  
    }  

BCP copy

 

【MyBatis-Plus】之批量插入
王廷云的博客
09-08 1万+
一、应用情景介绍 在实际的项目开发过程中，常常遇到批量保存数据的场景，当数据量比较少，比如只有几条数据的情况下，我们可以使用 for 循环来 insert 数据，但如果数据量比较多的情况下就不行，特别是并发的情况下，因为这样会增加数据库的负担。 我们通过查看 mybatis-plus 源码发现，mybatis-plus 的 IService API 接口提供了批量插入的接口： public interface IService<T> { ...... /** * 插入
mybatispuls3.5使用批量插入
07-21
在MyBatisPlus 3.5版本中，批量插入功能是其核心优化之一，这对于大数据量的操作尤其重要，可以显著提高数据插入的效率。 批量插入的优势在于减少了数据库连接的创建和关闭次数，以及降低了网络通信的开销。...
Day111.使用PreparedStatement实现批量数据的操作 -JDBC技术
阿昌爱Java
11-23 437
使用PreparedStatement实现批量数据的操作 5.1 批量执行SQL语句 当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率 JDBC的批量处理语句包括下面三个方法： addBatch(String)：添加需要批量处理的SQL语句或是参数； executeBatch()：执行批量处理语句； clearBatch():清空缓存的数据 通常我们会遇到两种批量执行SQL语句的情况： 多条SQL语句的批量处
批量插入文件.rar_CAD插件_lisp_writingzyb_批量插入_批量插入文件
07-13
在cad中运行此插件，然后批量插入dwg文件，方便使用。
YII框架批量插入数据的方法
10-20
YII框架提供了灵活的数据库操作接口，允许开发者通过自定义函数来实现高效的数据批量插入。本文将介绍YII框架中批量插入数据的方法，并通过实例演示了如何结合自定义函数来完成这一操作，同时列举了一些在YII框架下...
redis集群批量插入
11-23
当面对大量数据时，批量插入可以显著提高效率，减少网络通信开销。本文将详细讨论如何在Java环境下连接Redis集群并实现批量插入String类型的数据。 首先，我们需要理解Redis集群的基本概念。Redis集群是通过分片...
Mapper批量插入Oracle数据@InsertProvider注解
08-26
Mapper批量插入Oracle数据@InsertProvider注解 Mapper批量插入Oracle数据@InsertProvider注解是Mapper框架中的一种批量插入数据的方式，该方法可以将大量数据批量插入到Oracle数据库中。下面是该方法的详细说明： ...
高效批量插入和更新
03-24
C#批量插入，更新ORACLE 保存100万条数据大概3-5秒 保存或者更新100万条数据大概20秒 DataTable保存100万条数据大概1-2分钟 可能因环境原因时间有差异，不过可以看出性能还是很大提升的
批量插入【对新数据进行插入操作，已存在的记录进行更新操作】
我是Java程序员廖志伟，感谢朋友们的支持！不定期贡献一篇高品质、过万文字、图文并茂且附有视频解说、满载代码示例注释的良心之作，坚决杜绝粗制乱造。
10-21 650
解决方案：将单表的字段进行md5加密得出一个版本id，后续只要插入的字段是一样的，那么加密出来的版本id肯定也是一样的。第一次插入的2和第二次插入的3，他们二个的versionId是不一样的，需要将2改为无效，将3改为有效。第一次插入直接入库，第二次插入发现有一条记录一样，说明插入的数据中有一条记录已经在数据库里面了。第一次插入的1和第二次插入的1，他们二个的versionId是一样的，就不需要插入了。要求结果为1，3的数据是有效的，2的数据是无效的。如果不一样，则需要把之前插入的数据进行清洗。
10. 批量插入
DevOps海洋的渔夫@专栏
06-08 724
10. 批量插入前言上一章节，我们使用 PreparedStatement 操作了 BLOB 字段，下面我们再来看看批量插入的操作。批量插入1. 批量执行SQL语句当需要成批插入或者更新...
sql批量插入数据
蓝色的天空
07-14 374
hi，   自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。    WITH tempT AS ( SELECT item_id AS combo_id, item_id, now() AS create_date FROM ali_item WHERE...
mybatis批量插入
最新发布
weixin_52229884的博客
10-10 326
more。
BatchInsertData实现高效批量插入功能
根据提供的文件信息，我们可以推断该文件所涉及的知识点集中在数据库操作中的批量插入（Batch Insert）功能。为了构建详细的知识点内容，我们将围绕以下几个方面进行阐述： 1. 批量插入的定义与作用 2. 批量插入的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值