Behandeln von Ausnahmen¶

In einem Snowflake Scripting-Block können Sie bei Auftreten eines Fehlers eine Ausnahme auslösen. Sie können auch Ausnahmen behandeln, die in Ihrem Snowflake Scripting-Code auftreten.

Einführung in die Behandlung von Ausnahmen in Snowflake Scripting¶

Snowflake Scripting löst eine Ausnahme aus, wenn beim Ausführen einer Anweisung ein Fehler auftritt. Wenn eine Anweisung beispielsweise versucht, eine Tabelle zu löschen, die nicht existiert, löst Snowflake Scripting eine Ausnahme aus.

In einem Snowflake Scripting-Block können Sie Programme zur Ausnahmebehandlung (sog. Ausnahme-Handler) schreiben, die bestimmte Arten von Ausnahmen abfangen, die in diesem Block und in Blöcken, die in diesem Block verschachtelt sind, deklariert sind. Darüber hinaus können Sie für Fehler, die in Ihrem Code auftreten, eigene Ausnahmen definieren, die Sie beim Auftreten von Fehlern auslösen können.

Nachdem die Anweisungen im Handler ausgeführt wurden, können Sie den Block verlassen oder die Anweisungen im Block weiter ausführen. Weitere Informationen dazu finden Sie unter Behandeln einer Ausnahme in Snowflake Scripting.

Wenn in einem Snowflake Scripting-Block eine Ausnahme ausgelöst wird (entweder durch Ihren Code oder durch eine Anweisung, die nicht ausgeführt werden kann), versucht Snowflake Scripting, einen Handler für diese Ausnahme zu finden:

Wenn der Block, in dem die Ausnahme aufgetreten ist, einen Handler für diese Ausnahme hat, wird die Ausführung am Anfang dieses Handlers fortgesetzt.
Wenn der Block keinen eigenen Ausnahme-Handler hat, kann die Ausnahme durch den umschließenden Block abgefangen werden.

Tritt die Ausnahme mehr als eine Ebene tiefer auf, wird die Ausnahme ebenenweise nach oben gesendet, bis entweder:
- Eine Ebene mit einem geeigneten Ausnahme-Handler die Ausnahme behandelt.
- Die äußerste Ebene erreicht ist, in der ein Fehler auftritt.
Wenn es weder im aktuellen Block noch in den umschließenden Blöcken einen Handler für die Ausnahme gibt, wird die Ausführung des Blocks angehalten und der Client, der den Block zur Ausführung vorlegt (z. B. Snowsight, SnowSQL, usw.), meldet dies als Snowflake-Fehler.

Ein Ausnahme-Handler kann seinen eigenen Ausnahme-Handler enthalten, falls eine Ausnahme während der Behandlung einer anderen Ausnahme auftritt.

Deklarieren einer Ausnahme in Snowflake Scripting¶

Sie können Ihre eigene Ausnahme im DECLARE-Abschnitt des Blocks deklarieren. Verwenden Sie die unter Syntax der Ausnahmedeklaration beschriebene Syntax. Beispiel:

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');

Auslösen einer deklarierten Ausnahme in Snowflake Scripting¶

Um eine Ausnahme auszulösen, führen Sie den Befehl RAISE aus. Beispiel:

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN counter;
END;

Note: If you use Snowflake CLI, SnowSQL, the Classic Console, or the execute_stream or execute_string method in Python Connector code, use this example instead (see Using Snowflake Scripting in Snowflake CLI, SnowSQL, and Python Connector):

EXECUTE IMMEDIATE $$
DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN counter;
END;
$$
;

Wenn es keinen Handler gibt, wird die Ausführung an dem Punkt angehalten, an dem die Ausnahme ausgelöst wird. Im Beispiel wird counter nie inkrementiert und zurückgegeben.

Der Client, der diesen Block zur Ausführung vorlegt (z. B. Snowsight), meldet einen Fehler und gibt an, dass die Ausnahme nicht abgefangen wurde:

-20002 (P0001): Uncaught exception of type 'MY_EXCEPTION' on line 8 at position 4 : Raised MY_EXCEPTION.

Wenn Sie Code hinzufügen möchten, um von Ihnen ausgelöste Ausnahmen zu behandeln (sowie Ausnahmen, die ausgelöst werden, wenn Anweisungen nicht ausgeführt werden können), können Sie Ausnahme-Handler schreiben. Siehe Behandeln einer Ausnahme in Snowflake Scripting.

Bemerkung

Für den Fall, dass Sie in einen Ausnahme-Handler die gleiche Ausnahme erneut auslösen müssen, finden Sie entsprechende Informationen unter Erneutes Auslösen derselben Ausnahme in einem Ausnahme-Handler von Snowflake Scripting.

Behandeln einer Ausnahme in Snowflake Scripting¶

Sie können eine Ausnahme explizit behandeln, indem Sie sie mit einer EXCEPTION-Klausel abfangen, oder Sie können zulassen, dass der Block die Ausnahme an den umschließenden Block übergibt.

Verwenden Sie innerhalb der EXCEPTION-Klausel eine WHEN-Klausel, um eine Ausnahme nach Namen zu behandeln. Sie können sowohl von Ihnen deklarierte Ausnahmen als auch integrierte Ausnahmen verarbeiten. Derzeit bietet Snowflake die folgenden integrierten Ausnahmen:

STATEMENT_ERROR: Diese Ausnahme weist auf einen Fehler bei der Ausführung einer Anweisung hin. Wenn Sie zum Beispiel versuchen, eine Tabelle zu löschen, die nicht existiert, wird diese Ausnahme ausgelöst.
EXPRESSION_ERROR: Diese Ausnahme zeigt einen Fehler im Zusammenhang mit einem Ausdruck an. Wenn Sie z. B. einen Ausdruck erstellen, der als VARCHAR ausgewertet wird, und versuchen, den Wert des Ausdrucks einem FLOAT zuzuweisen, wird dieser Fehler ausgelöst.

Jede WHEN-Klausel in einem Ausnahmeblock kann einer der folgenden Typen sein:

EXIT: Der Block führt die Anweisungen im Handler aus und beendet dann den aktuellen Block. Wenn der Block eine Ausnahme dieses Typs ausführt und der Block Anweisungen nach der Anweisung enthält, die den Fehler verursacht hat, werden diese Anweisungen nicht ausgeführt.

Wenn der Block ein innerer Block ist und der Ausnahme-Handler keine RETURN-Anweisung enthält, verlässt die Ausführung den inneren Block und fährt mit dem Code im äußeren Block fort.

EXIT ist der Standard.
CONTINUE: Der Block führt die Anweisungen im Ausnahmeblock aus und fährt mit der Anweisung fort, die unmittelbar auf die Anweisung folgt, die den Fehler verursacht hat.

Ein CONTINUE-Handler kann Ausnahmen abfangen und verarbeiten, ohne den Anweisungsblock zu beenden, der die Ausnahme ausgelöst hat. Mit dem standardmäßigen EXIT-Handler wird bei Auftreten eines Fehlers in einem Block der Ablauf unterbrochen und der Fehler an den Aufrufenden zurückgegeben. Sie können einen CONTINUE-Handler allerdings verwenden, wenn die Fehlerbedingung nicht schwerwiegend genug ist, um eine Unterbrechung des Ablaufs zu rechtfertigen.

Eine EXCEPTION-Klausel kann WHEN-Klauseln beider Typen enthalten, EXIT und CONTINUE.

Wenn eine Ausnahme auftritt, können Sie Informationen über die Ausnahme erhalten, indem Sie die folgenden drei integrierten Variablen auslesen:

SQLCODE: Dies ist eine 5-stellige, vorzeichenbehaftete Ganzzahl. Bei benutzerdefinierten Ausnahmen ist dies die exception_number (Ausnahmenummer), die in der Syntax zum Deklarieren von Ausnahmen angegeben ist.
SQLERRM: Dies ist eine Fehlermeldung. Bei benutzerdefinierten Ausnahmen ist dies die exception_message (Ausnahmenummer), die in der Syntax zum Deklarieren von Ausnahmen angegeben ist.
SQLSTATE: Dies ist ein 5-Zeichen-Code, der auf dem ANSI-SQL-Standard SQLSTATE basiert. Snowflake verwendet zusätzliche Werte, die über die Werte des ANSI-SQL-Standards hinausgehen.

Wenn Sie eine WHEN-Klausel des Typs CONTINUE verwenden, spiegeln diese integrierten Variablen den Fehler wider, der die Ausnahme in der WHEN-Klausel verursacht hat. Nachdem die Anweisungen in der WHEN-Klausel abgeschlossen wurden und die Ausführung der Anweisung im Block fortgesetzt wird, geben die Werte dieser Variablen die Werte zurück, die sie vor dem Auslösen der Ausnahme hatten.

Um alle anderen Ausnahmen zu behandeln, die nicht integriert oder deklariert sind, verwenden Sie eine WHEN OTHER THEN-Klausel, Die WHEN OTHER THEN-Klausel kann vom Typ EXIT oder CONTINUE sein.

Nehmen Sie zum Beispiel an, dass Sie die folgende Fehlerprotokolltabelle haben, um Ihre Ausnahmen zu verfolgen:

CREATE OR REPLACE TABLE test_error_log(
  error_type VARCHAR,
  error_code VARCHAR,
  error_message VARCHAR,
  error_state VARCHAR,
  error_timestamp TIMESTAMP);

Der folgende anonyme Block fügt Informationen über die Ausnahmen in die Tabelle ein und gibt dem Benutzer Informationen über sie zurück:

Tipp

Das Beispiel definiert eine Ausnahme im Abschnitt DECLARE und behandelt dann diese Ausnahme. Für ein Beispiel, das eine STATEMENT_ERROR-Ausnahme behandelt, entfernen Sie die Kommentare (--) aus dieser Zeile:

-- SELECT 1/0;

Für ein Beispiel, das andere Fehler behandelt, entfernen Sie die Kommentare aus dieser Zeile:

-- LET var := 1/0;

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'STATEMENT_ERROR',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN my_exception THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'MY_EXCEPTION',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN OTHER THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'Other error',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
END;

EXECUTE IMMEDIATE $$
DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'STATEMENT_ERROR',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN my_exception THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'MY_EXCEPTION',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
  WHEN OTHER THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
    RETURN OBJECT_CONSTRUCT('Error type', 'Other error',
                            'SQLCODE', sqlcode,
                            'SQLERRM', sqlerrm,
                            'SQLSTATE', sqlstate);
END;
$$
;

Für den zurückgegebenen Wert behandelt dieses Beispiel jede Art von Ausnahme, indem es OBJECT_CONSTRUCT aufruft, um ein Objekt zu erstellen und zurückzugeben, das die Details über die Ausnahme enthält. Das Beispiel ergibt die folgende Ausgabe:

+--------------------------------------+
| anonymous block                      |
|--------------------------------------|
| {                                    |
|   "Error type": "MY_EXCEPTION",      |
|   "SQLCODE": -20002,                 |
|   "SQLERRM": "Raised MY_EXCEPTION.", |
|   "SQLSTATE": "P0001"                |
| }                                    |
+--------------------------------------+

Sie können die test_error_log-Tabelle abfragen, um zu bestätigen, dass der Fehler protokolliert wurde:

SELECT * FROM test_error_log;

+--------------+------------+----------------------+-------------+-------------------------+
| ERROR_TYPE   | ERROR_CODE | ERROR_MESSAGE        | ERROR_STATE | ERROR_TIMESTAMP         |
|--------------+------------+----------------------+-------------+-------------------------|
| MY_EXCEPTION | -20002     | Raised MY_EXCEPTION. | P0001       | 2025-09-05 12:15:00.068 |
+--------------+------------+----------------------+-------------+-------------------------+

Im vorherigen Beispiel wurden WHEN-Klauseln des Standardtyps (EXIT) verwendet. Wenn einer der WHEN-Klauseln eine Ausnahme abfängt, führt sie die Anweisungen in der WHEN-Klausel aus und wird dann beendet. Daher wird der folgende Code nicht ausgeführt:

counter := counter + 1;
RETURN 'My counter value: ' || counter;

Wenn Sie eine Ausnahme behandeln und dann den Code im Block weiter ausführen möchten, geben Sie WHEN-Klauseln von CONTINUE-Typ an. Das folgende Beispiel ist dasselbe wie das vorherige, aber es gibt WHEN-Klauseln des Typs CONTINUE an und entfernt die RETURN-Anweisung von jeder WHEN-Klausel:

DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN my_exception CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN OTHER CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
END;

EXECUTE IMMEDIATE $$
DECLARE
  my_exception EXCEPTION (-20002, 'Raised MY_EXCEPTION.');
BEGIN
  -- SELECT 1/0;
  -- LET var := 1/0;
  LET counter := 0;
  LET should_raise_exception := true;
  IF (should_raise_exception) THEN
    RAISE my_exception;
  END IF;
  counter := counter + 1;
  RETURN 'My counter value: ' || counter;
EXCEPTION
  WHEN STATEMENT_ERROR CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'STATEMENT_ERROR', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN my_exception CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'MY_EXCEPTION', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
  WHEN OTHER CONTINUE THEN
    INSERT INTO test_error_log VALUES(
      'OTHER', :sqlcode, :sqlerrm, :sqlstate, CURRENT_TIMESTAMP());
END;
$$
;

+---------------------+
| anonymous block     |
|---------------------|
| My counter value: 1 |
+---------------------+

Die Ausgabe zeigt, dass das Beispiel den folgenden Code weiter ausgeführt hat, nachdem die Ausnahme ausgelöst wurde:

counter := counter + 1;
RETURN counter;

Weitere Informationen zu CONTINUE-Handlern finden Sie unter EXCEPTION (Snowflake Scripting).

In seltenen Fällen kann die Behandlung einer Ausnahme explizit darin bestehen, nichts zu tut. Auf diese Weise können Sie bei Auftreten einer Ausnahme fortfahren, anstatt zu beenden. Weitere Informationen dazu finden Sie unter dem Befehl NULL.

Bemerkung

Für den Fall, dass Sie denselben Ausnahme-Handler noch einmal auslösen müssen, finden Sie entsprechende Informationen unter Erneutes Auslösen derselben Ausnahme in einem Ausnahme-Handler von Snowflake Scripting.

Wenn Sie keinen Handler für eine Ausnahme einrichten, meldet der Client, der den Block zur Ausführung sendet (z. B. Snowsight), einen Fehler (wie unter Auslösen einer deklarierten Ausnahme in Snowflake Scripting erläutert).

-20002 (P0001): Uncaught exception of type 'MY_EXCEPTION' on line 8 at position 4 : Raised MY_EXCEPTION.

Erneutes Auslösen derselben Ausnahme in einem Ausnahme-Handler von Snowflake Scripting¶

In manchen Fällen müssen Sie die gleiche Ausnahme auslösen, die Sie in Ihrem Ausnahme-Handler abgefangen haben. In diesen Fällen führen Sie den Befehl RAISE ohne Angabe von Argumenten aus.

Angenommen, dass Sie während der Ausnahmebehandlung einige Details über die Ausnahme erfassen müssen, bevor Sie die gleiche Ausnahme erneut auslösen. Nach der Erfassung der Details führen Sie den Befehl RAISE aus:

BEGIN
  SELECT * FROM non_existent_table;
EXCEPTION
  WHEN OTHER THEN
    LET LINE := SQLCODE || ': ' || SQLERRM;
    INSERT INTO myexceptions VALUES (:line);
    RAISE; -- Raise the same exception that you are handling.
END;

EXECUTE IMMEDIATE $$
BEGIN
  SELECT * FROM non_existent_table;
EXCEPTION
  WHEN OTHER THEN
    LET LINE := SQLCODE || ': ' || SQLERRM;
    INSERT INTO myexceptions VALUES (:line);
    RAISE; -- Raise the same exception that you are handling.
END;
$$;

Übergabe von Variablen an einen Ausnahme-Handler in Snowflake Scripting¶

Sie können Variablen an einen Ausnahme-Handler übergeben. Der Ausnahme-Handle kann Code auf der Grundlage des Wertes der Variable ausführen, und der Wert der Variable kann in Fehlermeldungen zurückgegeben werden.

Damit eine Variable an einen Handler im EXCEPTION-Abschnitt übergeben werden kann, muss die Variable im DECLARE-Abschnitt deklariert werden. Wenn eine Variable im BEGIN … END-Abschnitt des Blocks deklariert wird, kann im EXCEPTION-Abschnitt nicht auf sie zugegriffen werden.

Wenn Sie eine Snowflake Scripting gespeicherte Prozedur schreiben, die Argumente akzeptiert, können Sie diese Argumente auch in einem Ausnahme-Handler verwenden.

Der folgende anonyme Block übergibt zum Beispiel den Wert der counter_val-Variable an den Handler der Ausnahme:

DECLARE
  counter_val INTEGER DEFAULT 0;
  my_exception EXCEPTION (-20002, 'My exception text');
BEGIN
  WHILE (counter_val < 12) DO
    counter_val := counter_val + 1;
    IF (counter_val > 10) THEN
      RAISE my_exception;
    END IF;
  END WHILE;
  RETURN counter_val;
EXCEPTION
  WHEN my_exception THEN
    RETURN 'Error ' || sqlcode || ': Counter value ' || counter_val || ' exceeds the limit of 10.';
END;

EXECUTE IMMEDIATE $$
DECLARE
  counter_val INTEGER DEFAULT 0;
  my_exception EXCEPTION (-20002, 'My exception text');
BEGIN
  WHILE (counter_val < 12) DO
    counter_val := counter_val + 1;
    IF (counter_val > 10) THEN
      RAISE my_exception;
    END IF;
  END WHILE;
  RETURN counter_val;
EXCEPTION
  WHEN my_exception THEN
    RETURN 'Error ' || sqlcode || ': Counter value ' || counter_val || ' exceeds the limit of 10.';
END;
$$
;

Der Block gibt die folgende Fehlermeldung zurück:

+---------------------------------------------------------+
| anonymous block                                         |
|---------------------------------------------------------|
| Error -20002: Counter value 11 exceeds the limit of 10. |
+---------------------------------------------------------+

Im Folgenden finden Sie ein Beispiel für eine Snowflake Scripting gespeicherte Prozedur, die ein Argument übergibt. Das Beispiel zeigt, wie Sie das Argument in einem Ausnahme-Handler verwenden können:

CREATE OR REPLACE PROCEDURE exception_test_vars(amount INT)
  RETURNS TEXT
  LANGUAGE SQL
AS
DECLARE
  my_exception_1 EXCEPTION (-20002, 'Value too low');
  my_exception_2 EXCEPTION (-20003, 'Value too high');
BEGIN
  CREATE OR REPLACE TABLE test_order_insert(units INT);
  IF (amount < 1) THEN
    RAISE my_exception_1;
  ELSEIF (amount > 10) THEN
    RAISE my_exception_2;
  ELSE
    INSERT INTO test_order_insert VALUES (:amount);
  END IF;
  RETURN 'Order inserted successfully.';
EXCEPTION
  WHEN my_exception_1 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too low (1 or greater required).';
  WHEN my_exception_2 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too high (exceeds limit of 10).';
END;

CREATE OR REPLACE PROCEDURE exception_test_vars(amount INT)
  RETURNS TEXT
  LANGUAGE SQL
AS
$$
DECLARE
  my_exception_1 EXCEPTION (-20002, 'Value too low');
  my_exception_2 EXCEPTION (-20003, 'Value too high');
BEGIN
  CREATE OR REPLACE TABLE test_order_insert(units INT);
  IF (amount < 1) THEN
    RAISE my_exception_1;
  ELSEIF (amount > 10) THEN
    RAISE my_exception_2;
  ELSE
    INSERT INTO test_order_insert VALUES (:amount);
  END IF;
  RETURN 'Order inserted successfully.';
EXCEPTION
  WHEN my_exception_1 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too low (1 or greater required).';
  WHEN my_exception_2 THEN
    RETURN 'Error ' || sqlcode || ': Submitted amount ' || amount || ' is too high (exceeds limit of 10).';
END;
$$
;

Die folgenden Aufrufe der gespeicherten Prozedur zeigen die erwartete Ausgabe:

CALL exception_test_vars(7);

+------------------------------+
| EXCEPTION_TEST_VARS          |
|------------------------------|
| Order inserted successfully. |
+------------------------------+

CALL exception_test_vars(-3);

+-----------------------------------------------------------------------+
| EXCEPTION_TEST_VARS                                                   |
|-----------------------------------------------------------------------|
| Error -20002: Submitted amount -3 is too low (1 or greater required). |
+-----------------------------------------------------------------------+

CALL exception_test_vars(20);

+----------------------------------------------------------------------+
| EXCEPTION_TEST_VARS                                                  |
|----------------------------------------------------------------------|
| Error -20003: Submitted amount 20 is too high (exceeds limit of 10). |
+----------------------------------------------------------------------+