HTML TEXT

Some text.'); \set SQLTERM / CREATE OR REPLACE TRIGGER tri BEFORE UPDATE ON t1 FOR EACH ROW BEGIN RAISE NOTICE 'Old value of CLOB column: %', :OLD.c1; RAISE NOTICE 'Proposed new value of CLOB column: %',:NEW.c1; :NEW.c1 := :NEW.c1 || '

Standard footer paragraph.'; RAISE NOTICE 'Final value of CLOB column: %',:NEW.c1; END; / UPDATE t1 SET c1 = '

Different Document Fragment

Different text.'; 274 第 10 章 触发器 SELECT * FROM t1; 结果： NOTICE: Old value of CLOB column:

HTML TEXT

Some text. NOTICE: Proposed new value of CLOB column:

Different Document Fragment

Different text. NOTICE: Final value of CLOB column:

Different Document Fragment

Different text.

Standard footer paragraph. UPDATE 1 示例 10-14 带有 REFERENCING 子句的触发器 此示例创建一个与触发器相关变量同名的表 new，然后在该表上创建触发器。为了避免表名和相关变量名之间的 冲突，触发器将相关变量名取别名为 Newest。 CREATE TABLE new ( f1 NUMBER, f2 VARCHAR2(20) ); \set SQLTERM / CREATE OR REPLACE TRIGGER show_score_change BEFORE UPDATE ON new REFERENCING new AS Newest FOR EACH ROW BEGIN :Newest.f2 := TO_CHAR (:newest.f1); END; / 10.5 事件触发器 其触发事件由 DDL 语句组成。 详情参见触发器概述。 10.6 触发器调用的子程序 触发器可以调用 PL/SQL 编写的子程序。示例 10-4 中的触发器调用了一个 PL/SQL 子程序。触发器调用的子程 序不能运行事务控制语句，因为子程序运行在触发器体的上下文中。 275 第 10 章 10.7 触发器 触发编译、失效和重新编译 如果触发器引用另一个对象，例如子程序或包，并且该对象被修改或删除，则触发器将变为无效。下次触发事件 发生时，编译器会尝试重新验证触发器。 要手动重新编译触发器，请使用” ALTER TRIGGER 语句 ” 中描述的语句。 10.8 触发器中的异常处理 在大多数情况下，如果触发器运行引发异常的语句，并且异常未由异常处理程序处理，则数据库将回滚触发器及 其触发语句的影响。 注意: 强制执行复杂的安全授权或约束的触发器通常会引发用户定义的异常。这些在” 用户自定义异常” 另请参阅: 异常处理 ，关于异常处理的一般信息 远程异常处理 只有当远程数据库可用时，访问远程数据库的触发器才能进行远程异常处理。如果本地数据库必须编译触发器时 远程数据库不可用，则本地数据库无法验证访问远程数据库的语句，编译失败。如果触发器无法编译，则其异常处理 程序无法运行。 示例 10-15 中的触发器有一个 INSERT 访问远程数据库的语句。触发器还有一个异常处理程序。但是，如果本地 数据库尝试编译触发器时远程数据库不可用，则编译失败并且异常处理程序无法运行。 示例 10-15 如果远程数据库不可用，触发器无法处理异常 \set SQLTERM / CREATE OR REPLACE PROCEDURE insert_row_proc AUTHID CURRENT_USER AS no_remote_db EXCEPTION; -- declare exception PRAGMA EXCEPTION_INIT (no_remote_db, -20000); BEGIN INSERT INTO student@remote ( student_id, first_name, last_name, email, hire_date, job_id ) VALUES ( 99, 'Jane', 'Doe', 'jane.doe@example.com', SYSDATE, 'ST_MAN' ); EXCEPTION WHEN OTHERS THEN INSERT INTO stu_log (id, log_date, new_score, action) VALUES (99, SYSDATE, NULL, 'insert failed.'); 276 第 10 章 触发器 RAISE_APPLICATION_ERROR (-20000, 'Remote database is unavailable.'); END; / CREATE OR REPLACE TRIGGER student_tr AFTER INSERT ON student FOR EACH ROW BEGIN insert_row_proc; END; / 10.9 触发器设计指南 • 使用触发器确保无论何时发生特定事件，都会执行任何必要的操作（无论哪个用户或应用程序发出触发语 句）。 例如，使用触发器确保每当有人更新表时，都会更新其日志文件。 • 不要创建重复数据库功能的触发器。 例如，如果您可以对约束执行相同操作，请不要创建触发器来拒绝无效数据。 • 不要创建依赖于 SQL 语句处理行的顺序（可能会有所不同）的触发器。 例如，如果变量的当前值取决于行触发器正在处理的行，则不要将值分配给行触发器中的全局包变量。如果触 发器更新全局包变量，请在 BEFORE 语句触发器中初始化这些变量。 • BEFORE 在将行数据写入磁盘之前，使用行触发器修改行。 • 使用 AFTER 行触发器获取行 ID 并在操作中使用它。 注意: AFTER 行触发器比 BEFORE 行触发器更有效。使用 BEFORE 行触发器，首先为触发器读取受影响的数据 块，然后为触发语句读取。对于 AFTER 行触发器，受影响的数据块对于触发器是只读的。 • 如果 BEFORE 语句触发器的触发语句是与正在运行的 UPDATE 语句冲突的 UPDATE 或 DELETE 语句，则 数据库对 SAVEPOINT 执行透明 ROLLBACK 并重新启动触发语句。在触发语句成功完成之前，数据库可以多 次执行此操作。每次数据库重新启动触发语句时，触发器都会触发。ROLLBACK 到 SAVEPOINT 不会撤消对 触发器引用的包变量的更改。要检测这种情况，请在包中定义一个计数器变量。 • 不要创建递归触发器。 例如，不要创建在定义触发器的表上执行 UPDATE 语句的 AFTER UPDATE 触发器。触发器会递归触发，直 到内存不足。 277 第 10 章 触发器 • 如果您创建的触发器包含访问远程数据库的语句，则将该语句的异常处理程序放在存储的子程序中并从触发器 调用子程序。 有关详细信息，请参阅 远程异常处理。 • 如果触发器运行以下语句，则该语句返回触发器的所有者，而不是更新表的用户： – 只有提交的触发器才会触发。 – 要允许模块化安装在相同表上具有触发器的应用程序，请创建多个相同类型的触发器，而不是运行一系列 操作的单个触发器。 每个触发器都会看到先前触发的触发器所做的更改。每个触发器都可以看到 OLD 和 NEW 值。 10.10 触发器触发的顺序 如果为同一张表上的同一语句定义了两个或多个具有不同时间点的触发器，则它们按以下顺序触发： 1. 所有 BEFORE STATEMENT 触发器 2. 所有 BEFORE EACH ROW 触发器 3. 所有 AFTER EACH ROW 触发器 4. 所有 AFTER STATEMENT 触发器 10.11 触发器启用和禁用 默认情况下，CREATE TRIGGER 语句创建一个处于启用状态的触发器。要在禁用状态下创建触发器，请指定 DISABLE。在禁用状态下创建触发器可以确保它在启用之前编译没有错误。 暂时禁用触发器的一些原因是： • 触发器引用了一个不可用的对象。 • 您必须进行大量数据加载，并且希望它在不触发触发器的情况下快速进行。 • 您正在重新加载数据。 要启用或禁用单个触发器，请使用以下语句： ALTER TRIGGER [schema.]trigger_name { ENABLE | DISABLE }; 要启用或禁用在特定表上创建的所有版本中的所有触发器，请使用以下语句： ALTER TABLE table_name { ENABLE | DISABLE } ALL TRIGGERS; 278 第 10 章 触发器 在前面的两个语句中，schema 是包含触发器的模式的名称，默认是您的当前模式。 另请参阅: • “ALTER TRIGGER 语句 ”以获取有关 ALTER TRIGGER 语句的更多信息 • “ALTER TABLE 语句”以获取有关 ALTER TABLE 语句的更多信息 10.12 触发器更改和调试 要更改触发器，您必须替换或重新创建它。（该 ALTER TRIGGER 语句仅启用、禁用、编译或重命名触发 器。） 要替换触发器，请使用 CREATE TRIGGER 带有 OR REPLACE 子句的语句。 要重新创建触发器，请先使用 DROP TRIGGER 语句将其删除，然后再使用 CREATE TRIGGER 语句再次创 建它。 要调试触发器，您可以使用可用于存储子程序的工具。有关这些工具的信息，请参阅《KingbaseES 数据库开发 指南》。 另请参阅: • “CREATE TRIGGER 语句”以获取有关该 CREATE TRIGGER 语句的更多信息 • “DROP TRIGGER 语句”以获取有关该 DROP TRIGGER 语句的更多信息 • “ALTER TRIGGER 语句”以获取有关该 ALTER TRIGGER 语句的更多信息 10.13 触发器信息视图 *_TRIGGERS 静态数据字典视图显示有关触发器的信息。有关这些视图的信息，请参阅《KingbaseES 数据库 参考手册》。 示例 10-16 查看有关触发器的信息 此示例创建一个触发器并查询静态数据字典视图 USER_TRIGGERS 两次——首先显示其类型、触发事件和创 建它的表的名称，然后显示其主体。 \set SQLTERM / CREATE OR REPLACE TRIGGER Stu_count AFTER DELETE ON student DECLARE n INTEGER; BEGIN SELECT COUNT(*) INTO n FROM student; RAISE NOTICE 'There are now % student.', n; 279 第 10 章 触发器 END; / 查询： SELECT Trigger_type, Triggering_event, Table_name FROM USER_TRIGGERS WHERE Trigger_name = 'STU_COUNT'; 结果： trigger_type | triggering_event | table_name -----------------+------------------+-----------AFTER STATEMENT | DELETE | student (1 row) 查询： SELECT Trigger_body FROM USER_TRIGGERS WHERE Trigger_name = 'EMP_COUNT'; 结果： trigger_body ---------------------------------------------------------------------------------------CREATE OR REPLACE TRIGGER emp_count AFTER DELETE ON public.student FOR EACH STATEMENT + DECLARE + n + INTEGER; BEGIN + SELECT COUNT(*) INTO n FROM student; + RAISE NOTICE 'There are now % student.', n; + END (1 row) 280 第 11 章 包 11章 包 第 把相关的变量、常量、游标、异常和子程序等从逻辑上组织在一起形成一个包，包是模式下的一种对象。 一个包总是有一个包规范，它声明了可以从包外部引用的公共项。 如果包的公共项中包含游标或子程序，则包还必须有一个包体。包体必须定义公共游标的查询和公共子程序的实 现。包体还可以声明和定义不能从包外部引用但对于包的内部工作来说是必需的私有项。包体可以有一个初始化部 分，用于初始化变量、执行其他一次性逻辑并进行异常处理。您可以在不更改包规范或对包中公共项的引用的情况下 更改包体；所以，您可以将包体视为一个黑匣子。 包规范的 AUTHID 子句决定包中的子程序和游标是以其定义者（默认）还是调用者的权限运行，以及包中对模 式下其他对象的非限定引用是在定义者的模式中解析还是调用者的模式中解析。 另请参阅: • 包规范 ，了解更多关于包规范的信息 • 包体 获取更多关于包体的信息 • 函数声明与定义 • 过程声明与定义 • 调用者权限和定义者权限属性 11.1 包的优点 包用于开发可靠的，可维护的，可重复使用的代码。 • 模块化 通过使用包可以把逻辑上相关的变量、函数等封装成为一个 PL/SQL 模块。这样的包更易于理解，且包与包之 间的接口也简单明了，方便定义，这样非常有利于应用开发。 • 简化应用程序设计 当设计一个应用程序时，最初仅需要包规范的接口信息。您可以先编写包规范代码并进行编译，而暂不需要定 义包体；包体可以在需要实际完成应用程序时再定义。 281 第 11 章 包 • 隐藏实现的逻辑 – 包可以让您在包规范中共享您的接口信息，并在包体中隐藏具体的实现逻辑。将实现逻辑隐藏在包体中具 有以下优点： – 您可以在不影响应用程序的情况下更改实现逻辑。 – 应用程序用户无法开发依赖于您可能想要更改的实现逻辑的代码。 • 功能增强 包中的公共变量和游标在一个会话中会一直存在，可以被当前会话中的其它函数、存储过程或者其他包共享。 它们使您可以跨事务维护数据，而无需将其存储在数据库中。 • 高效性 – 第一次调用包函数或包存储过程时，整个包被加载到内存，以后再访问该包的对象时，不需要再进行 I/O 操作。 – 包可以防止级联依赖和不必要的重新编译。例如，如果您更改包体中的子函数的定义，数据库不会重新编 译调用该函数的其他子程序，因为这些子程序仅依赖于包规范中的函数声明。 • 方便授权 对包的授权同时将包中所有的对象授权。 11.2 包规范 包规范负责声明公共项，公共项的可见域为包所在的模式，即包中公共项对包所在的模式中的任何对象都可见。 要引用可见域内包中的公共项，需要使用包名称对其进行限定。（有关范围、可见性和限定的信息，请参阅“标识符 的作用域和可见性 ”。） 每个公共项的声明都包含了使用该公共项所需的所有信息。例如，假设包规范以以下方式声明函数 func FUNCTION func (n INTEGER) RETURN INTEGER; -- returns n 该声明表明函数 func 需要一个 INTEGER 类型参数并返回一个 INTEGER 类型的值。调用者必须知道应该使用 什么值调用函数 func，而不需要知道 func 是如何实现的。 11.2.1 包中公共项 包中的公共项包括： • 可被多个子程序使用的类型、变量、常量、子程序、游标和异常 包规范中定义的类型可以是 PL/SQL 用户定义的子类型（在用户定义的 PL/SQL 子类型 中描述）或 PL/SQL 复合类型（在PL/SQL 集合和记录 中描述）。 282 第 11 章 包 • 可用于独立子程序参数的关联数组类型 您不能在模式中定义关联数组类型。因此，需要要将关联数组变量作为参数传递给独立子程序时，您必须在包 规范中声明关联数组类型。这样做可以使被调用的子程序（声明该类型的参数）和调用子程序或匿名块（声明 该类型的变量）都可以使用该类型。见示例 11-2 。 • 在同一会话中的子程序之间必须保持可用的变量 • 用于读写公共变量的子程序 提供这些子程序来防止包用户直接读写公共变量。 • 相互调用的子程序 您不必像关心相互调用的独立子程序一样考虑包中子程序的编译顺序。 • 重载的子程序 重载的子程序是同一子程序的变体。也就是说，它们具有相同的名称，但参数不同。有关它们的更多信息，请 参阅子程序的重载 。 11.2.2 创建包规范 使用 CREATE PACKAGE 语句创建包规范。 如果包规范中未声明子程序，则该包可以不需要创建包体。 示例 11-1 简单的包规范 在这个例子中，包 pkg1 的规范声明了两个公共类型和三个公共变量以及一个公共异常。 \set SQLTERM / CREATE OR REPLACE PACKAGE pkg1 AUTHID DEFINER AS TYPE rec1 IS RECORD ( col1 INT, col2 TEXT); TYPE rec2 IS RECORD ( col1 VARCHAR2(10), col2 col3 INT, REAL); var1 CONSTANT REAL := 10.00; var2 INT; excep EXCEPTION; PRAGMA EXCEPTION_INIT(excep, -100); END pkg1; / \set SQLTERM ; 示例 11-2 将关联数组传递给独立子程序 283 第 11 章 包 在此示例中，包 pkg2 的规范中声明了关联数组类型 typ1 然后，独立存储过程 proc1 声明了一个 typ1 类型的参 数。接下来，匿名块声明一个 typ1 类型的变量为其赋值，并将它传递给打印它的存储过程 proc1。 set serveroutput on \set SQLTERM / CREATE OR REPLACE PACKAGE pkg2 AUTHID DEFINER IS TYPE typ1 IS TABLE OF INTEGER INDEX BY VARCHAR2(15); END; / CREATE OR REPLACE PROCEDURE proc1 ( p1 pkg2.typ1 ) AUTHID DEFINER IS i VARCHAR2(15); BEGIN i := p1.FIRST; WHILE i IS NOT NULL LOOP DBMS_OUTPUT.PUT_LINE (p1(i) || ' ' || i); i := p1.NEXT(i); END LOOP; END; / \set SQLTERM ; \set SQLTERM / DECLARE v1 pkg2.typ1; BEGIN v1('zero') := 0; v1('one') := 1; v1('two') := 2; proc1(v1); END; / \set SQLTERM ; 结果： 1 one 2 two 0 zero 284 第 11 章 包 包体 11.3 如果包规范声明了子程序，则必须要创建包体；否则，包体是可选的。包体和包规范必须在同一个模式中。 包规范中的每个子程序声明都必须在包体中具有相应的定义。相应子程序的声明和定义必须匹配，空格除外。 使用 CREATE PACKAGE BODY 语句创建包体。 在包规范中声明并在包体中定义的子程序是可以从包外部引用的公共项。包体还可以声明和定义不能从包外部引 用但可用于包的内部的私有项。 包体还可以有一个初始化部分，用于初始化公共变量并执行一些一次性逻辑。初始化部分仅在第一次引用包时运 行。初始化部分可以包括异常处理程序。 您可以在未更改包规范中公共项的情况下更改包体。 示例 11-3 匹配包规范和包体 在示例 11-3 中，相应的子程序声明和定义的参数名不匹配；因此，PL/SQL 会引发异常。 DROP TABLE IF EXISTS student CASCADE; CREATE TABLE student (id INT PRIMARY KEY, name TEXT, score NUMBER); \set SQLTERM / CREATE PACKAGE pkg3 AS PROCEDURE proc1 (p1 student.name%TYPE); END pkg3; / CREATE PACKAGE BODY pkg3 AS -- 参数名 p2 与声明的参数名 p1 不一致 PROCEDURE proc1 (p2 student.name%TYPE) IS BEGIN DBMS_OUTPUT.PUT_LINE('Student name is ' || p1); END; END pkg3; / \set SQLTERM ; 结果： ERROR: procedure "proc1" is declared in package "pkg3" and must be defined in the package body 正确示例： \set SQLTERM / CREATE PACKAGE BODY pkg3 AS PROCEDURE proc1 (p1 student.name%TYPE) IS BEGIN 285 第 11 章 包 DBMS_OUTPUT.PUT_LINE('Student name is ' || p1); END; END pkg3; / \set SQLTERM ; 结果： CREATE PACKAGE BODY 11.4 包实例化和初始化 当一个会话中引用包中对象时，数据库会为该会话对包进行实例化。包的实例化在每个不同的会话中都是独立 的。 当数据库实例化一个包时，它会对其进行初始化。初始化包括以下工作： • 为公共常量分配初始值 • 为公共变量分配初始值 • 执行包体的初始化部分 11.5 包编写指南 • 熟悉 KingbaseES 数据库提供的包，避免编写重复其特性的包。 有关 KingbaseES 数据库提供的包的更多信息，请参阅《KingbaseES 插件参考手册》。 • 使包具有通用性，以便跟多的应用程序可以复用它们。 • 在编写包体之前设计和编写包规范。 • 在包规范中，仅声明调用程序必须可见的项。 这种做法可以防止其他开发人员在您的实现细节上构建不安全的依赖关系，并减少重新编译。如果更改包规 范，则必须重新编译所有调用包的公共子程序的数据库对象。如果只更改包体，则无需重新编译这些对象。 • 在包体的初始化部分中分配初始值，而不是在包声明中分配。 这种做法有以下优点： – 用于计算初始值的代码可以更复杂，且记录的更完善。 – 如果计算初始值引发异常，则初始化部分可以使用自己的异常处理程序来处理它。 286 第 11 章 包 包示例 11.6 示例 11-4 创建两个表 student、log 和一个包 emp_admin ，然后从一个匿名块中调用包中的子程序，包 emp_admin 既有包规范又有包体。 包 emp_admin 的包规范声明了一个公共类型、游标和异常，以及三个公共的子程序。其中一个公共子程序被重 载（有关子程序重载的信息，请参阅子程序的重载 ）。 包体定义了包规范中声明的子程序，声明并定义了一个私有变量，一个私有函数，并拥有一个初始化块。 初始化部分（仅在匿名块第一次引用包时运行）向表 log 中插入一行数据并将私有变量 number_hired 初始化为 零。每次调用包过程 hire_student 时，它都会更新私有变量 number_hired 的值。 示例 11-4 创建包 emp_admin set serverout on -- 创建表: DROP TABLE IF EXISTS student CASCADE; CREATE TABLE student ( id INT PRIMARY KEY, name TEXT, score NUMBER ); DROP TABLE IF EXISTS log; CREATE TABLE log ( date_of_action DATE, user_id VARCHAR2(20), package_name VARCHAR2(30) ); -- 包规范 \set SQLTERM / CREATE OR REPLACE PACKAGE emp_admin AUTHID DEFINER AS -- 声明公共类型、游标、异常: TYPE RecTyp IS RECORD (id INT, score NUMBER); CURSOR desc_score RETURN RecTyp IS SELECT id, score FROM student ORDER BY score DESC; invalid_score EXCEPTION; 287 第 11 章 包 -- 声明公共子程序: FUNCTION hire_student ( name VARCHAR2, score NUMBER ) RETURN NUMBER; -- 重载的公共子程序: PROCEDURE fire_student (emp_id INT); PROCEDURE fire_student (emp_name VARCHAR2); PROCEDURE raise_score (emp_id INT, emp_score NUMBER); FUNCTION highest_score (n NUMBER) RETURN RecTyp; END emp_admin; / \set SQLTERM ; -- 包体: \set SQLTERM / CREATE OR REPLACE PACKAGE BODY emp_admin AS number_hired -- 私有变量，仅包体可见 NUMBER; -- 定义在包中声明的子程序: FUNCTION hire_student ( name VARCHAR2, score NUMBER ) RETURN NUMBER IS BEGIN INSERT INTO student ( id, name, score ) VALUES ( number_hired, hire_student.name, hire_student.score ); DBMS_OUTPUT.PUT_LINE('The number of student is ' || TO_CHAR(number_hired) ); number_hired := number_hired + 1; RETURN number_hired - 1; END hire_student; 288 第 11 章 包 PROCEDURE fire_student (emp_id NUMBER) IS BEGIN DELETE FROM student WHERE id = emp_id; END fire_student; PROCEDURE fire_student (emp_name VARCHAR2) IS BEGIN DELETE FROM student WHERE name = emp_name; END fire_student; -- 私有函数，仅包体可见: FUNCTION score_ok ( score NUMBER ) RETURN BOOLEAN IS BEGIN RETURN (score >= 0) AND (score <= 100); END score_ok; PROCEDURE raise_score ( emp_id INT, emp_score NUMBER ) IS BEGIN IF score_ok(emp_score) THEN -- 调用私有函数 UPDATE student SET score = emp_score WHERE id = emp_id; ELSE RAISE invalid_score; END IF; EXCEPTION WHEN invalid_score THEN DBMS_OUTPUT.PUT_LINE ('The score is out of the specified range.'); END raise_score; FUNCTION highest_score ( n NUMBER ) RETURN RecTyp IS emp_rec RecTyp; BEGIN 289 第 11 章 包 OPEN desc_score; FETCH desc_score INTO emp_rec; CLOSE desc_score; RETURN emp_rec; END highest_score; BEGIN -- 包体的初始化块 INSERT INTO log (date_of_action, user_id, package_name) VALUES (SYSDATE, USER, 'EMP_ADMIN'); number_hired := 1; END emp_admin; / \set SQLTERM ; -- 在匿名块中调用包中子程序: \set SQLTERM / DECLARE new_emp_id NUMBER(6); highest_student emp_admin.RecTyp; BEGIN new_emp_id := emp_admin.hire_student ( 'Zhang San', 0 ); DBMS_OUTPUT.PUT_LINE ('The student id is ' || TO_CHAR(new_emp_id)); emp_admin.raise_score (new_emp_id, 90); highest_student := emp_admin.highest_score(1); DBMS_OUTPUT.PUT_LINE ( 'The highest score is '|| TO_CHAR (highest_student.score) || ', belonging to student: ' || TO_CHAR (highest_student.id) ); emp_admin.fire_student(new_emp_id); -- 也可以调用以下子程序: -- emp_admin.fire_student('Zhang San'); END; / \set SQLTERM ; 输出结果： 290 第 11 章 包 The number of student is 1 The student id is 1 The highest score is 90, belonging to student: 1 11.7 关于 STANDARD 包 KingbaseES 提供了一个名为 STANDARD 的系统包，该包中定义了部分可用于 PL/SQL 环境中的对象。例如， STANDARD 包声明 too_many_rows 等预定义异常。 11.8 DBMS_RANDOM 包 KingbaseES 提供了 DBMS_RANDOM 系统包下定义的随机数据产生的功能。 11.8.1 DBMS_RANDOM 包下函数 DBMS_RANDOM 系统包提供一个随机数或者字符的生成器。 下表列出了 DBMS_RANDOM 系统包并简要的表述了它们。 表 11.8.1: DBMS_RANDOM 软件包子程序和函数 子程序/函数 返回类型 INITIALIZE Procedure 使用一个种子值来初始化包 NORMAL Function 产生标准的正态分布函数 RANDOM Function 产生一个随机整数 SEED Procedure 重置随机数种子 STRING Function 产生一个随机字符串 TERMINATE Procedure 提供语法上的兼容不执行任何操作 VALUE Function 产生指定范围的随机数 • INITIALIZE Procedure 使用一个种子值来初始化 DBMS_RANDOM 包，默认情况下，DBMS_RANDOM 包是根据用户、时间、会话 来初始化。Initialize 这个函数已经过时，虽然目前受到支持，但考虑历史遗留原因和兼容性保留此初始化方式。 语法格式： 291 第 11 章 包 DBMS_RANDOM.INITIALIZE(init INTEGER); 参数说明： 表 11.8.2: initialize 参数 参数 描述 init 随机数种子值 返回值说明：VOID 示例： CALL dbms_random.initialize(8); • NORMAL Function 参数说明：无参 返回值说明：DOUBLE 示例： SELECT dbms_random.normal(); • RANDOM Function 产生一个随机整数，这个函数已经过时了，虽然目前还支持，但不应该使用它，考虑兼容性保留此函数。 语法格式： DBMS_RANDOM.RANDOM(); 参数说明：无参 返回值说明：INTEGER 示例： CALL dbms_random.random(); • SEED Procedure 重置种子，类似于 initialize 函数，initialize 函数已经被淘汰。seed 函数同时支持数值和字符作为种子值，而 initialize 只支持数值。 语法格式： 292 第 11 章 包 DBMS_RANDOM.SEED(i INTEGER); DBMS_RANDOM.SEED(t TEXT); 参数说明： 表 11.8.3: seed 参数 参数 描述 i 随机数种子值 t 随机数字符种子值 返回值说明： 表 11.8.4: seed 返回值 函数 类型 SEED(i INTEGER) VOID SEED(i TEXT) VOID 示例： CALL dbms_random.seed(8); CALL dbms_random.seed('test'); • STRING Function 获取一个随机字符串，第一个参数的是字符串的格式，第二个参数是指字符串的长度。长度最大为 5000，参数 如果超过 5000 会自动以 5000 处理。 语法格式： DBMS_RANDOM.STRING(type TEXT,len INTEGER); 参数说明： 表 11.8.5: string 参数 参数 描述 type 产生字符串的类型 见续表 293 第 11 章 包 表 11.8.5 – 续表 参数 描述 len 产生字符串的长度 表 11.8.6: type 参数对应含义 值 描述 ’u’,’U’ 返回大写字符的字符串 ’l’,’L’ 返回小写字母的字符串 ’a’,’A’ 返回大小写字母混合的字符串 ’x’,’X’ 返回大写字母和数字的字符串 ’p’,’P’ 返回任何可打印字符的字符串 返回值说明：TEXT 示例： SELECT dbms_random.string('U',5); SELECT dbms_random.string('P',2); SELECT dbms_random.string('x',4); SELECT dbms_random.string('a',2); SELECT dbms_random.string('l',3); • TERMINATE Procedure 原功能为使用完 dbms_random 包的时候执行此函数，但是现在此函数不执行任何功能，为了语法兼容保留。 语法格式： DBMS_RANDOM.TERMINATE(); 参数说明：无参 返回值说明：VOID 示例： CALL dbms_random.terminate(); VALUE Function 第一种无参的使用方式是获取一个大于或者等于 0 且小于 1 的随机数，精度为 16 位的小数。 294 第 11 章 包 第二使用方式可以指定最小值和最大值，返回值的范围大于或者等于 low，小于 high，精度同为 16 位小数。 语法格式： DBMS_RANDOM.VALUE(); DBMS_RANDOM.VALUE(low INTEGER,high INTEGER); 参数说明： 表 11.8.7: value 参数 参数 描述 low 产生的随机数最小值 high 产生的随机数最大值 返回值说明： 表 11.8.8: value 返回值 函数 类型 VALUE() VOID VALUE(low INTEGER,high INTEGER) VOID 示例： SELECT dbms_random.value(); SELECT dbms_random.value(10,15); 295 第 12 章 异常处理 12章 异常处理 第 本章解释如何处理 PL/SQL 运行时错误，即异常处理。 另请参阅: • ” 触发器中的异常处理 ” • ” FORALL 语句完成后处理 FORALL 异常 ” 12.1 异常处理概述 异常（PL/SQL 运行时错误）可能来自设计错误、编码错误、硬件故障或其他来源。无法预先处理所有可能触发 的异常，但可以编写异常处理程序，让程序在触发异常的情况下继续运行。 任何 PL/SQL 块都可以有一个异常处理部分，它可以处理一个或多个异常。例如： EXCEPTION WHEN ex_name_1 THEN statements_1 -- Exception handler WHEN ex_name_2 OR ex_name_3 THEN statements_2 -- Exception handler WHEN OTHERS THEN statements_3 -- Exception handler END; 在上面的语法示例中，ex_name_n 是异常的名称，statements_n 是一个或多个语句。（有关完整的语法和语 义，请参阅异常处理程序 。） 当 PL/SQL 块的可执行部分触发异常时，可执行部分会停止执行并将控制权转移到异常处理部分。如果抛出异 常 ex_name_1，则运行语句 statements_1 。如果抛出异常 ex_name_2 或 ex_name_3，则运行语句 statements_2 。如果抛出其他异常，则运行语句 statements_3。 异常处理程序运行后，控制权转移到封闭块的下一条语句。如果没有封闭块，则： • 如果异常处理程序在子程序中，则将控制权返回给调用者调用之后的语句处。 • 如果异常处理程序位于匿名块中，则控制权转移到主机环境（例如，ksql） 如果在没有异常处理程序的 PL/SQL 块中触发异常，则异常会传播。也就是说，异常会在连续的封闭块中向上 抛出，直到一个 PL/SQL 块有一个异常处理程序或没有封闭块为止（有关更多信息，请参阅异常传播 ）。如果没有 296 第 12 章 异常处理 异常处理程序，那么 PL/SQL 会向调用者或主机环境返回一个未处理的异常，这将决定最终的返回结果（有关更多 信息，请参阅未处理的异常 ）。 12.1.1 异常种类 KingbaseES 异常的种类分为： • 系统预定义异常 系统预定义异常是 PL/SQL 已命名的异常，这些异常都有一个错误代码，且会在系统运行出错时隐式（自动） 触发。有关详细信息，请参阅系统预定义异常。 • 用户自定义异常 可以在任何 PL/ SQL 匿名块、子程序或包的声明部分中声明自己的异常。例如，可以声明一个名为 invalid_number 的异常标记一个无效数字。用户自定义异常必须显式的触发。有关详细信息，请参阅用户自定义 异常。 下表总结了两种异常之间的差别。 表 12.1.1: 异常差异 异常种类 定义 错误代码 名字 隐式触发 显示触发 系统预定义异常 系统 总有 总有 是 可选 用户自定义异常 用户 用户分配 总有 否 总是 更多详细信息，请参阅使用 RAISE 语句触发系统预定义的异常 。 对于命名异常，可以编写特定的异常处理程序，而不是使用 OTHERS 异常处理程序来处理它。特定的异常处理 程序比 OTHERS 异常处理程序更有效，因为后者必须调用一个函数来确定它正在处理哪个异常。有关详细信息，请 参阅检索异常信息 。 12.1.2 异常处理程序的优点 使用异常处理程序进行异常处理使程序更易于编写和理解，并降低了未处理异常的可能性。 如果没有异常处理程序，则必须检查所有可能触发的异常，并处理它。但这样很容易忽略可能出现的异常，尤其 是在无法立即检测到异常的情况下（例如，使用了错误数据在计算运行之前可能无法检测到）。异常处理代码可以分 散在整个程序中。 使用异常处理程序，您不需要预先知道每个可能触发的异常或它可能发生的位置。您只需在可能发生错误的每个 块中包含一个异常处理模块。在异常处理模块中，您可以编写处理特定错误或未知错误的异常处理程序。如果块中的 任何地方（包括子块内）发生错误，则异常处理程序都会捕获并处理它。错误处理的相关信息则会被隔离在块的异常 处理部分，不会再影响程序后续的执行。 297 第 12 章 异常处理 在示例 12-1 中，一个存储过程使用单个异常处理程序来处理预定义异常 NO_DATA_FOUND，该异常可以出现 在两个 SELECT INTO 语句中的任何一个中。 如果多个语句使用相同的异常处理程序，并且您想知道哪个语句触发了异常，则可以使用变量辅助定位，如示 例示例 12-2 所示。 如果您可以确定您需要处理哪个异常，您可以为特定异常设置一个异常处理程序。您还可以通过将语句放入具有 自己的异常处理程序的块中来检查单个语句中的异常。 示例 12-1 在单个异常处理程序中处理多个异常 set serveroutput on \set SQLTERM / CREATE OR REPLACE PROCEDURE select_item ( t_column VARCHAR2, t_name VARCHAR2 ) AUTHID DEFINER IS temp VARCHAR2(30); BEGIN temp := t_column; -- For error message if next SELECT fails -- Fails if table t_name does not have column t_column: SELECT COLUMN_NAME INTO temp FROM USER_TAB_COLS WHERE TABLE_NAME = UPPER(t_name) AND COLUMN_NAME = UPPER(t_column); temp := t_name; -- For error message if next SELECT fails -- Fails if there is no table named t_name: SELECT OBJECT_NAME INTO temp FROM USER_OBJECTS WHERE OBJECT_NAME = UPPER(t_name) AND OBJECT_TYPE = 'TABLE'; EXCEPTION WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE ('No Data found for SELECT on ' || temp); WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE ('Unexpected error'); RAISE; END; / 298 第 12 章 异常处理 \set SQLTERM ; 调用过程（有一个 SYS_PROC 表，但没有 NAME 列）： \set SQLTERM / BEGIN select_item('sys_proc', 'name'); END; / \set SQLTERM ; 结果： No Data found for SELECT on sys_proc 调用过程（没有 EMP 表）： \set SQLTERM / BEGIN select_item('emp', 'name'); END; / \set SQLTERM ; 结果： No Data found for SELECT on emp 示例 12-2 在共享异常处理程序中使用定位变量 set serveroutput on \set SQLTERM / CREATE OR REPLACE PROCEDURE loc_var AUTHID DEFINER IS stmt_no POSITIVE; name_ VARCHAR2(100); BEGIN stmt_no := 1; SELECT table_name INTO name_ FROM user_tables WHERE table_name LIKE 'SYS%' LIMIT 1; stmt_no := 2; SELECT table_name INTO name_ 299 第 12 章 异常处理 FROM user_tables WHERE table_name LIKE 'XYZ%'; EXCEPTION WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE ('Table name not found in query ' || stmt_no); END; / \set SQLTERM ; CALL loc_var(); 结果： Table name not found in query 2 12.1.3 异常处理指南 为了使您的程序尽可能可靠和安全，请遵循以下原则： • 使用错误检索代码和异常处理程序。 在输入错误的数据可能导致出错的地方使用错误检查代码。比如不正确或为空的参数和不返回行或返回的行数 超出预期的查询语句。可以在程序编写过程中输入错误数据的不同组合来测试您的代码，以查看可能出现的错 误。有时您可以使用错误检查代码来避免引发异常，如示例示例 12-4 所示。 • 在可能发生错误的地方添加异常处理程序。 在数字计算、字符串操作和数据库操作期间尤其容易出错。错误也可能来自与您的代码无关的问题，例如，磁 盘存储或内存硬件故障，但您的代码仍然需要异常处理程序来处理他们。 • 设计您的程序以在数据库未处于您期望的状态时继续工作。 例如，您查询的表可能添加或删除了列，或者它们的类型已经更改。您可以通过使用%TYPE 限定符声明变量 或者使用%ROWTYPE 限定符声明记录变量来保存查询结果来避免出错。 • 尽可能使用命名异常编写异常处理程序，而不是使用 OTHERS 异常处理程序。 了解预定义异常的名称和原因。如果您知道您的数据库操作可能会引发特定的系统预定义异常，请专门为它们 编写异常处理程序。 • 让您的异常处理程序输出调试信息。 如果您将调试信息存储在单独的表中，请使用自治事务程序执行此操作，这样即使您回滚主程序所做的工作， 您也可以提交调试信息。有关自治事务程序的信息，请参阅自治事务 。 • 对于每个异常处理程序，仔细确认是让它进行事物的提交、回滚还是继续执行。 无论错误的严重程度如何，都需要使数据库保持正常状态并避免存储错误数据。 300 第 12 章 异常处理 • 通过在每个 PL/SQL 程序的顶层包含一个 OTHERS 异常处理程序来避免漏处理某些异常。 将 OTHERS 异常处理程序中的最后一条语句设为 RAISE， 有 关 RAISE 或调用 RAISE_APPLICATION_ERROR 的信息，请参阅显式触发异常。 12.2 系统预定义异常 针对许多比较常见的异常以及系统运行时会触发的异常，PL/SQL 内部为其预定义了一个名称。例如：除零错 误，对应的预定义异常名称为 DIVISION_BY_ZERO。当错误发生时，系统隐式（自动）抛出该异常。 KingbaseES 常见的系统预定义异常详见PL/SQL 预定义异常表 。 301 第 12 章 异常处理 表 12.2.1: PL/SQL 预定义异常 KingbaseES 异常名称 Oracle 对应异常名称 异常说明 CASE_NOT_FOUND CASE_NOT_FOUND CASE 语句中没有任何 WHEN 子句满足条件，且 没有 ELSE 子句。 COLLECTION_IS_NULL COLLECTION_IS_NULL 调用一个未初始化的嵌套 表或者可变数组的方法 (不包含 EXISTS)，或为 一个未初始化的嵌套表或 者可变数组的元素赋值。 DUPLICATE_CURSOR CURSOR_ALREADY_OPEN 打开一个已经打开的游 标。 UNIQUE_VIOLATION DUP_VAL_ON_INDEX 给一个有唯一约束条件的 数据字段保存相同的值。 INVALID_CURSOR_NAME INVALID_CURSOR 操作一个不合法的游标。 例如关闭一个未打开的游 标。 INVALID_TEXT_REPRESENTATION INVALID_NUMBER 出现运算、转换、截位或 长度的约束错误。 NO_DATA_FOUND NO_DATA_FOUND 未获取到数据。 INTERNAL_ERROR PROGRAM_ERROR PL/SQL 内部错误。 SELF_IS_NULL SELF_IS_NULL 调用一个为空对象的 MEMBER 方法。 OUT_OF_MEMORY STORAGE_ERROR 内存溢出。 SUBSCRIPT_BEYOND_COUNT SUBSCRIPT_BEYOND_COUNT 调用嵌套表或者可变数组 时，使用的下标索引超出 对应元素的总个数。 SUBSCRIPT_OUTSIDE_LIMIT SUBSCRIPT_OUTSIDE_LIMIT 调用嵌套表或者可变数组 时，使用的下标索引不在 合法范围内，如 (-1)。 TOO_MANY_ROWS TOO_MANY_ROWS 返回太多的结果行。 NUMERIC_VALUE_OUT_OF_RANGE VALUE_ERROR 数值类型超过定义域。 DIVISION_BY_ZERO ZERO_DIVIDE 除零错误。 302 第 12 章 异常处理 更多预定义异常信息可通过数据库系统函数 SYS_GET_PREDEFINED_EXCEPTION_DETAIL 进行查询，详 见SYS_GET_PREDEFINED_EXCEPTION_DETAIL 函数 。 示例 12-3 计 算 了 一 家 公 司 的 市 盈 率。 如 果 公 司 的 收 益 为 零， 则 除 法 操 作 会 引 发 预 定 义 的 异 常 DIVI- SION_BY_ZERO，并且块的可执行部分将控制权转移到异常处理部分。 示例 12-4 使用错误检查代码来避免示例 12-3 处理的异常。 另请参阅: • 使用 RAISE 语句触发系统预定义的异常 示例 12-3 匿名块中处理 DIVISION_BY_ZERO set serverout on \set SQLTERM / DECLARE stock_price NUMBER := 9.73; net_earnings NUMBER := 0; pe_ratio NUMBER; BEGIN pe_ratio := stock_price / net_earnings; -- raises ZERO_DIVIDE exception DBMS_OUTPUT.PUT_LINE('Price/earnings ratio = ' || pe_ratio); EXCEPTION WHEN ZERO_DIVIDE THEN DBMS_OUTPUT.PUT_LINE('Company had zero earnings.'); pe_ratio := NULL; END; / \set SQLTERM ; 结果： Company had zero earnings. 示例 12-4 匿名块中避免 DIVISION_BY_ZERO \set SQLTERM / DECLARE stock_price NUMBER := 9.73; net_earnings NUMBER := 0; pe_ratio NUMBER; BEGIN pe_ratio := CASE net_earnings WHEN 0 THEN NULL ELSE stock_price / net_earnings 303 第 12 章 异常处理 END; END; / \set SQLTERM ; 12.3 用户自定义异常 您可以在任何 PL/SQL 块，函数、存储过程或者包中声明一个异常。 语法格式： exception_name EXCEPTION ; 有关语义信息，请参阅“异常声明”。 用户自定义异常必须被显示触发，有关异常触发的详细信息，详见显式触发异常 。 用户自定义异常可以与一个错误码进行绑定，具体语法为： PRAGMA EXCEPTION_INIT (exception, error_code) ; 其中 exception 是用户自定义的异常，error_code 是大于 -1000000 且小于 0 的整数，error_code 可以是系统预 定义异常的错误码。 注意: EXCEPTION_INIT 仅可为当前声明块中声明的自定义异常进行错误码绑定。 当为包声明中声明的自定义异常进行错误码绑定时，无法使用包名对异常名称进行修饰。即如下语法是错误的： PRAGMA EXCEPTION_INIT (package.exception, error_code) ; 12.4 重新声明预定义的异常 建议不要重新声明系统预定义的异常，即声明一个用户定义的异常名称，该名称是系统预定义的异常名称。（有 关系统预定义异常名称的列表，请参见系统预定义异常 。） 如果您重新声明了系统预定义的异常，您的本地声明将覆盖 STANDARD 包中的全局声明。为全局声明的异常 编写的异常处理程序将无法处理它，除非您使用包名 STANDARD 来限定它的名称。 示例 12-5 对此进行了说明 示例 12-5 重新声明预定义异常 304 第 12 章 异常处理 DROP TABLE IF EXISTS t CASCADE; CREATE TABLE t (c NUMBER(2,1)); 在下面的块中，INSERT 语句隐式引发了 VALUE_ERROR 异常，异常处理程序捕获并处理了这个异常。 set serverout on \set SQLTERM / DECLARE default_number NUMBER := 0; BEGIN INSERT INTO t VALUES(TO_NUMBER('100.001', '9G999')); EXCEPTION WHEN VALUE_ERROR THEN DBMS_OUTPUT.PUT_LINE('Substituting default value for invalid number.'); INSERT INTO t VALUES(default_number); END; / \set SQLTERM ; 结果： Substituting default value for invalid number. 以下块重新声明了预定义的异常 VALUE_ERROR 当 INSERT 语句隐式触发预定义异常 VALUE_ERROR 时， 异常处理程序不会处理它。 set serverout on \set SQLTERM / DECLARE default_number NUMBER := 0; value_error EXCEPTION; -- redeclare predefined exception BEGIN INSERT INTO t VALUES(TO_NUMBER('100.001', '9G999')); EXCEPTION WHEN VALUE_ERROR THEN DBMS_OUTPUT.PUT_LINE('Substituting default value for invalid number.'); INSERT INTO t VALUES(default_number); END; / \set SQLTERM ; 结果： 305 第 12 章 ERROR: numeric field overflow DETAIL: A field with precision 2, scale 1 must round to an absolute 异常处理 value less than 10^1. CONTEXT: SQL statement "INSERT INTO t VALUES(TO_NUMBER('100.001', '9G999'))" PL/SQL function inline_code_block line 5 at SQL statement 如果您在异常处理程序中使用包名 STANDARD 限定异常名称，则上述块中的异常处理程序将处理预定义的异 常 VALUE_ERROR: set serverout on \set SQLTERM / DECLARE default_number NUMBER := 0; value_error EXCEPTION; -- redeclare predefined exception BEGIN INSERT INTO t VALUES(TO_NUMBER('100.001', '9G999')); EXCEPTION WHEN STANDARD.VALUE_ERROR THEN DBMS_OUTPUT.PUT_LINE('Substituting default value for invalid number.'); INSERT INTO t VALUES(default_number); END; / \set SQLTERM ; 结果： Substituting default value for invalid number. 12.5 显式触发异常 要显式触发常，请使用 RAISE 语句或存储过程 RAISE_APPLICATION_ERROR。 12.5.1 RAISE 语句 RAISE 语句可以显示的触发一个异常。在异常处理程序之外，RAISE 语句必须指定异常名称。如果在异常处理 程序内部，且省略了异常名称，那么该 RAISE 语句将重新引发当前正在处理的异常。 语法格式： RAISE [ exception ]; 306 第 12 章 异常处理 其中 exception 可以是已定义的用户自定义异常，也可以是系统预定义异常。 省略 exception 的 RAISE 子句仅可在异常处理模块中使用。 关于 RAISE 子句的更多用法，详见RAISE 语句 。 12.5.1.1 使用 RAISE 语句触发用户自定义的异常 在示例 12-6 中，存储过程声明了一个名为 past_due 的异常，使用 RAISE 语句显式触发它，并使用异常处理程 序处理它。 示例 12-6 声明、触发和处理用户定义的异常 \set SQLTERM / CREATE PROCEDURE account_status ( due_date DATE, today DATE) AUTHID DEFINER IS past_due EXCEPTION; -- declare exception BEGIN IF due_date < today THEN RAISE past_due; -- explicitly raise exception END IF; EXCEPTION WHEN past_due THEN -- handle exception RAISE NOTICE 'Account past due.'; END; / \set SQLTERM ; 调用存储过程： \set SQLTERM / BEGIN account_status (TO_DATE('01-JUL-2010', 'DD-MON-YYYY'), TO_DATE('09-JUL-2010', 'DD-MON-YYYY')); END; / \set SQLTERM ; 输出结果： NOTICE:: Account past due. 307 第 12 章 12.5.1.2 异常处理 使用 RAISE 语句触发系统预定义的异常 系统预定义异常通常由系统运行时隐式触发，但也可以使用 RAISE 语句显式地触发它们。当一个预定义常拥有 对应的异常处理程序时，无论是显式触发还是隐式触发，都会触发异常处理程序对相应的异常进行处理。 在示例 12-7 中，存储过程不论显式或是隐式触发预定义异常 VALUE_ERROR，异常处理程序始终都会处理 它。 示例 12-7 触发系统预定义异常 DROP TABLE IF EXISTS t CASCADE; CREATE TABLE t (c NUMBER(2,1)); \set SQLTERM / CREATE PROCEDURE p (n NUMBER) AUTHID DEFINER IS default_number NUMBER := 0; BEGIN IF n < 0 THEN RAISE VALUE_ERROR; -- 显式触发 ELSE INSERT INTO t VALUES(TO_NUMBER('100.001', '9G999')); -- 隐式触发 END IF; EXCEPTION WHEN VALUE_ERROR THEN RAISE NOTICE 'Substituting default value for invalid number.'; INSERT INTO t VALUES(default_number); END; / \set SQLTERM ; 调用存储过程： \set SQLTERM / BEGIN p(-1); END; / \set SQLTERM ; 输出结果： NOTICE:: Substituting default value for invalid number. 再次调用存储过程： \set SQLTERM / BEGIN 308 第 12 章 异常处理 p(1); END; / \set SQLTERM ; 输出结果： NOTICE: Substituting default value for invalid number. 12.5.1.3 使用 RAISE 语句重新触发当前异常 在异常处理程序中，可以使用 RAISE 语句重新引发当前正在处理的异常。重新引发的异常会将异常传递给当前 块中的异常处理程序块，若当前块中无相应的异常处理块，则该异常会传播，详见异常传播 。在重新引发异常时， 可以省略异常名称。 在示例 12-8 中，异常处理从内部块开始，到外部块结束。外部块声明异常，因此异常对两个块中都可见，并且 每个块都有一个专门针对该异常的异常处理程序。内部块触发异常，其异常处理程序进行初步处理，然后重新引发异 常，将其传递给外部块以进行进一步处理。 示例 12-8 重新触发异常 \set SQLTERM / DECLARE salary_too_high EXCEPTION; current_salary NUMBER := 20000; max_salary NUMBER := 10000; erroneous_salary NUMBER; BEGIN BEGIN IF current_salary > max_salary THEN RAISE salary_too_high; -- raise exception END IF; EXCEPTION WHEN salary_too_high THEN -- start handling exception erroneous_salary := current_salary; RAISE NOTICE 'Salary % is out of range.', erroneous_salary; RAISE NOTICE 'Maximum salary is %.', max_salary; RAISE; -- reraise current exception (exception name is optional) END; EXCEPTION WHEN salary_too_high THEN -- finish handling exception current_salary := max_salary; 309 第 12 章 异常处理 RAISE NOTICE 'Revising salary from % to %.', erroneous_salary, current_salary; END; / \set SQLTERM ; 输出结果： NOTICE: Salary 20000 is out of range. NOTICE: Maximum salary is 10000. NOTICE: Revising salary from 20000 to 10000. 12.5.2 存储过程 RAISE_APPLICATION_ERROR 存储过程 RAISE_APPLICATION_ERROR 通常用来抛出一个用户自定义异常，并将错误码和错误信息传播给 调用者。 要调用 RAISE_APPLICATION_ERROR，请使用以下语法： RAISE_APPLICATION_ERROR (error_code, message); 其中 error_code 是 -20999 .. -20000 之间的整数，message 是长度为 2048 字节的字符串，大于该长度的字符会 被自动截断。 使用 RAISE_APPLICATION_ERROR 抛出的用户定义的异常必须已使用 PRAGMA EXCEPTION_INIT 分 配 error_code。 通过存储过程 RAISE_APPLICATION_ERROR 抛出的异常可以用 OTHERS 进行捕获处理，也可以通过绑定 了相同 error_code 的用户自定义异常进行捕获处理，详见用户自定义异常 。 在示例 12-9 中，一个匿名块中声明了一个名为 past_due 的异常，并为其分配了错误代码 -20000。然后调用了 一个存储过程，存储过程调用带有错误代码 -20000 和消息的存储过程 RAISE_APPLICATION_ERROR ，然后控 制权返回到匿名块异常处理部分。为了检索与异常关联的消息，匿名块中的异常处理程序调用 SQLERRM 函数，详 见检索异常信息 。 示例 12-9 使用 RAISE_APPLICATION_ERROR 引发用户定义的异常 \set SQLTERM / CREATE PROCEDURE account_status ( due_date DATE, today DATE ) AUTHID DEFINER IS BEGIN IF due_date < today THEN -- explicitly raise exception RAISE_APPLICATION_ERROR(-20000, 'Account past due.'); END IF; END; 310 第 12 章 异常处理 / \set SQLTERM ; 调用存储过程： \set SQLTERM / DECLARE past_due EXCEPTION; -- declare exception PRAGMA EXCEPTION_INIT (past_due, -20000); -- assign error code to exception BEGIN account_status (TO_DATE('01-JUL-2010', 'DD-MON-YYYY'), TO_DATE('09-JUL-2010', 'DD-MON-YYYY')); -- invoke procedure EXCEPTION WHEN past_due THEN -- handle exception RAISE NOTICE '%', SQLERRM(-20000); END; / \set SQLTERM ; 输出结果： NOTICE: ERRCODE-20000: Account past due. 12.6 异常传播 如果在一个没有异常处理程序的块中抛出异常，则该异常会进行传播。即该异常会在连续的封闭块中重现，直到 被某个具有对应异常处理程序的块捕获处理或者没有封闭块为止。若一直没有对应的异常处理程序，那么 PL/SQL 会将未处理的异常返回给调用者或者返回到主机环境中，该异常也会成为当前程序执行的结果。 用户自定义的异常可以传播到超出其声明的范围（即超出声明它的块），但由于其名称在其超出的范围内不存 在。因此，超出其范围后，用户自定义的异常只能使用 OTHERS 来捕获处理。 在示例 12-10 中，内部块声明了一个名为 past_due 的异常，它没有异常处理程序。当内部块引发 past_due 时， 异常传播到外部块，其中不存在名为 past_due 的异常处理程序。外部块使用 OTHERS 异常处理程序处理异常。如 果外部块不处理用户定义的异常，则会发生错误，如示例 12-11 所示。 示例 12-10 处理超出范围传播的异常 \set SQLTERM / CREATE OR REPLACE PROCEDURE p AUTHID DEFINER AS BEGIN DECLARE 311 第 12 章 past_due EXCEPTION; due_date DATE := trunc(SYSDATE) - 1; todays_date DATE := trunc(SYSDATE); 异常处理 BEGIN IF due_date < todays_date THEN RAISE past_due; END IF; END; EXCEPTION WHEN OTHERS THEN NULL; END; / \set SQLTERM ; 示例 12-11 未处理传播超出范围的异常 \set SQLTERM / BEGIN DECLARE past_due EXCEPTION; due_date DATE := trunc(SYSDATE) - 1; todays_date DATE := trunc(SYSDATE); BEGIN IF due_date < todays_date THEN RAISE past_due; END IF; END; END; / \set SQLTERM ; 结果： ERROR: unhandled exception "past_due" CONTEXT: 12.6.1 PL/SQL function inline_code_block line 8 at RAISE 未传播的异常 异常在块中被触发并捕获处理，未发生传播，如示例 12-12 所示。 示例 12-12 未传播的异常 312 第 12 章 异常处理 \set SQLTERM / CREATE OR REPLACE PROCEDURE p AS BEGIN DECLARE past_due EXCEPTION; BEGIN RAISE past_due; EXCEPTION WHEN past_due THEN RAISE NOTICE 'Exception Does Not Propagate'; END; END; / \set SQLTERM ; 调用存储过程： CALL P(); 输出结果： NOTICE: Exception Does Not Propagate 12.6.2 从内部块传播到外部块的异常 异常在内部块中被触发，但未被捕获，传播到上层块中被捕获处理，如示例 12-13 所示。 示例 12-13 从内部块传播到外部块的异常 \set SQLTERM / CREATE OR REPLACE PROCEDURE p AS BEGIN DECLARE past_due EXCEPTION; BEGIN RAISE past_due; END; EXCEPTION WHEN OTHERS THEN RAISE NOTICE 'Exception Propagates from Inner Block to Outer Block'; END; 313 第 12 章 异常处理 / \set SQLTERM ; 调用存储过程： CALL P(); 输出结果： NOTICE: Exception Propagates from Inner Block to Outer Block 声明中触发的异常的传播 12.6.3 当前块中声明阶段抛出的异常会直接传播到上层块或者主机环境，而不是当前块。因此，声明阶段的异常处理程 序必须在调用块中，而不是在声明的当前块中。 在示例 12-14 中，VALUE_ERROR 异常处理程序与引发 VALUE_ERROR 的声明位于同一块中。因为异常会 立即传播到主机环境，所以异常处理程序不会处理它。 示例 12-15 与示例 12-14 类似，只是上层块中处理了内部块中的声明中引发的 VALUE_ERROR 异常。 示例 12-14 声明中触发的异常未处理 \set SQLTERM / DECLARE credit_limit CONSTANT NUMBER(3) := 5000; BEGIN NULL; EXCEPTION WHEN VALUE_ERROR THEN RAISE NOTICE 'Exception raised in declaration.'; END; / \set SQLTERM ; 输出结果： ERROR: numeric field overflow DETAIL: A field with precision 3, scale 0 must round to an absolute value less than 10^3. CONTEXT: PL/SQL function inline_code_block line 3 during statement block local variable initialization 示例 12-15 声明中触发的异常由上层块处理 314 第 12 章 异常处理 \set SQLTERM / BEGIN DECLARE credit_limit CONSTANT NUMBER(3) := 5000; BEGIN NULL; END; EXCEPTION WHEN VALUE_ERROR THEN RAISE NOTICE 'Exception raised in declaration.'; END; / \set SQLTERM ; 输出结果： NOTICE: 12.6.4 Exception raised in declaration. 异常处理程序中抛出的异常传播 异常处理阶段抛出的异常与声明阶段抛出的异常一样，会直接传播到上层块或者主机环境中。因此，异常处理程 序必须位于上层块或者调用块中。 在示例 12-16 中，当 n 为零时，计算 1/n 会引发预定义的异常 ZERO_DIVIDE，并且控制权转移到同一块中的 ZERO_DIVIDE 异常处理程序。当异常处理程序触发 ZERO_DIVIDE 时，异常会立即传播到调用程序。调用者不 处理异常，所以 PL/SQL 向主机环境返回一个未处理的异常错误。 示例 12-17 与示例 12-16 类似，只是当存储过程向调用者返回未处理的异常错误时，调用者会处理它。 示例 12-18 与示例 12-17 类似，只是由上层块处理内部块中的异常处理程序引发的异常。 在示例 12-19 中，存储过程中的异常处理部分具有用于处理用户自定义异常 i_is_one 和预定义异常 ZERO_DIVIDE 的异常处理程序。当 i_is_one 异常处理程序引发 ZERO_DIVIDE 时，异常会立即传播到调用程 序中（因此，ZERO_DIVIDE 异常处理程序不会处理它）。调用者不处理异常，所以 PL/SQL 向主机环境返回一个 未处理的异常错误。 示例 12-20 与示例 12-19 类似，只是上层中块处理了 i_is_one 异常处理程序引发的 ZERO_DIVIDE 异常。 示例 12-16 异常处理程序中触发的异常未处理 \set SQLTERM / CREATE OR REPLACE PROCEDURE print_reciprocal (n NUMBER) AUTHID DEFINER IS BEGIN RAISE NOTICE '%', 1/n; 315 第 12 章 异常处理 EXCEPTION WHEN ZERO_DIVIDE THEN RAISE NOTICE 'Error:'; RAISE NOTICE '% is undefined', 1/n; END; / \set SQLTERM ; 调用存储过程： \set SQLTERM / BEGIN -- invoking block print_reciprocal(0); END; / \set SQLTERM ; 输出结果： NOTICE: Error: ERROR: division by zero CONTEXT: PL/SQL function print_reciprocal(numeric) line 7 at RAISE SQL statement "CALL print_reciprocal(0)" PL/SQL function inline_code_block line 2 at CALL 示例 12-17 异常处理程序中引发的异常由调用程序处理 \set SQLTERM / CREATE OR REPLACE PROCEDURE print_reciprocal (n NUMBER) AUTHID DEFINER IS BEGIN RAISE NOTICE '%', 1/n; EXCEPTION WHEN ZERO_DIVIDE THEN RAISE NOTICE 'Error:'; RAISE NOTICE '% is undefined', 1/n; END; / \set SQLTERM ; 调用存储过程： \set SQLTERM / BEGIN -- invoking block print_reciprocal(0); EXCEPTION WHEN ZERO_DIVIDE THEN -- handles exception raised in exception handler 316 第 12 章 异常处理 RAISE NOTICE '1/0 is undefined.'; END; / \set SQLTERM ; 输出结果： NOTICE: Error: NOTICE: 1/0 is undefined. 示例 12-18 异常处理程序中引发的异常由上层块处理 set serverout on \set SQLTERM / CREATE OR REPLACE PROCEDURE print_reciprocal (n NUMBER) AUTHID DEFINER IS BEGIN BEGIN DBMS_OUTPUT.PUT_LINE(1/n); EXCEPTION WHEN ZERO_DIVIDE THEN DBMS_OUTPUT.PUT_LINE('Error in inner block:'); DBMS_OUTPUT.PUT_LINE(1/n || ' is undefined.'); END; EXCEPTION WHEN ZERO_DIVIDE THEN -- handles exception raised in exception handler DBMS_OUTPUT.PUT('Error in outer block: '); DBMS_OUTPUT.PUT_LINE('1/0 is undefined.'); END; / \set SQLTERM ; 调用存储过程： \set SQLTERM / BEGIN print_reciprocal(0); END; / \set SQLTERM ; 输出结果： 317 第 12 章 异常处理 Error in inner block: Error in outer block: 1/0 is undefined. 示例 12-19 未处理异常处理程序中引发的异常 set serverout on \set SQLTERM / CREATE OR REPLACE PROCEDURE descending_reciprocals (n INTEGER) AUTHID DEFINER IS i INTEGER; i_is_one EXCEPTION; BEGIN i := n; LOOP IF i = 1 THEN RAISE i_is_one; ELSE DBMS_OUTPUT.PUT_LINE('Reciprocal of ' || i || ' is ' || 1/i); END IF; i := i - 1; END LOOP; EXCEPTION WHEN i_is_one THEN DBMS_OUTPUT.PUT_LINE('1 is its own reciprocal.'); DBMS_OUTPUT.PUT_LINE('Reciprocal of ' || TO_CHAR(i-1) || ' is ' || TO_CHAR(1/(i-1))); WHEN ZERO_DIVIDE THEN DBMS_OUTPUT.PUT_LINE('Error:'); DBMS_OUTPUT.PUT_LINE(1/n || ' is undefined'); END; / \set SQLTERM ; 调用存储过程： \set SQLTERM / BEGIN descending_reciprocals(3); END; / \set SQLTERM ; 输出结果： 318 第 12 章 ERROR: 异常处理 division by zero CONTEXT: SQL statement "CALL DBMS_OUTPUT.PUT_LINE('Reciprocal of ' || TO_CHAR(i-1) || ' is ' || TO_CHAR(1/(i-1)))" PL/SQL function descending_reciprocals(integer) line 17 at CALL SQL statement "CALL descending_reciprocals(3)" PL/SQL function inline_code_block line 2 at CALL Reciprocal of 3 is 0 Reciprocal of 2 is 0 1 is its own reciprocal. 示例 12-20 异常处理程序中引发的异常由上层块处理 set serverout on \set SQLTERM / CREATE OR REPLACE PROCEDURE descending_reciprocals (n INTEGER) AUTHID DEFINER IS i INTEGER; i_is_one EXCEPTION; BEGIN BEGIN i := n; LOOP IF i = 1 THEN RAISE i_is_one; ELSE DBMS_OUTPUT.PUT_LINE('Reciprocal of ' || i || ' is ' || 1/i); END IF; i := i - 1; END LOOP; EXCEPTION WHEN i_is_one THEN DBMS_OUTPUT.PUT_LINE('1 is its own reciprocal.'); DBMS_OUTPUT.PUT_LINE('Reciprocal of ' || TO_CHAR(i-1) || ' is ' || TO_CHAR(1/(i-1))); WHEN ZERO_DIVIDE THEN DBMS_OUTPUT.PUT_LINE('Error:'); DBMS_OUTPUT.PUT_LINE(1/n || ' is undefined'); END; EXCEPTION WHEN ZERO_DIVIDE THEN -- handles exception raised in exception handler 319 第 12 章 异常处理 DBMS_OUTPUT.PUT_LINE('Error:'); DBMS_OUTPUT.PUT_LINE('1/0 is undefined'); END; / \set SQLTERM ; 调用存储过程： \set SQLTERM / BEGIN descending_reciprocals(3); END; / \set SQLTERM ; 输出结果： Reciprocal of 3 is 0 Reciprocal of 2 is 0 1 is its own reciprocal. Error: 1/0 is undefined 12.7 未处理的异常 异常在内部块中被触发，但未被捕获，且传播到外层块中。仍未被捕获，最终返回到主机环境中。 在打开单语句回滚的情况下，如果程序因为未处理的异常退出，PL/SQL 不会回滚程序所做的数据库更改。 提示: 通过在每个 PL/SQL 程序的顶层包含一个 OTHERS 异常处理程序来避免未处理的异常。 示例 12-21 未处理异常 \set SQLTERM / CREATE OR REPLACE PROCEDURE p AS BEGIN DECLARE past_due EXCEPTION; PRAGMA EXCEPTION_INIT (past_due, -4910); BEGIN RAISE past_due; 320 第 12 章 异常处理 END; END; / \set SQLTERM ; 调用存储过程： CALL P(); 输出结果： ERROR: ERRCODE-4910: non-KingbaseES exception CONTEXT: PL/SQL function p() line 7 at RAISE 12.8 检索异常信息 在异常处理程序中，对于正在处理的异常： • 您可以使用SQLCODE 函数 中描述的 PL/SQL 函数 SQLCODE 检索错误代码。 • 您可以使用以下任一方法检索错误消息： – PL/SQL 函数 SQLERRM，详见SQLERRM 函数 。 该函数最多返回 512 字节，这是数据库错误消息的最大长度（包括错误代码、详细的错误信息等）。 – PL/SQL 系统包 DBMS_UTILITY 中的包函数 DBMS_UTILITY.FORMAT_ERROR_STACK 此函数返回完整的错误堆栈，最多 2000 个字节。 – KingbaseES 数据库提供的其它异常信息检索方式。 另请参阅: PL/SQL 系统包中有关 DBMS_UTILITY.FORMAT_ERROR_BACKTRACE 函数的信息，该函数返回引发异 常时的调用堆栈，即使该程序是从上层块的异常处理程序中被调用的 12.8.1 SQLSTATE 变量 异常发生时，调用 SQLSTATE 变量返回当前异常对应的 SQL 标准错误码（五位字符串）。 12.8.2 SQLERRM 变量 异常发生时，调用 SQLERRM 变量返回当前异常相应的错误信息。 321 第 12 章 异常处理 注意: 变量 SQLSTATE 和 SQLERRM 仅在异常处理模块中可用。 12.8.3 SQLCODE 函数 语法： INT SQLCODE () ; 说明： 检索异常兼容 ORACLE 的错误码（负整数）。在异常处理程序之外，SQLCODE 函数始终返回 0，表示程序正 常编译执行。 对于系统预定义的异常，错误码是关联相关异常错误的编号，该数字通常为一个负整数。 对于用户自定义的异常，数字代码为 +1（默认值）或者通过 EXCEPTION_INIT 方法绑定的错误码。 12.8.4 SQLERRM 函数 语法： TEXT SQLERRM ( [ error_code ] ) ; 说明： 检索异常错误信息。 其中 error_code 为数据库异常对应的错误码，省略该参数时返回当前正在处理的异常错误信息。当 error_code 不是一个标准的错误码或者不存在时，都会进行相应的错误提示。 12.8.5 ERROR_LINE 函数 语法： INT ERROR_LINE () ; 说明： 返回抛出异常的函数（存储过程）中抛出异常的位置行号，若没有在异常处理块中，则返回 NULL。 12.8.6 ERROR_PROCEDURE 函数 语法： 322 第 12 章 异常处理 VARCHAR(128) ERROR_PROCEDURE () ; 说明： 返回抛出异常的函数（存储过程）或触发器的名称，若没有在异常处理块中，则返回 NULL。 12.8.7 ERROR_NUMBER 函数 语法： INT ERROR_NUMBER () ; 说明： 返回抛出异常的错误号，与 SQLCODE 相同。若没有在异常处理块中，则返回 NULL。 12.8.8 ERROR_MESSAGE 函数 语法： VARCHAR(4000) ERROR_MESSAGE () ; 说明： 返回异常消息的完整文本，与 SQLERRM 相同。若没有在异常处理块中，则返回 NULL。 12.8.9 ERROR_STATE 函数 语法： INT ERROR_STATE () ; 说明： 返回异常状态号，在异常处理块中始终为 1。若没有在异常处理块中，则返回 NULL。 12.8.10 ERROR_SEVERITY 函数 语法： INT ERROR_SEVERITY () ; 323 第 12 章 异常处理 说明： 返回异常的严重级别，在异常处理块中始终为 20。若没有在异常处理块中，则返回 NULL。 12.8.11 SYS_GET_PREDEFINED_EXCEPTION_DETAIL 函数 语法： SETOF RECORD SYS_GET_PREDEFINED_EXCEPTION_DETAIL ( OUT exception_name TEXT, OUT sqlstate TEXT, OUT sqlcode INTEGER) ; 说明： 返回所有的预定义异常的相关信息，exception_name 为预定义异常名称，sqlstate 为预定义异常的 SQL 标准错 误码，sqlcode 为预定义异常的 ORACLE 兼容错误码，如示例 12-23 所示。 示例 12-22 SQLCODE 函数和 SQLERRM 函数 set serverout on \set SQLTERM / CREATE OR REPLACE PROCEDURE p AUTHID DEFINER AS i INT; v_code NUMBER; v_errm VARCHAR2(64); BEGIN i := 1/0; EXCEPTION WHEN OTHERS THEN v_code := SQLCODE; v_errm := SUBSTR(SQLERRM, 1, 64); DBMS_OUTPUT.PUT_LINE ('Error code ' || v_code || ': ' || v_errm); END; / \set SQLTERM ; 调用存储过程： CALL P(); 输出结果： 324 第 12 章 异常处理 Error code -1476: division by zero 示例 12-23 SYS_GET_PREDEFINED_EXCEPTION_DETAIL 函数 SELECT * FROM SYS_GET_PREDEFINED_EXCEPTION_DETAIL(); 输出结果： exception_name | sqlstate | sqlcode ------------------------------------------------------+----------+--------sql_statement_not_yet_complete | 03000 | -10000 connection_exception | 08000 | -10001 connection_does_not_exist | 08003 | -10002 tablespace_is_readonly | F1001 | -10243 tablespace_is_write | F1002 | -10244 tablespace_operation_notsupport | F1003 | -10245 ... 异常捕获 12.9 异常捕获是异常处理程序的一部分，通常通过 EXCEPTION 子句对异常进行捕获操作。 通常情况下，一个语句引发异常，将导致当前语句退出执行，与该语句处于同一个事务内的语句也会被回滚。为 了处理异常，PL/SQL 块中可以通过 EXCEPTION 子句来捕获异常，进行相应处理，这时，处于同一个事务块中已 经执行的的语句不会被回滚，但当前语句被回滚。 KingbaseES 的 PL/SQL 中，当一条语句执行后，控制权将移交到下一条语句，但是当异常触发后，KingbaseES 的 PL/SQL 将立即捕获、处理异常。 语法格式： [ DECLARE [ < VariableDeclaration > ] [ < CursorDeclaration > ] [ < UserDefinedExceptionDeclaration > ] ] BEGIN < Statements > EXCEPTION WHEN ExceptionName [ OR ExceptionName... ] THEN < HandlerStatements >; [ WHEN ExceptionName[ OR ExceptionName... ] THEN < HandlerStatements >; 325 第 12 章 异常处理 ... ] END; 功能： 捕获异常。 使用说明： 1. ExceptionName，异常的名称，系统预先定义或用户自定义异常，直接使用即可，异常名称大小写均可，如 division_by_zero ，表示发生” 除零” 错误。异常名是与大小写无关的，一个异常名也可以通过 SQLSTATE 代码 指定，例如以下是等价的： WHEN division_by_zero THEN ... WHEN SQLSTATE '22012' THEN ... 2. ExceptionName 可以使用关键字 OTHERS ，用于处理在 OTHERS 之前没有显示指定处理的异常。 3. 如果没有发生异常，这种形式的块只是简单地执行所有 Statements ，然后转到 END 之后的下一个语句。但是 如果在 Statements 内发生了一个错误，则会放弃对 Statements 的进一步处理，然后转到 EXCEPTION 子句。 系统会在异常条件列表中匹配当前触发的异常。如果匹配成功，则执行对应的 HandlerStatements ，执行完成 后转到 END 之后的下一个语句。如果匹配失败，则该异常就会传播出去，就像没有 EXCEPTION 子句一样。 异常可以被外层闭合块中的 EXCEPTION 子句捕获，如果没有 EXCEPTION 则中止该程序的执行。 4. 如果在选中的 HandlerStatements 内触发新的异常，那么它不能被当前这个 EXCEPTION 子句捕获，而是被传 播出去。由外层的 EXCEPTION 子句捕获它。 5. 当一个异常被 EXCEPTION 子句捕获时，PL/SQL 函数的局部变量会保持异常触发时的值，但是该块中所有对 数据库状态的改变都会被回滚。如示例 12-24 所示： 6. 如果 KingbaseES 数据库打开了单语句回滚的参数（ora_statement_level_rollback），触发异常的语句不会回 滚之前已经执行完成的操作。如示例 12-25 所示： 7. 进入和退出一个包含 EXCEPTION 子句的块要比不包含 EXCEPTION 的块开销大的多。因此，尽量在必要的 时候使用 EXCEPTION 子句。 示例 12-24 异常触发导致 PL/SQL 函数内已完成的操作被回滚 DROP TABLE IF EXISTS mytab CASCADE; CREATE TABLE mytab(firstname TEXT, lastname TEXT); INSERT INTO mytab(firstname, lastname) VALUES('Tom', 'Jones'); \set SQLTERM / CREATE OR REPLACE PROCEDURE PROC() AS x int := 1; BEGIN UPDATE mytab SET firstname = 'Joe' WHERE lastname = 'Jones'; x := x / 0; EXCEPTION 326 第 12 章 异常处理 WHEN division_by_zero THEN RAISE NOTICE 'caught division_by_zero'; END; / \set SQLTERM ; 调用函数： CALL PROC(); NOTICE: caught division_by_zero 查询更改: SELECT * FROM mytab; firstname | lastname -----------+---------Tom | Jones (1 row) 当存储过程执行到对 x 赋值的地方时，它会触发一个 division_by_zero 异常，同时这个异常将被 EXCEPTION 子句捕获。不过此时 ora_statement_level_rollback 为 off，该块之前的 UPDATE 操作将不会被回滚，因此最终的结 果是数据库包含’Tom Jones’ 但不包含’Joe Jones’ 。 示例 12-25 异常触发未影响 PL/SQL 函数内已完成的操作 set ora_statement_level_rollback to on; DROP TABLE IF EXISTS mytab CASCADE; CREATE TABLE mytab(firstname TEXT, lastname TEXT); INSERT INTO mytab(firstname, lastname) VALUES('Tom', 'Jones'); \set SQLTERM / CREATE OR REPLACE PROCEDURE PROC() AS x int := 1; BEGIN UPDATE mytab SET firstname = 'Joe' WHERE lastname = 'Jones'; x := x / 0; EXCEPTION WHEN division_by_zero THEN RAISE NOTICE 'caught division_by_zero'; END; / \set SQLTERM ; 327 第 12 章 异常处理 调用函数： CALL PROC(); NOTICE: caught division_by_zero 查询更改: SELECT * FROM mytab; firstname | lastname -----------+---------Joe | Jones (1 row) 12.10 获取异常状态信息 在异常处理模块中，除系统变量和系统函数外，KingbaseES 也支持使用 GET STACKED DIAGNOSTICS 命令 获取有关当前异常的状态信息，该命令的语法为： GET STACKED DIAGNOSTICS variable { = | := } item [ , ... ]; 使用说明： 每个 item 都是一个异常相关状态项。下表中显示了当前可用的状态项。 328 第 12 章 异常处理 表 12.10.1: 异常状态项 名称 类型 描述 RETURNED_SQLSTATE TEXT 该异常的 SQLSTATE 错误代码 COLUMN_NAME TEXT 与异常相关的列名 CONSTRAINT_NAME TEXT 与异常相关的约束名 SYS_DATATYPE_NAME TEXT 与异常相关的数据类型名 MESSAGE_TEXT TEXT 该异常的主要消息的文本 TABLE_NAME TEXT 与异常相关的表名 SCHEMA_NAME TEXT 与异常相关的模式名 SYS_EXCEPTION_DETAIL TEXT 该异常的详细消息文本 SYS_EXCEPTION_HINT TEXT 该异常的提示消息文本 SYS_EXCEPTION_CONTEXT TEXT 描述产生异常时调用栈的文本行 如果触发的异常无法为某个状态项设置值，则对应的状态项将返回一个空字符串。 DECLARE text_var1 TEXT; text_var2 TEXT; text_var3 TEXT; BEGIN -- 某些可能导致异常的处理 ... EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS text_var1 = MESSAGE_TEXT, text_var2 = SYS_EXCEPTION_DETAIL, text_var3 = SYS_EXCEPTION_HINT; END; 12.11 获取执行位置信息 GET DIAGNOSTICS 命令可获取有关当前执行状态的信息。该命令的 SYS_CONTEXT 状态项可用于记录当前 执行位置。状态项 SYS_CONTEXT 会返回一个文本字符串，该字符串为一个描述该调用栈的多行文本。第一行会 指向当前函数以及当前正在执行 GET DIAGNOSTICS 命令的位置。第二行及其后的行表示调用栈中更上层的调用位 置信息。 329 第 12 章 异常处理 语法格式： GET DIAGNOSTICS stack = SYS_CONTEXT; 示例 12-26 获取执行位置信息 \set SQLTERM / CREATE OR REPLACE FUNCTION outer_func RETURN integer AS BEGIN RETURN inner_func(); END; / \set SQLTERM ; \set SQLTERM / CREATE OR REPLACE FUNCTION inner_func RETURN integer AS stack text; BEGIN GET DIAGNOSTICS stack = SYS_CONTEXT; RAISE NOTICE E'--- Call Stack ---\n%', stack; RETURN 1; END; / \set SQLTERM ; SELECT outer_func(); NOTICE: --- Call Stack --- PL/SQL function INNER_FUNC() line 4 at GET DIAGNOSTICS PL/SQL function OUTER_FUNC() line 3 at RETURN OUTER_FUNC -----------1 (1 row) GET STACKED DIAGNOSTICS ... SYS_EXCEPTION_CONTEXT 语句返回类似的栈跟踪，但是 SYS_EXCEPTION_CONTEXT 记录的是检测到异常的位置而不是当前位置。 12.12 检查断言 ASSERT 语句是一种向 PL/SQL 函数中插入调试检查的方法。 语法格式： 330 第 12 章 异常处理 ASSERT condition [ , message ]; 使用说明： a. condition 是一个布尔表达式，该表达式的计算结果被断言为真。如果结果为真，ASSERT 语句不会对程序产生 任何影响。但如果结果是假或者空，那么将发生一个 ASSERT_FAILURE 异常（如果在计算 condition 时发生 错误，会抛出一个对应的普通异常）。 b. 如果 message 参数非空，则在断言失败时，message 会被用来替换默认的错误消息文本（”assertion failed”）。 message 表达式在断言成功的情况下不会对程序产生任何影响。 c. 通过配置参数 plsql.check_asserts 可以启用或者禁用断言测试，这个参数为布尔值且默认为 on 。如果这个参数 值被设置为 off ，则 ASSERT 语句什么也不做。 d. ASSERT 是为了检测程序的 bug，而不是报告普通的错误情况。如果要报告普通错误，请使用前面介绍 的RAISE 语句 。 331 第 13 章 PL/SQL 优化和调优 13章 PL/SQL 优化和调优 第 本章说明 PL/SQL 编译器如何优化代码，以及如何编写高效的 PL/SQL 代码和改进现有的 PL/SQL 代码。 另请参阅: 《KingbaseES 数据库开发指南》，了解游标变量的缺点 13.1 最小化 CPU 开销 13.1.1 调优 SQL 语句 PL/SQL 程序运行缓慢的最常见原因是 SQL 语句缓慢。要使 PL/SQL 程序中的 SQL 语句尽可能高效： • 使用适当的索引。 有关详细信息，请参阅《KingbaseES 数据库性能调优指南》。 • 使用查询提示来避免不必要的全表扫描。 有关详细信息，请参阅《KingbaseES SQL 语言参考手册》。 • 使用以下方法分析 SQL 语句的执行计划和性能： – 具有调试 SQL 能力的工具 KWR 有关详细信息，请参阅《KingbaseES 数据库性能调优指南》。 • 使用批量 SQL，这是 PL/SQL 功能，可最大限度地减少 PL/SQL 和 SQL 之间通信的性能开销。 有关详细信息，请参阅“批量 SQL 和批量绑定 ”。 13.1.2 优化在查询中的函数调用 查询中调用的函数可能会运行数百万次。应该尽量避免不必要的函数，使调用尽可能高效。 332 第 13 章 PL/SQL 优化和调优 在查询中的表上创建基于函数的索引。CREATE INDEX 语句可能需要一段时间，但查询可以运行得更快，因为 每行的函数值都以缓存。 如果查询中将表上的一列传递给函数，则该查询不能在该列上使用用户创建的索引，因此查询可能会为表的每一 行（可能非常大）调用该函数。要最小化函数调用的数量，请使用嵌套查询。让内部查询将结果集过滤为少量行，并 让外部查询仅为这些行调用函数。 另请参阅: 《KingbaseES SQL 语言参考手册》以获取有关 CREATE INDEX 语句语法的信息 示例 13-1 嵌套查询提高了性能 在此示例中，两个查询生成相同的结果集，但第二个查询比第一个查询更有效。（在示例中，时间和时间差非常 小，因为 STUDENT 表非常小。对于非常大的表，它们会很重要。） \set SQLTERM / DECLARE begin_time TIMESTAMP; end_time TIMESTAMP; BEGIN begin_time := clock_timestamp(); FOR item IN ( SELECT DISTINCT(score) FROM student ORDER BY score ) LOOP dbms_output.put_line('student score: '|| item.score); END LOOP; raise notice 'time = %', clock_timestamp() - begin_time; begin_time := clock_timestamp(); FOR item IN ( SELECT score FROM (SELECT DISTINCT score FROM student) ORDER BY score ) LOOP IF item.score IS NOT NULL THEN dbms_output.put_line('student score: '|| item.score); END IF; END LOOP; raise notice 'time = %', clock_timestamp() - begin_time; 333 第 13 章 PL/SQL 优化和调优 END; / \set SQLTERM ; 结果类似于： NOTICE: time = 00:00:00.007212 NOTICE: time = 00:00:00.004924 ANONYMOUS BLOCK 13.1.3 调优循环语句中的 SQL 语句 因为 PL/SQL 应用程序通常是围绕循环构建的，所以优化循环本身和其中的代码非常重要。 如果您必须多次遍历结果集，或者在遍历结果集时发出其他查询，则可以更改原始查询以得到想要的结果。可以 结合多个查询的 SQL 集合运算符，如《KingbaseES SQL 语言参考手册》所述。 同时还可以使用子查询在多个阶段进行过滤和排序——请参阅处理带有子查询的查询结果集 。 另请参阅: 批量 SQL 和批量绑定 13.1.4 调优计算密集型 PL/SQL 代码 13.1.4.1 在性能关键代码中避免约束子类型 在性能关键代码中，避免使用受约束的子类型（在“约束子类型 ”中描述）。对受约束子类型的变量或参数的 每次分配都需要在运行时进行额外检查，以确保要分配的值不违反约束。 另请参阅: PL/SQL 预定义类型 包括预定义的约束子类型 13.1.4.2 最小化隐式数据类型转换 在程序运行时，如有必要，PL/SQL 会隐式（自动）在不同的数据类型之间进行转换。例如，如果您将 INTEGER 变量分配给 NUMBER 变量，那么 PL/SQL 会将 INTEGER 值转换为 NUMBER 值（因为值的内部表示不 同）。 尽可能减少隐式转换。例如： • 如果要将变量插入表列或从表列中分配值，则为变量赋予与表列相同的数据类型。 334 第 13 章 PL/SQL 优化和调优 提示: 使用%TYPE 属性声明变量，如“%TYPE 属性 ”中所述。 • 使每个文本的数据类型与分配给它的变量或它出现的表达式具有相同的数据类型。 • 将值从 SQL 数据类型转换为 PL/SQL 数据类型，然后在表达式中使用转换后的值。 例如，将 NUMBER 值转换为 PLS_INTEGER 值，然后 PLS_INTEGER 在表达式中使用这些值。 • 在将一种 SQL 数据类型的值分配给另一种 SQL 数据类型的变量之前，使用 SQL 转换函数将源值显式转换为目 标数据类型（有关 SQL 转换函数的信息，请参阅《KingbaseES SQL 语言参考手册》）。 • 使用接受不同数据类型参数的版本重载您的子程序，并针对其参数类型优化每个版本。有关重载子程序的信 息，请参阅子程序的重载 。 另请参阅: • 《KingbaseES SQL 语言参考手册》，了解有关 SQL 数据类型（也是 PL/SQL 数据类型）的隐式转换的信息 • 具有相同数据类型簇的基类型的子类型 13.1.5 使用 SQL 字符函数 SQL 有许多高度优化的字符函数，它们使用比 PL/SQL 代码更高效的低级代码。使用这些函数而不是编写 PL/ SQL 代码来做同样的事情。 另请参阅: • 《KingbaseES SQL 语言参考手册》，了解有关返回字符值的 SQL 字符函数的信息 • 《KingbaseES SQL 语言参考手册》，了解有关返回数值的 SQL 字符函数的信息 13.1.6 将最简单的条件测试放在首位 PL/SQL 在确定结果后立即停止计算逻辑表达式。尽可能将最简单的条件放在逻辑表达式中，从而利用这种短 路求值。例如，在测试函数返回值之前测试 PL/SQL 变量的值，这样如果变量测试失败，PL/SQL 就不需要调用函 数： IF bool_variable OR (number > 100) OR bool_function(parameter) END IF ... 另请参阅: 短路计算 335 第 13 章 PL/SQL 优化和调优 13.2 批量 SQL 和批量绑定 批量 SQL 最小化了 PL/SQL 和 SQL 之间通信的性能开销。构成批量 SQL 的 PL/SQL 特性是 FORALL 语句 和 BULK COLLECT 子句。为出现在 SQL 语句中的 PL/SQL 变量赋值称为绑定。 PL/SQL 和 SQL 通信如下：为了运行 SELECT INTO 或 DML 语句，PL/SQL 引擎将查询语句或 DML 语句发 送到 SQL 引擎。SQL 引擎运行查询语句或 DML 语句并将结果返回给 PL/SQL 引擎。 FORALL 语句将 DML 语句从 PL/SQL 分批发送到 SQL，而不是一次一条语句。BULK COLLECT 子句将结 果从 SQL 分批返回到 PL/SQL，而不是一次返回一条结果。如果查询语句或 DML 语句影响四条或更多结果集，则 批量 SQL 可以显着提高性能。 注意: 不能对远程表执行批量 SQL。 PL/SQL 绑定操作分为以下几类： 绑定类 绑定条件 别 内绑定 INSERT、UPDATE 或 MERGE 语句在 PL/SQL 中或在 host 变量中使用时 外绑定 INSERT、UPDATE 或 DELETE 语句的 RETURNING INTO 子句将数据库值分配给 PL/SQL 或 host 变量时 定义 当 SELECT 或 FETCH 语句将数据库值分配给 PL/SQL 或 host 变量时 对于内绑定和外绑定，批量 SQL 使用批量绑定；也就是说，它一次绑定整个值的集合。对于 n 个元素的集合， 批量 SQL 使用单个操作来执行相当于 n 个 SELECT INTO 或 DML 语句的操作。使用批量 SQL 的查询可以返回任 意数量的行，而无需为每一行使用 FETCH 语句。 注意: 并行 DML 不能使用批量 SQL 13.2.1 FORALL 语句 FORALL 语句是批量 SQL 的一项功能，它将 DML 语句从 PL/SQL 批量发送到 SQL，而不是一次一条语句。 要理解 FORALL 语句，首先考虑示例 13-2 中的 FOR LOOP 语句。它一次将这些 DML 语句从 PL/SQL 发送 到 SQL： DELETE FROM student WHERE id = 10; DELETE FROM student WHERE id = 30; DELETE FROM student WHERE id = 70; 336 第 13 章 PL/SQL 优化和调优 现在考虑示例 13-3 中的 FORALL 语句。它将相同的三个 DML 语句从 PL/SQL 批量发送到 SQL。 FORALL 语句通常比等效的 FOR LOOP 语句快得多。但是，一个 FOR LOOP 语句可以包含多个 DML 语 句，而一个 FORALL 语句只能包含一个。FORALL 语句发送给 SQL 的一批 DML 语句的不同之处仅在于它们的 VALUES 和 WHERE 子句。这些子句中的值必须来自现有的填充集合。 注意: FORALL 语句中的 DML 语句可以引用多个集合，但性能优势仅适用于使用 FORALL 索引变量作为索引的集 合引用。 示例 13-4 将相同的集合元素插入到两个数据库表中，对第一个表使用 FOR LOOP 语句，对第二个表使用 FORALL 语句，并显示每个语句需要多长时间。（时间因运行情况而异。） 示例 13-5 中，FORALL 语句适用于集合的子集。 另请参阅: • FORALL 语句 了解完整的语法和语义，包括限制 • 隐式游标 了解有关一般隐式游标属性和可与 FORALL 语句一起使用的其他隐式游标属性的信息 示例 13-2 FOR LOOP 语句中的 DELETE 语句 \set SQLTERM ; create table student(id int, name text, score number); insert into student values(1,'zhang',120); DROP TABLE student_temp; CREATE TABLE student_temp AS SELECT * FROM student; \set SQLTERM / DECLARE type depts_type is table of int index by int; TYPE NList IS VARRAY(30) OF PLS_INTEGER; ids NList := NList(20, 40, 60); -- id numbers depts depts_type; BEGIN FOR m in 1..3 LOOP select id from student into depts(m); END LOOP; FOR i IN depts.FIRST..depts.LAST LOOP DELETE FROM student_temp WHERE id = ids(i); END LOOP; END; / \set SQLTERM ; 示例 13-3 FORALL 语句中的 DELETE 语句 337 第 13 章 PL/SQL 优化和调优 DROP TABLE student_temp; CREATE TABLE student_temp AS SELECT * FROM student; \set SQLTERM / DECLARE TYPE NList IS VARRAY(30) OF PLS_INTEGER; ids NList := NList(20, 40, 60); -- id numbers BEGIN FORALL i IN depts.FIRST..depts.LAST DELETE FROM student_temp WHERE id = ids(i); END; / \set SQLTERM ; 示例 13-4 FOR LOOP 和 FORALL 语句中 INSERT 语句的时间差 DROP TABLE student_temp; CREATE TABLE student_temp ( id INTEGER, name VARCHAR2(15) ); DROP TABLE student_temp2; CREATE TABLE student_temp2 ( id INTEGER, name VARCHAR2(15) ); \set SQLTERM / DECLARE TYPE IdTab IS TABLE OF student_temp.id%TYPE INDEX BY PLS_INTEGER; TYPE NameTab IS TABLE OF student_temp.name%TYPE INDEX BY PLS_INTEGER; id IDTAB; name NAMETAB; i CONSTANT NUMBER := 50000; t1 TIMESTAMP; t2 TIMESTAMP; t3 TIMESTAMP; BEGIN FOR j IN 1..i LOOP -- name collections id(j) := j; name(j) := 'bianma. ' || TO_CHAR(j); END LOOP; t1 := clock_timestamp(); 338 第 13 章 PL/SQL 优化和调优 FOR i IN 1..i LOOP INSERT INTO student_temp VALUES (id(i), name(i)); END LOOP; t2 := clock_timestamp(); FORALL i IN 1..i INSERT INTO student_temp VALUES (id(i), name(i)); t3 := clock_timestamp(); raise notice 'Execution Time'; raise notice '--------------------------'; raise notice 'FOR LOOP: %', t2 - t1; raise notice 'FORALL : %', t3 - t2; COMMIT; END; / \set SQLTERM ; 结果类似于： NOTICE: Execution Time NOTICE: -------------------------- NOTICE: FOR LOOP: 00:00:00.941640 NOTICE: FORALL : 00:00:00.000287 ANONYMOUS BLOCK 示例 13-5 集合子集的 FORALL 语句 DROP TABLE student_temp; CREATE TABLE student_temp AS SELECT * FROM student; \set SQLTERM / DECLARE TYPE NList IS VARRAY(10) OF PLS_INTEGER; ids NList := NList(5,10,20,30,50,55,57,60,70,75); BEGIN FORALL j IN 4..7 DELETE FROM student_temp WHERE id = ids(j); END; / \set SQLTERM ; 339 第 13 章 PL/SQL 优化和调优 对稀疏集合使用 FORALL 语句 13.2.1.1 如果 FORALL 语句 bounds 子句引用稀疏集合，则使用 INDICES OF 或 VALUES OF 子句仅指定现有索引值。 可以对任何集合使用 INDICES OF，除了以字符串为索引的关联数组。只能对 PLS_INTEGER 索引的 PLS_INTEGER 元素的集合使用 VALUES OF 。 由 PLS_INTEGER 索引的 PLS_INTEGER 元素的集合可以是索引集合；也就是说，指向另一个集合（索引集 合）的元素的指针集合。 索引集合对于使用不同 FORALL 语句处理同一集合的不同子集很有用。与其将原始集合的元素复制到表示子集 的新集合中（这可能会占用大量时间和内存），不如用索引集合表示每个子集，然后在不同 FORALL 语句的 VALUES OF 子句中使用每个索引集合。 另请参阅: 稀疏集合和 SQL%BULK_EXCEPTIONS 示例 13-6 稀疏集合及其子集的 FORALL 语句 此示例使用带有 INDICES OF 子句的 FORALL 语句来使用稀疏集合的元素填充表。然后它使用两个带有 VALUES OF 子句的 FORALL 语句来用集合的子集填充两个表。 DROP TABLE student_tmp; CREATE TABLE student_tmp ( name VARCHAR2(32), id NUMBER(10) ); DROP TABLE teacher; CREATE TABLE teacher AS SELECT * FROM student_tmp WHERE 1 = 0; DROP TABLE administration; CREATE TABLE administration AS SELECT * FROM student_tmp WHERE 1 = 0; \set SQLTERM / DECLARE SUBTYPE stdname IS student_tmp.name%TYPE; TYPE stdname_typ IS TABLE OF stdname; std_tab stdname_typ; -- Collection of student names SUBTYPE teach_id IS teacher.id%TYPE; TYPE teachid_typ IS TABLE OF NUMBER; teach_tab teachid_typ; -- Collection of teacher id 340 第 13 章 PL/SQL 优化和调优 TYPE idx IS TABLE OF PLS_INTEGER; teacher_tab administration_tab idx := idx(); idx := idx(); PROCEDURE student_data_collections IS BEGIN std_tab := stdname_typ('Class1','Class2','Class3','Class4','Class5'); teach_tab := teachid_typ(5000.01, 0, 150.25, 4000.00, NULL); END; BEGIN student_data_collections; raise notice '--- student number data ---'; FOR i IN 1..std_tab.LAST LOOP raise notice 'student # %, %: %', i, std_tab(i),teach_tab(i); END LOOP; -- Delete invalid orders: FOR i IN 1..std_tab.LAST LOOP IF teach_tab(i) IS NULL OR teach_tab(i) = 0 THEN std_tab.delete(i); teach_tab.delete(i); END IF; END LOOP; -- std_tab is now a sparse collection. raise notice'--- student data with invalid deleted ---'; FOR i IN 1..std_tab.LAST LOOP IF std_tab.EXISTS(i) THEN raise notice 'Customer # %, %: %', i, std_tab(i),teach_tab(i); END IF; END LOOP; -- Using sparse collection, populate student_tmp table: FORALL i IN INDICES OF std_tab 341 第 13 章 PL/SQL 优化和调优 INSERT INTO student_tmp VALUES (std_tab(i), teach_tab(i)); student_data_collections; -- Restore original order data -- std_tab is a dense collection again. FOR i IN std_tab.FIRST .. std_tab.LAST LOOP IF teach_tab(i) IS NULL OR teach_tab(i) = 0 THEN administration_tab.EXTEND; administration_tab(administration_tab.LAST) := i; END IF; IF teach_tab(i) > 2000 THEN teacher_tab.EXTEND; teacher_tab(teacher_tab.LAST) := i; END IF; END LOOP; FORALL i IN VALUES OF administration_tab INSERT INTO administration VALUES (std_tab(i), teach_tab(i)); FORALL i IN VALUES OF teacher_tab INSERT INTO teacher VALUES (std_tab(i), teach_tab(i)); END; / \set SQLTERM ; 结果： NOTICE: --- student number data --- NOTICE: student # 1, Class1: 5000.01 NOTICE: student # 2, Class2: 0 NOTICE: student # 3, Class3: 150.25 NOTICE: student # 4, Class4: 4000.00 NOTICE: student # 5, Class5: NOTICE: --- student data with invalid deleted --- NOTICE: Customer # 1, Class1: 5000.01 NOTICE: Customer # 3, Class3: 150.25 NOTICE: Customer # 4, Class4: 4000.00 342 第 13 章 PL/SQL 优化和调优 ANONYMOUS BLOCK 验证是否存储了正确的订单详细信息： SELECT name "Class", id "Student Number" FROM student_tmp ORDER BY name; 结果： Class | Number --------+-------Class1 | 5000 Class3 | 150 Class4 | 4000 (3 rows) 查询： SELECT name "Class", id "Teacher Number" FROM teacher ORDER BY name; 结果： Class | Teacher Number --------+---------------Class1 | 5000 Class4 | 4000 (2 rows) 查询： SELECT name "Class", id "Administration Number" FROM administration ORDER BY name; 结果： Class | Administration Number --------+----------------------Class2 | 0 Class5 | (2 rows) 13.2.1.2 FORALL 语句中未处理的异常 在没有 SAVE EXCEPTIONS 子句的 FORALL 语句中，如果一个 DML 语句引发未处理的异常，则 PL/SQL 将 停止 FORALL 语句并回滚先前 DML 语句所做的所有更改。 例如，示例 13-2 中的 FORALL 语句按此顺序执行这些 DML 语句，除非其中一个引发未处理的异常： 343 第 13 章 PL/SQL 优化和调优 DELETE FROM student_temp WHERE id = ids(20); DELETE FROM student_temp WHERE id = ids(40); DELETE FROM student_temp WHERE id = ids(60); 如果第三条语句引发未处理的异常，则 PL/SQL 回滚第一条和第二条语句所做的更改。如果第二条语句引发了 未处理的异常，那么 PL/SQL 将回滚第一条语句所做的更改并且从不运行第三条语句。 您可以通过以下任一方式处理 FORALL 语句中引发的异常： • 在引发每个异常时立即处理（请参阅立即处理 FORALL 异常 ） • 在 FORALL 语句完成执行后，通过包含 SAVE EXCEPTIONS 子句处理异常（请参阅FORALL 语句完成后处 理 FORALL 异常 ） 13.2.1.3 立即处理 FORALL 异常 要立即处理 FORALL 语句中引发的异常，请省略 SAVE EXCEPTIONS 子句并编写适当的异常处理程序。 如果一个 DML 语句引发了已处理的异常，则 PL/SQL 回滚该语句所做的更改，但不会回滚先前 DML 语句所做 的更改。 在示例 13-7 中，FORALL 语句旨在运行三个 UPDATE 语句。但是，第二个引发了异常。异常处理程序处理异 常，显示错误消息并提交第一个 UPDATE 语句所做的更改。第三个 UPDATE 语句永远不会运行。 有关异常处理程序的信息，请参阅异常处理 。 示例 13-7 立即处理 FORALL 异常 DROP TABLE student_temp; CREATE TABLE student_temp ( classno NUMBER(3), duty VARCHAR2(11) ); \set SQLTERM / CREATE OR REPLACE PROCEDURE p1 AS TYPE NList IS TABLE OF PLS_INTEGER; class NList := NList(100, 200, 300); errmsg VARCHAR2(100); BEGIN -- student table: INSERT INTO student_temp VALUES (100, 'Simba'); INSERT INTO student_temp VALUES (200, 'Baksha'); INSERT INTO student_temp VALUES (300, 'nano'); COMMIT; 344 第 13 章 PL/SQL 优化和调优 FORALL j IN class.FIRST..class.LAST UPDATE student_temp SET duty = duty || 'RDJCNB' WHERE classno = class(j); EXCEPTION WHEN OTHERS THEN errmsg := SQLERRM; raise notice '%', error_message; COMMIT; -- Commit results of successful updates RAISE; END; / \set SQLTERM ; set ora_statement_level_rollback to on; 结果： CREATE PROCEDURE 调用过程： Call p1(); 结果： NOTICE: value too large for column "public"."student_temp"."duty" (actual:12, maximum:11) ERROR: value too large for column "public"."student_temp"."duty" (actual:12, maximum:11) CONTEXT: SQL statement "UPDATE student_temp SET duty = duty || 'RDJCNB' WHERE classno = class[j]" PL/SQL function p1() line 16 at SQL statement 查询: SELECT * FROM student_temp; 结果: classno | duty ---------+------------200 | Baksha 300 | nano 100 | SimbaRDJCNB (3 rows) 345 第 13 章 PL/SQL 优化和调优 13.2.1.4 FORALL 语句完成后处理 FORALL 异常 要允许 FORALL 语句在某些 DML 语句失败的情况下继续执行，请包含 SAVE EXCEPTIONS 子句。当 DML 语 句失败时，PL/SQL 不会引发异常；相反，它会保存有关失败的信息。FORALL 语句完成后，PL/SQL 为 FORALL 语句引发一个异常。 在异常处理程序中，您可以从隐式游标属性 SQL%BULK_EXCEPTIONS 获取有关每个单独的 DML 语句失败 的信息。 SQL%BULK_EXCEPTIONS 类似于有关在最近运行的 FORALL 语句期间失败的 DML 语句的信息的关联数 组。 SQL%BULK_EXCEPTIONS.COUNT 是失败的 DML 语句数。如果 SQL%BULK_EXCEPTIONS.COUNT 不 为零，那么对于从 1 到 SQL%BULK_EXCEPTIONS.COUNT 的每个索引值 i： • SQL%BULK_EXCEPTIONS(i). ERROR_INDEX 是失败的 DML 语句的编号。 • SQL%BULK_EXCEPTIONS(i). ERROR_CODE 是失败的 KingbaseES 数据库错误代码。 例如，如果一条 FORALL SAVE EXCEPTIONS 语句运行了 100 条 DML 语句，而第 10 条和第 64 条失败， 则： • SQL%BULK_EXCEPTIONS.COUNT = 2 • SQL%BULK_EXCEPTIONS(1).ERROR_INDEX = 10 • SQL%BULK_EXCEPTIONS(1).ERROR_CODE = 12899 • SQL%BULK_EXCEPTIONS(2).ERROR_INDEX = 64 • SQL%BULK_EXCEPTIONS(2).ERROR_CODE = 19278 注意: 在没有 SAVE EXCEPTIONS 子句的 FORALL 语句引发异常后，SQL%BULK_EXCEPTIONS.COUNT = 1。 使用错误代码，您可以使用 SQLERRM 函数获取相关的错误消息（在“SQLERRM 函数 ”中描述）： SQLERRM(-(SQL%BULK_EXCEPTIONS(i).ERROR_CODE)) 但是，SQLERRM 返回的错误消息不包括任何替换参数（比较示例 13-7 和示例 13-8 中的错误消息）。 示例 13-8 与示例 13-7 类似，不同之处在于： • FORALL 语句包括 SAVE EXCEPTIONS 子句。 • 异常处理程序 err_dml 使用 SQL%BULK_EXCEPTIONS 和 SQLERRM（和一些局部变量）来显示错误消息 以及哪个语句、集合项和字符串导致了错误。 示例 13-8 在 FORALL 语句完成后处理 FORALL 异常 346 第 13 章 PL/SQL 优化和调优 DROP TABLE student_temp; CREATE TABLE student_temp ( classno NUMBER(4), duty VARCHAR2(12) ); \set SQLTERM / CREATE OR REPLACE PROCEDURE p AS TYPE NList IS TABLE OF PLS_INTEGER; classes NList := NList(50, 100, 150); errmsg VARCHAR2(100); cook_no NUMBER; class_no student_temp.classno%TYPE; duty_no student_temp.duty%TYPE; err_dml EXCEPTION; PRAGMA EXCEPTION_INIT(err_dml, -10053); BEGIN -- Populate table: INSERT INTO student_temp VALUES (50 , 'simba'); INSERT INTO student_temp VALUES (100, 'baksha'); INSERT INTO student_temp VALUES (150, 'nana'); COMMIT; -- Append 9-character string to each duty: FORALL j IN classes.FIRST..classes.LAST SAVE EXCEPTIONS UPDATE student_temp SET duty = duty || ' RDJCNB' WHERE classno = classes(j); EXCEPTION WHEN err_dml THEN FOR i IN 1..SQL%BULK_EXCEPTIONS.COUNT LOOP errmsg := SQLERRM(-(SQL%BULK_EXCEPTIONS(i).ERROR_CODE)); raise notice '%', errmsg; cook_no := SQL%BULK_EXCEPTIONS(i).ERROR_INDEX; raise notice 'cook no:%', cook_no; class_no := classes(cook_no); raise notice 'class no:%', class_no; SELECT duty INTO duty_no FROM student_temp WHERE classno = class_no; 347 第 13 章 PL/SQL 优化和调优 raise notice 'duty no:%', duty_no; END LOOP; COMMIT; -- Commit results of successful updates WHEN OTHERS THEN raise notice 'Unrecognized error.'; raise notice '%', sqlcode; RAISE; END; / \set SQLTERM ; set ora_statement_level_rollback to on; 结果： CREATE PROCEDURE 调用过程： call p(); 结果： NOTICE: value too large for column "public"."student_temp"."duty" (actual:15, maximum:12) NOTICE: cook no:2 NOTICE: class no:100 NOTICE: duty no:baksha CALL 查询： SELECT * FROM student_temp; 结果： classno | duty ---------+-------------100 | baksha 50 | simba RDJCNB 150 | nana RDJCNB (3 rows) 348 第 13 章 PL/SQL 优化和调优 13.2.1.4.1 稀疏集合和 SQL%BULK_EXCEPTIONS 如果 FORALL 语句 bounds 子 句 引 用 了 稀 疏 集 合， 那 么 要 找 到 导 致 素， 必 须 逐 个 遍 历 元 素， 直 到 找 到 索 引 为 然 后， 如 果 FORALL 语句使用 VALUES DML 语句失败的集合元 SQL%BULK_EXCEPTIONS(i).ERROR_INDEX OF 的 元 素。 子 句 将 指 针 集 合 引 用 到 另 一 个 集 合， 则 必 须 找 到 索 引 为 SQL%BULK_EXCEPTIONS(i).ERROR_INDEX 的另一个集合的元素。 13.2.1.4.2 获取受 FORALL 语句影响的行数 在 FORALL 语句完成后，您可以从隐式游标属性 SQL%BULK_ROWCOUNT 获取每个 DML 语句影响的行 数。 要获取受 FORALL 语句影响的总行数，请使用隐式游标属性 SQL%ROWCOUNT，如“SQL%ROWCOUNT 属 性：有多少行受到影响？ ”。 SQL%BULK_ROWCOUNT 类似于一个关联数组，其第 i 个元素是最近完成的 FORALL 语句中受第 i 个 DML 语句影响的行数。元素的数据类型是 INTEGER。 示例 13-9 使用 SQL%BULK_ROWCOUNT 显示 FORALL 语句中每个 DELETE 语句删除了多少行，使用 SQL%ROWCOUNT 显示删除的总行数。 示例 13-10 使用 SQL%BULK_ROWCOUNT 显示 FORALL 语句中每个 INSERT SELECT 构造插入的行数， 使用 SQL%ROWCOUNT 显示插入的总行数。 示例 13-9 显示 FORALL 中每个 DELETE 影响的行数 DROP TABLE student_temp; CREATE TABLE student_tmp(id int, classno varchar(100)); truncate student; \set SQLTERM / begin for i in 1..9 loop insert into student values(i, i ||'-simba'); end loop; end; / \set SQLTERM / DECLARE TYPE NList IS TABLE OF PLS_INTEGER; ids NList := NList(1, 3, 5); BEGIN FORALL j IN ids.FIRST..ids.LAST DELETE FROM student_tmp WHERE id = ids(j); FOR i IN ids.FIRST..ids.LAST LOOP raise notice 'deleted :% records', SQL%BULK_ROWCOUNT(i); 349 第 13 章 PL/SQL 优化和调优 END LOOP; raise notice 'Total rows deleted: %', SQL%ROWCOUNT; END; / \set SQLTERM ; 结果： NOTICE: deleted :1 records NOTICE: deleted :1 records NOTICE: deleted :1 records NOTICE: Total rows deleted: 3 ANONYMOUS BLOCK 示例 13-10 显示 FORALL 中每个 INSERT SELECT 影响的行数 DROP TABLE student_temp; CREATE TABLE student_tmp(id int, classno varchar(100)); truncate student; \set SQLTERM / begin for i in 1..9 loop insert into student values(i, i ||'-simba'); end loop; end; / DECLARE TYPE class_no IS TABLE OF student_tmp.classno%TYPE; class class_no; BEGIN SELECT name BULK COLLECT INTO class FROM student; FORALL i IN 1..class.COUNT INSERT INTO student_tmp SELECT id, name FROM student WHERE name = class(i) ORDER BY name, id; FOR i IN 1..class.COUNT LOOP raise notice 'classno:%, inserted :% records', class(i), SQL%BULK_ROWCOUNT(i); END LOOP; 350 第 13 章 PL/SQL 优化和调优 raise notice 'Total records inserted: %', SQL%ROWCOUNT; END; / \set SQLTERM ; 结果： NOTICE: classno:1-simba, inserted :1 records NOTICE: classno:2-simba, inserted :1 records NOTICE: classno:3-simba, inserted :1 records NOTICE: classno:4-simba, inserted :1 records NOTICE: classno:5-simba, inserted :1 records NOTICE: classno:6-simba, inserted :1 records NOTICE: classno:7-simba, inserted :1 records NOTICE: classno:8-simba, inserted :1 records NOTICE: classno:9-simba, inserted :1 records NOTICE: Total records inserted: 9 ANONYMOUS BLOCK 13.2.2 BULK COLLECT 子句 BULK COLLECT 子句是批量 SQL 的一项功能，它可以将结果从 SQL 批量返回到 PL/SQL，而不是一次一个。 BULK COLLECT 子句可以出现在： • SELECT INTO 语句 • FETCH 语句 • RETURNING INTO 的语句：- DELETE 语句 - INSERT 语句 - UPDATE 语句 - EXECUTE IMMEDIATE 语 句 使用 BULK COLLECT 子句，前面的每个语句都会检索整个结果集，并将其存储在单个操作中的一个或多个集 合变量中（这比使用循环语句一次检索一个结果行更有效）。 注意: PL/SQL 处理 BULK COLLECT 子句的方式类似于它处理 LOOP 语句中的 FETCH 语句的方式。当带有 BULK COLLECT 子句的语句不返回任何行时，PL/SQL 不会引发异常。必须检查目标集合是否为空，如示例 13-17 所示。 13.2.2.1 带有 BULK COLLECT 子句的 SELECT INTO 语句 带有 BULK COLLECT 子句的 SELECT INTO 语句（也称为 SELECT BULK COLLECT INTO 语句）将整个 结果集选择到一个或多个集合变量中。 351 第 13 章 PL/SQL 优化和调优 有关详细信息，请参阅SELECT INTO 语句 。 警告: SELECT BULK COLLECT INTO 语句容易受到别名的影响，这可能会导致意外结果。有关详细信 息，请参阅SELECT BULK COLLECT INTO 语句和别名 。 示例 13-11 使用一条 SELECT BULK COLLECT INTO 语句将两个数据库列选择为两个集合（嵌套表）。 示例 13-12 使用 SELECT BULK COLLECT INTO 语句将结果集选择到嵌套的记录表中。 示例 13-11 将两个数据库列批量选择到两个嵌套表中 \set SQLTERM / DECLARE TYPE IdTab IS TABLE OF student.id%TYPE; TYPE NameTab IS TABLE OF student.name%TYPE; ids IdTab; names NameTab; PROCEDURE print_first_n (n POSITIVE) IS BEGIN IF ids.COUNT = 0 THEN raise notice 'Collections are empty.'; ELSE raise notice 'First % students:', n; FOR i IN 1 .. n LOOP raise notice ' student # id: %, name:%;',ids(i) ,names(i); END LOOP; END IF; END; BEGIN SELECT id, name BULK COLLECT INTO ids, names FROM student ORDER BY id; print_first_n(3); print_first_n(6); END; / \set SQLTERM ; 结果： 352 第 13 章 PL/SQL 优化和调优 NOTICE: First 3 students: NOTICE: student # id: 1, name:1-simba; NOTICE: student # id: 2, name:2-simba; NOTICE: student # id: 3, name:3-simba; NOTICE: First 6 students: NOTICE: student # id: 1, name:1-simba; NOTICE: student # id: 2, name:2-simba; NOTICE: student # id: 3, name:3-simba; NOTICE: student # id: 4, name:4-simba; NOTICE: student # id: 5, name:5-simba; NOTICE: student # id: 6, name:6-simba; ANONYMOUS BLOCK 示例 13-12 批量选择到嵌套记录表 truncate student; \set SQLTERM / BEGIN for i in 1..9 loop insert into student values(i, i ||'-simba', i*10); end loop; END; / create type typ1 as (name varchar(100), score numeric); / DECLARE TYPE NameSet IS TABLE OF typ1%ROWTYPE; name_students NameSet; -- nested table of records BEGIN -- Assign values to nested table of records: SELECT name, score BULK COLLECT INTO name_students FROM student WHERE id = 1 ORDER BY score; -- Print nested table of records: FOR i IN name_students.FIRST .. name_students.LAST LOOP raise notice '%, %', name_students(i).score, name_students(i).name; END LOOP; END; / \set SQLTERM ; drop type typ1; 353 第 13 章 PL/SQL 优化和调优 结果： NOTICE: 10, 1-simba ANONYMOUS BLOCK 13.2.2.1.1 SELECT BULK COLLECT INTO 语句和别名 在表格的声明中 SELECT column BULK COLLECT INTO collection FROM table ... PL/SQL 通过引用 column 和 collection 传递它们。与通过引用传递的子程序参数一样，别名可能会导致异常结 果。 另请参阅: • “子程序参数别名 ” 示例 13-14 使用游标来实现示例 13-13 预期的结果。 示例 13-15 从集合 numbers1 中选择特定值，然后将它们存储在不同的集合 numbers2 中。示例 13-15 比示例 13-14 运行得更快。 示例 13-13 SELECT BULK COLLECT INTO 具有意外结果的语句 CREATE OR REPLACE TYPE numtyp IS TABLE OF INTEGER; \set SQLTERM / CREATE OR REPLACE PROCEDURE p (i INTEGER) IS num1 numtyp := numtyp(3,4,5,6,7); BEGIN raise notice 'Before SELECT statement'; raise notice 'num1.COUNT() = %', num1.COUNT(); FOR j IN 1..num1.COUNT() LOOP raise notice 'num1(%)=%', j, num1(j); END LOOP; --Self-selecting BULK COLLECT INTO clause: SELECT a.COLUMN_VALUE BULK COLLECT INTO num1 FROM TABLE(num1) a WHERE a.COLUMN_VALUE > p.i ORDER BY a.COLUMN_VALUE; raise notice 'After SELECT statement'; raise notice 'num1.COUNT() = %', num1.COUNT(); END p; 354 第 13 章 PL/SQL 优化和调优 / \set SQLTERM ; 调用 p： call p(2); 结果： NOTICE: Before SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)=3 NOTICE: num1(2)=4 NOTICE: num1(3)=5 NOTICE: num1(4)=6 NOTICE: num1(5)=7 NOTICE: After SELECT statement NOTICE: num1.COUNT() = 2 CALL 调用 p： call p(14); 结果： NOTICE: Before SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)=3 NOTICE: num1(2)=4 NOTICE: num1(3)=5 NOTICE: num1(4)=6 NOTICE: num1(5)=7 NOTICE: After SELECT statement NOTICE: num1.COUNT() = 0 CALL 示例 13-14 示例 13-13 的游标解决方法 \set SQLTERM / CREATE OR REPLACE PROCEDURE p (i INTEGER) IS num1 numtyp := numtyp(55,56,57,58,59); CURSOR c IS SELECT a.COLUMN_VALUE FROM TABLE(num1) a WHERE a.COLUMN_VALUE > p.i 355 第 13 章 PL/SQL 优化和调优 ORDER BY a.COLUMN_VALUE; BEGIN raise notice 'Before SELECT statement'; raise notice 'num1.COUNT() = %', num1.COUNT(); FOR j IN 1..num1.COUNT() LOOP raise notice 'num1(%)=%', j, num1(j); END LOOP; OPEN c; FETCH c BULK COLLECT INTO num1; CLOSE c; raise notice 'After SELECT statement'; raise notice 'num1.COUNT() = %', num1.COUNT(); IF num1.COUNT() > 0 THEN FOR j IN 1..num1.COUNT() LOOP raise notice 'num1(%)=%', j, num1(j); END LOOP; END IF; END p; / \set SQLTERM ; 调用 p： call p(57); 结果： NOTICE: Before SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)=55 NOTICE: num1(2)=56 NOTICE: num1(3)=57 NOTICE: num1(4)=58 NOTICE: num1(5)=59 NOTICE: After SELECT statement NOTICE: num1.COUNT() = 2 NOTICE: num1(1)=58 NOTICE: num1(2)=59 CALL 调用 p： 356 第 13 章 PL/SQL 优化和调优 call p(120); 结果： NOTICE: Before SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)=55 NOTICE: num1(2)=56 NOTICE: num1(3)=57 NOTICE: num1(4)=58 NOTICE: num1(5)=59 NOTICE: After SELECT statement NOTICE: num1.COUNT() = 0 CALL 示例 13-15 示例 13-13 的第二次收集解决方法 \set SQLTERM / CREATE OR REPLACE PROCEDURE p (i IN INTEGER) AUTHID DEFINER IS num1 numtyp := numtyp(11,12,13,14,15); num2 numtyp := numtyp(0,0,0,0,0); BEGIN raise notice 'Before SELECT statement'; raise notice 'num1.COUNT() = %', num1.COUNT(); FOR j IN 1..num1.COUNT() LOOP raise notice 'num1(%)= %', j, num1(j); END LOOP; raise notice 'num2.COUNT() = %', num2.COUNT(); FOR j IN 1..num2.COUNT() LOOP raise notice 'num2(%)= %', j, num2(j); END LOOP; SELECT a.COLUMN_VALUE BULK COLLECT INTO num2 FROM TABLE(num1) a -- num2 appears here -- num1 appears here WHERE a.COLUMN_VALUE > p.i ORDER BY a.COLUMN_VALUE; raise notice 'After SELECT statement'; raise notice 'num1.COUNT() = %', num1.COUNT(); IF num1.COUNT() > 0 THEN 357 第 13 章 PL/SQL 优化和调优 FOR j IN 1..num1.COUNT() LOOP raise notice 'num1(%)= %', j, num1(j); END LOOP; END IF; raise notice 'num2.COUNT() = %', num2.COUNT(); IF num2.COUNT() > 0 THEN FOR j IN 1..num2.COUNT() LOOP raise notice 'num2(%)= %', j, num2(j); END LOOP; END IF; END p; / \set SQLTERM ; 调用 p： call p(12); 结果： NOTICE: Before SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)= 11 NOTICE: num1(2)= 12 NOTICE: num1(3)= 13 NOTICE: num1(4)= 14 NOTICE: num1(5)= 15 NOTICE: num2.COUNT() = 5 NOTICE: num2(1)= 0 NOTICE: num2(2)= 0 NOTICE: num2(3)= 0 NOTICE: num2(4)= 0 NOTICE: num2(5)= 0 NOTICE: After SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)= 11 NOTICE: num1(2)= 12 NOTICE: num1(3)= 13 NOTICE: num1(4)= 14 NOTICE: num1(5)= 15 NOTICE: num2.COUNT() = 3 NOTICE: num2(1)= 13 NOTICE: num2(2)= 14 358 第 13 章 PL/SQL 优化和调优 NOTICE: num2(3)= 15 CALL 调用 p： call p(30); 结果： NOTICE: Before SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)= 11 NOTICE: num1(2)= 12 NOTICE: num1(3)= 13 NOTICE: num1(4)= 14 NOTICE: num1(5)= 15 NOTICE: num2.COUNT() = 5 NOTICE: num2(1)= 0 NOTICE: num2(2)= 0 NOTICE: num2(3)= 0 NOTICE: num2(4)= 0 NOTICE: num2(5)= 0 NOTICE: After SELECT statement NOTICE: num1.COUNT() = 5 NOTICE: num1(1)= 11 NOTICE: num1(2)= 12 NOTICE: num1(3)= 13 NOTICE: num1(4)= 14 NOTICE: num1(5)= 15 NOTICE: num2.COUNT() = 0 CALL 13.2.2.1.1.1 SELECT BULK COLLECT INTO 语句的行限制 返回大量行的 SELECT BULK COLLECT INTO 语句会生成一个大型集合。要限制行数和集合大小，请使用以 下之一： • ROWNUM 伪列（在《KingbaseES SQL 语言参考手册》中描述） • FETCH FIRST 子句（在《KingbaseES SQL 语言参考手册》中描述） 示例 13-16 显示了几种限制 SELECT BULK COLLECT INTO 语句返回的行数的方法。 示例 13-16 使用 ROWNUM、SAMPLE 和 FETCH FIRST 限制批量选择 truncate student; \set SQLTERM / 359 第 13 章 PL/SQL 优化和调优 BEGIN for i in 1..100 loop insert into student values(i); end loop; END; / DECLARE TYPE IdList IS TABLE OF student.id%TYPE; ids IdList; BEGIN SELECT id BULK COLLECT INTO ids FROM student WHERE ROWNUM <= 50; SELECT id BULK COLLECT INTO ids FROM student FETCH FIRST 50 ROWS ONLY; END; / 13.2.2.1.1.2 循环编译集合的规则 当结果集存储在集合中时，很容易遍历行并引用不同的列。这种方式可以非常快，但也非常占用内存。有如下场 景可以考虑： • 只遍历结果集一次，请使用游标 FOR LOOP（请参阅使用游标 FOR LOOP 语句处理查询结果集 ）。 这种方式避免了存储结果集副本的内存开销。 • 在 SELECT INTO 语句中进行搜索或过滤，这样可以减少结果集来搜索某些值或将结果过滤到较小的集合中。 例如，在简单查询中，使用 WHERE 子句；请参阅《KingbaseES SQL 语言参考手册》。 • 在 SELECT INTO 语句的查询中使用子查询, 代替循环遍历结果集并为每个结果行运行另一个查询，（请参 阅处理带有子查询的查询结果集 ）。 • 使用 FORALL 语句，代替循环遍历结果集并为每个结果行运行另一个 DML 语句（请参阅FORALL 语句 ）。 13.2.2.2 带有 BULK COLLECT 子句的 FETCH 语句 带有 BULK COLLECT 子句的 FETCH 语句（也称为 FETCH BULK COLLECT 语句）将整个结果集提取到一 个或多个集合变量中。有关详细信息，请参阅FETCH 语句 。 示例 13-17 使用 FETCH BULK COLLECT 语句将整个结果集提取到两个集合（嵌套表）中。 示例 13-18 使用 FETCH BULK COLLECT 语句将结果集提取到记录集合（嵌套表）中。 示例 13-17 批量提取到两个嵌套表中 360 第 13 章 PL/SQL 优化和调优 drop type numtyp; create type listtype as (name varchar(100), score numeric); \set SQLTERM / BEGIN for i in 1..10 loop insert into student values(i, i||'-simba', i*10); end loop; END; / DECLARE TYPE NameTpe IS TABLE OF student.name%TYPE; TYPE ScoreTyp IS TABLE OF student.score%TYPE; CURSOR c1 IS SELECT name, score FROM student WHERE score > 5 ORDER BY name; names NameTpe; scores ScoreTyp; TYPE Typ IS TABLE OF listtype; recs Typ; v_limit PLS_INTEGER := 3; PROCEDURE print_results IS BEGIN -- Check if collections are empty: IF names IS NULL OR names.COUNT = 0 THEN raise notice 'No results!'; ELSE raise notice 'Result: '; FOR i IN names.FIRST .. names.LAST LOOP raise notice' Student %:%.', names(i), scores(i); END LOOP; END IF; END; BEGIN raise notice'--- Processing all results simultaneously ---'; OPEN c1; FETCH c1 BULK COLLECT INTO names, scores; CLOSE c1; 361 第 13 章 PL/SQL 优化和调优 print_results(); raise notice '--- Processing % rows at a time ---', v_limit; OPEN c1; LOOP FETCH c1 BULK COLLECT INTO names, scores LIMIT v_limit; EXIT WHEN names.COUNT = 0; print_results(); END LOOP; CLOSE c1; raise notice '--- Fetching records rather than columns ---'; OPEN c1; FETCH c1 BULK COLLECT INTO recs; FOR i IN recs.FIRST .. recs.LAST LOOP -- Now all columns from result set come from one record raise notice ' Student %:%', recs(i).name, recs(i).score; END LOOP; END; / \set SQLTERM ; drop type listtype; 结果： NOTICE: --- Processing all results simultaneously --- NOTICE: Result: NOTICE: Student 10-simba:100. NOTICE: Student 1-simba:10. NOTICE: Student 2-simba:20. NOTICE: Student 3-simba:30. NOTICE: Student 4-simba:40. NOTICE: Student 5-simba:50. NOTICE: Student 6-simba:60. NOTICE: Student 7-simba:70. NOTICE: Student 8-simba:80. NOTICE: Student 9-simba:90. NOTICE: --- Processing 3 rows at a time --- NOTICE: Result: NOTICE: Student 10-simba:100. NOTICE: Student 1-simba:10. NOTICE: NOTICE: Student 2-simba:20. Result: NOTICE: Student 3-simba:30. NOTICE: Student 4-simba:40. NOTICE: Student 5-simba:50. 362 第 13 章 PL/SQL 优化和调优 NOTICE: Result: NOTICE: Student 6-simba:60. NOTICE: Student 7-simba:70. NOTICE: Student 8-simba:80. NOTICE: Result: NOTICE: NOTICE: Student 9-simba:90. --- Fetching records rather than columns --- NOTICE: Student 10-simba:100 NOTICE: Student 1-simba:10 NOTICE: Student 2-simba:20 NOTICE: Student 3-simba:30 NOTICE: Student 4-simba:40 NOTICE: Student 5-simba:50 NOTICE: Student 6-simba:60 NOTICE: Student 7-simba:70 NOTICE: Student 8-simba:80 NOTICE: Student 9-simba:90 ANONYMOUS BLOCK 示例 13-18 批量提取到嵌套记录表中 create type listtype as (name varchar(100), score numeric); \set SQLTERM / DECLARE TYPE SetTyp IS TABLE OF listtype%ROWTYPE; students SetTyp; -- nested table of records cv REFCURSOR; BEGIN -- Assign values to nested table of records: OPEN cv FOR SELECT name, score FROM student WHERE id = '10' ORDER BY score; FETCH cv BULK COLLECT INTO students; CLOSE cv; -- Print nested table of records: FOR i IN students.FIRST .. students.LAST LOOP raise notice '%:%', students(i).name, students(i).score; END LOOP;END; 363 第 13 章 PL/SQL 优化和调优 / \set SQLTERM ; drop type listtype; 结果： NOTICE: 10-simba:100 ANONYMOUS BLOCK 13.2.2.2.1 FETCH BULK COLLECT 语句的行限制 返回大量行的 FETCH BULK COLLECT 语句会生成一个大型集合。要限制行数和集合大小，请使用 LIMIT 子 句。 在示例 13-19 中，对于 LOOP 语句的每次迭代，FETCH 语句将 10 行（或更少）提取到关联数组 ntab 中（覆 盖之前的值）。注意 LOOP 语句的退出条件。 示例 13-19 使用 LIMIT 限制批量 FETCH \set SQLTERM / DECLARE TYPE ntab IS TABLE OF NUMBER INDEX BY PLS_INTEGER; ids ntab; CURSOR c1 IS SELECT id FROM student WHERE score = 80 ORDER BY id; BEGIN OPEN c1; LOOP -- Fetch 10 rows or fewer in each iteration FETCH c1 BULK COLLECT INTO ids LIMIT 3; raise notice '------- Results from One Bulk Fetch --------'; FOR i IN 1..ids.COUNT LOOP raise notice 'Student Id: %',ids(i); END LOOP; EXIT WHEN c1%NOTFOUND; END LOOP; CLOSE c1; END; / \set SQLTERM ; 结果： 364 第 13 章 PL/SQL 优化和调优 NOTICE: ------- Results from One Bulk Fetch -------- NOTICE: Student Id: 8 ANONYMOUS BLOCK 13.2.2.3 RETURNING INTO 子句带有 BULK COLLECT 子句 带有 BULK COLLECT 子句的 RETURNING INTO 子句（也称为 RETURNING BULK COLLECT INTO 子 句）可以出现在 INSERT、UPDATE、DELETE 或 EXECUTE IMMEDIATE 语句中。使用 RETURNING BULK COLLECT INTO 子句，语句将其结果集存储在一个或多个集合中。请参阅 返回条款。 示例 13-20 使用带有 RETURNING BULK COLLECT INTO 子句的 DELETE 语句从表中删除行并在两个集合 （嵌套表）中返回它们。 示例 13-20 在两个嵌套表中返回已删除的行 DROP TABLE student_temp; CREATE TABLE student_temp AS SELECT * FROM student ORDER BY id; \set SQLTERM / DECLARE TYPE IdList IS TABLE OF student.id%TYPE; ids IdList; TYPE NameList IS TABLE OF student.name%TYPE; names NameList; BEGIN DELETE FROM student_temp WHERE id = 5 RETURNING id, name BULK COLLECT INTO ids, names; raise notice 'Deleted % rows:', SQL%ROWCOUNT; FOR i IN ids.FIRST .. ids.LAST LOOP raise notice 'Students # %:%', ids(i), names(i); END LOOP; END; / \set SQLTERM ; 结果： NOTICE: Deleted 1 rows: NOTICE: Students # 5:5-simba ANONYMOUS BLOCK 365 第 13 章 PL/SQL 优化和调优 13.2.3 FORALL 语句和 BULK COLLECT 子句一起使用 在 FORALL 语句中，DML 语句可以有一个 RETURNING BULK COLLECT INTO 子句。对于 FORALL 语句 的每次迭代，DML 语句将指定的值存储在指定的集合中，而不会覆盖以前的值，就像在 FOR LOOP 语句中执行相 同的 DML 语句一样。 在示例 13-21 中，FORALL 语句运行具有 RETURNING BULK COLLECT INTO 子句的 DELETE 语句。对 于 FORALL 语句的每次迭代，DELETE 语句将删除行的 id 和 score 值分别存储在集合 ids 和 scores 中。 示例 13-22 与示例 13-21 类似，只是它使用 FOR LOOP 语句而不是 FORALL 语句。 示例 13-21 FORALL 语句中使用带有 RETURN BULK COLLECT INTO 子句的 DELETE 语句 DROP TABLE student_temp; CREATE TABLE student_temp AS SELECT * FROM student ORDER BY id; \set SQLTERM / DECLARE TYPE ScoreList IS TABLE OF PLS_INTEGER; tag ScoreList := ScoreList(30,60,90); TYPE IdTyp IS TABLE OF student.id%TYPE; ids IdTyp; TYPE ScoreTyp IS TABLE OF student.score%TYPE; scores ScoreTyp; BEGIN FORALL j IN tag.FIRST..tag.LAST DELETE FROM student_temp WHERE score = tag(j) RETURNING id, score BULK COLLECT INTO ids, scores; raise notice '---Deleted % rows---', SQL%ROWCOUNT; FOR i IN ids.FIRST .. ids.LAST LOOP raise notice 'Student # % from student table %', ids(i), scores(i); END LOOP; END; / \set SQLTERM ; 结果： 366 第 13 章 PL/SQL 优化和调优 NOTICE: ---Deleted 3 rows--- NOTICE: Student # 3 from student table 30 NOTICE: Student # 6 from student table 60 NOTICE: Student # 9 from student table 90 ANONYMOUS BLOCK 示例 13-22 在 FOR LOOP 语句中使用带有 RETURN BULK COLLECT INTO 子句的 DELETE 语句 DROP TABLE student_temp; CREATE TABLE student_temp AS SELECT * FROM student ORDER BY id; \set SQLTERM / DECLARE TYPE ScoreList IS TABLE OF PLS_INTEGER; tag ScoreList := ScoreList(30,60,90); TYPE IdTyp IS TABLE OF student.id%TYPE; ids IdTyp; TYPE ScoreTyp IS TABLE OF student.score%TYPE; scores ScoreTyp; BEGIN FOR j IN tag.FIRST..tag.LAST LOOP DELETE FROM student_temp WHERE score = tag(j) RETURNING id, score BULK COLLECT INTO ids, scores; END LOOP; raise notice '---Deleted % rows---', SQL%ROWCOUNT; FOR i IN ids.FIRST .. ids.LAST LOOP raise notice 'Student # % from student table %', ids(i), scores(i); END LOOP; END; / \set SQLTERM ; 结果： NOTICE: ---Deleted 1 rows--- NOTICE: Student # 9 from student table 90 ANONYMOUS BLOCK 367 第 13 章 PL/SQL 优化和调优 13.3 Pipelined Table 函数的多重转换 Pipelined Table 函数是对数据执行多次转换的有效方式。 注意: Pipelined Table 函数不能使用在 database link 中。原因是 Pipelined Table 函数的返回类型是 SQL 用户定义 类型，只能在单个数据库中使用。尽管 Pipelined Table 函数的返回类型可能看起来是 PL/SQL 类型，但数据库实际 上将该 PL/SQL 类型转换为相应的 SQL 用户定义类型。 13.3.1 Table 函数概述 Table 函数是用户定义的 PL/SQL 函数，它返回行的集合（关联数组、嵌套表或可变数组）。 通过 SELECT 语句的 TABLE 子句中调用 Table 函数，可以从这个集合中进行选择，就像它是一个数据库表一 样。TABLE 运算符是可选的。 例如： SELECT * FROM TABLE(TableFunctionName(ParameterList)) 或者，可以在没有 TABLE 运算符的情况下编写相同的查询，如下所示： SELECT * FROM TableFunctionName(ParameterList) Table 函数可以将行的集合作为输入（也就是说，它可以有一个输入参数，即嵌套表、可变数组或游标变量）。 因此，表函数 tf1 的输出可以输入到表函数 tf2，tf2 的输出可以输入到表函数 tf3，以此类推。 Pipelined Table 函数在处理完一行后立即将该行返回给它的调用者，并继续处理下一行。响应时间得到改善，因 为在查询可以返回单个结果行之前，不需要构造整个集合返回到服务器。 警告: Pipelined Table 函数始终引用数据的当前状态。如果在为集合打开游标后集合中的数据发生更改，则 游标会反映更改。PL/SQL 变量是会话私有的，不是事务性的。因此，以适用于表数据而闻名的读取一致性不适 用于 PL/SQL 集合变量。 另请参阅: • 创建 Pipelined Table 函数 • 《KingbaseES SQL 语言参考手册》以获取有关 SELECT 语句的 TABLE 子句的更多信息 13.3.2 创建 Pipelined Table 函数 Pipelined Table 函数必须是独立函数或包函数。 368 第 13 章 PL/SQL 优化和调优 Pipelined 选项 对于独立函数，请在 CREATE FUNCTION 语句中指定 PIPELINED 选项（有关语法，请参阅 CREATE FUNCTION 语句）。对于包函数，请在函数声明和函数定义中指定 PIPELINED 选项（有关语法，请参 阅函数声明与定义 ）。 参数 通常，Pipelined Table 函数具有一个或多个游标变量参数。有关作为函数参数的游标变量的信息，请参 阅游标变量作为子程序参数 。 另请参阅: • 游标变量 获取有关游标变量的一般信息 • 子程序参数 获取有关子程序参数的一般信息 返回数据类型 Pipelined Table 函数返回值的数据类型必须是在模式级别或包内定义的集合类型（因此，它不能是关 联数组类型）。集合类型的元素必须是 SQL 数据类型，而不是只有 PL/ SQL 支持的数据类型（如 PLS_INTEGER 和 BOOLEAN）。有关集合类型的信息，请参阅集合类型 。有关 SQL 数据类型的信 息，请参阅《KingbaseES SQL 语言参考手册》。 PIPE ROW 语句 在 Pipelined Table 函数中，使用 PIPE ROW 语句将集合元素返回给调用者，而不将控制权返回给调用 者。有关其语法和语义，请参见PIPE ROW 语句 。 RETURN 语句 与每个函数一样，Pipelined Table 函数中的每个执行路径都必须指向一个 RETURN 语句，该语句将控制 权返回给调用者。但是，在 Pipelined Table 函数中，RETURN 语句不需要将值返回给调用者。有关其语 法和语义，请参见RETURN 语句 。 用例 示例 13-23 创建和调用 Pipelined Table 函数 此示例创建一个包，其中包含 Pipelined Table 函数 func1，然后从 func1 返回的行集合中进行选择。 \set SQLTERM / CREATE OR REPLACE PACKAGE pkg1 AS TYPE NumTyp IS TABLE OF PLS_INTEGER; FUNCTION func1(i NUMBER) RETURN NumTyp PIPELINED; END pkg1; / \set SQLTERM ; 创建一个返回元素集合 (1,3,5,... x) 的 Pipelined Table 函数 func1。 369 第 13 章 PL/SQL 优化和调优 \set SQLTERM / CREATE OR REPLACE PACKAGE BODY pkg1 AS FUNCTION func1(i NUMBER) RETURN NumTyp PIPELINED IS BEGIN FOR i IN 1..i by 2 LOOP PIPE ROW(i); END LOOP; RETURN; END; END; \set SQLTERM ; select * from TABLE(pkg1.func1(10)); 结果： column_value -------------1 3 5 7 9 (5 rows) select * from pkg1.func1(10); 结果: column_value -------------1 3 5 7 9 (5 rows) 13.3.3 Pipelined Table 函数作为转换函数 带有游标变量参数的 Pipelined Table 函数可以用作转换函数。该函数使用游标变量获取输入行。通过使用 PIPE ROW 语句，该函数将转换后的一行或多行通过管道传输到调用程序。如果 FETCH 和 PIPE ROW 语句位于 LOOP 语句中，则该函数可以转换多个输入行。 在示例 13-24 中，Pipelined Table 函数将 student 表的每个选定行转换为两个嵌套表行，并通过管道传递给调用 370 第 13 章 PL/SQL 优化和调优 它的 SELECT 语句。 示例 13-24 Pipelined Table 函数将每一行转换为两行 \set SQLTERM / CREATE OR REPLACE PACKAGE pkg1 AUTHID DEFINER IS TYPE RecTyp IS RECORD ( score NUMBER(6), name VARCHAR2(30) ); TYPE RecSet IS TABLE OF RecTyp; FUNCTION func1 (i int) RETURN RecSet PIPELINED; END pkg1; / CREATE OR REPLACE PACKAGE BODY pkg1 IS FUNCTION func1 (i int) RETURN RecSet PIPELINED IS rec1 RecTyp; rec2 student%ROWTYPE; CURSOR cur is SELECT * FROM student WHERE id > i; BEGIN open cur; LOOP FETCH cur INTO rec2; -- input row EXIT WHEN cur%NOTFOUND; rec1.score := rec2.id; rec1.name := rec2.name; PIPE ROW(rec1); -- first transformed output row rec1.name := rec2.name; rec1.score := rec2.score; PIPE ROW(rec1); -- second transformed output row END LOOP; CLOSE cur; RETURN; END func1; END pkg1; / \set SQLTERM ; SELECT * FROM TABLE (pkg1.func1 (5)); 结果： 371 第 13 章 PL/SQL 优化和调优 score | name -------+---------6 | 6-simba 60 | 6-simba 7 | 7-simba 70 | 7-simba 8 | 8-simba 80 | 8-simba 9 | 9-simba 90 | 9-simba 10 | 10-simba 100 | 10-simba (10 rows) 13.4 分析和跟踪 PL/SQL 程序 为了帮助您隔离大型 PL/SQL 程序中的性能问题，PL/SQL 提供了这些工具，以 PL/SQL 包的形式实现。 表 13.4.1: 分析和跟踪工具摘要 工具 包 描述 探查器界面 PLSQL-PLPROFILER 计算您的 PL/SQL 程序在每一行和每个子程序中花费的时间。 另请参阅: “plsql_plprofiler ” 372 第 14 章 语言元素 14章 语言元素 第 14.1 赋值语句 赋值语句将数据项的值设置为有效值。 语法 assignment_statement ::= assignment_statement_target := expression ; assignment_statement_target ::= { collection_variable [ ( index ) ] | cursor_variable | object[.attribute] | out_parameter | placeholder | record_variable[.field] | scalar_variable } 373 第 14 章 语言元素 placeholder ::= :host_variable (expression ::=) 语义 assignment_statement expression 其值要分配给 assignment_statement_target 的表达式。 表达式和 assignment_statement_target 必须具有兼容的数据类型。 注意: 具有相同类型的元素的集合可能没有相同的数据类型。 assignment_statement_target 要为其分配表达式的值的数据项。 collection_variable 374 第 14 章 语言元素 集合变量的名称。 index collection_variable 元素的索引。如果没有索引，整个集合变量都是赋值语句的目标。 索 引 必 须 是 一 个 数 字 表 达 式， 其 数 据 类 型 为 PLS_INTEGER 或可以隐式转换为 PLS_INTEGER。 cursor_variable 游标变量的名称。 object 抽象数据类型 (ADT) 的实例的名称。 attribute 对象的属性的名称。如果没有属性，整个 ADT 都是赋值语句的目标。 out_parameter 出现赋值语句的子程序的正式的 OUT 或 INOUT 参数的名称。 record_variable 一个记录变量的名称。 field record_variable 的一个字段的名称。如果没有字段，整个记录变量都是赋值语句的目标。 scalar_variable PL/SQL 标量变量的名称。 placeholder :host_variable 在 PL/SQL 环境中声明并作为绑定变量传递给 PL/SQL 的变量的名称。不要在冒号（：）和 host_variable 之间放置空格。 14.2 AUTONOMOUS_TRANSACTION 编译指示 AUTONOMOUS_TRANSACTION pragma 将程序标记为自治的；即独立于主事务。 在这种情况下，程序是以下之一： • 模式级（非嵌套）匿名 PL/SQL 块 • 独立子程序、包子程序 • ADT 的方法 375 第 14 章 语言元素 语法 autonomous_trans_pragma ::= PRAGMA AUTONOMOUS_TRANSACTION ; 示例 • 示例 7-39，“在包中声明自治功能” • 示例 7-40，“声明自治独立过程” • 示例 7-41，“声明自治 PL/SQL 块” • 示例 7-42，“调用自治函数” 14.3 基本 LOOP 语句 随着基本 LOOP 语句的每次迭代，它的语句运行并且控制返回到循环的顶部。当 LOOP 循环内的语句将控制转 移到循环外或引发异常时，该语句结束。 语法 basic_loop_statement ::= LOOP statement... END LOOP [ label ] ; (statement ::=) 语义 basic_loop_statement statement 为了防止无限循环，至少有一条语句必须将控制转移到循环之外。可以将控制转移到循环外的 语句是： • “CONTINUE 语句”（当它将控制转移到封闭标记循环的下一次迭代时） • “EXIT 语句” 376 第 14 章 语言元素 • “GOTO 语句” • “RAISE 语句” label 标识 basic_loop_statement 的标签（参见statement ::= 和label ::= ）。CONTINUE、EXIT 和 GOTO 语句可以引用这个标签。 标签提高了可读性，尤其是当 LOOP 语句嵌套时，但前提是您确保 END LOOP 语句中的标签 与同一 LOOP 语句开头的标签匹配。 示例 示例 14-1 带有 EXIT WHEN 语句的嵌套、带标签的基本 LOOP 语句 在这个例子中，一个基本的 LOOP 语句嵌套在另一个语句中，并且两者都有标签。内循环有两个 EXIT WHEN 语句；一个退出内循环，一个退出外循环。 \set SQLTERM / DECLARE i INTEGER := 0; j INTEGER; k INTEGER := 0; BEGIN <> LOOP i := i + 1; j := 0; <> LOOP j := j + 1; k := k + i * j; EXIT inner_loop WHEN (j > 5); EXIT outer_loop WHEN ((i * j) > 15); END LOOP inner_loop; END LOOP outer_loop; raise notice 'The sum of products equals: %', k; END; / 结果： NOTICE: The sum of products equals: 166 示例 14-2 带有 EXIT WHEN 语句的嵌套、未标记的基本 LOOP 语句 仅当外部循环被标记时，内部循环中的 EXIT WHEN 语句才能将控制权转移到外部循环。 在这个例子中，外部循环没有被标记；因此，内部循环无法将控制权转移给它。 377 第 14 章 语言元素 \set SQLTERM / DECLARE i INTEGER := 0; j INTEGER := 0; BEGIN LOOP i := i + 1; raise notice 'i = %', i; LOOP j := j + 1; raise notice 'j = %', j; EXIT WHEN (j > 3); END LOOP; raise notice 'Exited inner loop'; EXIT WHEN (i > 2); END LOOP; raise notice 'Exited outer loop'; END; / 结果： NOTICE: i = 1 NOTICE: j = 1 NOTICE: j = 2 NOTICE: j = 3 NOTICE: j = 4 NOTICE: Exited inner loop NOTICE: i = 2 NOTICE: j = 5 NOTICE: Exited inner loop NOTICE: i = 3 NOTICE: j = 6 NOTICE: Exited inner loop NOTICE: Exited outer loop 相关话题 • 游标 FOR LOOP 语句 • FOR LOOP 语句 378 第 14 章 语言元素 • WHILE LOOP 语句 • 基本 LOOP 语句 14.4 块 将相关声明和语句分组的块是 PL/SQL 源程序的基本单元。 它有一个可选的声明部分、一个必需的可执行部分和一个可选的异常处理部分。声明是块的本地声明，并且在块 完成执行时不再存在。块可以嵌套。 匿名块是可执行语句。 语法 plsql_block ::= [ DECLARE declare_section ] body (body ::=) declare_section::= { item_list_1 [ item_list_2 ] | item_list_2 } (item_list_2 ::=) item_list_1 ::= { type_definition | cursor_declaration | item_declaration | function_declaration | procedure_declaration 379 第 14 章 语言元素 } ... ( type_definition ::= , cursor_declaration ::= , item_declaration ::= , function_declaration ::= , procedure_declaration ::= ) item_list_2 ::= { cursor_declaration | cursor_definition | function_declaration | function_definition | procedure_declaration | procedure_definition } ... 380 第 14 章 语言元素 ( cursor_declaration ::= , cursor_definition ::= , function_declaration ::= , function_definition ::= , procedure_declaration ::= , procedure_definition ::= ) type_definition ::= { collection_type_definition | record_type_definition | ref_cursor_type_definition | subtype_definition } ( collection_type_definition ::= , record_type_definition ::= , ref_cursor_type_definition ::= , function_definition ::= , subtype_definition ::= ) subtype_definition ::= SUBTYPE subtype IS base_type [ constraint ] [ NOT NULL ] constraint ::= { precision [, scale ] | RANGE low_value .. high_value } 381 第 14 章 语言元素 item_declaration ::= { collection_variable_decl | constant_declaration | cursor_variable_declaration | exception_declaration | record_variable_declaration | variable_declaration } ( collection_variable_decl ::= , constant_declaration ::= , cursor_variable_declaration ::= , exception_declaration ::= , record_variable_declaration ::= , variable_declaration ::= ) body ::= BEGIN statement ... [ EXCEPTION exception_handler [ exception_handler ]... ] END [ name ] ; ( exception_handler ::= ) statement ::= [ << label >>[<< label >> ] ...] { assignment_statement | basic_loop_statement | case_statement 382 第 14 章 语言元素 | close_statement | continue_statement | cursor_for_loop_statement | execute_immediate_statement | exit_statement | fetch_statement | for_loop_statement | forall_statement | goto_statement | if_statement | null_statement | open_statement | open_for_statement | pipe_row_statement | plsql_block | procedure_call | raise_statement | return_statement | select_into_statement | sql_statement | while_loop_statement } 383 第 14 章 语言元素 384 第 14 章 语言元素 ( plsql_block ::= , procedure_call ::= , sql_statement ::= ) procedure_call ::= procedure [ ( [ parameter [, parameter ]... ] ) ] ; sql_statement ::= { commit_statement | collection_method_call | delete_statement | insert_statement | lock_table_statement | merge_statement | rollback_statement | savepoint_statement | set_transaction_statement | update_statement } 385 第 14 章 语言元素 语义 plsql_block label 未声明的标识符，对块来说是唯一的。 DECLARE 开始块的声明部分。 declare_section 包含局部声明，仅存在于块及其子块中，对封闭块不可见。 对 declare_section 的限制 create_package 、create_package_body 不 能 包 含 PRAGMA AUTONOMOUS_TRANSACTION 。 嵌套子程序不能包含 PRAGMA AUTONOMOUS_TRANSACTION 。 触发器不能包含 PRAGMA AUTONOMOUS_TRANSACTION 。 另请参阅: CREATE PACKAGE 声明 了解更多关于 create_package 386 第 14 章 语言元素 CREATE PACKAGE BODY 声明 了解更多关于 create_package_body subtype_definition 静态表达式可用于子类型声明。有关详细信息，请参阅静态表达式。 subtype 您正在定义的用户定义子类型的名称。 base_type 您正在定义的子类型的基本类型。base_type 可以是任何标量或用户定义的 PL/SQL 数据类型 说明符，例如 CHAR,DATE 或 RECORD。 NOT NULL 对使用此子类型声明的数据项施加 NOT NULL 约束。有关此约束的信息，请参阅NOT NULL 约束 。 constraint 指定数值数据类型的子类型的约束。 constraint 限制 如果 base_type 不是数字数据类型，则不要指定约束。 precision 指定数值数据类型的受约束子类型的精度。 precision 限制 如果 base_type 无法指定精度，则不要指定精度。 scale 指定数值数据类型的约束子类型的比例。 scale 限制 如果 base_type 无法指定比例，请不要指定比例。 RANGE low_value .. high_value 指定数值数据类型的受约束子类型的范围。low_value 和 high_value 必须是数字文字。 RANGE high_value .. low_value 的限制 仅当 base_type 是 PLS_INTEGER 或 PLS_INTEGER 的子类型（预定义或用户定 义）时才指定此子句。 body BEGIN 启动块的可执行部分，其中包含可执行语句。 387 第 14 章 语言元素 EXCEPTION 启动块的异常处理部分。当 PL/SQL 引发异常时，块的正常执行停止并且控制转移到适当的异 常处理程序。异常处理程序完成后，继续执行块后面的语句。有关异常处理的更多信息，请参 阅异常处理 。 exception_handler 请参阅异常处理程序 。 END 结束块。 name 适用的块的名称 END ——标签、函数名称、过程名称或包名称。 statement label 未声明的标识符，对语句来说是唯一的。 assignment_statement 请参阅赋值语句 。 basic_loop_statement 请参阅基本 LOOP 语句 。 case_statement 请参阅CASE 语句 。 close_statement 请参阅CLOSE 语句 。 collection_method_call 调用这些集合方法之一，它们是过程： • DELETE • EXTEND • TRIM 有关语法，请参阅集合方法调用 。 continue_statement 请参阅CONTINUE 语句 。 cursor_for_loop_statement 请参阅游标 FOR LOOP 语句 。 388 第 14 章 语言元素 execute_immediate_statement 请参阅EXECUTE IMMEDIATE 语句 。 exit_statement 请参阅EXIT 语句 。 fetch_statement 请参阅FETCH 语句 。 for_loop_statement 请参阅FOR LOOP 语句 。 forall_statement 请参阅FORALL 语句 。 goto_statement 请参阅GOTO 语句 。 if_statement 请参阅IF 语句 。 null_statement 请参阅NULL 语句 。 open_statement 请参阅OPEN 语句 。 open_for_statement 请参阅OPEN FOR 语句 。 pipe_row_statement 请参阅PIPE ROW 语句 。 对 pipe_row_statement 的限制 该语句只能出现在 pipelined 函数的主体中；否则，PL/SQL 会引发异常。 raise_statement 请参阅RAISE 语句 。 return_statement 请参阅RETURN 语句 。 select_into_statement 请参阅SELECT INTO 语句 。 while_loop_statement 389 第 14 章 语言元素 请参阅WHILE LOOP 语句 。 procedure_call procedure 您正在调用的过程的名称。 parameter [, parameter ]... 被调用函数的实际参数列表。每个实参的数据类型必须与对应的形参的数据类型兼容。形参的 模式决定了实参可以是什么： • 形式参数模式为 IN，实际参数为常量、初始化变量、文字或表达式 • 形式参数模式为 OUT，实际参数为数据类型未定义为 NOT NULL 的变量 • 形式参数模式为 IN OUT，实际参数为变量（通常是字符串缓冲区或数字累加器） 如果函数为参数指定默认值，您可以从参数列表中省略该参数。如果函数没有参数，或者为每 个参数指定一个默认值，您可以省略参数列表或指定一个空的参数列表。 另请参阅: 实际参数的位置、命名和混合表示法 sql_statement commit_statement SQL COMMIT 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。 delete_statement SQL DELETE 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。另请参阅DELETE 语句扩展 。 insert_statement SQL INSERT 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。另见INSERT 语句 扩展 。 lock_table_statement SQL LOCK TABLE 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。 merge_statement SQL MERGE 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。 rollback_statement SQL ROLLBACK 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。 savepoint_statement SQL SAVEPOINT 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。 set_transaction_statement 390 第 14 章 语言元素 SQL SET TRANSACTION 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。 update_statement SQL UPDATE 语句。有关语法，请参阅《KingbaseES SQL 语言参考手册》。另请参阅UPDATE 语句扩展 。 示例 • 示例 2-1，“PL/SQL 块结构” 相关话题 • 注释” • 块” • 标识符” • PL/SQL 数据类型 • 用户定义的 PL/SQL 子类型 14.5 CASE 语句 CASE 语句从一系列条件中进行选择并运行相应的语句。 简单 CASE 语句计算单个表达式并将其与几个潜在值进行比较。 搜索 CASE 语句计算多个布尔表达式并选择第一个值为 TRUE 的表达式。 语法 simple_case_statement ::= [ <> ] CASE case_operand WHEN boolean_expression THEN statement ; [ WHEN boolean_expression THEN statement ; ]... [ ELSE statement [ statement ]... ; END CASE [ label ] ; 391 第 14 章 语言元素 searched_case_statement ::= [ <> ] CASE WHEN boolean_expression THEN statement ; [ WHEN boolean_expression THEN statement ; ]... [ ELSE statement [ statement ]... ; END CASE [ label ]; ( boolean_expression ::= , statement ::= ) 语义 simple_case_statement selector 其值被评估一次并用于选择多个备选方案之一的表达式。selector 可以具有除 BLOB、BFILE 或用户定义类型之外的任何 PL/SQL 数据类型。 WHEN selector_value THEN statement selector_value 可以是除 BLOB、BFILE 或用户定义类型之外的任何 PL/SQL 类型的表达 式。 selector_value 是按顺序计算的。如果 selector_value 的值等于 selector 的值，则与该 selector_value 关联的语句运行，并且 CASE 语句结束。随后的 selector_value 不会被评 估。 警告: 语句可以修改数据库并调用非确定性函数。没有像 C switch 语句中那样的贯穿机制。 ELSE statement [statement ]... 当且仅当没有 selector_value 具有与 selector 相同的值时，语句才会运行。如果没有 ELSE 子句，如果没有 selector_value 与 selector 具有相同的值，则系统会引发预定义的异常 CASE_NOT_FOUND。 label 标识语句的标签（参见statement ::= 和label ::= ）。 392 第 14 章 语言元素 searched_case_statement WHEN boolean_expression THEN statement boolean_expressions 则与该 是 按 顺 序 计 算 的。 如 果 boolean_expression boolean_expression 关 联 的 语 句 运 行， 并 且 CASE 的值为 TRUE， 语 句 结 束。 不 评 估 后 续 的 boolean_expressions 。 警告: 语句可以修改数据库并调用非确定性函数。没有像 C switch 语句中那样的贯穿机 制。 ELSE statement [statement ]... 当且仅当没有 boolean_expression 的值为 TRUE 时，语句才会运行。如果没有 ELSE 子 句， 如 果 没 有 boolean_expression 的值为 TRUE， 则 系 统 会 引 发 预 定 义 的 异 常 CASE_NOT_FOUND。 label 标识语句的标签（参见statement ::= 和label ::= ）。 示例 • 示例 4-2，“打印 BOOLEAN 值” • 示例 5-6，“简单 CASE 语句” • 示例 5-7，“搜索 CASE 语句” 相关话题 在其他章节： • CASE 表达式 • 条件选择语句” • 简单 CASE 语句” • 搜索 CASE 语句” 14.6 CLOSE 语句 该 CLOSE 语句关闭命名游标，释放其资源以供重用。 关闭显式游标后，您可以使用 OPEN 语句重新打开它。您必须先关闭显式游标，然后再重新打开它。 关闭游标变量后，您可以使用 OPEN FOR 语句重新打开它。您无需在重新打开游标变量之前关闭它。 语法 393 第 14 章 语言元素 close_statement ::= CLOSE { cursor | cursor_variable } ; 语义 close_statement cursor 打开的显式游标的名称。 cursor_variable 打开的游标变量的名称。 示例 • 示例 7-6，“LOOP 语句中的 FETCH 语句” 相关话题 在本章节： • FETCH 语句 • OPEN 语句 • OPEN FOR 语句 在其他章节： • 打开和关闭显式游标 • 打开和关闭游标变量 14.7 集合方法调用 集合方法是一个 PL/SQL 子程序，它要么返回有关集合的信息，要么对集合进行操作。 语法 collection_method_call ::= collection.{ COUNT | DELETE [ ( index [, index ]... ) ] | EXISTS [ ( index ) ] 394 第 14 章 语言元素 | EXTEND [ ( index [, index ]... ) ] | FIRST | LAST | LIMIT | NEXT ( index ) | PRIOR ( index ) | TRIM ( number ) } 语义 collection_method_call 395 第 14 章 语言元素 collection 您正在调用其方法的集合的名称。 COUNT 返回集合中元素数量的函数，在COUNT 方法 中进行了说明。 DELETE 从集合中删除元素的过程，在DELETE 方法 中进行了说明。 对 DELETE 的限制 如果 collection 是一个可变数组，则不能使用 DELETE . index 数据类型为 PLS_INTEGER 或可隐式转换为 PLS_INTEGER 的数值表达式。 EXISTS 如果集合的索引元素存在则返回 TRUE 否则返回 FALSE 的函数，在EXISTS 方法 中进行了说 明。 EXTEND 将元素添加到集合末尾的过程，在EXTEND 方法 中进行了说明。 EXTEND 限制 如果集合是关联数组，则不能使用 EXTEND 。 FIRST 返回集合中第一个索引的函数，在FIRST 和 LAST 方法 中进行了说明。 LAST 返回集合中最后一个索引的函数，在FIRST 和 LAST 方法 中进行了说明。 LIMIT 返回集合可以拥有的最大元素数的函数。如果集合没有最大大小，则 LIMIT 返回 NULL。例 如，请参阅LIMIT 方法 。 NEXT 返回集合的后续现有元素的索引的函数（如果存在）。否则，NEXT 返回 NULL。有关详细信 息，请参阅PRIOR 和 NEXT 方法 。 PRIOR 返回集合的前一个现有元素（如果存在）的索引的函数。否则，PRIOR 返回 NULL。有关详细 信息，请参阅PRIOR 和 NEXT 方法 。 TRIM 396 第 14 章 语言元素 从集合末尾删除元素的过程，在TRIM 方法 中进行了说明。 对 TRIM 的限制 如果集合是关联数组，则不能使用 TRIM。 number 要从集合末尾删除的元素数。默认值：一个。 示例 • 示例 6-15，“使用嵌套表的 DELETE 方法” • 示例 6-16，“使用字符串索引的关联数组的 DELETE 方法” • 示例 6-17，“带有嵌套表的 TRIM 方法” • 示例 6-18，“嵌套表的 EXTEND 方法” • 示例 6-19，“带有嵌套表的 EXISTS 方法” • 示例 6-20，“PLS_INTEGER 索引的关联数组的 FIRST 和 LAST 值” • 示例 6-21，“由字符串索引的关联数组的 FIRST 和 LAST 值” • 示例 6-22，“在 FOR LOOP 中使用 FIRST 和 LAST 打印 Varray” • 示例 6-23，“在 FOR LOOP 中使用 FIRST 和 LAST 打印嵌套表” • 示例 6-24，“Varray 的 COUNT 和 LAST 值” • 示例 6-25，“嵌套表的 COUNT 和 LAST 值” • 示例 6-26，“不同集合类型的 LIMIT 和 COUNT 值” • 示例 6-27，“PRIOR 和 NEXT 方法” • 示例 6-28，“打印稀疏嵌套表的元素” 14.8 集合变量声明 集合变量是一个复合变量，其内部组件（称为元素）具有相同的数据类型。 集合变量的值及其元素的值可以更改。 您通过其名称引用整个集合。您使用语法 collection(index) 引用集合元素。 PL/SQL 有三种集合类型： • 关联数组（以前称为 PL/SQL 表或索引表） • 可变大小数组（varray） • 嵌套表 397 第 14 章 语言元素 关联数组可以通过字符串类型或整数索引。可变数组和嵌套表由整数索引。 您可以通过以下任一方式创建集合变量： • 定义一个集合类型，然后声明该类型的变量。 • 用于%TYPE 声明与先前声明的集合变量具有相同类型的集合变量。 注意: 本主题适用于您在 PL/SQL 块或包中定义的集合类型，它不同于您使用“CREATE TYPE 语句”创建的独立 集合类型。 在 PL/SQL 块或包中，您可以定义所有三种集合类型。使用该 CREATE TYPE 语句，您可以创建嵌套表类型 和 VARRAY 类型，但不能创建关联数组类型。 语法 collection_type_definition ::= TYPE type IS { assoc_array_type_def | varray_type_def | nested_table_type_def } ; assoc_array_type_def ::= TABLE OF datatype [ NOT NULL ] INDEX BY { PLS_INTEGER | BINARY_INTEGER | VARCHAR2 ( v_size ) | data_type } ( datatype ::= ) 398 第 14 章 语言元素 varray_type_def ::= { VARRAY | [ VARYING ] ARRAY } ( size_limit ) OF datatype [ NOT NULL ] ( datatype ::= ) nested_table_type_def ::= TABLE OF datatype [ NOT NULL ] ( datatype ::= ) collection_variable_decl ::= new_collection_var { assoc_array_type [ := function_call | collection_var_1 ] | ({varray_type | nested_table_type [ := { collection_constructor | collection_var_1 } ] | collection_var_2%TYPE } ; ( collection_constructor ::= , function_call ::= ) 语义 collection_type_definition 399 第 14 章 语言元素 type 您正在定义的集合类型的名称。 assoc_array_type_def 关联数组的类型定义。 对 assoc_array_type_def 的限制 只能出现在块、子程序、包规范或包主体的声明部分。 datatype 关联数组元素的数据类型。datatype 可以是任何 PL/SQL 数据类型，除了 REF CURSOR. NOT NULL 对关联数组的每个元素施加 NOT NULL 约束。有关此约束的信息，请参阅NOT NULL 约束 。 { PLS_INTEGER | BINARY_INTEGER } 指定关联数组的索引的数据类型是 PLS_INTEGER。 { VARCHAR2 | VARCHAR | STRING } ( v_size ) 指定关联数组索引的数据类型是长度为 v_size 的 VARCHAR2（或其子类型 VARCHAR 或 STRING）。 您可以使用 TO_CHAR 函数转换为 VARCHAR2 的任何类型的值填充关联数组的元 素。 LONG 指定关联数组的索引的数据类型是 LONG，相当于 VARCHAR2(32760)。 type_attribute, rowtype_attribute 指定关联数组的索引的数据类型是用%ROWTYPE 或指定的数据类型%TYPE。此数据类型必 须表示 PLS_INTEGER、BINARY_INTEGER 或 VARCHAR2(v_size)。 varray_type_def 可变大小数组的类型定义。 size_limit 可变数组可以拥有的最大元素数。size_limit 必须是 1 到 2147483647 范围内的整数文字。 datatype 可变数组元素的数据类型。datatype 可以是任何 PL/SQL 数据类型，除了 REF CURSOR. NOT NULL 对可变数组的每个元素施加 NOT NULL 约束。有关此约束的信息，请参阅NOT NULL 约束 。 nested_table_type_def 400 第 14 章 语言元素 嵌套表的类型定义。 datatype 嵌套表元素的数据类型。datatype 可以是除 REF CURSOR 或 NCLOB 之外的任何 PL/ SQL 数据类型。如果 datatype 是标量类型，则嵌套表具有该类型的单个列，称为 COLUMN_VALUE。 如果 datatype 是 ADT，则嵌套表的列与 ADT 的名称和属性匹配。 NOT NULL 对嵌套表的每个元素施加 NOT NULL 约束。有关此约束的信息，请参阅NOT NULL 约束 。 collection_variable_decl new_collection_var 要声明的集合变量的名称。 assoc_array_type 先前定义的关联数组类型的名称；new_collection_var 的数据类型。 varray_type 先前定义的 VARRAY 类型的名称；new_collection_var 的数据类型。 nested_table_type 先前定义的嵌套表类型的名称；new_collection_var 的数据类型。 collection_constructor new_collection_var 数据类型的集合构造函数，它提供了 new_collection_var 的初始值。 collection_var_1 先前声明的与 “new_collection_var“具 有 相 同 数 据 类 型 的 集 合 变 量 的 名 称， 它 提 供 了 new_collection_var 的初始值。 注意: collection_var_1 并且 new_collection_var 必须具有相同的数据类型，而不仅仅是相同 类型的元素。 collection_var_2 先前声明的集合变量的名称。 %TYPE 请参阅%TYPE 属性 。 示例 • 示例 6-1，“由字符串索引的关联数组” 401 第 14 章 语言元素 • 示例 6-2，“函数返回由 PLS_INTEGER 索引的关联数组” • 示例 6-4，“Varray（可变大小数组）” • 示例 6-5，“本地类型的嵌套表” • 示例 6-10，“二维 Varray 数组（数组的数组）” • 示例 6-11，“嵌套表的嵌套表及整型 Varray 数组的嵌套表” 注释 14.9 注释是 PL/SQL 编译器忽略的源程序文本。它的主要目的是记录代码，但您也可以使用它来禁用过时或未完成 的代码（也就是说，您可以将代码变成注释）。PL/SQL 有单行和多行注释。 语法 comment ::= { -- text | } 语义 comment -将行的其余部分变成单行注释。任何换行到下一行的文本都不是注释的一部分。 结束注释。 text 任何文字。 text 限制 在多行注释中，text 不能包含多行注释分隔符/或/. 因此，一个多行注释不能包含另一 个多行注释。但是，多行注释可以包含单行注释。 示例 402 第 14 章 语言元素 • 示例 3-5，“单行注释” • 示例 3-7，“单行注释” 常量声明 14.10 常量保存一个不变的值。常量声明指定常量的名称、数据类型和值，并为其分配存储空间。声明也可以施加 NOT NULL 约束。 语法 constant_declaration ::= constant CONSTANT datatype [NOT NULL] { := | DEFAULT } expression ; ( datatype ::= , expression ::= ) 语义 constant_declaration constant 您要声明的常量的名称。 datatype 可以用初始值声明变量的数据类型。 NOT NULL 对常量施加 NOT NULL 约束。 有关此约束的信息，请参阅NOT NULL 约束 。 expression 常 量 的 初 始 值。expression 必 须 具 有 与 数 据 类 型 兼 容 的 数 据 类 型。 当 细 化 constant_declaration 时，将表达式的值赋给 constant 。 示例 • 示例 3-12，“带有初始值的变量和常量声明” • 示例 3-13，“默认情况下变量初始化为 NULL” 相关话题 在本章节： 403 第 14 章 语言元素 • 集合变量声明 • 记录变量声明 • %ROWTYPE 属性 • 标量变量声明 • %TYPE 属性 14.11 CONTINUE 语句 该 CONTINUE 语句有条件地或无条件地退出循环的当前迭代，并将控制权转移到当前循环或封闭标记循环的下 一次迭代。 如果 CONTINUE 语句过早退出游标 FOR 循环（例如，退出内循环并将控制权转移到外循环的下一次迭代）， 游标将关闭（在此上下文中，CONTINUE 工作方式类似于 GOTO）。 CONTINUE WHEN 语句在其 WHEN 子句中的条件为真时退出循环的当前迭代，并将控制权转移到当前循环或 封闭标记循环的下一次迭代。 每次控制到达语句时，都会评估 CONTINUE WHEN 其子句中的条件。WHEN 如果条件不成立，则该 CONTINUE WHEN 语句不执行任何操作。 CONTINUE 语句的限制 • CONTINUE 语句必须在语句内部 LOOP。 • CONTINUE 语句不能跨越子程序或方法边界。 语法 continue_statement ::= CONTINUE [ label ] [ WHEN boolean_expression ] ; (boolean_expression ::=) 语义 continue_statement label 标识当前循环或封闭循环的名称。 404 第 14 章 语言元素 如果没有 label，则该 CONTINUE 语句将控制权转移到当前循环的下一次迭代。使用 label， CONTINUE 语句将控制转移到 label 标识的循环的下一次迭代。 WHEN boolean_expression 如果没有此子句，CONTINUE 语句将无条件退出循环的当前迭代。使用此子句，当且仅当 boolean_expression 的值为 TRUE 时，CONTINUE 语句退出循环的当前迭代。 示例 示例 14-3 基本 LOOP 语句中的 CONTINUE 语句 在此示例中，CONTINUE 基本 LOOP 语句中的语句无条件地将控制权转移到当前循环的下一次迭代。 \set SQLTERM / DECLARE i INTEGER := 1; BEGIN LOOP raise notice 'Inside loop: i = %', TO_CHAR(i); i := i + 1; IF i < 4 THEN CONTINUE; END IF; raise notice 'Inside loop, after CONTINUE: i = %', TO_CHAR(i); EXIT WHEN i = 6; END LOOP; raise notice 'After loop: i = %', TO_CHAR(i); END; / 结果： NOTICE: Inside loop: i = 1 NOTICE: Inside loop: i = 2 NOTICE: Inside loop: i = 3 NOTICE: Inside loop, after CONTINUE: NOTICE: Inside loop: NOTICE: Inside loop, after CONTINUE: NOTICE: Inside loop: NOTICE: Inside loop, after CONTINUE: NOTICE: After loop: i = 4 i = 4 i = 5 i = 5 i = 6 i = 6 示例 14-4 基本 LOOP 语句中的 CONTINUE WHEN 语句 在此示例中，当 i 小于 4 时，基本 LOOP 语句中的 CONTINUE WHEN 语句将控制权转移到当前循环的下一次 迭代。 405 第 14 章 语言元素 \set SQLTERM / DECLARE i INTEGER := 1; BEGIN LOOP raise notice 'Inside loop: i = %', TO_CHAR(i); i := i + 1; CONTINUE WHEN i < 4; raise notice 'Inside loop, after CONTINUE: i = %', TO_CHAR(i); EXIT WHEN i = 6; END LOOP; raise notice 'After loop: i = %', TO_CHAR(i); END; / 结果： NOTICE: Inside loop: i = 1 NOTICE: Inside loop: i = 2 NOTICE: Inside loop: i = 3 NOTICE: Inside loop, after CONTINUE: NOTICE: Inside loop: NOTICE: Inside loop, after CONTINUE: NOTICE: Inside loop: NOTICE: Inside loop, after CONTINUE: NOTICE: After loop: i = 4 i = 4 i = 5 i = 5 i = 6 i = 6 相关话题 • 循环语句 以获得更多概念信息 • 基本 LOOP 语句 了解有关标记循环的更多信息 • 游标 FOR LOOP 语句 • EXIT 语句 • 表达式 • FOR LOOP 语句 • WHILE LOOP 语句 406 第 14 章 语言元素 游标 FOR LOOP 语句 14.12 游标 FOR LOOP 语句将其循环索引隐式声明为指定游标返回的行类型的记录变量，然后打开游标。每次迭代 时，游标 FOR LOOP 语句从结果集中取出一行到记录中。当没有更多行要获取时，游标 FOR LOOP 语句将关闭游 标。如果循环内的语句将控制转移到循环外或引发异常，游标也会关闭。 语法 cursor_for_loop_statement ::= FOR record IN { cursor [ ( cursor_parameter_dec [ [,] cursor_parameter_dec ]... )] | ( select_statement ) } LOOP statement... END LOOP [label] ; (statement ::=) 语义 cursor_for_loop_statement record 游标 FOR LOOP 语句隐式声明为游标或 select_statement 返回类型的%ROWTYPE 记录变 量的循环索引的名称。 记录对于游标 FOR LOOP 语句是本地的。循环内的语句可以引用记录及其字段。他们只能通 过别名引用虚拟列。循环外的语句不能引用记录。游标 FOR LOOP 语句运行结束后，记录是 未定义的状态。 cursor 输入游标 FOR LOOP 时未打开的显式游标（不是游标变量）的名称。 actual_cursor_parameter 407 第 14 章 语言元素 与游标的形参对应的实参。 select_statement SQL SELECT 语句（不是 PL/SQL SELECT INTO 语句）。对于 select_statement ，PL/ SQL 声明、打开、获取和关闭隐式游标。但是，因为 select_statement 不是一个独立的语 句，所以隐式游标是内部的——您不能使用名称 SQL 来引用它。 label 标识 cursor_for_loop_statement 的标签（参见statement ::= , label ::= ）。CONTINUE、 EXIT 和 GOTO 语句可以引用这个标签。 标签提高了可读性，尤其是当 LOOP 语句嵌套时，但前提是您确保 END LOOP 语句中的标签 与同一 LOOP 语句开头的标签匹配。 示例 在本章节： • 示例 7-18，“隐式游标 FOR LOOP 语句” • 示例 7-19，“显式游标 FOR LOOP 语句” • 示例 7-20，“将参数传递给显式游标 FOR LOOP 语句” • 示例 7-21，“游标 FOR 循环引用虚拟列” 在其他章节： • 使用游标 FOR LOOP 语句处理查询结果集 14.13 游标变量声明 游标变量就像一个显式游标，不限于一个查询。 要创建游标变量，要么声明预定义类型 SYS_REFCURSOR 的变量，要么定义 REF CURSOR 类型，然后声明 该类型的变量。 游标变量的限制 • 您不能在包规范中声明游标变量。也就是说，包不能有公共游标变量（可以从包外部引用的游标变量）。 • 您不能将游标变量的值存储在集合或数据库列中。 • 您不能使用比较运算符来测试游标变量是否相等、不等或为空。 语法 ref_cursor_type_definition ::= TYPE type IS REF CURSOR [ RETURN { {db_table_or_view | cursor | cursor_variable}%ROWTYPE 408 第 14 章 语言元素 | record%TYPE | record_type | ref_cursor_type } ] ; cursor_variable_declaration ::= cursor_variable type; 语义 ref_cursor_type_definition type 您正在定义的 REF CURSOR 类型的名称。 RETURN 指定 RETURN 以定义强 REF CURSOR 类型。省略 RETURN 定义弱 REF CURSOR 类型。 有关强类型和弱 REF CURSOR 类型的信息，请参阅创建游标变量 。 db_table_or_view 数据库表或视图的名称，在声明时必须可访问。 cursor 先前声明的显式游标的名称。 cursor_variable 先前声明的游标变量的名称。 record 409 第 14 章 语言元素 用户定义记录的名称。 record_type 使用数据类型声明符 RECORD 定义的用户定义类型的名称。 ref_cursor_type 使用数据类型声明符 REF CURSOR 定义的用户定义类型的名称。 cursor_variable_declaration cursor_variable 您要声明的游标变量的名称。 type 您要声明的游标变量的类型——SYS_REFCURSOR 或您之前定义的 REF CURSOR 类型的名 称。SYS_REFCURSOR 是一个弱类型。有关强和弱 REF CURSOR 类型的信息，请参阅创建 游标变量 。 注意: SYS_REFCURSOR 类型是 REFCURSOR 类型的别名，因此使用到 SYS_REFCURSOR 类型的地方也可以 用 REFCURSOR 类型代替。 示例 • 示例 7-24，“游标变量声明” • 示例 7-25，“具有用户定义的返回类型的游标变量” • 示例 7-28，“游标变量查询中的变量 - 无结果集更改” • 示例 7-29，“游标变量查询中的变量 - 结果集更改” • 示例 7-30，“使用静态 SQL 查询集合” • 示例 7-31，“为一个查询打开游标变量的过程” • 示例 7-32，“为所选查询打开游标变量（返回类型相同）” • 示例 7-33，“为所选查询打开游标变量（不同的返回类型）” 相关话题 在本章节： • CLOSE 语句 • 命名游标属性 • 显式游标声明和定义 • FETCH 语句 • OPEN FOR 语句 410 第 14 章 语言元素 • %ROWTYPE 属性 • %TYPE 属性 在其他章节： • 游标变量 14.14 数据类型属性 ADT 元素的数据类型属性。 数据类型允许您声明记录变量字段、常量、函数返回值、集合变量和集合类型元素的数据类型。 • 记录变量声明 • 常量声明 • 函数声明与定义 • 集合变量声明 • CREATE FUNCTION 语句 • CREATE TYPE 语句 语法 datatype ::= { collection_type | [ REF ] object_type | record_type | ref_cursor_type | rowtype_attribute | scalar_datatype | type_attribute } 411 第 14 章 语言元素 ( rowtype_attribute ::= , type_attribute ::= ) 语义 datatype collection_type 用户定义的可变数组或嵌套表类型的名称（不是关联数组类型的名称）。 object_type 用户定义类型的实例。 record_type 使用数据类型声明符 RECORD 定义的用户定义类型的名称。 ref_cursor_type 使用数据类型声明符 REF CURSOR 定义的用户定义类型的名称。 scalar_datatype 标量数据类型的名称，包括大小、精度和字符或字节语义的任何限定符。 相关话题 在其他章节： • PL/SQL 数据类型 412 第 14 章 语言元素 14.15 DELETE 语句扩展 SQL DELETE 语句的 where_clause 的 PL/SQL 扩展允许您指定一个 CURRENT OF 子句，它将 DELETE 语 句限制为指定游标的当前行。 有关该 CURRENT OF 子句的信息，请参阅UPDATE 语句扩展 。 14.16 DETERMINISTIC 子句 仅兼容语法。 DETERMINISTIC 选项可以出现在以下语句中： • 函数声明与定义 语法 deterministic_clause ::= DETERMINISTIC 语义 deterministic_clause DETERMINISTIC 仅兼容语法。 14.17 元素规范 元素规范指定 ADT 的每个属性。 元素规范可以出现在以下 SQL 语句中： • ALTER TYPE 语句 • CREATE TYPE 语句 语法 element_spec ::= [inheritance_clauses] { subprogram_spec 413 第 14 章 语言元素 | constructor_spec | map_order_function_spec }... ( inheritance_clauses ::= , subprogram_spec ::= , constructor_spec ::= , map_order_function_spec ::= ) inheritance_clauses ::= {[NOT] {FINAL | INSTANTIABLE}}... subprogram_spec ::= { MEMBER | STATIC } { procedure_spec | function_spec } ( procedure_spec ::= , function_spec ::= ) procedure_spec ::= PROCEDURE procedure_name (parameter datatype [, parameter datatype ]...) [ { IS | AS } ] 414 第 14 章 语言元素 function_spec ::= FUNCTION name (parameter datatype [, parameter datatype ]...) return_clause return_clause ::= { RETURN datatype [ { IS | AS } ] } constructor_spec ::= [ FINAL ] [ INSTANTIABLE ] CONSTRUCTOR FUNCTION datatype [ ([ SELF IN OUT datatype, ] parameter datatype [, parameter datatype ]... ) ] RETURN SELF AS RESULT [ { IS | AS } ] 415 第 14 章 语言元素 map_order_function_spec ::= ORDER MEMBER function_spec 语义 element_spec inheritance_clauses 指定当前类型和子类型之间的关系。 [NOT] FINAL 指定这个方法是否可以被当前类型的子类型重写。目前仅兼容语法。 [NOT] INSTANTIABLE 指定当前类型不提供此方法的实现。目前仅兼容语法。 subprogram_spec 指定要作为 ADT 属性引用的子程序。对于每个这样的子程序，您必须在 ADT 主体中指定相应 的方法主体。 MEMBER 与作为属性引用的 ADT 关联的子程序。通常，您以 SELF 的方式调用 MEMBER 方 法，例如 object_expression.method()。此类方法有一个隐式的第一个参数，在方法体 中引用为 SELF，它表示调用该方法的对象。 STATIC 416 第 14 章 语言元素 与 ADT 关联的子程序。与 MEMBER 方法不同，STATIC 方法没有任何隐式参数。你 不能在他们的定义里引用 SELF。它们通常作为 type_name.method() 调用。 对 STATIC 的限制 对于 MEMBER 和 STATIC 方法，您必须在每个过程或函数规范的类型主体中 指定相应的方法主体。 procedure_spec 或 function_spec 指定过程或函数的参数和数据类型。如果该子程序不包括过程或函数的声明，则必须发出相应 的 CREATE TYPE BODY 声明。 return_clause return_clause 的第一种形式仅对函数有效。显示的语法是缩写形式。 constructor_spec 创建一个用户定义的构造函数，它是一个返回 ADT 的初始化实例的函数。如果每个构造函数的 参数在数量、顺序或数据类型上不同，则可以为单个 ADT 声明多个构造函数。 用户定义的构造函数的参数传递模式始终是 SELF IN OUT。因此，除非为了清楚起见，否则无 需指定此子句。 RETURN SELF AS RESULT 指定构造函数返回值的运行时类型是 SELF 参数的运行时类型。 map_order_function_spec OBJECT TYPE 类型中可声明一个 ORDER 方法。 ORDER MENBER ORDER 函数为排序函数。目前仅兼容语法。 14.18 EXCEPTION_INIT 编译指示 EXCEPTION_INIT pragma 将用户定义的异常名称与错误代码相关联。 EXCEPTION_INIT pragma 只能出现在与其关联的异常相同的声明部分中，在异常声明之后的任何位置。 语法 exception_init_pragma ::= PRAGMA EXCEPTION_INIT ( exception, error_code ) ; 语义 417 第 14 章 语言元素 exception_init_pragma exception 先前声明的用户定义异常的名称。 error_code 与异常关联的错误代码。error_code 通常由负整数组成，例如 NO_DATA_FOUND 的 error_code 是“-1403”。 注意: NO_DATA_FOUND 是预定义的异常。 如果两个 EXCEPTION_INIT pragma 将不同的错误代码分配给同一个用户定义的异常，则后面的 pragma 会覆盖前面的 pragma。 示例 • 示例 12-5，“命名内部定义的异常” • 示例 12-6，“使用 RAISE_APPLICATION_ERROR 引发用户定义的异常” • 示例 13-8，“在 FORALL 语句完成后处理 FORALL 异常” 相关话题 在本章节： • 异常声明 • 异常处理程序 • SQLCODE 函数 • SQLERRM 函数 在其他章节： • 存储过程 RAISE_APPLICATION_ERROR 14.19 异常声明 异常声明声明用户定义异常的名称。 您可以使用 EXCEPTION_INIT 编译指示将此名称分配给内部定义的异常。 语法 exception_declaration ::= exception EXCEPTION; 418 第 14 章 语言元素 语义 exception_declaration exception 您要声明的异常的名称。 exception 限制 您只能在 EXCEPTION_INIT pragma、RAISE 语句、RAISE_APPLICATION_ERROR 调用 或异常处理程序中使用异常。 示例 • 示例 12-5，“命名内部定义的异常” • 示例 12-6，“重新声明的预定义标识符” 相关话题 在本章节： • EXCEPTION_INIT 编译指示 • 异常处理程序 • raise 语句 在其他章节： • 用户自定义异常 14.20 异常处理程序 异常处理程序处理引发的异常。 异常处理程序出现在匿名块、子程序、触发器和包的异常处理部分。 语法 exception_handler ::= WHEN { exception [ OR exception ]... | OTHERS } THEN statement [ statement ]... 419 第 14 章 语言元素 (statement ::=) 语义 exception_handler exception 预定义异常（参见PL/SQL 预定义异常表 ）或用户定义异常（参见异常声明 ）的名称。 如果 PL/SQL 引发指定的异常，则相关的语句将运行。 OTHERS 指定块的异常处理部分中未明确指定的所有异常。如果 PL/SQL 引发这样的异常，那么相关的 语句就会运行。 注意: 在块的异常处理部分，WHEN OTHERS 异常处理程序是可选的。它只能出现一次，作为块的异常 处理部分中的最后一个异常处理程序。 示例 • 示例 12-1，“多个异常的单个异常处理程序” • 示例 12-2，“共享异常处理程序的语句的定位器变量” • 示例 12-3，“匿名块处理 ZERO_DIVIDE” • 示例 12-4，“匿名块避免 ZERO_DIVIDE” • 示例 12-6，“声明、引发和处理用户定义的异常” • 示例 12-10，“处理超出范围传播的异常” • 示例 12-24，“异常处理程序运行和执行结束” • 示例 12-25，“异常处理程序运行并继续执行” • 示例 13-8，“在 FORALL 语句完成后处理 FORALL 异常” 相关话题 在本章节： • 块 420 第 14 章 语言元素 • EXCEPTION_INIT 编译指示 • 异常声明 • raise 语句 • SQLCODE 函数 • SQLERRM 函数 在其他章节： • CREATE PACKAGE BODY 语句 • CREATE TRIGGER 语句 14.21 EXECUTE IMMEDIATE 语句 EXECUTE IMMEDIATE 语句在单个操作中构建并运行动态 SQL 语句。 本机动态 SQL 使用 EXECUTE IMMEDIATE 语句来处理大多数动态 SQL 语句。 注意: 使用动态 SQL 时，请注意 SQL 注入，存在安全风险。有关 SQL 注入的更多信息，请参阅SQL 注入 。 语法 execute_immediate_statement ::= EXECUTE IMMEDIATE dynamic_sql_stmt [ { into_clause | bulk_collect_into_clause } [ using_clause ] | using_clause [ dynamic_returning_clause ] | dynamic_returning_clause ] ; ( bulk_collect_into_clause ::= , dynamic_returning_clause ::= , into_clause ::= ) 421 第 14 章 语言元素 using_clause ::= USING [ IN | OUT | IN OUT ] bind_argument [ [,] [ [ IN | OUT | IN OUT ] bind_argument ]... 语义 execute_immediate_statement dynamic_sql_stmt 表示 SQL 语句的字符串文字、字符串变量或字符串表达式。它的类型必须是 CHAR、VARCHAR2 或 CLOB。 into_clause 指定存储语句返回的列值的变量或记录。有关此子句的更多信息，请参阅RETURNING INTO 子句 。 对 into_clause 的限制 当且仅当 dynamic_sql_stmt 返回单行时使用。 bulk_collect_into_clause 指定一个或多个集合来存储语句返回的行。有关此子句的更多信息，请参阅RETURNING INTO 子句 。 对 bulk_collect_into_clause 的限制 当且仅当 dynamic_sql_stmt 可以返回多行时使用。 dynamic_returning_clause 在单个变量或记录中返回受动态 SQL 语句影响的行的列值。有关此子句的更多信息，请参 阅RETURNING INTO 子句 。 对 dynamic_returning_clause 的限制 使用当且仅当 dynamic_sql_stmt 有 RETURNING INTO 子句。 using_clause 使用位置表示法指定绑定变量。 422 第 14 章 语言元素 注意: 如果在 dynamic_sql_statement 中重复占位符名称，请注意占位符与绑定变量的关联方 式取决于动态 SQL 语句的类型。有关详细信息，请参阅动态 SQL 语句中的重复占位符名称 。 using_clause 的限制 当且仅当 dynamic_sql_stmt 包含绑定变量的占位符时使用。 如果 dynamic_sql_stmt 有 RETURNING INTO 子句 ( static_returning_clause)，则 using_clause 只能包含 IN 绑定变量。RETURNING INTO 子句中的绑定 OUT 变量是 定义的绑定变量。 IN, OUT, IN OUT 绑定变量的参数模式。IN 绑定变量将其值传递给 dynamic_sql_stmt 。OUT 绑定变量存储 dynamic_sql_stmt 返回的值。IN OUT 绑定变量将其初始值传递给 dynamic_sql_stmt 并存 储 dynamic_sql_stmt 返回的值。默认值：IN。 对于带有 RETURNING 子句的 DML 语句，您可以将 OUT 绑定变量放在 RETURNING INTO 子句中，而无需指定参数模式，该模式始终为 OUT。 bind_argument 一个表达式，其值在运行时替换 dynamic_sql_stmt 中相应的占位符。 dynamic_sql_stmt 中的每个占位符都必须与 USING 子句或 RETURNING INTO 子句（或两 者）中的 bind_argument 或与 INTO 子句中的定义变量相关联。 您可以使用绑定变量的不同值重复运行 dynamic_sql_stmt 。您会产生一些开销，因为 EXECUTE IMMEDIATE 在每次执行之前都会准备好动态字符串。 注意: 绑定变量可以按任何顺序计算。如果一个程序确定了评估的顺序，那么在程序这样做的 时候，它的行为是未定义的。 bind_argument 的限制 bind_argument 不能是由字符串索引的关联数组。 bind_argument 不能是保留字 NULL。 要将值传递 NULL 给动态 SQL 语句，请在要使用的地方使用未初始化的变量 NULL， 如示例 8-7 所示。 示例 在本章节： • 示例 8-1，“从动态 PL/SQL 块调用子程序” • 示例 8-7，“未初始化的变量在 USING 子句中表示 NULL” 423 第 14 章 语言元素 • 示例 8-9，“动态 PL/SQL 块中的重复占位符名称” 在其他章节： • EXECUTE IMMEDIATE 语句 • DBMS_SQL 包 14.22 EXIT 语句 EXIT 语句有条件地或无条件地退出循环的当前迭代，并将控制转移到当前循环或封闭标记循环的结尾。 EXIT WHEN 语句在其 WHEN 子句中的条件为真时退出循环的当前迭代，并将控制转移到当前循环或封闭标记 循环的结尾。 每次控制到达 EXIT WHEN 语句时，都会评估其 WHEN 子句中的条件。如果条件不成立，则 EXIT WHEN 语 句不执行任何操作。为了防止无限循环，循环内的语句必须使条件为真。 语法 exit_statement ::= EXIT [ label ] [ WHEN boolean_expression ] ; (boolean_expression::=) 语义 exit_statement label 标识当前循环或封闭循环的名称。 如果没有 label，该 EXIT 语句将控制转移到当前循环的结尾。使用 label，该 EXIT 语句将控 制转移到 label 标识的循环的末尾。 WHEN boolean_expression 如 果 没 有 此 子 句，EXIT 语 句 将 无 条 件 退 出 循 环 的 当 前 迭 代。 使 用 此 子 句， 当 且 仅 当 boolean_expression 的值为 TRUE 时，EXIT 语句才退出循环的当前迭代。 示例 示例 14-5 带有 EXIT 语句的基本 LOOP 语句 在此示例中，基本 LOOP 语句中的 EXIT 语句无条件地将控制权转移到当前循环的末尾。 424 第 14 章 语言元素 \set SQLTERM / DECLARE i INTEGER := 1; BEGIN LOOP raise notice 'Inside loop: i = %', TO_CHAR(i); i := i + 2; IF i > 5 THEN EXIT; END IF; END LOOP; -- After EXIT, control resumes here raise notice 'After loop: i = %', TO_CHAR(i); END; / 结果： NOTICE: Inside loop: i = 1 NOTICE: Inside loop: i = 3 NOTICE: Inside loop: i = 5 NOTICE: After loop: i = 7 示例 14-6 带有 EXIT WHEN 语句的基本 LOOP 语句 在此示例中，当 x 大于 3 时，基本 LOOP 语句中的 EXIT WHEN 语句将控制权转移到当前循环的结尾。 \set SQLTERM / DECLARE i INTEGER := 1; BEGIN LOOP raise notice 'Inside loop: i = %', TO_CHAR(i); i := i + 2; EXIT WHEN i > 5; END LOOP; -- After EXIT, control resumes here raise notice 'After loop: i = %', TO_CHAR(i); END; / 结果： NOTICE: Inside loop: i = 1 NOTICE: Inside loop: i = 3 NOTICE: Inside loop: i = 5 425 第 14 章 NOTICE: After loop: 14.23 语言元素 i = 7 显式游标声明和定义 显式游标是指向私有 SQL 区域的命名指针，该区域通常存储用于处理特定查询或 DML 语句的信息，返回或影 响多行。 您可以使用显式游标一次检索一个结果集的行。 在使用显式游标之前，您必须声明和定义它。您可以先声明它（使用 cursor_declaration），然后在同一块、子 程序或包中定义它（使用 cursor_definition），也可以同时声明和定义它（使用 cursor_definition）。 显式游标声明和定义也分别称为游标规范和游标主体。 注意: 包规范中声明的显式游标受包的 AUTHID 子句影响。有关详细信息，请参阅CREATE PACKAGE 语句 。 语法 cursor_declaration ::= CURSOR cursor [( cursor_parameter_dec [, cursor_parameter_dec ]... )] RETURN rowtype; cursor_definition ::= CURSOR cursor [ ( cursor_parameter_dec [, cursor_parameter_dec ]... )] [ RETURN rowtype] IS select_statement ; 426 第 14 章 语言元素 cursor_parameter_dec ::= parameter [IN] datatype [ { := | DEFAULT } expression ] rowtype ::= { {db_table_or_view | cursor | cursor_variable}%ROWTYPE | record%TYPE | record_type } 语义 cursor_declaration cursor 您现在声明的显式游标的名称，稍后将在同一块、子程序或包中定义。cursor 可以是除保留字 SQL 之外的任何标识符。建议不要为游标提供与数据库表相同的名称。 显式游标名称遵循与变量相同的范围规则（请参阅标识符的作用域和可见性 ）。 cursor_definition 要么定义一个先前声明的显式游标，要么同时声明并定义一个显式游标。 cursor 您之前声明和现在正在定义的显式游标的名称，或者您正在声明和定义的显式游标的名称。cursor 可以是除保留字 SQL 之外的任何标识符。建议不要为游标提供与数据库表相同的名称。 427 第 14 章 语言元素 select_statement SQL SELECT 语句（不是 PL/SQL SELECT INTO 语句）。如果游标有形参，则每个形参都 必须出现在 select_statement 中。select_statement 还可以引用其范围内的其他 PL/SQL 变量。 对 select_statement 的限制 这 select_statement 不能有 WITH 子句。 cursor_parameter_dec 游标参数声明。 parameter 您要声明的正式游标参数的名称。这个名字可以出现在任何 select_statement 可以出现常量 的地方。 IN 无论您是否指定 IN，形式游标参数都具有 IN 子程序参数的特征，这些特征总结在表 9-1 中。 当游标打开时，形式参数的值是它的实际参数或默认值。 datatype 参数的数据类型。 datatype 限制 datatype 不能有约束（例如，NOT NULL，数字的精度和小数位数，或字符串的长 度）。 expression 指定正式游标参数的默认值。表达式的数据类型和形式游标参数必须兼容。 如果 OPEN 语句没有为形式游标参数指定实际参数，则该语句计算表达式并将其值分 配给形式游标参数。 如果 OPEN 语句确实为形式游标参数指定了实际参数，则该语句将实际参数的值分配 给形式游标参数并且不计算表达式。 rowtype 游标返回的行的数据类型。此行的列必须与 select_statement 返回的行的列匹配。 db_table_or_view 数据库表或视图的名称，在声明时必须可访问。 cursor 先前声明的显式游标的名称。 cursor_variable 428 第 14 章 语言元素 先前声明的游标变量的名称。 record 先前声明的记录变量的名称。 record_type 使用数据类型声明符 RECORD 定义的用户定义类型的名称。 示例 • 示例 7-5，“显式游标声明和定义” • 示例 7-8，“显式游标查询中的变量 - 无结果集更改” • 示例 7-9，“显式游标查询中的变量 - 结果集更改” • 示例 7-10，“具有需要别名的虚拟列的显式游标” • 示例 7-11，“接受参数的显式游标” • 示例 7-12，“具有默认值的游标参数” • 示例 7-13，“向现有游标添加形式参数” • 示例 7-22，“父查询的 FROM 子句中的子查询” • 示例 7-23，“相关子查询” • 示例 7-37，“在 COMMIT 语句后使用 FOR UPDATE 游标进行 FETCH” 相关话题 在本章节： • close 语句 • 游标 FOR LOOP 语句 • 游标变量声明 • FETCH 语句 • 命名游标属性 • OPEN 语句 • %ROWTYPE 属性 • %TYPE 属性 在其他章节： • 显式游标 • 处理查询结果集 • SELECT FOR UPDATE 和 FOR UPDATE 游标 429 第 14 章 14.24 语言元素 表达式 表达式是操作数（变量、常量、文字、运算符、函数调用和占位符）和运算符的任意复杂组合。 最简单的表达式是单个变量。 PL/SQL 编译器根据构成表达式的操作数和运算符的类型来确定表达式的数据类型。每次计算表达式时，都会产 生一个该类型的值。 语法 expression ::= { boolean_expression | character_expression | collection_constructor | date_expression | numeric_expression | searched_case_expression | simple_case_expression | ( expression ) } ( boolean_expression ::= , character_expression ::= , collection_constructor ::= , date_expression ::= , numeric_expression ::= , searched_case_expression ::= , simple_case_expression ::= ) boolean_expression ::= [ NOT ] { boolean_constant 430 第 14 章 语言元素 | boolean_function_call | boolean_literal | boolean_variable | conditional_predicate | other_boolean_form } [ { AND | OR } [ NOT ] { boolean_constant | boolean_function_call | boolean_literal | boolean_variable | conditional_predicate | other_boolean_form } ]... ( function_call ::= ) boolean_literal ::= { TRUE | FALSE | NULL } 431 第 14 章 语言元素 conditional_predicate ::= { INSERTING | UPDATING [ ( 'column' ) ] | DELETING } other_boolean_form ::= { collection.EXISTS ( index ) | expression { IS [ NOT ] NULL | [ NOT ] { BETWEEN expression AND expression | IN ( expression [, expression ]... ) | LIKE pattern } | relational_operator expression } | { named_cursor | SQL } % { FOUND | ISOPEN | NOTFOUND } } 432 第 14 章 语言元素 ( expression ::= , named_cursor ::= ) character_expression ::= { character_constant | character_function_call | character_literal | character_variable | placeholder] } [|| { character_constant | character_function_call | character_literal | character_variable | placeholder] } [|| { character_constant | character_function_call | character_literal | character_variable | placeholder] } ]... 433 第 14 章 语言元素 ( function_call ::= , placeholder ::= ) collection_constructor ::= collection_type ( [ value [, value]... ]) date_expression ::= { date_constant | date_function_call | date_literal | date_variable | placeholder] } [ { + | - } numeric_expression ] [ { + | - } numeric_expression ] ]... 434 第 14 章 语言元素 ( function_call ::= , placeholder ::= ) numeric_expression ::= numeric_subexpression [ { + | - | * | / } numeric_subexpression ]... numeric_subexpression ::= [ + | - ] { collection . { COUNT | FIRST | LAST | LIMIT | { NEXT | PRIOR } ( index ) } | named_cursor%ROWCOUNT | numeric_constant | numeric_function_call | numeric_literal | numeric_variable | placeholder 435 第 14 章 语言元素 | SQL%{ROWCOUNT | BULK_ROWCOUNT ( index )} } [ ** exponent ] ( function_call ::= , named_cursor ::= , placeholder ::= ) function_call ::= function [ ( [ parameter [, parameter ]... ] ) ] 436 第 14 章 语言元素 searched_case_expression ::= CASE WHEN boolean_expression THEN result_value [ WHEN boolean_expression THEN result_value]... [ ELSE result_value] END (boolean_expression ::=) simple_case_expression ::= CASE case_operand WHEN case_operand_value THEN result_value [ WHEN case_operand_value THEN result_value]... [ ELSE result_value] END 语义 boolean_expression 值为 TRUE、FALSE 或 NULL 的表达式。有关详细信息，请参阅布尔表达式 。 NOT, AND, OR 请参阅逻辑运算符 。 boolean_constant 类型常量的名称 BOOLEAN。 boolean_function_call 调用先前定义的返回 BOOLEAN 值的函数。有关更多语义信息，请参阅function_call 。 boolean_variable 类型变量的名称 BOOLEAN。 conditional_predicate 437 第 14 章 语言元素 请参阅检测触发 DML 语句的条件谓词 。 other_boolean_form collection 集合变量的名称。 EXISTS 如果集合的索引元素存在则返回 TRUE, 否则返回 FALSE 的集合方法（函数）。有关详细信 息，请参阅EXISTS 方法 。 对 EXISTS 的限制 如果集合是关联数组，则不能使用 EXISTS。 index 数据类型为 PLS_INTEGER 或可以隐式转换为 PLS_INTEGER 的数值表达式（有关后者的信 息，请参阅预定义的 PLS_INTEGER 子类型 ）。 IS [NOT] NULL 请参阅IS [NOT] NULL 运算符 。 BETWEEN expression AND expression 请参阅BETWEEN 运算符 。 IN expression [, expression ]... 请参阅IN 运算符 。 LIKE pattern 请参阅LIKE 运算符 。 relational_operator 请参阅关系运算符 。 SQL 与最近运行的 SELECT 或 DML 语句关联的隐式游标。有关详细信息，请参阅隐式游标 。 %FOUND, %ISOPEN, %NOTFOUND 隐式游标属性 和命名游标属性 中解释了游标属性。 character_expression 其值具有字符数据类型（即 CHAR 族中的数据类型，在“CHAR 数据类型族”中描述）的表达式。 character_constant 具有字符数据类型的常量的名称。 character_function_call 438 第 14 章 语言元素 调用先前定义的函数，该函数返回具有字符数据类型或可以隐式转换为字符数据类型的值。有 关更多语义信息，请参阅function_call 。 character_literal 字符数据类型的文字。 character_variable 具有字符数据类型的变量的名称。 || 连接运算符，将一个字符串操作数附加到另一个。有关详细信息，请参阅连接运算符 。 collection_constructor 使用具有指定值的元素构造指定类型的集合。 有关详细信息，请参阅集合的构造函数 。 collection_type 先前声明的嵌套表类型或 VARRAY 类型（不是关联数组类型）的名称。 value collection_type 集合的元素的有效值。 如果 collection_type 是 varray 类型，则它具有最大大小，值的数量不能超过该大小。 如果 collection_type 是嵌套表类型，则它没有最大大小。 如果不指定值，则构造的集合为 empty 但不为 null（关于 empty 和 null 的区别，请参阅集合类 型 ）。 date_expression 其值具有日期数据类型（即 DATE 族中的数据类型，在DATE 数据类型族 中描述）的表达式。 date_constant 具有日期数据类型的常量的名称。 date_function_call 调用先前定义的函数，该函数返回一个具有日期数据类型或可以隐式转换为日期数据类型的 值。有关更多语义信息，请参阅function_call 。 date_literal 其值具有日期数据类型或可以隐式转换为日期数据类型的文字。 date_variable 具有日期数据类型的变量的名称。 +, - 439 第 14 章 语言元素 加法和减法运算符。 numeric_expression 其值具有日期数值类型（即 NUMBER 族中的数据类型，在NUMBER 数据类型族 中描述）的表达式。 +, -, /, *, ^ 加法、减法、除法、乘法和求幂运算符。 numeric_subexpression collection 集合变量的名称。 COUNT, FIRST, LAST, LIMIT, NEXT, PRIOR 集合方法调用 中解释了集合方法。 named_cursor %ROWCOUNT 请参阅命名游标属性 。 numeric_constant 具有数字数据类型的常量的名称。 numeric_function_call 调用先前定义的函数，该函数返回具有数值数据类型或可以隐式转换为数值数据类型的值。有 关更多语义信息，请参阅function_call 。 numeric_literal 数值数据类型的文字。 numeric_variable 具有数字数据类型的变量的名称。 SQL%ROWCOUNT 隐式游标属性 中解释了游标属性。 SQL%BULK_ROWCOUNT SQL%BULK_ROWCOUNT 中解释了游标属性。 exponent 数值表达式。 function_call function 先前定义的函数的名称。 parameter [, parameter ]... 440 第 14 章 语言元素 被调用函数的实际参数列表。每个实参的数据类型必须与对应的形参的数据类型兼容。形参的 模式决定了实参可以是什么： • 形式参数模式为 IN，实际参数为常量、初始化变量、文字或表达式 • 形式参数模式为 OUT，实际参数为数据类型未定义为 NOT NULL 的变量 • 形式参数模式为 IN OUT，实际参数为变量（通常是字符串缓冲区或数字累加器） 如果函数为参数指定默认值，您可以从参数列表中省略该参数。如果函数没有参数，或者为每 个参数指定一个默认值，您可以省略参数列表或指定一个空的参数列表。 另请参阅: 实际参数的位置、命名和混合表示法 searched_case_expression WHEN boolean_expression THEN result boolean_expressions 是按顺序计算的。如果 boolean_expression 的值为 TRUE，则返回与 该 boolean_expression 关联的结果。不评估后续的 boolean_expressions 。 ELSE result 当 boolean_expression 为 false 时，result 才能返回值。 如果省略该 ELSE 子句，则搜索 case 表达式将返回 NULL。 simple_case_expression selector 任何 PL/SQL 类型的表达式，除了 BLOB、BFILE 或用户定义的类型。selector 被评估一 次。 WHEN selector_value THEN result selector_values 是按顺序计算的。如果 selector_value 是 selector 的值，则返回与该 selector_value 关联的结果。随后的 selector_values 不会被评估。 selector_value 可以是除 BLOB、BFILE、ADT、PL/SQL 记录、关联数组、可变数组或嵌 套表之外的任何 PL/SQL 类型。 ELSE result 当且仅当 selector_value 与 selector 没有具有相同的值时，才会返回结果。如果省略 ELSE 子句，简单 case 表达式将返回 NULL。 示例 • 示例 3-28，“用括号控制求值顺序” • 示例 3-29，“用括号提高可读性” • 示例 3-30，“运算符优先级” 441 第 14 章 语言元素 • 示例 3-40，“表达式中的关系运算符” • 示例 3-41，“表达式中的 LIKE 运算符” • 示例 3-43，“表达式中的 BETWEEN 运算符” • 示例 3-44，“表达式中的 IN 运算符” • 示例 3-47，“简单 CASE 表达式” • 示例 3-49，“搜索 CASE 表达式” • 示例 10-1，“触发器使用条件谓词检测触发语句” 相关话题 在其他章节： • 表达式 • 运算符优先级 • PL/SQL 数据类型 • 子程序参数 14.25 FETCH 语句 该 FETCH 语句从多行查询的结果集中检索数据行（一次一行、一次几行或一次所有行）并将数据存储在变量、 记录或集合中。 语法 fetch_statement ::= FETCH { cursor | cursor_variable } { into_clause | bulk_collect_into_clause [ LIMIT numeric_expression ] } ; ( bulk_collect_into_clause ::= , into_clause ::= , numeric_expression ::= ) 语义 fetch_statement cursor 442 第 14 章 语言元素 打开的显式游标的名称。要打开显式游标，请使用OPEN 语句 。 如果您在打开游标之前或关闭游标后尝试从显式游标中获取，PL/SQL 会引发预定义的异常 INVALID_CURSOR_NAME。 cursor_variable 打开的游标变量的名称。要打开游标变量，请使用OPEN FOR 语句 。游标变量可以是正式的 子程序参数（请参阅游标变量作为子程序参数 ）。 如果您尝试在打开游标变量之前或关闭它之后从游标变量中获取，PL/SQL 会引发预定义的异 常 INVALID_CURSOR_NAME。 into_clause 要让 FETCH 语句一次检索一行，请使用此子句指定变量或记录，以存储游标返回的行的列 值。有关 into_clause 的更多信息，请参阅into_clause ::= 。 bulk_collect_into_clause [ LIMIT numeric_expression ] 用于 bulk_collect_into_clause 指定一个或多个集合，用于存储 FETCH 语句返回的行。有 关 bulk_collect_into_clause 的更多信息，请参阅bulk_collect_into_clause ::= 。 要让 FETCH 语句一次检索所有行，请省略 LIMIT numeric_expression。 要限制 FETCH 语句一次检索的行数，请指定 LIMIT numeric_expression。 对 bulk_collect_into_clause 的限制 您不能在客户端程序中使用 bulk_collect_into_clause 。 当 FETCH 语句需要隐式数据类型转换时，bulk_collect_into_clause 只能有一个 collection。 示例 • 示例 6-46，“FETCH 分配值以记录该函数返回” • 示例 7-6，“LOOP 语句中的 FETCH 语句” • 示例 7-7，“将相同的显式游标提取到不同的变量中” • 示例 7-26，“使用游标变量获取数据” • 示例 7-27，“从游标变量中获取集合” • 示例 7-37，“在 COMMIT 语句后使用 FOR UPDATE 游标进行 FETCH” • 示例 8-8，“带有 OPEN FOR、FETCH 和 CLOSE 语句的本机动态 SQL” • 示例 13-17，“批量提取到两个嵌套表中” • 示例 13-18，“批量提取到嵌套记录表” • 示例 13-19，“使用 LIMIT 限制批量 FETCH” 443 第 14 章 语言元素 14.26 FOR LOOP 语句 对于 FOR LOOP 语句的每次迭代，它的语句都会运行，它的索引要么递增要么递减，并且控制返回到循环的顶 部。 FOR LOOP 语句在其索引达到指定值时结束，或者当循环内的语句将控制转移到循环外或引发异常时。索引也 称为迭代。循环外的语句不能引用迭代。在 FOR LOOP 语句运行后，迭代数未定义。 语法 for_loop_statement ::= FOR iterator LOOP statement... END LOOP [ label ] ; ( iterator ::= , statement ::= ) 语义 for_loop_statement iterator 见迭代器 statement 语句中的 EXIT、EXIT WHEN、CONTINUE 或 CONTINUE WHEN 会导致循环或循环的当 前迭代提前结束。 label 标识 for_loop_statement 的标签。CONTINUE、EXIT 和 GOTO 语句可以引用这个标签。 标签提高了可读性，尤其是当 LOOP 语句嵌套时，但前提是您确保 END LOOP 语句中的标签 与同一 LOOP 语句开头的标签匹配。 示例 • 示例 5-9，“外部语句引用 FOR LOOP 语句索引” • 示例 5-10，“与变量同名的 FOR LOOP 语句索引” • 示例 5-11，“FOR LOOP 语句引用与索引同名的变量” • 示例 5-12，“具有相同索引名称的嵌套 FOR LOOP 语句” 444 第 14 章 语言元素 • 示例 5-13，“FOR LOOP 语句范围迭代控制” • 示例 5-14，“反向 FOR LOOP 语句范围迭代控制” • 示例 5-16，“使用 FOR LOOP 步进范围迭代器的简单步进过滤器” 示例 14-7 FOR LOOP 语句中的 EXIT WHEN 语句 如果出现某种情况，您必须立即退出 FOR LOOP 语句。您可以将条件放在 FOR LOOP 语句内的 EXIT WHEN 语句中。 在这个例子中，FOR LOOP 语句执行了 5 次，当里面的 FETCH 语句没有返回一行时它会立即结束。 \set SQLTERM ; create table student(id int PRIMARY KEY, name text, score number); insert into student values(1, 'zhangsan', '100'); \set SQLTERM / DECLARE v_student student%ROWTYPE; CURSOR c1 is SELECT * FROM student; BEGIN OPEN c1; FOR i IN 1..5 LOOP FETCH c1 INTO v_student; EXIT WHEN c1%NOTFOUND; END LOOP; CLOSE c1; END; / 示例 14-8 内部 FOR LOOP 语句中的 EXIT WHEN 语句 现在假设必须提前退出的 FOR LOOP 语句嵌套在另一个 FOR LOOP 语句中。如果在提前退出内循环时，还想 退出外循环，则并在 EXIT WHEN 语句中指定其外循环标记。 \set SQLTERM ; create table student(id int PRIMARY KEY, name text, score number); insert into student values(1, 'zhangsan', '100'); \set SQLTERM / DECLARE v_student student%ROWTYPE; CURSOR c1 is SELECT * FROM student; BEGIN OPEN c1; <> FOR i IN 1..5 LOOP FOR j IN 1..5 LOOP FETCH c1 INTO v_student; 445 第 14 章 语言元素 EXIT outer_loop WHEN c1%NOTFOUND; END LOOP; END LOOP outer_loop; CLOSE c1; END; / 示例 14-9 内部 FOR LOOP 语句中的 CONTINUE WHEN 语句 如果想提前退出内循环但完成外循环的当前迭代，则标记外循环并在 CONTINUE WHEN 语句中指定其名称。 \set SQLTERM ; create table student(id int PRIMARY KEY, name text, score number); insert into student values(1, 'zhangsan', '100'); \set SQLTERM / DECLARE v_student student%ROWTYPE; CURSOR c1 is SELECT * FROM student; BEGIN OPEN c1; <> FOR i IN 1..5 LOOP FOR j IN 1..5 LOOP FETCH c1 INTO v_student; CONTINUE outer_loop WHEN c1%NOTFOUND; END LOOP; END LOOP outer_loop; CLOSE c1; END; / 相关话题 • FOR LOOP 迭代 • FOR LOOP 语句概述 • 基本 LOOP 语句 • CONTINUE 语句 • 游标 FOR LOOP 语句 • EXIT 语句 • FETCH 语句 446 第 14 章 语言元素 • FORALL 语句 • OPEN 语句 • WHILE LOOP 语句 • 异常处理概述 14.27 FORALL 语句 FORALL 语句多次运行一个 DML 语句，在 VALUES 和 WHERE 子句中具有不同的值。 不同的值来自现有的填充集合或主机数组。FORALL 语句通常比等效的 FOR LOOP 语句快得多。 注意: 只能在服务器程序中使用 FORALL 语句，而不能在客户端程序中使用。 语法 forall_statement ::= FORALL index IN bounds_clause [ SAVE EXCEPTIONS ] dml_statement; bounds_clause ::= { lower_bound .. upper_bound | INDICES OF collection [ BETWEEN lower_bound AND upper_bound ] | VALUES OF index_collection } 语义 forall_statement index 447 第 14 章 语言元素 FORALL 语句本地的隐式声明的整数变量的名称。FORALL 语句之外的语句不能引用 index。 FORALL 语句中的语句可以引用 index 作为索引变量，但不能在表达式中使用它或更改它的 值。FORALL 语句运行后，index 未定义。 dml_statement dml_statement 引用的每个集合都必须具有与索引值匹配的索引。如果将 DELETE、EXTEND 或 TRIM 方法应用于一个集合，那么也将其应用于其他集合，以便所有集合具有相同的索引 集。如果任何集合缺少引用的元素，PL/SQL 就会引发异常。 dml_statement 的限制 如果 dml_statement 是动态 SQL 语句，则 USING 子句（动态 SQL 语句的绑定 变量）中的值必须是对集合的简单引用，而不是表达式。例如，collection(i) 有效，但 UPPER(collection(i)) 无效。 SAVE EXCEPTIONS 即使某些 DML 语句失败，也让 FORALL 语句继续。有关详细信息，请参阅在 FORALL 语句 完成后处理 FORALL 异常 。 bounds_clause 指定为变量索引提供值的集合元素索引。对于每个值，SQL 引擎运行 dml_statement 一次。 lower_bound .. upper_bound lower_bound 和 upper_bound 都是数字表达式，PL/SQL 在输入 FORALL 语句时计 算一次，并在必要时四舍五入到最接近的整数。结果整数必须是连续索引号有效范围的 下限和上限。如果范围中的元素丢失或被删除，PL/SQL 将引发异常。 INDICES OF collection [ BETWEEN lower_bound AND upper_bound ] 指定 index 的值对应于集合元素的索引。索引不必是连续的。 lower_bound 和 upper_bound 都是数字表达式，PL/SQL 在输入 FORALL 语句时计 算一次，并在必要时四舍五入到最接近的整数。结果整数是有效索引号范围的下限和上 限，不必是连续的。 VALUES OF index_collection 指定 index 的值是 index_collection 的元素，它是由 PLS_INTEGER 索引 的 PLS_INTEGER 元素的集合。index_collection 的索引不必是连续的。如果 index_collection 为空，PL/SQL 会引发异常并且 FORALL 语句不会运行。 示例 • 示例 13-3，“FORALL 语句中的 DELETE 语句” • 示例 13-4，“FOR LOOP 和 FORALL 语句中 INSERT 语句的时间差” • 示例 13-5，“集合子集的 FORALL 语句” • 示例 13-6，“稀疏集合及其子集的 FORALL 语句” 448 第 14 章 语言元素 • 示例 13-7，“立即处理 FORALL 异常” • 示例 13-8，“在 FORALL 语句完成后处理 FORALL 异常” • 示例 13-21，“FORALL 语句中使用带有 RETURN BULK COLLECT INTO 子句的 DELETE 语句” 相关话题 在本章节： • FOR LOOP 语句 • 隐式游标属性 在其他章节： • FORALL 语句 • BULK COLLECT 子句 • FORALL 语句和 BULK COLLECT 子句一起使用 14.28 FOREACH 语句 FOREACH 循环很像一个 FOR 循环，但不是通过一个 SQL 查询返回的行进行迭代，它通过数组值的元素来迭 代。 通常，FOREACH 意味着通过一个组合值表达式的部件迭代；用于通过除数组之外组合类型进行循环的变体可 能会在未来被加入。 语法 foreach_statement ::= [ <> ] FOREACH target [ SLICE number ] IN ARRAY expression LOOP statements END LOOP [ label ]; ( expression ::= , statement ::= ) 语义 foreach_statement 449 第 14 章 语言元素 label 标识 foreach_statement 的标签（参见statement ::= ，label ::= ）。CONTINUE、EXIT 和 GOTO 语句可以引用这个标签。 标签提高了可读性，尤其是当 LOOP 语句嵌套时，但前提是确保 END LOOP 语句中的标签与 同一 LOOP 语句开头的标签匹配。 target target 变量必须是一个数组，并且它接收数组值的连续切片，其中每一个切片都有 SLICE 指定 的维度数。 元素会被按照存储顺序访问，而不管数组的维度数。 尽管 target 通常只是一个单一变量，当通过一个组合值（记录）的数组循环时，它可以是一个 变量列表。在那种情况下，对每一个数组元素，变量会被从组合值的连续列赋值。 SLICE 通过一个正 SLICE 值，FOREACH 通过数组的切片而不是单一元素迭代。SLICE 值必须是一 个不大于数组维度数的整数常量。 如果没有 SLICE，或者如果没有指定 SLICE 0，循环会通过计算 expression 得到的数组的个体 元素进行迭代。target 变量被逐一赋予每一个元素值，并且循环体会为每一个元素执行。 statements 语句中的 EXIT、EXIT WHEN、CONTINUE 或 CONTINUE WHEN 会导致循环或循环的当 前迭代提前结束。 expression 需要进行计算的表达式。用于数组的个体元素进行迭代。 示例 示例 1 在一个数组上循环的 FOREACH 语句： \set SQLTERM / CREATE OR REPLACE FUNCTION sum(int[]) RETURNS int8 AS DECLARE s int8 := 0; x int; BEGIN FOREACH x IN ARRAY $1 LOOP s := s + x; END LOOP; RETURN s; END; / \set SQLTERM ; 450 第 14 章 语言元素 SELECT sum(ARRAY[1,2,3]); 执行结果： SUM ----6 (1 row) 示例 2 一个通过一维切片迭代的例子： \set SQLTERM / CREATE OR REPLACE FUNCTION scan_rows(int[]) RETURNS void AS DECLARE x int[]; BEGIN FOREACH x SLICE 1 IN ARRAY $1 LOOP RAISE NOTICE 'row = %', x; END LOOP; END; / \set SQLTERM ; SELECT scan_rows(ARRAY[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]); 执行结果： NOTICE: row = {1,2,3} NOTICE: row = {4,5,6} NOTICE: row = {7,8,9} NOTICE: row = {10,11,12} 14.29 形式参数声明 形式参数声明指定参数的名称和数据类型，以及（可选）其模式和默认值。 形式参数声明可以出现在以下内容中： • 函数声明与定义 • 过程声明与定义 • CREATE FUNCTION 语句 451 第 14 章 语言元素 • CREATE PROCEDURE 语句 语法 parameter_declaration ::= parameter [ [ IN ] datatype [ { := | DEFAULT } expression ] | { OUT | IN OUT } [ NOCOPY ] datatype 语义 parameter_declaration parameter 您要声明的形式参数的名称，您可以在子程序的可执行部分中引用它。 IN, OUT, IN OUT 确定参数行为的模式，在“子程序参数模式”中进行了说明。默认值：IN 。 注意: 避免使用 OUT 和 IN OUT 作为函数参数。函数的目的是接受零个或多个参数并返回单个值。函 数必须没有副作用，副作用会改变子程序非本地变量的值。 NOCOPY 表示参数是引用而不是拷贝，仅语法兼容。 datatype 要声明的形式参数的数据类型。数据类型可以是受约束的子类型。 如果 datatype 是受约束的子类型，则相应的实际参数继承子类型的 NOT NULL 约束（如果有 的话），但不继承大小（参见示例 9-10 ）。 expression 452 第 14 章 语言元素 声明的形式参数的默认值。表达式的数据类型必须与数据类型兼容。 如果子程序调用没有为形参指定实参，则该调用计算表达式并将其值分配给形参。 如果子程序调用确实为形参指定了实参，则该调用将实参的值分配给形参并且不对表达式求 值。 示例 • 示例 3-24，“为变量赋值为 IN OUT 子程序参数” • 示例 9-9，“形式参数和实际参数” • 示例 9-13，“过程调用之前、期间和之后的参数值” • 示例 9-14，“异常处理后的 OUT 和 IN OUT 参数值” • 示例 9-17，“使用默认参数值的过程” • 示例 9-18，“函数提供默认参数值” • 示例 9-19，“在不更改现有调用的情况下添加子程序参数” 相关话题 在其他章节： • 子程序参数 • CREATE FUNCTION 语句 • CREATE PROCEDURE 语句 14.30 函数声明与定义 在调用函数之前，必须声明和定义它。可以先声明它（使用 function_declaration），然后在同一个块、子程序 或包中定义它（使用 function_definition），或者同时声明和定义它（使用 function_definition）。 函数是有返回值的子程序。值的数据类型是函数的数据类型。函数调用是一个表达式，其数据类型是函数的数据 类型。 函数声明也称为函数规范。 注意: 本主题适用于嵌套函数。 有关独立函数的信息，请参阅CREATE FUNCTION 语句 。 有关包函数的信息，请参阅CREATE PACKAGE 语句 。 语法 453 第 14 章 语言元素 function_declaration ::= function_heading [ DETERMINISTIC | RESULT_CACHE ]... ; function_heading ::= FUNCTION function_name [ ( parameter_declaration [, parameter_declaration ] ) ] RETURN datatype ( datatype ::= , parameter_declaration ::= ) function_definition ::= function_heading [ DETERMINISTIC | RESULT_CACHE [ relies_on_clause ] | PIPELINED ]... { IS | AS } { [ declare_section ] body } ( body ::= , declare_section ::= , pipelined_clause ::= , deterministic_clause ::= , result_cache_clause ::= ) 语义 function_declaration 454 第 14 章 语言元素 声明一个函数，但不定义它。定义必须稍后出现在与声明相同的块、子程序或包中。 function_heading 函数头指定函数名称及其参数列表。 function_name 您要声明或定义的函数的名称。 RETURN datatype 指定函数返回值的数据类型，可以是任何 PL/SQL 数据类型（请参阅PL/SQL 数据类型）。 datatype 限制 您不能限制此数据类型（例如，使用 NOT NULL）。如果数据类型是受约束的子类 型，则返回值不会继承子类型的约束（请参阅受约束子类型的形式化参数）。 function_definition 要么定义一个之前声明的函数，要么同时声明和定义一个函数。 declare_section 声明函数的本地项，可以在 body 中引用，并且在函数完成执行时不再存在。 body 函数的必需的可执行部分和可选的异常处理部分。在可执行部分，至少有一条执行路径必须指 向一条 RETURN 语句；否则，会发生运行时错误。 示例 • 示例 9-1，“声明、定义和调用一个简单的 PL/SQL 函数” 相关话题 • 形式参数声明 • 过程声明与定义 • PL/SQL 子程序 14.31 GOTO 语句 GOTO 语句将控制转移到带有标记的块或语句。 对 GOTO 声明的限制 • 如果 GOTO 语句过早退出 FOR LOOP 语句，游标将关闭。 • GOTO 语句不能将控制转移到 IF 语句、CASE 语句、LOOP 语句或子块中。 • GOTO 语句不能将控制从一个 IF 语句子句转移到另一个语句，或者从一个 CASE 语句转移到另一个语句。 455 第 14 章 语言元素 • GOTO 语句不能将控制转移出子程序。 • GOTO 语句不能将控制转移到异常处理程序中。 • GOTO 语句不能将控制从异常处理程序转移到当前块中（但它可以将控制从异常处理程序转移到封闭块中）。 语法 goto_statement ::= GOTO label ; 语义 goto_statement label 标识块或语句（参见plsql_block ::= , statement ::= , label ::= ）。 如果标签不在当前块中，则 GOTO 语句将控制转移到标签出现的第一个封闭块。 示例 示例 14-10 GOTO 语句 标签可以出现在语句之前 \set SQLTERM / DECLARE str VARCHAR2(100); n INTEGER := 40; BEGIN FOR j in 2..ROUND(SQRT(n)) LOOP IF MOD(n, j) = 0 THEN str := ' is not a prime number'; GOTO print_now; END IF; END LOOP; str := ' is a prime number'; <> raise notice '% %', TO_CHAR(n), str; END; / 结果: 456 第 14 章 NOTICE: 40 语言元素 is not a prime number 示例 14-11 不正确的标签放置 标签只能出现在块之前或语句之前。 \set SQLTERM / DECLARE done BOOLEAN := true; BEGIN FOR i IN 1..3 LOOP IF done THEN GOTO end_loop_pos; END IF; <> END LOOP; END; / 结果: ERROR: syntax error at or near "END" LINE 9: END LOOP; ^ 示例 14-12 GOTO 语句转到标记为 NULL 的语句 标签可以出现在 NULL 语句之前。 \set SQLTERM / DECLARE done BOOLEAN := true; BEGIN FOR i IN 1..3 LOOP IF done THEN GOTO end_loop_pos; END IF; <> NULL; END LOOP; END; / 示例 14-13 GOTO 语句将控制转移到封闭块 语句可以将 GOTO 控制从当前块转移到封闭块。 457 第 14 章 语言元素 \set SQLTERM ; drop table student; create table student (id int PRIMARY KEY, name text, score number); insert into student values (1, 'zhangsan', 100); insert into student values (2, 'lisi', 98); insert into student values (3, 'lihua', 100); \set SQLTERM / DECLARE v_name VARCHAR2(50); v_stu_id NUMBER(10) := 1; BEGIN <> SELECT name INTO v_name FROM student WHERE id = v_stu_id; BEGIN raise notice '%', v_name; v_stu_id := v_stu_id + 1; IF v_stu_id < 4 THEN GOTO get_name; END IF; END; END; / 结果: NOTICE: zhangsan NOTICE: lisi NOTICE: lihua 示例 14-14 GOTO 语句无法将控制权转移到 IF 语句中 该 GOTO 语句将控制权转移到一个 IF 语句中，从而导致错误。 \set SQLTERM / DECLARE done BOOLEAN := TRUE; BEGIN GOTO label_if; IF done THEN <> NULL; 458 第 14 章 语言元素 END IF; END; / 结果: ERROR: illegal GOTO statement, cannot transfer control to label 'label_if' CONTEXT: compilation of PL/SQL function "inline_code_block" near line 3 14.32 GET 语句 获得系统的状态指示语句。 语法 get_statement ::= GET [ CURRENT ] DIAGNOSTICS variable { = | := } item [ , ... ]; 语义 get_statement item item 是系统的一些表示状态信息的关键字，目前 item 有两个取值： • ROW_COUNT 最近执行的 SQL 语句处理的元组个数 • RESULT_OID 最近执行的 INSERT 语句插入的最后一个元组的 OID 另外，获得系统的状态指示还有一种方式是使用变量 FOUND。变量 FOUND 是一个布尔类型 的局部变量，在每一个存储过程体中初始值是 false，下面语句的执行将修改 FOUND 的值： SELECT INTO 若没有元组返回，则 FOUND 是 false，否则 FOUND 是 true。 PERFORM 若这个命令产生或者删除元组，则 FOUND 是 true，否则是 false。 UPDATE INSERT DELETE 若没有影响任何元组，则 FOUND 是 false，否则是 true。 FETCH 若得到一个元组，则 FOUND 是 true，否则是 false。 FOR 若执行超过一次（含一次），则 FOUND 是 true，否则是 false。若存在 FOR 循环，则会 设置 FOUND, 在 FOR 循环内部，FOUND 变量不会再次被 FOR 循环修改，但有可能被 FOR 循环中执行的语句修改。 459 第 14 章 语言元素 示例 获得状态语句示例如下所示。 CREATE TABLE tab_diagnos(a INT); INSERT INTO tab_diagnos VALUES(12); INSERT INTO tab_diagnos VALUES(34); INSERT INTO tab_diagnos VALUES(56); INSERT INTO tab_diagnos VALUES(78); \set SQLTERM / CREATE OR REPLACE PROCEDURE p() AS DECLARE mycursor CURSOR FOR SELECT count(*) FROM tab_diagnos; count_ret INTEGER; diagnostics_ret INTEGER; BEGIN OPEN mycursor; UPDATE tab_diagnos SET a = 5; --获取最近执行的元组数 GET DIAGNOSTICS diagnostics_ret = ROW_COUNT; raise NOTICE '%', FOUND; raise NOTICE '%', diagnostics_ret; END; / \set SQLTERM ; CALL p(); DROP TABLE tab_diagnos; 结果: NOTICE: t NOTICE: 4 CALL 14.33 IF 语句 IF 语句运行或跳过一个或多个语句的序列，具体取决于 BOOLEAN 表达式的值。 语法 460 第 14 章 语言元素 if_statement ::= IF boolean_expression THEN statement [ statement ]... [ ELSIF boolean_expression THEN statement [ statement ]... ]... [ ELSE statement [ statement ]... ] END IF ; ( boolean_expression ::= , statement ::= ) 语义 if_statement boolean_expression 值为 TRUE、FALSE 或 NULL 的表达式。 第一个 boolean_expression 总是被评估。仅当前面表达式的值为 FALSE 时，才会评估其他每 个 boolean_expression 。 如果计算一个 boolean_expression 并且其值为 TRUE，则相应 THEN 之后的语句将运行。随 后的表达式不会被计算，与它们关联的语句也不会运行。 ELSE 如果布尔表达式的值不是 TRUE，则运行 ELSE 之后的语句。 示例 • 示例 5-1，“IF THEN 语句” • 示例 5-2，“IF THEN ELSE 语句” • 示例 5-3，“嵌套的 IF THEN ELSE 语句” • 示例 5-4，“IF THEN ELSIF 语句” 14.34 隐式游标属性 隐式游标具有返回最近运行的 SELECT 或 DML 语句的信息的属性，且不与命名游标关联。 注意: 您只能在过程语句中使用游标属性，而不能在 SQL 语句中使用。 461 第 14 章 语言元素 语法 implicit_cursor_attribute ::= SQL% { ISOPEN | FOUND | NOTFOUND | ROWCOUNT | BULK_ROWCOUNT ( index ) | BULK_EXCEPTIONS { .COUNT | ( index ).{ ERROR_INDEX | ERROR_CODE } } } 语义 implicit_cursor_attribute %ISOPEN SQL%ISOPEN 始终具有值 FALSE。 %FOUND SQL%FOUND 具有以下值之一： 如果没有运行 SELECT 或 DML 语句，则为 NULL。 如果最近的 SELECT 或 DML 语句返回一行，则为 TRUE。 如果最近的 SELECT 或 DML 语句未返回行，则为 FALSE。 %NOTFOUND SQL%NOTFOUND 具有以下值之一： 如果没有运行 SELECT 或 DML 语句，则为 NULL。 462 第 14 章 语言元素 如果最近的 SELECT 或 DML 语句返回一行，则为 FALSE。 如果最近的 SELECT 或 DML 语句没有返回一行，则为 TRUE。 %ROWCOUNT SQL%ROWCOUNT 具有以下值之一： 如果没有运行 SELECT 或 DML 语句，则为 NULL。 如果 SELECT 或 DML 语句已运行，则到目前为止提取的行数。 SQL%BULK_ROWCOUNT 复合属性，类似于关联数组，其第 i 个元素是最近完成的 FORALL 语句中受第 i 个 DML 语句 影响的行数。有关详细信息，请参阅获取受 FORALL 语句影响的行数”。 SQL%BULK_ROWCOUNT 的限制 您不能将 SQL%BULK_ROWCOUNT(index) 的值分配给另一个集合。 SQL%BULK_EXCEPTIONS 复合属性，类似于有关在最近运行的 FORALL 语句期间失败的 DML 语句的信息的关联数组。 SQL%BULK_EXCEPTIONS.COUNT 是失败的 DML 语句数。如果 SQL%BULK_EXCEPTIONS.COUNT 不 为零，那么对于从 1 到 SQL%BULK_EXCEPTIONS.COUNT 的每个索引值 i： • SQL%BULK_EXCEPTIONS(i).ERROR_INDEX 是失败的 DML 语句的编号。 • SQL%BULK_EXCEPTIONS(i).ERROR_CODE 是失败的数据库错误代码。 通常，此属性出现在具有 SAVE EXCEPTIONS 子句的 FORALL 语句的异常处理程序中。有 关详细信息，请参阅在 FORALL 语句完成后处理 FORALL 异常 。 示例 • 示例 7-3，“SQL%FOUND 隐式游标属性” • 示例 7-4，“SQL%ROWCOUNT 隐式游标属性” • 示例 7-15，“%FOUND 显式游标属性” • 示例 7-14，“%ISOPEN 显式游标属性” • 示例 7-16，“%NOTFOUND 显式游标属性” • 示例 7-17，“%ROWCOUNT 显式游标属性” • 示例 13-8，“在 FORALL 语句完成后处理 FORALL 异常” • 示例 13-9，“显示 FORALL 中每个 DELETE 影响的行数” • 示例 13-10，“显示 FORALL 中每个 INSERT SELECT 影响的行数” 相关话题 在本章节： • FORALL 语句 463 第 14 章 语言元素 • 命名游标属性 在其他章节： • 隐式游标 14.35 调用者权限和定义者权限属性 指定存储的 PL/SQL 子程序的 AUTHID 属性。AUTHID 属性会影响单元在运行时发出的 SQL 语句的权限检 查。 invoker_rights_clause 可以出现在以下 SQL 语句中： • ALTER TYPE 语句 • CREATE FUNCTION 语句 • CREATE PACKAGE 语句 • CREATE PROCEDURE 语句 • CREATE TYPE 语句 • CREATE TYPE BODY 语句 语法 invoker_rights_clause ::= AUTHID { CURRENT_USER | DEFINER } 语义 invoker_rights_clause 当它出现在包声明中时，它指定包 AUTHID 中函数和过程的属性，以及包规范中声明的显式游标的属 性。 当它出现在独立函数声明中时，它指定 AUTHID 函数的属性。 当它出现在独立的过程声明中时，它指定了 AUTHID 过程的属性。 invoker_rights_clause 在子程序声明中只能出现一次。 当它出现在 ADT 中时，它指定了 AUTHID ADT 的成员函数和过程的属性。 对 invoker_rights_clause 的限制 464 第 14 章 语言元素 以下限制适用于类型： • 此子句仅对 ADT 有效，对嵌套表或 VARRAY 类型无效。 相关话题 在本章节： 调用者的权限和定义者的权限（AUTHID 属性） 以获取有关 AUTHID 属性的信息 子程序属性 14.36 INSERT 语句扩展 SQL INSERT 语句的 PL/SQL 扩展允许在 single_table_insert 的 values_clause 中指定记录名称，而不是在 insert_into_clause 中指定列列表。 这种形式的 INSERT 语句将记录插入到表中; 实际上，它向表中添加一行，并为该行的每一列赋予相应记录字段 的值。 语法 insert_into_clause ::= INTO dml_expression_clause [ t_alias ] values_clause ::= VALUES record 语义 insert_into_clause dml_table_expression_clause 通常是表名。 t_alias dml_table_expression_clause 的别名。 values_clause 465 第 14 章 语言元素 record RECORD 或%ROWTYPE dml_table_expression_clause 类 型 的 记 录 变 量 的 名 称。record 必须代表 解 释 的 项 目 的 一 行。 也 就 是 说， 对 于 行 的 每 一 列，record 必须有一个数据类型兼容的字段。如果列具有 NOT NULL 约束，则其对应字段不能具有 NULL 值。 示例 • 示例 6-49，“通过插入带有默认值的 Record 变量来初始化表” 相关话题 在本章节： • 记录变量声明 • %ROWTYPE 属性 在其他章节： • 向表中插入 record • 对 record 变量插入和更新的限制 14.37 迭代器 迭代器指定一个迭代和迭代控制。 迭代器可以出现在以下语句中： • FOR LOOP 语句 语法 iterator ::= iterand_decl [ , iterand_decl ] IN iteration_ctl_seq ( iterand_decl ::= , iteration_ctl_seq ::= ) iterand_decl ::= pls_identifier [ constrained_type ] 466 第 14 章 语言元素 iteration_ctl_seq ::= qual_iteration_ctl [, qual_iteration_ctl]... qual_iteration_ctl ::= [ REVERSE ] iteration_control ( iteration_control ::= ) iteration_control ::= ( stepped_control | single_expression_control | values_of_control | indices_of_control | cursor_iteration_control ) ( stepped_control ::= , single_expression_control ::= , values_of_control ::= , indices_of_control ::= , cursor_iteration_control ::= ) 467 第 14 章 语言元素 stepped_control ::= lower_bound .. upper_bound [ BY step ] single_expression_control ::= expr values_of_control ::= VALUES OF { expr | cursor_variable | ( cursor_object ) | ( dynamic_sql ) | ( sql_statement ) } (dynamic_sql ::=) indices_of_control ::= INDICES OF { expr | cursor_variable | ( cursor_object ) | ( cursor_variable ) | ( dynamic_sql ) | ( sql_statement ) } 468 第 14 章 语言元素 (dynamic_sql ::=) cursor_iteration_control ::= ( cursor_object ) | ( cursor_variable ) | ( dynamic_sql ) | ( sql_statement ) (dynamic_sql ::=) dynamic_sql ::= EXECUTE IMMEDIATE dynamic_sql_stmt [ USING [IN] bind_argument [,] +... ] 语义 iterator 迭代器指定一个迭代和迭代控制。 469 第 14 章 语言元素 循环外的语句不能引用 iterator 。循环内的语句可以引用 iterator ，但不能更改其值。FOR LOOP 语 句运行后，iterator 未定义。 iterand_decl iterand 类型可以隐式或显式声明。不能显式初始化迭代数。 当循环头中的 iterand 后面没有类型声明时，隐式声明了 iterand 类型。隐式类型由第一次迭代控制确定。 表 14.37.1: iterand 隐式类型默认值 迭代控制 隐式迭代类型 stepped 控制 PLS_INTEGER single expression PLS_INTEGER 游标控制 CURSOR%ROWTYPE VALUES OF 控制 集合元素类型 INDICES OF 控制 集合索引类型 pls_identifier FOR LOOP 语句本地的隐式声明变量的迭代名称。 constrained_type 当循环头中指定迭代类型时，显式声明迭代。为迭代分配值时会考虑为类型定义的任何约束。 迭代控件生成的值必须是与迭代类型兼容的赋值。适用通常的转换规则。所有违反约束的情况 都会引发异常。 iteration_ctl_seq 多个迭代控件可以通过用逗号分隔来链接在一起。 对 iteration_ctl_seq 的限制 因为迭代数对需要两个迭代数，所以迭代控件对不能与其他类型的迭代控件混合。 qual_iteration_ctl 合格的迭代控制指定了 REVERSE 选项和可选的停止和跳过谓词子句。 [ REVERSE ] 当指定可选关键字 REVERSE 时，序列中值的顺序会颠倒。 您可以将此选项与集合向量值表达式一起使用。在这种情况下，指定 REVERSE 会生成从 LAST 到 FIRST 的值，而不是从 FIRST 到 LAST 的值。 对 REVERSE 限制 • 如果在迭代控件中指定了 pipelined 函数，则不能使用此选项。 470 第 14 章 语言元素 • 不能将此选项与单个表达式迭代控件一起使用，因为它生成单个值，因此该关键字对该控 件没有任何合理的含义。 • 当迭代控件指定 SQL 语句时，不能使用此选项。这将创建查询返回的记录序列。可以在 SQL 语句中指定一个 ORDER BY 子句，以便按适当的顺序对行进行排序。 • 当集合是游标、游标变量、动态 SQL 或调用 pipelined 表函数的表达式时，不能使用此选 项。 iteration_control 迭代控件向迭代对象提供一系列值。 stepped_control lower_bound .. upper_bound [ BY step ] 如果没有 REVERSE，iterand 的值从 lower_bound 开始，随着循环的每次迭代逐步增 加，直到达到 upper_bound。 使用 REVERSE，iterand 的值从 upper_bound 开始，随着循环的每次迭代逐步减小， 直到达到 lower_bound。如果 upper_bound 小于 lower_bound，则语句永远不会运 行。 如果未指定此可选 BY 子句，则 step 的默认值为 1。 lower_bound 和 upper_bound 必 须 计 算 为 数 字 （数 字 文 字、 数 字 变 量 或 数 字 表 达 式）。 如 果 边 界 没 有 数 值， 那 么 PL/ SQL 会引发预定义的异常 NU- MERIC_VALUE_OUT_OF_RANGE。PL/ SQL 在输入 FOR LOOP 语句时计 算一次 lower_bound 和 upper_bound，并将它们存储为临时 PLS_INTEGER 值，必 要时将它们四舍五入为最接近的整数。 如果 lower_bound 等于 upper_bound，则语句只运行一次。 step 值必须大于零。 single_expression_control 单个表达式迭代控件生成单个值。 values_of_control 集合的元素类型必须是与迭代兼容的赋值。 index_of_control 集合的索引类型必须与迭代兼容。 与 INDICES OF 迭代控件一起使用的 iterand 不能是可变的。 cursor_iteration_control 游标迭代控件生成由显式或隐式游标返回的记录序列。游标定义是控制表达式。 cursor_iteration_control 的限制 471 第 14 章 语言元素 您不能 REVERSE 与光标迭代控件一起使用。 cursor_object cursor_object 是一个显式的 PL/SQL 游标对象。 sql_statement sql_statement 是为直接在迭代控件中指定的 SQL 语句创建的隐式 PL/SQL 游标对 象。 cursor_variable REF CURSOR 对象的先前声明的变量的名称。 dynamic_sql EXECUTE IMMEDIATE dynamic_sql_stmt [ USING [ IN ] (bind_argument [,] )+] 您可以使用动态查询来代替游标或集合迭代控件中的隐式游标定义。这样的构 造不能提供默认类型；如果它被用作第一个迭代控件，则必须为 iterand 指定 显式类型，或者为一对控件的值 iterand 指定显式类型。 可选 USING 子句是动态 SQL 中唯一允许的子句。它只能有 IN 一个或多个绑 定变量，每个变量用逗号分隔。 dynamic_sql_stmt 表示 SQL 语句的字符串文字、字符串变量或字符串表达式。它的类型必须是 CHAR、VARCHAR2 或 CLOB。 警告: 使用动态 SQL 时，请注意 SQL 注入，存在安全风险。有关 SQL 注 入的更多信息，请参阅SQL 注入 。 示例 • 示例 5-15，“步进范围迭代控件” • 示例 5-16，“使用 FOR LOOP 步进范围迭代器的简单步进过滤器” • 示例 5-17，“游标迭代控件” • 示例 5-18，“使用动态 SQL 作为迭代控制” 相关话题 • FOR LOOP 语句概述 14.38 命名游标属性 每个命名游标（显式游标或游标变量）都有四个属性，每个属性都返回有关 DML 语句执行的信息。 472 第 14 章 语言元素 注意: 只能在过程语句中使用游标属性，而不能在 SQL 语句中使用。 语法 named_cursor_attribute ::= named_cursor%{ ISOPEN | FOUND | NOTFOUND | ROWCOUNT } named_cursor ::= { explicit_cursor | cursor_parameter | cursor_variable } 语义 named_cursor_attribute %ISOPEN 如果游标打开，则 named_cursor%ISOPEN 为 TRUE，如果它没有打开则为 FALSE。 %FOUND named_cursor%FOUND 具有以下值之一： • 如果游标未打开，为 INVALID_CURSOR_NAME 异常。 • 如果游标已打开但未尝试获取，则 NULL。 • 如果最近的提取返回一行，TRUE。 • 如果最近的 fetch 没有返回一行，FALSE。 473 第 14 章 语言元素 %NOTFOUND named_cursor%NOTFOUND 具有以下值之一： • 如果游标未打开，为 INVALID_CURSOR_NAME 异常。 • 如果游标已打开但未尝试获取，则 NULL。 • 如果最近的提取返回一行，FALSE。 • 如果最近的 fetch 没有返回一行，TRUE。 %ROWCOUNT named_cursor%ROWCOUNT 具有以下值之一： • 如果游标未打开，为 INVALID_CURSOR_NAME 异常。 • 如果游标是打开的，那么到目前为止提取的行数。 named_cursor explicit_cursor 显式游标的名称。 cursor_parameter 正式游标参数的名称。 cursor_variable 游标变量的名称。 示例 • 示例 7-15，“%FOUND 显式游标属性” • 示例 7-14，“%ISOPEN 显式游标属性” • 示例 7-16，“%NOTFOUND 显式游标属性” • 示例 7-17，“%ROWCOUNT 显式游标属性” 相关话题 在本章节： • 游标变量声明 • 声明和定义显式游标 • 隐式游标属性 在其他章节： • 显式游标属性 474 第 14 章 语言元素 14.39 NULL 语句 该 NULL 语句是“no-op”（无操作）——它只将控制权传递给下一条语句。 注意: NULL 语句和 BOOLEAN 的 NULL 值无关。 语法 null_statement ::= NULL ; 示例 • 示例 5-19，“显示无操作的 NULL 语句” • 示例 5-20，“在子程序创建期间将 NULL 语句作为占位符” 14.40 OPEN 语句 该 OPEN 语句打开一个显式游标，分配数据库资源来处理关联的查询，标识结果集，并将游标定位在结果集的 第一行之前。 如果查询有 FOR UPDATE 子句，则该 OPEN 语句将锁定结果集的行。 语法 open_statement ::= OPEN cursor [ ( cursor_parameter [ [,] actual_cursor_parameter ]... ) ] ; 语义 open_statement cursor 未打开的显式游标的名称。 475 第 14 章 语言元素 actual_cursor_parameter 正在打开的游标的实际参数列表。实参可以是常量、初始化变量、文字或表达式。每个实参的 数据类型必须与对应的形参的数据类型兼容。 可以使用位置表示法或命名表示法指定实际的游标参数。有关这些符号的信息，请参阅实际参 数的位置、命名和混合表示法”。 如果游标指定参数的默认值，可以从参数列表中省略该参数。如果游标没有参数，或者为每个 参数指定一个默认值，可以省略参数列表或指定一个空的参数列表。 示例 • 示例 7-11，“接受参数的显式游标” • 示例 7-12，“具有默认值的游标参数” 相关话题 在本章节： • close 语句 • 显式游标声明和定义 • FETCH 语句 • OPEN FOR 语句 在其他章节： • 打开和关闭显式游标 • 显式游标的参数处理 14.41 OPEN FOR 语句 该 OPEN FOR 语句将游标变量与查询相关联，分配数据库资源来处理查询，标识结果集，并将游标定位在结果 集的第一行之前。 如果查询有 FOR UPDATE 子句，则该 OPEN FOR 语句将锁定结果集的行。 语法 open_for_statement ::= OPEN cursor_variable FOR { select_statement | dynamic_string } [ using_clause ] ; 476 第 14 章 语言元素 using_clause ::= USING [ IN ] bind_argument [ [,] [ [ IN ] bind_argument ]... 语义 open_for_statement cursor_variable 游标变量的名称。如果 cursor_variable 是子程序的形参，那么它不能有返回类型。有关作为 子程序参数的游标变量的信息，请参阅游标变量作为子程序参数 。 select_statement SQL SELECT 语句（不是 PL/SQL SELECT INTO 语句）。通常，select_statement 返回多 行。 dynamic_string 数据类型 CHAR、VARCHAR2 或 CLOB 的字符串文字、字符串变量或字符串表达式，表示 SQL SELECT 语句。通常，dynamic_statement 表示返回多行的 SQL SELECT 语句。 using_clause 使用位置表示法指定绑定变量。 注意: 如果在 dynamic_sql_statement 中重复占位符名称，请注意占位符与绑定变量的关联方 式取决于动态 SQL 语句的类型。有关详细信息，请参阅动态 SQL 语句中的重复占位符名称 。 对 using_clause 的限制 当且仅当 select_statement 或 dynamic_sql_stmt 包含绑定变量的占位符时才使用。 IN 绑 定 变 量 的 参 数 模 式。IN 绑定变量将其值传递给 select_statement 或 dynamic_string 。不支持 OUT，INOUT 模式。IN 可以省略。 bind_argument 在运行时其值替换其在 select_statement 或 dynamic_string 中的相应占位符的表达 式。必须为每个占位符指定一个 bind_argument 。 477 第 14 章 语言元素 bind_argument 的限制 • bind_argument 不能是由字符串索引的关联数组。 • 要将值 NULL 传递给动态 SQL 语句，请在要使用 NULL 的地方使用未初始化的变 量，如示例 8-7 中所示。 示例 • 示例 7-26，“使用游标变量获取数据” • 示例 7-30，“使用静态 SQL 查询集合” • 示例 7-31，“为一个查询打开游标变量的过程” • 示例 7-32，“为所选查询打开游标变量（返回类型相同）” • 示例 7-33，“为所选查询打开游标变量（不同的返回类型）” • 示例 8-8，“带有 OPEN FOR、FETCH 和 CLOSE 语句的本机动态 SQL” 14.42 PERFORM 语句 执行一个不返回任何行的 SQL 命令，比如一个不带 RETURNING 子句的 INSERT 语句。 语法 perform_statement ::= [PERFORM] query; 语义 perform_statement PERFORM PERFORM 关键字并不是必须的，可省略，可以把一个不返回任何行的命令直接写在一个 PL/ SQL 函数中执行。 任何出现在该命令文本中的 PL/SQL 变量名会被当作一个参数，后续该变量的值会作为该参数 运行时的值。 当以这种方式执行一个 SQL 命令时，PL/SQL 会将该命令缓存并重用执行计划。 有时候计算一个表达式或 SELECT 查询但抛弃其结果是有用的，例如调用一个有副作用但是没 有有用的结果值的函数。在 PL/SQL 可使用 PERFORM 语句，执行查询并且丢弃掉结果来实 478 第 14 章 语言元素 现。以写 SQL SELECT 命令相同的方式写该 query，并且将初始的关键词 SELECT 替换为 PERFORM。 对于 WITH 查询，使用 PERFORM 并且把该查询放在圆括号中（在这种情况中，该查询只能 返回一行）。PL/SQL 变量将被替换到该查询中，正像对不返回结果的命令所作的那样，并且 以相同的方式缓存计划。如果该查询产生至少一行记录，特殊变量 FOUND 会被设置为真，而 如果它不产生行则设置为假。 示例 一个例子： \set SQLTERM / create function perform_test() returns void as begin perform 2 + 2; end; / \set SQLTERM ; call perform_test(); drop function perform_test(); 运行结果： CALL 14.43 PIPE ROW 语句 PIPE ROW 语句只能出现在 pipelined 表函数的主体中，它将表行（但不是控制）返回给函数的调用者。 注意: • 如果 pipelined 表函数是自治事务的一部分，则它必须 COMMIT 或 ROLLBACK 在每个 PIPE ROW 语句之 前，以避免调用子程序中的错误。 • 为了提高性能，PL/SQL 运行时系统将管道行分批交付给调用程序。 语法 pipe_row_statement ::= PIPE ROW ( row ) ; 479 第 14 章 语言元素 语义 pipe_row_statement row 函数返回给其调用者的行（表元素），由类型为表元素的表达式表示。 如果表达式是记录变量，则必须使用表元素的数据类型显式声明。不能使用仅在结构上与元 素类型相同的数据类型来声明它。例如，如果元素类型有名称，则记录变量不能在游标 FOR LOOP 语句中用%TYPE 或%ROWTYPE 显式声明或用%ROWTYPE 隐式声明。 示例 • 示例 13-23，“创建和调用 pipelined 表函数” • 示例 13-24，“pipelined 表函数将每一行转换为两行” 相关话题 在本章节： • 函数声明与定义 在其他章节： • 创建 Pipelined Table 函数 14.44 PIPELINED 子句 指示数据库以迭代方式返回表函数或多态表函数的结果。 仅与表函数一起使用，以指定它是流水线的。流水线表函数在处理完该行后立即将一行返回给它的调用者，并继 续处理行。为了向调用者返回一行（但不是控制），该函数使用“PIPE ROW Statement ”。 表函数返回一个集合类型。 多态表函数是一个表函数，其返回类型由参数确定。 您可以通过在查询的 FROM 子句中的函数名称前使用 TABLE 关键字来查询这两种表函数。例如： SELECT * FROM TABLE( function_name (...)) 当出现表函数参数列表或空列表 () 时，TABLE 运算符是可选的。例如： SELECT * FROM function_name () 然后数据库返回由函数生成的行。 PIPELINED 选项可以出现在以下 SQL 语句中： • CREATE FUNCTION 语句 480 第 14 章 语言元素 • CREATE PACKAGE 语句 • CREATE PACKAGE BODY 语句 语法 pipelined_clause ::= PIPELINED 语义 pipelined_clause pipelined_clause 在函数中只能出现一次。 PIPELINED 要创建 PIPELINED 函数，请在函数定义中包含 pipelined_clause 。如果在定义 PIPELINED 函数之前声明它，则必须在函数声明中指定 PIPELINED 选项。 对 PIPELINED 的限制 不能为嵌套函数指定 PIPELINED。 示例 示例 13-23 , 创建和调用 pipelined table 函数 示例 13-24 , 作为转换函数 pipelined table 函数 14.45 过程声明与定义 在调用过程之前，必须声明和定义它。可以先声明它（使用 procedure_declaration），然后在同一个块、子程序 或包中定义它（使用 procedure_definition），或者同时声明和定义它（使用 procedure_definition）。 过程是执行特定操作的子程序。过程调用（或调用）是一个语句。 过程声明也称为过程规范。 注意: 有关独立过程的更多信息，请参阅CREATE PROCEDURE 语句 。有关包过程的更多信息，请参阅CREATE PACKAGE 语句 。 语法 481 第 14 章 语言元素 procedure_declaration ::= procedure_heading [ procedure_properties ] [ ; ] (procedure_properties ::=) procedure_heading ::= PROCEDURE procedure [ ( parameter_declaration [, parameter_declaration ]... ) ] (parameter_declaration ::=) procedure_properties ::= [ { invoker_rights_clause }] (invoker_rights_clause ::=) procedure_definition ::= procedure_declaration { IS | AS } { [ declare_section ] body } ( body ::= , declare_section ::= ) 语义 procedure_declaration 482 第 14 章 语言元素 声明一个过程，但不定义它。定义必须稍后出现在与声明相同的块、子程序或包中。 procedure_heading procedure 要声明或定义的过程的名称。 procedure_properties 每个过程属性在过程声明中只能出现一次。属性可以按任何顺序出现。属性出现在标题中 IS 或 AS 关键 字之前。属性不能出现在嵌套过程中。 独立过程在其声明中可能具有以下属性。 调用者的权限和定义者的权限（AUTHID 属性） procedure_definition 要么定义一个先前声明的过程，要么既声明又定义一个过程。 declare_section 声明过程本地的项目，可以在 body 中引用，并且在过程完成执行时不再存在。 body 过程的必需的可执行部分和可选的异常处理部分。 示例 • 示例 9-1，“声明、定义和调用简单的 PL/SQL 过程” 相关话题 在本章节： • 形式参数声明 • 函数声明与定义 在其他章节： • PL/SQL 子程序 • CREATE PROCEDURE 语句 14.46 RAISE 语句 RAISE 语句显式引发异常。 在异常处理程序之外，必须指定异常名称。在异常处理程序中，如果省略异常名称，则 RAISE 语句会重新引发 当前异常。 语法 483 第 14 章 语言元素 raise_statement ::= RAISE [ exception ] ; 语义 raise_statement exception 异常的名称，可以是预定义的（参见PL/ SQL 预定义异常表 ）或用户声明的（参见异常声明 ）。 exception 仅在异常处理程序中是可选的，其中默认值是当前异常（请参阅使用 RAISE 语句重 新触发当前异常 ）。 如果在 RAISE EXCEPTION 命令中没有指定异常名或 SQLSTATE， 默 认 使 用 RAISE_EXCEPTION（P0001）。 如 果 没 有 指 定 要 显 示 的 错 误 信 息， 默 认 使 用 异 常 名 或 SQLSTATE 作为错误信息。 兼容性 RAISE 语句同样可以作为打印语句。 RAISE [ level ] 'format' [, expression [, ... ]] [ USING option = expression [, ... ] ]; RAISE [ level ] condition_name [ USING option = expression [, ... ] ]; RAISE [ level ] SQLSTATE 'sqlstate' [ USING option = expression [, ... ] ]; RAISE [ level ] USING option = expression [, ... ]; 使用说明： a. Level 指定错误的输出级别。它的取值为 DEBUG、LOG、INFO、NOTICE、WARNING 和 EXCEPTION 中 的一个，EXCEPTION 为缺省值。EXCEPTION 选项在输出出错信息的同时中断存储过程运行，存储过程所 做的操作全部回滚；但如果过程体中使用捕获异常的语句，则异常可以被处理；其他级别只会产生不同优先级 别的消息。一个特定优先级别的消息是否会输出到客户端或写到服务器的日志中，或同时输出到客户端和服务 器日志，则由配置变量 log_min_messages 和 client_min_messages 控制。 b. FormatString，是一个格式字符串，可以是简单字符串，也可以是包含一个或多个’%’ 字符的格式字符串。运行 时，每个’%’ 都将被后续对应的表达式 expression 的值替换；’%%’ 会显示一个’%’ 字符。参数的数量必须匹配 格式字符串中% 占位符的数量，否则在函数编译期间就会发生错误。 c. USING 将其后的 option = expression 作为额外的消息附加到输出的消息中。 d. option 关键字可以是 MESSAGE、DETAIL、HINT 和 ERRCODE，expression 可以是任意的字符串表达式。 MESSAGE 设置错误信息，如果在 USING 前已经指定了格式串，则同时指定该选项是错误的；DETAIL 提供 484 第 14 章 语言元素 一个错误的详细信息；HINT 提供一个提示信息；ERRCODE 指定错误码（SQLSTATE），也可以是已定义的 异常名，或者是一个五个字符（字符的取值范围为数字 0-9 和大写字母 A-Z 的任意组合）的 SQLSTATE 码， 如果 USING 前已经指定了异常名或 SQLSTATE，则同时指定 ERRCODE 是错误的。 e. 在格式二和格式三中不能指定格式串，可以在 USING 子句中提供需要显示的错误信息。 f. 当通过 SQLSTATE 码指定错误码时，不局限于预定义的错误码，它可以是由数字（0-9）或大写字母（A-Z） 任意组合成的长度为 5 的串。建议避免使用以 3 个 0 结束的错误码，因为这种错误码是某一类错误码，只能通 过捕获整个类来捕获。 示例 \set SQLTERM ; CREATE TABLE testRaise(i INT); \set SQLTERM / CREATE PROCEDURE testRaise(i INT) AS BEGIN IF i > 0 AND i <10 THEN RAISE NOTICE 'your input value "%" is valid.',i; ELSE RAISE EXCEPTION 'your input value "%" is invalid.',i; END IF; INSERT INTO testRaise VALUES(i); END; / \set SQLTERM ; 函数参数为 9 的查询结果: CALL testRaise(9); NOTICE: your input value "9" is valid. CALL 函数参数为 11 的查询结果: CALL testRaise(11); ERROR: your input value "11" is invalid. CONTEXT: PL/SQL function TESTRAISE(INTEGER) line 6 at RAISE 插入值，并显示结果: INSERT INTO testRaise VALUES(20); SELECT * FROM testRaise; 485 第 14 章 语言元素 I ---9 20 (2 rows) 删除表和存储过程： DROP TABLE testRaise; DROP PROCEDURE testRaise; 示例 14-15 在 RAISE 语句中指定 HINT : \set SQLTERM / CREATE OR REPLACE FUNCTION check_userid() RETURNS VOID AS DECLARE user_id VARCHAR(10); BEGIN user_id = '00000'; RAISE EXCEPTION 'Nonexistent ID --> %', user_id USING HINT = 'Please check your user id'; END; / \set SQLTERM ; SELECT check_userid(); DROP FUNCTION check_userid(); 执行结果: ERROR: Nonexistent ID --> 00000 HINT: Please check your user id CONTEXT: PL/SQL function CHECK_USERID() line 6 at RAISE 示例 14-16 如下两种设置 SQLSTATE 的方法是等价的: \set SQLTERM / BEGIN RAISE 'The value can not be NULL' USING ERRCODE = 'not_null_violation'; END; / \set SQLTERM ; 执行结果: 486 第 14 章 ERROR: 语言元素 The value can not be NULL CONTEXT: PL/SQL function inline_code_block line 2 at RAISE \set SQLTERM / BEGIN RAISE 'The value can not be NULL' USING ERRCODE = '23502'; END; / \set SQLTERM ; 执行结果: ERROR: The value can not be NULL CONTEXT: PL/SQL function inline_code_block line 2 at RAISE 示例 14-17 主要参数是要被报告的条件名或 SQLSTATE： \set SQLTERM / BEGIN RAISE division_by_zero; END; / \set SQLTERM ; 执行结果: ERROR: division_by_zero CONTEXT: PL/SQL function inline_code_block line 2 at RAISE 示例 14-18 主要参数是要 SQLSTATE： \set SQLTERM / BEGIN RAISE SQLSTATE '22012'; END; / \set SQLTERM ; 执行结果: ERROR: 22012 CONTEXT: PL/SQL function inline_code_block line 2 at RAISE 示例 14-19 USING 能被用来提供一个自定义的错误消息、细节或提示： 487 第 14 章 语言元素 \set SQLTERM / BEGIN RAISE USING MESSAGE = 'Only USING clause'; END; / \set SQLTERM ; 执行结果: ERROR: Only USING clause CONTEXT: PL/SQL function inline_code_block line 2 at RAISE 示例 14-20 没有参数的 RAISE ： \set SQLTERM / CREATE OR REPLACE FUNCTION reraise_test() RETURNS VOID AS DECLARE c VARCHAR(20); BEGIN c = 'OUTER BLOCK'; <> DECLARE c VARCHAR(20); BEGIN c = 'INNER BLOCK'; RAISE 'Where am I: %', c USING ERRCODE = 'zero_divide'; EXCEPTION WHEN OTHERS THEN RAISE NOTICE 'Where am I: %', c; RAISE; END; EXCEPTION WHEN OTHERS THEN RAISE 'Where am I: %', c; RAISE; END; / \set SQLTERM ; SELECT reraise_test(); DROP FUNCTION reraise_test(); 执行结果: 488 第 14 章 NOTICE: Where am I: INNER BLOCK ERROR: Where am I: OUTER BLOCK CONTEXT: 语言元素 PL/SQL function RERAISE_TEST() line 19 at RAISE • 示例 12-6 ，“声明、触发和处理用户定义的异常” • 示例 12-7 ，“触发系统预定义异常” • 示例 12-8 ，“重新触发异常” 相关话题 在本章节： • 异常声明 • 异常处理程序 在其他章节： • 显式触发异常 14.47 记录变量声明 记录变量是一个复合变量，其内部组件（称为字段）可以具有不同的数据类型。记录变量的值及其字段的值可以 更改。 可以通过名称引用整个记录变量。使用语法引用记录字段 record.field。 可以通过以下任何方式创建记录变量： • 定义记录类型，然后声明该类型的变量。 • 用于%ROWTYPE 声明表示数据库表或视图的全部或部分行的记录变量。 • 用于%TYPE 声明与先前声明的记录变量具有相同类型的记录变量。 语法 record_type_definition ::= TYPE record_type IS RECORD ( field_definition [, field_definition]... ) ; 489 第 14 章 语言元素 field_definition ::= field datatype [ [ NOT NULL ] { := | DEFAULT } expression ] ( datatype ::= , expression ::= ) record_variable_declaration ::= record_1 { record_type | rowtype_attribute | record_2%TYPE }; ( rowtype_attribute ::= ) 语义 record_type_definition record_type 正在定义的记录类型的名称。 field_definition field 正在定义的字段的名称。 datatype 正在定义的字段的数据类型。 NOT NULL 对定义的字段施加 NOT NULL 约束。 有关此约束的信息，请参阅NOT NULL 约束 。 expression 490 第 14 章 语言元素 数据类型与数据类型兼容的表达式。详细说明 record_variable_declaration 时，将表达式的 值分配给 record.field。该值是该字段的初始值。 record_variable_declaration record_1 要声明的记录变量的名称。 record_type 先前定义的记录类型的名称。record_type 是 record_1 的数据类型。 rowtype_attribute 请参阅%ROWTYPE 属性 。 record_2 先前声明的记录变量的名称。 %TYPE 请参阅%TYPE 属性 。 示例 • 示例 6-31，“记录类型定义和变量声明” • 示例 6-32，“带有 RECORD 字段的 RECORD 类型（嵌套 RECORD）” • 示例 6-33，“带有可变数组字段的记录类型” 相关话题 在本章节： • 集合变量声明 • %ROWTYPE 属性 14.48 RETURN 语句 RETURN 语句立即结束子程序或包含它的匿名块的执行。 在函数中，RETURN 语句将指定的值分配给函数标识符并将控制权返回给调用者，调用者在调用后立即恢复 执行（可能在调用语句内）。函数中的每个执行路径都必须指向一个 RETURN 语句（否则，PL/SQL 运行时会报 错）。 在过程中，RETURN 语句将控制权返回给调用者，在调用后立即恢复执行。 在匿名块中，RETURN 语句退出它自己的块和所有封闭块。 一个子程序或匿名块可以包含多个 RETURN 语句。 491 第 14 章 语言元素 注意: 该 RETURN 语句与 RETURN 函数头中的子句不同，它指定返回值的数据类型。 语法 return_statement ::= RETURN [ expression ] ; ( expression ::= ) 语义 return_statement expression 当 RETURN 语句在流水线表函数中时可选。当 RETURN 语句在任何其他函数中时是必需的。 当 RETURN 语句在过程或匿名块中时不允许。 RETURN 语句将表达式的值分配给函数标识符。因此，表达式的数据类型必须与函数的 RETURN 子句中的数据类型兼容。有关表达式的信息，请参阅表达式”。 示例 • 示例 9-3，“函数中的 RETURN 语句后恢复执行” • 示例 9-4，“并非每个执行路径都指向 RETURN 语句的函数” • 示例 9-5，“每个执行路径都指向 RETURN 语句的函数” • 示例 9-6，“过程中的 RETURN 语句后继续执行” • 示例 9-7，“匿名块中的 RETURN 语句后恢复执行” 相关话题 在本章节： • 块 • 函数声明与定义 • 过程声明与定义 492 第 14 章 语言元素 14.49 RETURN NEXT 以及 RETURN QUERY 语句 当一个 PL/SQL 函数被声明为返回 SETOF sometype，那么遵循的过程则略有不同。在这种情况下，要返回的 个体项被用一个 RETURN NEXT 或者 RETURN QUERY 命令的序列指定，并且接着会用一个不带参数的最终 RETURN 命令来指示这个函数已经完成执行。RETURN NEXT 可以被用于标量和复合数据类型；对于复合类型，将返 回一个完整的结果” 表”。RETURN QUERY 将执行一个查询的结果追加到一个函数的结果集中。在一个单一的返回 集合的函数中，RETURN NEXT 和 RETURN QUERY 可以被随意地混合，这样它们的结果将被串接起来。 RETURN NEXT 和 RETURN QUERY 实际上不会从函数中返回—它们简单地向函数的结果集中追加零或多 行。然后会继续执行 PL/SQL 函数中的下一条语句。随着后继的 RETURN NEXT 和 RETURN QUERY 命令的执 行，结果集就建立起来了。最后一个 RETURN（应该没有参数）会导致控制退出该函数（或者你可以让控制到达函 数的结尾）。 如果声明函数带有输出参数，只需要写不带表达式的 RETURN NEXT。在每一次执行时，输出参数变量的当 前值将被保存下来用于最终返回为结果的一行。注意为了创建一个带有输出参数的集合返回函数，在有多个输出参数 时，你必须声明函数为返回 SETOF record；或者如果只有一个类型为 sometype 的输出参数时，声明函数为 SETOF sometype。 语法 RETURN NEXT expression; RETURN QUERY query; RETURN QUERY EXECUTE command-string [ USING expression [, ... ] ]; 语义 RETURN QUERY EXECUTE RETURN QUERY 有一种变体 RETURN QUERY EXECUTE，它可以动态指定要被执行的查询。可以 通过 USING 向计算出的查询字符串插入参数表达式，这和在 EXECUTE 命令中的方式相同。 示例 下面是一个使用 RETURN NEXT 的函数例子： \set SQLTERM ; CREATE TABLE foo (fooid INT, foosubid INT, fooname TEXT); INSERT INTO foo VALUES (1, 2, 'three'); INSERT INTO foo VALUES (4, 5, 'six'); \set SQLTERM / CREATE OR REPLACE FUNCTION get_all_foo() RETURNS SETOF foo AS DECLARE r foo%rowtype; BEGIN FOR r IN 493 第 14 章 语言元素 SELECT * FROM foo WHERE fooid > 0 LOOP -- 这里可以做一些处理 RETURN NEXT r; -- 返回 SELECT 的当前行 END LOOP; RETURN; END; / \set SQLTERM ; SELECT * FROM get_all_foo(); FOOID | FOOSUBID | FOONAME -------+----------+--------1 | 2 | three 4 | 5 | six (2 rows) 这里是一个使用 RETURN QUERY 的函数的例子： CREATE TABLE flight (flightid INT, flightdate date); INSERT INTO flight VALUES(1001, '2018-07-05'); INSERT INTO flight VALUES(1002, '2018-07-06'); \set SQLTERM / CREATE OR REPLACE FUNCTION get_available_flightid(date) RETURNS SETOF integer AS BEGIN RETURN QUERY SELECT flightid FROM flight WHERE flightdate >= $1 AND flightdate < ($1 + 1); -- 因为执行还未结束，我们可以检查是否有行被返回 -- 如果没有就抛出异常。 IF NOT FOUND THEN RAISE EXCEPTION 'No flight at %.', $1; END IF; RETURN; END; / \set SQLTERM ; -- 返回可用的航班或者在没有可用航班时抛出异常。 SELECT * FROM get_available_flightid('2019-07-06'); DROP TABLE flight; DROP FUNCTION get_available_flightid; 494 第 14 章 语言元素 执行结果： ERROR: No flight at 2019-07-06 00:00:00. CONTEXT: 注意: PL/SQL function GET_AVAILABLE_FLIGHTID(DATE) line 8 at RAISE 如上所述，目前 RETURN NEXT 和 RETURN QUERY 的实现在从函数返回之前会把整个结果集都保存起 来。这意味着如果一个 PL/SQL 函数生成一个非常大的结果集，性能可能会很差：数据将被写到磁盘上以避免内存 耗尽，但是函数本身在整个结果集都生成之前不会退出。将来的 PL/SQL 版本可能会允许用户定义没有这种限制的 集合返回函数。目前，数据开始被写入到磁盘的时机由配置变量 work_mem 控制。拥有足够内存来存储大型结果集 的管理员可以考虑增大这个参数。 14.50 RETURNING INTO 子句 RETURNING INTO 子句指定存储子句所属语句返回的值的变量。 变量可以是单个变量或集合。如果该语句不影响任何行，则变量的值未定义。 静态 RETURNING INTO 子句属于 DELETE、INSERT 或 UPDATE 语句。动态 RETURNING INTO 子句属 于 EXECUTE IMMEDIATE 语句。 注意: 不能将该 RETURNING INTO 子句用于远程或并行删除。 语法 static_returning_clause ::= { RETURNING | RETURN } column [, column ]... { into_clause | bulk_collect_into_clause } dynamic_returning_clause ::= { RETURNING | RETURN } { into_clause | bulk_collect_into_clause } 495 第 14 章 语言元素 into_clause ::= INTO { variable [, variable ]... | record ) bulk_collect_into_clause ::= BULK COLLECT INTO { collection } [, { collection } ]... 语义 static_returning_clause column 表达式，其值为数据库表的列名。 into_clause 指定存储语句返回的列值的变量或记录。 对 into_clause 的限制 当且仅当 dynamic_sql_stmt（出现在“EXECUTE IMMEDIATE Statement”中）返回单行 时，在 dynamic_returning_clause 中使用 into_clause。 record 用于存储语句返回的行的记录变量的名称。对于语句中的每个 select_list 项，记录必须有一个 对应的、类型兼容的字段。 variable 496 第 14 章 语言元素 存储语句返回的列的标量变量的名称或在 PL/SQL 宿主环境中声明并作为绑定变量传递给 PL/ SQL 的宿主游标变量的名称。语句中的每个 select_list 项都必须有一个对应的类型兼容的变 量。宿主游标变量的数据类型与任何 PL/SQL 游标变量的返回类型兼容。 bulk_collect_into_clause 指 定 一 个 或 多 个 现 有 集 合， 用 于 存 储 语 句 返 回 的 行。 对 于 语 句 中 的 每 个 select_list 项， bulk_collect_into_clause 必须具有对应的、类型兼容的集合。 有关使用此子句的原因，请参阅批量 SQL 和批量绑定 。 对 bulk_collect_into_clause 的限制 当且仅当 dynamic_sql_stmt（出现在EXECUTE IMMEDIATE 语句 中）可以返回多行时，才 使用 dynamic_returning_clause 中的 bulk_collect_into_clause 子句。 不能在客户端程序中使用 bulk_collect_into_clause。 当包含 bulk_collect_into_clause 的 语 句 需 要 隐 式 数 据 类 型 转 换 时， bulk_collect_into_clause 只能有一个集合。 collection 存储语句返回的行的集合变量的名称。 collection 限制 collection 不能是由字符串索引的关联数组的名称。 当语句需要隐式数据类型转换时，collection 不能是复合类型的集合的名称。 示例 • 示例 6-47，“UPDATE 语句为记录变量赋值” • 示例 7-1，“静态 SQL 语句” • 示例 13-20，“返回两个嵌套表中已删除的行” • 示例 13-21，“FORALL 语句中使用带有 RETURN BULK COLLECT INTO 子句的 DELETE 语句” 相关话题 在本章节： • DELETE 语句扩展 • EXECUTE IMMEDIATE 语句 • FETCH 语句 • SELECT INTO 语句 • UPDATE 语句扩展 在其他章节： • 使用 SQL 语句将行返回到 PL/SQL record 变量 497 第 14 章 语言元素 • EXECUTE IMMEDIATE 语句 • RETURNING INTO 子句带有 BULK COLLECT 子句 14.51 RESULT_CACHE 子句 仅兼容语法。 该 RESULT_CACHE 子句可以出现在以下 SQL 语句中： • 函数声明与定义 语法 result_cache_clause ::= RESULT_CACHE [ RELIES_ON ( [ data_source [, data_source]... ] ) ] 语义 result_cache_clause result_cache_clause 在函数中只能出现一次。 RESULT_CACHE 仅兼容语法。 14.52 %ROWTYPE 属性 %ROWTYPE 属性允许您声明表示数据库表或视图的完整或部分行的记录。 对于整行或部分行的每个可见列，记录都有一个具有相同名称和数据类型的字段。如果行的结构发生变化，那么 记录的结构也会相应地发生变化。使不可见的列可见会更改使用%ROWTYPE 属性声明的某些记录的结构。 记录字段不继承相应列的约束或初始值。 语法 rowtype_attribute ::= { explicit_cursor_name | cursor_variable_name | db_table_or_view_name } %ROWTYPE 498 第 14 章 语言元素 语义 rowtype_attribute explicit_cursor_name 显式游标的名称。对于由与 explicit_cursor_name 关联的查询选择的每一列，记录都有一个 具有相同名称和数据类型的字段。 cursor_variable_name 强游标变量的名称。对于与 cursor_variable_name 关联的查询选择的每一列，记录都有一个 具有相同名称和数据类型的字段。 db_table_or_view_name 详细说明声明时可访问的数据库表或视图的名称。对于 db_table_or_view_name 的每一列，记 录都有一个具有相同名称和数据类型的字段。 示例 • 示例 6-35，“%ROWTYPE 变量表示完整的数据库表行” • 示例 6-36，“%ROWTYPE 变量不继承初始值或约束” • 示例 6-37，“%ROWTYPE 变量表示部分数据库表行” • 示例 6-38，“%ROWTYPE 变量表示连接行” • 示例 6-43，“将%ROWTYPE 记录分配给 RECORD 类型记录” 相关话题 在本章节： • 游标变量声明 • 显式游标声明和定义 • 记录变量声明 • %TYPE 属性 在其他章节： • 使用%ROWTYPE 属性声明 499 第 14 章 语言元素 标量变量声明 14.53 标量变量存储没有内部组件的值。值可以改变。标量变量声明指定变量的名称和数据类型并为其分配存储空间。 声明还可以分配初始值并施加 NOT NULL 约束。 通过名称引用标量变量。 语法 variable_declaration ::= variable datatype [ [ NOT NULL] {:= | DEFAULT} expression ] ; ( expression ::= ) 语义 variable_declaration variable 要声明的变量的名称。 datatype 标量数据类型的名称，包括大小、精度和字符或字节语义的任何限定符。 有关标量数据类型的信息，请参阅PL/SQL 数据类型 。 NOT NULL 对变量施加 NOT NULL 约束。有关此约束的信息，请参阅NOT NULL 约束 。 expression 详细说明声明时要分配给变量的值。expression 和 variable 必须具有兼容的数据类型。 示例 • 示例 3-11，“声明常量” • 示例 3-12，“带有初始值的变量和常量声明” • 示例 3-9，“变量默认初始化为 NULL” • 示例 3-8，“具有 NOT NULL 约束的变量声明” 500 第 14 章 语言元素 14.54 SELECT INTO 语句 该 SELECT INTO 语句从一个或多个数据库表中检索值（就像 SQL SELECT 语句一样）并将它们存储在变量 中（SQL SELECT 语句不这样做）。 警告: 带有 BULK COLLECT 子句的 SELECT INTO 语句容易受到别名的影响，这可能会导致意外结果。 有关详细信息，请参阅SELECT BULK COLLECT INTO 语句和别名 。 语法 select_into_statement ::= SELECT [ { DISTINCT | UNIQUE | ALL } ] select_list { into_clause | bulk_collect_into_clause } FROM rest_of_statement ; ( bulk_collect_into_clause ::= , into_clause ::= , select_list ::= ) 语义 select_into_statement DISTINCT | UNIQUE 如果希望数据只返回每组选定重复行的一个副本，请指定 DISTINCT 或 UNIQUE 。这两个关 键字是同义词。重复行是与选择列表中的每个表达式的匹配值的行。 对 DISTINCT 和 UNIQUE 查询的限制 所有选择列表表达式中的总字节数限制为数据块的大小减去一些开销。 如果 select_list 包含 lob 列，则不能指定 DISTINCT 。 ALL （默认）使数据库返回所有选定的行，包含所有重复的副本。 select_list 如果 SELECT INTO 语 句 没 有 返 回 任 何 行，PL/ SQL 就会引发预定义的异常 NO_DATA_FOUND。为防止出现此异常，请选择聚合函数 COUNT(*) 的结果，即使没 有符合条件的行也会返回单个值。 501 第 14 章 语言元素 into_clause 使用此子句，SELECT INTO 语句从单行中检索一列或多列，并将它们存储在一个或多个标量 变量或一个记录变量中。有关详细信息，请参阅into_clause ::= 。 bulk_collect_into_clause 使用此子句，SELECT INTO 语句检索整个结果集并将其存储在一个或多个集合变量中。有关 更多信息，请参阅bulk_collect_into_clause ::= 。 rest_of_statement 在 SQL SELECT 语句中可以跟随关键字 FROM 的任何内容。 示例 • 示例 3-23，“使用 SELECT INTO 语句为变量赋值” • 示例 6-45，“SELECT INTO 将值分配给记录变量” • 示例 7-35，“ROLLBACK 语句” • 示例 7-39，“在包中声明自治功能” • 示例 8-16，“防止 SQL 注入的验证检查” • 示例 13-11，“将两个数据库列批量选择到两个嵌套表中” • 示例 13-12，“批量选择到嵌套记录表” • 示例 13-16，“使用 ROWNUM、SAMPLE 和 FETCH FIRST 限制批量选择” 相关话题 在本章节： • FETCH 语句 • %ROWTYPE 属性 在其他章节： • 用 SELECT INTO 语句为变量赋值 • 使用 SELECT INTO 将一行赋值给 record 变量 • 使用 SELECT INTO 语句处理查询结果集 • 带有 BULK COLLECT 子句的 SELECT INTO 语句 14.55 SQLCODE 函数 在异常处理程序中，该 SQLCODE 函数返回正在处理的异常的数字代码。（在异常处理程序之外，SQLCODE 返回 0） 502 第 14 章 语言元素 对于内部定义的异常，数字代码是相关 KingbaseES 数据库错误的编号。 对于用户定义的异常，数字代码是 +1 （默认值）EXCEPTION_INIT 或由编译指示与异常关联的错误代码。 语法 sqlcode_function ::= SQLCODE 示例 • 示例 12-22，“显示 SQLCODE 和 SQLERRM 值” 相关话题 在本章节： • 块 • EXCEPTION_INIT 编译指示 • 异常处理程序 • SQLERRM 函数 在其他章节： • 检索异常信息 14.56 SQLERRM 函数 该 SQLERRM 函数返回与错误代码相关的错误消息。 注意: 建议使用 DBMS_UTILITY.FORMAT_ERROR_STACK 而不是 SQLERRM，除非使用 FORALL 语句及其 SAVE EXCEPTIONS 子句。有关详细信息，请参阅检索异常信息 。 语法 sqlerrm_function ::= SQLERRM [ ( error_code ) ] 503 第 14 章 语言元素 语义 sqlerrm_function error_code 值为数据库错误代码的表达式。 默认值：与 SQLCODE 的当前值关联的错误代码。 如果 error_code 的值为负数，其绝对值为数据库错误代码，则 SQLERRM 返回与该错误代码 关联的错误消息。例如： set serveroutput on; \set SQLTERM / BEGIN DBMS_OUTPUT.PUT_LINE('SQLERRM(-6511): ' || TO_CHAR(SQLERRM(-6511))); END; / 结果： SQLERRM(-6511): ERRCODE-6511: cursor_already_open 如果 error_code 的值为负数且其绝对值不是数据库错误代码，SQLERRM 将返回此消息。例 如： set serveroutput on; \set SQLTERM / BEGIN DBMS_OUTPUT.PUT_LINE('SQLERRM(-50000): ' || TO_CHAR(SQLERRM(-50000))); END; / 结果： SQLERRM(-50000): ERRCODE-50000: non-KingbaseES exception 示例 • 示例 12-22，“显示 SQLCODE 和 SQLERRM 值” • 示例 13-8，“在 FORALL 语句完成后处理 FORALL 异常” 相关话题 在本章节： • 块 • EXCEPTION_INIT 编译指示 504 第 14 章 语言元素 • SQLCODE 函数 14.57 %TYPE 属性 %TYPE 属性允许将常量、变量、集合元素、记录字段或子程序参数声明为与先前声明的变量或列具有相同的数 据类型（不知道该类型是什么）。 声明的项%TYPE 是引用项，之前声明的项是被引用项。 引用项从被引用项继承以下内容： • 数据类型和大小 • 引用项不继承被引用项的初始值。 • 如果被引用项的声明发生变化，那么引用项的声明也会相应改变。 语法 type_attribute::= { collection_variable_name | cursor_variable_name | db_table_or_view_name.column_name | object_name | record_variable_name[.field_name ] | scalar_variable_name } %TYPE 语义 505 第 14 章 语言元素 type_attribute collection_variable_name 集合变量的名称。 对 collection_variable_name 的限制 在常量声明中，collection_variable_name 不能是关联数组变量。 cursor_variable_name 游标变量的名称。 db_table_or_view_name 详细说明声明时可访问的数据库表或视图的名称。 column_name db_table_or_view 列的名称。 object_name ADT 实例的名称。 record_variable_name 记录变量的名称。 field_name record_variable 的字段名称。 scalar_variable_name 标量变量的名称。 示例 • 示例 3-14，“声明与列相同类型的变量” • 示例 3-15，“将相同类型的变量声明为另一个变量” 相关话题 在本章节： • %ROWTYPE 属性 • 标量变量声明 在其他章节： • 使用%TYPE 属性声明 506 第 14 章 语言元素 14.58 UPDATE 语句扩展 PL/SQL 扩展 SQL UPDATE 语句的 update_set_clause 和 where_clause 如下： 在 update_set_clause 中，可以指定一条记录。对于每个选定的行，UPDATE 语句使用相应记录字段的值更新 每一列。 在 where_clause 中，可以指定一个 CURRENT OF 子句，它将 UPDATE 语句限制在指定游标的当前行。 语法 update_set_clause ::= SET ROW = record where_clause ::= WHERE condition CURRENT OF for_update_cursor 语义 update_set_clause record 代表 dml_table_expression_clause 描述的项目的行的记录变量的名称。也就是说，对于行的每 一列，记录必须有一个数据类型兼容的字段。如果列具有 NOT NULL 约束，则其对应字段不能 具有 NULL 值。 where_clause for_update_cursor FOR UPDATE 游标的名称；也就是说，与 FOR SELECT UPDATE 语句关联的显式游标。 示例 • 示例 6-50，“通过记录更新行” 相关话题 在本章节： • 显式游标声明和定义 • 记录变量声明 507 第 14 章 语言元素 • %ROWTYPE 属性 在其他章节： • 通过 Record 变量更新行 • 对 record 变量插入和更新的限制 • SELECT FOR UPDATE 和 FOR UPDATE 游标 14.59 WHILE LOOP 语句 WHILE LOOP 语句在条件为 TRUE 时运行一个或多个语句。 WHILE LOOP 语句在条件变为 FALSE 或 NULL 时结束，当循环内的语句将控制转移到循环外或引发异常时也 会结束。 语法 while_loop_statement ::= WHILE boolean_expression LOOP statement... END LOOP [ label ] ; ( boolean_expression ::= , statement ::= ) 语义 while_loop_statement boolean_expression 值为 TRUE、FALSE 或 NULL 的表达式。 boolean_expression 在循环的每次迭代开始时进行评估。如果其值为 TRUE，则 LOOP 之后 的语句将运行。否则，控制转移到 WHILE LOOP 语句之后的语句。 statement 为防止无限循环，至少有一条语句必须将 boolean_expression 的值更改为 FALSE 或 NULL， 将控制转移到循环外，或引发异常。 可以将控制转移到循环外的语句是： • “CONTINUE 语句”（当它将控制转移到封闭标记循环的下一次迭代时） 508 第 14 章 语言元素 • “EXIT 语句” • “GOTO 语句” • “RAISE 语句” label 标识 while_loop_statement 的标签（参见statement ::= , label ::= ）。CONTINUE、EXIT 和 GOTO 语句可以引用这个标签。 标签提高了可读性，尤其是当 LOOP 语句嵌套时，但前提是确保 END LOOP 语句中的标签与 同一 LOOP 语句开头的标签匹配。 示例 示例 14-21 WHILE LOOP 语句 第一个语句中的 WHILE LOOP 语句从不运行，第二个语句中的 WHILE LOOP 语句运行一次。 \set SQLTERM / DECLARE a1 BOOLEAN := FALSE; BEGIN WHILE a1 LOOP raise notice '%', 'Not print.'; a1 := TRUE; END LOOP; WHILE NOT a1 LOOP raise notice '%', 'Hello, world!'; a1 := TRUE; END LOOP; END; / 结果： NOTICE: Hello, world! 相关话题 • 基本 LOOP 语句 • 游标 FOR LOOP 语句 • 显式游标声明和定义 • FETCH 语句 • FOR LOOP 语句 • FORALL 语句 509 第 14 章 语言元素 • OPEN 语句 • WHILE LOOP 语句 510 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 第 15章 用于存储 PL/SQL 单元的 SQL 语 句 本章解释如何使用创建、更改和删除存储的 PL/SQL 单元的 SQL 语句。 CREATE [ OR REPLACE ] 语句 这些 SQL 语句中的每一个都在模式级别创建一个 PL/SQL 单元并将其存储在数据库中： • CREATE FUNCTION 语句 • CREATE PACKAGE 语句 • CREATE PACKAGE BODY 语句 • CREATE PROCEDURE 语句 • CREATE TRIGGER 语句 • CREATE TYPE 语句 • CREATE TYPE BODY 语句 这些 CREATE 语句中的每一个都有一个可选 OR REPLACE 子句。指定 OR REPLACE 重新创建现有的 PL/ SQL 单元，即更改其声明或定义而不删除它、重新创建它并重新授予之前授予的对象权限 (替换触发器和 type 会删 除重建)。如果重新定义 PL/SQL 单元，数据库会重新编译它。 注意: 在 CREATE OR REPLACE 替换现有的 PL/SQL 单元之前，语句不会发出警告。 这些 CREATE 语句都不能出现在 PL/SQL 块中。 ALTER 语句 要重新编译现有的 PL/SQL 单元而不重新创建它（不更改其声明或定义），请使用以下 SQL 语句之一： • ALTER FUNCTION 语句 • ALTER PACKAGE 语句 • ALTER PROCEDURE 语句 511 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 • ALTER TRIGGER 语句 • ALTER TYPE 语句 使用 ALTER 语句的原因是： 启用或禁用触发器。 该 ALTER TYPE 语句还有其他用途。 DROP 语句 要从数据库中删除现有的 PL/SQL 单元，请使用以下 SQL 语句之一： • DROP FUNCTION 语句 • DROP PACKAGE 语句 • DROP PACKAGE BODY 语句 • DROP PROCEDURE 语句 • DROP TRIGGER 语句 • DROP TYPE 语句 • DROP TYPE BODY 语句 15.1 ALTER FUNCTION 语句 ALTER FUNCTION 更改一个函数的定义。 你必须拥有该函数以使用 ALTER FUNCTION。要更改一个函数的模式，你还必须具有新模式上的 CREATE 特权。 要更改拥有者，你还必须是新拥有角色的一个直接或者间接成员，并且该角色必须具有在该函数的模式上的 CREATE 特权（这些限制强制修改拥有者不能做一些通过删除和重建该函数做不到的事情。不过，一个超级用户怎么都能更改 任何函数的所有权）。 语法 ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] action [ ... ] [ RESTRICT ] ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] RENAME TO new_name ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] OWNER TO { new_owner | CURRENT_USER | SESSION_USER } ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] SET SCHEMA new_schema ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] DEPENDS ON EXTENSION extension_name ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] COMPILE 512 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ALTER FUNCTION name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] COMMENT 'String' 其中 action 是以下之一： CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT IMMUTABLE | STABLE | VOLATILE | [ NOT ] LEAKPROOF [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER PARALLEL { UNSAFE | RESTRICTED | SAFE } COST execution_cost ROWS result_rows SUPPORT support_function SET configuration_parameter { TO | = } { value | DEFAULT } SET configuration_parameter FROM CURRENT RESET configuration_parameter RESET ALL 语义 name 一个现有函数的名称（可以被模式限定）。如果没有指定参数列表，则该名称必须在它的模式 中唯一。 argmode 一个参数的模式：IN、OUT、INOUT 或者 VARIADIC。如果被忽略，默认为 IN。注意 ALTER FUNCTION 并不真正关心 OUT 参数，因为在决定函数的身份时只需要输入参数。因此列出 IN、 INOUT 以及 VARIADIC 参数即可。 argname 一个参数的名称。注意 ALTER FUNCTION 并不真正关心参数名称，因为在确定函数的身份时只 需要参数的数据类型即可。 argtype 该函数的参数（如果有）的数据类型（可以被模式限定）。 new_name 该函数的新名称。 new_owner 该函数的新拥有者。注意如果该函数被标记为 SECURITY DEFINER，它的后续执行将会使用新拥 有者。 new_schema 该函数的新模式。 513 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 extension_name 该函数所依赖的扩展的名称。 CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT CALLED ON NULL INPUT 将该函数改为在某些或者全部参数为空值时可以被调用。 RETURNS NULL ON NULL INPUT 或者 STRICT 将该函数改为只要任一参数为空值就不被调用而是 自动假定一个空值结果。详见CREATE FUNCTION 语句 。 IMMUTABLE | STABLE | VOLATILE 把该函数的稳定性更改为指定的设置。详见CREATE FUNCTION 语句 。 [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER 更改该函数是否为一个安全性定义者。关键词 EXTERNAL 是为了符合 SQL，它会被忽略。关于 这项能力的详情请见CREATE FUNCTION 语句 。 PARALLEL 决定该函数对于并行是否安全。详见CREATE FUNCTION 语句 。 LEAKPROOF 更改该函数是否被认为是防泄漏的。关于这项能力的详情请见CREATE FUNCTION 语句 。 COST execution_cost 更改该函数的估计执行代价。详见CREATE FUNCTION 语句 。 ROWS result_rows 更改一个集合返回函数的估计行数。详见CREATE FUNCTION 语句 。 SUPPORT support_function 设置或更改计划器支持函数以用于此函数。详见 函数优化的信息。超级用户方能使用此选项。 此选项不能用于完全删除支持函数，因为它必须命名一个新的支持函数。如果需要，可以使用 CREATE OR REPLACE FUNCTION。 configuration_parameter | value 当该函数被调用时，要对一个配置参数做出增加或者更改的赋值。如果 “value“是 DEFAULT 或 者使用等价的 RESET，该函数本地的设置将会被移除，这样该函数会使用其环境中存在的值执 行。使用 RESET ALL 可以清除所有函数本地的设置。SET FROM CURRENT 把 ALTER FUNCTION 执行时该参数的当前值保存为进入该函数时要应用的值。 有关允许的参数名称和值可详见 SET 以及《KingbaseES 数据库参考手册》。 RESTRICT 为了符合 SQL 标准存在，被忽略。 COMPILE 514 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 重新编译函数，刷新其状态属性。 COMMENT 'String' 修改函数的注释内容，当参数 String 为空时相当于删除注释。此功能仅限在 MySQL 模式下使 用。 示例 要把用于类型 integer 的函数 sqrt 重命名为 square_root： ALTER FUNCTION sqrt(integer) RENAME TO square_root; 要把用于类型 integer 的函数 sqrt 的拥有者改为 joe： ALTER FUNCTION sqrt(integer) OWNER TO joe; 要把用于类型 integer 的函数 sqrt 的模式改为 maths： ALTER FUNCTION sqrt(integer) SET SCHEMA maths; 要把类型 integer 的函数 sqrt 标记为依赖于扩展 mathlib： ALTER FUNCTION sqrt(integer) DEPENDS ON EXTENSION mathlib; 要调整一个函数的自动搜索路径： ALTER FUNCTION check_password(text) SET search_path = admin, sys_temp; 要禁止一个函数的 search_path 的自动设置： ALTER FUNCTION check_password(text) RESET search_path; 这个函数将用其调用者使用的搜索路径来执行。 在 MySQL 模式的数据库下，修改一个函数的注释： ALTER FUNCTION add_em COMMENT 'CHANGE COMMENT FOR FUNCTION add_em'; 兼容性 这个语句部分兼容 SQL 标准中的 ALTER FUNCTION 语句。该标准允许修改一个函数的多个属性，但是不提供重 命名一个函数、标记一个函数为安全定义、为一个函数附加配置参数值或者更改一个函数的拥有者、模式或者稳定性 等功能。该标准还要求 RESTRICT 关键字，它在 KingbaseES 中是可选的。 参见 CREATE FUNCTION 语句 ，DROP FUNCTION 语句 ，ALTER PROCEDURE 语句 515 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 15.2 ALTER PACKAGE 语句 ALTER PACKAGE -- 修改一个包的定义 修改包的属性，包括：名称、属主和模式。需要注意，包属性的修改是没有包规范和包体之分的，包体总是和包 规范具有相同属性。包被修改后，该包的对象（变量、常量、游标、函数和存储过程）的相关属性也会被修改。 执行 ALTER PACKAGE 的用户必须是包的属主或非受限数据库管理员，并且要具有包所在模式的 USAGE 权限。 执行 OWNER TO 时，如果执行 ALTER PACKAGE 命令的用户是包的属主但不是非受限数据库管理员，那么新的用 户要具有该模式的 CREATE 权限。 执行 RENAME TO 时，要求用户具有包所在模式下的 CREATE 权限。 执行 SET SCHEMA 时，要求用户在新模式下拥有 CREATE 权限。 语法 ALTER PACKAGE name OWNER TO { new_owner | CURRENT_USER | SESSION_USER } ALTER PACKAGE name RENAME TO new_name ALTER PACKAGE name SET SCHEMA new_schema ALTER PACKAGE name COMPILE [ PACKAGE | SPECIFICATION | BODY ] 语义 name 修改的包的名字。可以有数据库名和模式名修饰，但数据库名只能是当前数据库。 new_name 包的新名字。 new_owner 包的新属主。 new_schema 包的新归属模式。 COMPILE 重新编译包，刷新其状态属性。可通过关键字 PACKAGE 指定是重新编译整个包，关键字 SPECIFICATION 指定重新编译包声明，关键字 BODY 指定重新编译包体。 示例 ALTER PACKAGE pkg OWNER TO user_a; ALTER PACKAGE pkg RENAME TO pkg2; 516 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ALTER PACKAGE test.public.pkg RENAME TO pkg3;(当前数据库为 TEST) ALTER PACKAGE pkg SET SCHEMA sch; 参见 CREATE PACKAGE 语句 ，CREATE PACKAGE BODY 语句 ，DROP PACKAGE 语句 ，DROP PACKAGE BODY 语句 15.3 ALTER PROCEDURE 语句 ALTER PROCEDURE 更改一个过程的定义。 要使用 ALTER PROCEDURE，你必须拥有该过程。要更改一个过程的模式，你还必须有新模式上的 CREATE 特 权。要更改拥有者，你还必须是新拥有角色的直接或间接成员，并且那个角色在该过程的模式上拥有 CREATE 特权 （这些限制强制更新拥有者无法做到通过删除和重建该过程无法做到的事情。不过，超级用户总是能够更改任何过程 的拥有关系）。 语法 ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] action [ ... ] [ RESTRICT ] ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] RENAME TO new_name ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] OWNER TO { new_owner | CURRENT_USER | SESSION_USER } ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] SET SCHEMA new_schema ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] DEPENDS ON EXTENSION extension_name ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] COMPILE ALTER PROCEDURE name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] COMMENT 'String' 其中 action 是下列之一： [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER SET configuration_parameter { TO | = } { value | DEFAULT } SET configuration_parameter FROM CURRENT RESET configuration_parameter RESET ALL 517 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 语义 name 一个现有的过程的名字（可以被模式限定）。如果没有指定参数列表，这个名字必须在其模式 中唯一。 argmode 参数的模式：IN 或 VARIADIC。如果被省略，默认是 IN。 argname 参数的名字。注意 ALTER PROCEDURE 实际上并不关心参数名，因为只需要参数的数据类型来确 定过程的身份。 argtype 如果该过程有参数，这是参数的数据类型（可以被模式限定）。 new_name 该过程的新名字。 new_owner 该过程的新拥有者。注意，如果这个过程被标记为 SECURITY DEFINER，接下来它将被作为新 拥有者执行。 new_schema 该过程的新模式。 extension_name 该过程所依赖的扩展的名称。 [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER 更改该过程是否为一个安全性定义器。关键词 EXTERNAL 由于 SQL 符合性的原因被忽略。更多 有关这个能力的信息请见CREATE PROCEDURE 语句 。 configuration_parameter | value 增加或者更改配置参数的值，该值在调用过程时使用。如果 “value“是 DEFAULT 或者等效 的值，则会使用 RESET，过程本地的设置会被移除，这样该过程的执行就会使用其所处环境 中的值。使用 RESET ALL 可以清除所有的过程本地设置。SET FROM CURRENT 会把 ALTER PROCEDURE 执行时该参数的当前值保存为进入该过程时要被应用的值。 RESTRICT 为了符合 SQL 标准会被忽略。 COMPILE 重新编译存储过程，刷新其状态属性。 518 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 COMMENT 'String' 修改存储过程的注释内容，当参数 String 为空时相当于删除注释。此功能仅限在 MySQL 模式 下使用。 示例 要重命名具有两个 integer 类型参数的过程 insert_data 为 insert_record： ALTER PROCEDURE insert_data(integer, integer) RENAME TO insert_record; 要把具有两个 integer 类型参数的过程 insert_data 的拥有者改为 joe： ALTER PROCEDURE insert_data(integer, integer) OWNER TO joe; 要把具有两个 integer 类型参数的过程 insert_data 的模式改为 accounting： ALTER PROCEDURE insert_data(integer, integer) SET SCHEMA accounting; 要把过程 insert_data(integer, integer) 标记为依赖于扩展 myext： ALTER PROCEDURE insert_data(integer, integer) DEPENDS ON EXTENSION myext; 要调整一个过程自动设置的搜索路径： ALTER PROCEDURE check_password(text) SET search_path = admin, sys_temp; 要为一个过程禁用 search_path 的自动设置： ALTER PROCEDURE check_password(text) RESET search_path; 现在这个过程将用其调用者所使用的任何搜索路径执行。 在 MySQL 模式的数据库下，修改一个存储过程的注释： ALTER PROCEDURE increment2 COMMENT 'CHANGE COMMENT FOR PRODURE increment2'; 兼容性 这个语句与 SQL 标准中的 ALTER PROCEDURE 语句部分兼容。标注你允许修改一个过程的多个属性，但是不提供 重命名过程、标记过程为安全定义、为过程附加配置参数值或者更改过程的拥有者、模式或者稳定性的能力。标准还 要求 RESTRICT 关键字，而它在 KingbaseES 中是可选的。 参见 CREATE PROCEDURE 语句 ，DROP PROCEDURE 语句 ，ALTER FUNCTION 语句 519 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 15.4 ALTER TRIGGER 语句 ALTER TRIGGER 更改一个现有触发器的属性。RENAME 子句更改给定触发器的名称而不更改其定义。DEPENDS ON EXTENSION 子句把该触发器标记为依赖于一个扩展，这样如果扩展被删除，该触发器也会被自动删除。可使用 ENABLE 启用或 DISABLE 禁用指定触发器。 要更改一个触发器的属性，你必须拥有该触发器所作用的表。 语法 ALTER TRIGGER name ON table_name RENAME TO new_name ALTER TRIGGER name ON table_name DEPENDS ON EXTENSION extension_name ALTER TRIGGER name ENABLE ALTER TRIGGER name DISABLE ALTER TRIGGER name COMPILE 语义 name 要修改的一个现有触发器的名称。 table_name 这个触发器所作用的表的名称。 new_name 该触发器的新名称。 extension_name 该触发器所依赖的扩展的名称。 COMPILE 重新编译触发器，刷新其状态属性。 注解 临时启用或者禁用一个触发器的功能由 PLSQL ALTER TABLE 或者ALTER TRIGGER 语句 提供。需要注意 的是使用 ALTER TRIGGER 禁用或启用触发器时，如果触发器名不唯一则报错。 示例 要重命名一个现有的触发器： ALTER TRIGGER emp_stamp ON emp RENAME TO emp_track_chgs; 要把一个触发器标记为依赖于一个扩展： ALTER TRIGGER emp_stamp ON emp DEPENDS ON EXTENSION emplib; 520 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 启用一个触发器： ALTER TRIGGER emp_stamp ENABLE; 禁用一个触发器： ALTER TRIGGER emp_stamp DISABLE; 兼容性 ALTER TRIGGER 是一种 KingbaseES 的 SQL 标准扩展。 参见 PLSQL ALTER TABLE 15.5 ALTER TYPE 语句 ALTER TYPE —更改一个类型的定义 语法 ALTER TYPE name action [, ... ] ALTER TYPE name OWNER TO { new_owner | CURRENT_USER | SESSION_USER } ALTER TYPE name RENAME ATTRIBUTE attribute_name TO new_attribute_name [ CASCADE | RESTRICT ] ALTER TYPE name RENAME TO new_name ALTER TYPE name SET SCHEMA new_schema ALTER TYPE name ADD VALUE [ IF NOT EXISTS ] new_enum_value [ { BEFORE | AFTER } neighbor_enum_value ] ALTER TYPE name RENAME VALUE existing_enum_value TO new_enum_value ALTER TYPE name ADD ATTRIBUTE (attribute_name data_type [, ... ]) [ CASCADE | RESTRICT ] ALTER TYPE name MODIFY ATTRIBUTE (attribute_name data_type [, ... ]) [ CASCADE | RESTRICT ] ALTER TYPE name DROP ATTRIBUTE (attribute_name [, ... ]) [ CASCADE | RESTRICT ] ALTER TYPE name COMPILE [ SPECIFICATION | BODY ] 这里 action 是以下之一： ADD ATTRIBUTE attribute_name data_type [ COLLATE collation ] [ CASCADE | RESTRICT ] DROP ATTRIBUTE [ IF EXISTS ] attribute_name [ CASCADE | RESTRICT ] ALTER ATTRIBUTE attribute_name [ SET DATA ] TYPE data_type [ COLLATE collation ] [ CASCADE | RESTRICT ] 521 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 MODIFY ATTRIBUTE attribute_name data_type [ CASCADE | RESTRICT ] ADD subprogram_spec DROP subprogram_spec 注意: ALTER TYPE name action 中的 { ADD | DROP | ALTER | MODIFY } ATTRIBUTE attribute_name ... 操作不能与 ALTER TYPE name { ADD | MODIFY | DROP } ATTRIBUTE ( attribute_name [ , ... ] ) ... 操作混 用。 下面的用法就是错误的： ALTER TYPE obj_type drop attribute c1, drop attribute (c2, c3); 正确的用法应是： ALTER TYPE obj_type drop attribute c1, drop attribute c2, drop attribute c3; 或者： ALTER TYPE obj_type drop attribute (c1, c2, c3); 注意: ALTER TYPE 更改一种现有类型的定义。它有几种形式： ADD ATTRIBUTE 这种形式为一种组合类型增加一个新属性，语法和CREATE TYPE 语句 相同。 DROP ATTRIBUTE [ IF EXISTS ] 这种形式从一种组合类型删除一个属性。如果指定了 IF EXISTS 并且该属性不存在，则不会抛出错误。 这种情况下会发出一个提示。 SET DATA TYPE 这种形式更改一种组合类型的一个属性类型。 OWNER 这种形式更改该类型的拥有者。 RENAME 这种形式更改该类型的名称或者一种组合类型的一个属性的名称。 SET SCHEMA 这种形式把该类型移动到另一个模式中。 ADD VALUE [ IF NOT EXISTS ] [ BEFORE | AFTER ] 522 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 这种形式为一种枚举类型增加一个新值。可以用 BEFORE 或者 AFTER 一个现有值来指定新值在枚举顺序中 的位置。否则，新项会被增加在值列表的最后。 如果指定了 IF NOT EXISTS，该类型已经包含新值时不会发生错误：会发出一个提示但是不采取其他行 动。否则，如果新值已经存在会发生错误。 RENAME VALUE 该形式重命名枚举类型的值。该值在枚举排序中的位置不受影响。如果指定的值不存在或新名称已存在， 则会发生错误。 ADD ATTRIBUTE、DROP ATTRIBUTE 和 ALTER ATTRIBUTE 动作可以被整合到一个多个修改组成的列表中，以便被 平行应用。例如，可以在一个命令中增加多个属性并且/或者修改多个属性的类型。 要使用 ALTER TYPE，你必须拥有该类型。要更改一个类型的模式，你还必须拥有新模式上的 CREATE 特权。要 更改拥有者，你还必须是新拥有角色的一个直接或者间接成员，并且该角色必须具有该类型的模式上的 CREATE 特权 （这些限制强制修改拥有者不能做一些通过删除和重建该类型做不到的事情。不过，一个超级用户怎么都能更改任何 类型的所有权。）。要增加一个属性或者修改一个属性类型，你还必须具有该数据类型上的 USAGE 特权。 语义 name 要修改的一个现有类型的名称（可能被模式限定）。 new_name 该类型的新名称。 new_owner 该类型新拥有者的用户名。 new_schema 该类型的新模式。 attribute_name 要增加、修改或者删除的属性名称。 new_attribute_name 要被重命名的属性的新名称。 data_type 要增加的属性的数据类型，或者是要修改的属性的新类型。 new_enum_value 要被增加到一个枚举类型的值列表的新值，或将赋予现有值的新名称。和所有枚举文本一样， 它需要被引号引用。 neighbor_enum_value 523 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 一个现有枚举值，新值应该被增加在紧接着该枚举值之前或者之后的位置上。和所有枚举文本 一样，它需要被引号引用。 existing_enum_value 现有的应该重命名的枚举值。和所有的枚举文本一样，它需要被引号引用。 subprogram_spec 对象类型的内部方法声明，详见CREATE TYPE 语句 。 CASCADE 自动将操作传播到被更改类型的类型表及其后代。 RESTRICT 如果被更改的类型是类型表的类型，则拒绝该操作。这是默认设置。 COMPILE 重新编译类型，刷新其状态属性，可通过关键字 SPECIFICATION 指定重新编译类型声明，关 键字 BODY 指定重新编译类型定义。 注解 如果 ALTER TYPE ... ADD VALUE（增加一个新值到枚举类型的形式）在一个事务块中执行，新值将不能使用直 到事务被提交之后。 涉及到一个新增加枚举值的比较有时会被只涉及原始枚举值的比较更慢。这通常只会在利用 BEFORE 或者 AFTER 来把新值的排序位置设置为非列表结尾的地方时发生。不过，有时候即使把新值增加到最后时也会发生这种情况（如 果创建了该枚举类型之后出现过 OID 计数器“回卷”，就会发生这种情况）。这种减速通常不明显，但是如果它确 实带来了麻烦，通过删除并且重建该枚举类型或者转储并且重载整个数据库可以重新得到最优性能。 示例 要重命名一个数据类型： ALTER TYPE electronic_mail RENAME TO email; 把类型 email 的拥有者改为 joe： ALTER TYPE email OWNER TO joe; 把类型 email 的模式改为 customers： ALTER TYPE email SET SCHEMA customers; 增加一个新属性到一个类型： ALTER TYPE compfoo ADD ATTRIBUTE f3 int; 在一个特定的排序位置上为一个枚举类型增加一个新值： 524 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ALTER TYPE colors ADD VALUE 'orange' AFTER 'red'; 重命名一个枚举值： ALTER TYPE colors RENAME VALUE 'purple' TO 'mauve'; 兼容性 增加和删除属性的变体是 SQL 标准的一部分，而其他变体是 KingbaseES 扩展。 参见 CREATE TYPE 语句 ，DROP TYPE 语句 15.6 CREATE FUNCTION 语句 CREATE FUNCTION 定义一个新函数。 该 CREATE FUNCTION 语句创建或替换独立函数。 独立函数是存储在数据库中的函数（返回单个值的子程序）。 如果 CREATE FUNCTION 语句包括了一个模式名，那么该函数会被创建在指定的模式中。如果 CREATE FUNCTION 语句没有指定模式名，则会被创建在当前模式中。 新函数的名称不能和同一个模式中具有相同输入参数类型的任何现有函数或过程名称相同。不过，不同参数类型 的函数和过程能够同名（这被称作重载）。 要替换一个现有函数的当前定义，可以使用 CREATE OR REPLACE FUNCTION。但不能用这种方式更改函数的名称 或者参数类型（如果尝试这样做，实际上就会创建一个新的不同的函数）。 CREATE OR REPLACE FUNCTION 将不会让你更改一个现有函数的返回类型。要这样做，你必须先删除再重建该函 数（在使用 OUT 参数时，除了删除函数之外无法更改任何 OUT 参数的类型）。 当 CREATE OR REPLACE FUNCTION 被用来替换一个现有的函数，该函数的拥有权和权限不会改变。所有其他的 函数属性会按照该命令中所指定的或者隐含的来赋值。同时，必须拥有该函数的角色才能替换它。 如果删除并且重建一个函数，且新函数和旧函数不一样时，你将必须删掉引用旧函数的现有规则、视图、触发器 等。使用 CREATE OR REPLACE FUNCTION 更改一个函数定义不会破坏引用该函数的对象。还有，ALTER FUNCTION 可 以被用来更改一个现有函数的大部分属性。 创建该函数的用户将成为该函数的拥有者。 要创建一个函数，你必须拥有参数类型和返回类型上的 USAGE 特权。 语法 第一种 PLSQL 语法： 525 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 create_function ::= CREATE [ OR REPLACE ] [ EDITIONABLE | NONEDITIONABLE ] FUNCTION plsql_function_source plsql_function_source ::= [ schema. ] function_name [ ( parameter_declaration [, parameter_declaration]... ) ] RETURN datatype [ { invoker_rights_clause | pipelined_clause }... ] [ COMMENT 'String' ] { IS | AS } { [ declare_section ] body } ; ( invoker_rights_clause ::= , pipelined_clause ::= , parameter_declaration ::= , datatype ::= , declare_section ::= , body ::= ) 第二种 PLPGSQL 语法： CREATE [ OR REPLACE ] [INTERNAL] FUNCTION name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] ) [ RETURNS rettype | RETURNS TABLE ( column_name column_type [, ...] ) ] [ COMMENT 'String' ] 526 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 { LANGUAGE lang_name | TRANSFORM { FOR TYPE type_name } [, ... ] | WINDOW | IMMUTABLE | STABLE | VOLATILE | [ NOT ] LEAKPROOF | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER | PARALLEL { UNSAFE | RESTRICTED | SAFE } | COST execution_cost | ROWS result_rows | SUPPORT support_function | SET configuration_parameter { TO value | = value | FROM CURRENT } | AS 'definition' | AS 'obj_file', 'link_symbol' } ... 语义 第一种语法的语义： create_function OR REPLACE 如果存在，则重新创建该函数，并重新编译它。 在重新定义函数之前被授予权限的用户仍然可以访问该函数，而无需重新授予权限。 [ EDITIONABLE | NONEDITIONABLE ] 仅兼容语法。 plsql_function_source schema 包含函数的模式的名称。默认值：当前模式。 function_name 要创建的函数的名称。 RETURN datatype 对于 datatype ，指定函数返回值的数据类型。返回值可以是 PL/SQL 支持的任何数 据类型。 数据类型不能指定长度、精度或小数位数。数据库从调用函数的环境中获取返回值的长 度、精度或小数位数。 不能限制此数据类型（例如，使用 NOT NULL）。 body 函数所需的可执行部分，以及函数的异常处理部分（可选）。 527 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 declare_section 函数的可选声明部分。声明是函数本地的，可以在 body 中引用，并且在函数完成执行 时不再存在。 COMMENT 'String' 添加函数的注释内容，此功能仅限在 MySQL 模式下使用。 第二种语法的语义： name 要创建的函数的名称（可以被模式限定）。 argmode 一个参数的模式：IN、OUT、INOUT 或者 VARIADIC，默认为 IN。 只有 OUT 参数能跟在一个 VARIADIC 参数后面。 OUT 和 INOUT 参数不能和 RETURNS TABLE 一起使用。 argname 参数名，可以在一些语言（包括 SQL 和 PL/SQL）函数体中使用该名称。对于其他语言，输入 参数名只是额外的文字。但是你可以在调用一个函数时使用输入参数名来提高可读性。 在任何情况下，输出参数的名称是有意义的，因为它定义了结果行类型中的列名（如果忽略一个输出参数 的名称，系统将选择一个默认的列名）。 argtype 该函数参数的数据类型。参数类型可以是基本类型、组合类型或者域类型，或者可以引用一个 表列的类型等。 根据实现语言，也可以允许指定 cstring 之类的伪类型。伪类型表示实际参数类型没有被完整 指定或者不属于普通 SQL 数据类型集合。 可以写 table_name.column_name%TYPE 来引用一列的类型。使用这种特性有时可以帮助创建 一个不受表定义更改影响的函数。 default_expr 当参数没有被指定值时，使用默认值的表达式。该表达式必须能被强制为该参数的参数类型。 只有输入（包括 INOUT）参数可以具有默认值。所有跟随在一个具有默认值的参数之后的输入 参数也必须有默认值。 rettype 返回数据类型（可能被模式限定）。返回类型可以是一种基本类型、组合类型或者域类型，也 可以引用一个表列的类型。根据实现语言，也可以允许指定 cstring 之类的“伪类型”。如果 该函数不会返回一个值，可以指定返回类型为 void。 当有 OUT 或者 INOUT 参数时，可以省略 RETURNS 子句。如果存在，该子句必须和输出参数所 表示的结果类型一致：如果有多个输出参数，则为 RECORD，否则与单个输出参数的类型相同。 528 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 SETOF 修饰符表示该函数将返回一个项的集合而不是一个单一项。 可以写 table_name.column_name%TYPE 来引用一列的类型。 column_name RETURNS TABLE 语法中一个输出列的名称。这实际上是另一种声明 OUT 参数的方法，不过 RETURNS TABLE 也隐含了 RETURNS SETOF。 column_type RETURNS TABLE 语法中的输出列的数据类型。 lang_name 用以实现该函数的语言的名称。可以是 sql、c、internal 或者一个用户定义的过程语言的名 称，例如 plsql 或 plpgsql。不推荐用单引号包围该名称，并且要求区分大小写。 TRANSFORM { FOR TYPE type_name } [, ... ] } 一个由转换构成的列表，对该函数的调用适用于它们。转换在 SQL 类型和语言相关的数据类型 之间进行变换，详见 PLSQL CREATE TRANSFORM 。过程语言实现通常把有关内建类型的 知识硬编码在代码中，因此那些不需要列举在这里。如果一种过程语言实现不知道如何处理一 种类型并且没有转换被提供，它将回退到一种默认的行为来转换数据类型，但是这取决于具体 实现。 WINDOW WINDOW 表示该函数是一个窗口函数而不是一个普通函数。当前只用于用 C 编写的函数。在替换 一个现有函数定义时，不能更改 WINDOW 属性。 IMMUTABLE | STABLE | VOLATILE 这些属性告知查询优化器该函数的行为。最多只能指定其中一个。如果这些都不出现，则会默 认为 VOLATILE。 IMMUTABLE 表示该函数不能修改数据库并且对于给定的参数值总是会返回相同的值。也就是 说，它不会做数据库查找或者使用没有在其参数列表中直接出现的信息。如果给定合格选项， 任何用全常量参数对该函数的额调用可以立刻用该函数值替换。 STABLE 表示该函数不能修改数据库，并且对于相同的参数值，它在一次表扫描中将返回相同的 结果。但是这种结果在不同的 SQL 语句执行期间可能会变化。对于那些结果依赖于数据库查 找、参数变量（例如当前时区）等的函数来说，这是合适的（对希望查询被当前命令修改的行 的 AFTER 触发器不适合）。还要注意 current_timestamp 函数族适合被标记为稳定，因为它 们的值在一个事务内不会改变。 VOLATILE 表示该函数的值在一次表扫描中都有可能改变，因此不能做优化。在这种意义上，相 对较少的数据库函数是不稳定的，一些例子是 random()、currval()、timeofday()。但是注 意任何有副作用的函数都必须被分类为不稳定的，即便其结果是可以预测的，这是为了调用被 优化掉。一个例子是 setval()。 更多细节可见 函数易变性分类。 529 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 LEAKPROOF LEAKPROOF 表示该函数没有副作用。它不会泄露有关其参数的信息（除了通过返回值）。例 如，一个只对某些参数值抛出错误消息而对另外一些却不抛出错误的函数不是防泄漏的，一 个把参数值包括在任何错误消息中的函数也不是防泄漏的。这会影响系统如何执行在使用 security_barrier 选项创建的视图或者开启了行级安全性的表上执行查询。对于包含有非防 泄漏函数的查询，系统将在验证任何来自查询本身的用户提供条件之前强制验证来自安全策 略或者安全屏障的条件，防止无意中的数据暴露。被标记为防泄漏的函数和操作符被假定是 可信的，并且可以在安全性策略和安全性屏障视图的条件之前被执行。此外，没有参数的函 数或者不从安全屏障视图或表传递任何参数的函数不一定要被标记为防泄漏的。详见 KingbaseES_SQL 语言参考手册中 CREATE VIEW 和规则和权限章节。这个选项只能由超级用户 设置。 CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT CALLED ON NULL INPUT（默认）表示在某些参数为空值时应正常调用该函数。如果有必要，函 数的作者应该负责检查空值并且做出适当的相应。 RETURNS NULL ON NULL INPUT 或 STRICT 表示只要其任意参数为空值，该函数就会返回空值。 如果指定了这个参数，当有空值参数时该函数不会被执行，而是自动返回一个空值结果。 PARALLEL PARALLEL UNSAFE 表示该函数不能在并行模式中运行并且 SQL 语句中存在一个这样的函数会强制使用顺 序执行计划。这是默认选项。PARALLEL RESTRICTED 表示该函数能在并行模式中运行，但是其执行 被限制在并行组的领导者中。PARALLEL SAFE 表示该函数对于在并行模式中运行是安全的并且不受 限制。 如果函数修改任何数据库状态、会使用子事务之类的方式改变事务、访问序列或者对设置（如 setval）做出持久性的更改，它们就应该被标记为并行不安全。如果它们访问临时表、客户端连接 状态、游标、预备语句或者系统无法在并行模式中同步的本地后端状态，它们应该被标为并行受 限。通常，如果一个函数是受限的或者不安全的却被标成了安全，或者它本来是不安全的却被标成 了受限，在并行查询中执行时它可能会抛出错误或者产生错误的答案。如果被错误的标记，C 语 言函数理论上可能展现出完全无法定义的行为，因为系统没有办法保护自己不受任意的 C 代码影 响，但是在大部分情况下其结果也不会比任何其他函数差到哪里去。如果有疑问，函数应该被标为 UNSAFE，这也是默认值。 COST execution_cost 一个给出该函数的估计执行代价的正数，单位是 cpu_operator_cost 。如果该函数返回一个集 合，这就是每个被返回行的代价。如果没有指定代价，对 C 语言和内部函数会指定为 1 个单 位，对其他语言的函数则会指定为 100 单位。更大的值会导致规划器尝试避免对该函数的不必 要的过多计算。 ROWS result_rows 一个正数，它给出规划器期望该函数返回的行数估计。只有当该函数被声明为返回一个集合时 才允许这个参数。默认假设为 1000 行。 530 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 SUPPORT support_function 使用此函数的计划支持函数的名称 (可选模式限定)。见 函数优化的信息。必须是超级用户才能 使用这个选项。 configuration_parameter | value SET 子句导致进入该函数时指定配置参数将被设置为指定值。并且在该函数退出时恢复到该参 数之前的值。SET FROM CURRENT 会把 CREATE FUNCTION 被执行时该参数的当前值保存为进入 该函数时将被应用的值。 如果一个 SET 子句被附加到一个函数，那么在该函数内为同一个变量执行的 SET LOCAL 命令 会被限制于该函数：在函数退出时该配置参数之前的值仍会被恢复。不过，一个普通的 SET 命 令（没有 LOCAL）会覆盖 SET 子句，更像一个之前的 SET LOCAL 命令所做的那样：这种命令 的效果在函数退出后将会持续，除非当前事务被回滚。 definition 一个定义该函数的字符串常量，其含义取决于语言。它可以是一个内部函数名、一个对象文件 的路径、一个 SQL 命令或者用一种过程语言编写的文本。 obj_file, link_symbol 当 C 语言源代码中该函数的名称与 SQL 函数的名称不同时，这种形式的 AS 子句被用于动态 可载入 C 语言函数。字符串 “obj_file“是包含编译好的 C 函数的动态库文件的名称，它会由 LOAD 命令解析。字符串 “link_symbol“是该函数的链接符号，也就是该函数在 C 语言源代码 中的名称。如果省略链接符号，它将被假定为要定义的 SQL 函数的名称。所有函数的 C 名称都 必须不同，因此必须为重载的 C 函数给出不同的 C 名称（例如把参数类型作为 C 名称的一部 分）。 在重复调用引用同一对象文件的 CREATE FUNCTION 时，对每个会话该文件只会被载入一次。要 卸载并且重新装载该文件（可能是在开发期间），需要开始一个新会话。 label_name 一个标签名。 [EXTERNAL] SECURITY INVOKER | [EXTERNAL] SECURITY DEFINER | SECURITY INVOKER 表示要用调用该函数的用户的特权来执行它。这是默认值。SECURITY DEFINER 指定要用创建函 数的用户的特权来执行该函数。 为了符合 SQL，允许使用关键词 EXTERNAL。但是它是可选的，因为与 SQL 中不同，这个特性 适用于所有函数而不仅是那些外部函数。 COMMENT 'String' 添加函数的注释内容，此功能仅限在 MySQL 模式下使用。 重载 KingbaseES 允许函数重载，只要函数之间具有可区分的输入参数类型。在这种情况下，同一个名称就可以被用 于多个不同的函数。 531 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 如果两个函数具有相同的名称和输入参数类型，它们被认为相同（不考虑任何 OUT 参数）。因此这些声明会冲 突： CREATE FUNCTION foo(int) ... CREATE FUNCTION foo(int, out text) ... 具有不同参数类型列表的函数在创建时将不会被认为是冲突的，但是如果默认值被提供，在使用时它们有可能会 冲突。例如，考虑 CREATE FUNCTION foo(int) ... CREATE FUNCTION foo(int, int default 42) ... 调用 foo(10) 将会失败，因为在要决定应该调用哪个函数时会有歧义。 注解 允许把完整的 SQL 类型语法用于声明一个函数的参数和返回值。不过，CREATE FUNCTION 会抛弃带圆括号的类 型修饰符（例如类型 numeric 的精度域）。例如 CREATE FUNCTION foo (varchar(10)) ... 和 CREATE FUNCTION foo (varchar) ... 完全一样。 在用 CREATE OR REPLACE FUNCTION 替换一个现有函数时，对于更改参数名是有限制的。不能更改已经分配给 任何输入参数的名称（不过可以给之前没有名称的参数增加名称）。如果有多于一个输出参数，不能更改输出参数的 名称，因为可能会改变描述函数结果的匿名组合类型的列名。这些限制是为了确保函数被替换时，已有的对该函数的 调用不会停止工作。 如果一个被声明为 STRICT 的函数带有一个 VARIADIC 参数，会严格检查该可变数组作为一个整体是否为非空。 如果该数组有空值元素，该函数仍将被调用。 示例 下列示例可以帮用户了解函数的创建。 例 1：在 PL/SQL 中，使用一个参数名称增加一个整数： \set SQLTERM / CREATE OR REPLACE FUNCTION increment(i integer) RETURNS integer AS BEGIN RETURN i + 1; END; / \set SQLTERM ; call increment(1); 执行结果： increment ----------- 532 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 2 (1 row) 例 2：创建一个返回类型为 REFCURSOR 的用户自定义函数: \set SQLTERM ; CREATE TABLE student(SID INTEGER, SNAME CHAR(30)); INSERT INTO student VALUES(1, 'Tom'); INSERT INTO student VALUES(2, 'Jack'); \set SQLTERM / CREATE OR REPLACE FUNCTION return_type RETURNS REFCURSOR AS DECLARE CURSOR c1 FOR SELECT * FROM student; BEGIN OPEN c1; RETURN c1; END; / \set SQLTERM ; call return_type(); 执行结果： return_type ------------------- (1 row) 例 3：OUT/INOUT 参数的例子: \set SQLTERM @ CREATE OR REPLACE function fout(i in int, j out text, k in out int) returns varchar AS BEGIN j := i || 'fout'; k := k + 1; return 'bar'::varchar; END; @ \set SQLTERM / declare k text; c varchar(12); 533 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 h int := 3; begin c := fout(1, k, h); -- 传入变量 raise notice 'k = %, c = %, h = %', k, c, h; end; / 执行结果： NOTICE: k = 1fout, c = bar, h = 4 例 4：在 MySQL 模式的数据库下，创建一个包含注释的函数： CREATE FUNCTION add_em(x integer, y integer) RETURNS bigint COMMENT 'a function example' AS BEGIN SELECT x + y; END; 编写安全的 SECURITY DEFINER 函数 因为一个 SECURITY DEFINER 函数会被以创建它的用户的特权来执行，需要小心地确保该函数不会被误用。为 了安全，search_path 应该被设置为排除任何不可信用户可写的模式。这可以阻止恶意用户创建对象（例如表、函数 以及操作符）来掩饰该函数所要用到的对象。在这方面特别重要的是临时表模式，默认情况下它会第一个被搜索并且 通常对任何用户都是可写的。可以通过强制最后搜索临时模式来得到一种安全的布局。要这样做，把 sys_temp 写成 search_path 中的最后一项。这个函数展示了安全的用法： \set SQLTERM / CREATE FUNCTION check_password(uname TEXT, pass TEXT) RETURNS BOOLEAN SECURITY DEFINER -- 设置一个安全的 search_path：受信的模式，然后是 'sys_temp'。 SET search_path = admin, sys_temp AS DECLARE passed BOOLEAN; BEGIN SELECT (pwd = $2) INTO passed FROM pwds WHERE username = $1; RETURN passed; END; / \set SQLTERM ; 534 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 这个函数的目的是为了访问表 admin.pwds。但是如果没有 SET 子句或者带有 SET 子句却只提到 admin，该函 数会变成创建一个名为 pwds 的临时表。 在 KingbaseES V7 版本之前，SET 子句不可用，因而较老的函数可能包含相当复杂的逻辑来保存、设置以及恢复 search_path。对于这种目的，SET 子句更容易。 另一点要记住的是默认情况下，会为新创建的函数给 PUBLIC 授予执行特权（详见 权限）。你常常会希望把安 全定义函数的使用限制在某些用户中。要这样做，你必须收回默认的 PUBLIC 特权，然后选择性地授予执行特权。为 了避免出现新函数能被所有人访问的时间窗口，应在一个事务中创建它并且设置特权。例如： BEGIN; CREATE FUNCTION check_password(uname TEXT, pass TEXT) ... SECURITY DEFINER; REVOKE ALL ON FUNCTION check_password(uname TEXT, pass TEXT) FROM PUBLIC; GRANT EXECUTE ON FUNCTION check_password(uname TEXT, pass TEXT) TO admins; COMMIT; 相关话题 在这一章当中： PLSQL ALTER FUNCTION 语句 PLSQL CREATE PROCEDURE 语句 PLSQL DROP FUNCTION 语句 在其他章节： 函数声明与定义 获取有关在 PL/SQL 块中创建函数的信息 形式参数声明 PL/SQL 子程序 在其他书中： 《KingbaseES SQL 语言参考手册》以获取有关 CALL 语句的信息 《KingbaseES 数据库开发指南》了解有关从 SQL 语句调用的用户定义函数的限制的信息 15.7 CREATE PACKAGE 语句 CREATE PACKAGE 定义一个新的包规范。CREATE OR REPLACE PACKAGE 将创建一个新的包规范或者替换一个现有 的包规范。要创建一个包规范，用户必须具有该模式下的 CREATE 权限。包规范中主要涵盖了各种公有资源的声明信 息，它们包括：类型、变量以及子过程的声明和异常声明。子过程的声明只包括子过程的名称、参数信息以及返回值 信息，是不包括子过程的实现的。 语法 535 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 create_package ::= CREATE [ OR REPLACE ] [ EDITIONABLE | NONEDITIONABLE ] PACKAGE plsql_package_source plsql_package_source ::= [ schema. ] package_name [ invoker_rights_clause ] { IS | AS } package_item_list END [ package_name ] ; ( invoker_rights_clause ::= ) package_item_list ::= { type_definition | cursor_declaration | item_declaration | package_function_declaration | package_procedure_declaration } ... 536 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ( type_definition ::= , cursor_declaration ::= , item_declaration ::= ) package_function_declaration ::= function_heading [ deterministic_clause | pipelined_clause | result_cache_clause ] ; ( function_heading ::= , deterministic_clause ::= , pipelined_clause ::= , result_cache_clause ::= ) package_procedure_declaration ::= procedure_heading ; (procedure_heading::=) 语义 create_package OR REPLACE 537 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 如果存在，则重新创建包，并重新编译它。 在重新定义包之前被授予权限的用户仍然可以访问包，而无需重新授予权限。 [ EDITIONABLE | NONEDITIONABLE ] 仅兼容语法。 plsql_package_source schema 包的模式的名称。默认值：当前模式。 package_name 存储在数据库中的包。有关命名约定，请参阅“标识符”。 package_item_list 定义包中的每种类型并声明包中的每个游标和子程序。除了多态表函数外，每个声明都 必须在包体中有相应的定义。相应声明和定义的标题必须逐字匹配，空格除外。包多态 表函数必须在与其实现包相同的包中声明。 package_item_list 的限制 PRAGMA AUTONOMOUS_TRANSACTION 不能出现在这里。 示例 例 1：创建一个包规范 \set SQLTERM / CREATE OR REPLACE PACKAGE pac AUTHID DEFINER AS i INT; j float NOT NULL DEFAULT 200; pi CONSTANT float := 3.14159265; cur CURSOR FOR SELECT 100; CURSOR cur2 (a INT) FOR SELECT 2; cur3 CURSOR (b INT) FOR SELECT 3; refcur REFCURSOR; FUNCTION f(i INT) RETURNS INT; FUNCTION f2(j OUT INT) RETURNS INT; PROCEDURE p(i float); PROCEDURE p2(i INT, j INT); END pac; / \set SQLTERM ; 参见 ALTER PACKAGE 语句 , CREATE PACKAGE BODY 语句 , DROP PACKAGE 语句 , DROP PACKAGE BODY 语句 538 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 15.8 CREATE PACKAGE BODY 语句 CREATE PACKAGE BODY 定义一个新的包体。CREATE OR REPLACE PACKAGE BODY 将创建一个新的包体或者替换一 个现有的包体。 要定义一个包体，用户必须具有该模式下的 CREATE 权限。 当数据库管理员不是包规范的属主时，也可以创建包体，这时包体的属主仍与包规范为同一属主。 如果包规范中定义了子程序，那么这个包必须有包体，否则这个包可以没有包体。包规范和包体必须在同一模式 下。包体中的子程序的定义必须与包规范中的声明一致。 包体主要有两个作用： a. 用于提供对包规范中子程序的定义； b. 允许为包编写特定的初始化代码（类似面向对象中对象的构造函数）。 语法 create_package_body ::= CREATE [ OR REPLACE ] [ EDITIONABLE | NONEDITIONABLE ] PACKAGE BODY plsql_package_body_source plsql_package_body_source ::= [ schema. ] package { IS | AS } declare_section [ initialize_section ] END [ package_name ] ; (declare_section ::=) 539 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 initialize_section ::= BEGIN statement... [ EXCEPTION exception_handler... ] ( statement ::= , exception_handler ::= ) 语义 create_package_body OR REPLACE 如果存在，则重新创建包主体，并重新编译它。 在重新定义包主体之前被授予权限的用户仍然可以访问包，而无需重新授予权限。 [ EDITIONABLE | NONEDITIONABLE ] 仅实现语法。 plsql_package_body_source schema 包的模式的名称。默认值：当前模式。 package_name 要创建的包的名称。 declare_section 对包规范中的每个游标和子程序声明都有一个定义。相应子程序声明和定义的标题必须 逐字匹配，空格除外。 还可以声明和定义只能从包内部引用的私有项。 对 declare_section 的限制 PRAGMA AUTONOMOUS_TRANSACTION 不能出现在这里。 initialize_section 初始化变量并执行任何其他一次性设置步骤。 示例 例 1：包体不包含初始化函数 540 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 \set SQLTERM / CREATE OR REPLACE PACKAGE pac AS i INT := 100; FUNCTION f() RETURNS INT; END; / CREATE OR REPLACE PACKAGE BODY pac AS FUNCTION f() RETURNS INT AS BEGIN RETURN pac.i; END; END; / \set SQLTERM ; 例 2：包体包含初始化函数 \set SQLTERM / CREATE OR REPLACE PACKAGE pac AS i INT := 100; FUNCTION f() RETURNS INT; END; / CREATE OR REPLACE PACKAGE BODY pac AS FUNCTION f() RETURNS INT AS BEGIN RETURN pac.i; END; BEGIN pac.i := pac.i * 100; END pac; / \set SQLTERM ; 相关话题 在这一章当中： ALTER PACKAGE 语句 CREATE PACKAGE 语句 DROP PACKAGE 语句 DROP PACKAGE BODY 语句 541 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 在其他章节： 包 包体 函数声明与定义 过程声明与定义 15.9 CREATE PROCEDURE 语句 CREATE PROCEDURE 语句创建一个新的过程。 独立过程是存储在数据库中的过程（执行特定操作的子程序）。 CREATE OR REPLACE PROCEDURE 将会创建一个新过程或者替换一个已有的定义。为了能够定义过程，用户必须 具有所使用的语言上的 USAGE 特权。 如果这个命令中包括了一个模式名称，则该过程将被创建在该模式中。否则过程将被创建在当前的模式中。新过 程的名称不能和同一模式中具有相同输入参数类型的任何现有过程或函数同名。不过，具有不同参数类型的过程和函 数可以同名（这被称为重载）。 要 替 换 一 个 已 有 过 程 的 当 前 定 义， 请 使 用 CREATE OR REPLACE PROCEDURE。 如 果 用 CREATE OR REPLACE PROCEDURE 更改过程的名称或者参数类型，实际上会创建一个新的、不同的过程。 当 CREATE OR REPLACE PROCEDURE 被用来替换一个现有的过程时，该过程的拥有关系和权限保持不变。所有其 他的过程属性会被赋予这个命令中指定的或者隐含的值。必须拥有（包括成为拥有它的角色）该过程才能替换它。 创建过程的用户将成为该过程的拥有者。 为了能够创建一个过程，用户必须具有参数类型上的 USAGE 特权。 语法 第一种 PLSQL 语法： create_procedure ::= CREATE [ OR REPLACE ] [ EDITIONABLE | NONEDITIONABLE ] PROCEDURE plsql_procedure_source 542 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 plsql_procedure_source ::= [ schema. ] procedure_name [ ( parameter_declaration [, parameter_declaration ]... ) ] [ invoker_rights_clause ] [ COMMENT 'String' ] { IS | AS } { [ declare_section ] body } ; ( parameter_declaration ::= , invoker_rights_clause ::= , declare_section ::= , body ::= ) 第二种 PLPGSQL 语法： CREATE [ OR REPLACE ] PROCEDURE ProcedureName ([ [, ...n]]) [ COMMENT 'String' ] { LANGUAGE lang_name | TRANSFORM { FOR TYPE type_name } [, ... ] | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER | SET configuration_parameter { TO value | = value | FROM CURRENT } | AS 'definition' | AS 'obj_file', 'link_symbol' } ... 语义 第一种语法的语义： create_procedure OR REPLACE 如果存在，则重新创建该过程，并重新编译它。 在重新定义过程之前被授予权限的用户仍然可以访问该过程而无需重新授予权限。 [ EDITIONABLE | NONEDITIONABLE ] 仅实现语法。 plsql_procedure_source 543 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 schema 过程的模式的名称。默认值：当前模式。 procedure_name 要创建的过程的名称。 body 过程所需的可执行部分，以及（可选）过程的异常处理部分。 declare_section 过程的可选声明部分。声明是过程本地的，可以在主体中引用，并且在过程完成执行时 不再存在。 COMMENT 'String' 添加存储过程的注释内容，此功能仅限在 MySQL 模式下使用。 第二种语法的语义： ProcedureName 存储过程名称, 可加模式名。 [EXTERNAL] SECURITY INVOKER | [EXTERNAL] SECURITY DEFINER SECURITY INVOKER 表示要用调用该函数的用户的特权来执行它，这是默认值。SECURITY DEFINER 指定要用创建函数的用户的特权来执行该函数。 为了符合 SQL，允许使用关键词 EXTERNAL。但是它是可选的，因为与 SQL 中不同，这个特性 适用于所有函数而不仅是那些外部函数。 lang_name 用于实现该过程的语言名称。它可以是 sql、c、internal 或者一种用户定义的过程语言的名 称，例如 plsql 或 plpgsql。将名称包裹在单引号内的方式已经被废弃，并且要求大小写匹 配。 TRANSFORM { FOR TYPE type_name } [, ... ] } 列出对过程的调用应该应用哪些 Transform。Transform 负责在 SQL 类型和语言相关的数据类 型之间进行转换。过程语言实现通常采用硬编码的方式保存内建类型的知识，因此它们无需在 这里列出。但如果一种过程语言实现不知道如何处理一种类型并且没有提供 Transform，它将 回退到默认的行为来转换数据类型，但是这依赖于其实现。 configuration_parameter | value SET 子句导致在进入该过程时指定的配置参数被设置为指定的值，并且在过程退出时恢复到之 前的值。SET FROM CURRENT 把 CREATE PROCEDURE 执行时该参数的当前值保存为在进入该过程 时要应用的值。 如果对过程附加一个 SET 子句，那么在该过程中为同一个变量执行的 SET LOCAL 命令的效 果就被限制于该过程：在过程退出时还是会恢复到该配置参数的以前的值。不过，一个普通的 544 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 SET 命令（没有 LOCAL）会重载这个 SET 子句，很像它对一个之前的 SET LOCAL 命令所做的 事情：这样一个命令的效果将持续到过程退出之后，除非当前事务被回滚。 如 果 对 过 程 附 加 一 个 SET 子 句， 则 该 过 程 不 能 执 行 事 务 控 制 语 句 （例 如 COMMIT 和 ROLLBACK，具体取决于实现的语言）。 有关允许的参数名和值的更多信息请参考 KingbaseES 数据库参考手册。 definition 一个定义该过程的字符串常量，其含义取决于语言。它可以是一个内部的过程名、一个对象文 件的路径、一个 SQL 命令或者以一种过程语言编写的文本。 obj_file, link_symbol 当 C 语言源码中的过程名与 SQL 过程的名称不同时，这种形式的 AS 子句被用于动态可装载的 C 语言过程。字符串 “obj_file“是包含已编译好的 C 过程的共享库文件名，并且被按照 LOAD 命令的方式解析。字符串 “link_symbol“是该过程的链接符号，也就是该过程在 C 语言源代码 中的名称。如果链接符号被省略，则会被假定为与正在被定义的 SQL 过程的名称相同。 当重复的 CREATE PROCEDURE 调用引用同一个对象文件时，只会对每一个会话装载该文件一 次。要卸载或者重新载入该文件（可能是在开发期间），应该开始一个新的会话。 ParameterList 语法格式： ::= {[IN | OUT | INOUT] ParameterName [ { DEFAULT | := } ] } [, ...n] 功能： 定义存储过程的参数。 使用说明： a. IN，OUT，INOUT 参数模式，定义了形式参数的行为。用法与不指定 LANGAGUE 时创 建的CREATE FUNCTION 语句 一致。 b. ParameterName，表示一个形式参数，该参数在存储过程中被声明，并且可以在该存储过 程体中被引用。 c. DataType，形式参数的数据类型。可以使用的数据类型请参考”SQL 参考手册” 的” 数据类 型” 部分的内容。 d. DEFAULT 关键字或“:=”用来指示存储过程参数的默认值， 是一个合法的 表达式。跟在有默认值的参数后面的输入参数也都必须有默认值。 e. VariableDeclaration，声明变量和常量。其中变量名不允许和存储过程体中的结果集或表中 的列名重名。参照如下示例。 545 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 f. 存储过程没有“RETURNS”子句，在存储过程体中可以使用“RETURN”语句，SQL 标 准规定存储过程没有返回值，KingbaseES 的存储过程即返回一个空值（VOID）。 COMMENT 'String' 添加存储过程的注释内容，此功能仅限在 MySQL 模式下使用。 示例 例 1 简单存储过程示例： \set SQLTERM / CREATE OR REPLACE PROCEDURE increment1(i INTEGER) AS BEGIN RAISE NOTICE '%', i; END; / \set SQLTERM ; call increment1(2); 执行结果： NOTICE: 2 例 2 带有 OUT 参数的存储过程示例： \set SQLTERM / CREATE OR REPLACE PROCEDURE increment2(i IN INTEGER, result OUT INTEGER) AS BEGIN result := i + 2; END; / declare a1 int := 10; a2 int; begin increment2(a1, a2); raise notice '%', a2; end; / 执行结果： NOTICE: 12 例 3 参数带有默认值的存储过程示例： 546 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 \set SQLTERM / CREATE OR REPLACE PROCEDURE increment2(OUT result INTEGER, IN i INTEGER:=1) AS BEGIN result := i + 2; END; / declare a1 int; begin increment2(a1); raise notice '%', a1; end; / 执行结果： NOTICE: 3 例 4 包含注释的存储过程示例： \set SQLTERM / CREATE OR REPLACE PROCEDURE increment2(IN i INTEGER, OUT result INTEGER) COMMENT 'a procedure' AS BEGIN result := i + 2; END; / \set SQLTERM ; 相关话题 在这一章当中： ALTER PROCEDURE 语句 语句 DROP PROCEDURE 语句 语句 在其他章节： 形式参数声明 过程声明与定义 PL/SQL 子程序 在其他书中： 《KingbaseES SQL 语言参考手册》以获取有关 CALL 语句信息 547 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 《KingbaseES 数据库开发指南》了解有关调用规范的更多信息 《KingbaseES 数据库开发指南》了解有关调用存储的 PL/SQL 子程序的更多信息 15.10 CREATE TRIGGER 语句 CREATE TRIGGER 创建一个新触发器。该触发器将被关联到指定的表或视图并且在表上发生特定操作时将执行指 定的函数 “function_name“或匿名 PL/SQL 块。 语法 第一种 PLSQL 语法： create_trigger ::= CREATE [ OR REPLACE ] [ EDITIONABLE | NONEDITIONABLE ] TRIGGER plsql_trigger_source plsql_trigger_source ::= [ schema. ]trigger_name { simple_dml_trigger | instead_of_dml_trigger } ( simple_dml_trigger ::= , instead_of_dml_trigger ::= ) simple_dml_trigger ::= { BEFORE | AFTER } dml_event_clause [ referencing_clause ] [ FOR EACH ROW ] [ WHEN ( condition ) ] trigger_body 548 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ( dml_event_clause ::= , referencing_clause ::= , trigger_body ::= ) instead_of_dml_trigger ::= INSTEAD OF { DELETE | INSERT | UPDATE } [ OR { DELETE | INSERT | UPDATE } ]... ON [ schema. ] noneditioning_view [ referencing_clause ] [ FOR EACH ROW ] trigger_body ( referencing_clause ::= , trigger_body ::= ) dml_event_clause ::= { DELETE | INSERT | UPDATE [ OF column [, column ]... ] } [ OR { DELETE | INSERT | UPDATE [ OF column [, column]... ] }... ON [ schema.] { table | view } 549 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 referencing_clause ::= REFERENCING { OLD [ AS ] old | NEW [ AS ] new }.. trigger_body ::= { plsql_block | CALL routine_clause } routine_clause ::= [ schema. ] [ type. ] { procedure | method } ( ) ( plsql_block ::= ) 550 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 第二种 PLPGSQL 语法： CREATE [ CONSTRAINT ] TRIGGER [ schema. ] name { BEFORE | AFTER | INSTEAD OF } { event [ OR ... ] } ON table_name [ FROM referenced_table_name ] [ NOT DEFERRABLE | [ DEFERRABLE ] [ INITIALLY IMMEDIATE | INITIALLY DEFERRED ] ] [ REFERENCING { { OLD | NEW } TABLE [ AS ] transition_relation_name } [ ... ] ] [ FOR [ EACH ] { ROW | STATEMENT } ] [ WHEN ( condition ) ] EXECUTE { FUNCTION | PROCEDURE } function_name ( arguments ) 这里的 event 可以是下列之一： INSERT UPDATE [ OF column_name [, ... ] ] DELETE TRUNCATE 语义 第一种语法的语义： create_trigger OR REPLACE 如果存在，则重新创建触发器，并重新编译它。 在重新定义触发器之前被授予权限的用户仍然可以访问该过程，而无需重新授予权限。 [ EDITIONABLE | NONEDITIONABLE ] 仅兼容语法。 plsql_trigger_source schema 指定模式名，仅语法兼容。 trigger 要创建的触发器的名称。 simple_dml_trigger 创建一个简单的 DML 触发器（在“DML 触发器”中描述）。 BEFORE 使数据库在运行触发事件之前触发触发器。对于行触发器，触发器会在每个受影响的行 发生更改之前触发。 551 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 BEFORE 的限制 不能在视图上指定 BEFORE 触发器，除非它是一个编辑视图。 在 BEFORE 语句触发器中，触发器主体不能读取:NEW 或:OLD。（在 BEFORE 行触发器 中，触发器主体可以读写:OLD 和:NEW 字段。） AFTER 使数据库在运行触发事件后触发触发器。对于行触发器，触发器会在每个受影响的行发 生更改后触发。 对 AFTER 的限制 不能在视图上指定 AFTER 触发器，除非它是一个编辑视图。 在 AFTER 语句触发器中，触发器主体不能读取:NEW 或:OLD。（在 AFTER 行触发器 中，触发器主体可以读取但不能写入:OLD 和:NEW 字段。） FOR EACH ROW 将触发器创建为行触发器。 数据库为受触发语句影响并满足 WHEN 条件中定义的可选触发器约束的每一行触发一个 行触发器。 如果省略此子句，则触发器是语句触发器。只有在满足可选触发器约束的情况下发出触 发语句时，数据库才会触发语句级触发器。 WHEN (condition) 指定数据库为触发语句影响的每一行计算的 SQL 条件。如果针对受影响的行， condition 的值是 TRUE，则 trigger_body 针对该行运行；否则，trigger_body 不 会针对该行运行。无论 condition 的值如何，触发语句都会运行。 condition 可以包含相关名称（请参阅 referencing_clause ::= ）。 在 condition 下，最好不要在相关名称 NEW、OLD 之前放置冒号 (:)（在此上下文 中，它不是绑定变量的占位符）。 另请参阅: 《KingbaseES 数据库 SQL 语言参考手册》，了解有关 SQL condition 的内容。 WHEN（条件）的限制 如果指定此子句，那么还必须指定 FOR EACH ROW 。 condition 不能包含子查询或 PL/SQL 表达式（例如，用户定义函数的调用）。 trigger_body 数据库运行可以触发触发器的 PL/SQL 块或 CALL 子程序。CALL 子程序是不带参数 的 PL/SQL 存储过程。 instead_of_dml_trigger 552 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 创建一个 INSTEAD OF DML 触发器（在INSTEAD OF DML 触发器 中描述）。 对 INSTEAD OF 的限制 INSTEAD OF 触发器可以读取:OLD 和:NEW 值，但不能更改它们。 DELETE 如果触发器是在非编辑视图上创建的，那么只要 DELETE 语句从定义了非编辑视图的表 中删除一行，DELETE 就会导致数据库触发触发器。 INSERT 如果触发器是在非编辑视图上创建的，那么只要 INSERT 语句将行添加到定义非编辑视 图的表中，INSERT 就会使数据库触发触发器。 UPDATE 如果触发器是在非编辑视图上创建的，那么只要 UPDATE 语句更改定义了非编辑视图的 表的列中的值，UPDATE 就会导致数据库触发触发器。 另请参阅: 《KingbaseES SQL 语言参考手册》中 CREATE VIEW 的 AS 子查询子句，用于防止 对视图进行插入、更新或删除的构造列表。 noneditioning_view noneditioning_view 是要在其上创建触发器的非编辑视图的名称。 FOR EACH ROW INSTEAD OF 触发器始终是行触发器，因此仅用于标识。 trigger_body 数据库运行以触发触发器的 PL/SQL 块或 CALL 子程序。CALL 子程序是不带参数的 PL/SQL 存储过程。 dml_event_clause 指定 simple_dml_trigger 的触发语句。数据库在现有用户事务中触发触发器。 DELETE 每当 DELETE 语句从表或定义视图的表中删除一行时，使数据库触发触发器。 INSERT 每当 INSERT 语句将行添加到表或定义视图的表时，使数据库触发触发器。 UPDATE [ OF column [, column ] ] 每当 UPDATE 语句更改指定列中的值时，使数据库触发触发器。默认值：只要 UPDATE 语句更改表的任何列或定义视图的表中的值，数据库就会触发触发器。 如果指定列，则不能在触发器主体中更改其值。 553 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 schema 包含要在其上创建触发器的数据库对象的模式的名称。默认值：当前模式。 table 要在其上创建触发器的表的名称。 view 要在其上创建触发器的视图的名称。 referencing_clause 指定相关名称，它引用当前行的旧值、新值。默认值：OLD、NEW。 如果触发器与名为 OLD、NEW 的表相关联，则使用此子句指定不同的相关名称以避免表名称 和相关名称之间的混淆。 对 reference_clause 的限制 如果 trigger_body 是 call routine_clause ，则引用子句无效。 routine_clause 触发器引用的程序为不带参数的存储过程或不带参数的 object type static 方法。 schema 指定模式名。 type 指定 object type 类型名。 procedure 指定不带参数的存储过程名。 method 指定不带参数的 object type static 方法。 第二种语法的语义： name 给新触发器的名称。这必须与同一个表上的任何其他触发器不同。 BEFORE | AFTER | INSTEAD OF 决定触发器函数是要在事件之前、之后被调用还是会取代该事件。一个约束触发器也能被指定 为 AFTER。 event INSERT、UPDATE、DELETE 或者 TRUNCATE 之一，这指定了将要引发该触发器的事件。多个事件 可以用 OR 指定，要求转换表的时候除外。 554 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 对于 UPDATE 事件，可以使用下面的语法指定一个列的列表： UPDATE OF column_name1 [, column_name2 ... ] 只有当至少一个被指定的列出现在 UPDATE 命令的更新目标中时，该触发器才会触发；或者， 指定的列之一是生成的列，该列依赖于 UPDATE 的目标列。 INSTEAD OF UPDATE 事件不允许列的列表。在请求转换表时，也不能指定列的列表。 schema 指定模式名，仅语法兼容。 table_name 要使用该触发器的表、视图或外部表的名称（可能被模式限定）。 referenced_table_name 约束引用的另一个表的（可能是模式限定的）名称。此选项用于外键约束，不推荐用于一般用 途。这只能为约束触发器指定。 DEFERRABLE | NOT DEFERRABLE | INITIALLY IMMEDIATE | INITIALLY DEFERRED 该触发器的默认时机。这些约束选项的细节可参考 PLSQL CREATE TABLE 文档。这只能为 约束触发器指定。 REFERENCING 该关键字紧接在声明一个或者两个关系名称之前，这些关系名称提供对触发语句的转换表的访 问。 OLD TABLE | NEW TABLE 这个子句指示接下来的关系名是用于前转换表还是后转换表。 transition_relation_name 在该触发器中这个转换表要使用的（未限定）名称。 FOR EACH ROW | FOR EACH STATEMENT 这指定是否应该为受触发事件影响的每一行触发一次触发函数，或者每个 SQL 语句只触发 一次。如果两者都没有被指定，则 FOR EACH STATEMENT 是默认值。约束触发器只能指定 FOR EACH ROW。 condition 一个决定该触发器函数是否将被实际执行的布尔表达式。如果指定了 WHEN，只有 condition 返回 true 时才会调用该函数。在 FOR EACH ROW 触发器中，WHEN 条件可以分别写 OLD. column_name 或者 NEW.column_name 来引用列的新旧行值。当然，INSERT 触发器不能引用 OLD 并且 DELETE 触发器不能引用 NEW。 INSTEAD OF 触发器不支持 WHEN 条件。 555 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 当前，WHEN 表达式不能包含子查询。 注意对于约束触发器，对于 WHEN 条件的计算不会被延迟，而是直接在行更新操作被执行之后 立刻发生。如果该条件计算得不到真，那么该触发器就不会被放在延迟执行的队列中。 function_name 一个用户提供的函数，它被声明为不用参数并且返回类型 trigger，当触发器引发时会执行该 函数。 一个用户提供的无参数存储过程。 在 CREATE TRIGGER 的语法中，关键词 FUNCTION 和 PROCEDURE 是等效的，这里，关键词 PROCEDURE 的使用是有历史原因的并且已经被废弃。 arguments 一个可选的逗号分隔的参数列表，它在该触发器被执行时会被提供给该函数。参数是字符串常 量。简单的名称和数字常量也可以被写在这里，但是它们将全部被转换成字符串。请检查该触 发器函数的实现语言的描述来找出在函数内部如何访问这些参数，这可能与普通函数参数不 同。 示例 DML 触发器 示例 10-1 ，“触发器使用条件谓词检测触发语句” 示例 10-2 ，“INSTEAD OF 触发器” 确保参考完整性的触发器 示例 10-3 ，“子表的外键触发器” 示例 10-4 ，“父表的 UPDATE 和 DELETE RESTRICT 触发器” 示例 10-5 ，“父表的 UPDATE 和 DELETE SET NULL 触发器” 示例 10-6 ，“父表的 DELETE CASCADE 触发器” 示例 10-7 ，“父表的更新 CASCADE 触发器” 示例 10-8 ，“触发器检查复杂约束” 示例 10-9 ，“触发器强制执行安全授权” 示例 10-10 ，“触发器派生新列值” 使用关联名称和伪记录的触发器 示例 10-11 ，“触发器记录对 stu_score.score 的更改” 示例 10-12 ，“条件触发器打印得分变化信息” 示例 10-13 ，“触发器修改 CLOB 列” 示例 10-14 ，“带有 REFERENCING 子句的触发器” 556 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 兼容性 SQL 指定多个触发器应该以被创建时间的顺序触发。KingbaseES 则使用名称顺序，这被认为更加方便。 SQL 指定级联删除上的 BEFORE DELETE 触发器在级联的 DELETE 完成之后引发。KingbaseES 的行为则是 BEFORE DELETE 总是在删除动作之前引发，即使是一个级联删除。这被认为更加一致。如果 BEFORE 触发器修改行或 者在引用动作引起的更新期间阻止更新，这也是非标准行为。这能导致约束违背或者被存储的数据不遵从引用约束。 使用 OR 为一个单一触发器指定多个动作的能力是 SQL 标准的一个 KingbaseES 扩展。 为 TRUNCATE 引发触发器的能力是 SQL 标准的一个 KingbaseES 扩展，在视图上定义语句级触发器的能力也是 一样。 CREATE CONSTRAINT TRIGGER 是 SQL 标准的一个 KingbaseES 扩展。 相关话题 在这一章当中： ALTER TRIGGER 语句 DROP TRIGGER 语句 在其他章节： 触发器 15.11 CREATE TYPE 语句 CREATE TYPE 在当前数据库中注册一种新的数据类型。定义数据类型的用户将成为它的拥有者。 该 CREATE TYPE 语句指定类型的名称及其属性、方法和其他属性。 该 CREATE TYPE 语句创建或替换其中之一的规范： • 抽象数据类型 (ADT) • 独立可变数组（varray）类型 • 独立嵌套表类型 • 不完整的对象类型 不完整类型是由前向类型定义创建的类型。它被称为不完整的，因为它有名称但没有属性或方法。它可以被其 他类型引用，允许定义相互引用的类型。但是，必须先完全指定类型，然后才能使用它来创建表或对象列或嵌 套表类型的列。 CREATE TYPE BODY 语句 包含实现该类型的方法的代码。 注意: • 如果创建的类型的规范仅声明属性但没有方法，则无需指定类型主体。 557 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 • 使用 CREATE TYPE 语句创建的独立集合类型不同于在 PL/SQL 块或包中使用关键字 TYPE 定义的集合类 型。有关后者的信息，请参阅集合变量声明 。 • 使用该 CREATE TYPE 语句，可以创建嵌套表和 VARRAY 类型，但不能创建关联数组。在 PL/SQL 块或包 中，可以定义所有三种集合类型。 创建类型具有以下先决条件： • 要在模式中创建类型，必须具有 CREATE TYPE 系统权限。 • 要在其他用户的模式中创建类型，必须具有 CREATE ANY TYPE 系统权限。可以显式获取这些权限，也可以 通过角色授予这些权限。 • 类型的所有者必须被显式授予 EXECUTE 对象特权才能访问类型定义中引用的所有其他类型，或者必须授予类 型所有者 EXECUTE ANY TYPE 系统特权。所有者无法通过角色获得这些权限。 • 如果类型所有者打算授予其他用户对该类型的访问权限，则必须使用 GRANT OPTION 授予所有者对所引用类 型的 EXECUTE 对象特权或使用 ADMIN OPTION 授予 EXECUTE ANY TYPE 系统特权。否则，类型所有 者没有足够的权限将对该类型的访问权限授予其他用户。 语法 create_type ::= CREATE [OR REPLACE] [ EDITIONABLE | NONEDITIONABLE ] TYPE plsql_type_source plsql_type_source ::= [ schema. ] type_name [ FORCE ] [ invoker_rights_clause ] { object_base_type_def } ; ( invoker_rights_clause ::= , object_base_type_def ::= ) object_base_type_def ::= { IS | AS } { object_type_def | varray_type_spec | nested_table_type_spec } 558 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ( object_type_def ::= , varray_type_spec ::= , nested_table_type_spec ::= ) object_type_def ::= OBJECT ( { attribute datatype [,] } [ { , element_spec } ] ) [ [NOT] { FINAL | INSTANTIABLE } ]... ( datatype ::= , element_spec ::= ) varray_type_spec ::= { VARRAY | [ VARYING ] ARRAY } ( size_limit ) OF datatype [ NOT NULL ] ( datatype ::= ) nested_table_type_spec ::= TABLE OF datatype [ NOT NULL ] ( datatype ::= ) 语义 create_type 559 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 OR REPLACE 如果存在，则重新创建该类型，并重新编译它。 在重新定义之前被授予该类型权限的用户仍然可以访问该类型，而无需重新授予权限。 plsql_type_source schema 包含该类型模式的名称。默认值：当前模式。 type_name ADT、嵌套表类型或 VARRAY 类型的名称。 数据库为您创建的每个用户定义类型隐式定义了一个构造方法。构造函数是系统提供的 过程，用于在 SQL 语句或 PL/SQL 代码中构造类型值的实例。构造方法的名称是用户 定义类型的名称。还可以使用 constructor_spec 语法创建用户定义的构造函数。 ADT 构造方法的参数是 ADT 的数据属性。它们的出现顺序与 ADT 的属性定义顺序 相同。嵌套表或可变数组构造函数的参数是嵌套表或可变数组的元素。 FORCE FORCE 作为一个与 OR REPLACE 配合使用的选项参数，当使用 CREATE OR REPLACE TYPE 语句创建一个对象类型替换一个已有类型时，FORCE 选项可以决定如何处理被替 换类型的依赖关系。 含有 FORCE 选项的替换创建语句 (CREATE OR REPLACE TYPE) 会级联删除所有对原类 型有依赖的对象，并成功创建新的对象类型。不含有 FORCE 选项的替换创建语句则会 在检测到原有类型处于被依赖状态时进行提示并阻止新类型成功创建。 只有对象类型的创建语句支持 FORCE 选项，由于 FORCE 选项会级联删除所有依赖对 象，请谨慎使用。 注意: 如果 type t1 有依赖 type t2，并且 typet2 有依赖表，那么 type t1 也有依赖表。 object_base_type_def 创建模式级 ADT。 IS | AS 创建 ADT 时需要关键字 IS 或 AS。 attribute ADT 属性的名称。ADT 属性是具有名称和类型说明符的数据项，它构成了 ADT 的结 构。必须为每个 ADT 指定至少一个属性。该名称在 ADT 中必须是唯一的，但可以在 其他 ADT 中使用。 datatype 560 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ADT 属性的数据类型。该数据类型必须存储在数据库中；即预定义的数据类型 或用户定义的独立集合类型。 datatype 限制 不能对 NOT NULL 属性施加约束。 object_type_def 创建一个 ADT。构成数据结构的变量称为属性。定义 ADT 行为的成员子程序称为方法。 OBJECT 关键字。 [NOT] FINAL [NOT] INSTANTIABLE [NOT] FINAL FINAL 子句决定是否可以以此类型为基类型创建其他子类型。目前仅兼容语 法。 [NOT] INSTANTIABLE INSTANTIABLE 子句决定是否可以为此类型构造实例对象。目前仅兼容语 法。 varray_type_spec 将类型创建为一组有序的元素，每个元素都具有相同的数据类型。 nested_table_type_spec 创建类型为 datatype 的命名嵌套表。 示例 创建一个 INT 类型的嵌套表，并且元素的值不能 NULL： CREATE TYPE int_table AS TABLE OF INT NOT NULL; 创建一个最大长度为 10 的 INT 类型的可变数组： CREATE TYPE int_varray AS VARRAY(10) OF INT; 创建一个对象类型声明： CREATE OR REPLACE TYPE objtype FORCE AUTHID CURRENT_USER AS OBJECT( f1 INT, f2 TEXT, MEMBER FUNCTION memfunc(i INT) RETURN INT, STATIC PROCEDURE staproc(), CONSTRUCTOR FUNCTION objtype(self inout objtype) RETURN SELF AS RESULT ); 561 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 相关话题 ALTER TYPE 语句 CREATE TYPE BODY 语句 DROP TYPE 语句 抽象数据类型 集合变量声明 PL/SQL 数据类型 15.12 CREATE TYPE BODY 语句 CREATE TYPE BODY 定义 CREATE TYPE 语句创建的类型规范中的成员方法。 创建类型体具有以下先决条件： • ADT 的 CREATE TYPE 规范中的每个成员声明都必须在 CREATE TYPE 或 CREATE TYPE BODY 语句中 具有相应的定义。 • 要在模式中创建或替换类型主体，必须具有 CREATE TYPE 或 CREATE ANY TYPE 系统权限。 • 要在其他用户的模式中创建类型，必须具有 CREATE ANY TYPE 系统权限。 • 要替换另一个用户模式中的类型，必须具有 DROP ANY TYPE 系统特权。 语法 create_type_body ::= CREATE [ OR REPLACE ] TYPE BODY plsql_type_body_source plsql_type_body_source ::= [ schema. ] type_name { IS | AS } subprog_decl_in_type [, { subprog_decl_in_type } ]... END; 562 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ( subprog_decl_in_type ::= ) subprog_decl_in_type ::= { [ MEMBER | STATIC ] proc_decl_in_type | [ MEMBER | STATIC ] func_decl_in_type | constructor_declaration } ( proc_decl_in_type ::= , func_decl_in_type ::= ) proc_decl_in_type ::= PROCEDURE name [ ( parameter_declaration [, parameter_declaration ]... ) ] [ invoker_rights_clause ] { IS | AS } { [ declare_section ] body } 563 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ( parameter_declaration ::= , declare_section ::= , body ::= , invoker_rights_clause ::= ) func_decl_in_type ::= FUNCTION name [ ( parameter_declaration [, parameter_declaration ]... ) ] RETURN datatype [ invoker_rights_clause ] [ PIPELINED ] { IS | AS } { [ declare_section ] body } ( parameter_declaration ::= , declare_section ::= , body ::= , invoker_rights_clause ::= , pipelined_clause ::= ) constructor_declaration ::= CONSTRUCTOR FUNCTION datatype [ [ SELF IN OUT datatype, ] parameter datatype [, parameter datatype ]... ] RETURN SELF AS RESULT { IS | AS } { [ declare_section ] body } ( datatype ::= , declare_section ::= , body ::= ) 语义 create_type_body 564 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 OR REPLACE 如果存在，则重新创建类型主体，并重新编译它。 在重新定义类型主体之前被授予权限的用户仍然可以访问类型主体而无需重新授予权 限。 plsql_type_body_source schema 包含类型主体的模式的名称。默认值：当前模式。 type_name ADT 的名称。 subprog_decl_in_type 与类型规范相关的函数或过程子程序的类型。 必须在类型规范中为每个过程或函数声明定义相应的方法名称和可选参数列表。对于函 数，还必须指定返回类型。 proc_decl_in_type 过程子程序声明。 STATIC 对象类型内部函数（存储过程）的类型为 STATIC 。 MEMBER 对象类型内部函数（存储过程）的类型为 MEMBER 。 constructor_declaration 用户定义的构造函数子程序声明。构造函数的 RETURN 子句必须是 RETURN SELF AS RESULT。此设置指示构造函数返回值的特定类型是传递给构造函数的 SELF 参数的特定类型。 declare_section 声明过程或函数的本地项。 body 过程或函数语句。 func_decl_in_type 函数子程序声明。 注意: • 静 态 函 数 （存 储 过 程） 不 能 创 建 含 有 名 为 SELF 的 参 数， 在 调 用 时 需 要 以 类 型 名 做 前 缀 修 饰， 如 type_name.method()。 565 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 • 成员函数（存储过程）的第一个参数必须是名为 SELF 且类型为当前对象类型的参数，若未显式创建 SELF 参 数，那么该参数会被隐式创建为 IN 参数。在调用成员函数（存储过程）时需要以类型定义的具体对象名做前 缀修饰，如 object_expression.method()。且不需要为 SELF 参数传值，成员函数（存储过程）会自动接收对其 进行修饰的对象作为 SELF 参数传入。 • 成员函数（存储过程）的 SELF 参数可以是 IN 参数或者 IN OUT 参数。 • 一个对象类型可以创建多个构造函数，所有构造函数都必须与类型同名。与成员方法一样，自定义构造函数的 第一个参数必须是 SELF 参数，若 SELF 参数未被显式创建，也会被隐式创建。 • 不同于成员方法的是，自定义构造函数的 SELF 参数只能是 IN OUT 参数。 • 不同于普通函数，自定义构造函数的 RETURN 子句不能带有任何表达式，构造函数总会自动把 SELF 参数作为 返回值进行返回。 示例 创建一个完整的对象类型： CREATE OR REPLACE TYPE objtype FORCE AUTHID CURRENT_USER AS OBJECT( f1 int, f2 varchar2(10), MEMBER FUNCTION memfunc(i int) RETURN INT, STATIC PROCEDURE staproc, CONSTRUCTOR FUNCTION objtype(self in out objtype) RETURN SELF AS RESULT ); \set SQLTERM / CREATE OR REPLACE TYPE BODY objtype AS MEMBER FUNCTION memfunc(i int) RETURN INT AS BEGIN RAISE NOTICE 'self.f1 is %', self.f1; RAISE NOTICE 'self.f2 is %', f2; RETURN i; END; STATIC PROCEDURE staproc AS BEGIN RAISE NOTICE 'this is a static procedure in object type'; END; CONSTRUCTOR FUNCTION objtype(self in out objtype) RETURN SELF AS RESULT AS BEGIN f1 := 1; self.f2 := 'a'; RETURN ; END; 566 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 END; / \set SQLTERM ; 对象类型成员函数及构造函数的使用： CREATE TABLE tb1(i objtype); INSERT INTO tb1 VALUES(objtype()); -- 自定义构造函数 INSERT INTO tb1 VALUES(objtype(2, 'b')); -- 默认构造函数 SELECT * FROM tb1; i ------(1,a) (2,b) (2 rows) SELECT t.i.memfunc(1) FROM tb1 t; NOTICE: self.f1 is 1 NOTICE: self.f2 is a NOTICE: self.f1 is 2 NOTICE: self.f2 is b objtype.memfunc ----------------1 1 (2 rows) 对象类型静态存储过程的使用： CALL objtype.staproc(); NOTICE: this is a static procedure in object type CALL 相关话题 CREATE TYPE 语句 DROP TYPE BODY 语句 CREATE FUNCTION 语句 CREATE PROCEDURE 语句 567 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 15.13 DROP FUNCTION 语句 DROP FUNCTION 移除一个已有函数的定义。要执行这个命令用户必须是该函数的拥有者。可能存在多个不同的函 数具有相同的函数名和不同的参数列表，需要指定函数的参数类型进行删除。如果函数名是唯一的，可直接进行删除 操作，不需要指定参数类型。 语法 DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...] [ CASCADE | RESTRICT ] 语义 IF EXISTS 如果该函数不存在则不要抛出一个错误，而是发出一个提示。 name 一个现有函数的名称（可以是模式限定的）。如果未指定参数列表，则该名称在其模式中必须 是唯一的。 argmode 一个参数的模式：IN、OUT、INOUT 或者 VARIADIC。如果被忽略，则默认为 IN。注意 DROP FUNCTION 并不真正关心 OUT 参数，因为决定函数的身份时只需要输入参数。因此列出 IN、 INOUT 和 VARIADIC 参数足以。 argname 一个参数的名称。注意 DROP FUNCTION 并不真正关心参数名称，因为决定函数的身份时只需要 参数的数据类型。 argtype 如果函数有参数，这是函数参数的数据类型（可以是模式限定的）。 CASCADE 自动删除依赖于该函数的对象（例如操作符和触发器），然后删除所有依赖于那些对象的对 象。 RESTRICT 如果有任何对象依赖于该函数，则拒绝删除它。这是默认值。 示例 这个命令删除 sqrt 函数： DROP FUNCTION sqrt(integer); 在一个命令中删除多个函数： 568 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 DROP FUNCTION sqrt(integer), sqrt(bigint); 如果函数名称在其模式中是唯一的，则可以在不带参数列表的情况下引用它： DROP FUNCTION update_employee_salaries; 请注意，这与以下语句不同： DROP FUNCTION update_employee_salaries(); 前者可以删除具有任意数量 (包括零个) 参数的函数，只要该名称是唯一的；后者删除一个零个参数的函数。 兼容性 该命令符合 SQL 标准，使用这些 KingbaseES 扩展： • 该标准只允许每个命令删除一个函数。 • IF EXISTS 选项 • 能够指定参数模式和名称 参见 CREATE FUNCTION 语句 ，ALTER FUNCTION 语句 15.14 DROP PACKAGE 语句 删除包。需要注意，在执行该命令删除一个包的时候，会同时删除包规范和包体。无法单独删除一个包规范，若 只想删除一个包体，可通过 DROP PACKAGE BODY 命令，详见DROP PACKAGE BODY 语句 。 用户必须是包的属主或包所在模式的属主或非受限数据库管理员。 用户要具有包所在模式下的 USAGE 权限。 语法 DROP PACKAGE [ IF EXISTS ] package_names [ CASCADE | RESTRICT ]; 语义 package_names 包的名字，当需要同时删除多个包时，包名之间用, 隔开。可以有数据库名和模式名修饰，但数 据库名只能是当前数据库。 IF EXIST 要删除的包不存在时，不会出现错误信息。 CASCADE 569 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 自动删除依赖于该过程的对象，然后接着删除依赖于那些对象的对象。 RESTRICT 如果有任何对象依赖于该过程，则拒绝删除它。这是默认选项。 示例 DROP PACKAGE pkg; DROP PACKAGE IF EXISTS test.public.pkg, pkg2; 参见 ALTER PACKAGE 语句 , CREATE PACKAGE 语句 , CREATE PACKAGE BODY 语句 , DROP PACKAGE BODY 语句 15.15 DROP PACKAGE BODY 语句 删除包体。需要注意，在执行该命令删除一个包体的时候，不会删除包规范。无法单独删除一个包规范，若想删 除包含包规范在内的一整个包，可通过 DROP PACKAGE 命令，详见DROP PACKAGE 语句 。 用户必须是包的属主或包所在模式的属主或非受限数据库管理员。 用户要具有包所在模式下的 USAGE 权限。 语法 DROP PACKAGE BODY [ IF EXISTS ] package_names; 语义 package_names 包的名字，当需要同时删除多个包体时，包名之间用, 隔开。可以有数据库名和模式名修饰，但 数据库名只能是当前数据库。 IF EXIST 要删除的包体不存在时，不会出现错误信息。 示例 DROP PACKAGE BODY pkg; DROP PACKAGE BODY IF EXISTS test.public.pkg, pkg2; 参见 570 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 ALTER PACKAGE 语句 ，CREATE PACKAGE 语句 ，CREATE PACKAGE BODY 语句 ，DROP PACKAGE 语句 15.16 DROP PROCEDURE 语句 DROP PROCEDURE 移除一个现有过程的定义。为了执行这个命令，用户必须是该过程的拥有者。该过程的参数类 型必须指定，因为可能存在多个不同的过程具有相同名称和不同参数列表。 语法 DROP PROCEDURE [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...] [ CASCADE | RESTRICT ] 语义 IF EXISTS 如果该过程不存在也不抛出一个错误。这种情况下会发出一个提示。 name 现有过程的名称（可以是被模式限定的）。如果没有指定参数列表，则该名称在其所属的模式 中必须是唯一的。 argmode 参数的模式：IN 或者 VARIADIC。如果省略，默认为 IN。 argname 参数的名称。注意，其实 DROP PROCEDURE 并不在意参数名称，因为只需要参数的数据类型来 确定过程的身份。 argtype 该过程如果有参数，参数的数据类型（可以是被模式限定的）。 CASCADE 自动删除依赖于该过程的对象，然后接着删除依赖于那些对象的对象。 RESTRICT 如果有任何对象依赖于该过程，则拒绝删除它。这是默认选项。 示例 DROP PROCEDURE do_db_maintenance(); 兼容性 这个命令符合 SQL 标准，不过 KingbaseES 做了这些扩展： 571 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 • 标准仅允许每个命令删除一个过程。 • IF EXISTS 选项 • 指定参数模式和名称的能力 参见 CREATE PROCEDURE 语句 ，ALTER PROCEDURE 语句 ，DROP FUNCTION 语句 15.17 DROP TRIGGER 语句 DROP TRIGGER 移除一个现有的触发器定义。要执行这个命令，当前用户必须是触发器基表的拥有者。 语法 DROP TRIGGER [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ] DROP TRIGGER name 语义 IF EXISTS 如果该触发器不存在则不要抛出一个错误，而是发出一个提示。 name 要移除的触发器的名称。 table_name 定义了该触发器的表的名称（可以是模式限定的）。 CASCADE 自动删除依赖于该触发器的对象，然后删除所有依赖于那些对象的对象。 RESTRICT 如果有任何对象依赖于该触发器，则拒绝删除它。这是默认值。 示例 销毁表 films 上的触发器 if_dist_exists： DROP TRIGGER if_dist_exists ON films; 销毁表 films 上的触发器 if_dist_exists，且 if_dist_exists 名唯一： DROP TRIGGER if_dist_exists; 572 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 兼容性 在 SQL 标准中，不同表上也不能有同名的触发器，但 KingbaseES 存在同名触发器。因此当触发器名不唯一时， 使用 DROP TRIGGER name 命令 KingbaseES 会报错。 参见 CREATE TRIGGER 语句 15.18 DROP TYPE 语句 DROP TYPE 语句移除一种用户定义的数据类型。只有类型的拥有者才能移除它。 语法 DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT | FORCE | VALIDATE ] 语义 IF EXISTS 如果该类型不存在则不要抛出一个错误，而是发出一个提示。 name 要移除的数据类型的名称（可以是模式限定的）。 CASCADE 自动删除依赖于该类型的对象（例如表列、函数、操作符），然后删除所有依赖于那些对象的 对象。 RESTRICT 如果有任何对象依赖于该类型，则拒绝删除它。这是默认值。 FORCE 同 CASCADE。 VALIDATE 同 RESTRICT。 示例 要移除数据类型 box： DROP TYPE box; 参见 ALTER TYPE 语句 ，CREATE TYPE 语句 ，DROP TYPE BODY 语句 573 第 15 章 用于存储 PL/SQL 单元的 SQL 语句 15.19 DROP TYPE BODY 语句 DROP TYPE BODY 移除一个对象类型的所有内部函数（存储过程）的定义。只有对象类型的拥有者才能移除它。 需要注意，在执行该命令删除一个类型体的时候，不会删除类型规范。无法单独删除一个类型规范，若想删除包 含类型规范在内的一整个类型，可通过 DROP TYPE 命令，详见DROP TYPE 语句 。 语法 DROP TYPE BODY [ IF EXISTS ] name [, ...] 语义 IF EXISTS 如果该类型体不存在则不要抛出一个错误，而是发出一个提示。 name 要移除的对象类型体的名称（可以是模式限定的）。 示例 要移除对象类型体 objtype： DROP TYPE BODY objtype; 参见 ALTER TYPE 语句 ，CREATE TYPE 语句 ，CREATE TYPE BODY 语句 ，DROP TYPE 语句 574 第 16 章 A PL/SQL 源文本加密 16章 A PL/SQL 源文本加密 第 您可以为以下 PL/SQL 单元加密 PL/SQL 源文本，从而防止任何人使用数据字典显示该文本： • 包体 • 函数 • 存储过程 包含加密的 PL/SQL 源文本的文件称为加密文件。客户端工具可以移动、备份或直接导入处理。 要生成加密文件，请使用 PL/SQL Wrapper 实用程序或 DBMS_DDL 子程序。PL/SQL Wrapper 实用程序加密 由指定 SQL 文件创建的每个可加密 PL/SQL 单元的源文本。DBMS_DDL 子程序加密单个动态生成的可加密 PL/ SQL 单元的源文本。 PL/SQL Wrapper 实用程序和 DBMS_DDL 子程序都检测标记化错误（例如，失控的字符串），但不会检测语 法或语义错误（例如，不存在的表或视图）。 16.1 PL/SQL 源文本加密限制 • 加密 PL/SQL 源文本不是隐藏密码或表名的安全方法。 • 不能加密触发器的 PL/SQL 源文本。 要隐藏触发器的实现细节，请将它们放在存储的子程序中，加密子程序，并编写一个调用子程序的触发器。 16.2 PL/SQL 源文本加密指南 • 仅加密包体，而不是包规范。 • 不加密规范是允许其他开发人员查看使用包或类型所需的信息（参见示例 A-5 ）。加密包体可以防止他们看到 包的实现。 • 仅在完成编辑文本后才对文件进行加密。 575 第 16 章 A PL/SQL 源文本加密 • 不能编辑加密的文件。如果加密的文件需要更改，必须编辑原始文本，然后将其加密。 • 在分发加密文件之前，请在文本编辑器中查看它并确保所有重要部分都已加密。 16.3 使用 PL/SQL Wrapper 工具加密 PL/SQL 源文 本 PL/SQL Wrapper 实用程序采用单个 SQL 文件并生成一个等效的文本文件，其中加密了每个可加密 PL/SQL 单 元的 PL/SQL 源文本。 有关可加密的 PL/SQL 单元的列表，请参阅“PL/SQL 源文本加密”的介绍。 PL/SQL Wrapper 实用程序无法连接到 KingbaseES 数据库。要运行 PL/SQL Wrapper 实用程序，请在操作系 统提示符下输入以下命令（等号周围没有空格）： wrap iname=input_file [ oname=output_file ] input_file 是包含 SQL 语句的任意组合的现有文件的名称。 output_file 是 PL/SQL Wrapper 实用程序创建的文件的名称——被加密的文件。 注意: 如果 input_file 是一个加密文件，则 output_file 是再次加密的文件。 input_file 的默认文件扩展名是 sql。output_file 的默认名称是 input_file.plb。因此，这些命令是等价的： wrap iname=/kesdir/kesfile.sql wrap iname=/kesdir/kesfile.sql oname=/kesdir/kesfile.plb 此示例为指定不同的文件扩展名 input_file 和不同的名称 output_file： wrap iname=/mydir/myfile.src oname=/yourdir/yourfile.out 您可以将 output_file 在 Ksql 中作为脚本运行。例如： test=# \i /yourdir/yourfile.out 示例 A-1 具有两个可加密 PL/SQL 单元的 SQL 文件 这个例子显示了一个 SQL 文件的文本 wrap_test.sql，它包含两个可加密的 PL/SQL 单元——过程 wrapproc 和 函数 wrapfunc 。该文件还包含注释和一些 SQL 语句。 create table t1(id int); 576 第 16 章 A PL/SQL 源文本加密 / insert into t1 values(1),(2),(3); / SELECT COUNT(*) FROM t1; / CREATE PROCEDURE wrapproc AUTHID CURRENT_USER IS TYPE t1_tab IS TABLE OF t1%ROWTYPE INDEX BY INTEGER; all_id t1_tab; BEGIN SELECT * BULK COLLECT INTO all_id FROM t1; FOR i IN 1..3 LOOP DBMS_OUTPUT.PUT_LINE('T1 Id: ' || all_id(i).id); END LOOP; END; / CREATE OR REPLACE FUNCTION wrapfunc ( n INTEGER ) RETURN INTEGER AUTHID CURRENT_USER -- PL/SQL style comment inside wrapfunc function spec, but will be deleted. IS fun_a1 INTEGER := 0; fun_a2 INTEGER := 1; BEGIN IF n = 1 THEN -- terminating condition RETURN fun_a1; ELSIF n = 2 THEN RETURN fun_a2; ELSE RETURN wrapfunc(n-2) + wrapfunc(n-1); END IF; END; / 示例 A-2 使用 PL/SQL 加密实用程序加密文件 此示例使用 PL/SQL Wrapper 实用程序来加密 wrap_test.sql 并显示已加密的文件 wrap_test.plb。加密文件 加密（变得不可读）过程 wrapproc 和函数 wrapfunc 的 PL/SQL 源文本，但将注释保留在加密源之外。加密文件 wrap_test.sql： wrap iname=wrap_test.sql 结果： 577 第 16 章 A PL/SQL 源文本加密 Processing wrap_test.sql to wrap_test.plb wrap_test.plb 的内容： \set SQLTERM / create table t1(id int); / insert into t1 values(1),(2),(3); / SELECT COUNT(*) FROM t1; / CREATE PROCEDURE wrapproc AUTHID CURRENT_USER IS WRAPPED tEi28mifS2OE24WQ+yecGjUsj6F36jtaPpqsFptzxzPmnTAa+ytnZhtyjby5 w/DwRKHtpTsc/YGdT1LTbNBeDBjFJZ9aAcPJZh4zF7ejhO1M5yOHThhF0VU3 xQky+16gfsF4rZST1VGIe6zKwtkzj6hpryrv9yafr5UHnm0SmF2tN7z9YeAB IvVm6mK+VyNee0dMV9yxL1Z5BZqQe7UzNz9M5gys3MuoY6q7zYlxcwc6KSK0 RQLBvdFY9W7vm5GROMDJ1N/h96f4dbZWpPnxdEJz0VWJT7tT99AWyKOt5eZE vGR743hQbXM91u+X7DglQszFNsrtoqZogDwZG73ylw== END; / CREATE OR REPLACE FUNCTION wrapfunc ( n INTEGER ) RETURN INTEGER AUTHID CURRENT_USER IS WRAPPED VFLIjR+55WAyW9Lw6/g9ZJw8EQ7gAKk3JTPfpj3aocdX+cBYc1QbrVExIa3V D10p/1twjkM4Ss9ISXEqm2t4K5JEPJv9BXErpA1dzTVL8Lzw4vZa8957ZOYg Hk/Kc43CHTbaLYq6/QVsG2nNXNLyM5XPr4ZZY1GC601/2CjIRY3I9dC+muml r2K65AoXRtOv+XSpaIW3ojFbAtfIe4u1PPDi9lrz3ntk5iAeT8pzjcK8nqt2 zTAZ+zJPiKUGiM/qXlRTGbN3R6du1/fH7UoSqzaIA6xKb7NzGUfRtDjCW7js wj0VtmtG1jGst4pDWA5W0zwSu2PDIYigfz88ye/6qbgHdb9pZu+SIlAmtenZ yZzbOHH2f8ftsSk/kK8m+erPAUpSNvPOoFgzYgy4l88YYw== END; / 578 第 16 章 A PL/SQL 源文本加密 示例 A-3 运行加密的文件并查看加密的 PL/SQL 单元 在 Ksql 中，此示例运行加密文件 wrap_test.plb，创建过程 wrapproc 和函数 wrapfunc 。选择子程序的文本（被 加密，因此不可读），然后调用子程序。 test=# -- Run wrapped file: test=# \i wrap_test.plb CREATE TABLE INSERT 0 3 count ------3 (1 row) CREATE PROCEDURE CREATE FUNCTION test=# -- Try to display procedure source text: test=# select prosrc from sys_proc where proname='wrapproc'; test-# / prosrc -------------------------------------------------------------WRAPPED + tEi28mifS2OE24WQ+yecGjUsj6F36jtaPpqsFptzxzPmnTAa+ytnZhtyjby5+ w/DwRKHtpTsc/YGdT1LTbNBeDBjFJZ9aAcPJZh4zF7ejhO1M5yOHThhF0VU3+ xQky+16gfsF4rZST1VGIe6zKwtkzj6hpryrv9yafr5UHnm0SmF2tN7z9YeAB+ IvVm6mK+VyNee0dMV9yxL1Z5BZqQe7UzNz9M5gys3MuoY6q7zYlxcwc6KSK0+ RQLBvdFY9W7vm5GROMDJ1N/h96f4dbZWpPnxdEJz0VWJT7tT99AWyKOt5eZE+ vGR743hQbXM91u+X7DglQszFNsrtoqZogDwZG73ylw== + END (1 row) test=# test=# -- Try to display function source text: test=# test=# select prosrc from sys_proc where proname='wrapfunc'; test-# / prosrc -------------------------------------------------------------WRAPPED + VFLIjR+55WAyW9Lw6/g9ZJw8EQ7gAKk3JTPfpj3aocdX+cBYc1QbrVExIa3V+ D10p/1twjkM4Ss9ISXEqm2t4K5JEPJv9BXErpA1dzTVL8Lzw4vZa8957ZOYg+ Hk/Kc43CHTbaLYq6/QVsG2nNXNLyM5XPr4ZZY1GC601/2CjIRY3I9dC+muml+ r2K65AoXRtOv+XSpaIW3ojFbAtfIe4u1PPDi9lrz3ntk5iAeT8pzjcK8nqt2+ zTAZ+zJPiKUGiM/qXlRTGbN3R6du1/fH7UoSqzaIA6xKb7NzGUfRtDjCW7js+ 579 第 16 章 A PL/SQL 源文本加密 wj0VtmtG1jGst4pDWA5W0zwSu2PDIYigfz88ye/6qbgHdb9pZu+SIlAmtenZ+ yZzbOHH2f8ftsSk/kK8m+erPAUpSNvPOoFgzYgy4l88YYw== + END (1 row) test=#set serverout on test=# BEGIN wrapproc; DBMS_OUTPUT.PUT_LINE('wrapfunc(5) = ' || wrapfunc(5)); END; / T1 Id: 1 T1 Id: 2 T1 Id: 3 wrapfunc(5) = 3 16.4 用 DBMS_DDL 子程序加密 PL/SQL 源文本 DBMS_DDL 包提供了 WRAP 函数和 CREATE_WRAPPED 过程，它们中的每一个都可以加密单个动态生成 的可加密 PL/SQL 单元的 PL/SQL 源文本。如果 WRAP 或 CREATE_WRAPPED 的输入不是有效的可加密 PL/ SQL 单元，则会引发该异常。（有关可加密的 PL/SQL 单元的列表，请参阅“PL/SQL 源文本加密”的介绍。） 每个 WRAP 函数将单个 CREATE 语句作为输入，该语句创建一个可加密的 PL/SQL 单元并返回一个等效的 CREATE 语句，其中 PL/SQL 源文本已被加密。有关这些 WRAP 函数的更多信息，请参阅《KingbaseES 插件参考 手册》。 每个 CREATE_WRAPPED 过程执行其对应的 WRAP 函数所做的事情，然后运行返回的 CREATE 语句，创建 指定的 PL/SQL 单元。有关这些 CREATE_WRAPPED 过程的更多信息，请参阅《KingbaseES 插件参考手册》。 提示: 调用 DBMS_DDL 子程序时，请使用完全限定的包名称 SYS.DBMS_DDL，以避免在有人创建名为 DBMS_DDL 的本地包或定义公共同义词 DBMS_DDL 时发生名称冲突。 注意: 输入到 WRAP 函数或 CREATE_WRAPPED 过程的 CREATE 语句以调用子程序的用户的权限运行。 示例 A-4 使用 CREATE_WRAPPED 过程动态创建包规范（使用 EXECUTE IMMEDIATE 语句）和加密的包 体。 示例 A-5 选择示例 A-4 创建的包的文本 stu_scores ，然后调用过程 stu_scores.raise_score。如果包体被加密， 那么调用过程所需的信息将不可读。 580 第 16 章 A PL/SQL 源文本加密 示例 A-4 使用 CREATE_WRAPPED 过程创建加密的包体 \set SQLTERM ; CREATE TABLE student (id int, name text, score number); insert into student values(1, 'zhangsan', 100); insert into student values(2, 'lisi', 99); insert into student values(3, 'lihua', 98); \set SQLTERM / DECLARE pkg_text VARCHAR2(32767); -- 创建包规范和包体的文本 FUNCTION generate_spec (pkgname VARCHAR2) RETURN VARCHAR2 AS BEGIN RETURN 'CREATE PACKAGE ' || pkgname || ' AUTHID CURRENT_USER AS PROCEDURE raise_score (stu_id NUMBER, amount NUMBER); END ' || pkgname || ';'; END generate_spec; FUNCTION generate_body (pkgname VARCHAR2) RETURN VARCHAR2 AS BEGIN RETURN 'CREATE PACKAGE BODY ' || pkgname || ' AS PROCEDURE raise_score (stu_id NUMBER, amount NUMBER) IS BEGIN UPDATE student SET score = score + amount WHERE id = stu_id; END raise_score; END ' || pkgname || ';'; END generate_body; BEGIN pkg_text := generate_spec('stu_scores'); -- 生成包规范文本 EXECUTE IMMEDIATE pkg_text; -- 创建包规范 pkg_text := generate_body('stu_scores'); -- 生成包体文本 SYS.DBMS_DDL.CREATE_WRAPPED(pkg_text); -- 创建加密包体 END; / 示例 A-5 查看带有加密的包体和调用包过程 查看包文本： SELECT pkgbodysrc FROM sys_package WHERE pkgname = 'stu_scores'; 结果： pkgbodysrc -------------------------------------------------------------- 581 第 16 章 WRAPPED A PL/SQL 源文本加密 + sS7LP7io7BJ2UEXlOlhSo0HIIrYrCHL3IE6U7gYU5eGMACwaixq/NwDZ9pZl+ fP512lSl1zUs99jLD2fiOkpAsjtWGvnihfTzebAeKgX8rDo6ONGOk2sohRxJ+ VD52h4ecCDWsGlTEH62AM3CC3aQ9AgeIPPkuE7ftJWkA5WkashX/jnF5/AsQ+ vt5jX/2p/R/boV5jqwpzNzjrwAyf2AV4wSJSRf+tuk+VCtPuUlqDzSIXyzip+ Z983Ri/r1ou7L833 + END 结果： \set SQLTERM ; select * from student; id | name | score ----+----------+------1 | zhangsan | 100 2 | lisi | 99 3 | lihua | 98 (3 rows) call stu_scores.raise_score(3, 2); select * from student; id | name | score ----+----------+------1 | zhangsan | 100 2 | lisi | 99 3 | lihua | 100 (3 rows) 582 第 17 章 第 B PL/SQL 名称解析 17章 B PL/SQL 名称解析 本附录介绍 PL/SQL 名称解析，重点为 PL/SQL 编译器如何解析对标识符的模糊引用。 如果您在其编译单元中更改标识符（即如果您添加、重命名或删除标识符），则标识符可能会引用不唯一。 17.1 限定名称和点符号 当一个命名项属于另一个命名项时，您可以（有时必须）使用点表示法用“父”项的名称来限定“子”项的名 称。例如： 引用 名称限定 语法 记录的字段 记录名称 record_name.field_name 集合方法 集合名称 collection_name.method 伪列 CURRVAL 序列名称 sequence_name.CURRVAL 伪列 NEXTVAL 序列名称 sequence_name.NEXTVAL 如果在命名的 PL/SQL 单元中声明了一个标识符，您可以使用该单元的名称（块、子程序或包）来限定其简单 名称（其声明中的名称），使用以下语法： unit_name.simple_identifier_name 如果标识符不可见，则必须限定其名称（请参阅” 标识符的作用域和可见性 ”）。 如果标识符属于另一个模式，则必须使用模式名称限定其名称，使用以下语法： schema_name.package_name 一个简单的名称可以用多个名称来限定，如示例 B-1 所示。 可能有歧义的限定名称的一些示例是： 583 第 17 章 B PL/SQL 名称解析 • 另一个模式拥有的架构对象，例如： schema_name.table_name schema_name.procedure_name() schema_name.type_name.member_name() • 另一个用户拥有的包对象，例如： schema_name.package_name.procedure_name() schema_name.package_name.record_name.field_name 示例 B-1 限定名称 \set SQLTERM / CREATE OR REPLACE PACKAGE pkg1 AUTHID DEFINER AS num NUMBER; TYPE rt IS RECORD (a NUMBER); var1 rt; TYPE ct IS TABLE OF rt INDEX BY PLS_INTEGER; var2 ct; FUNCTION f1 (a1 NUMBER) RETURN rt; FUNCTION f2 (a2 NUMBER) RETURN ct; END pkg1; / CREATE OR REPLACE PACKAGE BODY pkg1 AS FUNCTION f1 (a1 NUMBER) RETURN rt IS n NUMBER; BEGIN n := num; -- 不合格的变量名 n := pkg1.num; -- 包名限定的变量名 n := var1.a; -- 变量名后跟字段名 n := pkg1.var1.a; -- 包名限定的变量名后跟组件名称 var1.a := a1; RETURN var1; END f1; FUNCTION f2 (a2 NUMBER) RETURN ct IS v_rt rt; v_ct ct; BEGIN v_rt.a := a2; v_ct(1) := v_rt; RETURN v_ct; END f2; END pkg1; 584 第 17 章 B PL/SQL 名称解析 / 列名优先级 17.2 如果 SQL 语句引用的名称既属于列又属于局部变量或形参，则列名优先。 警告: 当变量或参数名称被解释为列名称时，可能会无意中删除、更改或插入数据。 在示例 B-2 中，名称 name 既属于局部变量又属于列（名称不区分大小写）。因此，在 WHERE 子句中，对 name 的两个引用都解析为列，并且所有行都被删除。 示例 B-3 通过给变量一个不同的名称来解决示例 B-2 中的问题。 在示例 B-4 中，函数 stu_name 有一个形式参数和一个局部变量，其名称是表 student 的列的名称。参数和变量 名用函数名限定，以区别于列名。 示例 B-2 解释为列名的变量名导致意外结果 DROP TABLE IF EXISTS student; DROP TABLE IF EXISTS stu_name; CREATE TABLE student (id int PRIMARY KEY, name text, score number); insert into student values (1, 'xx', 99); CREATE TABLE stu_name AS SELECT name FROM student; \set SQLTERM / DECLARE name TEXT := 'xa'; BEGIN DELETE FROM student WHERE name = name; RAISE NOTICE 'Deleted % rows', SQL%ROWCOUNT; END; / 结果： NOTICE: Deleted 1 rows 示例 B-3 使用不同的变量名称修复示例 B-2 insert into student values (1, 'xx', 99); \set SQLTERM / DECLARE v_name TEXT := 'xa'; BEGIN 585 第 17 章 B PL/SQL 名称解析 DELETE FROM student WHERE name = v_name; RAISE NOTICE 'Deleted % rows', SQL%ROWCOUNT; END; / 结果： NOTICE: Deleted 0 rows 示例 B-4 名称解析的子程序名称 \set SQLTERM / DECLARE FUNCTION stu_name (id IN NUMBER) RETURN student.name%TYPE AS DECLARE v_name student.name%TYPE; BEGIN SELECT name INTO v_name FROM student WHERE id = stu_name.id; RETURN v_name; END stu_name; BEGIN FOR item IN ( SELECT id FROM student) LOOP RAISE NOTICE 'Student: %', stu_name(item.id); END LOOP; END; / 结果： NOTICE: Student: xx 17.3 PL/SQL 和 SQL 名称解析规则的区别 PL/SQL 和 SQL 名称解析规则非常相似。然而： • PL/SQL 规则比 SQL 规则更宽松。 因为大多数 SQL 名称解析规则是依赖上下文相关信息的，所以它比 PL/SQL 名称解析规则更加准确。 • PL/SQL 和 SQL 以不同的方式解析限定名。 586 第 17 章 B PL/SQL 名称解析 例如，在解析 student 表名时： – PL/SQL 首先搜索当前 ms 模式中命名的包、类型、表和视图，然后搜索公共同义词，最后在 ms 模式中 搜索名为 student 的对象。 – SQL 首先在 ms 模式中搜索名为 student 的对象，然后在当前模式中搜索名为 ms 的包、类型、表和视图。 注意: 当 PL/SQL 编译器处理静态 SQL 语句时，它将该语句发送到 SQL 子系统，该子系统使用 SQL 规则来解析语 句中的名称。详见” 静态 SQL 语句中的名称解析 ”。 17.4 静态 SQL 语句中的名称解析 静态 SQL 在” PL/SQL 静态 SQL ” 中进行了描述。 当 PL/SQL 编译器找到静态 SQL 语句时： 1. 如果语句是 SELECT 语句，则 PL/SQL 编译器删除 INTO 子句。 2. PL/SQL 编译器将语句发送到 SQL 子系统。 3. SQL 子系统检查语句的语法。 如果语法不正确，PL/SQL 单元的编译将失败。如果语法正确，SQL 子系统将确定表的名称并尝试解析 SQL 语句范围内的其他名称。 4. 如果 SQL 子系统无法解析 SQL 语句范围内的名称，则它将名称发送回 PL/SQL 编译器。该名称称为转义标识 符。 5. PL/SQL 编译器尝试解析转义的标识符。 首先，编译器尝试解析 PL/SQL 单元范围内的标识符。如果失败，编译器会尝试解析模式范围内的标 识符。如果失败，PL/SQL 单元的编译就会失败。 6. 如果 PL/SQL 单元的编译成功，则 PL/SQL 编译器生成与静态 SQL 语句等效的常规 SQL 语句的文本，并将 该文本与生成的计算机代码一起存储。 7. 在运行时，PL/SQL 运行时系统调用解析、绑定和运行常规 SQL 语句的例程。 绑定变量是转义的标识符（参见步骤 4）。 8. 如果语句是 SELECT 语句，则 PL/SQL 运行时系统将结果存储在 PL/SQL 编译器在步骤 1 中删除的 INTO 子 句中指定的 PL/SQL 目标中。 587 第 18 章 C PL/SQL 程序限制 18章 C PL/SQL 程序限制 第 本附录描述了 PL/SQL 语言强加的程序限制。 表 18.1: PL/SQL 编译器限制 项目 限制 绑定变量传递给程序单元 512 RECORD 中的字段 1600 嵌套集合的级别 6 PLS_INTEGER 或 BINARY_INTEGER 值的大小 -2147483648~2147483647 子程序、函数或过程中的形参数量 65536 自治事务中的函数或过程形参数量 512 动态 SQL 绑定参数数量 1024 NUMBER 值的精度（十进制数字） 38 REAL 值的精度（十进制数字） 6 标识符的大小（字节） 63 CHAR 值的大小（字节） 10 ＊ 10 ＊ 1024 LONG 值的大小（字节） 1G-1 LONG RAW 值的大小（字节） 32760 RAW 值的大小（字节） 1G-1 VARCHAR2 值的大小（字节） 1G-1 NCHAR 值的大小（字节） 10 ＊ 10 ＊ 1024 见续表 588 第 18 章 C PL/SQL 程序限制 表 18.1 – 续表 项目 限制 NVARCHAR2 值的大小（字节） 1G-1 BLOB 值的大小（字节） 1G-1 CLOB 值的大小（字节） 1G-1 NCLOB 值的大小（字节） 1G-1 当 PL/ SQL 块、子程序、包或模式级用户定义类型超过大小限制时，您会收到诸如对象超长之类的错误。通 常，包或匿名块会出现此问题。对于一个包，最好的解决方案是将它分成更小的包。对于匿名块，最好的解决方案是 将其重新定义为一组子程序，可以存储在数据库中。 有关数据类型限制的更多信息，请参阅PL/SQL 数据类型 。 589 第 19 章 D PL/SQL 保留字和关键字 19章 D PL/SQL 保留字和关键字 第 保留字和关键字是在 PL/ SQL 中具有特殊含义的标识符。它们不区分大小写。有关它们的更多信息，请参阅 “保留关键字和非保留关键字”。 表 19.1: PL/SQL 保留字 首字母 保留字 A ALL B BEGIN, BY C CASE D DECLARE E ELSE, END, EXECUTE F FOR, FORALL, FOREACH, FROM, FUNCTION FINAL G GOTO H HAVING I IF, IN, INTO,INSTANTIABLE L LOOP N NOT, NULL O OR P PROCEDURE S STRICT T THEN, TO 见续表 590 第 19 章 D PL/SQL 保留字和关键字 表 19.1 – 续表 首字母 保留字 U USING W WHEN, WHILE, WRAPPED 表 19.2: PL/SQL 关键字 首字母 关键字 A ABSOLUTE, ALIAS, AND, ARRAY, AS, ASSERT B BACKWARD, BETWEEN, BULK C CALL, CHAIN, CLOSE, COLLATE, COLLECT, COLUMN, COLUMN_NAME, COMMIT, CONSTANT, CONSTRAINT, CONSTRAINT_NAME, CONSTRUCTOR, CONTINUE, COUNT, CURRENT, CURSOR D DATATYPE, DEBUG, DEFAULT, DELETE, DETAIL, DETERMINISTIC, DIAGNOSTICS, DO, DUMP E ELSEIF, ELSIF, ERRCODE, ERROR, EXCEPTION, EXCEPTION_INIT, EXCEPTIONS, EXISTS, EXIT, EXTEND F FETCH, FIRST, FORWARD G GET H HINT I IMMEDIATE, IMMUTABLE, IMPORT, INDEX, INDICES, INFO, INOUT, INSERT, IS L LAST, LIMIT, LOG M MEMBER, MERGE, MESSAGE, MESSAGE_TEXT, MOVE N NEXT, NO, NOCOPY, NOTICE O OF, OPEN, OPTION, OUT P PERFORM, PG_CONTEXT, PG_EXCEPTION_DETAIL, PG_DATATYPE_NAME, PG_EXCEPTION_HINT, PG_EXCEPTION_CONTEXT, PIPE, PIPELINED, PRAGMA, PRINT_STRICT_PARAMS, PRIOR Q QUERY 见续表 591 第 19 章 D PL/SQL 保留字和关键字 表 19.2 – 续表 首字母 关键字 R RAISE, RANGE, RECORD, REF, RELATIVE, RELIES_ON, RESET, RESULT, RESULT_CACHE, RETURN, RETURNED_SQLSTATE, RETURNING, RETURNS, REVERSE, ROLLBACK, ROW, ROW_COUNT, ROWTYPE S SAVE, SCHEMA, SCHEMA_NAME, SCROLL, SELF, SET, SETOF, SLICE, SQLSTATE, STABLE, STACKED, STATIC, SUBTYPE T TABLE, TABLE_NAME, TRIM, TYPE U UPDATE, USE_COLUMN, USE_VARIABLE V VALUES, VARIABLE_CONFLICT, VARRAY, VARYING, VOLATILE W WARNING 592 第 20 章 E PL/SQL 预定义类型 20章 E PL/SQL 预定义类型 第 本附录按数据类型族对 SYS 模式下预定义的数据类型和子类型进行分组。 • CHAR 数据类型系列 SYS.DBMS_ID AS VARCHAR2(128); SYS.DBMS_QUOTED_ID AS VARCHAR2(130); SYS.DBMS_ID_30 AS VARCHAR2(30); SYS.DBMS_QUOTED_ID_30 AS VARCHAR2(32); SYS.STRING AS VARCHAR2; • DATE 数据类型系列 SYS.TIME_UNCONSTRAINED AS TIME(6); SYS.TIME_TZ_UNCONSTRAINED AS TIME(6) WITH TIME ZONE; SYS.TIMESTAMP_UNCONSTRAINED AS TIMESTAMP(6); SYS.TIMESTAMP_TZ_UNCONSTRAINED AS TIMESTAMP(6) WITH TIME ZONE; SYS.TIMESTAMP_LTZ_UNCONSTRAINED AS TIMESTAMP(6) WITH LOCAL TIME ZONE; • NUMBER 数据类型系列 SYS.BINARY_INTEGER as integer; SYS.SIMPLE_INTEGER as integer not null; SYS.SIMPLE_FLOAT as BINARY_FLOAT not null; SYS.SIMPLE_DOUBLE as BINARY_DOUBLE not null; SYS.POSITIVE as integer check (value > 0); SYS.positiven as integer check (value > 0) not null; SYS."NATURAL" as integer check (value >= 0); SYS.NATURALN as integer check (value >= 0) not null; SYS.SIGNTYPE as integer CHECK (VALUE = -1 OR VALUE = 0 OR VALUE = 1); PLS_INTEGER is INT(4); REAL is FLOAT(4); DOUBLE PRECISION is FLOAT(8); DEC is NUMERIC; 593 第 20 章 E PL/SQL 预定义类型 BINARY_FLOAT is FLOAT(4); BINARY_DOUBLE is FLOAT(8); 另请参阅: “PL/SQL 数据类型”，了解更多关于 PL/SQL 数据类型的信息 “用户定义的 PL/SQL 子类型”，了解也适用于预定义子类型的信息 594 第 21 章 F PLSQL 对象支持状态 21章 F PLSQL 对象支持状态 第 KingbaseES 的 PLSQL 对象包括函数、存储过程、触发器、包、包体、对象类型、对象类型体和匿名块。其中 匿名块即用即销，不具有状态属性。其它具有状态属性的 PLSQL 对象在创建时都需要根据创建时 plsql 块的编译结 果设置相应的状态，在创建、调用或者重新编译时无任何异常抛出，则当前对象的状态会被定义为有效状态。若编译 过程中 plsql 块内发生错误，则将当前创建对象创建为无效状态，并且在创建时弹出警告信息，在调用时也会抛出异 常提示。 动态 SQL 中的异常不会在编译阶段抛出，也不会影响当前创建对象的有效性。声明的状态会影响定义的状态， 而定义的状态则无法影响声明的状态。 在 KingbaseES 中，对于对象类型（object type）而言，声明要么创建成功。要么创建失败，创建成功就一定是 有效的，body 即使创建成功，也可能是无效的。当出现两个 PLSQL 对象互相引用对方的情况时，二者也总会是无 效的。 21.1 限制与约束 由于包的实现方式限制，当包处于无效状态时，对其中变量和类型的引用并不能被动刷新包的状态，此时需要主 动刷新包的状态，让包处于有效状态，才能正常识别和引用包中变量和类型。在 KingbaseES 的 PLSQL 中，涉及到 表达式结果集匹配检测的操作，都无法在编译阶段进行检测，只能发生在执行阶段，故相关异常亦无法影响该对象的 状态。例如游标返回值与游标 select 语句返回结果集不匹配，该操作需要对游标 select 表达式进行计算，故无法在编 译阶段进行。 另外，由于数据库对 DCL 语句的处理机制影响，DCL 语句中的异常在 PLSQL 编译中也无法检测出来，包括 GRANT 语句、ALTER 语句、COMMENT 等语句中的对象不存在等问题，只能在执行时检测。所以 KingbaseES 的 PLSQL 无法在编译阶段检测相关问题并正确设置对应的状态。 由于该功能引入了较为严格的编译检查机制，所以与部分 PG 原有生态产生冲突，目前已知情况包括： 1. 在 PLSQL 对象中使用 DDL 语句创建一个 SQL 对象后马上使用该对象，会由于检测机制导致该 PLSQL 对象 无法执行。 2. 列数不匹配的情况，在 PG 原生的逻辑中是能正常执行的，但在开启对象状态功能后列数不匹配的情况将不再 被允许。 595 第 21 章 F PLSQL 对象支持状态 综上所述，建议对象支持状态的功能仅在高度兼容 oracle 的数据朝 KingbaseES 迁移时或者在基于 KingbaseES 系统上做原生开发时使用。如果是 PG 的数据朝 KingbaseES 迁移或者旧的 KingbaseES 做升级迁移，则不建议启用 该功能。否则可能导致迁移或者升级失败。 21.2 控制参数 KingbaseES 提供参数 ora_func_style 进行 PLSQL 对象状态的启停控制功能，详情参见《KingbaseES 数据库 参考手册》的 ora_func_style 参数章节。 21.3 对象状态刷新 KingbaseES 中的 PLSQL 对象在创建时被赋予状态属性，则也需要在使用过程中支持进行状态刷新维护。支持 被动刷新和主动刷新功能。 21.3.1 被动刷新 PLSQL 对象调用时，对其进行有效性检查： • 若当前调用对象有效，则继续调用。 • 若当前调用对象无效，则需要对其进行重新编译。 • 若编译过程中未发现异常，则将对应对象的状态刷新为有效状态并继续调用。若重新编译过程中发现错误，则 将其状态刷新为无效，并将所有在 sys_depend 系统表中记录的依赖于当前 PLSQL 对象的其它 PLSQL 对象的 状态一起刷新为无效状态。 • KingbaseES 暂不支持嵌套编译，所以在创建对象引用数据库中已存在的无效对象时，无法对其进行刷新操作。 21.3.2 主动刷新 KingbaseES 使用 ALTER…COMPILE 命令来主动刷新 PLSQL 对象状态。详情参见以下语句： • ALTER FUNCTION 语句 • ALTER PACKAGE 语句 • ALTER PROCEDURE 语句 • ALTER TRIGGER 语句 • ALTER TYPE 语句 596 第 21 章 F PLSQL 对象支持状态 示例 21.3.3 示例 1 被动刷新 \set SQLTERM / CREATE OR REPLACE FUNCTION func_test2 RETURN INT IS BEGIN INSERT INTO t1 VALUES(1); RAISE NOTICE '5'; RETURN 1; END; / ----警告提示如下： WARNING: HINT: relation "t1" does not exist compilation of PL/SQL function "func_test2" near line 3 WARNING: function func_test2() is invalid \set SQLTERM ; SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST2'; status --------INVALID \set SQLTERM / CREATE OR REPLACE FUNCTION func_test1 RETURN INT IS BEGIN CREATE TABLE t1(id int); RETURN 1; END; / \set SQLTERM ; SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST2'; status --------INVALID SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST1'; status --------VALID SELECT func_test1(); func_test1 597 第 21 章 F PLSQL 对象支持状态 -----------1 SELECT status from USER_OBJECTS where object_name = 'FUNC_TEST2'; status --------INVALID SELECT func_test2(); func_test2 -----------1 SELECT status from USER_OBJECTS where object_name = 'FUNC_TEST2'; status --------VALID DROP FUNCTION func_test1; DROP FUNCTION func_test2; DROP TABLE t1; 示例 2 被动刷新 \set SQLTERM / CREATE OR REPLACE FUNCTION func_test1 RETURN INT IS BEGIN INSERT INTO t1 VALUES(1); RAISE NOTICE '5'; RETURN 1; END; / ----警告提示如下： WARNING: HINT: relation "t1" does not exist compilation of PL/SQL function "func_test2" near line 3 WARNING: function func_test2() is invalid \set SQLTERM ; SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST1'; status --------INVALID SELECT func_test1(); 598 第 21 章 F PLSQL 对象支持状态 ----警告提示如下： WARNING: HINT: relation "t1" does not exist compilation of PL/SQL function "func_test1" near line 3 WARNING: function func_test1() is invalid CREATE TABLE t1(id int); ----主动刷新 ALTER FUNCTION func_test1 COMPILE; SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST1'; status --------VALID SELECT func_test1(); NOTICE：5 func_test1 -----------1 DROP FUNCTION func_test1; DROP TABLE t1; 状态蔓延 21.4 在 KingbaseES 中，数据库对象依赖关系被存储到系统表 sys_depend 中。在被依赖对象被删除或者变为无效状 态时，无效状态会蔓延至所有引用该对象的 PLSQL 对象上。互相引用的 PLSQL 对象会由于互相引用导致编译无法 通过而总是处于无效状态。 示例如下： \set SQLTERM ; create table t1(id int，score int); \set SQLTERM / CREATE OR REPLACE FUNCTION func_test1 RETURN INT IS BEGIN INSERT INTO t1 VALUES(1,1); RETURN 1; END; / 599 第 21 章 F PLSQL 对象支持状态 \set SQLTERM ; \set SQLTERM / CREATE OR REPLACE FUNCTION func_test2 RETURN INT IS a1 INT; BEGIN a1 := func_test1(); RAISE NOTICE '5'; RETURN 1; END; / \set SQLTERM ; SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST1'; status -------VALID SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST2'; status -------VALID DROP TABLE T1; SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST1'; status -------INVALID SELECT status FROM USER_OBJECTS WHERE object_name = 'FUNC_TEST2'; status -------INVALID 21.5 相关视图 • 可以通过 all_objects、user_objects 和 dba_objects 视图三个视图中的 status 字段查看对象的有效状态。 • PLSQL 内部的表达式中引用的数据库对象，都会与当前的 PLSQL 对象建立依赖关系，该依赖关系存储到系统 表 sys_depend‘中。在被依赖对象被删除或者变为无效状态时，无效状态会蔓延至所有引用该对象的 PLSQL 对 象上。详情参见《:ref:‘KingbaseES 数据库参考手册》中系统表 sys_depend 章节。 600 版权声明 版权声明 北京人大金仓信息技术股份有限公司（简称：人大金仓）版权所有，并保留对本手册及本声明的一切权利。 未得到人大金仓的书面许可，任何人不得以任何方式或形式对本手册内的任何部分进行复制、摘录、备份、修 改、传播、翻译成其他语言、将其全部或部分用于商业用途。 免责声明 本手册内容依据现有信息制作，由于产品版本升级或其他原因，其内容有可能变更。人大金仓保留在没有任何通 知或者提示的情况下对手册内容进行修改的权利。 本手册仅作为使用指导，人大金仓在编写本手册时已尽力保证其内容准确可靠，但并不确保手册内容完全没有错 误或遗漏，本手册中的所有信息也不构成任何明示或暗示的担保。 技术支持 • 人大金仓官方网站：http://www.kingbase.com.cn/ • 人大金仓文档中心：http://help.kingbase.com.cn/ • 全国服务热线：400-601-1188 • 人大金仓技术支持与反馈信箱：support@kingbase.com.cn 601 服务周期承诺 服务周期承诺 由于市场需求在不断变化，技术创新和发展的进程不断加剧，产品的版本更迭不可避免。人大金仓对于产品版本 生命周期的有效管理，有助于您提前规划项目，更好地从产品服务终止上过渡。 表 1: KingbaseES 产品生命周期里程碑 关键里程碑点 定义 产品发布日期 产品正式发布版本，即 GA（general availability）版本的发布日期。 停止销售日期 正式停止销售的日期，版本停止接受订单日。该日之后，产品将不再销售。 停止功能升级日期 在该日期之后，不再提供新特性和新硬件支持。但依旧提供错误修复、安全修复、功 能维护等服务。 停止功能维护日期 在该日期之后，不再维护功能，修复问题。但依旧提供安全修复等服务 停止安全维护日期 在该日期之后，不再发布补丁版本修复中高风险漏洞，仅提供有限的支持。 产品服务终止日期 停止提供产品服务和支持的日期。包括软件维护版本，缺陷修复，以及针对该产品的 所有服务支持（包括服务热线和远程/现场支持）。 服务周期策略 金仓数据库管理系统 KingbaseES 产品确保以下的服务周期： 1）产品自发布之日起至产品停止功能升级（包含新特性、新硬件支持）之日不少于 5 年。 2）产品停止功能升级之日起至产品停止功能维护（主要包括问题修复）之日不少于 4 年。 3）产品功能维护停止之日起至产品停止安全维护（包括中高风险漏洞修复）之日不少于 2 年。 服务终止策略 金仓数据库管理系统 KingbaseES 产品确保在销售后，至少提供 6 年的服务支持。 注意: 人大金仓将会综合各方因素来确定产品服务终止日期。并将在实际产品服务终止日期之前至少 90 天，通过公 602 服务周期承诺 开方式宣布产品服务终止日期。 603