本篇，我将来讲解一下在sqlserver中批量插入数据。
先创建一个用来测试的数据库和表，为了让插入数据更快，表中主键采用的是guid，表中没有创建任何索引。guid必然是比自增长要快的，因为你生成一个guid算法所花的时间肯定比你从数据表中重新查询上一条记录的id的值然后再进行加1运算要少。而如果存在索引的情况下，每次插入记录都会进行索引重建，这是非常耗性能的。如果表中无可避免的存在索引，我们可以通过先删除索引，然后批量插入，最后再重建索引的方式来提高效率。
create database carsys;
go
use carsys;
go
create table product(
id uniqueidentifier primary key ,
name varchar (50) not null ,
price decimal (18,2) not null
)
我们通过sql脚本来插入数据，常见如下四种方式。
方式一：一条一条插入，性能最差，不建议使用。
insert into product(id, name ,price) values (newid(), '牛栏1段' ,160);
insert into product(id, name ,price) values (newid(), '牛栏2段' ,260);
......
方式二：insert bulk
语法如下：
bulk insert [ [ 'database_name' .][ 'owner' ].]{ 'table_name' from 'data_file' }
with (
[ batchsize [ = batch_size ] ],
[ check_constraints ],
[ codepage [ = 'acp' | 'oem' | 'raw' | 'code_page' ] ],
[ datafiletype [ = 'char' | 'native' | 'widechar' | 'widenative' ] ],
[ fieldterminator [ = 'field_terminator' ] ],
[ firstrow [ = first_row ] ],
[ fire_triggers ],
[ formatfile = 'format_file_path' ],
[ keepidentity ],
[ keepnulls ],
[ kilobytes_per_batch [ = kilobytes_per_batch ] ],
[ lastrow [ = last_row ] ],
[ maxerrors [ = max_errors ] ],
[ order ( { column [ asc | desc ] } [ ,...n ] ) ],
[ rows_per_batch [ = rows_per_batch ] ],
[ rowterminator [ = 'row_terminator' ] ],
[ tablock ],
)
相关参数说明：
bulk insert
[ database_name . [ schema_name ] . | schema_name . ] [ table_name | view_name ]
from 'data_file'
[ with
(
[ [ , ] batchsize = batch_size ] --batchsize指令来设置在单个事务中可以插入到表中的记录的数量
[ [ , ] check_constraints ] --指定在大容量导入操作期间，必须检查所有对目标表或视图的约束。若没有 check_constraints 选项，则所有 check 和 foreign key 约束都将被忽略，并且在此操作之后表的约束将标记为不可信。
[ [ , ] codepage = { 'acp' | 'oem' | 'raw' | 'code_page' } ] --指定该数据文件中数据的代码页
[ [ , ] datafiletype =
{ 'char' | 'native' | 'widechar' | 'widenative' } ] --指定 bulk insert 使用指定的数据文件类型值执行导入操作。
[ [ , ] fieldterminator = 'field_terminator' ] --标识分隔内容的符号
[ [ , ] firstrow = first_row ] --指定要加载的第一行的行号。默认值是指定数据文件中的第一行
[ [ , ] fire_triggers ] --是否启动触发器
[ [ , ] formatfile = 'format_file_path' ]
[ [ , ] keepidentity ] --指定导入数据文件中的标识值用于标识列
[ [ , ] keepnulls ] --指定在大容量导入操作期间空列应保留一个空值，而不插入用于列的任何默认值
[ [ , ] kilobytes_per_batch = kilobytes_per_batch ]
[ [ , ] lastrow = last_row ] --指定要加载的最后一行的行号
[ [ , ] maxerrors = max_errors ] --指定允许在数据中出现的最多语法错误数，超过该数量后将取消大容量导入操作。
[ [ , ] order ( { column [ asc | desc ] } [ ,...n ] ) ] --指定数据文件中的数据如何排序
[ [ , ] rows_per_batch = rows_per_batch ]
[ [ , ] rowterminator = 'row_terminator' ] --标识分隔行的符号
[ [ , ] tablock ] --指定为大容量导入操作持续时间获取一个表级锁
[ [ , ] errorfile = 'file_name' ] --指定用于收集格式有误且不能转换为 ole db 行集的行的文件。
)]
方式三：insert into xx select...
insert into product(id, name ,price)
select newid(), '牛栏1段' ,160
union all
select newid(), '牛栏2段' ,180
union all
......
方式四：拼接sql
insert into product(id, name ,price) values
(newid(), '牛栏1段' ,160)
,(newid(), '牛栏2段' ,260)
......
在c#中通过ado.net来实现批量操作存在四种与之对应的方式。
方式一：逐条插入
#region 方式一
static void insertone()
{
console.writeline( "采用一条一条插入的方式实现" );
stopwatch sw = new stopwatch();
using (sqlconnection conn = new sqlconnection(strconnmsg)) //using中会自动open和close 连接。
{
string sql = "insert into product(id,name,price) values(newid(),@p,@d)" ;
conn.open();
for ( int i = 0; i < totalrow; i++)
{
using (sqlcommand cmd = new sqlcommand(sql, conn))
{
cmd.parameters.addwithvalue( "@p" , "商品" + i);
cmd.parameters.addwithvalue( "@d" , i);
sw.start();
cmd.executenonquery();
console.writeline( string .format( "插入一条记录，已耗时{0}毫秒" , sw.elapsedmilliseconds));
}
if (i == getrow)
{
sw.stop();
break ;
}
}
}
console.writeline( string .format( "插入{0}条记录，每{4}条的插入时间是{1}毫秒,预估总得插入时间是{2}毫秒，{3}分钟" ,
totalrow, sw.elapsedmilliseconds, ((sw.elapsedmilliseconds / getrow) * totalrow), getminute((sw.elapsedmilliseconds / getrow * totalrow)), getrow));
}
static int getminute( long l)
{
return (int32)l / 60000;
}
#endregion
运行结果如下：
我们会发现插入100w条记录，预计需要50分钟时间，每插入一条记录大概需要3毫秒左右。
方式二：使用sqlbulk
#region 方式二
static void inserttwo()
{
console.writeline( "使用bulk插入的实现方式" );
stopwatch sw = new stopwatch();
datatable dt = gettableschema();
using (sqlconnection conn = new sqlconnection(strconnmsg))
{
sqlbulkcopy bulkcopy = new sqlbulkcopy(conn);
bulkcopy.destinationtablename = "product" ;
bulkcopy.batchsize = dt.rows.count;
conn.open();
sw.start();
for ( int i = 0; i < totalrow;i++ )
{
datarow dr = dt.newrow();
dr[0] = guid.newguid();
dr[1] = string .format( "商品" , i);
dr[2] = ( decimal )i;
dt.rows.add(dr);
}
if (dt != null && dt.rows.count != 0)
{
bulkcopy.writetoserver(dt);
sw.stop();
}
console.writeline( string .format( "插入{0}条记录共花费{1}毫秒，{2}分钟" , totalrow, sw.elapsedmilliseconds, getminute(sw.elapsedmilliseconds)));
}
}
static datatable gettableschema()
{
datatable dt = new datatable();
dt.columns.addrange( new datacolumn[] {
new datacolumn( "id" , typeof (guid)),
new datacolumn( "name" , typeof ( string )),
new datacolumn( "price" , typeof ( decimal ))});
return dt;
}
#endregion
运行结果如下：
插入100w条记录才8s多，是不是很溜。
打开sqlserver profiler跟踪，会发现执行的是如下语句：
insert bulk product ([id] uniqueidentifier, [name] varchar(50) collate chinese_prc_ci_as, [price] decimal(18,2))
方式三：使用tvps(表值参数）插入数据
从sqlserver 2008起开始支持tvps。创建缓存表producttemp ，执行如下sql。
create type producttemp as table (
id uniqueidentifier primary key ,
name varchar (50) not null ,
price decimal (18,2) not null
)
执行完成之后，会发现在数据库carsys下面多了一张缓存表producttemp
可见插入100w条记录共花费了11秒多。
方式四：拼接sql
此种方法在c#中有限制，一次性只能批量插入1000条，所以就得分段进行插入。
#region 方式四
static void insertfour()
{
console.writeline( "采用拼接批量sql插入的方式实现" );
stopwatch sw = new stopwatch();
using (sqlconnection conn = new sqlconnection(strconnmsg)) //using中会自动open和close 连接。
{
conn.open();
sw.start();
for ( int j = 0; j < totalrow / getrow;j++ )
{
stringbuilder sb = new stringbuilder();
sb.append( "insert into product(id,name,price) values" );
using (sqlcommand cmd = new sqlcommand())
{
for ( int i = 0; i < getrow; i++)
{
sb.appendformat( "(newid(),'商品{0}',{0})," , j*i+i);
}
cmd.connection = conn;
cmd测试数据mandtext = sb.tostring().trimend( ',' );
cmd.executenonquery();
}
}
sw.stop();
console.writeline( string .format( "插入{0}条记录，共耗时{1}毫秒" ,totalrow,sw.elapsedmilliseconds));
}
}
#endregion
运行结果如下：
我们可以看到大概花费了10分钟。虽然在方式一的基础上，性能有了较大的提升，但是显然还是不够快。
总结： 大数据批量插入方式一和方式四尽量避免使用，而方式二和方式三都是非常高效的批量插入数据方式。其都是通过构建datatable的方式插入的，而我们知道datatable是存在内存中的，所以当数据量特别特别大，大到内存中无法一次性存储的时候，可以分段插入。比如需要插入9千万条数据，可以分成9段进行插入，一次插入1千万条。而在for循环中直接进行数据库操作，我们是应该尽量避免的。每一次数据库的连接、打开和关闭都是比较耗时的，虽然在c#中存在数据库连接池，也就是当我们使用using或者conn.close()，进行释放连接时，其实并没有真正关闭数据库连接，它只是让连接以类似于休眠的方式存在，当再次操作的时候，会从连接池中找一个休眠状态的连接，唤醒它，这样可以有效的提高并发能力，减少连接损耗。而连接池中的连接数，我们都是可以配置的。
源码下载
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持服务器之家！
原文链接：http://HdhCmsTestcnblogs测试数据/jiekzou/p/6145550.html
dy("nrwz");
查看更多关于详解C#批量插入数据到Sqlserver中的四种方式的详细内容...