EXCEPTION (Exécution de scripts Snowflake)¶

Spécifie comment traiter les exceptions soulevées dans le bloc Exécution de scripts Snowflake.

Pour plus d’informations sur les exceptions, voir Traitement des exceptions.

Voir aussi:

RAISE

Syntaxe¶

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

OĂč :

exception_name

Un nom d’exception dĂ©fini dans la partie DECLARE du bloc actuel, ou dans un bloc englobant.

statement

Une instruction peut ĂȘtre l’un des Ă©lĂ©ments suivants :

  • Une seule instruction SQL (y compris CALL).

  • Une instruction de flux de contrĂŽle (par exemple, une instruction de bouclage ou de branchement).

  • Un bloc imbriquĂ©.

Notes sur l’utilisation¶

  • Chaque bloc peut avoir son propre gestionnaire d’exception.

  • Snowflake ne prend pas en charge plus d’un gestionnaire d’exception par bloc. Cependant, ce gestionnaire peut dĂ©tecter plusieurs types d’exceptions en ayant plus d’une clause WHEN.

  • Le gestionnaire des exceptions doit se trouver Ă  la fin du bloc. Si le bloc contient des instructions aprĂšs le gestionnaire d’exception, ces instructions ne sont pas exĂ©cutĂ©es.

  • La clause WHEN OTHER THEN rĂ©cupĂšre toute exception non encore spĂ©cifiĂ©e.

  • Si plus d’une clause WHEN peut correspondre Ă  une exception spĂ©cifique, c’est la premiĂšre clause WHEN qui est exĂ©cutĂ©e. Les autres clauses ne sont pas exĂ©cutĂ©es.

  • Un gestionnaire d’exception ne peut traiter une exception spĂ©cifiĂ©e que si cette exception spĂ©cifiĂ©e se trouve dans le scope.

  • Si une procĂ©dure stockĂ©e est destinĂ©e Ă  renvoyer une valeur, elle doit renvoyer une valeur Ă  partir de chaque chemin possible, y compris chaque clause WHEN du gestionnaire d’exception.

  • Pour utiliser une variable dans un gestionnaire d’exceptions, la variable doit ĂȘtre dĂ©clarĂ©e dans la section DECLARE ou passĂ©e en argument Ă  une procĂ©dure stockĂ©e. Elle ne peut pas ĂȘtre dĂ©clarĂ©e dans la section BEGIN. .. END. Pour plus d’informations, voir Passer des variables Ă  un gestionnaire d’exceptions.

Exemples¶

Cet exemple dĂ©clare, lĂšve et gĂšre une exception. Remarques importantes :

  • Le gestionnaire d’exceptions est conçu pour traiter plusieurs types d’exceptions.

  • L’une des clauses WHEN du gestionnaire d’exception contient une seule instruction, tandis que l’autre contient un bloc.

    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

    Remarque : Si vous utilisez Snowflake CLI, SnowSQL, Classic Console, ou la mĂ©thode execute_stream ou execute_string dans le code Connecteur Python, utilisez cet exemple Ă  la place (voir Utilisation de Snowflake Scripting dans Snowflake CLI, SnowSQL, le Classic Console et le connecteur Python) :

    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

Voici le rĂ©sultat de l’exĂ©cution de l’exemple qui soulĂšve l’exception. Cela montre que le gestionnaire d’exceptions a dĂ©celĂ© l’exception.

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

L’exemple suivant est similaire au prĂ©cĂ©dent, mais prĂ©sente des blocs imbriquĂ©s et montre qu’un bloc interne peut soulever une exception dĂ©clarĂ©e soit dans le bloc interne, soit dans un bloc externe.

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

Remarque : Si vous utilisez Snowflake CLI, SnowSQL, Classic Console, ou la mĂ©thode execute_stream ou execute_string dans le code Connecteur Python, utilisez cet exemple Ă  la place (voir Utilisation de Snowflake Scripting dans Snowflake CLI, SnowSQL, le Classic Console et le connecteur Python) :

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

Voici le rĂ©sultat de l’exĂ©cution de l’exemple qui soulĂšve l’exception. Cela montre que le gestionnaire d’exceptions a dĂ©celĂ© l’exception.

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

L’exemple suivant est similaire Ă  l’exemple prĂ©cĂ©dent, mais prĂ©sente des blocs imbriquĂ©s, dont chacun possĂšde son propre gestionnaire d’exceptions.

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

Remarque : Si vous utilisez Snowflake CLI, SnowSQL, Classic Console, ou la mĂ©thode execute_stream ou execute_string dans le code Connecteur Python, utilisez cet exemple Ă  la place (voir Utilisation de Snowflake Scripting dans Snowflake CLI, SnowSQL, le Classic Console et le connecteur Python) :

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

Note

Cet exemple utilise le mĂȘme nom d’exception (e1) dans les blocs externe et interne.

Ce n’est pas recommandĂ©.

L’exemple fait cela pour illustrer le scope des noms d’exception. Les deux exceptions portant le nom e1 sont des exceptions diffĂ©rentes.

Le gestionnaire e1 du bloc externe ne traite pas l’exception e1 qui est dĂ©clarĂ©e et soulevĂ©e dans le bloc interne.

Voici le rĂ©sultat de l’exĂ©cution de l’exemple qui soulĂšve l’exception. Cela montre que le gestionnaire d’exception interne s’est exĂ©cutĂ©.

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

Ce fragment d’exemple montre :

  • Comment dĂ©tecter plus d’une exception dans la mĂȘme clause en utilisant OR.

  • Comment dĂ©tecter des exceptions non spĂ©cifiĂ©es en utilisant 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

L’exemple suivant montre comment retourner SQLCODE, SQLERRM (message d’erreur SQL), et SQLSTATE lors de la capture d’une exception :

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

Remarque : Si vous utilisez Snowflake CLI, SnowSQL, Classic Console, ou la mĂ©thode execute_stream ou execute_string dans le code Connecteur Python, utilisez cet exemple Ă  la place (voir Utilisation de Snowflake Scripting dans Snowflake CLI, SnowSQL, le Classic Console et le connecteur Python) :

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

L’exĂ©cution de cet exemple produit le rĂ©sultat suivant :

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

Cet exemple montre comment renvoyer une valeur Ă  partir de chaque chemin possible :

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
Langage: Français