事务¶

什么是事务？¶

事务是作为原子单元处理的一系列 SQL 语句。事务中的所有语句要么一起应用（即提交），要么一起撤消（即回滚）。Snowflake 事务保证了 ACID 属性 (link removed)。

事务可以同时包括读取和写入。

事务遵循以下规则：

• 事务永远不会“嵌套”。例如，不能创建将回滚已提交的“内部”事务的“外部”事务，也不能创建将提交已回滚的“内部”事务的“外部”事务。

• 事务与单个会话相关联。多个会话不能共享同一事务。有关处理同一会话中具有重叠线程的事务的信息，请参阅 事务和多线程。

术语¶

本主题内容：

• 术语“DDL”包括 CTAS 语句 (CREATE TABLE AS SELECT ...) 以及其他 DDL 语句。

• 术语“DML”是指 INSERT、UPDATE、DELETE、MERGE 和 TRUNCATE 语句。

• 术语“查询语句”是指 SELECT 和 CALL 语句。

虽然 CALL 语句（调用 存储过程）是一条语句，但它调用的存储过程可以包含多条语句。存储过程和事务有特殊的规则。

显式事务¶

可以通过执行 BEGIN 语句显式启动事务。Snowflake 支持同义词 BEGIN WORK 和 BEGIN TRANSACTION。Snowflake 建议使用 BEGIN TRANSACTION。

可以通过执行 COMMIT 或 ROLLBACK 显式结束事务。Snowflake 支持 COMMIT 的同义词 COMMIT WORK，以及 ROLLBACK 的同义词 ROLLBACK WORK。

通常，如果事务已经处于活动状态，任何 BEGIN TRANSACTION 语句都会被忽略。但是，用户应避免使用额外的 BEGIN TRANSACTION 语句，因为额外的 BEGIN TRANSACTION 语句会使人类读者更难将 COMMIT （或 ROLLBACK）语句与相应的 BEGIN TRANSACTION 配对。

此规则的一个例外涉及嵌套存储过程调用。有关详细信息，请参阅 范围内事务。

隐式事务¶

事务可以隐式开始和结束，而无需显式的 BEGIN TRANSACTION 或 COMMIT/ROLLBACK。隐式事务的行为方式与显式事务相同。但是，确定隐式事务何时启动的规则与确定显式事务何时启动的规则不同。

停止和启动的规则取决于语句是 DDL 语句、DML 语句还是查询语句。如果语句是 DML 或查询语句，则规则取决于是否启用了 AUTOCOMMIT。

混合事务的隐式和显式开始和结束¶

为了避免编写令人困惑的代码，应避免在同一事务中混合隐式和显式开始和结束。以下情况是合法的，但不鼓励：

• 隐式启动的事务可以通过显式 COMMIT 或 ROLLBACK 来结束。

• 显式启动的事务可以通过隐式 COMMIT 或 ROLLBACK 来结束。

事务中的失败语句¶

尽管事务作为一个单元提交或回滚，但这并不等同于说它作为一个单元成功或失败。如果语句在事务中失败，您仍然可以提交事务，而不是回滚事务。

当事务中的 DML 语句或 CALL 语句失败时，该失败语句所做的更改将被回滚。但是，事务将保持活动状态，直到提交或回滚整个事务。如果已提交事务，则应用成功语句的更改。

例如，请考虑以下代码，该代码插入两个有效值和一个无效值：

CREATE TABLE table1 (i int);
BEGIN TRANSACTION;
INSERT INTO table1 (i) VALUES (1);
INSERT INTO table1 (i) VALUES ('This is not a valid integer.');    -- FAILS!
INSERT INTO table1 (i) VALUES (2);
COMMIT;
SELECT i FROM table1 ORDER BY i;

如果执行失败的 INSERT 语句之后的语句，则最终 SELECT 语句的输出将包括整数值为 1 和 2 的行，即使事务中的其他语句之一失败也是如此。

事务和多线程¶

尽管多个会话不能共享同一个事务，但使用单个连接的多个 线程 共享同一个会话，因此共享同一个事务。这可能会导致意外结果，例如一个线程回滚在另一个线程中完成的工作。

当使用 Snowflake 驱动程序（如 Snowflake JDBC 驱动程序）或连接器（如 Snowflake Connector for Python）的客户端应用程序为多线程时，会出现这种情况。如果两个或多个线程共享同一连接，则这些线程也共享该连接中的当前事务。一个线程的 BEGIN TRANSACTION、COMMIT 或 ROLLBACK 会影响使用该共享连接的所有线程。如果线程异步运行，则结果可能无法预测。

同样，更改一个线程中的 AUTOCOMMIT 设置会影响使用同一连接的所有其他线程中的 AUTOCOMMIT 设置。

Snowflake 建议多线程客户端程序至少执行以下操作之一：

• 对每个线程使用单独的连接。

  请注意，即使使用单独的连接，您的代码仍可能遇到生成不可预测输出的争用条件；例如，一个线程可能会在另一个线程尝试更新数据之前删除数据。

• 以同步而不是异步方式执行线程，以控制执行步骤的顺序。

非重叠事务¶

以下各节介绍：

• 在事务中使用存储过程。

• 在存储过程中使用事务。

CREATE PROCEDURE p1()
...
$$
    begin transaction;
    statement C;
    statement D;
    commit;

    begin transaction;
    statement E;
    statement F;
    commit;
$$;

BEGIN TRANSACTION;
statement A;
statement B;
COMMIT;

CALL p1();

BEGIN TRANSACTION;
statement G;
statement H;
COMMIT;

BEGIN TRANSACTION;
statement A;
statement B;
COMMIT;

BEGIN TRANSACTION;
statement C;
statement D;
COMMIT;

BEGIN TRANSACTION;
statement E;
statement F;
COMMIT;

BEGIN TRANSACTION;
statement G;
statement H;
COMMIT;

范围内事务¶

包含一个事务的 存储过程 可以从另一个事务中调用。例如，存储过程中的事务可以包括对包含事务的另一个存储过程的调用。

Snowflake 不 将内部事务视为嵌套事务；相反，内部事务是一个 单独的事务。Snowflake 称这些为“自治范围内事务”（或简称为“范围内事务”）。

每个范围内事务的起点和终点决定了事务中包含哪些语句。开始和结束可以是显式的，也可以是隐式的。每个 SQL 语句只是一个事务的一部分。封闭 ROLLBACK 或 COMMIT 不会撤消封闭的 COMMIT 或 ROLLBACK。

下图显示了两个存储过程和两个范围内事务。在此示例中，每个存储过程都包含其自己的独立事务。第一个存储过程调用第二个存储过程，因此这些过程在时间上重叠，但是，它们在内容上不重叠。阴影内框内的所有语句都在一个事务中；所有其他语句都在另一个事务中。

在下一个示例中，事务边界与存储过程边界不同；在外部存储过程中启动的事务包括内部存储过程中的部分语句，但不是全部语句。

在上面的代码中，第二个存储过程包含第一个事务范围内的一些语句（SP2_T1_S2 和 SP2_T1_S3）。只有阴影内框中的语句 SP2_T2_S1 在第二个事务的范围内。

下一个示例演示了如果事务未在同一存储过程中开始和结束，则会出现的问题。该示例包含与 BEGIN 语句相同数量的 COMMIT 语句。但是，BEGIN 和 COMMIT 语句没有正确配对，因此该示例包含两个错误：

• 外部存储过程启动范围内事务，但不会显式完成它。因此，该范围内事务在该存储过程的末尾会导致错误，并且活动事务将隐式回滚。

• 第二个存储过程包含一个 COMMIT，但在该存储过程中没有相应的 BEGIN。此 COMMIT 不 提交在第一个存储过程中启动的打开事务。相反，不正确的成对 COMMIT 会导致错误。

下一个示例显示了三个在时间上重叠的范围内事务。在此示例中，存储过程 p1() 从事务内部调用另一个存储过程 p2()，p2() 包含自己的事务，因此在 p2() 中启动的事务也独立运行。（此示例使用伪代码。）

CREATE PROCEDURE p2()
...
$$
    BEGIN TRANSACTION;
    statement C;
    COMMIT;
$$;

CREATE PROCEDURE p1()
...
$$
    BEGIN TRANSACTION;
    statement B;
    CALL p2();
    statement D;
    COMMIT;
$$;

BEGIN TRANSACTION;
statement A;
CALL p1();
statement E;
COMMIT;

Copy

在这三个范围内事务中：

• 任何存储过程之外的事务都包含语句 A 和 E。

• 存储过程 p1() 中的事务包含语句 B 和 D。

• p2() 中的事务包含语句 C。

范围内事务的规则也适用于递归存储过程调用。递归调用只是一种特定类型的嵌套调用，遵循与嵌套调用相同的事务规则。

当 AUTOCOMMIT 关闭时，在组合隐式事务和存储过程时要特别小心。如果在存储过程结束时意外地使事务处于活动状态，则该事务将回滚。

例如，以下伪代码示例会在存储过程结束时导致隐式 ROLLBACK：

CREATE PROCEDURE p1() ...
$$
    INSERT INTO parent_table ...;
    INSERT INTO child_table ...;
$$;


ALTER SESSION SET AUTOCOMMIT = FALSE;
CALL p1;
COMMIT WORK;

在此示例中，设置 AUTOCOMMIT 的命令提交任何活动事务。新事务不会立即启动。存储过程包含一条 DML 语句，该语句隐式开始一个新事务。该隐式 BEGIN TRANSACTION 在存储过程中没有匹配的 COMMIT 或 ROLLBACK。由于存储过程末尾有一个活动事务，因此该活动事务会隐式回滚。

如果要在单个事务中运行整个存储过程，请在调用存储过程之前启动事务，并在调用后提交事务：

CREATE PROCEDURE p1() ...
$$
    INSERT INTO parent_table ...;
    INSERT INTO child_table ...;
$$;


ALTER SESSION SET AUTOCOMMIT = FALSE;
BEGIN TRANSACTION;
CALL p1;
COMMIT WORK;

在这种情况下，BEGIN 和 COMMIT 正确配对，代码执行时不会出错。

或者，将 BEGIN TRANSACTION 和 COMMIT 都放在存储过程中，如下面的伪代码示例所示：

CREATE PROCEDURE p1() ...
$$
    BEGIN TRANSACTION;
    INSERT INTO parent_table ...;
    INSERT INTO child_table ...;
    COMMIT WORK;
$$;


ALTER SESSION SET AUTOCOMMIT = FALSE;
CALL p1;

如果在范围内事务中没有正确配对 BEGIN/COMMIT 块，Snowflake 会报告错误。该错误可能会产生进一步的影响，例如阻止完成存储过程或阻止提交封闭事务。例如，在下面的伪代码示例中，将回滚封闭存储过程以及封闭的存储过程中的某些语句：

CREATE or replace PROCEDURE outer_sp1()
...
AS
$$
    insert 'osp1_alpha';
    BEGIN WORK;
    insert 'osp1_beta';
    CALL inner_sp2();
    INSERT 'osp1_delta';
    COMMIT WORK;
    INSERT 'osp1_omega';
$$;

CREATE or replace PROCEDURE inner_sp2()
...
AS
$$
    BEGIN WORK;
    insert 'isp2';
    -- Missing COMMIT, so implicitly rolls back!
$$;

CALL outer_sp1();

SELECT * FROM st;

Copy

在此示例中，插入的唯一值是“osp1_alpha”。因为 COMMIT 与 BEGIN 没有正确配对，所以没有插入任何其他值。错误处理方式如下：

1. 当过程 inner_sp2() 完成时，Snowflake 检测到 inner_sp2() 中的 BEGIN 没有相应的 COMMIT （或 ROLLBACK）。

   1. Snowflake 隐式回滚在 inner_sp2() 中启动的范围内事务。

   2. Snowflake 还会发出错误，因为对 inner_sp2() 的 CALL 失败。

2. 因为 inner_sp2() 的 CALL 失败，并且因为该 CALL 语句在 outer_sp1() 中，所以存储过程 outer_sp1() 本身也失败并返回错误，而不是继续。

3. 因为 outer_sp1() 没有完成执行：

   • 值“osp1_delta”和“osp1_omega”的 INSERT 语句从不执行。

   • outer_sp1() 中的打开事务被隐式回滚而不是提交，因此值“osp1_beta”的插入永远不会提交。

READ COMMITTED 隔离¶

使用 READ COMMITTED 隔离时，语句只能看到语句开始前提交的数据。它永远不会看到未提交的数据。

在多语句事务中执行语句时：

• 语句只能看到 语句 开始前提交的数据。如果在执行第一个和第二个语句之间提交了另一个事务，则同一事务中的两个连续语句可以看到不同的数据。

• 语句 确实 会看到同一事务 中 以前执行的语句所做的更改，即使这些更改尚未提交。

锁等待超时¶

被阻止的语句要么获取它正在等待的资源的锁，要么等待资源变得可用时超时。可以通过设置 LOCK_TIMEOUT 参数来配置语句应该阻止的时间量（以秒为单位）。

例如，要将当前会话的锁超时更改为 2 小时（7200 秒）：

ALTER SESSION SET LOCK_TIMEOUT=7200;

SHOW PARAMETERS LIKE 'lock%';

+--------------+-------+---------+---------+-------------------------------------------------------------------------------+
| key          | value | default | level   | description                                                                   |
|--------------+-------+---------+---------+-------------------------------------------------------------------------------|
| LOCK_TIMEOUT | 7200  | 43200   | SESSION | Number of seconds to wait while trying to lock a resource, before timing out  |
|              |       |         |         | and aborting the statement. A value of 0 turns off lock waiting i.e. the      |
|              |       |         |         | statement must acquire the lock immediately or abort. If multiple resources   |
|              |       |         |         | need to be locked by the statement, the timeout applies separately to each    |
|              |       |         |         | lock attempt.                                                                 |
+--------------+-------+---------+---------+-------------------------------------------------------------------------------+

Copy

死锁¶

当并发事务正在等待彼此锁定的资源时，就会发生死锁。

在 Snowflake 中，同时执行自动提交 DML 或查询语句时不会发生死锁。但是，显式启动的事务和每个事务中的多个语句可能会发生死锁。Snowflake 检测死锁并选择作为死锁一部分的最新语句作为牺牲品。语句将回滚，但事务本身仍处于活动状态，必须提交或回滚。

死锁检测可能需要一些时间。

允许语句错误中止事务¶

要允许事务中的语句错误中止事务，请在会话或账户级别设置 TRANSACTION_ABORT_ON_ERROR 参数。

使用 LOCK_WAIT_HISTORY 视图分析被阻止的事务¶

LOCK_WAIT_HISTORY 视图 返回事务详细信息，这些信息对分析被阻止的事务非常有用。输出中的每一行都包含正在等待锁的事务的详细信息，以及持有该锁或正在等待该锁的事务的详细信息。

例如，请参阅以下方案：

在此方案中，将返回以下数据：

• 事务 B 是等待锁的事务。

• 事务 B 在时间戳 T1 时请求锁。

• 事务 A 是持有锁的事务。

• 事务 A 中的查询 2 是阻止程序查询。

查询 2 是阻止程序查询，因为它是事务 A（持有锁的事务）中事务 B（等待锁的事务）开始等待的第一个语句。

但是，请注意，事务 A（查询 5）中的后续查询也获取了锁。这些事务的后续并发执行可能会导致事务 B 阻止获取事务 A 中锁的其他查询。因此，您必须调查第一个阻止程序事务中的所有查询。

范围内事务和存储过程的简单示例¶

这是范围内事务的简单示例。存储过程包含一个事务，该事务插入值为 12 的行，然后回滚。外部事务提交。输出显示保留外部事务范围内的所有行，而不保留内部事务范围内的行。

请注意，因为只有部分存储过程位于其自己的事务内，所以由存储过程内但不在存储过程事务内的 INSERT 语句插入的值将被保留。

创建两个表：

create table tracker_1 (id integer, name varchar);
create table tracker_2 (id integer, name varchar);

创建存储过程：

create procedure sp1()
returns varchar
language javascript
AS
$$
    // This is part of the outer transaction that started before this
    // stored procedure was called. This is committed or rolled back
    // as part of that outer transaction.
    snowflake.execute (
        {sqlText: "insert into tracker_1 values (11, 'p1_alpha')"}
        );

    // This is an independent transaction. Anything inserted as part of this
    // transaction is committed or rolled back based on this transaction.
    snowflake.execute (
        {sqlText: "begin transaction"}
        );
    snowflake.execute (
        {sqlText: "insert into tracker_2 values (12, 'p1_bravo')"}
        );
    snowflake.execute (
        {sqlText: "rollback"}
        );

    // This is part of the outer transaction started before this
    // stored procedure was called. This is committed or rolled back
    // as part of that outer transaction.
    snowflake.execute (
        {sqlText: "insert into tracker_1 values (13, 'p1_charlie')"}
        );

    // Dummy value.
    return "";
$$;

调用存储过程：

begin transaction;
insert into tracker_1 values (00, 'outer_alpha');
call sp1();
insert into tracker_1 values (09, 'outer_zulu');
commit;

结果应包括 00、11、13 和 09。ID = 12 的行不应包含在内。此行位于已回滚的封闭的事务的范围内。所有其他行都在外部事务的范围内，并且已提交。请特别注意，IDs 为 11 和 13 的行位于存储过程内部，但在最内部的事务之外；它们在封闭事务的范围内，并通过该事务提交。

select id, name FROM tracker_1
union all
select id, name FROM tracker_2
order by id;
+----+-------------+
| ID | NAME        |
|----+-------------|
|  0 | outer_alpha |
|  9 | outer_zulu  |
| 11 | p1_alpha    |
| 13 | p1_charlie  |
+----+-------------+

记录独立于事务成功的信息¶

这是如何使用范围内事务的简单实用示例。在此示例中，事务记录某些信息；无论事务本身是成功还是失败，都会保留该记录的信息。此技术可用于跟踪所有尝试的操作，无论每个操作是否成功。

创建两个表：

create table data_table (id integer);
create table log_table (message varchar);

创建存储过程：

create procedure log_message(MESSAGE VARCHAR)
returns varchar
language javascript
AS
$$
    // This is an independent transaction. Anything inserted as part of this
    // transaction is committed or rolled back based on this transaction.
    snowflake.execute (
        {sqlText: "begin transaction"}
        );
    snowflake.execute (
        {sqlText: "insert into log_table values ('" + MESSAGE + "')"}
        );
    snowflake.execute (
        {sqlText: "commit"}
        );

    // Dummy value.
    return "";
$$;

create procedure update_data()
returns varchar
language javascript
AS
$$
    snowflake.execute (
        {sqlText: "begin transaction"}
        );
    snowflake.execute (
        {sqlText: "insert into data_table (id) values (17)"}
        );
    snowflake.execute (
        {sqlText: "call log_message('You should see this saved.')"}
        );
    snowflake.execute (
        {sqlText: "rollback"}
        );

    // Dummy value.
    return "";
$$;

调用存储过程：

begin transaction;
call update_data();
rollback;

数据表为空，因为事务已回滚：

select * from data_table;
+----+
| ID |
|----|
+----+

但是，日志记录表不为空；插入到日志记录表中是在与插入到 data_table 不同的事务中完成的。

select * from log_table;
+----------------------------+
| MESSAGE                    |
|----------------------------|
| You should see this saved. |
+----------------------------+

范围内事务和存储过程的示例¶

接下来的几个示例使用下面所示的表和存储过程。通过传递适当的参数，调用方可以控制 BEGIN TRANSACTION、COMMIT 和 ROLLBACK 语句在存储过程中的执行位置。

创建表：

create table tracker_1 (id integer, name varchar);
create table tracker_2 (id integer, name varchar);
create table tracker_3 (id integer, name varchar);

此过程是封闭存储过程，根据传递给它的参数，可以创建封闭事务。

create procedure sp1_outer(
    USE_BEGIN varchar,
    USE_INNER_BEGIN varchar,
    USE_INNER_COMMIT_OR_ROLLBACK varchar,
    USE_COMMIT_OR_ROLLBACK varchar
    )
returns varchar
language javascript
AS
$$
    // This should be part of the outer transaction started before this
    // stored procedure was called. This should be committed or rolled back
    // as part of that outer transaction.
    snowflake.execute (
        {sqlText: "insert into tracker_1 values (11, 'p1_alpha')"}
        );

    // This is an independent transaction. Anything inserted as part of this
    // transaction is committed or rolled back based on this transaction.
    if (USE_BEGIN != '')  {
        snowflake.execute (
            {sqlText: USE_BEGIN}
            );
        }
    snowflake.execute (
        {sqlText: "insert into tracker_2 values (12, 'p1_bravo')"}
        );
    // Call (and optionally begin/commit-or-rollback) an inner stored proc...
    var command = "call sp2_inner('";
    command = command.concat(USE_INNER_BEGIN);
    command = command.concat("', '");
    command = command.concat(USE_INNER_COMMIT_OR_ROLLBACK);
    command = command.concat( "')" );
    snowflake.execute (
        {sqlText: command}
        );
    if (USE_COMMIT_OR_ROLLBACK != '') {
        snowflake.execute (
            {sqlText: USE_COMMIT_OR_ROLLBACK}
            );
        }

    // This is part of the outer transaction started before this
    // stored procedure was called. This is committed or rolled back
    // as part of that outer transaction.
    snowflake.execute (
        {sqlText: "insert into tracker_1 values (13, 'p1_charlie')"}
        );

    // Dummy value.
    return "";
$$;

此过程是内部存储过程，根据传递给它的参数，可以创建封闭的事务。

create procedure sp2_inner(
    USE_BEGIN varchar,
    USE_COMMIT_OR_ROLLBACK varchar)
returns varchar
language javascript
AS
$$
    snowflake.execute (
        {sqlText: "insert into tracker_2 values (21, 'p2_alpha')"}
        );

    if (USE_BEGIN != '')  {
        snowflake.execute (
            {sqlText: USE_BEGIN}
            );
        }
    snowflake.execute (
        {sqlText: "insert into tracker_3 values (22, 'p2_bravo')"}
        );
    if (USE_COMMIT_OR_ROLLBACK != '')  {
        snowflake.execute (
            {sqlText: USE_COMMIT_OR_ROLLBACK}
            );
        }

    snowflake.execute (
        {sqlText: "insert into tracker_2 values (23, 'p2_charlie')"}
        );

    // Dummy value.
    return "";
$$;

begin transaction;
insert into tracker_1 values (00, 'outer_alpha');
call sp1_outer('begin transaction', 'begin transaction', 'rollback', 'commit');
insert into tracker_1 values (09, 'outer_charlie');
rollback;

-- Should return only 12, 21, 23.
select id, name from tracker_1
union all
select id, name from tracker_2
union all
select id, name from tracker_3
order by id;
+----+------------+
| ID | NAME       |
|----+------------|
| 12 | p1_bravo   |
| 21 | p2_alpha   |
| 23 | p2_charlie |
+----+------------+

begin transaction;
insert into tracker_1 values (00, 'outer_alpha');
call sp1_outer('begin transaction', 'begin transaction', 'commit', 'rollback');
insert into tracker_1 values (09, 'outer_charlie');
commit;

select id, name from tracker_1
union all
select id, name from tracker_2
union all
select id, name from tracker_3
order by id;
+----+---------------+
| ID | NAME          |
|----+---------------|
|  0 | outer_alpha   |
|  9 | outer_charlie |
| 11 | p1_alpha      |
| 13 | p1_charlie    |
| 22 | p2_bravo      |
+----+---------------+

在存储过程中对事务使用错误处理¶

下面的代码演示存储过程中事务的简单错误处理。如果传递参数值“fail”，则存储过程会尝试从两个存在的表和一个不存在的表中删除，并且存储过程将捕获错误并返回错误消息。如果未传递参数值“fail”，则该过程将尝试从两个确实存在的表中删除，并成功。

创建表和存储过程：

begin transaction;

create table parent(id integer);
create table child (child_id integer, parent_ID integer);

-- ----------------------------------------------------- --
-- Wrap multiple related statements in a transaction,
-- and use try/catch to commit or roll back.
-- ----------------------------------------------------- --
-- Create the procedure
create or replace procedure cleanup(FORCE_FAILURE varchar)
  returns varchar not null
  language javascript
  as
  $$
  var result = "";
  snowflake.execute( {sqlText: "begin transaction;"} );
  try {
      snowflake.execute( {sqlText: "delete from child where parent_id = 1;"} );
      snowflake.execute( {sqlText: "delete from parent where id = 1;"} );
      if (FORCE_FAILURE === "fail")  {
          // To see what happens if there is a failure/rollback,
          snowflake.execute( {sqlText: "delete from no_such_table;"} );
          }
      snowflake.execute( {sqlText: "commit;"} );
      result = "Succeeded";
      }
  catch (err)  {
      snowflake.execute( {sqlText: "rollback;"} );
      return "Failed: " + err;   // Return a success/error indicator.
      }
  return result;
  $$
  ;

commit;

调用存储过程并强制出错：

call cleanup('fail');
+----------------------------------------------------------+
| CLEANUP                                                  |
|----------------------------------------------------------|
| Failed: SQL compilation error:                           |
| Object 'NO_SUCH_TABLE' does not exist or not authorized. |
+----------------------------------------------------------+

在不强制出错的情况下调用存储过程：

call cleanup('do not fail');
+-----------+
| CLEANUP   |
|-----------|
| Succeeded |
+-----------+