Appel d’une procédure stockée

Vous pouvez appeler une procédure stockée en utilisant la commande SQL CALL.

Pour qu’un utilisateur puisse appeler une procédure stockée, le rôle de l’utilisateur doit avoir le privilège USAGE pour la procédure stockée.

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.

Spécification des arguments

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   |
+-------------------+

Exemples

Pour exécuter une procédure stockée, utilisez une instruction CALL. Par exemple :

call stproc1(5.14::FLOAT);
Copy

Chaque argument d’une procédure stockée peut être une expression générale :

CALL stproc1(2 * 5.14::FLOAT);
Copy

Un argument peut être une sous-requête :

CALL stproc1(SELECT COUNT(*) FROM stproc_test_table1);
Copy

Vous ne pouvez appeler qu’une procédure stockée par instruction CALL. Par exemple, l’instruction suivante échoue :

call proc1(1), proc2(2);                          -- Not allowed
Copy

En outre, vous ne pouvez pas utiliser une procédure stockée CALL dans le cadre d’une expression. Par exemple, toutes les instructions suivantes échouent :

call proc1(1) + proc1(2);                         -- Not allowed
call proc1(1) + 1;                                -- Not allowed
call proc1(proc2(x));                             -- Not allowed
select * from (call proc1(1));                    -- Not allowed
Copy

Toutefois, dans une procédure stockée, la procédure stockée peut appeler une autre procédure stockée ou s’appeler elle-même de manière récursive.

Prudence

Les appels imbriqués peuvent dépasser la profondeur de pile maximale autorisée. Soyez donc prudent lors de l’imbrication des appels, en particulier lors de l’utilisation de la récursivité.