第四章 PL/SQL的控制结构

最新推荐文章于 2021-10-26 16:29:27 发布

iteye_2060

最新推荐文章于 2021-10-26 16:29:27 发布

阅读量88

点赞数

<div id="chapter">第四章 PL/SQL的控制结构</div>

一、PL/SQL控制结构一览
根据结构定理(structure theorem)，任何计算机程序都可以用下图中的基本控制结构来表示。它们可以任意组合来解决问题。 

<img src="https://p-blog.csdn.net/images/p_blog_csdn_net/rcom10002/244670/o_4-1.gif" alt="">
选择结构是用于测试条件的，根据条件的真假，执行一系列语句。一个条件语句可以是任何能够返回布尔值(TRUE或FALSE)的变量或表达式。循环结构能在条件满足的情况下反复执行。序列结构只是简单的按照顺序执行语句。 
二、条件控制：IF和CASE语句
有时候，我们需要根据具体的条件来采取不同的对策。IF语句就能让我们按条件来执行语句序列。也就是说，语句序列的执行与否取决于某个给定的条件。
有三种IF语句：IF-THEN、IF-THEN-ELSE和IF-THEN-ELSIF。CASE语句是条件判断的精简形式，它能计算条件表达式的值并
在多个对应动作中做出选择。 
1、IF-THEN语句
IF语句最简单的形式就是把一个条件和一个语句序列用关键字THEN和END IF关联起来： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
conditionTHEN
 
sequence_of_statements END
IF
; </td>
</tr></tbody></table>
</blockquote>
只有在条件值为真的时候语句序列才能被执行。如果条件值为假或是空，IF语句就什么都不做。无论哪种情况，控制权最后还是会被传递到下一个语句，如下例： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
sales>QUOTATHEN
 
compute_bonus(empid); UPDATE
payroll SET
pay=pay+bonus WHERE
empno=emp_id; END
IF
; </td>
</tr></tbody></table>
</blockquote>
如果我们把IF语句放到一行，就可以像下面这样编写： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
x>yTHEN
high:=x;END
IF
; </td>
</tr></tbody></table>
</blockquote>
2、IF-THEN-ELSE语句
第二种形式的IF语句使用关键字ELSE添加了一个额外的处理选项，如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
conditionTHEN
 
sequence_of_statements1 ELSE
 
sequence_of_statements2 END
IF
; </td>
</tr></tbody></table>
</blockquote>
当条件为假或空时，ELSE子句中的语句序列就会被执行。下例中，第一个UPDATE语句在条件为真的情况下执行，而第二个UPDATE语句在条件为假或为空的情况下才会被执行： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
trans_type='CR'
THEN
 UPDATE
accounts SET
balance=balance+credit WHERE
... ELSE
 UPDATE
accounts SET
balance=balance-debit WHERE
... END
IF
; </td>
</tr></tbody></table>
</blockquote>
THEN和ELSE子句中也可以包含IF语句。就是说IF语句能够被嵌套使用，如下例所示： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
trans_type='CR'
THEN
 UPDATE
accounts SET
balance=balance+credit WHERE
... ELSE
 IF
new_balance>=minimum_balanceTHEN
 UPDATE
accounts SET
balance=balance-debit WHERE
... ELSE
 RAISE
insufficient_funds; END
IF
; END
IF
; </td>
</tr></tbody></table>
</blockquote>
3、IF-THEN-ELSIF语句
有时我们可能需要从几个选项中选择一个，这时我们就需要使用第三种IF语句，添加一个ELSIF关键字提供额外的条件选项，使用方法如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
condition1THEN
 
sequence_of_statements1 ELSIF
condition2THEN
 
sequence_of_statements2 ELSE
 
sequence_of_statements3 END
IF
; </td>
</tr></tbody></table>
</blockquote>
如果第一个条件为假或空，ELSIF子句就会检测另外一个条件。一个IF语句可以有多个ELSIF子句；最后一个ELSE子句是可选的。条件表达式
从上而下的计算。只要有满足的条件，与它关联的语句就会执行，然后控制权转到下一个语句。如果所有的条件都为假或是空，ELSE部分的语句就会执行。看一
下下面的例子： 
<blockquote>
<table border="0"><tbody><tr>
<td>
BEGIN
 
... IF
sales>50000THEN
 
bonus:=1500; ELSIF
sales>35000THEN
 
bonus:=500; ELSE
 
bonus:=100; END
IF
; INSERT
INTO
payroll VALUES
(emp_id,bonus,...); END
; </td>
</tr></tbody></table>
</blockquote>
如果sales的值大于50000的话，第一个和第二个条件就为真。然而，bonus只会被赋予1500的值，因为第二个条件并没有执行到。当第一个条件为真的话，它关联的语句就会执行，然后控制权转到INSERT语句。 
4、CASE语句
同IF语句一样，CASE语句也是选出一个语句序列来执行。但是，为了选择出合适的语句序列，CASE会使用一个选择器，而不是多个布尔表达式。想要比较IF和CASE语句的话，请看下面对学校成绩的描述信息： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
grade='A'
THEN
 
DBMS_OUTPUT.put_line('Excellent'
); ELSIF
grade='B'
THEN
 
DBMS_OUTPUT.put_line('VeryGood'
); ELSIF
grade='C'
THEN
 
DBMS_OUTPUT.put_line('Good'
); ELSIF
grade='D'
THEN
 
DBMS_OUTPUT.put_line('Fair'
); ELSIF
grade='F'
THEN
 
DBMS_OUTPUT.put_line('Poor'
); ELSE
 
DBMS_OUTPUT.put_line('Nosuchgrade'
); END
IF
; </td>
</tr></tbody></table>
</blockquote>
请注意这五个布尔表达式，在每一个实例中，我们只对同一变量的值进行检测，看它的分数值是否等于"A"、"B"、"C"、"D"、"E"或"F"。下面我们用CASE语句重新编写上面的程序： 
<blockquote>
<table border="0"><tbody><tr>
<td>
CASE
grade WHEN
'A'
THEN
 
DBMS_OUTPUT.put_line('Excellent'
); WHEN
'B'
THEN
 
DBMS_OUTPUT.put_line('VeryGood'
); WHEN
'C'
THEN
 
DBMS_OUTPUT.put_line('Good'
); WHEN
'D'
THEN
 
DBMS_OUTPUT.put_line('Fair'
); WHEN
'F'
THEN
 
DBMS_OUTPUT.put_line('Poor'
); ELSE
 
DBMS_OUTPUT.put_line('Nosuchgrade'
); END
CASE
; </td>
</tr></tbody></table>
</blockquote>
CASE语句的可读性高而且高效，所以，如果可能的话，尽量把IF-THEN-ELEIF都改写成CASE语句。 
CASE语句以关键字CASE开头，然后跟上一个选择器，也就是上例中的变量grade。选择器表达式可能是很复杂的。例如，它有可能是一个函数调
用。但在通常情况下，它只是一个独立的变量。选择器表达式只被计算一次。它的值可以是除BLOB、BFILE、对象类型、PL/SQL记录、索引表、变长
数组或嵌套表之外的任何有效的PL/SQL数据类型。 
选择器后面跟着一个或多个WHEN子句，它们是按顺序检测的。选择器的值决定了哪个子句被执行。如果选择器的值等于WHEN子句的表达式
值，WHEN子句中的语句序列就会被执行。例如在上面例子中，如果grade等于"C"，程序就会输出"Good"。当WHEN子句中的语句序列被执行完
毕，控制权会转到下一个语句，而不会再执行后续的WHEN子句。 
ELSE子句的工作原理与IF中的类似。上例子中，如果grade的值不与任何一个WHEN子句匹配，ELSE部分就会被执行，"No such
grade"就会被输出。ELSE子语是可选的。但是，如果我们省略了ELSE子句，PL/SQL就会为我们添加隐式的ELSE子句： 
<blockquote>
<table border="0"><tbody><tr>
<td>
ELSE
RAISE
CASE_NOT_FOUND; </td>
</tr></tbody></table>
</blockquote>
如果CASE语句选择了隐式的ELSE子句，PL/SQL就会抛出预定义异常CASE_NOT_FOUND。所以，即使我们省略了ELSE子句，ELSE也会有一个默认的动作。 
关键字END CASE是CASE语句结束的标志。这两个关键字必须用空格分开。形式如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>[<<label_name>>] CASE
selector WHEN
expression1THEN
 
sequence_of_statements1; WHEN
expression2THEN
 
sequence_of_statements2; 
... WHEN
expressionnTHEN
 
sequence_of_statementsn; 
[ELSE
sequence_of_statementsN+1;] END
CASE
[label_name]; </td>
</tr></tbody></table>
</blockquote>
同PL/SQL块一样，CASE语句也是可以加标签的。标签是一个未声明的标识符，必须出现在CASE语句的开头，用双尖括号夹起来。标签的名称也可以出现在CASE语句的结尾处，但不是必须的。 
CASE语句中的异常会按正常的方法处理，就是说正常的执行语句停止，控制权转到PL/SQL块或子程序的异常控制部分。 
<ul>
<li>搜寻式CASE语句 </li>
</ul>
PL/SQL还提供下面搜寻形式的CASE语句： 
<blockquote>
<table border="0"><tbody><tr>
<td>[<<label_name>>] CASE
 WHEN
search_condition1THEN
 
sequence_of_statements1; WHEN
search_condition2THEN
 
sequence_of_statements2; 
... WHEN
search_conditionnTHEN
 
sequence_of_statementsn; 
[ELSE
sequence_of_statementsN+1;] END
CASE
[label_name]; </td>
</tr></tbody></table>
</blockquote>
搜寻式CASE语句没有选择器。并且，它的WHEN子句只能包含结果为布尔类型的表达式，产生其它类型结果的表达式是不允许的。示例如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
CASE
 WHEN
grade='A'
THEN
 
DBMS_OUTPUT.put_line('Excellent'
); WHEN
grade='B'
THEN
 
DBMS_OUTPUT.put_line('VeryGood'
); WHEN
grade='C'
THEN
 
DBMS_OUTPUT.put_line('Good'
); WHEN
grade='D'
THEN
 
DBMS_OUTPUT.put_line('Fair'
); WHEN
grade='F'
THEN
 
DBMS_OUTPUT.put_line('Poor'
); ELSE
 
DBMS_OUTPUT.put_line('Nosuchgrade'
); END
CASE
; </td>
</tr></tbody></table>
</blockquote>
搜寻条件是按顺序计算的。每个搜寻条件的布尔值决定了哪个WHEN子句被执行。一旦WHEN子句被执行，控制权就会被交给下一个语句，后续的搜寻条件就不会被考虑。 
如果没有找到搜寻条件为TRUE的子句，ELSE子句就会执行。ELSE虽然是可选的，但是，如果省略了ELSE，PL/SQL就会添加隐式的ELSE子句： 
<blockquote>
<table border="0"><tbody><tr>
<td>
ELSE
RAISE
CASE_NOT_FOUND; </td>
</tr></tbody></table>
</blockquote>
如果执行过程中有异常发生，我们可以在块或子程序的异常控制部分捕获到。 
5、PL/SQL条件控制语句使用准则
我们不应该像下面这样使用笨拙的IF语句： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
new_balance<minimum_balanceTHEN
 
overdrawn:=TRUE
; ELSE
 
overdrawn:=FALSE
; END
IF
; 
... IF
overdrawn=TRUE
THEN
 RAISE
insufficient_funds; END
IF
; </td>
</tr></tbody></table>
</blockquote>
上面的代码忽视了两个地方。首先，布尔表达式的值可以直接赋给布尔变量。所以我们可以把第一个IF语句简化成下面的语句形式： 
<blockquote>
<table border="0"><tbody><tr>
<td>overdrawn:=new_balance<minimum_balance; </td>
</tr></tbody></table>
</blockquote>
第二，布尔变量本身就是TRUE或FALSE。所以，在IF的条件表达式中直接使用变量本身即可： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
overdrawnTHEN
... </td>
</tr></tbody></table>
</blockquote>
尽可能地使用ELSIF子句代替嵌套IF语句。这样我们的代码就更易读易理解。比较下面两个IF语句： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
condition1THEN
 
statement1; ELSE
 IF
condition2THEN
 
statement2; ELSE
 IF
condition3THEN
 
statement3; END
IF
; END
IF
; END
IF
; </td>
<td valign="top">
IF
condition1THEN
 
statement1; ELSIF
condition2THEN
 
statement2; ELSIF
condition3THEN
 
statement3; END
IF
;</td>
</tr></tbody></table>
</blockquote>
这两个语句在逻辑上是等价的，但第一个语句看起来有些混乱，而第二个就较为明显。 
如果把单独一个表达式与多个值进行比较的话，我们可以使用CASE语句来代替多个ELSIF子句。 
三、循环控制：LOOP和EXIT语句
LOOP语句能让我们反复执行一个语句序列。有三种形式的LOOP语句：LOOP，WHILE-LOOP和FOR-LOOP。 
1、LOOP
LOOP语句最简单的形式就是把语句序列放到关键字LOOP和END LOOP之间，语法如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
LOOP
 
sequence_of_statements; END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
在每一个循环中，语句序列都会被顺序执行，然后再返回循环顶部从头执行。如果不想继续执行，可以使用EXIT语句退出循环。我们可以把一个或多个EXIT语句放到循环里，但不能放到循环外面。有两种形式的EXIT语句：EXIT和EXIT-WHEN。 
<ul>
<li>EXIT </li>
</ul>
EXIT语句会强迫循环无条件终止。当遇到EXIT语句时，循环会立即终止，并把控制权交给下面的语句。示例如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
LOOP
 
... IF
credit_rating<3THEN
 
... EXIT
;--exitloopimmediately
 END
IF
; END
LOOP
; --controlresumeshere
</td>
</tr></tbody></table>
</blockquote>
下面再举一个不能在PL/SQL块中使用EXIT语句的例子： 
<blockquote>
<table border="0"><tbody><tr>
<td>
BEGIN
 
... IF
credit_rating<3THEN
 
... EXIT
;--notallowed
 END
IF
; END
; </td>
</tr></tbody></table>
</blockquote>
记住，EXIT语句必须放在循环内。如果想在PL/SQL块正常到达程序结尾之前而终止执行，可以使用RETURN语句。 
<ul>
<li>EXIT-WHEN </li>
</ul>
EXIT-WHEN语句可以根据给定的条件跳出循环。当遇到EXIT语句时，WHEN子句中的表达式值就会被计算。如果条件满足，循环就会被终止，控制权转到循环语句之后的语句。示例如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
LOOP
 FETCH
c1 INTO
... EXIT
WHEN
c1%NOTFOUND;--exitloopifconditionistrue
 
... END
LOOP
; CLOSE
c1; </td>
</tr></tbody></table>
</blockquote>
在条件满足之前，循环是不会结束的。所以，循环里的语句必须要改变循环条件的值。上例中，如果FETCH语句返回了一行值，WNEN子句中的条件就为假；如果不能返回结果，WNEN子句中的条件就为真，循环就会结束，控制权转入CLOSE语句。 
EXIT-WHEN语句可以替代简单的IF语句，例如，比较下面两段代码： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
count>100THEN
 EXIT
; END
IF
; </td>
<td valign="top">
EXIT
WHEN
count>100;</td>
</tr></tbody></table>
</blockquote>
这两个语句在逻辑上是等价的，但EXIT-WHEN语句更容易阅读和理解。 
<ul>
<li>循环标签 </li>
</ul>
跟PL/SQL块一样，循环也是可以添加标签。标签必须出现在LOOP语句的开端，语法如下： 
<blockquote>
<table border="0"><tbody><tr>
<td><<label_name>> LOOP
 
sequence_of_statements END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
而在LOOP语句结束部分出现的标签名称是可选的，语法如下： 
<blockquote>
<table border="0"><tbody><tr>
<td><<my_loop>> LOOP
 
... END
LOOP
my_loop; </td>
</tr></tbody></table>
</blockquote>
在LOOP结束部分使用标签名称能够改善可读性。
无论使用哪种EXIT语句形式，都可以结束一个封闭的LOOP块，而不仅仅局限于当前的LOOP块。只要在我们想结束的封闭LOOP块上添加一个标签，然后像下面这样在EXIT语句中使用这个标签就可以了：
<blockquote>
<table border="0"><tbody><tr>
<td><<outer>> LOOP
 
... LOOP
 
... EXIT
outerWHEN
...--exitbothloops
 END
LOOP
; 
... END
LOOP
outer; </td>
</tr></tbody></table>
</blockquote>
2、WHILE-LOOP
WHILE-LOOP语句用关键字LOOP和END LOOP把语句序列封闭起来并与一个布尔条件表达式相关联： 
<blockquote>
<table border="0"><tbody><tr>
<td>
WHILE
conditionLOOP
 
sequence_of_statements END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
每次循环之前，程序都是计算布尔表达式的值。如果条件为真，语句序列就会被执行，然后重新返回循环顶部计算布尔表达式的值；如果布尔表达式的值为假或空，控制权就会被交给循环之后的语句。下面看一个例子： 
<blockquote>
<table border="0"><tbody><tr>
<td>
WHILE
total<=25000LOOP
 
... SELECT
sal INTO
salary FROM
emp WHERE
x=x;... 
total:=total+salary; END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
循环的次数是与条件相关的，而且在循环结束之前是未知的。由于条件是在循环顶部测试的，所以语句序列有可能一次都没有执行。在上面的例子中，如果total的初始值比25000大，那么条件值就是假，循环就会被跳过。
有些语言有LOOP UNTIL或是REPEAT UNTIL这样的结构，在底部测试条件表达式的值。这样，语句序列就会至少执行一次。PL/SQL没有这样的结构，但我们可以变通地使用下面的方法来实现这样的功能： 
<blockquote>
<table border="0"><tbody><tr>
<td>
LOOP
 
sequence_of_statements EXIT
WHEN
boolean_expression; END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
要保证WHILE循环至少执行一次，在条件表达式中使用初始化过的布尔变量，如下例所示： 
<blockquote>
<table border="0"><tbody><tr>
<td>done:=FALSE
; WHILE
NOT
doneLOOP
 
sequence_of_statements; 
done:=boolean_expression; END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
在循环内的语句必须为布尔变量赋上一个新值。否则循环就会无限地执行下去。如下例的两个LOOP语句在逻辑上是等价的：
<blockquote>
<table border="0"><tbody><tr>
<td>
WHILE
TRUE
LOOP
 
... END
LOOP
; </td>
<td>
LOOP
 
... END
LOOP
;</td>
</tr></tbody></table>
</blockquote>
3、FOR-LOOP
FOR语句会在指定的整数范围内进行循环操作。循环的内容被关键字FOR和LOOP封闭起来。两个"点"(..)作为范围操作符来使用。语法如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
counterIN
[REVERSE
]lower_bound..higher_boundLOOP
 
sequence_of_statements END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
当首次进入FOR循环时，循环的范围就会被确定下来，并且不会重新计算。如下例所示，语句序列会执行三次，每执行一次，循环因子就会增加1。 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
iIN
1..3LOOP
--assignthevalues1,2,3toi
 
sequence_of_statements--executesthreetimes
 END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
下例演示了如果下界值等于上界值，循环中的语句序列只执行一次： 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
iIN
3..3LOOP
--assignthevalues3toi
 
sequence_of_statements--executesonetime
 END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
默认情况下，循环总是从下界到上界。不过也可以使用REVERSE关键字，让循环从上界往下界执行。但是要记住，范围的书写格式仍旧是递增顺序的。 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
iIN
REVERSE
1..3LOOP
--assignthevalues3,2,1toi
 
sequence_of_statements--executesthreetimes
 END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
FOR循环里，循环计数器只能当作常量来引用且不能为它赋值，如下例： 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
ctrIN
1..10LOOP
 IF
NOT
finishedTHEN
 INSERT
INTO
... VALUES
(ctr);--legal
 
factor:=ctr*2;--legal
 ELSE
 
ctr:=10;--notallowed
 END
IF
; END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
<ul>
<li>迭代法 </li>
</ul>
循环范围的边界可以是文字、变量或表达式，但它们都必须是数字。否则PL/SQL会抛出预定义异常VALUE_ERROR。如下例，下界不一定非得是1。但循环计数器只能是每次增加1。 
<blockquote>
<table border="0"><tbody><tr>
<td>jIN
-5..5 
kIN
REVERSE
first..last 
stepIN
0..TRUNC(high/low)*2 </td>
</tr></tbody></table>
</blockquote>
在PL/SQL内部，它会把边界值赋给一个临时的PLS_INTEGER变量，并在需要的时候把值转换成最接近的整数。PLS_INTEGER的范围是-2**31到2**31之间。所以，如果边界值超过这个范围，我们就会得到一个数字溢出错误： 
<blockquote>
<table border="0"><tbody><tr>
<td>
DECLARE
 
hiNUMBER
:=2**32; BEGIN
 FOR
jIN
1..hiLOOP
--causesa鈥檔umericoverflow鈥?error
 
... END
LOOP
; END
; </td>
</tr></tbody></table>
</blockquote>
有些语言提供了STEP子句，它能让我们指定循环增量。PL/SQL没有这样的结构，但我们可以在FOR循环内扩大循环计数器的倍数来实现这样的功能。在下面的例子中，我们今天的日期赋给索引表的第一个、第五个和第十五个元素。 
<blockquote>
<table border="0"><tbody><tr>
<td>
DECLARE
 TYPE
datelistIS
TABLE
OF
DATE
 INDEX
BY
BINARY_INTEGER
; 
datesdatelist; 
kCONSTANT
INTEGER
:=5;--setnewincrement
 BEGIN
 FOR
jIN
1..3LOOP
 
dates(j*k):=SYSDATE
;--multiplyloopcounterbyincrement
 END
LOOP
; 
... END
; </td>
</tr></tbody></table>
</blockquote>
<ul>
<li>动态范围 </li>
</ul>
PL/SQL允许我们在运行时决定循环的范围，如下例所示： 
<blockquote>
<table border="0"><tbody><tr>
<td>
SELECT
COUNT(empno) INTO
emp_count FROM
emp; FOR
iIN
1..emp_countLOOP
 
... END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
emp_count在运行时是未知的；SELECT语句在运行时才返回结果值。 
如果循环范围中的下界值超过上界值会怎样呢？如下例所示，循环内的语句序列就不会被执行，控制权直接交给下一个语句： 
<blockquote>
<table border="0"><tbody><tr>
<td>
--limitbecomes1
 FOR
iIN
2..LIMITLOOP
 
sequence_of_statements--executeszerotimes
 END
LOOP
; --controlpasseshere
</td>
</tr></tbody></table>
</blockquote>
<ul>
<li>作用域规则 </li>
</ul>
循环计数器只在循环内部定义，我们不能在循环外引用它。循环退出后，循环计数器就会失效，如下例： 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
ctrIN
1..10LOOP
 
... END
LOOP
; 
sum:=ctr-1;--notallowed
</td>
</tr></tbody></table>
</blockquote>
我们不需要显式声明循环计数器，因为它会被隐式地声明为INTEGER类型本地变量。下面的例子中本地声明覆盖了全局声明： 
<blockquote>
<table border="0"><tbody><tr>
<td>
DECLARE
 
ctrINTEGER
; BEGIN
 
... FOR
ctrIN
1..25LOOP
 
... IF
ctr>10THEN
...--referstoloopcounter
 END
LOOP
; END
; </td>
</tr></tbody></table>
</blockquote>
如果想在上例中引用全局变量，我们就得借助标签和点标志，例如： 
<blockquote>
<table border="0"><tbody><tr>
<td><<main>> DECLARE
 
ctrINTEGER
; 
... BEGIN
 
... FOR
ctrIN
1..25LOOP
 
... IF
main.ctr>10THEN
--referstoglobalvariable
 
... END
IF
; END
LOOP
; END
main; </td>
</tr></tbody></table>
</blockquote>
同样的作用域规则也适用于嵌套FOR循环。如下面的例子，两个循环计数器的名字相同，所以，用从内层循环引用外层循环的循环计数器，就必须使用标签和点标志： 
<blockquote>
<table border="0"><tbody><tr>
<td><<outer>> FOR
stepIN
1..25LOOP
 FOR
stepIN
1..10LOOP
 
... IF
outer.step>15THEN
... END
LOOP
; END
LOOP
outer; </td>
</tr></tbody></table>
</blockquote>
<ul>
<li>使用EXIT语句 </li>
</ul>
EXIT语句可以立即结束一个FOR循环。例如，下面的循环语句正常情况应该执行十次，但是，如果FETCH语句取得数据失败，循环就会立即终止，无论它执行过多少次： 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
jIN
1..10LOOP
 FETCH
c1INTO
emp_rec; EXIT
WHEN
c1%NOTFOUND; 
... END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
在使用EXIT时，我们可以结束任何封闭循环，而不仅仅是当前循环。只要在我们想结束的封闭循环上加上标签，然后在EXIT语句中引用它，就能结束做过标记的FOR循环了，如下例： 
<blockquote>
<table border="0"><tbody><tr>
<td><<outer>> FOR
iIN
1..5LOOP
 
... FOR
jIN
1..10LOOP
 FETCH
c1INTO
emp_rec; EXIT
outerWHEN
c1%NOTFOUND;--exitbothFORloops
 
... END
LOOP
; END
LOOP
outer; --controlpasseshere
</td>
</tr></tbody></table>
</blockquote>
四、顺序控制：GOTO和NULL语句
与IF和LOOP语句不通，GOTO和NULL语句对PL/SQL编程来说不是必须的。PL/SQL结构中很少用到GOTO语句。有时，它就是用于简化逻辑的。NULL用于改善可读性使条件语句看起来更加清晰。 
滥用GOTO能使结构混乱，不易理解和维护(有时被称为意大利面条式代码 - spaghetti code)。所以，GOTO语句的使用一定要有节制。例如，要从一个深嵌套中跳到异常控制块，要用异常抛出而不是使用GOTO语句。 
1、GOTO语句
GOTO语句可以无条件跳到一个标签处。标签名称在它所处的作用范围内必须是唯一的。执行的时候，GOTO语句会把控制权交给一个做了标记的语句或块。GOTO语句可以向上或向下跳转，示例如下： 
<blockquote>
<table border="0"><tbody><tr>
<td>
BEGIN
 
... GOTO
insert_row; 
... 
<<insert_row>> INSERT
INTO
empVALUES
... END
; </td>
</tr></tbody></table>
</blockquote>
再看一个向上跳转的例子：
<blockquote>
<table border="0"><tbody><tr>
<td>
BEGIN
 
... 
<<update_row>> BEGIN
 UPDATE
empSET
... 
... END
; 
... GOTO
update_row; 
... END
; </td>
</tr></tbody></table>
</blockquote>
下例中的标签end_loop是不允许的，因为它并没有到达一个处理语句： 
<blockquote>
<table border="0"><tbody><tr>
<td>
DECLARE
 
doneBOOLEAN
; BEGIN
 
... FOR
iIN
1..50LOOP
 IF
doneTHEN
 GOTO
end_loop; END
IF
; 
... 
<<end_loop>>--notallowed
 END
LOOP
;--notanexecutablestatement
 END
; </td>
</tr></tbody></table>
</blockquote>
改进方法很简单，只需添加一个NULL语句即可： 
<blockquote>
<table border="0"><tbody><tr>
<td>
FOR
iIN
1..50LOOP
 IF
doneTHEN
 GOTO
end_loop; END
IF
; 
... 
<<end_loop>> NULL
;--anexecutablestatement
 END
LOOP
; </td>
</tr></tbody></table>
</blockquote>
GOTO语句还能从当前块跳入一个封闭的块中： 
<blockquote>
<table border="0"><tbody><tr>
<td>
DECLARE
 
my_enameCHAR
(10); BEGIN
 
<<get_name>> SELECT
ename INTO
my_ename FROM
emp WHERE
... BEGIN
 
... GOTO
get_name;--branchtoenclosingblock
 END
; END
; </td>
</tr></tbody></table>
</blockquote>
<ul>
<li>约束 </li>
</ul>
有些情况下，GOTO语句是不能使用的。特别是想用GOTO语句跳到IF、CASE、LOOP或子块。例如，下面的GOTO语句是不允许的： 
<blockquote>
<table border="0"><tbody><tr>
<td>
BEGIN
 
... GOTO
update_row;--can’tbranchintoIFstatement
 
... IF
validTHEN
 
... 
<<update_row>> UPDATE
empSET
... END
IF
; END
; </td>
</tr></tbody></table>
</blockquote>
如下例所示，GOTO不能从一个IF的一个分支跳到另一个分支。同样，也不能从CASE的一个WHEN子句跳到另一个WHEN子句。 
<blockquote>
<table border="0"><tbody><tr>
<td>
BEGIN
 
... IF
validTHEN
 
... GOTO
update_row;--can’tbranchintoELSE
clause
 ELSE
 
... 
<<update_row>> UPDATE
empSET
... END
IF
; END
; </td>
</tr></tbody></table>
</blockquote>
下例中演示了GOTO语句不能从封闭的块跳入它的子块： 
<blockquote>
<table border="0"><tbody><tr>
<td>
BEGIN
 
... IF
status='OBSOLETE'
THEN
 GOTO
delete_part;--can’tbranchintosub-block
 END
IF
; 
... BEGIN
 
... 
<<delete_part>> DELETE
FROM
partsWHERE
... END
; END
; </td>
</tr></tbody></table>
</blockquote>
同样，GOTO也不能跳出子程序： 
<blockquote>
<table border="0"><tbody><tr>
<td>
DECLARE
 
... PROCEDURE
compute_bonus(emp_idNUMBER
)IS
 BEGIN
 
... GOTO
update_row;--can’tbranchoutofsubprogram
 END
; BEGIN
 
... 
<<update_row>> UPDATE
empSET
... END
; </td>
</tr></tbody></table>
</blockquote>
最后，GOTO不能从异常控制部分跳入当前块。例如，下面的GOTO语句就是不允许的： 
<blockquote>
<table border="0"><tbody><tr>
<td>
DECLARE
 
... 
pe_ratioREAL
; BEGIN
 
... SELECT
price/NVL(earnings,0) INTO
pe_ratio FROM
... 
<<insert_row>> INSERT
INTO
stats VALUES
(pe_ratio,...); EXCEPTION
 WHEN
ZERO_DIVIDETHEN
 
pe_ratio:=0; GOTO
insert_row;--can'tbranchintocurrentblock
 END
; </td>
</tr></tbody></table>
</blockquote>
但是，GOTO语句可以从一个异常控制程序中跳转到一个封闭块。
2、NULL语句
NULL语句本身什么都不做，只是简单的把控制权交给下一个语句而已。在控制结构中，NULL只是告诉阅读者一个可能会被考虑到的情况，而实际的没有任何动作。下面的例子中演示了忽视未命名异常的操作： 
<blockquote>
<table border="0"><tbody><tr>
<td>
EXCEPTION
 WHEN
ZERO_DIVIDETHEN
 ROLLBACK
; WHEN
VALUE_ERRORTHEN
 INSERT
INTO
errorsVALUES
... COMMIT
; WHEN
OTHERS
THEN
 NULL
; </td>
</tr></tbody></table>
</blockquote>
在IF语句中或其他一些需要至少有一个可执行语句的地方，NULL语句就会被使用来满足这种语法。下例中，NULL语句强调了只有顶级(top-rated)雇员才能得到红利： 
<blockquote>
<table border="0"><tbody><tr>
<td>
IF
rating>90THEN
 
compute_bonus(emp_id); ELSE
 NULL
; END
IF
; </td>
</tr></tbody></table>
</blockquote>
在程序设计时，NULL语句很容易创建stub程序。stub程序是一段虚设的子程序，它能让我们推迟函数或过程的实现。因为子程序的可执行部分至少需要一句可执行语句，NULL语句就会派上用场，充当占位语句，如下例： 


PROCEDURE
debit_account(acct_idINTEGER
,amountREAL
)IS
 BEGIN
 NULL
; END
debit_account;

iteye_2060

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第四章 PL/SQL的控制结构

第四章 PL/SQL的控制结构&lt;!-- InstanceEndEditable --&gt;&lt;!-- InstanceBeginEditable name="EditRegion2" --&gt;一、PL/SQL控制结构一览根据结构定理(structure theorem)，任何计算机程序都可以用下图中的基本控制结构来表示。它们可以任意组合来解决问题。选...
复制链接

扫一扫