EXCEPTION (Snowflake Scripting)¶

Gibt an, wie Ausnahmen behandelt werden sollen, die im Snowflake Scripting-Block ausgelöst werden.

Weitere Informationen zu Ausnahmen finden Sie unter Behandeln von Ausnahmen.

Siehe auch::: RAISE

Syntax¶

EXCEPTION
    WHEN <exception_name> [ OR <exception_name> ... ] THEN
        <statement>;
        [ <statement>; ... ]
    [ WHEN ... ]
    [ WHEN OTHER THEN ]
        <statement>;
        [ <statement>; ... ]

Copy

Wobei:

exception_name
Ein Ausnahmename, der im DECLARE-Teil des aktuellen Blocks oder in einem umschließenden Block definiert ist.

statement
Folgende Typen von Anweisungen sind möglich:

Eine einzelne SQL-Anweisung (einschließlich CALL)

Eine Ablaufsteuerungsanweisung (z. B. Schleife oder Verzweigung)

Ein verschachtelter Block

Nutzungshinweise¶

Jeder Block kann einen eigenen Ausnahme-Handler haben.
Snowflake unterstützt nicht mehr als einen Ausnahme-Handler pro Block. Dieser Handler kann jedoch mehr als einen Typ von Ausnahme abfangen, indem er mehr als eine WHEN-Klausel enthält.
Der Ausnahme-Handler sollte am Ende des Blocks stehen. Wenn der Block Anweisungen nach dem Ausnahme-Handler enthält, werden diese Anweisungen nicht ausgeführt.
Mit der WHEN OTHER THEN-Klausel kann jede noch nicht spezifizierte Ausnahme abgefangen werden.
Wenn auf eine bestimmte Ausnahme mehr als eine WHEN-Klausel zutreffen könnte, wird die erste übereinstimmende WHEN-Klausel ausgeführt. Die anderen Klauseln werden nicht ausgeführt.
Ein Ausnahme-Handler kann eine angegebene Ausnahme nur behandeln, wenn die angegebene Ausnahme im Sichtbarkeitsbereich ist.
Wenn eine gespeicherte Prozedur einen Wert zurückgeben soll, dann muss sie einen Wert aus jedem möglichen Pfad zurückgeben, einschließlich jeder WHEN-Klausel des Ausnahme-Handlers.

Beispiele¶

In diesem Beispiel wird eine Ausnahme deklariert, ausgelöst und behandelt. Beachten Sie Folgendes:

Der Ausnahme-Handler ist so konzipiert, dass er mehr als einen Typ von Ausnahme behandeln kann.

Eine der WHEN-Klauseln im Ausnahme-Handler enthält eine einzelne Anweisung, während die andere einen Block enthält.

DECLARE
  RESULT VARCHAR;
  EXCEPTION_1 EXCEPTION (-20001, 'I caught the expected exception.');
  EXCEPTION_2 EXCEPTION (-20002, 'Not the expected exception!');
BEGIN
  RESULT := 'If you see this, I did not catch any exception.';
  IF (TRUE) THEN
    RAISE EXCEPTION_1;
  END IF;
  RETURN RESULT;
EXCEPTION
  WHEN EXCEPTION_2 THEN
    RETURN SQLERRM;
  WHEN EXCEPTION_1 THEN
    RETURN SQLERRM;
END;

Copy

Hinweis: Wenn Sie SnowSQL oder die klassische Weboberfläche verwenden, benutzen Sie stattdessen dieses Beispiel (siehe Verwenden von Snowflake Scripting in SnowSQL und über die klassische Weboberfläche):

EXECUTE IMMEDIATE $$
    DECLARE
        RESULT VARCHAR;
        EXCEPTION_1 EXCEPTION (-20001, 'I caught the expected exception.');
        EXCEPTION_2 EXCEPTION (-20002, 'Not the expected exception!');
    BEGIN
        RESULT := 'If you see this, I did not catch any exception.';
        IF (TRUE) THEN
            RAISE EXCEPTION_1;
        END IF;
        RETURN RESULT;
    EXCEPTION
        WHEN EXCEPTION_2 THEN
            RETURN SQLERRM;
        WHEN EXCEPTION_1 THEN
            RETURN SQLERRM;
    END;
$$
;

Copy

Hier ist die Ausgabe für die Ausführung des Beispiels, das die Ausnahme auslöst. Dies zeigt, dass der Ausnahme-Handler die Ausnahme abgefangen hat.

+----------------------------------+
| anonymous block                  |
|----------------------------------|
| I caught the expected exception. |
+----------------------------------+

Copy

Das nächste Beispiel ähnelt dem vorherigen Beispiel, zeigt aber verschachtelte Blöcke und zeigt, dass ein innerer Block eine Ausnahme auslösen kann, die entweder im inneren Block oder in einem äußeren Block deklariert wurde.

DECLARE
  e1 EXCEPTION (-20001, 'Exception e1');

BEGIN
  -- Inner block.
  DECLARE
    e2 EXCEPTION (-20002, 'Exception e2');
    selector BOOLEAN DEFAULT TRUE;
  BEGIN
    IF (selector) THEN
      RAISE e1;
    ELSE
      RAISE e2;
    END IF;
  END;

EXCEPTION
  WHEN e1 THEN
    RETURN SQLERRM || ' caught in outer block.';
END;

Copy

EXECUTE IMMEDIATE $$
    DECLARE
        e1 EXCEPTION (-20001, 'Exception e1');

    BEGIN
        -- Inner block.
        DECLARE
            e2 EXCEPTION (-20002, 'Exception e2');
            selector BOOLEAN DEFAULT TRUE;
        BEGIN
            IF (selector) THEN
                RAISE e1;
            ELSE
                RAISE e2;
            END IF;
        END;

    EXCEPTION
        WHEN e1 THEN
            BEGIN
                RETURN SQLERRM || ' caught in outer block.';
            END;

    END;
$$
;

Copy

Hier ist die Ausgabe für die Ausführung des Beispiels, das die Ausnahme auslöst. Dies zeigt, dass der Ausnahme-Handler die Ausnahme abgefangen hat.

+-------------------------------------+
| anonymous block                     |
|-------------------------------------|
| Exception e1 caught in outer block. |
+-------------------------------------+

Copy

Das nächste Beispiel ähnelt dem vorherigen Beispiel, zeigt aber verschachtelte Blöcke, von denen jeder seinen eigenen Ausnahme-Handler hat.

DECLARE
  RESULT VARCHAR;
  e1 EXCEPTION (-20001, 'Outer exception e1');

BEGIN
  RESULT := 'No error so far (but there will be).';

  DECLARE
    e1 EXCEPTION (-20101, 'Inner exception e1');
  BEGIN
    RAISE e1;
  EXCEPTION
    WHEN e1 THEN
      RESULT := 'Inner exception raised.';
      RETURN RESULT;
  END;

  RETURN RESULT;

EXCEPTION
  WHEN e1 THEN
    RESULT := 'Outer exception raised.';
    RETURN RESULT;

END;

Copy

EXECUTE IMMEDIATE $$
    DECLARE
        RESULT VARCHAR;
        e1 EXCEPTION (-20001, 'Outer exception e1');

    BEGIN
        RESULT := 'No error so far (but there will be).';

        DECLARE
            e1 EXCEPTION (-20101, 'Inner exception e1');
        BEGIN
            RAISE e1;
        EXCEPTION
            WHEN e1 THEN
                RESULT := 'Inner exception raised.';
                RETURN RESULT;
        END;

        RETURN RESULT;

    EXCEPTION
        WHEN e1 THEN
            RESULT := 'Outer exception raised.';
            RETURN RESULT;

    END;
$$
;

Copy

Bemerkung

In diesem Beispiel wird im äußeren und inneren Block derselbe Ausnahmename (e1) verwendet.

Dies wird nicht empfohlen.

Das Beispiel veranschaulicht den Sichtbarkeitsbereich von Ausnahmenamen. Die beiden Ausnahmen mit dem Namen e1 sind unterschiedliche Ausnahmen.

Der Handler e1 im äußeren Block behandelt nicht die Ausnahme e1, die im inneren Block deklariert ist und ausgelöst wird.

Hier ist die Ausgabe für die Ausführung des Beispiels, das die Ausnahme auslöst. Dies zeigt, dass der innere Ausnahme-Handler ausgeführt wurde.

+-------------------------+
| anonymous block         |
|-------------------------|
| Inner exception raised. |
+-------------------------+

Copy

Dieses Beispielfragment zeigt Folgendes:

Abfangen von mehr als einer Ausnahme in derselben Klausel durch Verwendung von OR

Abfangen von nicht spezifizierten Ausnahmen mit WHEN OTHER THEN

EXCEPTION
  WHEN MY_FIRST_EXCEPTION OR MY_SECOND_EXCEPTION OR MY_THIRD_EXCEPTION THEN
    RETURN 123;
  WHEN MY_FOURTH_EXCEPTION THEN
    RETURN 4;
  WHEN OTHER THEN
    RETURN 99;

Copy

Im folgenden Beispiel wird gezeigt, wie SQLCODE, SQLERRM (SQL-Fehlermeldung) und SQLSTATE bei Abfangen einer Ausnahme zurückgegeben werden:

DECLARE
  MY_EXCEPTION EXCEPTION (-20001, 'Sample message');
BEGIN
  RAISE MY_EXCEPTION;
EXCEPTION
  WHEN STATEMENT_ERROR THEN
    RETURN OBJECT_CONSTRUCT('Error type', 'STATEMENT_ERROR',
                            'SQLCODE', SQLCODE,
                            'SQLERRM', SQLERRM,
                            'SQLSTATE', SQLSTATE);
  WHEN EXPRESSION_ERROR THEN
    RETURN OBJECT_CONSTRUCT('Error type', 'EXPRESSION_ERROR',
                            'SQLCODE', SQLCODE,
                            'SQLERRM', SQLERRM,
                            'SQLSTATE', SQLSTATE);
  WHEN OTHER THEN
    RETURN OBJECT_CONSTRUCT('Error type', 'Other error',
                            'SQLCODE', SQLCODE,
                            'SQLERRM', SQLERRM,
                            'SQLSTATE', SQLSTATE);
END;

Copy

EXECUTE IMMEDIATE $$
    DECLARE
        MY_EXCEPTION EXCEPTION (-20001, 'Sample message');
    BEGIN
        RAISE MY_EXCEPTION;
    EXCEPTION
        WHEN STATEMENT_ERROR THEN
            RETURN OBJECT_CONSTRUCT('Error type', 'STATEMENT_ERROR',
                                    'SQLCODE', SQLCODE,
                                    'SQLERRM', SQLERRM,
                                    'SQLSTATE', SQLSTATE);
        WHEN EXPRESSION_ERROR THEN
            RETURN OBJECT_CONSTRUCT('Error type', 'EXPRESSION_ERROR',
                                    'SQLCODE', SQLCODE,
                                    'SQLERRM', SQLERRM,
                                    'SQLSTATE', SQLSTATE);
        WHEN OTHER THEN
            RETURN OBJECT_CONSTRUCT('Error type', 'Other error',
                                    'SQLCODE', SQLCODE,
                                    'SQLERRM', SQLERRM,
                                    'SQLSTATE', SQLSTATE);
    END;
$$
;

Copy

Die Ausführung dieses Beispiels ergibt die folgende Ausgabe:

+--------------------------------+
| anonymous block                |
|--------------------------------|
| {                              |
|   "Error type": "Other error", |
|   "SQLCODE": -20001,           |
|   "SQLERRM": "Sample message", |
|   "SQLSTATE": "P0001"          |
| }                              |
+--------------------------------+

Copy

Das folgende Beispiel demonstriert die Rückgabe eines Wertes aus jedem möglichen Pfad:

declare
    e1 exception;
    e2 exception;
begin
    statement_1;
    ...
    RETURN x;
exception
    when e1 then begin
        ...
        RETURN y;
        end;
    when e2 then begin
        ...
        RETURN z;
        end;
end;

Copy