Catégories :

DDL pour les fonctions définies par l’utilisateur, les fonctions externes et les procédures stockées

CREATE PROCEDURE

Crée une nouvelle procédure stockée.

Une procédure peut être écrite dans l’un des langages suivants :

Note

Lorsque vous voulez créer et appeler une procédure anonyme (plutôt que stockée), utilisez CALL (avec procédure anonyme). La création d’une procédure anonyme ne nécessite pas un rôle avec des privilèges de schéma CREATE PROCEDURE.

Voir aussi :

ALTER PROCEDURE, DROP PROCEDURE , SHOW PROCEDURES , DESCRIBE PROCEDURE, CALL

Syntaxe

Java et Scala

Pour les procédures stockées en ligne, utilisez la syntaxe suivante :

CREATE [ OR REPLACE ] [ SECURE ] PROCEDURE <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
  RETURNS <result_data_type> [ NOT NULL ]
  LANGUAGE { SCALA | JAVA }
  RUNTIME_VERSION = '<scala_or_java_runtime_version>'
  PACKAGES = ( 'com.snowflake:snowpark:<version>' [, '<package_name_and_version>' ...] )
  [ IMPORTS = ( '<stage_path_and_file_name_to_read>' [, '<stage_path_and_file_name_to_read>' ...] ) ]
  HANDLER = '<fully_qualified_method_name>'
  [ TARGET_PATH = '<stage_path_and_file_name_to_write>' ]
  [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
  [ VOLATILE | IMMUTABLE ] -- Note: VOLATILE and IMMUTABLE are deprecated.
  [ COMMENT = '<string_literal>' ]
  [ EXECUTE AS { CALLER | OWNER } ]
  AS '<procedure_definition>'

Pour les procédures stockées précompilées en Scala et Java, utilisez la syntaxe suivante :

CREATE [ OR REPLACE ] [ SECURE ] PROCEDURE <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
  RETURNS <result_data_type> [ NOT NULL ]
  LANGUAGE { SCALA | JAVA }
  RUNTIME_VERSION = '<scala_or_java_runtime_version>'
  PACKAGES = ( 'com.snowflake:snowpark:<version>' [, '<package_name_and_version>' ...] )
  [ IMPORTS = ( '<stage_path_and_file_name_to_read>' [, '<stage_path_and_file_name_to_read>' ...] ) ]
  HANDLER = '<fully_qualified_method_name>'
  [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
  [ VOLATILE | IMMUTABLE ] -- Note: VOLATILE and IMMUTABLE are deprecated.
  [ COMMENT = '<string_literal>' ]
  [ EXECUTE AS { CALLER | OWNER } ]

JavaScript

CREATE [ OR REPLACE ] [ SECURE ] PROCEDURE <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
  RETURNS <result_data_type> [ NOT NULL ]
  LANGUAGE JAVASCRIPT
  [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
  [ VOLATILE | IMMUTABLE ] -- Note: VOLATILE and IMMUTABLE are deprecated.
  [ COMMENT = '<string_literal>' ]
  [ EXECUTE AS { CALLER | OWNER } ]
  AS '<procedure_definition>'

Important

JavaScript est sensible à la casse, alors que SQL ne l’est pas. Voir Sensibilité à la casse dans les arguments JavaScript pour obtenir des informations importantes sur l’utilisation de noms d’arguments de procédure stockée dans le code JavaScript.

Python

Pour les procédures stockées en ligne, utilisez la syntaxe suivante :

CREATE [ OR REPLACE ] [ SECURE ] PROCEDURE <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
  RETURNS <result_data_type> [ NOT NULL ]
  LANGUAGE PYTHON
  RUNTIME_VERSION = '<python_version>'
  PACKAGES = ( 'snowflake-snowpark-python[==<version>]'[, '<package_name>[==<version>]` ... ])
  [ IMPORTS = ( '<stage_path_and_file_name_to_read>' [, '<stage_path_and_file_name_to_read>' ...] ) ]
  HANDLER = '<function_name>'
  [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
  [ VOLATILE | IMMUTABLE ] -- Note: VOLATILE and IMMUTABLE are deprecated.
  [ COMMENT = '<string_literal>' ]
  [ EXECUTE AS { CALLER | OWNER } ]
  AS '<procedure_definition>'

Pour une procédure stockée dans laquelle le code se trouve dans un fichier sur une zone de préparation, utilisez la syntaxe suivante :

CREATE [ OR REPLACE ] PROCEDURE <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
  RETURNS <result_data_type> [ NOT NULL ]
  LANGUAGE PYTHON
  RUNTIME_VERSION = '<python_version>'
  PACKAGES = ( 'snowflake-snowpark-python[==<version>]'[, '<package_name>[==<version>]` ... ])
  [ IMPORTS = ( '<stage_path_and_file_name_to_read>' [, '<stage_path_and_file_name_to_read>' ...] ) ]
  HANDLER = '<module_file_name>.<function_name>'
  [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
  [ VOLATILE | IMMUTABLE ] -- Note: VOLATILE and IMMUTABLE are deprecated.
  [ COMMENT = '<string_literal>' ]
  [ EXECUTE AS { CALLER | OWNER } ]

Exécution de scripts Snowflake

CREATE [ OR REPLACE ] PROCEDURE <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
  RETURNS { <result_data_type> | TABLE ( [ <col_name> <col_data_type> [ , ... ] ] ) }
    [ NOT NULL ]
  LANGUAGE SQL
  [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
  [ VOLATILE | IMMUTABLE ] -- Note: VOLATILE and IMMUTABLE are deprecated.
  [ COMMENT = '<string_literal>' ]
  [ EXECUTE AS { CALLER | OWNER } ]
  AS <procedure_definition>

Note

Si vous créez une procédure Exécution de scripts Snowflake dans SnowSQL ou dans l’interface Web classique, vous devez utiliser les délimiteurs de littéral de chaîne (' ou $$) autour de la procedure definition. Voir Utilisation d’Exécution de scripts Snowflake dans SnowSQL et l’interface Web classique.

Paramètres requis

Tous les langages

name ( [ arg_name arg_data_type ] [ , ... ] )

Spécifie l’identificateur (name) et tout argument d’entrée pour la procédure stockée.

RETURNS result_data_type [ NOT NULL ]

Spécifie le type du résultat renvoyé par la procédure stockée.

  • Pour result_data_type, utilisez le type de données Snowflake qui correspond au type de langage que vous utilisez.

    Note

    Les procédures stockées que vous écrivez dans Snowpark (Java ou Scala) doivent avoir une valeur de retour. Dans Snowpark (Python), lorsqu’une procédure stockée ne renvoie aucune valeur, on considère qu’elle renvoie None. Notez que chaque instruction CREATE PROCEDURE doit inclure une clause RETURNS qui définit un type de retour, même si la procédure ne retourne rien explicitement.

  • Pour RETURNS TABLE ( [ col_name col_data_type [ , ... ] ] ), si vous connaissez les types de données Snowflake des colonnes de la table renvoyée, spécifiez les noms et les types de colonnes :

    CREATE OR REPLACE PROCEDURE get_top_sales()
    RETURNS TABLE (sales_date DATE, quantity NUMBER)
    ...
    

    Sinon (par exemple, si vous déterminez les types de colonnes pendant l’exécution), vous pouvez omettre les noms et les types de colonnes :

    CREATE OR REPLACE PROCEDURE get_top_sales()
    RETURNS TABLE ()
    

    Note

    Actuellement, dans la clause RETURNS TABLE(...) de CREATE PROCEDURE, vous ne pouvez pas spécifier GEOGRAPHY comme type de colonne.

    CREATE OR REPLACE PROCEDURE test_return_geography_table_1()
    RETURNS TABLE(g GEOGRAPHY)
    ...
    

    Si vous le faites, l’appel de la procédure stockée entraîne une erreur :

    CALL test_return_geography_table_1();
    
    Stored procedure execution error: data type of returned table does not match expected returned table type
    

    Pour contourner ce problème, vous pouvez omettre les arguments et les types de colonnes dans RETURNS TABLE().

    CREATE OR REPLACE PROCEDURE test_return_geography_table_1()
    RETURNS TABLE()
    ...
    

    RETURNS TABLE(...) n’est possible que dans les procédures stockées Exécution de scripts Snowflake qui renvoient une table. Voir RETURN.

En pratique, la valeur renvoyée ne peut pas être utilisée, car l’appel ne peut pas faire partie d’une expression.

LANGUAGE language

Spécifie le langage du code de la procédure stockée Notez que ceci est facultatif pour les procédures stockées écrites avec Exécution de scripts Snowflake.

Actuellement, les valeurs prises en charge pour language comprennent :

Par défaut : SQL.

AS procedure_definition

Définit le code exécuté par la procédure stockée. La définition peut consister en n’importe quel code valide.

Remarques :

  • Pour les procédures stockées dont le code n’est pas en ligne, omettez la clause AS. Cela inclut les procédures stockées précompilées dans Snowpark Scala et Java, et les procédures stockées dans Python dont le code se trouve sur une zone de préparation.

    Utilisez plutôt la clause IMPORTS pour spécifier l’emplacement du fichier contenant le code de la procédure stockée. Pour plus de détails, voir :

  • Vous devez utiliser les délimiteurs de littéral de chaîne (' ou $$) autour de la procedure definition si :

  • Pour les procédures stockées en JavaScript et si vous écrivez une chaîne qui contient de nouvelles lignes, vous pouvez utiliser des guillemets (également appelés « backticks ») autour de la chaîne.

    L’exemple ci-dessous d’une procédure stockée JavaScript utilise $$ et des guillemets, car le corps de la procédure stockée contient des guillemets simples et des guillemets doubles :

    CREATE OR REPLACE TABLE table1 ("column 1" VARCHAR);
    
    CREATE or replace PROCEDURE proc3()
      RETURNS VARCHAR
      LANGUAGE javascript
      AS
      $$
      var rs = snowflake.execute( { sqlText: 
          `INSERT INTO table1 ("column 1") 
               SELECT 'value 1' AS "column 1" ;`
           } );
      return 'Done.';
      $$;
    
  • Pour les langages autres que Exécution de scripts Snowflake, Snowflake ne valide pas complètement le code lorsque vous exécutez la commande CREATE PROCEDURE.

    Par exemple, pour les procédures stockées Snowpark (Scala), le nombre et les types d’arguments d’entrée sont validés, mais le corps de la fonction ne l’est pas. Si le nombre ou les types ne correspondent pas (par exemple, si le type de données Snowflake NUMBER est utilisé alors que l’argument est un type non numérique), l’exécution de la commande CREATE PROCEDURE provoque une erreur.

    Si le code n’est pas valide, la commande CREATE PROCEDURE réussira, et des erreurs s’afficheront lorsque la procédure stockée sera appelée.

Pour plus de détails sur les procédures stockées, voir Travailler avec des procédures stockées.

Java, Python, ou Scala

RUNTIME_VERSION = 'language_runtime_version'

Version de la runtime du langage à utiliser. Les versions prises en charge sont les suivantes :

  • Java : 11

  • Python : 3.8

  • Scala : 2.12

PACKAGES = ( 'snowpark_package_name' [, 'package_name' ...] )

Une liste, séparée par des virgules, des noms des paquets déployés dans Snowflake qui doivent être inclus dans l’environnement d’exécution du code du gestionnaire. Le paquet Snowpark est requis pour les procédures stockées, il doit donc toujours être référencé dans la clause PACKAGES. Pour plus d’informations sur Snowpark, voir Snowpark.

Par défaut, l’environnement dans lequel Snowflake exécute les procédures stockées comprend un ensemble sélectionné de paquets pour les langages pris en charge. Lorsque vous référencez ces paquets dans la clause PACKAGES, il n’est pas nécessaire de référencer un fichier contenant le paquet dans la clause IMPORTS car le paquet est déjà disponible dans Snowflake. Vous pouvez également spécifier la version du paquet.

Pour obtenir la liste des paquets et des versions pris en charge pour un langage particulier, interrogez la vue INFORMATION_SCHEMA.PACKAGES pour les lignes, en spécifiant le langage. Par exemple :

select * from information_schema.packages where language = '<language>';

language est java, python, ou scala.

La syntaxe pour faire référence à un paquet dans PACKAGES varie selon le langage du paquet, comme décrit ci-dessous.

  • Java

    Spécifiez le nom du paquet et le numéro de version en utilisant la forme suivante :

    domain:package_name:version
    

    Pour spécifier la dernière version, spécifiez latest pour version.

    Par exemple, pour inclure un paquet de la dernière bibliothèque Snowpark dans Snowflake, utilisez ce qui suit :

    PACKAGES = ('com.snowflake:snowpark:latest')
    

    Lorsque vous spécifiez un paquet de la bibliothèque Snowpark, vous devez spécifier la version 1.3.0 ou une version ultérieure.

  • Python

    Snowflake comprend un grand nombre de paquets disponibles via Anaconda ; pour plus d’informations, voir Utilisation de paquets tiers.

    Spécifiez le nom du paquet et le numéro de version en utilisant la forme suivante :

    package_name[==version]
    

    Pour spécifier la dernière version, omettez le numéro de version.

    Par exemple, pour inclure la version du paquet spacy 2.3.5 (ainsi que la dernière version du paquet Snowpark requis), utilisez ce qui suit :

    PACKAGES = ('snowflake-snowpark-python', 'spacy==2.3.5')
    

    Lorsque vous spécifiez un paquet de la bibliothèque Snowpark, vous devez spécifier la version 0.4.0 ou une version ultérieure. Omettez le numéro de version pour utiliser la dernière version disponible dans Snowflake.

  • Scala

    Spécifiez le nom du paquet et le numéro de version en utilisant la forme suivante :

    domain:package_name:version
    

    Pour spécifier la dernière version, spécifiez latest pour version.

    Par exemple, pour inclure un paquet de la dernière bibliothèque Snowpark dans Snowflake, utilisez ce qui suit :

    PACKAGES = ('com.snowflake:snowpark:latest')
    

    Snowflake prend en charge l’utilisation de Snowpark version 0.9.0 ou ultérieure dans une procédure stockée Scala. Notez toutefois que ces versions présentent des limites. Par exemple, les versions antérieures à la version 1.1.0 ne prennent pas en charge l’utilisation de transactions dans une procédure stockée.

HANDLER = 'fully_qualified_method_name'

  • Python

    Utilisez le nom de la fonction ou de la méthode de la procédure stockée. Cela peut varier selon que le code est en ligne ou référencé au niveau d’une zone de préparation.

    • Lorsque le code est en ligne, vous pouvez spécifier uniquement le nom de la fonction, comme dans l’exemple suivant :

      CREATE OR REPLACE PROCEDURE MYPROC(from_table STRING, to_table STRING, count INT)
        ...
        HANDLER = 'run'
      AS
      $$
      def run(session, from_table, to_table, count):
        ...
      $$;
      
    • Lorsque le code est importé depuis une zone de préparation, spécifiez le nom de la fonction de gestionnaire entièrement qualifié sous la forme <nom_module>.<nom_fonction>.

      CREATE OR REPLACE PROCEDURE MYPROC(from_table STRING, to_table STRING, count INT)
        ...
        IMPORTS = ('@mystage/my_py_file.py')
        HANDLER = 'my_py_file.run';
      
  • Java et Scala

    Utilisez le nom complet de la méthode ou de la fonction pour la procédure stockée. Ceci se présente généralement sous la forme suivante :

    com.my_company.my_package.MyClass.myMethod
    

    où :

    com.my_company.my_package
    

    correspond au paquet contenant l’objet ou la classe :

    package com.my_company.my_package;
    

Paramètres facultatifs

Tous les langages

SECURE

Indique que la procédure est sécurisée. Pour plus d’informations sur les procédures sécurisées, voir Protection des informations sensibles avec les UDFs et les procédures stockées sécurisées.

[ [ NOT ] NULL ]

Indique si la procédure stockée peut renvoyer des valeurs NULL ou doit uniquement renvoyer des valeurs NON-NULL.

La valeur par défaut est NULL (c’est-à-dire que la procédure stockée peut renvoyer une valeur NULL).

CALLED ON NULL INPUT ou . RETURNS NULL ON NULL INPUT | STRICT

Spécifie le comportement de la procédure stockée lors d’un appel avec des entrées « null ». Contrairement aux fonctions définies par le système, qui retournent toujours la valeur « null » lorsqu’une entrée est nulle, les procédures stockées peuvent gérer des entrées null, retournant des valeurs non nulles même lorsqu’une entrée est nulle :

  • CALLED ON NULL INPUT appellera toujours la procédure stockée avec des entrées null. Il appartient à la procédure de traiter ces valeurs de manière appropriée.

  • RETURNS NULL ON NULL INPUT (ou son synonyme STRICT) n’appelle pas la procédure stockée si une entrée est null, ainsi les instructions contenues dans la procédure stockée ne seront pas exécutées. En revanche, une valeur null sera toujours retournée. Notez que la procédure peut toujours retourner une valeur null pour les entrées non null.

Par défaut : CALLED ON NULL INPUT

VOLATILE | IMMUTABLE

Obsolète

Attention

Ces mots-clés sont obsolètes pour les procédures stockées. Ces mots-clés ne sont pas destinés à s’appliquer aux procédures stockées. Dans une prochaine version, ces mots-clés seront supprimés de la documentation.

COMMENT = 'string_literal'

Spécifie un commentaire pour la procédure stockée, qui est affiché dans la colonne DESCRIPTION de la sortie SHOW PROCEDURES.

Par défaut : stored procedure

EXECUTE AS CALLER ou . EXECUTE AS OWNER

Spécifie si une procédure stockée peut s’exécuter avec les privilèges du propriétaire (procédure stockée des « droits du propriétaire ») ou avec les privilèges de l’appelant (procédure stockée des « droits de l’appelant ») :

  • Si vous exécutez l’instruction CREATE PROCEDURE ... EXECUTE AS CALLER, alors plus tard, la procédure s’exécutera en tant que procédure de droits de l’appelant.

  • Si vous exécutez CREATE PROCEDURE ... EXECUTE AS OWNER, la procédure sera exécutée comme une procédure de droits du propriétaire.

Par défaut (si ni OWNER ni CALLER ne sont spécifiés explicitement au moment de la création de la procédure), la procédure s’exécute en tant que procédure stockée avec droits du propriétaire.

Les procédures stockées avec droits du propriétaire ont moins d’accès à l’environnement de l’appelant (par exemple, les variables de session de l’appelant), et Snowflake utilise par défaut ce niveau supérieur de confidentialité et de sécurité.

Pour plus d’informations, voir Présentation des procédures stockées des droits de l’appelant et des droits du propriétaire.

Par défaut : OWNER

Java, Python, ou Scala

IMPORTS = ( 'stage_path_and_file_name_to_read' [, 'stage_path_and_file_name_to_read' ...] )

L’emplacement (zone de préparation), le chemin et le nom du ou des fichiers à importer. Vous devez définir la clause IMPORTS pour inclure tous les fichiers dont dépend votre procédure stockée :

  • Si vous écrivez une procédure stockée en ligne, vous pouvez omettre cette clause, sauf si votre code dépend de classes définies en dehors de la procédure stockée ou de fichiers de ressources.

  • Java ou Scala : si vous écrivez une procédure stockée précompilée, vous devez également inclure un chemin vers le fichier JAR contenant la définition de la procédure stockée.

  • Python : si le code de votre procédure stockée se trouve au niveau d’une zone de préparation, vous devez également inclure un chemin vers le fichier du module dans lequel se trouve votre code.

Chaque fichier de la clause IMPORTS doit avoir un nom unique, même si les fichiers se trouvent dans des sous-répertoires différents ou dans des zones de préparation différentes.

TARGET_PATH = 'stage_path_and_file_name_to_write'

Pour le code de procédure stockée en Java ou Scala, la clause TARGET_PATH spécifie l’emplacement vers lequel Snowflake doit écrire le code compilé (fichier JAR) après avoir compilé le code source spécifié dans procedure_definition. Si cette clause est omise, Snowflake recompile le code source chaque fois que le code est nécessaire.

Note

Cette clause n’est pas nécessaire pour les procédures stockées dont le code est en Python.

Si vous spécifiez cette clause :

  • Vous ne pouvez pas définir cette option sur un fichier existant. Snowflake renvoie une erreur si le TARGET_PATH pointe vers un fichier existant.

  • Si vous spécifiez les clauses IMPORTS et TARGET_PATH , le nom du fichier dans la clause TARGET_PATH doit être différent de chaque nom de fichier dans la clause IMPORTS , même si les fichiers se trouvent dans des sous-répertoires différents ou dans des zones de préparation différentes.

  • Si vous n’avez plus besoin d’utiliser la procédure stockée (par exemple, si vous détruisez la procédure stockée), vous devez supprimer manuellement ce fichier JAR.

Notes sur l’utilisation

  • Pour toutes les procédures stockées :

    • Les procédures stockées prennent en charge la surcharge. Deux procédures peuvent avoir le même nom si elles ont un nombre différent de paramètres ou un type de données différent pour leurs paramètres.

    • 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.

    • Les instructions CREATE OR REPLACE <objet> sont atomiques. Autrement dit, lorsque l’objet est remplacé, la suppression de l’ancien objet et la création du nouvel objet sont traitées en une seule transaction.

    • Concernant les métadonnées :

      Attention

      Les clients doivent s’assurer qu’aucune donnée personnelle (autre que pour un objet utilisateur), donnée sensible, donnée à exportation contrôlée ou autre donnée réglementée n’est saisie comme métadonnée lors de l’utilisation du service Snowflake. Pour plus d’informations, voir Champs de métadonnées dans Snowflake.

    Astuce

    Si votre organisation utilise une combinaison de procédures stockées relatives aux droits de l’appelant et aux droits du propriétaire, vous pouvez utiliser une convention de dénomination pour vos procédures stockées afin d’indiquer si une procédure stockée individuelle est une procédure stockée avec droits d’un appelant ou une procédure stockée avec droits du propriétaire.

  • Pour les procédures stockées JavaScript :

    • Une procédure stockée JavaScript ne peut renvoyer qu’une seule valeur, telle qu’une chaîne (par exemple, un indicateur de réussite/échec) ou un nombre (par exemple, un code d’erreur). Si vous devez renvoyer des informations plus détaillées, vous pouvez renvoyer un VARCHAR contenant des valeurs séparées par un délimiteur (tel qu’une virgule) ou un type de données semi-structuré, tel que VARIANT.

  • Pour les procédures stockées Java, voir les limitations connues.

  • Pour les procédures stockées Python, voir les limitations connues.

  • Pour les procédures stockées Scala, voir les limitations connues.

Exemples

Cela crée une procédure stockée triviale qui renvoie une valeur codée en dur. Cela n’est pas réaliste, mais affiche la syntaxe de base SQL avec un minimum de code JavaScript :

create or replace procedure sp_pi()
    returns float not null
    language javascript
    as
    $$
    return 3.1415926;
    $$
    ;

Voici un exemple plus réaliste incluant un appel à l’API JavaScript. Une version plus complète de cette procédure pourrait permettre à un utilisateur d’insérer des données dans une table dans laquelle l’utilisateur ne disposerait pas de privilèges nécessaires pour insérer directement des données. Des instructions JavaScript pourraient vérifier les paramètres d’entrée et exécuter la requête SQL INSERT uniquement si certaines conditions étaient remplies.

create or replace procedure stproc1(FLOAT_PARAM1 FLOAT)
    returns string
    language javascript
    strict
    execute as owner
    as
    $$
    var sql_command = 
     "INSERT INTO stproc_test_table1 (num_col1) VALUES (" + FLOAT_PARAM1 + ")";
    try {
        snowflake.execute (
            {sqlText: sql_command}
            );
        return "Succeeded.";   // Return a success/error indicator.
        }
    catch (err)  {
        return "Failed: " + err;   // Return a success/error indicator.
        }
    $$
    ;

Pour plus d’exemples, voir Travailler avec des procédures stockées.

Revenir au début