Appel d’une procédure stockée¶

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;
  $$;

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');

+------------------------+
| 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');

+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

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

CALL sp_concatenate_strings(
  'one',
  'two',
  'three');

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

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');

+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-post    |
+-------------------+

CALL build_string_proc('hello', 'before-');

+-------------------+
| 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');

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

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

CALL stproc1(2 * 5.14::FLOAT);

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

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

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

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

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.