标准答案：
在最新的SQL2005中的存储过程（Procere）类似于java语言中的方法，它是SQL语句和控制流语句的预编译集合。存储过程在数据库内，可由应用程序通过一个调用执行，而且允许用户声明变量，逻辑控制语句以及其他强大的编程功能。
存储过程可包含逻辑控制语句和数据操作语句，它可以接收参数，输出参数，返回单个或多个结果集以及返回值。
给你一个例子：
create proc proc_takeMoney
@cardID1 varchar(20), --汇款账号
@pwd int , --汇款密码
@takeMoney money, --汇款金额
@cardID2 varchar(20) --存款账号
as
set nocount on
declare @err int
set @err = 0
if exists(select 1 from cardInfo where cardID = @cardID1 and pass = @pwd)
begin
begin tran --事物开始
update cardInfo set balance = balance + @takeMoney where cardID = @cardID2 --接受款帐户加上@takeMoney
set @err = @err + @@error
update cardInfo set balance = balance - @takeMoney where cardID = @cardID1 --汇款帐户减去@takeMoney
set @err = @err + @@error
/*--交易信息表插入交易信息--*/
insert into transInfo(transDate,cardId,transType,transMoney) values(default,@cardID1,'支取',@takeMoney)
set @err = @err + @@error
insert into transInfo(transDate,cardId,transType,transMoney) values(default,@cardID2,'存入',@takeMoney)
set @err = @err + @@error
/*--交易信息--*/
select top 2 * from transInfo order by transDate desc
if(@err<>0)
begin
rollback tran --错误回滚事物
end
else
begin
commit tran --无错误提交事物
end
end --if结束
else
begin
print '密码错误'
end
/*--调用存储过程--*/
declare @cardID1 varchar(20),@cardID2 varchar(20),@pwd int ,@takeMoney money
set @cardID1 ='1010 3576 1234 5678' --张三卡号
set @pwd = 888888 --张三密码
set @cardID2 ='1010 3576 1212 1134' --李四卡号
set @takeMoney =20 --汇款金额
exec proc_takeMoney @cardID1 ,@pwd,@takeMoney,@cardID2
⑵ SQL语句执行过程详解
SQL语句执行过程详解
一条sql，plsql的执行到底是怎样执行的呢？
一、SQL语句执行原理：
第一步:客户端把语句发给服务器端执行当我们在客户端执行 select 语句时,客户端会把这条 SQL 语句发送给服务器端,让服务器端的
进程来处理这语句。也就是说,Oracle 客户端是不会做任何的操作,他的主要任务就是把客户端产生
的一些 SQL 语句发送给服务器端。虽然在客户端也有一个数据库进程,但是,这个进程的作用跟服务器
上的进程作用事不相同的。服务器上的数据库进程才会对SQL 语句进行相关的处理。不过,有个问题需
要说明,就是客户端的进程跟服务器的进程是一一对应的。也就是说,在客户端连接上服务器后,在客户
端与服务器端都会形成一个进程,客户端上的我们叫做客户端进程;而服务器上的我们叫做服务器进程。
第二步:语句解析
当客户端把 SQL 语句传送到服务器后,服务器进程会对该语句进行解析。同理,这个解析的工作,
也是在服务器端所进行的。虽然这只是一个解析的动作,但是,其会做很多“小动作”。
1. 查询高速缓存(library cache)。服务器进程在接到客户端传送过来的 SQL 语句时,不
会直接去数据库查询。而是会先在数据库的高速缓存中去查找,是否存在相同语句的执行计划。如果在
数据高速缓存中,则服务器进程就会直接执行这个 SQL 语句,省去后续的工作。所以,采用高速数据缓
存的话,可以提高 SQL 语句的查询效率。一方面是从内存中读取数据要比从硬盘中的数据文件中读取
数据效率要高,另一方面,也是因为这个语句解析的原因。
不过这里要注意一点,这个数据缓存跟有些客户端软件的数据缓存是两码事。有些客户端软件为了
提高查询效率,会在应用软件的客户端设置数据缓存。由于这些数据缓存的存在,可以提高客户端应用软
件的查询效率。但是,若其他人在服务器进行了相关的修改,由于应用软件数据缓存的存在,导致修改的
数据不能及时反映到客户端上。从这也可以看出,应用软件的数据缓存跟数据库服务器的高速数据缓存
不是一码事。
2. 语句合法性检查(data dict cache)。当在高速缓存中找不到对应的 SQL 语句时,则服
务器进程就会开始检查这条语句的合法性。这里主要是对 SQL 语句的语法进行检查,看看其是否合乎
语法规则。如果服务器进程认为这条 SQL 语句不符合语法规则的时候,就会把这个错误信息,反馈给客
户端。在这个语法检查的过程中,不会对 SQL 语句中所包含的表名、列名等等进行 SQL 他只是语法
上的检查。
3. 语言含义检查(data dict cache)。若 SQL 语句符合语法上的定义的话,则服务器进程
接下去会对语句中的字段、表等内容进行检查。看看这些字段、表是否在数据库中。如果表名与列名不
准确的话,则数据库会就会反馈错误信息给客户端。所以,有时候我们写 select 语句的时候,若语法
与表名或者列名同时写错的话,则系统是先提示说语法错误,等到语法完全正确后,再提示说列名或表名
错误。
4. 获得对象解析锁(control structer)。当语法、语义都正确后,系统就会对我们需要查询
的对象加锁。这主要是为了保障数据的一致性,防止我们在查询的过程中,其他用户对这个对象的结构发
生改变。
5. 数据访问权限的核对(data dict cache)。当语法、语义通过检查之后,客户端还不一定
能够取得数据。服务器进程还会检查,你所连接的用户是否有这个数据访问的权限。若你连接上服务器
的用户不具有数据访问权限的话,则客户端就不能够取得这些数据。有时候我们查询数据的时候,辛辛苦
苦地把 SQL 语句写好、编译通过,但是,最后系统返回个 “没有权限访问数据”的错误信息,让我们气
半死。这在前端应用软件开发调试的过程中,可能会碰到。所以,要注意这个问题,数据库服务器进程先
检查语法与语义,然后才会检查访问权限。
6. 确定最佳执行计划 ?。当语句与语法都没有问题,权限也匹配的话,服务器进程还是不会直接对
数据库文件进行查询。服务器进程会根据一定的规则,对这条语句进行优化。不过要注意,这个优化是有
限的。一般在应用软件开发的过程中,需要对数据库的 sql 语言进行优化,这个优化的作用要大大地大
于服务器进程的自我优化。所以,一般在应用软件开发的时候,数据库的优化是少不了的。当服务器进程
的优化器确定这条查询语句的最佳执行计划后,就会将这条 SQL 语句与执行计划保存到数据高速缓存
(library cache)。如此的话,等以后还有这个查询时,就会省略以上的语法、语义与权限检查的步骤,
而直接执行 SQL 语句,提高 SQL 语句处理效率。
第三步:语句执行
语句解析只是对 SQL 语句的语法进行解析,以确保服务器能够知道这条语句到底表达的是什么意
思。等到语句解析完成之后,数据库服务器进程才会真正的执行这条 SQL 语句。这个语句执行也分两
种情况。
一是若被选择行所在的数据块已经被读取到数据缓冲区的话,则服务器进程会直接把这个数据传递
给客户端,而不是从数据库文件中去查询数据。
若数据不在缓冲区中,则服务器进程将从数据库文件中查询相关数据,并把这些数据放入到数据缓冲
区中(buffer cache)。
第四步:提取数据
当语句执行完成之后,查询到的数据还是在服务器进程中,还没有被传送到客户端的用户进程。所以,
在服务器端的进程中,有一个专门负责数据提取的一段代码。他的作用就是把查询到的数据结果返回给
用户端进程,从而完成整个查询动作。从这整个查询处理过程中,我们在数据库开发或者应用软件开发过
程中,需要注意以下几点:
一是要了解数据库缓存跟应用软件缓存是两码事情。数据库缓存只有在数据库服务器端才存在,在
客户端是不存在的。只有如此,才能够保证数据库缓存中的内容跟数据库文件的内容一致。才能够根据
相关的规则,防止数据脏读、错读的发生。而应用软件所涉及的数据缓存,由于跟数据库缓存不是一码事
情,所以,应用软件的数据缓存虽然可以提高数据的查询效率,但是,却打破了数据一致性的要求,有时候
会发生脏读、错读等情况的发生。所以,有时候,在应用软件上有专门一个功能,用来在必要的时候清除
数据缓存。不过,这个数据缓存的清除,也只是清除本机上的数据缓存,或者说,只是清除这个应用程序
的数据缓存,而不会清除数据库的数据缓存。
二是绝大部分 SQL 语句都是按照这个处理过程处理的。我们 DBA 或者基于 Oracle 数据库的
开发人员了解这些语句的处理过程,对于我们进行涉及到 SQL 语句的开发与调试,是非常有帮助的。有
时候,掌握这些处理原则,可以减少我们排错的时间。特别要注意,数据库是把数据查询权限的审查放在
语法语义的后面进行检查的。所以,有时会若光用数据库的权限控制原则,可能还不能满足应用软件权限
控制的需要。此时,就需要应用软件的前台设置,实现权限管理的要求。而且,有时应用数据库的权限管
理,也有点显得繁琐,会增加服务器处理的工作量。因此,对于记录、字段等的查询权限控制,大部分程
序涉及人员喜欢在应用程序中实现,而不是在数据库上实现。
DBCC DROPCLEANBUFFERS
从缓冲池中删除所有清除缓冲区。
DBCC FREEPROCCACHE
从过程缓存中删除所有元素。
DBCC FREESYSTEMCACHE
从所有缓存中释放所有未使用的缓存条目
SQL语句中的函数、关键字、排序等执行顺序:
1. FROM 子句返回初始结果集。
2. WHERE 子句排除不满足搜索条件的行。
3. GROUP BY 子句将选定的行收集到 GROUP BY 子句中各个唯一值的组中。
4. 选择列表中指定的聚合函数可以计算各组的汇总值。
5. 此外,HAVING 子句排除不满足搜索条件的行。
6. 计算所有的表达式;
7. 使用 order by 对结果集进行排序。
8. 查找你要搜索的字段。
二、SQL语句执行完整过程：
1.用户进程提交一个 sql 语句:
update temp set a=a*2，给服务器进程。
2.服务器进程从用户进程把信息接收到后,在 PGA 中就要此进程分配所需内存,存储相关的信息,如在会
话内存存储相关的登录信息等。
3.服务器进程把这个 sql 语句的字符转化为 ASCII 等效数字码,接着这个 ASCII 码被传递给一个
HASH 函数,并返回一个 hash 值,然后服务器进程将到shared pool 中的 library cache 中去查找是否存在相
同的 hash 值,如果存在,服务器进程将使用这条语句已高速缓存在 SHARED POOL 的library cache 中的已
分析过的版本来执行。
4.如果不存在,服务器进程将在 CGA 中,配合 UGA 内容对 sql,进行语法分析,首先检查语法的正确性,接
着对语句中涉及的表,索引,视图等对象进行解析,并对照数据字典检查这些对象的名称以及相关结构，并根据
ORACLE 选用的优化模式以及数据字典中是否存在相应对象的统计数据和是否使用了存储大纲来生成一个
执行计划或从存储大纲中选用一个执行计划,然后再用数据字典核对此用户对相应对象的执行权限,最后生成
一个编译代码。
5.ORACLE 将这条 sql 语句的本身实际文本、HASH 值、编译代码、与此语名相关联的任何统计数据
和该语句的执行计划缓存在 SHARED POOL 的 library cache中。服务器进程通过 SHARED POOL 锁存
器(shared pool latch)来申请可以向哪些共享 PL/SQL 区中缓存这此内容,也就是说被SHARED POOL 锁存
器锁定的 PL/SQL 区中的块不可被覆盖,因为这些块可能被其它进程所使用。
6.在 SQL 分析阶段将用到 LIBRARY
CACHE,从数据字典中核对表、视图等结构的时候,需要将数据
字典从磁盘读入 LIBRARY
CACHE,因此,在读入之前也要使用LIBRARY
CACHE 锁存器(library cache
pin,library cache lock)来申请用于缓存数据字典。 到现在为止,这个 sql 语句已经被编译成可执行的代码了,
但还不知道要操作哪些数据,所以服务器进程还要为这个 sql 准备预处理数据。
7.首先服务器进程要判断所需数据是否在 db buffer 存在,如果存在且可用,则直接获取该数据,同时根据
LRU 算法增加其访问计数;如果 buffer 不存在所需数据,则要从数据文件上读取首先服务器进程将在表头部
请求 TM 锁(保证此事务执行过程其他用户不能修改表的结构),如果成功加 TM 锁,再请求一些行级锁(TX
锁),如果 TM、TX 锁都成功加锁,那么才开始从数据文件读数据,在读数据之前,要先为读取的文件准备好
buffer 空间。服务器进程需要扫面 LRU list 寻找 free db buffer,扫描的过程中,服务器进程会把发现的所有
已经被修改过的 db buffer 注册到 dirty list 中, 这些 dirty buffer 会通过 dbwr 的触发条件,随后会被写出到
数据文件,找到了足够的空闲 buffer,就可以把请求的数据行所在的数据块放入到 db buffer 的空闲区域或者
覆盖已经被挤出 LRU list 的非脏数据块缓冲区,并排列在 LRU list 的头部,也就是在数据块放入 DB
BUFFER 之前也是要先申请 db buffer 中的锁存器,成功加锁后,才能读数据到 db buffer。
8.记日志 现在数据已经被读入到 db buffer 了,现在服务器进程将该语句所影响的并被读
入 db buffer 中的这些行数据的 rowid 及要更新的原值和新值及 scn 等信息从 PGA 逐条的写入 redo log
buffer 中。在写入 redo log buffer 之前也要事先请求 redo log buffer 的锁存器,成功加锁后才开始写入,当
写入达到 redo log buffer 大小的三分之一或写入量达到 1M 或超过三秒后或发生检查点时或者 dbwr 之前
发生,都会触发 lgwr 进程把 redo log buffer 的数据写入磁盘上的 redo file 文件中(这个时候会产生log file
sync 等待事件)
已经被写入 redofile 的 redo log buffer 所持有的锁存器会被释放,并可被后来的写入信息覆盖,
redo log buffer是循环使用的。Redo file 也是循环使用的,当一个 redo file 写满后,lgwr 进程会自动切换到
下一 redo file(这个时候可能出现 log fileswitch(checkpoint complete)等待事件)。如果是归档模式,归档进
程还要将前一个写满的 redo file 文件的内容写到归档日志文件中(这个时候可能出现 log file
switch(archiving needed)。
9.为事务建立回滚段 在完成本事务所有相关的 redo log buffer 之后,服务器进程开始改写这个 db buffer
的块头部事务列表并写入 scn,然后 包含这个块的头部事务列表及 scn 信息的数据副本放入回滚段中,将
这时回滚段中的信息称为数据块的“前映像“,这个”前映像“用于以后的回滚、恢复和一致性读。(回滚段可以
存储在专门的回滚表空间中,这个表空间由一个或多个物理文件组成,并专用于回滚表空间,回滚段也可在其它
表空间中的数据文件中开辟。
10.本事务修改数据块 准备工作都已经做好了,现在可以改写 db buffer 块的数据内容了,并在块的头部写
入回滚段的地址。
11.放入 dirty list 如果一个行数据多次 update 而未 commit,则在回滚段中将会有多个“前映像“,除了第
一个”前映像“含有 scn 信息外,其他每个“前映像“的头部都有 scn 信息和“前前映像”回滚段地址。一个
update 只对应一个 scn,然后服务器进程将在 dirty list 中建立一
条指向此 db buffer 块的指针(方便 dbwr 进程可以找到 dirty list 的 db buffer 数据块并写入数据文件中)。
接着服务器进程会从数据文件中继续读入第二个数据块,重复前一数据块的动作,数据块的读入、记日志、建
立回滚段、修改数据块、放入 dirty list。当 dirty queue 的长度达到阀值(一般是 25%),服务器进程将通知
dbwr 把脏数据写出,就是释放 db buffer 上的锁存器,腾出更多的 free db buffer。前面一直都是在说明
oracle 一次读一个数据块,其实 oracle 可以一次读入多个数据块(db_file_multiblock_read_count 来设置一
次读入块的个数)
说明:
在预处理的数据已经缓存在 db buffer 或刚刚被从数据文件读入到 db buffer 中,就要根据 sql 语句
的类型来决定接下来如何操作。
1>如果是 select 语句,则要查看 db buffer 块的头部是否有事务,如果有事务,则从回滚段中读取数据;如
果没有事务,则比较 select 的 scn 和 db buffer 块头部的 scn,如果前者小于后者,仍然要从回滚段中读取数据;
如果前者大于后者,说明这是一非脏缓存,可以直接读取这个 db buffer 块的中内容。
2>如果是 DML 操作,则即使在 db buffer 中找到一个没有事务,而且 SCN 比自己小的非脏
缓存数据块,服务器进程仍然要到表的头部对这条记录申请加锁,加锁成功才能进行后续动作,如果不成功,则要
等待前面的进程解锁后才能进行动作(这个时候阻塞是 tx 锁阻塞)。
用户 commit 或 rollback 到现在为止,数据已经在 db buffer 或数据文件中修改完
成,但是否要永久写到数文件中,要由用户来决定 commit(保存更改到数据文件) rollback 撤销数据的更改)。
1.用户执行 commit 命令
只有当 sql 语句所影响的所有行所在的最后一个块被读入 db buffer 并且重做信息被写入 redo log
buffer(仅指日志缓冲区,而不包括日志文件)之后,用户才可以发去 commit 命令,commit 触发 lgwr 进程,但不
强制立即 dbwr来释放所有相应 db buffer 块的锁(也就是no-force-at-commit,即提交不强制写),也就是说有
可能虽然已经 commit 了,但在随后的一段时间内 dbwr 还在写这条 sql 语句所涉及的数据块。表头部的行锁
并不在 commit 之后立即释放,而是要等 dbwr 进程完成之后才释放,这就可能会出现一个用户请求另一用户
已经 commit 的资源不成功的现象。
A .从 Commit 和 dbwr 进程结束之间的时间很短,如果恰巧在 commit 之后,dbwr 未结束之前断电,因为
commit 之后的数据已经属于数据文件的内容,但这部分文件没有完全写入到数据文件中。所以需要前滚。由
于 commit 已经触发 lgwr,这些所有未来得及写入数据文件的更改会在实例重启后,由 smon 进程根据重做日
志文件来前滚,完成之前 commit 未完成的工作(即把更改写入数据文件)。
B.如果未 commit 就断电了,因为数据已经在 db buffer 更改了,没有 commit,说明这部分数据不属于数
据文件,由于 dbwr 之前触发 lgwr 也就是只要数据更改,(肯定要先有 log) 所有 DBWR,在数据文件上的修改
都会被先一步记入重做日志文件,实例重启后,SMON 进程再根据重做日志文件来回滚。
其实 smon 的前滚回滚是根据检查点来完成的,当一个全部检查点发生的时候,首先让 LGWR 进程将
redo log buffer 中的所有缓冲(包含未提交的重做信息)写入重做日志文件,然后让 dbwr 进程将 db buffer 已
提交的缓冲写入数据文件(不强制写未提交的)。然后更新控制文件和数据文件头部的 SCN,表明当前数据库
是一致的,在相邻的两个检查点之间有很多事务,有提交和未提交的。
像前面的前滚回滚比较完整的说法是如下的说明:
A.发生检查点之前断电,并且当时有一个未提交的改变正在进行,实例重启之后,SMON 进程将从上一个
检查点开始核对这个检查点之后记录在重做日志文件中已提交的和未提交改变,因为
dbwr 之前会触发 lgwr,所以 dbwr 对数据文件的修改一定会被先记录在重做日志文件中。因此,断电前被
DBWN 写进数据文件的改变将通过重做日志文件中的记录进行还原,叫做回滚,
B. 如果断电时有一个已提交,但 dbwr 动作还没有完全完成的改变存在,因为已经提交,提交会触发 lgwr
进程,所以不管 dbwr 动作是否已完成,该语句将要影响的行及其产生的结果一定已经记录在重做日志文件中
了,则实例重启后,SMON 进程根据重做日志文件进行前滚.
实例失败后用于恢复的时间由两个检查点之间的间隔大小来决定,可以通个四个参数设置检查点执行的频
率:
Log_checkpoint_interval:
决定两个检查点之间写入重做日志文件的系统物理块(redo blocks)
的大小,默认值是 0,无限制。
log_checkpoint_timeout:
两 个 检 查 点 之 间 的 时 间 长 度（秒）默 认 值 1800s。
fast_start_io_target:
决定了用于恢复时需要处理的块的多少,默认值是 0,无限制。
fast_start_mttr_target:
直接决定了用于恢复的时间的长短,默认值是 0,无限制(SMON 进程执行的前滚
和回滚与用户的回滚是不同的,SMON 是根据重做日志文件进行前滚或回滚,而用户的回滚一定是根据回滚段
的内容进行回滚的。
在这里要说一下回滚段存储的数据,假如是 delete 操作,则回滚段将会记录整个行的数据,假如是 update,
则回滚段只记录被修改了的字段的变化前的数据(前映像),也就是没有被修改的字段是不会被记录的,假如是
insert,则回滚段只记录插入记录的 rowid。 这样假如事务提交,那回滚段中简单标记该事务已经提交;假如是
回退,则如果操作是 delete,回退的时候把回滚段中数据重新写回数据块,操作如果是 update,则把变化前数据
修改回去,操作如果是 insert,则根据记录的 rowid 把该记录删除。
2.如果用户 rollback。
则服务器进程会根据数据文件块和 DB BUFFER 中块的头部的事务列表和 SCN 以及回滚段地址找到
回滚段中相应的修改前的副本,并且用这些原值来还原当前数据文件中已修改但未提交的改变。如果有多个
“前映像”,服务器进程会在一个“前映像”的头部找到“前前映像”的回滚段地址,一直找到同一事务下的最早的
一个“前映像”为止。一旦发出了 COMMIT,用户就不能rollback,这使得 COMMIT 后 DBWR 进程还没有
全部完成的后续动作得到了保障。到现在为例一个事务已经结束了。
说明:
TM 锁:
符合 lock 机制的,用于保护对象的定义不被修改。 TX 锁:
这个锁代表一个事务,是行
级锁,用数据块头、数据记录头的一些字段表示,也是符合 lock 机制,有 resource structure、lock
structure、enqueue 算法。
⑶ sql存储过程是什么
所有设计优良的 Microsoft® SQL Server™ 2000 应用程序都应当使用存储过程。不论是否将应用程序的业务逻辑写入存储过程都应如此。甚至连没有业务逻辑组件的标准 Transact-SQL 语句，在用参数打包成存储过程后也能获得性能收益。编译进存储过程的 Transact-SQL 语句在执行时可省去大量的处理。
存储过程的另一个优点是客户端执行请求使用网络的效率比将等效的 Transact-SQL 语句发送到服务器高。例如，假设应用程序需要将一个大的二进制值插入 image 数据列。为使用 INSERT 语句发送数据，该应用程序必须将该二进制值转换为字符串（其大小翻倍），然后发送到服务器。服务器再将该值转换回二进制格式以存储在 image 列中。
相反，应用程序可以创建下列格式的存储过程：
CREATE PROCEDURE P(@p1 image) AS INSERT T VALUES (@p1)
当客户端应用程序请求执行过程 P 时，image 参数值将一直以二进制格式发送到服务器，从而节省处理时间并减少网络流量。
如果 SQL Server 存储过程中包含业务服务逻辑，因为业务服务逻辑将处理移动到数据，而不是将数据移动到处理，因而存储过程能提供更大的性能收益。
存储过程的优点
(1)存储过程的能力大大增强了SQL语言的功能和灵活性。存储过程可以用流控制语句编写，有很强的灵活性，可以完成复杂的判断和较复杂的 运算。
(2) 可保证数据的安全性和完整性。
● 通过存储过程可以使没有权限的用户在控制之下间接地存取数据库，从而保证数据的安全。
● 通过存储过程可以使相关的动作在一起发生，从而可以维护数据库的完整性。
(3) 再运行存储过程前，数据库已对其进行了语法和句法分析，并给出了优化执行方案。这种已经编译好的过程可极大地改善SQL语句的性能。 由于执行SQL语句的大部分工作已经完成，所以存储过程能以极快的速度执行。
(4)可以降低网络的通信量。
(5) 使体现企业规则的运算程序放入数据库服务器中，以便：
● 集中控制。
● 当企业规则发生变化时在服务器中改变存储过程即可，无须修改任何应用程序。企业规则的特点是要经常变化，如果把体现企业规则的运算程序放入应用程序中，则当企业规则发生变化时，就需要修改应用程序工作量非常之大（修改、发行和安装应用程序）。如果把体现企业规则的 运算放入存储过程中，则当企业规则发生变化时，只要修改存储过程就可以了，应用程序无须任何变化。
1.使用企业管理器创建用户存储过程
操作步骤如下：
（1）启动SQL Server企业管理器。
（2）在“控制台根目录”窗口，展开“SQL Server组”，首先，选择“数据库”，然后，选择“存储过程”，单击鼠标右键，打开快捷菜单。
（3）在打开快捷菜单中，选择“新建存储过程”菜单命令，进入“存储过程属性”窗口。
（4）在“存储过程属性”窗口，在文本框中输入存储过程代码，单击“确定”，结束存储过程的创建。
2.使用T-SQL语句创建用户存储过程
SQL命令格式：
CREATE PROC [ EDURE ] <Procere_name> [ ; Number ]
[ { @parameter Data_type }
[ VARYING ] [ = Default ] [ OUTPUT ]] [ ,...n ]
[ WITH{ RECOMPILE | ENCRYPTION | RECOMPILE , ENCRYPTION }]
[ FOR REPLICATION ]
AS sql_statements
功能：创建一个用户存储过程，并保存在数据库中。
⑷ 什么是SQL的存储过程
sql存储过程说简单点就是一个在t-sql下用户可以自行定义的函数，
但是与一般的函数也有不同的地方，比如它的返回值只能return(int类型)，如果你要输出什么信息的话只能用output.这也是存储过程的一个特色吧，设定的参数可以有输出。讲起来有点抽象，给你个例子看看吧！
首先创建一个存储过程
create
procere
cunchuguocheng
@a
int,
@b
int,
@c
int
output
as
begin
select
@c
=
@a+@b
return(0)
end
然后调用这个存储过程
declare
@value
int,
--返回值
@c
int
--结果值
exec
@value
=
cunchuguocheng
2,2,@c
output
select
@value
as
返回值
select
@c
as
结果值
程序写的很简单，你运行一下我想你就会对存储过程有所了解了。
⑸ 一条sql语句的执行过程
需要建立一张表来记录
explain plan SET statement_id='name' FOR (这里是你要调试的语句 )
SELECT
A.OPERATION,
OPTIONS,
OBJECT_NAME,
OBJECT_TYPE,
ID,
PARENT_ID
FROM
PLAN_TABLE A
WHERE
STATEMENT_ID='name'
ORDER BY
Id;
ID 'name'是一个标识，你可以自己取，字段有很多个，以下是各个字段的解释（可能格式不对，你可以复制后看）：
字段名 字段类型 含义
STATEMENT_ID VARCHAR2(30) explain PLAN 语句中所指定的最优STATEMENT_ID 参数值, 如果在EXPLAN PLAN语句中没有使用SET STATEMENT_ID，那么此值会被设为NULL。
REMARKS VARCHAR2(80) 与被解释规划的各步骤相关联的注释最长可达80 字节
OPERATION VARCHAR2(30) 各步骤所执行内部操作的名称在某条语句所产生的第一行中该列的可能取值如下DELETE STATEMENT INSERT STATEMENT SELECT STATEMENT UPDATE STATEMENT
OPTIONS VARCHAR2(30) 对OPERATION 列中所描述操作的变种
OBJECT_NODE VARCHAR2(128) 用于访问对象的数据库链接database link 的名称对于使用并行执行的本地查询该列能够描述操作中输出的次序
OBJECT_OWNER VARCHAR2(30) 对于包含有表或索引的架构schema 给出其所有者的名称
OBJECT_NAME VARCHAR2(30) 表或索引的名称
OBJECT_INSTANCE INTEGER 根据对象出现在原始original 语句中的次序所给出的相应次序编号就原始的语句文本而论其处理顺序为自左至右自外向内景象扩张view
OBJECT_TYPE VARCHAR2(30) 用于提供对象描述性信息的修饰符例如索引的NON-UNIQUE
OPTIMIZER VARCHAR2(255) 当前优化程序的模式
ID INTEGER 分配给执行规划各步骤的编号
PARENT_ID INTEGER 对ID 步骤的输出进行操作的下一个执行步骤的ID
POSITION INTEGER 对于具有相同PARENT_ID 的步骤其相应的处理次序
COST INTEGER 根据优化程序的基于开销的方法所估计出的操作开销值对于使用基于规则方法的语句该列为空该列值没有特定的测量单位它只是一个用于比较执行规划开销大小的权重值
CARDINALITY INTEGER 根据基于开销的方法对操作所访问行数的估计值
BYTES INTEGER 根据基于开销的方法对操作所访问字节的估计
=============================================
你按照我说的做，后面用
SELECT
*
FROM
PLAN_TABLE A
WHERE
STATEMENT_ID='name'
结果已经很清楚了，全部满足你的要求。
各列的具体含义上面已经给出。
⑹ 一条sql的整个过程是怎样的
SQL语句执行过程详解
一、SQL语句执行原理：
第一步:客户端把语句发给服务器端执行
当我们在客户端执行 select 语句时,客户端会把这条 SQL 语句发送给服务器端,让服务器端的
进程来处理这语句。也就是说,Oracle 客户端是不会做任何的操作,他的主要任务就是把客户端产生
的一些 SQL 语句发送给服务器端。虽然在客户端也有一个数据库进程,但是,这个进程的作用跟服务器
上的进程作用事不相同的。服务器上的数据库进程才会对SQL 语句进行相关的处理。不过,有个问题需
要说明,就是客户端的进程跟服务器的进程是一一对应的。也就是说,在客户端连接上服务器后,在客户
端与服务器端都会形成一个进程,客户端上的我们叫做客户端进程;而服务器上的我们叫做服务器进程。
第二步:语句解析
当客户端把 SQL 语句传送到服务器后,服务器进程会对该语句进行解析。同理,这个解析的工作,
也是在服务器端所进行的。虽然这只是一个解析的动作,但是,其会做很多“小动作”。
1. 查询高速缓存(library cache)。服务器进程在接到客户端传送过来的 SQL 语句时,不
会直接去数据库查询。而是会先在数据库的高速缓存中去查找,是否存在相同语句的执行计划。如果在
数据高速缓存中,则服务器进程就会直接执行这个 SQL 语句,省去后续的工作。所以,采用高速数据缓
存的话,可以提高 SQL 语句的查询效率。一方面是从内存中读取数据要比从硬盘中的数据文件中读取
数据效率要高,另一方面,也是因为这个语句解析的原因。
不过这里要注意一点,这个数据缓存跟有些客户端软件的数据缓存是两码事。有些客户端软件为了
提高查询效率,会在应用软件的客户端设置数据缓存。由于这些数据缓存的存在,可以提高客户端应用软
件的查询效率。但是,若其他人在服务器进行了相关的修改,由于应用软件数据缓存的存在,导致修改的
数据不能及时反映到客户端上。从这也可以看出,应用软件的数据缓存跟数据库服务器的高速数据缓存
不是一码事。
2. 语句合法性检查(data dict cache)。当在高速缓存中找不到对应的 SQL 语句时,则服
务器进程就会开始检查这条语句的合法性。这里主要是对 SQL 语句的语法进行检查,看看其是否合乎
语法规则。如果服务器进程认为这条 SQL 语句不符合语法规则的时候,就会把这个错误信息,反馈给客
户端。在这个语法检查的过程中,不会对 SQL 语句中所包含的表名、列名等等进行 SQL 他只是语法
上的检查。
3. 语言含义检查(data dict cache)。若 SQL 语句符合语法上的定义的话,则服务器进程
接下去会对语句中的字段、表等内容进行检查。看看这些字段、表是否在数据库中。如果表名与列名不
准确的话,则数据库会就会反馈错误信息给客户端。所以,有时候我们写 select 语句的时候,若语法
与表名或者列名同时写错的话,则系统是先提示说语法错误,等到语法完全正确后,再提示说列名或表名
错误。
4. 获得对象解析锁(control structer)。当语法、语义都正确后,系统就会对我们需要查询
的对象加锁。这主要是为了保障数据的一致性,防止我们在查询的过程中,其他用户对这个对象的结构发
生改变。
5. 数据访问权限的核对(data dict cache)。当语法、语义通过检查之后,客户端还不一定
能够取得数据。服务器进程还会检查,你所连接的用户是否有这个数据访问的权限。若你连接上服务器
的用户不具有数据访问权限的话,则客户端就不能够取得这些数据。有时候我们查询数据的时候,辛辛苦
苦地把 SQL 语句写好、编译通过,但是,最后系统返回个 “没有权限访问数据”的错误信息,让我们气
半死。这在前端应用软件开发调试的过程中,可能会碰到。所以,要注意这个问题,数据库服务器进程先
检查语法与语义,然后才会检查访问权限。
6. 确定最佳执行计划 。当语句与语法都没有问题,权限也匹配的话,服务器进程还是不会直接对
数据库文件进行查询。服务器进程会根据一定的规则,对这条语句进行优化。不过要注意,这个优化是有
限的。一般在应用软件开发的过程中,需要对数据库的 sql 语言进行优化,这个优化的作用要大大地大
于服务器进程的自我优化。所以,一般在应用软件开发的时候,数据库的优化是少不了的。当服务器进程
的优化器确定这条查询语句的最佳执行计划后,就会将这条 SQL 语句与执行计划保存到数据高速缓存
(library cache)。如此的话,等以后还有这个查询时,就会省略以上的语法、语义与权限检查的步骤,
而直接执行 SQL 语句,提高 SQL 语句处理效率。
第三步:语句执行
语句解析只是对 SQL 语句的语法进行解析,以确保服务器能够知道这条语句到底表达的是什么意
思。等到语句解析完成之后,数据库服务器进程才会真正的执行这条 SQL 语句。这个语句执行也分两
种情况。
一是若被选择行所在的数据块已经被读取到数据缓冲区的话,则服务器进程会直接把这个数据传递
给客户端,而不是从数据库文件中去查询数据。
若数据不在缓冲区中,则服务器进程将从数据库文件中查询相关数据,并把这些数据放入到数据缓冲
区中(buffer cache)。
第四步:提取数据
当语句执行完成之后,查询到的数据还是在服务器进程中,还没有被传送到客户端的用户进程。所以,
在服务器端的进程中,有一个专门负责数据提取的一段代码。他的作用就是把查询到的数据结果返回给
用户端进程,从而完成整个查询动作。从这整个查询处理过程中,我们在数据库开发或者应用软件开发过
程中,需要注意以下几点:
一是要了解数据库缓存跟应用软件缓存是两码事情。数据库缓存只有在数据库服务器端才存在,在
客户端是不存在的。只有如此,才能够保证数据库缓存中的内容跟数据库文件的内容一致。才能够根据
相关的规则,防止数据脏读、错读的发生。而应用软件所涉及的数据缓存,由于跟数据库缓存不是一码事
情,所以,应用软件的数据缓存虽然可以提高数据的查询效率,但是,却打破了数据一致性的要求,有时候
会发生脏读、错读等情况的发生。所以,有时候,在应用软件上有专门一个功能,用来在必要的时候清除
数据缓存。不过,这个数据缓存的清除,也只是清除本机上的数据缓存,或者说,只是清除这个应用程序
的数据缓存,而不会清除数据库的数据缓存。
二是绝大部分 SQL 语句都是按照这个处理过程处理的。我们 DBA 或者基于 Oracle 数据库的
开发人员了解这些语句的处理过程,对于我们进行涉及到 SQL 语句的开发与调试,是非常有帮助的。有
时候,掌握这些处理原则,可以减少我们排错的时间。特别要注意,数据库是把数据查询权限的审查放在
语法语义的后面进行检查的。所以,有时会若光用数据库的权限控制原则,可能还不能满足应用软件权限
控制的需要。此时,就需要应用软件的前台设置,实现权限管理的要求。而且,有时应用数据库的权限管
理,也有点显得繁琐,会增加服务器处理的工作量。因此,对于记录、字段等的查询权限控制,大部分程
序涉及人员喜欢在应用程序中实现,而不是在数据库上实现。
DBCC DROPCLEANBUFFERS
从缓冲池中删除所有清除缓冲区。
DBCC FREEPROCCACHE
从过程缓存中删除所有元素。
DBCC FREESYSTEMCACHE
从所有缓存中释放所有未使用的缓存条目
SQL语句中的函数、关键字、排序等执行顺序:
1. FROM 子句返回初始结果集。
2. WHERE 子句排除不满足搜索条件的行。
3. GROUP BY 子句将选定的行收集到 GROUP BY 子句中各个唯一值的组中。
4. 选择列表中指定的聚合函数可以计算各组的汇总值。
5. 此外,HAVING 子句排除不满足搜索条件的行。
6. 计算所有的表达式;
7. 使用 order by 对结果集进行排序。
8. 查找你要搜索的字段。
⑺ 描述数据库创建到SQL Server中的过程
从物理结构上讲，每个数据库都包含有数据文件和日志文件。开始使用数据库前，必须先创建数据库，以便生成这些文件。在SQL Server 2005中创建数据库的方法很多，其中最主要的方法是：
l 直观地利用SQL Server Management Studio创建数据库。
l 通过Transact-SQL代码创建数据库。
注意
新建的数据库实际上是根据Model数据库中保存的数据库模板创建的，也就是说它是Model数据库的一个副本。
下面将分别介绍这两种创建数据库的方法。
6.3.1 利用SQL Server Management Studio创建数据库
在SQL Server Management Studio中，用户可以非常方便地利用图形化的方法创建数据库。接下来，我们将利用这种方法创建一个示例数据库——Customers数据库。
(1) 选择【开始】|【程序】| Microsoft SQL Server 2005 | SQL Server Management Studio命令，打开SQL Server Management Studio。
(2) 使用【Windows身份验证】连接到SQL Server 2005数据库实例。
(3) 展开SQL Server实例，右击【数据库】，然后从弹出的快捷菜单中选择【新建数据库】命令，打开【新建数据库】对话框，如图6.2所示。
(4) 在【新建数据库】对话框中，输入数据库名称Customers。
图6.2 新建数据库
提示
数据库的名称必须遵循SQL Server 2005命名规则。名字的长度在1～128个字符之间；名称的第一个字符必须是字母或者“_”、“@”和“#”中的任意字符；名称中不能包含空格和SQL Server 2005的保留字(如master)。
(5) 如果接受所有默认值，可以单击【确定】按钮结束创建工作；由于本示例中的Customers数据库没有用默认值，因此还需要继续下面的可选步骤。
(6) 在【所有者】下拉列表框中可以选择数据库的所有者。数据库的所有者是对数据库有完全操作权限的用户。默认值表示当前登录Windows系统的是管理员账户。Customers数据库需要更改所有者名称，因此单击“...”按钮，打开【选择数据库所有者】对话框，如图6.3所示。在这个对话框中单击【浏览】按钮，打开【查找对象】对话框，如图6.4所示，在对话框中选择登录对象sa作为数据库的所 有者。
图6.3 选择数据库所有者
图6.4 选择对象
(7) 选中【使用全文索引】复选框，启用数据库的全文搜索。这样数据库中的变长复杂数据类型列也可以建立索引。
(8) 在Customer上添加新文件组。选中【文件组】页，单击【添加】按钮，接着输入文件组的名称“DefaultGroup”，并选中这个文件组的【默认值】选项，如图6.5所示。
图6.5 添加文件组
(9) 如果要更改主数据文件和事务日志文件的默认值，可以在【数据库文件】列表框中单击相应的单元并输入新值。对于Customers数据库，需要在主数据文件的【初始大小】栏中输入新的初始大小值10MB；接着单击【自动增长】栏中的“...”按钮，打开更改自动增长设置对话框(如图6.6所示)，选中【按MB】单选按钮，将值更改为2MB，并选中【不限制文件增长】单选按钮；最后在日志文件的【路径】栏中输入新的日志文件路径“D:\DataBaseLog”。
图6.6 更改主数据文件的自动增长设置
(10) 在Customers数据库中添加新的数据文件Customers_1：在【常规】页中单击【添加】按钮，在【数据库文件】列表框中会添加一个新行，在【逻辑名称】栏中输入文件的名称“Customers1”，在【文件类型】栏中选择【数据】类型。在【文件组】中选择DefaultGroup文件组，其他接受默认值，如图6.7所示。
图6.7 添加数据文件和日志文件
(11) 在Customers数据库中添加新的日志文件Customers_Log1。在【常规】页中单击【添加】按钮，在【数据库文件】列表框中会添加一个新行，在【逻辑名称】栏中输入文件的名称“Customers_log1”，在【文件类型】栏中选择【日志】类型，在【路径】栏中输入新的路径“D:\DataBaseLog”，其他接受默认值。
(12) 如果要更改数据库的排序规则，可以选择【选项】页(如图6.8所示)，然后在【排序规则】下拉列表框中选择一个排序规则。Customers数据库使用默认的排序规则。
图6.8 选择数据库的排序规则
提示
排序规则指定了SQL字符存储和比较所使用的规则，以及字符保存的结构。详细的排序规则定义可以参考SQL Server 2005的联机文档。
(13) 如果要更改恢复模式，可以在【选项】页的【恢复模式】下拉列表框中选择一个恢复模式，如图6.9所示。Customers数据库使用【完整】模式。
图6.9 选择恢复模式
提示
恢复模式的具体定义，可以参考后面章节的相关内容。
(14) 如果要更改数据库选项，可以选择【选项】页，然后修改数据库的选项。Customers数据库不需要更改这些选项。
(15) 单击【确定】按钮完成数据库的创建。
(16) 在执行完以上步骤后，SQL Server数据库引擎就会在数据库实例中创建一个新的数据库Customers，如图6.10所示。
图6.10 创建了一个新的数据库Customers
6.3.2 通过Transact-SQL代码创建数据库
除了可以通过SQL Server Management Studio的图形化界面创建数据库外，还可以使用Transact-SQL语言提供的CREATE DATABASE语句来创建数据库。对于具有丰富的编程经验的用户，后一种方法更加简单有效。下面首先介绍CREATE DATABASE语句的语法，接着描述了使用CREATE DATABASE语句创建上一节中的Customers示例数据库的方法。
1. CREATE DATABASE语句的语法和参数
CREATE DATABASE语句的语法约定如下所示。
CREATE DATABASE database_name
[ ON
[ PRIMARY ] [ <filespec> [ ,...n ]
[ , <filegroup> [ ,...n ] ]
]
[
[ LOG ON { <filespec> [ ,...n ] } ] ]
[ COLLATE collation_name ]
[ FOR { ATTACH [ WITH <service_broker_option> ]
| ATTACH_REBUILD_LOG }]
[ WITH <external_access_option> ]
]
[;]
<filespec> ::=
{
( NAME = logical_file_name ,
FILENAME = 'os_file_name'
[ , SIZE = size [ KB | MB | GB | TB ] ]
[ , MAXSIZE = { max_size [ KB | MB | GB | TB ] | UNLIMITED } ]
[ , FILEGROWTH = growth_increment [ KB | MB | GB | TB | % ] ]
) [ ,...n ]
}
<filegroup> ::=
{ FILEGROUP filegroup_name [ DEFAULT ]
<filespec> [ ,...n ] }
<external_access_option> ::=
{ DB_CHAINING { ON | OFF }
| TRUSTWORTHY { ON | OFF }
}
<service_broker_option> ::=
{ ENABLE_BROKER
| NEW_BROKER
| ERROR_BROKER_CONVERSATIONS
}
CREATE DATABASE语句中的参数说明如下。
l database_name：新数据库的名称。数据库名称在 SQL Server 的实例中必须唯一，并且必须符合标识符规则。如果未指定数据文件的名称，则 SQL Server 使用database_name作为logical_file_name和os_file_name。
l ON：指定显式定义用来存储数据库数据部分的磁盘文件(数据文件)。当后面是以逗号分隔的、用以定义主文件组的数据文件的<filespec>项列表时，需要使用ON。主文件组的文件列表可后跟以逗号分隔的、用以定义用户文件组及其文件的<filegroup>项列表(可选)。
l PRIMARY：指定关联的<filespec>列表定义主文件。在主文件组的<filespec>项中指定的第一个文件将成为主文件。一个数据库只能有一个主文件。如果没有指定 PRIMARY，那么 CREATE DATABASE 语句中列出的第一个文件将成为主文件。
l LOG ON：指定显式定义用来存储数据库日志的磁盘文件(日志文件)。LOG ON后跟以逗号分隔的用以定义日志文件的<filespec> 项列表。如果没有指定 LOG ON，将自动创建一个日志文件，其大小为该数据库的所有数据文件大小总和的 25%，取两者之中的较大者。
l COLLATE collation_name：指定数据库的默认排序规则。排序规则名称既可以是 Windows 排序规则名称，也可以是 SQL 排序规则名称。如果没有指定排序规则，则将 SQL Server 实例的默认排序规则分配为数据库的排序规则。不能使用 FOR ATTACH 或 FOR ATTACH_REBUILD_LOG 子句指定排序规则名称。
l FOR ATTACH：指定通过附加一组现有的操作系统文件来创建数据库。必须有一个指定主文件的 <filespec> 项。至于其他 <filespec> 项，只需要指定与第一次创建数据库或上一次附加数据库时路径不同的文件的那些项即可。必须有一个<filespec>项指定这些文件。FOR ATTACH 具有以下要求：所有数据文件(MDF 和 NDF)都必须可用；如果存在多个日志文件，这些文件都必须可用；如果一个可读/写数据库具有一个当前不可用的日志文件，并且进行附加操作前在没有被使用或打开情况下关闭了该数据库，那么FOR ATTACH会自动重新生成日志文件并更新主文件。相比之下，对于只读数据库，由于主文件不能更新，将不能重新生成日志。因此，如果附加一个日志不可用的只读数据库，必须在 FOR ATTACH 子句中提供日志文件或文件。
l FOR ATTACH_REBUILD_LOG：指定通过附加一组现有的操作系统文件来创建数据库。该选项只限于读/写数据库。如果缺少一个或多个事务日志文件，将重新生成日志文件。必须有一个指定主文件的 <filespec> 项。 使用FOR ATTACH_REBUILD_LOG参数必须确保完全关闭数据库并且所有数据文件都 可用。
l <filespec>：控制文件属性。
l NAME logical_file_name：指定文件的逻辑名称。在Creat Name中命名用了下面介绍指定FILENAME参数时，就需要设置NAME参数，除非指定FOR ATTACH子句之一。
l logical_file_name：引用文件时，SQL Server 中使用的逻辑名称。logical_file_name 必须在数据库中唯一，必须符合标识符规则。名称可以是字符或 Unicode 常量，也可以是常规标识符或分隔标识符。
l FILENAME ' os_file_name '：指定操作系统(物理)文件名称。os_file_name是创建文件时由操作系统使用的路径和文件名。文件必须驻留在下列设备中：安装 SQL Server 的本地服务器、存储局域网络(Storage Area Network，简称SAN)或基于 iSCSI 的网络。执行 CREATE DATABASE 语句前，指定路径必须存在。日志文件一定不要放在压缩文件系统中。
l SIZE size：指定文件的大小。size是文件的初始大小。如果没有为主文件提供初始大小，则数据库引擎将使用model数据库中的主文件的大小。如果指定了辅助数据文件或日志文件，但未指定该文件的初始大小，则数据库引擎将以 1 MB 作为该文件的大小。此外，为数据库主文件指定的大小至少应与model数据库的主文件大小相同。可以使用千字节(KB)、兆字节(MB)、千兆字节(GB)或兆兆字节(TB)单位，默认值为 MB。这个值必须为整数，对于大于 2 147 483 647 的值，使用更大的单位。
l MAXSIZE max_size：指定文件可增大到的最大大小。max_size 表示最大的文件大小。可以使用KB、MB、GB和TB单位，默认值为MB。如果不指定文件的最大尺寸，则文件将增长到磁盘被充满为止。这个值必须为整数，对于大于 2 147 483 647 的值，使用更大的单位。
l UNLIMITED：指定文件将增长到整个磁盘。在 SQL Server 2005 中，规定日志文件可增长的最大大小为 2TB，而数据文件的最大大小为 16TB。
l FILEGROWTH growth_increment：指定文件的自动增量。文件的 FILEGROWTH 设置不能超过 MAXSIZE 设置。growth_increment表示每次需要新空间时为文件添加的空间量。值为 0 时表明自动增长被设置为关闭，不允许增加空间。如果未指定 FILEGROWTH，则数据文件的默认值为1MB，日志文件的默认增长比例为10%，并且最小值为64KB。
l <filegroup>：控制文件组属性。
l FILEGROUP filegroup_name：文件组的逻辑名称。filegroup_name必须在数据库中唯一，不能是系统提供的名称 PRIMARY 和 PRIMARY_LOG。名称可以是字符或Unicode常量，也可以是常规标识符或分隔标识符。名称必须符合标识符规则。
l DEFAULT：指定命名文件组为数据库中的默认文件组。
l <external_access_option>：控制外部与数据库之间的双向访问。
l DB_CHAINING { ON | OFF }：当指定为 ON 时，可以连接跨数据库服务器的链接源或目标。当为 OFF 时，数据库不能参与跨数据库所有权的链接。默认值 为OFF。
l TRUSTWORTHY { ON | OFF }：当指定为ON时，使用模拟上下文的数据库模块(例如，视图、用户定义函数或存储过程)可以访问数据库以外的资源。当为OFF时，模拟上下文中的数据库模块不能访问数据库以外的资源。默认值为OFF。
l <service_broker_option>：控制数据库上的Service Broker选项。
l ENABLE_BROKER：对指定的数据库启用 Service Broker服务。
l NEW_BROKER：在sys.databases 和还原数据库中创建一个新的 service_ broker_guid 值。
l ERROR_BROKER_CONVERSATIONS：结束所有会话，并产生一个错误信息指出数据库已附加或还原。
2. 使用CREATE DATABASE语句创建Customers数据库
使用一条 CREATE DATABASE 语句就可以创建数据库以及存储该数据库的文件。SQL Server通过使用以下步骤实现CREATE DATABASE语句： 首先，SQL Server 2005 数据库引擎使用model数据库的副本初始化该数据库及其元数据；接着，为数据库分配 Service Broker GUID；最后，使用空页填充数据库的剩余部分(包含记录数据库中空间使用情况的内部数据页除外)。在一个 SQL Server 的实例中最多可以指定32 767个数据库。
下面使用CREATE DATABASE语句重新创建上一节中创建的Customers示例数据库。具体步骤如下。
(1) 打开SQL Server Management Studio，并用【Windows身份验证】登录。
(2) 选中数据库实例，右击，从弹出的快捷菜单中选择【新建查询选项】命令，打开查询编辑窗口。
(3) 在查询编辑窗口中输入如下的Transact-SQL语句：
CREATE DATABASE Customers
ON PRIMARY
(
NAME = Customers,
FILENAME = 'C:\Program Files\Microsoft SQL Server\ MSSQL.1\MSSQL\DATA\ Customers.mdf',
SIZE = 10,
MAXSIZE = UNLIMITED,
FILEGROWTH = 2
),
FILEGROUP DefaultGroup
(
NAME = Customers_1,
FILENAME = 'C:\Program Files\Microsoft SQL Server\ MSSQL.1\ MSSQL\DATA\ Customers_1.ndf',
SIZE = 3MB,
MAXSIZE = UNLIMITED,
FILEGROWTH = 1MB
)
LOG ON
(
NAME = Customers_log,
FILENAME = 'D:\DataBaseLog \Customers_log.ldf',
SIZE = 1MB,
MAXSIZE = UNLIMITED,
FILEGROWTH = 10%
),
(
NAME = Customers_log1,
FILENAME = 'D:\DataBaseLog\Customers_log1.ldf',
SIZE =3MB,
MAXSIZE = UNLIMITED,
FILEGROWTH = 10%
)
(4) 单击工具栏上的【执行】按钮执行上面输入的SQL语句。
(5) 在查询执行后，查询结果窗口中会返回查询执行的结果。如果查询执行没有错误，在对象资源管理窗口中展开数据库实例下的【数据库】项，可以看到新建的Customers数据库，如图6.11所示。
注意
在重新创建Customers数据库前，必须首先删除上一节中建立的Customers数据库。
提示
在创建数据库时，请根据数据库中预期的最大数据量，创建尽可能大的数据文件。另外，创建、修改或删除用户数据库后，应备份 master 数据库。
图6.11 使用CREATE DATABASE语句创建Customers数据库
要缩小某个分区的容量大小，该分区内必须存在未被使用的磁盘空间；要增大某个分区的容量大小，必须存在紧邻该分区的自由空间。
⑻ 请帮忙详细解释一下SQL的存储过程：（请逐行解释，谢谢）
有重复的，只介绍部分有用并且关键的。由于你的代码是部分的，所以只能大概的给你解释，让你知道每一步基本上的作用，不能详细的解释哪个变量是干什么的，那需要看到整个程序后才可以的。希望你能理解。有问题可以再直接向我提问。祝你好运、。
USE [XYS]---确定数据库名
GO
/****** Object: StoredProcere [dbo].[usp_kpi_rfid_report2] Script Date: 03/22/2011 14:11:12 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [dbo].[usp_kpi_rfid_report2] --存储结构作用的表名
@factory varchar(10),----定义变量
@ship_date_from varchar(10),
@ship_date_to varchar(10),
@work_date varchar(10),
@fz_major varchar(3),
@zj_major varchar(3),
@component varchar(3),
@component2 varchar(3),
@WC varchar(1),
@PX varchar(1),
@PO varchar(20)
AS
/*
exec usp_kpi_rfid_report2 ---将读取到的数据重新命名
@factory='', --工厂
@ship_date_from = '', --船期开始
@ship_date_to = '', --船期结束
@work_date= '22-03-2011', --生产日期
@fz_major = '001', --发毛工序
@zj_major = '003', --配扎工序
@component = '001', --全件部件
@component2 = '996', --后整部件
@WC = '1', --查询未完成，=1可以查询已完成
@PX = '0', --=0按PO排序，=1按交货期排序
@po='hb0084'
*/
declare @work_date_from datetime, --创建触发器
@work_date_to datetime,定义变量
@date datetime,
@px_txt varchar(20),
@px_sql varchar(1000)
---查询数据，按照上面的变量查询
使用触发器判断数据是否改变如果改变就进行相用的处理。
if len(@ship_date_from) = 0 or @ship_date_from = '-1' or @ship_date_from is null
select @ship_date_from = '', @work_date_from = nullelse
select @work_date_from = convert(datetime, @ship_date_from, 105)
if len(@ship_date_to) = 0 or @ship_date_to = '-1' or @ship_date_to is null
select @ship_date_to = '', @work_date_to = null
else
select @work_date_to = convert(datetime, @ship_date_to, 105)
if len(@work_date) = 0 or @work_date = '-1' or @work_date is null
select @work_date = '', @date = null
else
select @date = convert(datetime, @work_date, 105)
if @px='0'
select @px_txt='sp_ord_no'
else
select @px_txt='po_startdate'