Comprendre les blocs dans Exécution de scripts Snowflake

Dans Exécution de scripts Snowflake, vous écrivez du code procédural dans un bloc Exécution de scripts Snowflake. Cette rubrique explique comment écrire du code procédural dans un bloc.

Dans ce chapitre :

Comprendre la structure d’un bloc

Un bloc a la structure de base suivante :

DECLARE
  ... (variable declarations, cursor declarations, etc.) ...
BEGIN
  ... (Snowflake Scripting and SQL statements) ...
EXCEPTION
  ... (statements for handling exceptions) ...
END;

Un bloc est constitué de sections (dont certaines sont facultatives) qui sont délimitées par des mots-clés. Chaque section sert un objectif différent :

  • DECLARE : si vous devez utiliser des variables, des curseurs, etc. dans le bloc, vous pouvez les déclarer soit dans la section DECLARE du bloc, soit dans la section BEGIN ... END du bloc.

    Vous pouvez déclarer les éléments suivants :

    Cette section du bloc est facultative.

  • BEGIN … END : écrivez les instructions SQL et les constructions Exécution de scripts Snowflake dans la section du bloc située entre BEGIN et END.

  • EXCEPTION : si vous devez ajouter un code de traitement des exceptions, ajoutez-le à la section EXCEPTION du bloc.

    Cette section du bloc est facultative.

Un bloc simple ne nécessite que les mots-clés BEGIN et END. Par exemple :

BEGIN
    CREATE TABLE employee (id INTEGER, ...);
    CREATE TABLE dependents (id INTEGER, ...);
END;

Important

Le mot-clé BEGIN qui démarre un bloc est différent du mot-clé BEGIN qui démarre une transaction. Pour éviter la confusion, Snowflake recommande fortement de commencer les transactions par BEGIN TRANSACTION (ou l’ancienne forme BEGIN WORK), plutôt que simplement BEGIN.

Tous les objets de base de données que vous créez dans un bloc (par exemple, les tables dans l’exemple ci-dessus) peuvent être utilisés en dehors du bloc.

Si le code utilise des variables, vous pouvez déclarer ces variables dans le bloc. Une façon de le faire se trouve dans la section DECLARE du bloc. Par exemple :

DECLARE
    radius_of_circle FLOAT;
    area_of_circle FLOAT;
BEGIN
    radius_of_circle := 3;
    area_of_circle := pi() * radius_of_circle * radius_of_circle;
    RETURN area_of_circle;
END;

Cet exemple déclare une variable, utilise la variable et renvoie la valeur de la variable. (Pour plus de détails sur la façon dont les valeurs sont renvoyées par un bloc, voir Renvoyer une valeur).

Notez que ces variables ne peuvent pas être utilisées en dehors du bloc. Voir Comprendre la portée des déclarations.

Vous pouvez également déclarer une variable dans la section BEGIN ... END du bloc en utilisant LET. Pour plus de détails, voir Déclaration d’une variable.

Utilisation d’un bloc dans une procédure stockée

Vous pouvez utiliser un bloc dans la définition d’une procédure stockée. Voici un exemple que vous pouvez exécuter dans Snowsight pour créer une procédure stockée contenant un bloc Exécution de scripts Snowflake :

CREATE OR REPLACE PROCEDURE area()
  RETURNS FLOAT
  LANGUAGE SQL
  AS
    DECLARE
      radius FLOAT;
      area_of_circle FLOAT;
    BEGIN
      radius := 3;
      area_of_circle := PI() * radius * radius;
      RETURN area_of_circle;
    END;

Notez que si vous utilisez SnowSQL ou l’interface Web classique, vous devez utiliser des guillemets simples ou des doubles signes de dollar pour délimiter le bloc, comme expliqué dans Utilisation d’Exécution de scripts Snowflake dans SnowSQL et l’interface Web classique :

CREATE OR REPLACE PROCEDURE area()
RETURNS FLOAT
LANGUAGE SQL
AS
$$
DECLARE
    radius FLOAT;
    area_of_circle FLOAT;
BEGIN
    radius := 3;
    area_of_circle := PI() * radius * radius;
    RETURN area_of_circle;
END;
$$
;

Utilisation d’un bloc anonyme

Si vous ne voulez pas stocker le bloc dans une procédure stockée dans la base de données, vous pouvez définir et utiliser un bloc anonyme. Un bloc anonyme est un bloc qui ne fait pas partie d’une procédure stockée. Vous définissez le bloc comme une instruction SQL distincte et autonome.

L’instruction BEGIN … END qui définit le bloc exécute également le bloc. (Vous ne lancez pas une commande CALL distincte pour exécuter le bloc).

Voici un exemple de bloc anonyme que vous pouvez exécuter dans Snowsight :

DECLARE
  radius_of_circle FLOAT;
  area_of_circle FLOAT;
BEGIN
  radius_of_circle := 3;
  area_of_circle := PI() * radius_of_circle * radius_of_circle;
  RETURN area_of_circle;
END;

L’exemple produit le résultat suivant :

+-----------------+
| anonymous block |
|-----------------|
|    28.274333882 |
+-----------------+

Notez que si vous utilisez SnowSQL ou l’interface Web classique, vous devez spécifier le bloc sous la forme d’une chaîne littérale (délimitée par des guillemets simples ou des doubles signes de dollar), et vous devez passer le bloc à la commande EXECUTE IMMEDIATE, comme expliqué dans Utilisation d’Exécution de scripts Snowflake dans SnowSQL et l’interface Web classique :

EXECUTE IMMEDIATE $$
DECLARE
    radius_of_circle FLOAT;
    area_of_circle FLOAT;
BEGIN
    radius_of_circle := 3;
    area_of_circle := PI() * radius_of_circle * radius_of_circle;
    RETURN area_of_circle;
END;
$$
;
+-----------------+
| anonymous block |
|-----------------|
|    28.274333882 |
+-----------------+

Notez que l’en-tête de colonne dans la sortie est un « bloc anonyme » ; si le code avait été exécuté dans une procédure stockée, l’en-tête de colonne aurait été le nom de la procédure stockée.

L’exemple suivant définit un bloc anonyme qui crée deux tables qui sont liées. Dans cet exemple, le bloc de code procédural n’a pas besoin d’utiliser de variables, la section DECLARE du bloc est donc omise.

BEGIN
  CREATE TABLE parent (ID INTEGER);
  CREATE TABLE child (ID INTEGER, parent_ID INTEGER);
  RETURN 'Completed';
END;
+-----------------+
| anonymous block |
|-----------------|
| Completed       |
+-----------------+

Remarque : si vous utilisez SnowSQL ou l’interface Web classique, utilisez cet exemple à la place (voir Utilisation d’Exécution de scripts Snowflake dans SnowSQL et l’interface Web classique) :

EXECUTE IMMEDIATE $$
BEGIN
    CREATE TABLE parent (ID INTEGER);
    CREATE TABLE child (ID INTEGER, parent_ID INTEGER);
    RETURN 'Completed';
END;
$$
;
+-----------------+
| anonymous block |
|-----------------|
| Completed       |
+-----------------+
Revenir au début