Sql异常非常慢......如何加速？

我有一段代码将数据导入到sql表中.当输入数据出现问题(例如,数据类型错误或将被截断)时,它会按预期生成异常,但速度非常慢.如果它们都很好,我可以在几秒钟内导入10,000行,但有时源数据需要一点tlc,因此应用程序会导入好行并报告异常,以便可以修复它们.例如,如果所有10,000行都有一个需要缩短的字段,因为它会被截断,那么它需要10分钟而不是10或20秒.

增加的时间不是因为任何代码在catch块中运行...即使catch块中根本没有代码也会这样做.任何人都知道这是否就是它的方式,或者是否有任何可以做到更快的事情？

编辑:好的,根据请求我在下面添加了一些代码,但我想你很快就会明白我为什么不认为有必要这样做:)

    public void ImportRow(DataRow r, SqlConnection conn, SqlTransaction trx)
    {
        var sqlCmd = _importCommand.CreateSqlCommand(r);
        SqlCommand sCom = new SqlCommand(sqlCmd, conn, trx);

        try
        {
            sCom.ExecuteNonQuery();
        }
        catch (Exception e)
        {

        }
    }

_importCommand.CreateSqlCommand(r)只返回一个字符串(因为你可能已经在SqlCommand构造函数参数中使用了它).正如您所看到的,我还没有向catch块添加任何代码.当没有异常时它会sCom.ExecuteNonQuery();很快执行,但是当有异常时会有一个短暂的暂停.该ImportRow方法在另一个函数的循环中调用,但我已经确定滞后来自此方法的try块,因此其他代码不相关.

在批量插入操作期间遇到错误时,必须回滚成功插入的记录.根据经验,与撤消操作相比,回滚期间操作的撤消将始终较慢,因为它必须回读日志(针对写入优化而不是读取)并补偿操作.然而,不能用10秒到10分钟来解释.因此,除非您能提供某种服务器需要10分钟的证据,否则我必须得出结论,那就是您在10分钟内执行某些操作的应用程序代码.

更新

让我们尝试10k插入所有失败并将它们与成功的10k插入进行比较:

set nocount on;
use master;
if db_id('test') is not null
begin
    alter database test set single_user with rollback immediate;
    drop database test;
end
go

create database test;
go

use test;
go

create table good (a int, b char(1000));
go

declare @start datetime = getdate(), @i int =0;
begin transaction;
while @i < 10000
begin
    insert into good (a) values (@i);
    set @i += 1;
end
commit;
declare @end datetime = getdate();
select 'good: ', datediff(ms, @start, @end);
go

create table bad (a int, b char(1000), constraint fail check (a<0));
go

declare @start datetime = getdate(), @i int =0;
begin transaction;
while @i < 10000
begin
    insert into bad (a) values (@i);
    set @i += 1;
end
commit;
declare @end datetime = getdate();
select 'bad: ', datediff(ms, @start, @end);
go

在我的测试机器上,我获得了大约600毫秒的"好"情况和大约1400毫秒的坏情况.所以异常加倍,但几分钟之内.

接下来,让我们做同样的事情,但是来自托管客户端:

    static void Main(string[] args)
    {
        try
        {
            using (SqlConnection conn = new SqlConnection(@"..."))
            {
                conn.Open();
                Stopwatch sw = new Stopwatch();
                sw.Start();
                using (SqlTransaction trn = conn.BeginTransaction())
                {
                    SqlCommand cmd = new SqlCommand(
                       "insert into good (a) values (@i)", conn, trn);
                    SqlParameter p = new SqlParameter("@i", SqlDbType.Int);
                    cmd.Parameters.Add(p);
                    for (int i = 0; i < 10000; ++i)
                    {
                        p.Value = i;
                        cmd.ExecuteNonQuery();
                    }
                    trn.Commit();
                    sw.Stop();
                }
                Console.WriteLine("Good: {0}", sw.Elapsed);

                int excount = 0;
                sw.Reset();
                sw.Start();

                using (SqlTransaction trn = conn.BeginTransaction())
                {
                    SqlCommand cmd = new SqlCommand(
                        "insert into bad (a) values (@i)", conn, trn);
                    SqlParameter p = new SqlParameter("@i", SqlDbType.Int);
                    cmd.Parameters.Add(p);
                    for (int i = 0; i < 10000; ++i)
                    {
                        p.Value = i;
                        try
                        {
                            cmd.ExecuteNonQuery();
                        }
                        catch (SqlException s)
                        {
                            ++excount;
                        }
                    }
                    trn.Commit();
                    sw.Stop();
                }
                Console.WriteLine("Bad: {0} [Exceptions: {1}]",  
                   sw.Elapsed, excount);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }

结果(零售和调试版本都有类似的时间):

Good: 00:00:00.8601303
Bad: 00:01:57.8987760 [Exceptions: 10000]

因此,从原始SQL Server时间的1.4秒开始,时间已经过去了将近2分钟.所以案件结案,例外是昂贵的,对吗？没那么快.尝试在没有连接调试器的情况下运行应用程序(Ctrl + F5):

Good: 00:00:00.6640281
Bad: 00:00:02.3746845 [Exceptions: 10000]

回到2秒.所以真正的罪魁祸首不是SQL Server,不是C#异常处理也不是SqlClient层.是调试器.这是正常的,因为调试器会执行一些非常具有侵入性的操作,并在每个抛出的CLR异常上运行大量代码.如果您的代码基本上只是抛出异常,那么结果会产生很大的影响.它被称为First Chance Exception Handling,其他人之前曾说过.

但是,如果正在调试应用程序,则调试器会在程序执行之前查看所有异常.这是第一次和第二次机会异常之间的区别:调试器第一次看到异常(因此名称).如果调试器允许程序执行继续并且不处理异常,程序将像往常一样看到异常.

再次证明,在处理性能问题时,最好是衡量.