控制结构可能是PL/pgSQL中最有用的(以及最重要)的部分了。利用PL/pgSQL的控制结构,你可以以非常灵活而且强大的方法操纵PostgreSQL的数据。
有两个命令让我们能够从函数中返回数据:RETURN
和RETURN NEXT
。
RETURN
RETURN expression
;
带有一个表达式的RETURN
用于终止函数并把expression
的值返回给调用者。这种形式被用于不返回集合的PL/pgSQL函数。
如果一个函数返回一个标量类型,表达式的结果将被自动转换成函数的返回类型。但是要返回一个复合(行)值,你必须写一个正好产生所需列集合的表达式。这可能需要使用显式造型。
如果你声明带输出参数的函数,那么就只需要写不带表达式的RETURN
。输出参数变量的当前值将被返回。
如果你声明函数返回void
,一个RETURN
语句可以被用来提前退出函数;但是不要在RETURN
后面写一个表达式。
一个函数的返回值不能是未定义。如果控制到达了函数最顶层的块而没有碰到一个RETURN
语句,那么会发生一个运行时错误。不过,这个限制不适用于带输出参数的函数以及返回void
的函数。在这些情况中,如果顶层的块结束,将自动执行一个RETURN
语句。
一些例子:
-- 返回一个标量类型的函数 RETURN 1 + 2; RETURN scalar_var; -- 返回一个组合类型的函数 RETURN composite_type_var; RETURN (1, 2, 'three'::text); -- 必须把列造型成正确的类型
RETURN NEXT
以及RETURN QUERY
RETURN NEXTexpression
; RETURN QUERYquery
; RETURN QUERY EXECUTEcommand-string
[ USINGexpression
[, ... ] ];
当一个PL/pgSQL函数被声明为返回SETOF
,那么遵循的过程则略有不同。在这种情况下,要返回的个体项被用一个sometype
RETURN NEXT
或者RETURN QUERY
命令的序列指定,并且接着会用一个不带参数的最终RETURN
命令来指示这个函数已经完成执行。RETURN NEXT
可以被用于标量和复合数据类型;对于复合类型,将返回一个完整的结果“表”。RETURN QUERY
将执行一个查询的结果追加到一个函数的结果集中。在一个单一的返回集合的函数中,RETURN NEXT
和RETURN QUERY
可以被随意地混合,这样它们的结果将被串接起来。
RETURN NEXT
和RETURN QUERY
实际上不会从函数中返回 — 它们简单地向函数的结果集中追加零或多行。然后会继续执行PL/pgSQL函数中的下一条语句。随着后继的RETURN NEXT
和RETURN QUERY
命令的执行,结果集就建立起来了。最后一个RETURN
(应该没有参数)会导致控制退出该函数(或者你可以让控制到达函数的结尾)。
RETURN QUERY
有一种变体RETURN QUERY EXECUTE
,它可以动态指定要被执行的查询。可以通过USING
向计算出的查询字符串插入参数表达式,这和在EXECUTE
命令中的方式相同。
如果你声明函数带有输出参数,只需要写不带表达式的RETURN NEXT
。在每一次执行时,输出参数变量的当前值将被保存下来用于最终返回为结果的一行。注意为了创建一个带有输出参数的集合返回函数,在有多个输出参数时,你必须声明函数为返回SETOF record
;或者如果只有一个类型为sometype
的输出参数时,声明函数为SETOF
。
sometype
下面是一个使用RETURN NEXT
的函数例子:
CREATE TABLE foo (fooid INT, foosubid INT, fooname TEXT); INSERT INTO foo VALUES (1, 2, 'three'); INSERT INTO foo VALUES (4, 5, 'six'); CREATE OR REPLACE FUNCTION get_all_foo() RETURNS SETOF foo AS $BODY$ DECLARE r foo%rowtype; BEGIN FOR r IN SELECT * FROM foo WHERE fooid > 0 LOOP -- 这里可以做一些处理 RETURN NEXT r; -- 返回 SELECT 的当前行 END LOOP; RETURN; END $BODY$ LANGUAGE plpgsql; SELECT * FROM get_all_foo();
这里是一个使用RETURN QUERY
的函数的例子:
CREATE FUNCTION get_available_flightid(date) RETURNS SETOF integer AS $BODY$ 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 $BODY$ LANGUAGE plpgsql; -- 返回可用的航班或者在没有可用航班时抛出异常。 SELECT * FROM get_available_flightid(CURRENT_DATE);
如上所述,目前RETURN NEXT
和RETURN QUERY
的实现在从函数返回之前会把整个结果集都保存起来。这意味着如果一个PL/pgSQL函数生成一个非常大的结果集,性能可能会很差:数据将被写到磁盘上以避免内存耗尽,但是函数本身在整个结果集都生成之前不会退出。将来的PL/pgSQL版本可能会允许用户定义没有这种限制的集合返回函数。目前,数据开始被写入到磁盘的时机由配置变量work_mem控制。拥有足够内存来存储大型结果集的管理员可以考虑增大这个参数。
IF
和CASE
语句让你可以根据某种条件执行二选其一的命令。PL/pgSQL有三种形式的IF
:
IF ... THEN ... END IF
IF ... THEN ... ELSE ... END IF
IF ... THEN ... ELSIF ... THEN ... ELSE ... END IF
以及两种形式的CASE
:
CASE ... WHEN ... THEN ... ELSE ... END CASE
CASE WHEN ... THEN ... ELSE ... END CASE
IF-THEN
IFboolean-expression
THENstatements
END IF;
IF-THEN
语句是IF
的最简单形式。 如果条件为真,在THEN
和END IF
之间的语句将被执行。否则,将忽略它们。
例子:
IF v_user_id <> 0 THEN UPDATE users SET email = v_email WHERE user_id = v_user_id; END IF;
IF-THEN-ELSE
IFboolean-expression
THENstatements
ELSEstatements
END IF;
IF-THEN-ELSE
语句对IF-THEN
进行了增加,它让你能够指定一组在条件不为真时应该被执行的语句(注意这也包括条件为 NULL 的情况)。
例子:
IF parentid IS NULL OR parentid = '' THEN RETURN fullname; ELSE RETURN hp_true_filename(parentid) || '/' || fullname; END IF;
IF v_count > 0 THEN INSERT INTO users_count (count) VALUES (v_count); RETURN 't'; ELSE RETURN 'f'; END IF;
IF-THEN-ELSIF
IFboolean-expression
THENstatements
[ ELSIFboolean-expression
THENstatements
[ ELSIFboolean-expression
THENstatements
...]] [ ELSEstatements
] END IF;
有时会有多于两种选择。IF-THEN-ELSIF
则提供了一个简便的方法来检查多个条件。IF
条件会被一个接一个测试,直到找到第一个为真的。然后执行相关语句,然后控制会被交给END IF
之后的下一个语句(后续的任何IF
条件不会被测试)。如果没有一个IF
条件为真,那么ELSE
块(如果有)将被执行。
这里有一个例子:
IF number = 0 THEN result := 'zero'; ELSIF number > 0 THEN result := 'positive'; ELSIF number < 0 THEN result := 'negative'; ELSE -- 嗯,唯一的其他可能性是数字为空 result := 'NULL'; END IF;
关键词ELSIF
也可以被拼写成ELSEIF
。
另一个可以完成相同任务的方法是嵌套IF-THEN-ELSE
语句,如下例:
IF demo_row.sex = 'm' THEN pretty_sex := 'man'; ELSE IF demo_row.sex = 'f' THEN pretty_sex := 'woman'; END IF; END IF;
不过,这种方法需要为每个IF
都写一个匹配的END IF
,因此当有很多选择时,这种方法比使用ELSIF
要麻烦得多。
CASE
CASEsearch-expression
WHENexpression
[,expression
[ ... ]] THENstatements
[ WHENexpression
[,expression
[ ... ]] THENstatements
... ] [ ELSEstatements
] END CASE;
CASE
的简单形式提供了基于操作数等值判断的有条件执行。search-expression
会被计算(一次)并且一个接一个地与WHEN
子句中的每个expression
比较。如果找到一个匹配,那么相应的statements
会被执行,并且接着控制会被交给END CASE
之后的下一个语句(后续的WHEN
表达式不会被计算)。如果没有找到匹配,ELSE
语句
会被执行。但是如果ELSE
不存在,将会抛出一个CASE_NOT_FOUND
异常。
这里是一个简单的例子:
CASE x WHEN 1, 2 THEN msg := 'one or two'; ELSE msg := 'other value than one or two'; END CASE;
CASE
CASE WHENboolean-expression
THENstatements
[ WHENboolean-expression
THENstatements
... ] [ ELSEstatements
] END CASE;
CASE
的搜索形式基于布尔表达式真假的有条件执行。每一个WHEN
子句的boolean-expression
会被依次计算,直到找到一个得到真
的。然后相应的statements
会被执行,并且接下来控制会被传递给END CASE
之后的下一个语句(后续的WHEN
表达式不会被计算)。如果没有找到为真的结果,ELSE
statements
会被执行。但是如果ELSE
不存在,那么将会抛出一个CASE_NOT_FOUND
异常。
这里是一个例子:
CASE WHEN x BETWEEN 0 AND 10 THEN msg := 'value is between zero and ten'; WHEN x BETWEEN 11 AND 20 THEN msg := 'value is between eleven and twenty'; END CASE;
这种形式的CASE
整体上等价于IF-THEN-ELSIF
,不同之处在于CASE
到达一个被忽略的ELSE
子句时会导致一个错误而不是什么也不做。
使用LOOP
、EXIT
、CONTINUE
、WHILE
、FOR
和FOREACH
语句,你可以安排PL/pgSQL重复一系列命令。
LOOP
[ <<label
>> ] LOOPstatements
END LOOP [label
];
LOOP
定义一个无条件的循环,它会无限重复直到被EXIT
或RETURN
语句终止。可选的label
可以被EXIT
和CONTINUE
语句用在嵌套循环中指定这些语句引用的是哪一层循环。
EXIT
EXIT [label
] [ WHENboolean-expression
];
如果没有给出label
,那么最内层的循环会被终止,然后跟在END LOOP
后面的语句会被执行。如果给出了label
,那么它必须是当前或者更高层的嵌套循环或者语句块的标签。然后该命名循环或块就会被终止,并且控制会转移到该循环/块相应的END
之后的语句上。
如果指定了WHEN
,只有boolean-expression
为真时才会发生循环退出。否则,控制会转移到EXIT
之后的语句。
EXIT
可以被用在所有类型的循环中,它并不限于在无条件循环中使用。
在和BEGIN
块一起使用时,EXIT
会把控制交给块结束后的下一个语句。需要注意的是,一个标签必须被用于这个目的;一个没有被标记的EXIT
永远无法被认为与一个BEGIN
块匹配(这种状况从PostgreSQL 8.4 之前的发布就已经开始改变。这可能允许一个未被标记的EXIT
匹配一个BEGIN
块)。
例子:
LOOP -- 一些计算 IF count > 0 THEN EXIT; -- 退出循环 END IF; END LOOP; LOOP -- 一些计算 EXIT WHEN count > 0; -- 和前一个例子相同的结果 END LOOP; <<ablock>> BEGIN -- 一些计算 IF stocks > 100000 THEN EXIT ablock; -- 导致从 BEGIN 块中退出 END IF; -- 当stocks > 100000时,这里的计算将被跳过 END;
CONTINUE
CONTINUE [label
] [ WHENboolean-expression
];
如果没有给出label
,最内层循环的下一次迭代会开始。也就是,循环体中剩余的所有语句将被跳过,并且控制会返回到循环控制表达式(如果有)来决定是否需要另一次循环迭代。如果label
存在,它指定应该继续执行的循环的标签。
如果指定了WHEN
,该循环的下一次迭代只有在boolean-expression
为真时才会开始。否则,控制会传递给CONTINUE
后面的语句。
CONTINUE
可以被用在所有类型的循环中,它并不限于在无条件循环中使用。
例子:
LOOP -- 一些计算 EXIT WHEN count > 100; CONTINUE WHEN count < 50; -- 一些用于 count IN [50 .. 100] 的计算 END LOOP;
WHILE
[ <<label
>> ] WHILEboolean-expression
LOOPstatements
END LOOP [label
];
只要boolean-expression
被计算为真,WHILE
语句就会重复一个语句序列。在每次进入到循环体之前都会检查该表达式。
例如:
WHILE amount_owed > 0 AND gift_certificate_balance > 0 LOOP -- 这里是一些计算 END LOOP; WHILE NOT done LOOP -- 这里是一些计算 END LOOP;
FOR
(整型变体)[ <<label
>> ] FORname
IN [ REVERSE ]expression
..expression
[ BYexpression
] LOOPstatements
END LOOP [label
];
这种形式的FOR
会创建一个在一个整数范围上迭代的循环。变量name
会自动定义为类型integer
并且只在循环内存在(任何该变量名的现有定义在此循环内都将被忽略)。给出范围上下界的两个表达式在进入循环的时候计算一次。如果没有指定BY
子句,迭代步长为 1,否则步长是BY
中指定的值,该值也只在循环进入时计算一次。如果指定了REVERSE
,那么在每次迭代后步长值会被减除而不是增加。
整数FOR
循环的一些例子:
FOR i IN 1..10 LOOP -- 我在循环中将取值 1,2,3,4,5,6,7,8,9,10 END LOOP; FOR i IN REVERSE 10..1 LOOP -- 我在循环中将取值 10,9,8,7,6,5,4,3,2,1 END LOOP; FOR i IN REVERSE 10..1 BY 2 LOOP -- 我在循环中将取值 10,8,6,4,2 END LOOP;
如果下界大于上界(或者在REVERSE
情况下是小于),循环体根本不会被执行。而且不会抛出任何错误。
如果一个label
被附加到FOR
循环,那么整数循环变量可以用一个使用那个label
的限定名引用。
使用一种不同类型的FOR
循环,你可以通过一个查询的结果进行迭代并且操纵相应的数据。语法是:
[ <<label
>> ] FORtarget
INquery
LOOPstatements
END LOOP [label
];
target
是一个记录变量、行变量或者逗号分隔的标量变量列表。target
被连续不断被赋予来自query
的每一行,并且循环体将为每一行执行一次。下面是一个例子:
CREATE FUNCTION cs_refresh_mviews() RETURNS integer AS $$ DECLARE mviews RECORD; BEGIN RAISE NOTICE 'Refreshing materialized views...'; FOR mviews IN SELECT * FROM cs_materialized_views ORDER BY sort_key LOOP -- 现在 "mviews" 有一个来自于 cs_materialized_views 的记录 RAISE NOTICE 'Refreshing materialized view %s ...', quote_ident(mviews.mv_name); EXECUTE format('TRUNCATE TABLE %I', mviews.mv_name); EXECUTE format('INSERT INTO %I %s', mviews.mv_name, mviews.mv_query); END LOOP; RAISE NOTICE 'Done refreshing materialized views.'; RETURN 1; END; $$ LANGUAGE plpgsql;
如果循环被一个EXIT
语句终止,那么在循环之后你仍然可以访问最后被赋予的行值。
在这类FOR
语句中使用的query
可以是任何返回行给调用者的 SQL 命令:最常见的是SELECT
,但你也可以使用带有RETURNING
子句的INSERT
、UPDATE
或DELETE
。一些EXPLAIN
之类的功能性命令也可以用在这里。
PL/pgSQL变量会被替换到查询文本中,并且如第 42.10.1 节和第 42.10.2 节中详细讨论的,查询计划会被缓存以用于可能的重用。
FOR-IN-EXECUTE
语句是在行上迭代的另一种方式:
[ <<label
>> ] FORtarget
IN EXECUTEtext_expression
[ USINGexpression
[, ... ] ] LOOPstatements
END LOOP [label
];
这个例子类似前面的形式,只不过源查询被指定为一个字符串表达式,在每次进入FOR
循环时都会计算它并且重新规划。这允许程序员在一个预先规划好了的命令的速度和一个动态命令的灵活性之间进行选择,就像一个纯EXECUTE
语句那样。在使用EXECUTE
时,可以通过USING
将参数值插入到动态命令中。
另一种指定要对其结果迭代的查询的方式是将它声明为一个游标。这会在第 42.7.4 节中描述。
FOREACH
循环很像一个FOR
循环,但不是通过一个 SQL 查询返回的行进行迭代,它通过一个数组值的元素来迭代(通常,FOREACH
意味着通过一个组合值表达式的部件迭代;用于通过除数组之外组合类型进行循环的变体可能会在未来被加入)。在一个数组上循环的FOREACH
语句是:
[ <<label
>> ] FOREACHtarget
[ SLICEnumber
] IN ARRAYexpression
LOOPstatements
END LOOP [label
];
如果没有SLICE
,或者如果没有指定SLICE 0
,循环会通过计算expression
得到的数组的个体元素进行迭代。target
变量被逐一赋予每一个元素值,并且循环体会为每一个元素执行。这里是一个通过整数数组的元素循环的例子:
CREATE 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; $$ LANGUAGE plpgsql;
元素会被按照存储顺序访问,而不管数组的维度数。尽管target
通常只是一个单一变量,当通过一个组合值(记录)的数组循环时,它可以是一个变量列表。在那种情况下,对每一个数组元素,变量会被从组合值的连续列赋值。
通过一个正SLICE
值,FOREACH
通过数组的切片而不是单一元素迭代。SLICE
值必须是一个不大于数组维度数的整数常量。target
变量必须是一个数组,并且它接收数组值的连续切片,其中每一个切片都有SLICE
指定的维度数。这里是一个通过一维切片迭代的例子:
CREATE 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; $$ LANGUAGE plpgsql; 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}
默认情况下,任何在PL/pgSQL函数中发生的错误会中止该函数的执行,而且实际上会中止其周围的事务。你可以使用一个带有EXCEPTION
子句的BEGIN
块俘获错误并且从中恢复。其语法是BEGIN
块通常的语法的一个扩展:
[ <<label
>> ] [ DECLAREdeclarations
] BEGINstatements
EXCEPTION WHENcondition
[ ORcondition
... ] THENhandler_statements
[ WHENcondition
[ ORcondition
... ] THENhandler_statements
... ] END;
如果没有发生错误,这种形式的块只是简单地执行所有statements
, 并且接着控制转到END
之后的下一个语句。但是如果在statements
内发生了一个错误,则会放弃对statements
的进一步处理,然后控制会转到EXCEPTION
列表。系统会在列表中寻找匹配所发生错误的第一个condition
。如果找到一个匹配,则执行对应的handler_statements
,并且接着把控制转到END
之后的下一个语句。如果没有找到匹配,该错误就会传播出去,就好像根本没有EXCEPTION
一样:错误可以被一个带有EXCEPTION
的闭合块捕捉,如果没有EXCEPTION
则中止该函数的处理。
condition
的名字可以是附录 A中显示的任何名字。一个分类名匹配其中所有的错误。特殊的条件名OTHERS
匹配除了QUERY_CANCELED
和ASSERT_FAILURE
之外的所有错误类型(虽然通常并不明智,还是可以用名字捕获这两种错误类型)。条件名是大小写无关的。一个错误条件也可以通过SQLSTATE
代码指定,例如以下是等价的:
WHEN division_by_zero THEN ... WHEN SQLSTATE '22012' THEN ...
如果在选中的handler_statements
内发生了新的错误,那么它不能被这个EXCEPTION
子句捕获,而是被传播出去。一个外层的EXCEPTION
子句可以捕获它。
当一个错误被EXCEPTION
捕获时,PL/pgSQL函数的局部变量会保持错误发生时的值,但是该块中所有对持久数据库状态的改变都会被回滚。例如,考虑这个片段:
INSERT INTO mytab(firstname, lastname) VALUES('Tom', 'Jones'); BEGIN UPDATE mytab SET firstname = 'Joe' WHERE lastname = 'Jones'; x := x + 1; y := x / 0; EXCEPTION WHEN division_by_zero THEN RAISE NOTICE 'caught division_by_zero'; RETURN x; END;
当控制到达对y
赋值的地方时,它会带着一个division_by_zero
错误失败。这个错误将被EXCEPTION
子句捕获。而在RETURN
语句中返回的值将是x
增加过后的值。但是UPDATE
命令的效果将已经被回滚。不过,在该块之前的INSERT
将不会被回滚,因此最终的结果是数据库包含Tom Jones
但不包含Joe Jones
。
进入和退出一个包含EXCEPTION
子句的块要比不包含EXCEPTION
的块开销大的多。因此,只在必要的时候使用EXCEPTION
。
例 42.2. UPDATE
/INSERT
的异常
这个例子使用异常处理来酌情执行UPDATE
或
INSERT
。我们推荐应用使用带有
ON CONFLICT DO UPDATE
的INSERT
而不是真正使用这种模式。下面的例子主要是为了展示
PL/pgSQL如何控制流程:
CREATE TABLE db (a INT PRIMARY KEY, b TEXT); CREATE FUNCTION merge_db(key INT, data TEXT) RETURNS VOID AS $$ BEGIN LOOP -- 首先尝试更新见 UPDATE db SET b = data WHERE a = key; IF found THEN RETURN; END IF; -- 不在这里,那么尝试插入该键 -- 如果其他某人并发地插入同一个键, -- 我们可能得到一个唯一键失败 BEGIN INSERT INTO db(a,b) VALUES (key, data); RETURN; EXCEPTION WHEN unique_violation THEN -- 什么也不做,并且循环再次尝试 UPDATE END; END LOOP; END; $$ LANGUAGE plpgsql; SELECT merge_db(1, 'david'); SELECT merge_db(1, 'dennis');
这段代码假定unique_violation
错误是INSERT
造成,并且不是由该表上一个触发器函数中的INSERT
导致。如果在该表上有多于一个唯一索引,也可能会发生不正确的行为,因为不管哪个索引导致该错误它都将重试该操作。通过接下来要讨论的特性来检查被捕获的错误是否为所预期的会更安全。
异常处理器经常被用来标识发生的特定错误。有两种方法来得到PL/pgSQL中当前异常的信息:特殊变量和GET STACKED DIAGNOSTICS
命令。
在一个异常处理器内,特殊变量SQLSTATE
包含了对应于被抛出异常的错误代码(可能的错误代码列表见表 A.1)。特殊变量SQLERRM
包含与该异常相关的错误消息。这些变量在异常处理器外是未定义的。
在一个异常处理器内,我们也可以用GET STACKED DIAGNOSTICS
命令检索有关当前异常的信息,该命令的形式为:
GET STACKED DIAGNOSTICSvariable
{ = | := }item
[ , ... ];
每个item
是一个关键词,它标识一个被赋予给指定变量
(应该具有接收该值的正确数据类型)的状态值。表 42.2中显示了当前可用的状态项。
表 42.2. 错误诊断项
名称 | 类型 | 描述 |
---|---|---|
RETURNED_SQLSTATE | text | 该异常的 SQLSTATE 错误代码 |
COLUMN_NAME | text | 与异常相关的列名 |
CONSTRAINT_NAME | text | 与异常相关的约束名 |
PG_DATATYPE_NAME | text | 与异常相关的数据类型名 |
MESSAGE_TEXT | text | 该异常的主要消息的文本 |
TABLE_NAME | text | 与异常相关的表名 |
SCHEMA_NAME | text | 与异常相关的模式名 |
PG_EXCEPTION_DETAIL | text | 该异常的详细消息文本(如果有) |
PG_EXCEPTION_HINT | text | 该异常的提示消息文本(如果有) |
PG_EXCEPTION_CONTEXT | text | 描述产生异常时调用栈的文本行(见第 42.6.7 节) |
如果异常没有为一个项设置值,将返回一个空字符串。
这里是一个例子:
DECLARE text_var1 text; text_var2 text; text_var3 text; BEGIN -- 某些可能导致异常的处理 ... EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS text_var1 = MESSAGE_TEXT, text_var2 = PG_EXCEPTION_DETAIL, text_var3 = PG_EXCEPTION_HINT; END;
GET DIAGNOSTICS
(之前在第 42.5.5 节中描述)命令检索有关当前执行状态的信息(反之上文讨论的GET STACKED DIAGNOSTICS
命令会把有关执行状态的信息报告成一个以前的错误)。它的PG_CONTEXT
状态项可用于标识当前执行位置。状态项PG_CONTEXT
将返回一个文本字符串,其中有描述该调用栈的多行文本。第一行会指向当前函数以及当前正在执行GET DIAGNOSTICS
的命令。第二行及其后的行表示调用栈中更上层的调用函数。例如:
CREATE OR REPLACE FUNCTION outer_func() RETURNS integer AS $$ BEGIN RETURN inner_func(); END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION inner_func() RETURNS integer AS $$ DECLARE stack text; BEGIN GET DIAGNOSTICS stack = PG_CONTEXT; RAISE NOTICE E'--- Call Stack ---\n%', stack; RETURN 1; END; $$ LANGUAGE plpgsql; SELECT outer_func(); NOTICE: --- Call Stack --- PL/pgSQL function inner_func() line 5 at GET DIAGNOSTICS PL/pgSQL function outer_func() line 3 at RETURN CONTEXT: PL/pgSQL function outer_func() line 3 at RETURN outer_func ------------ 1 (1 row)
GET STACKED DIAGNOSTICS ... PG_EXCEPTION_CONTEXT
返回同类的栈跟踪,但是它描述检测到错误的位置而不是当前位置。