Sql Server数据库事务

事务是单个的工作单元。如果某一事务成功，则在该事务中进行的所有数据修改均会提交，成为数据库中的永久组成部分。如果事务遇到错误且必须取消或回滚，则所有数据修改均被清除。

      举个例子，比如你去银行转帐就是一个事务。转帐可以简单的分为两个步骤，一是把钱从你的帐户中扣除，二是把钱存到你指定转帐的帐户中。这两个步骤就是一个事务，必须全部执行，或是全部不执行。如果从你帐户扣钱成功，但是转帐失败，那么你转帐的钱就没有了；如果是扣钱失败了，但是转帐成功了，那银行就亏了。

       事务是作为单个逻辑工作单元执行的一系列操作。一个逻辑工作单元必须有四个属性，称为原子性、一致性、隔离性和持久性 (ACID) 属性，只有这样才能成为一个事务。
       原子性：事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。
       一致性：事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内部数据结构（如 B 树索引或双向链表）都必须是正确的。
       隔离：由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务识别数据时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是第二个事务修改它之后的状态，事务不会识别中间状态的数据。这称为可串行性，因为它能够重新装载起始数据，并且重播一系列事务，以使数据结束时的状态与原始事务执行的状态相同。
      持久性：事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一直保持。

      SQL Server 以下列事务模式运行。
      自动提交事务:每条单独的语句都是一个事务。
      显式事务:每个事务均以 BEGIN TRANSACTION 语句显式开始，以 COMMIT 或 ROLLBACK 语句显式结束。
      隐式事务:在前一个事务完成时新事务隐式启动，但每个事务仍以 COMMIT 或 ROLLBACK 语句显式完成。
      批处理级事务:只能应用于多个活动结果集 (MARS)，在 MARS 会话中启动的 Transact-SQL 显式或隐式事务变为批处理级事务。当批处理完成时没有提交或回滚的批处理级事务自动由 SQL Server 进行回滚。

      Sql Server中有三种使用事务的方法，分别是Sql语句，SqlTransaction和TransactionScope，下面一节将分别介绍这三种事务的使用方法。

本节主要介绍Sql语句，SqlTransaction和TransactionScope这三种使用事务的方法。

      本节的所有例子都在sql server 2008和vs 2008环境下运行通过，如果没有sql server2008，那么使用sql server 2005也一样，但是sql se rver 2000上是无法运行通过的，因为某些sql语句在2000中不支持。请大家注意这点。

       请先执行下面的脚本，在本机的数据库实例中建立测试数据库，以方便运行例子。

[c-sharp] view plain copy

1. --建库  
2. IF EXISTS (SELECT name FROM sys.databases WHERE name = N'TransTestDb')  
3.     drop database [TransTestDb]  
4.   
5. CREATE DATABASE [TransTestDb];  
6.   
7.   
8. --建表  
9. use [TransTestDb]  
10. go  
11. IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[TransTestTable]') AND type in (N'U'))  
12.     drop table [TransTestTable]  
13.   
14. CREATE TABLE [dbo].[TransTestTable](Id int, [Name] varchar(16));  
15.   
16.   
17. --初始值  
18. use [TransTestDb]  
19. go  
20. insert into [TransTestTable]  
21.     select 1,'a' union  
22.     select 2,'b' union  
23.     select 3,'c';  

 

      首先介绍利用Sql语句来使用事务。Sql Server2005/2008提供了begin tran，commit tran和rollback tran三个语句来显示的使用事务。begin tran表示事务开始，commit tran表示事务提交，rollback tran表示事务回滚。具体代码如下：

[c-sharp] view plain copy

1. begin try  
2.     begin tran  
3.         insert into dbo.TransTestTable values (66,'66');  
4.         update dbo.TransTestTable set [Name] = '77' where [Id] = 66;  
5.         --RAISERROR ('Error raised in TRY block.',16,1);  
6.     commit tran  
7. end try  
8. begin catch  
9.     rollback tran  
10. end catch  

      代码中的begin try和begin catch是捕获异常时使用的，只在sql server2005/2008中支持，sql server 2000上不支持这个语句。在begin try 和 end try之间的代码运行时如果发生异常，则程序会跳转到begin catch和end catch中执行相关的rollback tran回滚操作。在begin tran和commit tran之间就是一个事务，insert和update必须同时成功，否则就同时失败。RAISERROR 语句的意思是抛出一个异常，只在sql server2005/2008中支持，sql server 2000上不支持这个语句。

      执行上面的代码，我们会发现，插入和更新同时都成功了。把RAISERROR的注释去掉后，再执行，我们会发现，插入和更新都回滚了。因为RAISERROR抛出异常后，没有执行到commit tran，而是直接执行begin catch里面的rollback tran回滚语句了。

 

      下面介绍SqlTransaction的使用方法。SqlTransaction是System.Data.SqlClient命名空间下的一个事务类，主要方法有Commit()和Rollback()两个函数，更多方法和属性请参考MSDN。具体代码如下：

[c-sharp] view plain copy

1. static void Main(string[] args)  
2.         {  
3.   
4.             SqlConnection sqlConn = new SqlConnection(  
5.                 ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString);  
6.             SqlTransaction sqlTrans = null;  
7.             try  
8.             {  
9.                 sqlConn.Open();  
10.                 sqlTrans = sqlConn.BeginTransaction();//事务开始  
11.                 SqlCommand sqlComm = new SqlCommand("", sqlConn, sqlTrans);  
12.                 sqlComm.CommandTimeout = 120;  
13.                 sqlComm.CommandType = System.Data.CommandType.Text;  
14.   
15.                 string insertSql = "insert into dbo.TransTestTable values (66,'66');";  
16.                 string updateSql = "update dbo.TransTestTable set [Name] = '77' where [Id] = 66;";  
17.   
18.                 sqlComm.CommandText = insertSql;  
19.                 sqlComm.ExecuteNonQuery();//执行insert  
20.   
21.                 sqlComm.CommandText = updateSql;  
22.                 sqlComm.ExecuteNonQuery();//执行update  
23.                 //throw new Exception("test exception.the transaction must rollback");  
24.   
25.                 sqlTrans.Commit();//事务提交  
26.             }  
27.             catch (Exception ex)  
28.             {  
29.                 sqlTrans.Rollback();//事务回滚  
30.                 Console.WriteLine(ex.Message);  
31.             }  
32.             finally  
33.             {  
34.                 if (sqlConn.State != System.Data.ConnectionState.Closed)  
35.                     sqlConn.Close();  
36.             }  
37.   
38.             Console.ReadLine();  
39.         }  

上面的代码显示了SqlTransaction类的基本使用方法。首先使用SqlConnection建立连接后，sqlConn.BeginTransaction()表示事务的开始，在执行一些基本操作后（代码是执行一个insert和一个update）后，执行sqlTrans.Commit();表示事务提交，这时候，刚才insert和update的数据在数据库才能被使用。如果把throw new Exception("test exception.the transaction must rollback");这句的注释去掉，我们会发现，程序没有执行提交，而是直接执行了catch中的Rollback()，进行了回滚。那么刚才的insert和update一起被回滚。

 

       最后看一下TransactionScope的基本用法。TransactionScope继承IDisposable接口，所以一般在using中使用。具体代码如下：

[c-sharp] view plain copy

1. static void Main(string[] args)  
2. {  
3.    using (TransactionScope scope = new TransactionScope())  
4.    {  
5.        SqlConnection sqlConn = new SqlConnection(  
6.            ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString);  
7.        sqlConn.Open();  
8.   
9.         string insertSql = "insert into [TransTestTable] values(11,'11')";  
10.         string updateSql = "update [TransTestTable] set [Name] = '111' where [Id] = 11";  
11.   
12.        SqlCommand sqlComm = new SqlCommand(insertSql, sqlConn);  
13.        sqlComm.CommandType = System.Data.CommandType.Text;  
14.        sqlComm.ExecuteNonQuery();  
15.                   
16.        sqlComm = new SqlCommand(updateSql, sqlConn);  
17.        sqlComm.CommandType = System.Data.CommandType.Text;  
18.        sqlComm.ExecuteNonQuery();  
19.   
20.        sqlConn.Close();  
21.   
22.        scope.Complete();  
23.      }  
24.   
25.      Console.ReadLine();  
26. }  

在using中定义了一个TransactionScope，相当于定义了一个事务范围即这个事务作用域为using内。程序执行了两个动作，一个insert，一个update，最后执行了scope.Complete();相当于提交事务。如果把scope.Complete();注释掉，我们会发现insert和update都被回滚了，因为在using作用域内，如果没有提交命令，那么scope在销毁时，会自动回滚所有的操作

 

      以上就是三种事务的基本使用方法，在此基础之上，还可以引申出更多的问题，比如嵌套事务，三种方法的混合使用等问题。在此就不一一列举了。