匿名块支持自治事务 自治事务可以在匿名块中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建匿名块语法相同，请参见匿名块，示例如下。 gaussdb=# CREATE TABLE t1(a INT ,B TEXT); CREATE TABLE gaussdb=# START TRANSACTION; START TRANSACTION gaussdb=# DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN DBE_OUTPUT.PRINT_LINE('JUST USE CALL.'); INSERT INTO t1 VALUES(1,'YOU ARE SO CUTE,WILL COMMIT!'); END; / JUST USE CALL. ANONYMOUS BLOCK EXECUTE gaussdb=# INSERT INTO t1 VALUES(1,'YOU WILL ROLLBACK!'); INSERT 0 1 gaussdb=# ROLLBACK; ROLLBACK gaussdb=# SELECT * FROM t1; a | b ---+------------------------------ 1 | YOU ARE SO CUTE,WILL COMMIT! (1 row) gaussdb=# DROP TABLE t1; DROP TABLE 上述例子，最后在回滚的事务块前执行包含自治事务的匿名块，直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

函数支持自治事务 自治事务可以在函数中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与函数语法相同，请参见CREATE FUNCTION示例如下。 gaussdb=# CREATE TABLE t4(a INT, b INT, c TEXT); CREATE TABLE gaussdb=# CREATE OR REPLACE FUNCTION autonomous_32(a INT ,b INT ,c TEXT) RETURN INT AS DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t4 VALUES(a, b, c); RETURN 1; END; / CREATE FUNCTION gaussdb=# CREATE OR REPLACE FUNCTION autonomous_33(num1 INT) RETURN INT AS DECLARE num3 INT := 220; tmp INT; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN num3 := num3/num1; RETURN num3; EXCEPTION WHEN DIVISION_BY_ZERO THEN SELECT autonomous_32(num3, num1, SQLERRM) INTO tmp; ROLLBACK; RETURN 0; END; / CREATE FUNCTION gaussdb=# SELECT autonomous_33(0); autonomous_33 --------------- 0 (1 row) gaussdb=# SELECT * FROM t4; a | b | c -----+---+------------------ 220 | 0 | division by zero (1 row) gaussdb=# DROP TABLE t4; DROP TABLE gaussdb=# DROP FUNCTION autonomous_32; DROP FUNCTION gaussdb=# DROP FUNCTION autonomous_33; DROP FUNCTION 上述例子，最后在回滚的事务块中执行包含自治事务的函数，也能直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

存储过程支持自治事务 自治事务可以在存储过程中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建存储过程语法相同，请参见CREATE PROCEDURE，示例如下。 --建表 gaussdb=# CREATE TABLE t2(a INT, b INT); CREATE TABLE gaussdb=# INSERT INTO t2 VALUES(1,2); INSERT 0 1 gaussdb=# SELECT * FROM t2; a | b ---+--- 1 | 2 (1 row) --创建包含自治事务的存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_4(a INT, b INT) AS DECLARE num3 INT := a; num4 INT := b; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t2 VALUES(num3, num4); DBE_OUTPUT.PRINT_LINE('JUST USE CALL.'); END; / CREATE PROCEDURE --创建调用自治事务存储过程的普通存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_5(a INT, b INT) AS DECLARE BEGIN DBE_OUTPUT.PRINT_LINE('JUST NO USE CALL.'); INSERT INTO t2 VALUES(666, 666); autonomous_4(a,b); ROLLBACK; END; / CREATE PROCEDURE --调用普通存储过程 gaussdb=# SELECT autonomous_5(11,22); JUST NO USE CALL. JUST USE CALL. autonomous_5 -------------- (1 row) --查看表结果 gaussdb=# SELECT * FROM t2 ORDER BY a; a | b ----+---- 1 | 2 11 | 22 (2 rows) gaussdb=# DROP TABLE t2; DROP TABLE gaussdb=# DROP PROCEDURE autonomous_4; DROP PROCEDURE gaussdb=# DROP PROCEDURE autonomous_5; DROP PROCEDURE 上述例子，最后在回滚的事务块中执行包含自治事务的存储过程，直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

Package支持自治事务 自治事务可以在package中的存储过程或者函数中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建package中存储过程或函数语法相同，请参见CREATE PACKAGE，示例如下。 --建表 gaussdb=# CREATE TABLE t2(a INT, b INT); CREATE TABLE gaussdb=# INSERT INTO t2 VALUES(1,2); INSERT 0 1 gaussdb=# SELECT * FROM t2; a | b ---+--- 1 | 2 (1 row) --创建包含自治事务的PACKAGE中的存储过程和函数 gaussdb=# CREATE OR REPLACE PACKAGE autonomous_pkg AS PROCEDURE autonomous_4(a INT, b INT); FUNCTION autonomous_32(a INT ,b INT) RETURN INT; END autonomous_pkg; / CREATE PACKAGE gaussdb=# CREATE OR REPLACE PACKAGE BODY autonomous_pkg AS PROCEDURE autonomous_4(a INT, b INT) AS DECLARE num3 INT := a; num4 INT := b; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t2 VALUES(num3, num4); END; FUNCTION autonomous_32(a INT ,b INT) RETURN INT AS DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t2 VALUES(a, b); RETURN 1; END; END autonomous_pkg; / CREATE PACKAGE BODY --创建调用PACKAGE自治事务存储过程和函数的普通存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_5(a INT, b INT) AS DECLARE va INT; BEGIN INSERT INTO t2 VALUES(666, 666); autonomous_pkg.autonomous_4(a,b); va := autonomous_pkg.autonomous_32(a + 1, b + 1); ROLLBACK; END; / CREATE PROCEDURE --调用普通存储过程 gaussdb=# SELECT autonomous_5(11,22); autonomous_5 -------------- (1 row) --查看表结果 gaussdb=# SELECT * FROM t2 ORDER BY a; a | b ----+---- 1 | 2 11 | 22 12 | 23 (3 rows) gaussdb=# DROP TABLE t2; DROP TABLE 上述例子，最后在回滚的事务块中执行包含package自治事务的存储过程和函数，直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

匿名块支持自治事务 自治事务可以在匿名块中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建匿名块语法相同，请参见匿名块。 gaussdb=# CREATE TABLE t1(a INT ,B TEXT); NOTICE: The 'DISTRIBUTE BY' clause is not specified. Using 'a' as the distribution column by default. HINT: Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column. CREATE TABLE gaussdb=# START TRANSACTION; START TRANSACTION gaussdb=# DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN DBE_OUTPUT.PRINT_LINE('JUST USE CALL.'); INSERT INTO t1 VALUES(1,'YOU ARE SO CUTE,WILL COMMIT!'); END; / JUST USE CALL. ANONYMOUS BLOCK EXECUTE gaussdb=# INSERT INTO t1 VALUES(1,'YOU WILL ROLLBACK!'); INSERT 0 1 gaussdb=# ROLLBACK; ROLLBACK gaussdb=# SELECT * FROM t1; a | b ---+------------------------------ 1 | YOU ARE SO CUTE,WILL COMMIT! (1 row) gaussdb=# DROP TABLE t1; DROP TABLE 上述例子，最后在回滚的事务块前执行包含自治事务的匿名块，直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

存储过程支持自治事务 自治事务可以在存储过程中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建存储过程语法相同，请参见CREATE PROCEDURE，示例如下。 --建表 gaussdb=# CREATE TABLE t2(a INT, b INT); NOTICE: The 'DISTRIBUTE BY' clause is not specified. Using 'a' as the distribution column by default. HINT: Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column. CREATE TABLE gaussdb=# INSERT INTO t2 VALUES(1,2); INSERT 0 1 gaussdb=# SELECT * FROM t2; a | b ---+--- 1 | 2 (1 row) --创建包含自治事务的存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_4(a INT, b INT) AS DECLARE num3 INT := a; num4 INT := b; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t2 VALUES(num3, num4); DBE_OUTPUT.PRINT_LINE('JUST USE CALL.'); END; / CREATE PROCEDURE --创建调用自治事务存储过程的普通存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_5(a INT, b INT) AS DECLARE BEGIN DBE_OUTPUT.PRINT_LINE('JUST NO USE CALL.'); INSERT INTO t2 VALUES(666, 666); autonomous_4(a,b); ROLLBACK; END; / CREATE PROCEDURE --调用普通存储过程 gaussdb=# SELECT autonomous_5(11,22); JUST NO USE CALL. JUST USE CALL. autonomous_5 -------------- (1 row) --查看表结果 gaussdb=# SELECT * FROM t2 ORDER BY a; a | b ----+---- 1 | 2 11 | 22 (2 rows) gaussdb=# DROP TABLE t2; DROP TABLE 上述例子，最后在回滚的事务块中执行包含自治事务的存储过程，直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

函数支持自治事务 自治事务可以在函数中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与函数语法相同，请参见CREATE FUNCTION。 gaussdb=# CREATE TABLE t4(a INT, b INT, c TEXT); NOTICE: The 'DISTRIBUTE BY' clause is not specified. Using 'a' as the distribution column by default. HINT: Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column. CREATE TABLE gaussdb=# CREATE OR REPLACE FUNCTION autonomous_32(a INT ,b INT ,c TEXT) RETURN INT AS DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t4 VALUES(a, b, c); RETURN 1; END; / CREATE FUNCTION gaussdb=# CREATE OR REPLACE FUNCTION autonomous_33(num1 INT) RETURN INT AS DECLARE num3 INT := 220; tmp INT; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN num3 := num3/num1; RETURN num3; EXCEPTION WHEN DIVISION_BY_ZERO THEN SELECT autonomous_32(num3, num1, SQLERRM) INTO tmp; ROLLBACK; RETURN 0; END; / CREATE FUNCTION gaussdb=# SELECT autonomous_33(0); autonomous_33 --------------- 0 (1 row) gaussdb=# SELECT * FROM t4; a | b | c -----+---+------------------ 220 | 0 | division by zero (1 row) gaussdb=# DROP TABLE t4; DROP TABLE 上述例子，最后在回滚的事务块中执行包含自治事务的函数，也能直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

PACKAGE支持自治事务 自治事务可以在package中的存储过程或者函数中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建package中存储过程或函数语法相同，请参见CREATE PACKAGE。 gaussdb=# create database test DBCOMPATIBILITY = 'ORA'; CREATE DATABASE test=# \c test --建表 test=# CREATE TABLE t2(a INT, b INT); NOTICE: The 'DISTRIBUTE BY' clause is not specified. Using 'a' as the distribution column by default. HINT: Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column. CREATE TABLE test=# INSERT INTO t2 VALUES(1,2); INSERT 0 1 test=# SELECT * FROM t2; a | b ---+--- 1 | 2 (1 row) --创建包含自治事务的PACKAGE中的存储过程和函数 test=# CREATE OR REPLACE PACKAGE autonomous_pkg AS PROCEDURE autonomous_4(a INT, b INT); FUNCTION autonomous_32(a INT ,b INT) RETURN INT; END autonomous_pkg; / CREATE PACKAGE test=# CREATE OR REPLACE PACKAGE BODY autonomous_pkg AS PROCEDURE autonomous_4(a INT, b INT) AS DECLARE num3 INT := a; num4 INT := b; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t2 VALUES(num3, num4); END; FUNCTION autonomous_32(a INT ,b INT) RETURN INT AS DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO t2 VALUES(a, b); RETURN 1; END; END autonomous_pkg; / CREATE PACKAGE BODY --创建调用PACKAGE自治事务存储过程和函数的普通存储过程 test=# CREATE OR REPLACE PROCEDURE autonomous_5(a INT, b INT) AS DECLARE va INT; BEGIN INSERT INTO t2 VALUES(666, 666); autonomous_pkg.autonomous_4(a,b); va := autonomous_pkg.autonomous_32(a + 1, b + 1); ROLLBACK; END; / CREATE PROCEDURE --调用普通存储过程 test=# SELECT autonomous_5(11,22); autonomous_5 -------------- (1 row) --查看表结果 test=# SELECT * FROM t2 ORDER BY a; a | b ----+---- 1 | 2 11 | 22 12 | 23 (3 rows) test=# DROP TABLE t2; DROP TABLE 上述例子，最后在回滚的事务块中执行包含PACKAGE自治事务的存储过程和函数，直接说明了自治事务的特性，即主事务的回滚不会影响自治事务已经提交的内容。 父主题： 自治事务

匿名块支持自治事务 自治事务可以在匿名块中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建匿名块语法相同，示例如下。 gaussdb=# create table t1(a int ,b text); NOTICE: The 'DISTRIBUTE BY' clause is not specified. Using 'a' as the distribution column by default. HINT: Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column. CREATE TABLE gaussdb=# START TRANSACTION; START TRANSACTION gaussdb=# DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN dbe_output.print_line('just use call.'); insert into t1 values(1,'you are so cute,will commit!'); END; / just use call. ANONYMOUS BLOCK EXECUTE gaussdb=# insert into t1 values(1,'you will rollback!'); INSERT 0 1 gaussdb=# rollback; ROLLBACK gaussdb=# select * from t1; a | b ---+------------------------------ 1 | you are so cute,will commit! (1 row) 上述例子，最后在回滚的事务块前执行包含自治事务的匿名块，也能直接说明了自治事务的特性，即主事务的回滚，不会影响自治事务已经提交的内容。 父主题： 自治事务

函数支持自治事务 自治事务可以在函数中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与函数语法相同，示例如下。 gaussdb=# create table t4(a int, b int, c text); NOTICE: The 'DISTRIBUTE BY' clause is not specified. Using 'a' as the distribution column by default. HINT: Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column. CREATE TABLE gaussdb=# CREATE OR REPLACE function autonomous_32(a int ,b int ,c text) RETURN int AS DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN insert into t4 values(a, b, c); return 1; END; / gaussdb=# CREATE OR REPLACE function autonomous_33(num1 int) RETURN int AS DECLARE num3 int := 220; tmp int; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN num3 := num3/num1; return num3; EXCEPTION WHEN division_by_zero THEN select autonomous_32(num3, num1, sqlerrm) into tmp; return 0; END; / CREATE FUNCTION gaussdb=# select autonomous_33(0); autonomous_33 --------------- 0 (1 row) gaussdb=# select * from t4; a | b | c -----+---+------------------ 220 | 0 | division by zero (1 row) 父主题： 自治事务

函数支持自治事务 自治事务可以在函数中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与函数语法相同，示例如下。 gaussdb=# create table t4(a int, b int, c text); gaussdb=# CREATE OR REPLACE function autonomous_32(a int ,b int ,c text) RETURN int AS DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN insert into t4 values(a, b, c); return 1; END; / CREATE FUNCTION gaussdb=# CREATE OR REPLACE function autonomous_33(num1 int) RETURN int AS DECLARE num3 int := 220; tmp int; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN num3 := num3/num1; return num3; EXCEPTION WHEN division_by_zero THEN select autonomous_32(num3, num1, sqlerrm) into tmp; return 0; END; / CREATE FUNCTION gaussdb=# select autonomous_33(0); autonomous_33 --------------- 0 (1 row) gaussdb=# select * from t4; a | b | c -----+---+------------------ 220 | 0 | division by zero (1 row) 父主题： 自治事务

存储过程支持自治事务 自治事务可以在存储过程中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建存储过程语法相同，示例如下。 --建表 gaussdb=# create table t2(a int, b int); CREATE TABLE gaussdb=# insert into t2 values(1,2); INSERT 0 1 gaussdb=# select * from t2; a | b ---+--- 1 | 2 (1 row) --创建包含自治事务的存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_4(a int, b int) AS DECLARE num3 int := a; num4 int := b; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN insert into t2 values(num3, num4); dbe_output.print_line('just use call.'); END; / CREATE PROCEDURE --创建调用自治事务存储过程的普通存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_5(a int, b int) AS DECLARE BEGIN dbe_output.print_line('just no use call.'); insert into t2 values(666, 666); autonomous_4(a,b); rollback; END; / CREATE PROCEDURE --调用普通存储过程 gaussdb=# select autonomous_5(11,22); just no use call. just use call. autonomous_5 -------------- (1 row) --查看表结果 gaussdb=# select * from t2 order by a; a | b ----+---- 1 | 2 11 | 22 (2 rows) 上述例子，最后在回滚的事务块中执行包含自治事务的存储过程，直接说明了自治事务的特性，即主事务的回滚，不会影响自治事务已经提交的内容。 父主题： 自治事务

存储过程支持自治事务 自治事务可以在存储过程中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建存储过程语法相同，示例如下。 --建表 gaussdb=# create table t2(a int, b int); NOTICE: The 'DISTRIBUTE BY' clause is not specified. Using 'a' as the distribution column by default. HINT: Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column. CREATE TABLE gaussdb=# insert into t2 values(1,2); INSERT 0 1 gaussdb=# select * from t2; a | b ---+--- 1 | 2 (1 row) --创建包含自治事务的存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_4(a int, b int) AS DECLARE num3 int := a; num4 int := b; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN insert into t2 values(num3, num4); dbe_output.print_line('just use call.'); END; / CREATE PROCEDURE --创建调用自治事务存储过程的普通存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_5(a int, b int) AS DECLARE BEGIN dbe_output.print_line('just no use call.'); insert into t2 values(666, 666); autonomous_4(a,b); rollback; END; / CREATE PROCEDURE --调用普通存储过程 gaussdb=# select autonomous_5(11,22); just no use call. just use call. autonomous_5 -------------- (1 row) --查看表结果 gaussdb=# select * from t2 order by a; a | b ----+---- 1 | 2 11 | 22 (2 rows) 上述例子，最后在回滚的事务块中执行包含自治事务的存储过程，直接说明了自治事务的特性，即主事务的回滚，不会影响自治事务已经提交的内容。 父主题： 自治事务

匿名块支持自治事务 自治事务可以在匿名块中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建匿名块语法相同，示例如下。 gaussdb=# create table t1(a int ,b text); CREATE TABLE gaussdb=# START TRANSACTION; START TRANSACTION gaussdb=# DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN dbe_output.print_line('just use call.'); insert into t1 values(1,'you are so cute,will commit!'); END; / just use call. ANONYMOUS BLOCK EXECUTE gaussdb=# insert into t1 values(1,'you will rollback!'); INSERT 0 1 gaussdb=# rollback; ROLLBACK gaussdb=# select * from t1; a | b ---+------------------------------ 1 | you are so cute,will commit! (1 row) 上述例子，最后在回滚的事务块前执行包含自治事务的匿名块，也能直接说明了自治事务的特性，即主事务的回滚，不会影响自治事务已经提交的内容。 父主题： 自治事务

Package支持自治事务 自治事务可以在package中的存储过程或者函数中定义，标识符为PRAGMA AUTONOMOUS_TRANSACTION，其余语法与创建package中存储过程或函数语法相同，示例如下。 --建表 gaussdb=# drop table if exists t2; gaussdb=# create table t2(a int, b int); CREATE TABLE gaussdb=# insert into t2 values(1,2); INSERT 0 1 gaussdb=# select * from t2; a | b ---+--- 1 | 2 (1 row) --创建包含自治事务的package中的存储过程和函数 gaussdb=# CREATE OR REPLACE PACKAGE autonomous_pkg AS PROCEDURE autonomous_4(a int, b int); FUNCTION autonomous_32(a int ,b int) RETURN int; END autonomous_pkg; / CREATE PACKAGE gaussdb=# CREATE OR REPLACE PACKAGE body autonomous_pkg AS PROCEDURE autonomous_4(a int, b int) AS DECLARE num3 int := a; num4 int := b; PRAGMA AUTONOMOUS_TRANSACTION; BEGIN insert into t2 values(num3, num4); END; FUNCTION autonomous_32(a int ,b int) RETURN int AS DECLARE PRAGMA AUTONOMOUS_TRANSACTION; BEGIN insert into t2 values(a, b); return 1; END; END autonomous_pkg; / CREATE PACKAGE BODY --创建调用package自治事务存储过程和函数的普通存储过程 gaussdb=# CREATE OR REPLACE PROCEDURE autonomous_5(a int, b int) AS DECLARE va int; BEGIN insert into t2 values(666, 666); autonomous_pkg.autonomous_4(a,b); va := autonomous_pkg.autonomous_32(a + 1, b + 1); rollback; END; / CREATE PROCEDURE --调用普通存储过程 gaussdb=# select autonomous_5(11,22); autonomous_5 -------------- (1 row) --查看表结果 gaussdb=# select * from t2 order by a; a | b ----+---- 1 | 2 11 | 22 12 | 23 (3 rows) 上述例子，最后在回滚的事务块中执行包含package自治事务的存储过程和函数，直接说明了自治事务的特性，即主事务的回滚，不会影响自治事务已经提交的内容。 父主题： 自治事务