标签：没有 数据 nsa 快照 溢出 禁用 static val ber
一. 事务和锁
了解事务和锁
事务：保持逻辑数据一致性与可恢复性，必不可少的利器。
锁：多用户访问同一数据库资源时，对访问的先后次序权限管理的一种机制，没有他事务或许将会一塌糊涂，不能保证数据的安全正确读写。
死锁：是数据库性能的重量级杀手之一，而死锁却是不同事务之间抢占数据资源造成的。
不懂的听上去，挺神奇的，懂的感觉我在扯淡，下面带你好好领略下他们的风采，嗅査下他们的狂骚。。
先说事务--概念，分类
用华仔无间道中的一句来给你诠释下：去不了终点，回到原点。
举例说明：
在一个事务中，你写啦2条sql语句，一条是修改订单表状态,一条是修改库存表库存-1 。 如果在修改订单表状态的时候出错，事务能够回滚，数据将恢复到没修改之前的数据状态，下面的修改库存也就不执行，这样确保你关系逻辑的一致，安全。。
事务就是这个样子，倔脾气，要么全部执行，要么全部不执行，回到原数据状态。
书面解释：事务具有原子性，一致性，隔离性，持久性。
然而在SQL Server中事务被分为3类常见的事务：
显式事务的应用
常用语句就四个。
上面的都是心法，下面的给你来个招式，要看仔细啦。
1 ---开启事务
2 begin tran
3 --错误扑捉机制，看好啦，这里也有的。并且可以嵌套。
4 begin try
5 --语句正确
6 insert into lives (Eat,Play,Numb) values (‘猪肉‘,‘足球‘,1)
7 --Numb为int类型，出错
8 insert into lives (Eat,Play,Numb) values (‘猪肉‘,‘足球‘,‘abc‘)
9 --语句正确
10 insert into lives (Eat,Play,Numb) values (‘狗肉‘,‘篮球‘,2)
11 end try
12 begin catch
13 select Error_number() as ErrorNumber, --错误代码
14 Error_severity() as ErrorSeverity, --错误严重级别，级别小于10 try catch 捕获不到
15 Error_state() as ErrorState , --错误状态码
16 Error_Procedure() as ErrorProcedure , --出现错误的存储过程或触发器的名称。
17 Error_line() as ErrorLine, --发生错误的行号
18 Error_message() as ErrorMessage --错误的具体信息
19 if(@@trancount>0) --全局变量@@trancount，事务开启此值+1，他用来判断是有开启事务
20 rollback tran ---由于出错，这里回滚到开始，第一条语句也没有插入成功。
21 end catch
22 if(@@trancount>0)
23 commit tran --如果成功Lives表中，将会有3条数据。
24
25 --表本身为空表，ID ,Numb为int 类型，其它为nvarchar类型
26 select * from lives
---开启事务
begin tran
--错误扑捉机制，看好啦，这里也有的。并且可以嵌套。
begin try
--语句正确
insert into lives (Eat,Play,Numb) values (‘猪肉‘,‘足球‘,1)
--加入保存点
save tran pigOneIn
--Numb为int类型，出错
insert into lives (Eat,Play,Numb) values (‘猪肉‘,‘足球‘,2)
--语句正确
insert into lives (Eat,Play,Numb) values (‘狗肉‘,‘篮球‘,3)
end try
begin catch
select Error_number() as ErrorNumber, --错误代码
Error_severity() as ErrorSeverity, --错误严重级别，级别小于10 try catch 捕获不到
Error_state() as ErrorState , --错误状态码
Error_Procedure() as ErrorProcedure , --出现错误的存储过程或触发器的名称。
Error_line() as ErrorLine, --发生错误的行号
Error_message() as ErrorMessage --错误的具体信息
if(@@trancount>0) --全局变量@@trancount，事务开启此值+1，他用来判断是有开启事务
rollback tran ---由于出错，这里回滚事务到原点，第一条语句也没有插入成功。
end catch
if(@@trancount>0)
rollback tran pigOneIn --如果成功Lives表中，将会有3条数据。
--表本身为空表，ID ,Numb为int 类型，其它为nvarchar类型
select * from lives
使用set xact_abort
设置 xact_abort on/off , 指定是否回滚当前事务，为on时如果当前sql出错，回滚整个事务，为off时如果sql出错回滚当前sql语句，其它语句照常运行读写数据库。
需要注意的时：xact_abort只对运行时出现的错误有用，如果sql语句存在编译时错误，那么他就失灵啦。
delete lives --清空数据
set xact_abort off
begin tran
--语句正确
insert into lives (Eat,Play,Numb) values (‘猪肉‘,‘足球‘,1)
--Numb为int类型，出错,如果1234..那个大数据换成‘132dsaf‘ xact_abort将失效
insert into lives (Eat,Play,Numb) values (‘猪肉‘,‘足球‘,12345646879783213)
--语句正确
insert into lives (Eat,Play,Numb) values (‘狗肉‘,‘篮球‘,3)
commit tran
select * from lives
为on时，结果集为空，因为运行是数据过大溢出出错，回滚整个事务。
事务把死锁给整出来啦
跟着做：打开两个查询窗口，把下面的语句，分别放入2个查询窗口，在5秒内运行2个事务模块。
begin tran
update lives set play=‘羽毛球‘
waitfor delay ‘0:0:5‘
update dbo.Earth set Animal=‘老虎‘
commit tran
begin tran
update Earth set Animal=‘老虎‘
waitfor delay ‘0:0:5‘ --等待5秒执行下面的语句
update lives set play=‘羽毛球‘
commit tran
select * from lives
select * from Earth
为什么呢，下面我们看看锁，什么是锁。
并发事务成败皆归于锁——锁定
在多用户都用事务同时访问同一个数据资源的情况下，就会造成以下几种数据错误。
然而锁定，就是为解决这些问题所生的，他的存在使得一个事务对他自己的数据块进行操作的时候，而另外一个事务则不能插足这些数据块。这就是所谓的锁定。
锁定从数据库系统的角度大致可以分为6种：
这些锁之间的相互兼容性，也就是，是否可以同时存在。
|
|
现有的授权模式 |
|
|
|
|
|
|
请求的模式 |
IS |
S |
U |
IX |
SIX |
X |
|
意向共享 (IS) |
是 |
是 |
是 |
是 |
是 |
否 |
|
共享 (S) |
是 |
是 |
是 |
否 |
否 |
否 |
|
更新 (U) |
是 |
是 |
否 |
否 |
否 |
否 |
|
意向排他 (IX) |
是 |
否 |
否 |
是 |
否 |
否 |
|
意向排他共享 (SIX) |
是 |
否 |
否 |
否 |
否 |
否 |
|
排他 (X) |
否 |
否 |
否 |
否 |
否 |
否 |
锁兼容性具体参见：http://msdn.microsoft.com/zh-cn/library/ms186396.aspx
锁粒度和层次结构参见：http://msdn.microsoft.com/zh-cn/library/ms189849(v=sql.105).aspx
死锁
什么是死锁，为什么会产生死锁。我用 “事务把死锁给整出来啦” 标题下的两个事务产生的死锁来解释应该会更加生动形象点。
例子是这样的：
第一个事务（称为A）：先更新lives表 --->>停顿5秒---->>更新earth表
第二个事务（称为B）：先更新earth表--->>停顿5秒---->>更新lives表
先执行事务A----5秒之内---执行事务B，出现死锁现象。
过程是这样子的：
这样相互等待对方释放资源，造成资源读写拥挤堵塞的情况，就被称为死锁现象，也叫做阻塞。而为什么会产生，上例就列举出来啦。
然而数据库并没有出现无限等待的情况，是因为数据库搜索引擎会定期检测这种状况，一旦发现有情况，立马选择一个事务作为牺牲品。牺牲的事务，将会回滚数据。有点像两个人在过独木桥，两个无脑的人都走在啦独木桥中间，如果不落水，必定要有一个人给退回来。这种相互等待的过程，是一种耗时耗资源的现象，所以能避则避。
哪个人会被退回来，作为牺牲品，这个我们是可以控制的。控制语法：
set deadlock_priority <级别>
死锁处理的优先级别为 low<normal<high，不指定的情况下默认为normal，牺牲品为随机。如果指定，牺牲品为级别低的。
还可以使用数字来处理标识级别：-10到-5为low，-5为normal，-5到10为high。
减少死锁的发生，提高数据库性能
死锁耗时耗资源，然而在大型数据库中，高并发带来的死锁是不可避免的，所以我们只能让其变的更少。
可参考：http://msdn.microsoft.com/zh-cn/library/ms191242(v=sql.105).aspx
查看锁活动情况：
--查看锁活动情况
select * from sys.dm_tran_locks
--查看事务活动情况
dbcc opentran
可参考：http://msdn.microsoft.com/zh-cn/library/ms190345.aspx
为事务设置隔离级别
所谓事物隔离级别，就是并发事务对同一资源的读取深度层次。分为5种。
--语法
set tran isolation level <级别>
read uncommitted隔离级别的例子：
begin tran
set deadlock_priority low
update Earth set Animal=‘老虎‘
waitfor delay ‘0:0:5‘ --等待5秒执行下面的语句
rollback tran
开另外一个查询窗口执行下面语句
set tran isolation level read uncommitted
select * from Earth --读取的数据为正在修改的数据 ，脏读
waitfor delay ‘0:0:5‘ --5秒之后数据已经回滚
select * from Earth --回滚之后的数据
read committed隔离级别的例子：
begin tran
update Earth set Animal=‘老虎‘
waitfor delay ‘0:0:10‘ --等待5秒执行下面的语句
rollback tran
set tran isolation level read committed
select * from Earth ---获取不到老虎，不能脏读
update Earth set Animal=‘猴子1‘ --可以修改
waitfor delay ‘0:0:10‘ --10秒之后上一个事务已经回滚
select * from Earth --修改之后的数据，而不是猴子
剩下的几个级别，不一一列举啦，自己理解吧。
设置锁超时时间
发生死锁的时候，数据库引擎会自动检测死锁，解决问题，然而这样子是很被动，只能在发生死锁后，等待处理。
然而我们也可以主动出击，设置锁超时时间，一旦资源被锁定阻塞，超过设置的锁定时间，阻塞语句自动取消，释放资源，报1222错误。
好东西一般都具有两面性，调优的同时，也有他的不足之处，那就是一旦超过时间，语句取消，释放资源，但是当前报错事务，不会回滚，会造成数据错误，你需要在程序中捕获1222错误，用程序处理当前事务的逻辑，使数据正确。
--查看超时时间,默认为-1
select @@lock_timeout
--设置超时时间
set lock_timeout 0 --为0时，即为一旦发现资源锁定，立即报错，不在等待，当前事务不回滚，设置时间需谨慎处理后事啊，你hold不住的。
二. 存储过程
存储过程简介
什么是存储过程：存储过程可以说是一个记录集吧，它是由一些T-SQL语句组成的代码块，这些T-SQL语句代码像一个方法一样实现一些功能（对单表或多表的增删改查），然后再给这个代码块取一个名字，在用到这个功能的时候调用他就行了。
存储过程的好处：
1.由于数据库执行动作时，是先编译后执行的。然而存储过程是一个编译过的代码块，所以执行效率要比T-SQL语句高。
2.一个存储过程在程序在网络中交互时可以替代大堆的T-SQL语句，所以也能降低网络的通信量，提高通信速率。
3.通过存储过程能够使没有权限的用户在控制之下间接地存取数据库，从而确保数据的安全。
小结：总之存储过程是好东西，在做项目时属于必备利器，下面介绍存储过程的基本语法。
存储过程的语法和参数讲解
存储过程的一些基本语法：
--------------创建存储过程-----------------
CREATE PROC [ EDURE ] procedure_name [ ; number ]
[ { @parameter data_type }
[ VARYING ] [ = default ] [ OUTPUT ]
] [ ,...n ]
[ WITH
{ RECOMPILE | ENCRYPTION | RECOMPILE , ENCRYPTION } ]
[ FOR REPLICATION ]
AS sql_statement [ ...n ]
--------------调用存储过程-----------------
EXECUTE Procedure_name ‘‘ --存储过程如果有参数，后面加参数格式为：@参数名=value，也可直接为参数值value
--------------删除存储过程-----------------
drop procedure procedure_name --在存储过程中能调用另外一个存储过程，而不能删除另外一个存储过程
创建存储过程的参数：
1.procedure_name ：存储过程的名称，在前面加#为局部临时存储过程，加##为全局临时存储过程。
2.; number：是可选的整数，用来对同名的过程分组，以便用一条 DROP PROCEDURE 语句即可将同组的过程一起除去。例如，名为 orders 的应用程序使用的过程可以命名为 orderproc;1、orderproc;2 等。DROP PROCEDURE orderproc 语句将除去整个组。如果名称中包含定界标识符，则数字不应包含在标识符中，只应在 procedure_name 前后使用适当的定界符。
3.@parameter： 存储过程的参数。可以有一个或多个。用户必须在执行过程时提供每个所声明参数的值（除非定义了该参数的默认值）。存储过程最多可以有 2.100 个参数。
使用 @ 符号作为第一个字符来指定参数名称。参数名称必须符合标识符的规则。每个过程的参数仅用于该过程本身；相同的参数名称可以用在其它过程中。默认情况下，参数只能代替常量，而不能用于代替表名、列名或其它数据库对象的名称。有关更多信息，请参见 EXECUTE。
4.data_type：参数的数据类型。所有数据类型（包括 text、ntext 和 image）均可以用作存储过程的参数。不过，cursor 数据类型只能用于 OUTPUT 参数。如果指定的数据类型为 cursor，也必须同时指定 VARYING 和 OUTPUT 关键字。有关 SQL Server 提供的数据类型及其语法的更多信息，请参见数据类型。
说明 对于可以是 cursor 数据类型的输出参数，没有最大数目的限制。
5.VARYING： 指定作为输出参数支持的结果集（由存储过程动态构造，内容可以变化）。仅适用于游标参数。
6.default： 参数的默认值。如果定义了默认值，不必指定该参数的值即可执行过程。默认值必须是常量或 NULL。如果过程将对该参数使用 LIKE 关键字，那么默认值中可以包含通配符（%、_、[] 和 [^]）。
7.OUTPUT ：表明参数是返回参数。该选项的值可以返回给 EXEC[UTE]。使用 OUTPUT 参数可将信息返回给调用过程。Text、ntext 和 image 参数可用作 OUTPUT 参数。使用 OUTPUT 关键字的输出参数可以是游标占位符。
8.RECOMPILE: 表明 SQL Server 不会缓存该过程的计划，该过程将在运行时重新编译。在使用非典型值或临时值而不希望覆盖缓存在内存中的执行计划时，请使用 RECOMPILE 选项。
9.ENCRYPTION: 表示 SQL Server 加密 syscomments 表中包含 CREATE PROCEDURE 语句文本的条目。使用 ENCRYPTION 可防止将过程作为 SQL Server 复制的一部分发布。 说明 在升级过程中，SQL Server 利用存储在 syscomments 中的加密注释来重新创建加密过程。
10.FOR REPLICATION :指定不能在订阅服务器上执行为复制创建的存储过程。.使用 FOR REPLICATION 选项创建的存储过程可用作存储过程筛选，且只能在复制过程中执行。本选项不能和 WITH RECOMPILE 选项一起使用。
11.AS :指定过程要执行的操作。
12.sql_statement :过程中要包含的任意数目和类型的 Transact-SQL 语句。但有一些限制。
小结：看过这些基本语法后，下面我就根据语法创建各式的存储过程。
创建存储过程
|
UserAccount |
||||
|
UserID |
UserName |
PassWord |
RegisterTime |
RegisterIP |
|
12 |
6 |
6 |
2012-12-31 |
6 |
|
18 |
5 |
5 |
2013-01-01 |
5 |
|
19 |
1 |
1 |
2013-01-01 |
1 |
|
20 |
2 |
2 |
2013-01-01 |
2 |
|
21 |
3 |
3 |
2013-01-01 |
3 |
|
22 |
4 |
4 |
2013-01-01 |
4 |
|
23 |
5 |
5 |
2013-01-01 |
5 |
|
25 |
7 |
7 |
2013-01-01 |
7 |
|
26 |
8 |
8 |
2013-01-01 |
8 |
|
NULL |
NULL |
NULL |
NULL |
NULL |
针对上面的表，我使用存储过程对它做一些操作：
1. 只返回单一记录集的存储过程
-------------创建名为GetUserAccount的存储过程----------------
create Procedure GetUserAccount
as
select * from UserAccount
go
-------------执行上面的存储过程----------------
exec GetUserAccount
结果：相当于运行 select * from UserAccount 这行代码，结果为整个表的数据。
2.没有输入输出的存储过程
-------------创建名为GetUserAccount的存储过程----------------
create Procedure inUserAccount
as
insert into UserAccount (UserName,[PassWord],RegisterTime,RegisterIP) values(9,9,‘2013-01-02‘,9)
go
-------------执行上面的存储过程----------------
exec inUserAccount
结果：相当于运行 insert into UserAccount (UserName,[PassWord],RegisterTime,RegisterIP) values(9,9,‘2013-01-02‘,9) 这行代码。
3.有返回值的存储过程
-------------创建名为GetUserAccount的存储过程----------------
create Procedure inUserAccountRe
as
insert into UserAccount (UserName,[PassWord],RegisterTime,RegisterIP) values(10,10,‘2013-01-02‘,10)
return @@rowcount
go
-------------执行上面的存储过程----------------
exec inUserAccountRe
解释：这里的@@rowcount为执行存储过程影响的行数，执行的结果是不仅插入了一条数据，还返回了一个值即 return value =1 ，这个可以在程序中获取，稍后在c#调用存储过程中会有说到。
4.有输入参数和输出参数的存储过程
-------------创建名为GetUserAccount的存储过程----------------
create Procedure GetUserAccountRe
@UserName nchar(20),
@UserID int output
as
if(@UserName>5)
select @UserID=COUNT(*) from UserAccount where UserID>25
else
set @UserID=1000
go
-------------执行上面的存储过程----------------
exec GetUserAccountRe ‘7‘,null
解释：@UserName为输入参数，@UserID为输出参数。 运行结果为@userID为COOUT（*）即 =1。
5. 同时具有返回值、输入参数、输出参数的存储过程
-------------创建名为GetUserAccount的存储过程----------------
create Procedure GetUserAccountRe1
@UserName nchar(20),
@UserID int output
as
if(@UserName>5)
select @UserID=COUNT(*) from UserAccount where UserID>25
else
set @UserID=1000
return @@rowcount
go
-------------执行上面的存储过程----------------
exec GetUserAccountRe1 ‘7‘,null
结果：@userID为COOUT（*）即 =1，Retun Value=1。
6.同时返回参数和记录集的存储过程
-------------创建名为GetUserAccount的存储过程----------------
create Procedure GetUserAccountRe2
@UserName nchar(20),
@UserID int output
as
if(@UserName>5)
select @UserID=COUNT(*) from UserAccount where UserID>25
else
set @UserID=1000
select * from UserAccount
return @@rowcount
go
-------------执行上面的存储过程----------------
exec GetUserAccountRe2 ‘7‘,null
结果：返回执行 select * from UserAccount 这句代码的结果集，同时@userID为COOUT（*）即 =1，Retun Value=9。
7.返回多个记录集的存储过程
-------------创建名为GetUserAccount的存储过程----------------
create Procedure GetUserAccountRe3
as
select * from UserAccount
select * from UserAccount where UserID>5
go
-------------执行上面的存储过程----------------
exec GetUserAccountRe3
结果：返回两个结果集，一个为 select * from UserAccount，另一个为 select * from UserAccount where UserID>5 。
三. 游标
什么是游标
结果集，结果集就是select查询之后返回的所有行数据的集合。
游标则是处理结果集的一种机制吧，它可以定位到结果集中的某一行，多数据进行读写，也可以移动游标定位到你所需要的行中进行操作数据。
一般复杂的存储过程，都会有游标的出现，他的用处主要有：
游标的分类
根据游标检测结果集变化的能力和消耗资源的情况不同，SQL Server支持的API服务器游标分为一下4种：
静态游标在滚动时检测不到表数据变化，但消耗的资源相对很少。动态游标在滚动时能检测到所有表数据变化，但消耗的资源却较多。键集驱动游标则处于他们中间，所以根据需求建立适合自己的游标，避免资源浪费。。
游标的生命周期
游标的生命周期包含有五个阶段：声明游标、打开游标、读取游标数据、关闭游标、释放游标。
1.声明游标，语法
DECLARE cursor_name CURSOR [ LOCAL | GLOBAL ]
[ FORWARD_ONLY | SCROLL ]
[ STATIC | KEYSET | DYNAMIC | FAST_FORWARD ]
[ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ]
[ TYPE_WARNING ]
FOR select_statement
[ FOR UPDATE [ OF column_name [ ,...n ] ] ]
参数说明：
2.声明一个动态游标
declare orderNum_02_cursor cursor scroll
for select OrderId from bigorder where orderNum=‘ZEORD003402‘
3.打开游标
--打开游标语法
open [ Global ] cursor_name | cursor_variable_name
cursor_name:游标名，cursor_variable_name：游标变量名称，该变量引用了一个游标。
--打开游标
open orderNum_02_cursor
4.提取数据
--提取游标语法
Fetch
[ [Next|prior|Frist|Last|Absoute n|Relative n ]
from ]
[Global] cursor_name
[into @variable_name[,....]]
参数说明：
例子：
--提取数据
fetch first from orderNum_02_cursor
fetch relative 3 from orderNum_02_cursor
fetch next from orderNum_02_cursor
fetch absolute 4 from orderNum_02_cursor
fetch next from orderNum_02_cursor
fetch last from orderNum_02_cursor
fetch prior from orderNum_02_cursor
select * from bigorder where orderNum=‘ZEORD003402‘
结果（对比一下，就明白啦）：
例子：
--提取数据赋值给变量
declare @OrderId int
fetch absolute 3 from orderNum_02_cursor into @OrderId
select @OrderId as id
select * from bigorder where orderNum=‘ZEORD003402‘
结果：
通过检测全局变量@@Fetch_Status的值，获得提取状态信息，该状态用于判断Fetch语句返回数据的有效性。当执行一条Fetch语句之后，@@Fetch_Status可能出现3种值：0，Fetch语句成功。-1：Fetch语句失败或行不在结果集中。-2：提取的行不存在。
这个状态值可以帮你判断提取数据的成功与否。
declare @OrderId int
fetch absolute 3 from orderNum_02_cursor into @OrderId
while @@fetch_status=0 --提取成功，进行下一条数据的提取操作
begin
select @OrderId as id
fetch next from orderNum_02_cursor into @OrderId --移动游标
end
5.利用游标更新删除数据
--游标修改当前数据语法
Update 基表名 Set 列名=值[,...] Where Current of 游标名
--游标删除当前数据语法
Delete 基表名 Where Current of 游标名
---游标更新删除当前数据
---1.声明游标
declare orderNum_03_cursor cursor scroll
for select OrderId ,userId from bigorder where orderNum=‘ZEORD003402‘
--2.打开游标
open orderNum_03_cursor
--3.声明游标提取数据所要存放的变量
declare @OrderId int ,@userId varchar(15)
--4.定位游标到哪一行
fetch First from orderNum_03_cursor into @OrderId,@userId --into的变量数量必须与游标查询结果集的列数相同
while @@fetch_status=0 --提取成功，进行下一条数据的提取操作
begin
if @OrderId=122182
begin
Update bigorder Set UserId=‘123‘ Where Current of orderNum_03_cursor --修改当前行
end
if @OrderId=154074
begin
Delete bigorder Where Current of orderNum_03_cursor --删除当前行
end
fetch next from orderNum_03_cursor into @OrderId ,@userId --移动游标
end
6.关闭游标
游标打开后，服务器会专门为游标分配一定的内存空间存放游标操作的数据结果集，同时使用游标也会对某些数据进行封锁。所以游标一旦用过，应及时关闭，避免服务器资源浪费。
--关闭游标语法
close [ Global ] cursor_name | cursor_variable_name
--关闭游标
close orderNum_03_cursor
7.删除游标
删除游标，释放资源
--释放游标语法
deallocate [ Global ] cursor_name | cursor_variable_name
--释放游标
deallocate orderNum_03_cursor
四.触发器
概念：
??触发器（trigger）是SQL server 提供给程序员和数据分析员来保证数据完整性的一种方法，它是与表事件相关的特殊的存储过程，它的执行不是由程序调用，也不是手工启动，而是由事件来触发，当对一个表进行操作（ insert，delete， update）时就会激活它执行。触发器经常用于加强数据的完整性约束和业务规则等。 触发器可以从 DBA_TRIGGERS ，USER_TRIGGERS 数据字典中查到。
触发器和存储过程的区别:
??触发器与存储过程的区别是运行方式的不同，触发器不能执行EXECUTE语句调用，而是在用户执行Transact-SQL语句时自动触发执行而存储过程需要用户，应用程序或者触发器来显示地调用并执行。
一:触发器的优点
?1.触发器是自动的。当对表中的数据做了任何修改之后立即被激活。
?2.触发器可以通过数据库中的相关表进行层叠修改。
?3.触发器可以强制限制。这些限制比用CHECK约束所定义的更复杂。与CHECK约束不同的是，触发器可以引用其他表中的列。
二:触发器的作用
?触发器的主要作用就是其能够实现由主键和外键所不能保证的复杂参照完整性和数据的一致性，它能够对数据库中的相关表进行级联修改，提高比CHECK约束更复杂的的数据完整性，并自定义错误消息。触发器的主要作用主要有以下接个方面：
三:触发器的分类
?SqlServer包括三种常规类型的触发器：DML触发器、DDL触发器和登录触发器。
1.DML(数据操作语言,Data Manipulation Language)触发器
?DML触发器是一些附加在特定表或视图上的操作代码，当数据库服务器中发生数据操作语言事件时执行这些操作。SqlServer中的DML触发器有三种：
当遇到下列情形时，应考虑使用DML触发器：
2.DDL(数据定义语言,Data Definition Language)触发器
?DDL触发器是当服务器或者数据库中发生数据定义语言(主要是以create,drop,alter开头的语句)事件时被激活使用，使用DDL触发器可以防止对数据架构进行的某些更改或记录数据中的更改或事件操作。
3.登录触发器
????登录触发器将为响应 LOGIN 事件而激发存储过程。与 SQL Server 实例建立用户会话时将引发此事件。登录触发器将在登录的身份验证阶段完成之后且用户会话实际建立之前激发。因此，来自触发器内部且通常将到达用户的所有消息（例如错误消息和来自 PRINT 语句的消息）会传送到 SQL Server 错误日志。如果身份验证失败，将不激发登录触发器。
四：触发器的工作原理
触发器触发时：
inserted表：
deleted表：
inserted表和deleted表对照：
|
修改操作记录 |
inserted表 |
deleted表 |
|
增加(insert)记录 |
存放新增的记录 |
............ |
|
删除(deleted)记录 |
.............. |
存放被删除的记录 |
|
修改(update)记录 |
存放更新后的记录 |
存放更新前的记录 |
五:创建触发器
创建触发器的语法：
CREATE TRIGGER trigger_name
ON table_name
[WITH ENCRYPTION]
FOR | AFTER | INSTEAD OF [DELETE, INSERT, UPDATE]
AS
T-SQL语句
GO
--with encryption 表示加密触发器定义的sql文本
--delete,insert,update指定触发器的类型
准备测试数据:
--创建学生表
create table student(
stu_id int identity(1,1) primary key,
stu_name varchar(10),
stu_gender char(2),
stu_age int
)
1.创建insert触发器
--创建insert触发器
create trigger trig_insert
on student
after insert
as
begin
if object_id(N‘student_sum‘,N‘U‘) is null--判断student_sum表是否存在
create table student_sum(stuCount int default(0));--创建存储学生人数的student_sum表
declare @stuNumber int;
select @stuNumber = count(*)from student;
if not exists (select * from student_sum)--判断表中是否有记录
insert into student_sum values(0);
update student_sum set stuCount =@stuNumber; --把更新后总的学生数插入到student_sum表中
end
--测试触发器trig_insert-->功能是向student插入数据的同时级联插入到student_sum表中，更新stuCount
--因为是后触发器，所以先插入数据后，才触发触发器trig_insert;
insert into student(stu_name,stu_gender,stu_age)values(‘吕布‘,‘男‘,30);
select stuCount 学生总人数 from student_sum;
insert into student(stu_name,stu_gender,stu_age)values(‘貂蝉‘,‘女‘,30);
select stuCount 学生总人数 from student_sum;
insert into student(stu_name,stu_gender,stu_age)values(‘曹阿瞒‘,‘男‘,40);
select stuCount 学生总人数 from student_sum;
执行上面的语句后，结果如下图所示：
既然定义了学生总数表student_sum表是向student表中插入数据后才计算学生总数的，所以学生总数表应该禁止用户向其中插入数据
--创建insert_forbidden,禁止用户向student_sum表中插入数据
create trigger insert_forbidden
on student_sum
after insert
as
begin
RAISERROR(‘禁止直接向该表中插入记录，操作被禁止‘,1,1)--raiserror 是用于抛出一个错误
rollback transaction
end
--触发触发器insert_forbidden
insert student_sum (stuCount) values(5);
结果如下：
2.创建delete触发器
用户执行delete操作，就会激活delete触发器，从而控制用户能够从数据库中删除数据记录，触发delete触发器后，用户删除的记录会被添加到deleted表中，原来表的相应记录被删除，所以在deleted表中查看删除的记录。
--创建delete触发器
create trigger trig_delete
on student
after delete
as
begin
select stu_id as 已删除的学生编号,stu_name stu_gender,stu_age
from deleted
end;
--执行一一条delete语句触发trig_delete触发器
delete from student where stu_id=1;
结果如下：
3.创建UPDATE触发器
update触发器是当用户在指定表上执行update语句时被调用被调用，这种类型的触发器用来约束用户对数据的修改。update触发器可以执行两种操作：更新前的记录存储在deleted表中，更新后的记录存储在inserted表中。
--创建update触发器
create trigger trig_update
on student
after update
as
begin
declare @stuCount int;
select @stuCount=count(*) from student;
update student_sum set stuCount =@stuCount;
select stu_id as 更新前学生编号,stu_name as 更新前学生姓名 from deleted
select stu_id as 更新后学生编号,stu_name as 更新后学生姓名 from inserted
end
--创建完成，执行一条update语句触发trig_update触发器
update student set stu_name=‘张飞‘ where stu_id=2;
4.创建替代触发器
与前面介绍的三种after触发器不同，SqlServer服务器在执行after触发器的sql代码后，先建立临时的inserted表和deleted表，然后执行代码中对数据库操作，最后才激活触发器中的代码。而对于替代(instead of)触发器,SqlServer服务器在执行触发instead of 触发器的代码时，先建立临时的inserted表和deleted表，然后直接触发instead of触发器，而拒绝执行用户输入的DML操作语句。
--创建instead of 触发器
create trigger trig_insteadOf
on student
instead of insert
as
begin
declare @stuAge int;
select @stuAge=(select stu_age from inserted)
if(@stuAge >120)
select ‘插入年龄错误‘ as ‘失败原因‘
end
创建完成，执行一条insert语句触发触发器trig_insteadOf
5.嵌套触发器介绍
如果一个触发器在执行操作时调用了另外一个触发器，而这个触发器又接着调用了下一个触发器，那么就形成了嵌套触发器。嵌套触发器在安装时就被启用，但是可以使用系统存储过程sp_configure禁用和重新启用嵌套触发器。
嵌套触发器不一定要形成一个环，它可以 T1->T2->T3...这样一直触发下去，最多允许嵌套 32 层。如果嵌套的次数超过限制，那么该触发器将被终止，并回滚整个事务，使用嵌套触发器需要注意以下几点：
嵌套是用来保持整个数据库的完整性的重要功能，但有时可能需要禁用嵌套，如果禁用了嵌套，那么修改一个触发器的实现不会再触发该表上的任何触发器。在下述情况下，需要禁用嵌套触发器：
使用下列语句禁用嵌套和再次启用嵌套：
--禁用嵌套
exce sp_configure ‘nested triggers‘,0;
--启用嵌套
exce sp_configure ‘nested triggers‘,1;
6.递归触发器
触发器的递归是指一个触发器从其内部再一次激活该触发器，例如update操作激活的触发器内部还有一条数据表的更新语句，那么这个更新语句就有可能激活这个触发器本身，当然，这种递归的触发器内部还会有判断语句，只有一定情况下才会执行那个T_SQL语句，否则就成为无线调用的死循环了。
SqlServer中的递归触发器包括两种：直接递归和间接递归。
默认情况下，递归触发器选项是禁用的。递归触发器最多只能递归16层，如果递归中的第16个触发器激活了第17个触发器，则结果与发布的rollback命令一样，所有数据都将回滚。
我们举例解释如下，假如有表1、表2名称分别为 T1、T2，在 T1、T2 上分别有触发器 G1、G2。
设置直接递归：
默认情况下是禁止直接递归的，要设置为允许有两种方法：
六:管理触发器
1.查看触发器
(1).查看数据库中所有的触发器
--查看数据库中所有的触发器
use 数据库名
go
select * from sysobjects where xtype=‘TR‘
sysobjects 保存着数据库的对象，其中 xtype 为 TR 的记录即为触发器对象。在 name 一列，我们可以看到触发器名称。
(2).sp_helptext 查看触发器内容
use 数据库名
go
exec sp_helptext ‘触发器名称‘
将会以表的样式显示触发器内容。
除了触发器外，sp_helptext 还可以显示 规则、默认值、未加密的存储过程、用户定义函数、视图的文本。
(3).sp_helptrigger 用于查看触发器的属性
sp_helptrigger 有两个参数：第一个参数为表名；第二个为触发器类型，为 char(6) 类型，可以是 INSERT、UPDATE、DELETE，如果省略则显示指定表中所有类型触发器的属性。
use 数据库名
go
exec sp_helptrigger tableName
2.禁用启用触发器
禁用:alter table 表名 disable trigger 触发器名称
启用:alter table 表名 enable trigger 触发器名称
如果有多个触发器，则各个触发器名称之间用英文逗号隔开。
如果把“触发器名称”换成“ALL”，则表示禁用或启用该表的全部触发器。
3修改触发器
--修改触发器语法
ALTER TRIGGER trigger_name
ON table_name
[ WITH ENCRYPTION ]
FOR {[DELETE][,][INSERT][,][UPDATE]}
AS
sql_statement;
4.删除触发器
--语法格式:
DROP TRIGGER { trigger } [ ,...n ]
参数:
trigger: 要删除的触发器名称
n:表示可以删除多个触发器的占位符
标签：没有 数据 nsa 快照 溢出 禁用 static val ber
原文地址：https://www.cnblogs.com/linjierd/p/10101093.html
