Appel d’une procédure stockée

Vous pouvez appeler une procédure stockée de plusieurs manières.

Outils d’appel de procédures

Choisissez l’outil permettant d’appeler la procédure.

Langage

Approche

SQL

Exécutez une commande SQL, par exemple en utilisant l”Snowsight.

Exécutez la commande SQL CALL pour appeler une procédure.

Java, Python ou Scala avec Snowpark

Écrivez du code localement dans l’un des langages pris en charge, l’appel s’exécutant dans Snowflake.

Exécutez le code client qui utilise les APIs Snowpark dans l’un des langages suivants.

Ligne de commande

Créez et gérez des entités Snowflake en exécutant des commandes à partir de la ligne de commande.

Exécutez des commandes de la CLI Snowflake :

Python

Sur le client, écrivez du code qui exécute des opérations de gestion sur Snowflake.

Exécutez du code qui utilise l’API Snowflake Python.

APIs RESTful (indépendantes du langage)

Effectuez des requêtes auprès des points de terminaison RESTful pour créer et gérer des entités Snowflake.

Faites une requête pour créer une procédure à l’aide de l’API REST Snowflake

Une fois que vous avez les privilèges pour appeler la procédure stockée, vous pouvez utiliser une instruction CALL pour appeler la procédure stockée.

Note

Pour créer et appeler une procédure anonyme, utilisez CALL (avec procédure anonyme). La création et l’appel d’une procédure anonyme ne nécessitent pas un rôle avec des privilèges de schéma CREATE PROCEDURE.

Notes sur l’utilisation

  • Les noms des procédures ne sont pas nécessairement uniques dans le schéma ; les procédures stockées sont identifiées et résolues par leurs types d’arguments ainsi que par leurs noms (c’est-à-dire que les procédures stockées peuvent être surchargées).

  • En dehors d’un bloc Exécution de scripts Snowflake, la valeur renvoyée par la procédure stockée ne peut pas être utilisée, car l’appel ne peut pas faire partie d’une expression.

    Dans un bloc Exécution de scripts Snowflake, vous pouvez spécifier INTO :snowflake_scripting_variable pour capturer la valeur de retour de la procédure stockée dans une variable Exécution de scripts Snowflake.

  • Les procédures stockées ne sont pas atomiques ; si une instruction d’une procédure stockée échoue, les autres instructions de la procédure stockée ne sont pas nécessairement annulées. Pour des informations sur les procédures et les transactions stockées, voir Gestion des transactions.

  • Vous pouvez également créer et appeler une procédure anonyme en utilisant CALL (avec procédure anonyme).

Appeler une procédure stockée avec SQL

Si la procédure stockée a des arguments, vous pouvez spécifier ces arguments par nom ou par position.

Par exemple, la procédure stockée suivante accepte trois arguments :

CREATE OR REPLACE PROCEDURE sp_concatenate_strings(
    first_arg VARCHAR,
    second_arg VARCHAR,
    third_arg VARCHAR)
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
  BEGIN
    RETURN first_arg || second_arg || third_arg;
  END;
  $$;
Copy

Lors de l’appel de la procédure, vous pouvez spécifier les arguments par leur nom :

CALL sp_concatenate_strings(
  first_arg => 'one',
  second_arg => 'two',
  third_arg => 'three');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Si vous spécifiez les arguments par leur nom, il n’est pas nécessaire de les spécifier dans un ordre particulier :

CALL sp_concatenate_strings(
  third_arg => 'three',
  first_arg => 'one',
  second_arg => 'two');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Vous pouvez également spécifier les arguments par position :

CALL sp_concatenate_strings(
  'one',
  'two',
  'three');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Remarques :

  • Vous devez spécifier tous les arguments soit par leur nom, soit par leur position. Vous ne pouvez pas spécifier certains arguments par leur nom et d’autres par leur position.

    Lorsque vous spécifiez un argument par son nom, vous ne pouvez pas utiliser de guillemets doubles autour du nom de l’argument.

  • Si deux fonctions ou deux procédures ont le même nom, mais des types d’arguments différents, vous pouvez utiliser les noms des arguments pour spécifier la fonction ou la procédure à exécuter, si les noms des arguments sont différents. Reportez-vous à Surcharge de procédures et de fonctions.

Spécification d’arguments facultatifs

Si la procédure stockée a des arguments facultatifs, vous pouvez omettre les arguments facultatifs dans l’appel. Chaque argument facultatif a une valeur par défaut qui est utilisée lorsque l’argument est omis.

Par exemple, la procédure stockée suivante comporte un argument obligatoire et deux arguments facultatifs. Chaque argument facultatif a une valeur par défaut.

CREATE OR REPLACE PROCEDURE build_string_proc(
    word VARCHAR,
    prefix VARCHAR DEFAULT 'pre-',
    suffix VARCHAR DEFAULT '-post'
  )
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
    BEGIN
      RETURN prefix || word || suffix;
    END;
  $$
  ;
Copy

Vous pouvez omettre tout argument facultatif dans l’appel. Lorsque vous omettez un argument, la valeur par défaut de l’argument est utilisée.

CALL build_string_proc('hello');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-post    |
+-------------------+

CALL build_string_proc('hello', 'before-');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| before-hello-post |
+-------------------+

Si vous devez omettre un argument facultatif et spécifier un autre argument facultatif qui apparaît après l’argument omis dans la signature, utilisez des arguments nommés plutôt que des arguments positionnels.

Par exemple, supposons que vous souhaitiez omettre l’argument prefix et spécifier l’argument suffix. L’argument suffix apparaît après l’argument prefix dans la signature, vous devez donc spécifier les arguments par leur nom :

CALL build_string_proc(word => 'hello', suffix => '-after');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-after   |
+-------------------+
Langage: Français