SnowConvert AI - Redshift - CREATE PROCEDURE

Description

Crée une nouvelle procédure stockée ou remplace une procédure existante pour la base de données actuelle. (Procédure de création de référence linguistique Redshift SQL).

Pour plus d’informations sur les clauses de procédure, reportez-vous aux définitions suivantes :

Grammar Syntax

Voici la syntaxe SQL pour créer une procédure dans Amazon Redshift. Cliquez ici pour accéder à la spécification de Redshift pour cette syntaxe.

 CREATE [ OR REPLACE ] PROCEDURE sp_procedure_name  
  ( [ [ argname ] [ argmode ] argtype [, ...] ] )
[ NONATOMIC ]
AS $$
  procedure_body
$$ LANGUAGE plpgsql
[ { SECURITY INVOKER | SECURITY DEFINER } ]
[ SET configuration_parameter { TO value | = value } ]       
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift

 CREATE PROCEDURE TEST_PROCEDURE()
LANGUAGE PLPGSQL
AS
$$
BEGIN
    NULL;
END;
$$;
Copy

Code de sortie :

Snowflake
 CREATE PROCEDURE TEST_PROCEDURE ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;
Copy

ALIAS DECLARATION

Description

Si la signature de la procédure stockée omet le nom de l’argument, vous pouvez déclarer un alias pour l’argument.

Il n’y a pas de support pour cela dans Snowflake.

Pour parvenir à une équivalence fonctionnelle, les alias seront supprimés et toutes les utilisations seront renommées.

Lorsqu’un alias est déclaré pour un paramètre sans nom, un nom généré sera créé pour le paramètre et les utilisations. Lorsque l’alias concerne un paramètre avec un nom, l’alias sera remplacé par le vrai nom du paramètre.

Grammar Syntax

 name ALIAS FOR $n;
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE test_procedure (integer)
LANGUAGE plpgsql
AS
$$
DECLARE
    first_alias ALIAS  FOR $1;
    second_alias ALIAS  FOR $1;
BEGIN
   INSERT INTO t1
   VALUES (first_alias + 1);
   INSERT INTO t1
   VALUES (second_alias + 2);
END;
$$;

--Notice the parameter already has a name
--and we are defining two alias to the same parameter
CREATE OR REPLACE PROCEDURE test_procedure (PARAMETER1 integer)
LANGUAGE plpgsql
AS
$$
DECLARE
    first_alias ALIAS  FOR $1;
    second_alias ALIAS  FOR $1;
BEGIN
   INSERT INTO t1
   VALUES (first_alias + 1);
   INSERT INTO t1
   VALUES (second_alias + 2);
END;
$$;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE test_procedure (SC_ARG1 integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
BEGIN
   INSERT INTO t1
   VALUES (:SC_ARG1 + 1);
   INSERT INTO t1
   VALUES (:SC_ARG1 + 2);
END;
$$;

--Notice the parameter already has a name
--and we are defining two alias to the same parameter
--** SSC-FDM-0007 - MISSING DEPENDENT OBJECT "t1" **
CREATE OR REPLACE PROCEDURE test_procedure (PARAMETER1 integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
BEGIN
   INSERT INTO t1
   VALUES (:PARAMETER1 + 1);
   INSERT INTO t1
   VALUES (:PARAMETER1 + 2);
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

ARGUMENTS MODE

Description

Les procédures stockées Amazon Redshift prennent en charge les paramètres qui peuvent être transmis lors de l’invocation de la procédure. Ces paramètres vous permettent de fournir des valeurs d’entrée, de récupérer des valeurs de sortie ou de les utiliser pour des opérations d’entrée et de sortie. Vous trouverez ci-dessous une explication détaillée des types de paramètres, de leurs modes et des exemples de leur utilisation. Snowflake ne prend en charge que les valeurs d’entrée.

IN (Paramètres d’entrée)

Objet : permet de transmettre des valeurs à la procédure.

Mode par défaut : si aucun mode n’est spécifié, les paramètres sont considérés comme IN.

Comportement : les valeurs transmises à la procédure ne peuvent pas être modifiées à l’intérieur de la procédure.

OUT (Paramètres de sortie)

Objet : utilisé pour renvoyer des valeurs de la procédure.

Comportement : les paramètres peuvent être modifiés à l’intérieur de la procédure et sont renvoyés à l’appelant. Vous ne pouvez pas envoyer de valeur initiale.

INOUT (Paramètres d’entrée/sortie)

Objet : permet de transmettre des valeurs à la procédure et de les modifier pour qu’elles renvoient des valeurs actualisées.

Comportement : combine le comportement de IN et OUT. Vous devez envoyer une valeur initiale quelle que soit la sortie.

Grammar Syntax

 [ argname ] [ argmode ] argtype
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
CREATE OR REPLACE PROCEDURE SP_PARAMS(
IN PARAM1 INTEGER,
OUT PARAM2 INTEGER,
INOUT PARAM3 INTEGER)
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE SP_PARAMS (PARAM1 INTEGER, PARAM2 OUT INTEGER, PARAM3 OUT INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/10/2025",  "domain": "no-domain-provided" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes

  1. SCC-EWI-0028 : type non pris en charge par Snowflake.

  2. SSC-EWI-RS0010: Top-level procedure call with out parameters is not supported.

PROCEDURE BODY

Description

Like Redshift, Snowflake supports CREATE PROCEDURE using $$ procedure_logic $$ as the body. There is a difference in the Redshift syntax where a word can be inside the $$ like $word$ and used as a delimiter body like $word$ procedure_logic $word$. SnowConvert AI will transform it by removing the word, leaving the $$.

Grammar Syntax

 AS
$Alias$
  procedure_body
$Alias$ 
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE SP()
AS 
$somename$
BEGIN
   NULL;
END;
$somename$ 
LANGUAGE plpgsql;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE SP ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
AS
$$
   BEGIN
      NULL;
   END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

BLOCK STATEMENT

Description

PL/pgSQL est une langage structuré en blocs. Le corps complet d’une procédure est défini dans un bloc, qui contient des déclarations de variables et des instructions PL/pgSQL. Une instruction peut également être un bloc imbriqué ou un sous-bloc.

Grammar Syntax

 [ <<label>> ]
[ DECLARE
  declarations ]
BEGIN
  statements
EXCEPTION
  WHEN OTHERS THEN
    statements
END [ label ];
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE MY_PROCEDURE() 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE MY_PROCEDURE ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/10/2025",  "domain": "test" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

DECLARE

Description

Section pour déclarer toutes les variables de procédure à l’exception des variables de boucle.\ Redshift prend en charge plusieurs sections DECLARE par instruction de bloc, puisque Snowflake ne prend pas en charge ce comportement, elles doivent être fusionnées en une seule instruction de déclaration par bloc.

Grammar Syntax

 [ DECLARE declarations ]
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE first_procedure (first_parameter integer)
LANGUAGE plpgsql
    AS
$$
DECLARE
    i int := first_parameter;
BEGIN
   select i;
END;
$$;

CREATE OR REPLACE PROCEDURE second_procedure (first_parameter integer)
LANGUAGE plpgsql
    AS
$$
DECLARE
    i int := first_parameter;
DECLARE
    j int := first_parameter;
BEGIN
   select i;
END;
$$;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE first_procedure (first_parameter integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/11/2025",  "domain": "test" }}'
    AS
$$
   DECLARE
      i int := first_parameter;
BEGIN
   select i;
END;
$$;

CREATE OR REPLACE PROCEDURE second_procedure (first_parameter integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/11/2025",  "domain": "test" }}'
    AS
$$
   DECLARE
      i int := first_parameter;
      j int := first_parameter;
BEGIN
   select i;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

EXCEPTION

Description

Lorsqu’une exception se produit et que vous ajoutez un bloc de gestion des exceptions, vous pouvez écrire des instructions RAISE et la plupart des autres instructions PL/pgSQL. Par exemple, vous pouvez lever une exception avec un message personnalisé ou insérer un enregistrement dans une table de connexion.

Grammar Syntax

 EXCEPTION
  WHEN OTHERS THEN
    statements
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE update_employee_sp() AS
$$
BEGIN
    select var;
EXCEPTION WHEN OTHERS THEN
    RAISE INFO 'An exception occurred.';
END;
$$
LANGUAGE plpgsql;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE update_employee_sp ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
BEGIN
    select var;
EXCEPTION WHEN OTHER THEN
        CALL RAISE_MESSAGE_UDF('INFO', 'An exception occurred.');
        RAISE;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

LABEL

Description

Les étiquettes sont utilisées dans Redshift pour qualifier un bloc ou pour utiliser l’instruction EXIT ou END. Snowflake ne prend pas en charge les étiquettes.

Avertissement

Les étiquettes n’étant pas prises en charge par Snowflake, un EWI sera imprimée

Grammar Syntax

 [<<label>>]
BEGIN
    ...
END [label]
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE test_procedure (first_parameter integer)
LANGUAGE plpgsql
AS
$$
    <<Begin_block_label>>
BEGIN
   INSERT INTO my_test_table
   VALUES (first_parameter);
END;
$$;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE test_procedure (first_parameter integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
   !!!RESOLVE EWI!!! /*** SSC-EWI-0094 - LABEL DECLARATION FOR A STATEMENT IS NOT SUPPORTED BY SNOWFLAKE SCRIPTING <<Begin_block_label>> ***/!!!
BEGIN
   INSERT INTO my_test_table
   VALUES (:first_parameter);
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes

  1. SSC-EWI-0094: Label declaration not supported

NONATOMIC

Description

Le NONATOMIC effectue une validation après chaque instruction de la procédure stockée. Snowflake prend en charge un paramètre AUTOCOMMIT . Le paramètre par défaut pour AUTOCOMMIT est TRUE (activé).

Lorsque AUTOCOMMIT est activé, chaque instruction en dehors d’une transaction explicite est traitée comme à l’intérieur de sa transaction implicite à une seule instruction. En d’autres termes, cette instruction est automatiquement validée si elle réussit et automatiquement annulée si elle échoue. En d’autres termes, Snowflake fonctionne comme NONATOMIC « par défaut ».

Grammar Syntax

 NONATOMIC
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE SP_NONATOMIC()
NONATOMIC 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE SP_NONATOMIC ()
RETURNS VARCHAR
----** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--NONATOMIC
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/10/2025",  "domain": "test" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

POSITIONAL ARGUMENTS

Description

Redshift supports nameless parameters by referencing the parameters by their position using $. Snowflake does not support this behavior. To ensure functional equivalence, SnowConvert AI can convert those references by the parameter’s name if the name is present in the definition. If not, SnowConvert AI will generate a name for the parameter, and the uses will be replaced with the new name.

Grammar Syntax

 $n
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE SP_POSITIONAL_REFERENCES(
INTEGER,
param2 INTEGER,
INTEGER)
AS 
$$
    DECLARE
        localVariable INTEGER := 0;
    BEGIN
        localVariable := $2 + $3 + $1;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE SP_POSITIONAL_REFERENCES (SC_ARG1
INTEGER,
param2 INTEGER, SC_ARG3 INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
    DECLARE
        localVariable INTEGER := 0;
    BEGIN
        localVariable := param2 + SC_ARG3 + SC_ARG1;
    END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

RAISE

Description

Use the RAISE level statement to report messages and raise errors.

(Redshift SQL Language Reference RAISE)

Note

RAISE are fully supported by Snowflake.

Grammar Syntax

 RAISE level 'format' [, variable [, ...]];
Copy

Dans Amazon Redshift, l’instruction RAISE est utilisée pour générer des messages dans la console ou lancer des exceptions personnalisées. Redshift vous permet de spécifier différents niveaux pour indiquer la gravité du message. Dans Snowflake, cette fonctionnalité peut être émulée à l’aide d’une fonction définie par l’utilisateur (UDF) qui appelle la console en fonction du niveau spécifié.

  1. Exception :\ Lorsque le niveau est « EXCEPTION », une exception personnalisée est levée avec un message général : « To view the EXCEPTION MESSAGE, you need to check the log » (pour afficher le messsage d’exception, vous devez vérifier le journal), le code d’exception est -20002, ce qui indique à l’utilisateur que le message personnalisé se trouve dans le journal. Cela est dû aux limites de l’envoi d’exceptions personnalisées dans Snowflake.

  2. Avertissement :\ Si le niveau est « WARNING », SYSTEM$LOG_WARN est utilisé pour imprimer le message d’avertissement dans le journal de Snowflake, ce qui permet de mettre en évidence les problèmes potentiels sans interrompre le flux d’exécution.

  3. Info :\ Pour tout autre niveau (tel que « INFO »), SYSTEM$LOG_INFO est utilisé pour imprimer le message dans le journal de la console, ce qui permet d’obtenir des informations plus détaillées sur l’état du système sans provoquer d’interruptions critiques.

Cette approche permet d’émuler les fonctionnalités des niveaux de gravité de Redshift, en les adaptant à la syntaxe et aux fonctions de Snowflake, tout en conservant la flexibilité et le contrôle sur les messages et les exceptions générés lors de l’exécution.

Limitations

  • Pour voir les journaux dans Snowflake, il est nécessaire d’avoir des privilèges spécifiques, tels que les rôles ACCOUNTADMIN ou SECURITYADMIN.

  • Les journaux dans Snowflake ne sont pas disponibles immédiatement et il peut y avoir un léger délai avant que l’information ne soit visible.

  • Les messages d’erreur personnalisés dans les exceptions ne sont pas affichés comme dans Redshift. Pour voir les messages personnalisés, vous devez accéder directement aux connecteurs.

For further information, please refer to the following page.

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE raise_example(IN user_id INT)
LANGUAGE plpgsql
AS $$
BEGIN
	RAISE EXCEPTION 'User % not exists.', user_id;
END;
$$;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE raise_example (user_id INT)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/11/2025",  "domain": "test" }}'
AS $$
BEGIN
	CALL RAISE_MESSAGE_UDF('EXCEPTION', 'User % not exists.', array_construct(:user_id));
END;
$$;
Copy

UDFs

RAISE_MESSAGE_UDF
 CREATE OR REPLACE PROCEDURE RAISE_MESSAGE_UDF(LEVEL VARCHAR, MESSAGE VARCHAR, ARGS VARIANT)
RETURNS VARCHAR
LANGUAGE SQL
AS
$$
    DECLARE
        MY_EXCEPTION EXCEPTION (-20002, 'To view the EXCEPTION MESSAGE, you need to check the log.');
        SC_RAISE_MESSAGE VARCHAR;
    BEGIN
        SC_RAISE_MESSAGE := STRING_FORMAT_UDF(MESSAGE, ARGS);
        IF (LEVEL = 'EXCEPTION') THEN
            SYSTEM$LOG_ERROR(SC_RAISE_MESSAGE);
            RAISE MY_EXCEPTION;
        ELSEIF (LEVEL = 'WARNING') THEN
            SYSTEM$LOG_WARN(SC_RAISE_MESSAGE);
            RETURN 'Warning printed successfully';
        ELSE
            SYSTEM$LOG_INFO(SC_RAISE_MESSAGE);
            RETURN 'Message printed successfully';
        END IF;
    END;
$$;
Copy
STRING_FORMAT_UDF
 CREATE OR REPLACE FUNCTION PUBLIC.STRING_FORMAT_UDF(PATTERN VARCHAR, ARGS VARIANT)
RETURNS VARCHAR
LANGUAGE JAVASCRIPT
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "udf",  "convertedOn": "02/11/2025",  "domain": "test" }}'
AS
$$
	var placeholder_str = "{%}";
	var result = PATTERN.replace(/(?<!%)%(?!%)/g, placeholder_str).replace("%%","%");
	for (var i = 0; i < ARGS.length; i++)
	{
		result = result.replace(placeholder_str, ARGS[i]);
	}
	return result;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

RETURN

Description

L’instruction RETURN renvoie à l’appelant une procédure stockée. (Référence linguistique Redshift SQL Return).

La conversion de l’instruction de retour d’Amazon Redshift vers Snowflake est simple, il suffit d’envisager l’ajout de NULL à l’instruction return sur Snowflake.

Grammar Syntax

 RETURN;
Copy

Modèles d’échantillons de sources

Cas simple

Code d’entrée :
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 ()
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/12/2025",  "domain": "test" }}'
AS
$$
BEGIN
  RETURN NULL;
END
$$;
Copy

Lorsque la procédure a des paramètres de sortie

SnowConvert AI returns a variant with parameters set up as output parameters. So, for each return, SnowConvert AI will add a variant as a return value.

Code d’entrée :
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (OUT output_value VARCHAR)
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (output_value OUT VARCHAR)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/16/2025",  "domain": "no-domain-provided" }}'
AS
$$
BEGIN
   RETURN NULL;
END
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

SECURITY (DEFINER | INVOKER)

Description

La clause SECURITY des procédures stockées Amazon Redshift définit le contexte de contrôle d’accès et d’autorisations dans lequel la procédure s’exécute. Cela permet de déterminer si la procédure utilise les privilèges du propriétaire (créateur) ou de l’appelant (utilisateur invoquant la procédure).

Grammar Syntax

 [ { SECURITY INVOKER | SECURITY DEFINER } ]  
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE SP_SECURITY_INVOKER( )
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql
SECURITY INVOKER
;

CREATE OR REPLACE PROCEDURE SP_SECURITY_DEFINER( )
AS 
$$
     BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql
SECURITY DEFINER;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE SP_SECURITY_INVOKER ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
EXECUTE AS CALLER
AS
$$
    BEGIN
        NULL;
    END;
$$
;

CREATE OR REPLACE PROCEDURE SP_SECURITY_DEFINER ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
EXECUTE AS OWNER
AS
$$
    BEGIN
        NULL;
    END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

VARIABLE DECLARATION

Description

Declare all variables in a block, except for loop variables, in the block’s DECLARE section.

(Redshift SQL Language Reference Variable Declaration)

Note

Les déclarations de variables sont entièrement supportées par Snowflake.

Grammar Syntax

 DECLARE
name [ CONSTANT ] type [ NOT NULL ] [ { DEFAULT | := } expression ];
Copy

Dans Redshift, le mot-clé CONSTANT empêche la réaffectation des variables pendant l’exécution. Comme Snowflake ne prend pas en charge ce mot-clé, il est supprimé lors de la transformation. Cela n’a pas d’incidence sur la fonctionnalité, car la logique ne doit pas tenter de réaffecter une variable constante.

La contrainte NOT NULL dans Redshift garantit qu’une variable ne peut pas se voir attribuer une valeur nulle et exige une valeur par défaut non nulle. Comme Snowflake ne prend pas en charge cette contrainte, elle est supprimée lors de la transformation. Toutefois, la valeur par défaut est conservée afin de préserver la fonctionnalité.

Une variable déclarée avec un Refcursor est transformée en type Resultset, pour plus d’informations DECLARE REFCURSOR.

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE VARIABLE_DECLARATION()
LANGUAGE plpgsql
AS $$
DECLARE
    v_simple_int INT;	
    v_default_char CHAR(4) DEFAULT 'ABCD';
    v_default_float FLOAT := 10.00;
    v_constant_char CONSTANT CHAR(4) := 'ABCD';
    v_notnull VARCHAR NOT NULL DEFAULT 'Test default';
    v_refcursor REFCURSOR;
BEGIN
-- Procedure logic
END;
$$;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE VARIABLE_DECLARATION ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
        DECLARE
            v_simple_int INT;
            v_default_char CHAR(4) DEFAULT 'ABCD';
            v_default_float FLOAT := 10.00;
            v_constant_char CHAR(4) := 'ABCD';
            --** SSC-FDM-PG0012 - NOT NULL CONSTRAINT HAS BEEN REMOVED. ASSIGNING NULL TO THIS VARIABLE WILL NO LONGER CAUSE A FAILURE. **
            v_notnull VARCHAR DEFAULT 'Test default';
            v_refcursor RESULTSET;
BEGIN
            NULL;
-- Procedure logic
END;
$$;
Copy

Problèmes connus

Aucun problème n’a été constaté.

EWIs connexes

  1. SSC-FDM-PG0012 : la contrainte NOT NULL a été supprimée. L’attribution de NULL à cette variable n’entraînera plus d’échec.

TRANSACTIONS

COMMIT

Description

Valide la transaction en cours dans la base de données. Cette commande rend permanentes les mises à jour de la base de données issues de la transaction. (Référence linguistique Redshift SQL COMMIT)

Grammar Syntax

COMMIT [WORK | TRANSACTION]

Copy

Modèles d’échantillons de sources

Données de configuration

Redshift
Query
 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);
Copy
Snowflake
Query
 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);
Copy

COMMIT avec le mot-clé TRANSACTION

Le mot-clé TRANSACTION n’est pas pris en charge par Snowflake. Toutefois, comme il n’a pas d’incidence sur la fonctionnalité, il sera simplement supprimé.

Redshift
Query
 COMMIT TRANSACTION;
Copy
Snowflake
Query
 COMMIT;
Copy

COMMIT dans une procédure de comportement de transaction par défaut (sans clause NONATOMIC)

Afin d’éviter les exceptions de transactions hors champ d’application dans Snowflake, les utilisations de COMMIT seront mises en correspondance avec BEGIN TRANSACTION.

Lorsque plusieurs instructions COMMIT sont présentes dans la procédure, plusieurs instructions BEGIN TRANSACTION seront générées après chaque COMMIT pour émuler le comportement de la transaction Redshift.

Redshift
Query
 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    COMMIT;
    INSERT INTO transaction_values_test VALUES (a + 1);
    COMMIT;
END
$$;

CALL transaction_test(120);

SELECT * FROM transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 120  |
| 121  |
+------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    COMMIT;
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a + 1);
    COMMIT;
END
$$;

CALL transaction_test(120);

SELECT * FROM
    transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 120  |
| 121  |
+------+

Copy

COMMIT dans une procédure avec comportement NONATOMIC

Le comportement NONATOMIC de Redshift est émulé dans Snowflake à l’aide du paramètre de session AUTOCOMMIT défini sur true.

Since the AUTOCOMMIT session parameter is assumed to be true by SnowConvert AI, the COMMIT statement inside NONATOMIC procedures is left as is.

Redshift
Query
 CREATE OR REPLACE PROCEDURE nonatomic_procedure(a int)
    NONATOMIC
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a + 2);
    INSERT INTO transaction_values_test values (a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 12   |
| 13   |
+------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE nonatomic_procedure (a int)
RETURNS VARCHAR
--    --** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--    NONATOMIC
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a + 2);
    INSERT INTO transaction_values_test
    values (:a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM
transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 12   |
| 13   |
+------+

Copy

Problèmes connus

1. COMMIT à l’intérieur d’un appel de procédure imbriqué

Dans Redshift, lorsqu’une instruction COMMIT est spécifiée dans un appel de procédure imbriqué, la commande engage tout le travail en attente des instructions précédentes dans le champ d’application actuel et le champ d’application parent. La validation des actions du champ parent n’est pas prise en charge dans Snowflake, lorsque ce cas est détecté, un FDM sera généré.

Redshift

Query
 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    INSERT INTO transaction_values_test values (a + 2);
    CALL transaction_test(a + 3);
END
$$;
Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    INSERT INTO transaction_values_test
    values (:a + 2);
    --** SSC-FDM-RS0006 - CALLED PROCEDURE CONTAINS USAGES OF COMMIT/ROLLBACK, MODIFYING THE CURRENT TRANSACTION IN CHILD SCOPES IS NOT SUPPORTED IN SNOWFLAKE **
    CALL transaction_test(:a + 3);
END
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes

  1. SSC-FDM-RS0006 : la procédure appelée contient des utilisations de COMMIT/ROLLBACK, la modification de la transaction en cours dans les champs d’application enfants n’est pas prise en charge dans Snowflake.

ROLLBACK

Description

Arrête la transaction en cours et annule toutes les mises à jour effectuées par cette transaction. (Référence linguistique ROLLBACK Redshift SQL)

Grammar Syntax

ROLLBACK [WORK | TRANSACTION]

Copy

Modèles d’échantillons de sources

Données de configuration

Redshift
Query
 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);
Copy
Snowflake
Query
 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);
Copy

ROLLBACK avec le mot-clé TRANSACTION

Le mot-clé TRANSACTION n’est pas pris en charge par Snowflake. Toutefois, comme il n’a pas d’incidence sur la fonctionnalité, il sera simplement supprimé.

Redshift
Query
 ROLLBACK TRANSACTION;
Copy
Snowflake
Query
 ROLLBACK;
Copy

ROLLBACK dans une procédure de comportement de transaction par défaut (sans clause NONATOMIC)

Afin d’éviter les exceptions de transactions hors champ d’application dans Snowflake, les utilisations de ROLLBACK seront mises en correspondance avec BEGIN TRANSACTION.

Lorsque plusieurs instructions de contrôle de transaction sont présentes dans la procédure, plusieurs instructions BEGIN TRANSACTION seront générées après chacune d’entre elles afin d’émuler le comportement de transaction de Redshift.

Redshift
Query
 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    COMMIT;
    insert into transaction_values_test values (80);
    insert into transaction_values_test values (55);
    ROLLBACK;
END
$$;

CALL transaction_test(120);

SELECT * FROM transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 120  |
+------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test values (:a);
    COMMIT;
    BEGIN TRANSACTION;
    insert into transaction_values_test values (80);
    insert into transaction_values_test values (55);
    ROLLBACK;
END
$$;

CALL transaction_test(120);

SELECT * FROM
    transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 120  |
+------+

Copy

ROLLBACK dans une procédure avec comportement NONATOMIC

Le comportement NONATOMIC de Redshift est émulé dans Snowflake à l’aide du paramètre de session AUTOCOMMIT défini sur true.

Since the AUTOCOMMIT session parameter is assumed to be true by SnowConvert AI, the ROLLBACK statement inside NONATOMIC procedures is left as is.

Redshift
Query
 CREATE OR REPLACE PROCEDURE nonatomic_procedure(a int)
    NONATOMIC
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test values (a + 2);
    INSERT INTO transaction_values_test values (a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE nonatomic_procedure (a int)
RETURNS VARCHAR
--    --** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--    NONATOMIC
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test
    values (:a + 2);
    INSERT INTO transaction_values_test
    values (:a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM
transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Copy

Problèmes connus

1. ROLLBACK à l’intérieur d’un appel de procédure imbriqué

Dans Redshift, lorsqu’une instruction ROLLBACK est spécifiée dans un appel de procédure imbriqué, la commande engage tout le travail en attente des instructions précédentes dans le champ d’application actuel et le champ d’application parent. La validation des actions du champ parent n’est pas prise en charge dans Snowflake, lorsque ce cas est détecté, un FDM sera généré.

Redshift

Query
 CREATE OR REPLACE PROCEDURE transaction_test(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    ROLLBACK;
    INSERT INTO transaction_values_test values (a + 1);
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    CALL transaction_test(a + 3);
    COMMIT;
END
$$;
Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE transaction_test (a int)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a);
    ROLLBACK;
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a + 1);
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test (a int)
RETURNS VARCHAR
    LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a);
    --** SSC-FDM-RS0006 - CALLED PROCEDURE CONTAINS USAGES OF COMMIT/ROLLBACK, MODIFYING THE CURRENT TRANSACTION IN CHILD SCOPES IS NOT SUPPORTED IN SNOWFLAKE **
    CALL transaction_test(:a + 3);
    COMMIT;
END
$$;
Copy

2. ROLLBACK des instructions DDL

Dans Snowflake, les instructions DDL effectuent un commit implicite chaque fois qu’elles sont exécutées à l’intérieur d’une procédure, rendant ainsi effectif tout le travail précédant l’exécution de DDL ainsi que de DDL lui-même. De ce fait, l’instruction ROLLBACK n’est pas en mesure d’écarter les modifications antérieures à ce point. Ce problème sera résolu à l’aide d’une instruction FDM.

Redshift
Query
 CREATE OR REPLACE PROCEDURE rollback_ddl(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    CREATE TABLE someRollbackTable
    (
        col1 INTEGER
    );

    INSERT INTO someRollbackTable values (a);
    ROLLBACK;
END
$$;
Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE rollback_ddl (a int)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a);
    CREATE TABLE someRollbackTable
    (
        col1 INTEGER
    );
    BEGIN TRANSACTION;
    INSERT INTO someRollbackTable
    values (:a);
    --** SSC-FDM-RS0007 - DDL STATEMENTS PERFORM AN AUTOMATIC COMMIT, ROLLBACK WILL NOT WORK AS EXPECTED **
    ROLLBACK;
END
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes

  1. SSC-FDM-RS0006 : la procédure appelée contient des utilisations de COMMIT/ROLLBACK, la modification de la transaction en cours dans les champs d’application enfants n’est pas prise en charge dans Snowflake.

  2. SSC-FDM-RS0007 : les instructions DDL effectuent un COMMIT automatique, ROLLBACK ne fonctionnera pas comme prévu.

TRUNCATE

Description

Supprime toutes les lignes d’une table sans effectuer de balayage de la table (Référence linguistique Redshift SQLTRUNCATE)

Grammar Syntax

TRUNCATE [TABLE] table_name

Copy

Modèles d’échantillons de sources

Données de configuration

Redshift
Query
 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);
Copy
Snowflake
Query
 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);
Copy

TRUNCATE dans une procédure de comportement de transaction par défaut (sans clause NONATOMIC)

Comme l’instruction TRUNCATE valide automatiquement la transaction dans laquelle elle est exécutée, chacune de ses utilisations génère une instruction COMMIT dans Snowflake pour émuler ce comportement.

Étant donné qu’une instruction COMMIT est générée, la même instruction BEGIN TRANSACTION sera appliquée à TRUNCATE. Pour plus d’informations, consultez la spécification de traduction COMMIT .

Redshift
Query
 CREATE OR REPLACE PROCEDURE truncate_in_procedure(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    TRUNCATE TABLE transaction_values_test;
    INSERT INTO transaction_values_test VALUES (a + 12);
    COMMIT;
END
$$;

CALL truncate_in_procedure(10);

SELECT * FROM transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 22   |
+------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE truncate_in_procedure (a int)
RETURNS VARCHAR
    LANGUAGE SQL
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    TRUNCATE TABLE transaction_values_test;
    COMMIT;
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a + 12);
    COMMIT;
END
$$;

CALL truncate_in_procedure(10);

SELECT * FROM
    transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 22   |
+------+

Copy

TRUNCATE dans une procédure avec comportement NONATOMIC

Le comportement NONATOMIC de Redshift est émulé dans Snowflake à l’aide du paramètre de session AUTOCOMMIT défini sur true.

Since the AUTOCOMMIT session parameter is assumed to be true by SnowConvert AI, the TRUNCATE statement inside NONATOMIC procedures is left as is, there is no need to generate a COMMIT statement because every statement is automatically commited when executed.

Redshift
Query
 CREATE OR REPLACE PROCEDURE nonatomic_procedure(a int)
    NONATOMIC
    LANGUAGE plpgsql
    AS $$
BEGIN
    TRUNCATE TABLE transaction_values_test;
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test values (a + 2);
    INSERT INTO transaction_values_test values (a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE nonatomic_procedure (a int)
RETURNS VARCHAR
--    --** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--    NONATOMIC
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    TRUNCATE TABLE transaction_values_test;
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test
    values (:a + 2);
    INSERT INTO transaction_values_test
    values (:a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM
transaction_values_test;
Copy
Result
+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Copy

Problèmes connus

1. TRUNCATE à l’intérieur d’un appel de procédure imbriqué

Dans Redshift, lorsqu’une instruction COMMIT est spécifiée dans un appel de procédure imbriqué, la commande engage tout le travail en attente des instructions précédentes dans le champ d’application actuel et le champ d’application parent. La validation des actions du champ parent n’est pas prise en charge dans Snowflake, lorsque ce cas est détecté, un FDM sera généré.

Redshift

Query
 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    TRUNCATE TABLE transaction_values_test;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    INSERT INTO transaction_values_test values (a + 2);
    CALL transaction_test(a + 3);
END
$$;
Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    TRUNCATE TABLE transaction_values_test;
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    INSERT INTO transaction_values_test
    values (:a + 2);
    --** SSC-FDM-RS0006 - CALLED PROCEDURE CONTAINS USAGES OF COMMIT/ROLLBACK, MODIFYING THE CURRENT TRANSACTION IN CHILD SCOPES IS NOT SUPPORTED IN SNOWFLAKE **
    CALL transaction_test(:a + 3);
END
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes

  1. SSC-FDM-RS0006 : la procédure appelée contient des utilisations de COMMIT/ROLLBACK, la modification de la transaction en cours dans les champs d’application enfants n’est pas prise en charge dans Snowflake.

CONDITIONS

CASE

Description

L’instruction CASE de Redshift vous permet de renvoyer des valeurs en fonction de conditions, ce qui permet une logique conditionnelle dans les requêtes. Elle a deux formes : simple et recherchée. (Référence linguistique Redshift SQL Conditionnels : Case).

Cas simple

Une simple instruction CASE fournit une exécution conditionnelle basée sur l’égalité des opérandes.

Note

Les Case simples sont entièrement pris en charge par Snowflake.

Grammar Syntax

 CASE search-expression
WHEN expression [, expression [ ... ]] THEN
  statements
[ WHEN expression [, expression [ ... ]] THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE proc1(x INT)
LANGUAGE plpgsql
AS $$
BEGIN
  CASE x
WHEN 1, 2 THEN
  NULL;
ELSE
  NULL;
END CASE;                  
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE proc1 (x INT)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/14/2025",  "domain": "test" }}'
AS $$
BEGIN
  CASE x
    WHEN 1 THEN
      NULL;
    WHEN 2 THEN
      NULL;
   ELSE
     NULL;
  END CASE;
END;
$$;
Copy

Cas recherché

Note

Les Case recherchés sont entièrement pris en charge par Snowflake.

Grammar Syntax

 CASE
WHEN boolean-expression THEN
  statements
[ WHEN boolean-expression THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE PROCEDURE PROC1 (paramNumber int)
LANGUAGE plpgsql
AS $$
DECLARE
    result VARCHAR(100);	
BEGIN
CASE
  WHEN paramNumber BETWEEN 0 AND 10 THEN
    result := 'value is between zero and ten';
  WHEN paramNumber BETWEEN 11 AND 20 THEN
    result := 'value is between eleven and twenty';
  END CASE;  
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE PROCEDURE PROC1 (paramNumber int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    DECLARE
      result VARCHAR(100);
      case_not_found EXCEPTION (-20002, 'Case not found.');
BEGIN
CASE
  WHEN paramNumber BETWEEN 0 AND 10 THEN
    result := 'value is between zero and ten';
  WHEN paramNumber BETWEEN 11 AND 20 THEN
    result := 'value is between eleven and twenty';
  ELSE
    RAISE case_not_found;
  END CASE;
END;
$$;
Copy

CASE sans ELSE

Dans Redshift, lorsqu’une expression CASE est exécutée et qu’aucune des conditions validées n’est remplie, et qu’il n’y a pas de ELSE défini, l’exception “CASE NOT FOUND” est déclenchée. Dans Snowflake, le code s’exécute mais ne renvoie aucun résultat. Pour conserver la même fonctionnalité dans Snowflake dans ce scénario, une exception portant le même nom sera déclarée et exécutée si aucune des conditions de CASE n’est remplie.

Note

Les Case sans Else sont entièrement pris en charge par Snowflake.

Code d’entrée :
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (input_value INT)
AS $$
BEGIN
  CASE input_value
  WHEN 1 THEN
   NULL;
  END CASE;
END;
$$ LANGUAGE plpgsql;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (input_value INT)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
    DECLARE
      case_not_found EXCEPTION (-20002, 'Case not found.');
BEGIN
  CASE input_value
  WHEN 1 THEN
   NULL;
  ELSE
   RAISE case_not_found;
  END CASE;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

IF

Description

Cette instruction vous permet de prendre des décisions en fonction de certaines conditions. (Référence linguistique Redshift SQL Conditionnels : IF).

SnowConvert AI will add the parenthesis in the conditions and change the keyword ELSIF by ELSEIF since Redshift does not require the parenthesis in the conditions and ELSIF is the keyword.

Grammar Syntax

 IF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
    ...] ]
[ ELSE
  statements ]
END IF;
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE PROCEDURE PROC1 (paramNumber int)
LANGUAGE plpgsql
AS $$
DECLARE
    result VARCHAR(100);	
BEGIN
    IF paramNumber = 0 THEN
      result := 'zero';
    ELSIF paramNumber > 0 THEN
      result := 'positive';
    ELSIF paramNumber < 0 THEN
      result := 'negative';
    ELSE
      result := 'NULL';
    END IF;
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE PROCEDURE PROC1 (paramNumber int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
        DECLARE
            result VARCHAR(100);
BEGIN
            IF (:paramNumber = 0) THEN
                result := 'zero';
            ELSEIF (:paramNumber > 0) THEN
                result := 'positive';
            ELSEIF (:paramNumber < 0) THEN
                result := 'negative';
              ELSE
                result := 'NULL';
            END IF;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

LOOPS

Description

Ces instructions sont utilisées pour répéter un bloc de code jusqu’à la condition spécifiée. (Référence linguistique Redshift SQL Boucles).

CONTINUE FOR LOOP WHILE EXIT

CONTINUE

Description

Lorsque les conditions CONTINUE sont true, la boucle peut continuer l’exécution, lorsqu’elles sont fausses, la boucle s’arrête. (Référence linguistique Redshift SQL Conditionnels : CONTINUE ).

Avertissement

CONTINUE sont partiellement pris en charge par Snowflake.

Grammar Syntax

 CONTINUE [ label ] [ WHEN expression ];
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (x INT)
    LANGUAGE plpgsql
AS $$
DECLARE
    i INTEGER := 0;
BEGIN
    <<simple_loop_when>>
    LOOP
        i := i + 1;
        CONTINUE WHEN i = 5;
        RAISE INFO 'i %', i;
        EXIT simple_loop_when WHEN (i >= x);
    END LOOP;
END;
$$;

CREATE OR REPLACE PROCEDURE procedure11 (x INT)
    LANGUAGE plpgsql
AS $$
DECLARE
    i INTEGER := 0;
BEGIN
    LOOP
        i := i + 1;
		IF (I = 5) THEN 
        	CONTINUE;
		END IF;
        RAISE INFO 'i %', i;
        EXIT WHEN (i >= x);
    END LOOP;
END;
$$;
Copy
Results

Sortie de la console

1

2

3

4

6

7

Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE procedure1 (x INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    		DECLARE
    			i INTEGER := 0;
BEGIN
    			--** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
    LOOP
        i := i + 1;
        IF (:i = 5) THEN
        	CONTINUE;
        END IF;
        CALL RAISE_MESSAGE_UDF('INFO', 'i %', array_construct(:i));
        IF ((:i >= : x)) THEN
        	EXIT simple_loop_when;
        END IF;
    END LOOP simple_loop_when;
END;
$$;

CREATE OR REPLACE PROCEDURE procedure11 (x INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    		DECLARE
    			i INTEGER := 0;
BEGIN
    			--** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
    LOOP
        i := i + 1;
		IF (:I = 5) THEN
        	CONTINUE;
		END IF;
        CALL RAISE_MESSAGE_UDF('INFO', 'i %', array_construct(:i));
        IF ((:i >= : x)) THEN
        	EXIT;
        END IF;
    END LOOP;
END;
$$;
Copy
Results

Sortie de la console

1

2

3

4

6

7

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

EXIT

Description

Arrêtez l’exécution de la boucle lorsque les conditions définies dans l’instruction WHEN sont true (Reférence linguistique Redshift SQL Conditionnels : EXIT).

Avertissement

EXIT sont partiellement pris en charge par Snowflake.

Grammar Syntax

 EXIT [ label ] [ WHEN expression ];
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE simple_loop_when(x int)
LANGUAGE plpgsql
AS $$
DECLARE i INTEGER := 0;
BEGIN
  <<simple_loop_when>>
  LOOP
    RAISE INFO 'i %', i;
    i := i + 1;
    EXIT simple_loop_when WHEN (i >= x);
  END LOOP;
END;
$$;   
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE simple_loop_when (x int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    DECLARE
      i INTEGER := 0;
BEGIN
      --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
  LOOP
        CALL RAISE_MESSAGE_UDF('INFO', 'i %', array_construct(:i));
    i := i + 1;
        IF ((:i >= : x)) THEN
          EXIT simple_loop_when;
        END IF;
  END LOOP simple_loop_when;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

FOR

Grammar Syntax

Variante entière

 [<<label>>]
FOR name IN [ REVERSE ] expression .. expression LOOP
  statements
END LOOP [ label ];
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE procedure1 ()
AS $$
BEGIN
  FOR i IN 1..10 LOOP
    NULL;
  END LOOP;

  FOR i IN REVERSE 10..1 LOOP
    NULL;
  END LOOP;
END;
$$ LANGUAGE plpgsql;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
BEGIN
  FOR i IN 1 TO 10
                   --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
                   LOOP
    NULL;
  END LOOP;

  FOR i IN REVERSE 10 TO 1
                           --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
                           LOOP
    NULL;
  END LOOP;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

  1. SSC-EWI-PG0006: Reference a variable using the Label is not supported by Snowflake.

LOOP

Description

Une boucle simple définit une boucle inconditionnelle qui est répétée indéfiniment jusqu’à ce qu’elle soit terminée par une instruction EXIT ou RETURN. (Référence linguistique Redshift SQL Conditionnels : Simple Loop).

Avertissement

Les Simple Loop sont partiellement prises en charge par Snowflake.

Grammar Syntax

 [<<label>>]
LOOP
  statements
END LOOP [ label ];
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE simple_loop()
LANGUAGE plpgsql
AS $$
BEGIN
  <<simple_while>>
  LOOP
    RAISE INFO 'I am raised once';  
    EXIT simple_while;
    RAISE INFO 'I am not raised';
  END LOOP;
  RAISE INFO 'I am raised once as well';
END;
$$;   
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE simple_loop ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
BEGIN
  --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
  LOOP
    CALL RAISE_MESSAGE_UDF('INFO', 'I am raised once');
    EXIT simple_while;
    CALL RAISE_MESSAGE_UDF('INFO', 'I am not raised');
  END LOOP simple_while;
  CALL RAISE_MESSAGE_UDF('INFO', 'I am raised once as well');
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

WHILE

Grammar Syntax

 [<<label>>]
WHILE expression LOOP
  statements
END LOOP [ label ];
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE simple_loop_when()
    LANGUAGE plpgsql
AS $$
DECLARE
    i INTEGER := 0;
BEGIN
    WHILE I > 5 AND I > 10 LOOP
        NULL;
    END LOOP;   
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE simple_loop_when ()
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
            DECLARE
                i INTEGER := 0;
BEGIN
                WHILE (:I > 5 AND : I > 10)
                                            --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
                                            LOOP
        NULL;
    END LOOP;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

CURSORS

CLOSE CURSOR

Description

Ferme toutes les ressources libres associées à un curseur ouvert. (Référence linguistique Redshift SQL Close Cursor ).

Note

Cette syntaxe est entièrement prise en charge par Snowflake.

Grammar Syntax

 CLOSE cursor
Copy

Modèles d’échantillons de sources

Code d’entrée :

Redshift
 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   CLOSE cursor1;
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE cursor_test ()
RETURNS VARCHAR
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/05/2025",  "domain": "test" }}'
AS $$
BEGIN
   CLOSE cursor1;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

FETCH CURSOR

Description

Récupère les lignes à l’aide d’un curseur. (Référence linguistique Redshift SQL Fetch)

Informations sur la transformation

 FETCH [ NEXT | ALL | {FORWARD [ count | ALL ] } ] FROM cursor

FETCH cursor INTO target [, target ...];
Copy

Modèles d’échantillons de sources

Données de configuration

Redshift
Query
 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');
Copy
Snowflake
Query
 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');
Copy

Fetch into

L’instruction FETCH into de Redshift est totalement équivalente dans Snowflake

Redshift
Query
 CREATE OR REPLACE PROCEDURE fetch_into_example()
LANGUAGE plpgsql
AS $$
DECLARE my_cursor CURSOR FOR
        SELECT col1, col2
        FROM cursor_example;
        some_id INT;
        message VARCHAR(20);
BEGIN
    OPEN my_cursor;
    FETCH my_cursor INTO some_id, message;
    CLOSE my_cursor;
    INSERT INTO cursor_example VALUES (some_id * 10, message || ' world!');
END;
$$;

CALL fetch_into_example();

SELECT * FROM cursor_example;
Copy
Result
+------+-------------+
| col1 | col2        |
+------+-------------+
| 10   | hello       |
| 100  | hello world!|
+------+-------------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE fetch_into_example ()
RETURNS VARCHAR
LANGUAGE SQL
AS $$
DECLARE
    my_cursor CURSOR FOR
    SELECT col1, col2
    FROM
    cursor_example;
    some_id INT;
    message VARCHAR(20);
BEGIN
    OPEN my_cursor;
    FETCH my_cursor INTO some_id, message;
    CLOSE my_cursor;
    INSERT INTO cursor_example
			VALUES (:some_id * 10, :message || ' world!');
END;
$$;

CALL fetch_into_example();

SELECT * FROM
	cursor_example;
Copy
Result
+------+-------------+
| col1 | col2        |
+------+-------------+
| 10   | hello       |
| 100  | hello world!|
+------+-------------+

Copy

Problèmes connus

1. La recherche sans variables cibles n’est pas prise en charge

Snowflake exige que l’instruction FETCH spécifie la clause INTO avec les variables dans lesquelles les valeurs des lignes récupérées seront stockées. Lorsqu’une instruction FETCH est trouvée dans le code sans clause INTO, un EWI est généré.

Code d’entrée :

 FETCH FORWARD FROM cursor1;
Copy

Code de sortie :

 !!!RESOLVE EWI!!! /*** SSC-EWI-PG0015 - FETCH CURSOR WITHOUT TARGET VARIABLES IS NOT SUPPORTED IN SNOWFLAKE ***/!!!
FETCH FORWARD FROM cursor1;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes

  1. SSC-EWI-PG0015: Fetch cursor without target variables is not supported in Snowflake

OPEN CURSOR

Description

Avant de pouvoir utiliser un curseur pour récupérer des lignes, il faut l’ouvrir. (Référence linguistique Redshift SQL Open Cursor).

Note

Cette syntaxe est entièrement prise en charge par Snowflake.

Grammar Syntax

 OPEN bound_cursor_name [ ( argument_values ) ];
Copy

Modèles d’échantillons de sources

Données de configuration

Redshift
Query
 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

CREATE TABLE cursor_example_results
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');
Copy
Snowflake
Query
 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

CREATE TABLE cursor_example_results
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');
Copy

Ouvrir le curseur sans arguments

Code d’entrée :
Redshift
 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   OPEN cursor1;
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE cursor_test ()
RETURNS VARCHAR
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/05/2025",  "domain": "test" }}'
AS $$
BEGIN
   OPEN cursor1;
END;
$$;
Copy

Ouvrir le curseur avec des arguments

Cursor arguments have to be binded per each one of its uses, SnowConvert AI will generate the bindings, was well as reorder and repeat the passed values to the OPEN statement as needed to satisfy the bindings.

Redshift
Query
 CREATE OR REPLACE PROCEDURE cursor_open_test()
LANGUAGE plpgsql
AS $$
DECLARE
    cursor2 CURSOR (val1 VARCHAR(20), val2 INTEGER) FOR SELECT col1 + val2, col2 FROM cursor_example where val1 = col2 and val2 > col1;
    res1 INTEGER;
    res2 VARCHAR(20);
BEGIN
    OPEN cursor2('hello', 50);
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results VALUES (res1, res2);
END;
$$;

call cursor_open_test();

SELECT * FROM cursor_example_results;
Copy
Result
+------+-------+
| col1 | col2  |
+------+-------+
| 60   | hello |
+------+-------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE cursor_open_test ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
        DECLARE
            cursor2 CURSOR FOR SELECT col1 + ?, col2 FROM
                cursor_example
            where
                ? = col2 and ? > col1;
            res1 INTEGER;
            res2 VARCHAR(20);
BEGIN
    OPEN cursor2 USING (50, 'hello', 50);
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results
            VALUES (:res1, : res2);
END;
$$;

call cursor_open_test();
SELECT * FROM
cursor_example_results;
Copy
Result
+------+-------+
| col1 | col2  |
+------+-------+
| 60   | hello |
+------+-------+

Copy

Ouvrir le curseur avec les paramètres de la procédure ou les variables locales

The procedure parameters or local variables have to be binded per each one of its uses in the cursor query, SnowConvert AI will generate the bindings and add the parameter or variable names to the OPEN statement, even if the cursor originally had no parameters.

Redshift
Query
 CREATE OR REPLACE PROCEDURE cursor_open_test(someValue iNTEGER)
LANGUAGE plpgsql
AS $$
DECLARE
    charVariable VARCHAR(20) DEFAULT 'hello';
    cursor2 CURSOR FOR SELECT col1 + someValue, col2 FROM cursor_example where charVariable = col2 and someValue > col1;
    res1 INTEGER;
    res2 VARCHAR(20);
BEGIN
    OPEN cursor2;
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results VALUES (res1, res2);
END;
$$;

call cursor_open_test(30);
Copy
Result
+------+-------+
| col1 | col2  |
+------+-------+
| 40   | hello |
+------+-------+

Copy
Snowflake
Query
 CREATE OR REPLACE PROCEDURE cursor_open_test (someValue iNTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
        DECLARE
            charVariable VARCHAR(20) DEFAULT 'hello';
            cursor2 CURSOR FOR SELECT col1 + ?, col2 FROM
                cursor_example
            where
                ? = col2 and ? > col1;
            res1 INTEGER;
            res2 VARCHAR(20);
BEGIN
    OPEN cursor2 USING (someValue, charVariable, someValue);
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results
            VALUES (:res1, : res2);
END;
$$;

call cursor_open_test(30);
Copy
Result
+------+-------+
| col1 | col2  |
+------+-------+
| 40   | hello |
+------+-------+

Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

DECLARE CURSOR

Description

Définit un nouveau curseur. Utilisez un curseur pour récupérer quelques lignes à la fois dans le jeu de résultats d’une requête plus importante. (Référence linguistique Redshift SQL Declare Cursor).

Note

Cette syntaxe est entièrement prise en charge par Snowflake.

Grammar Syntax

 name CURSOR [ ( arguments ) ] FOR query 
Copy

Modèles d’échantillons de sources

Code d’entrée :

Code d’entrée :

Redshift

 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
DECLARE
   -- Declare the cursor
   cursor1 CURSOR FOR SELECT 1;
   cursor2 CURSOR (key integer) FOR SELECT 2 where 1 = key;
   
BEGIN
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE cursor_test ()
RETURNS VARCHAR
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
      DECLARE
         -- Declare the cursor
         cursor1 CURSOR FOR SELECT 1;
         cursor2 CURSOR FOR SELECT 2 where 1 = ?;
BEGIN
         NULL;
END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.

DECLARE REFCURSOR

Description

Le type de données refcursor contient simplement une référence à un curseur. Vous pouvez créer une variable curseur en la déclarant comme une variable de type refcursor

(Référence linguistique Redshift SQL Déclaration Refcursor)

Note

Les déclarations de curseurs sont entièrement prises en charge par Snowflake.

Grammar Syntax

 DECLARE
name refcursor;
Copy

Snowflake ne prenant pas en charge le type de données REFCURSOR, sa fonctionnalité est répliquée en convertissant la variable REFCURSOR en un type RESULTSET. La requête utilisée pour ouvrir REFCURSOR est affectée à la variable RESULTSET, après quoi un nouveau curseur est créé et lié à la variable RESULTSET. En outre, toutes les références au REFCURSOR d’origine dans la logique du curseur sont mises à jour pour utiliser le nouveau curseur, répliquant ainsi la fonctionnalité originale.

Modèles d’échantillons de sources

Cas : Usage unique

Code d’entrée :
Redshift
 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR()
LANGUAGE plpgsql
AS $$
DECLARE
  v_curs1 refcursor;
BEGIN
  OPEN v_curs1 FOR SELECT column1_name, column2_name FROM your_table;
-- Cursor logic
  CLOSE v_curs1;
 END;
$$;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
  DECLARE
   v_curs1 RESULTSET;
BEGIN
   v_curs1 := (
    SELECT column1_name, column2_name FROM your_table
   );
   LET v_curs1_Resultset_1 CURSOR
   FOR
    v_curs1;
   OPEN v_curs1_Resultset_1;
-- Cursor logic
  CLOSE v_curs1_Resultset_1;
 END;
$$;
Copy
Cas : Curseur avec Sql dynamique
Code d’entrée :
Redshift
 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC(min_salary NUMERIC)
LANGUAGE plpgsql
AS $$
DECLARE
    cur refcursor;
    qry TEXT;
BEGIN
    qry := 'SELECT id, name FROM employees WHERE salary > ' || min_salary;

    OPEN cur FOR EXECUTE qry;
-- Cursor logic
    CLOSE cur;
END;
$$;


CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC2(min_salary NUMERIC)
LANGUAGE plpgsql
AS $$
DECLARE
    cur refcursor;
BEGIN
    OPEN cur FOR EXECUTE 'SELECT id, name FROM employees WHERE salary > ' || min_salary;
-- Cursor logic
    CLOSE cur;
END;
$$;
Copy
Code de sortie :
Redshift
 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC (min_salary NUMERIC)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
        DECLARE
            cur RESULTSET;
    qry TEXT;
BEGIN
    qry := 'SELECT id, name FROM employees WHERE salary > ' || min_salary;
            cur := (
                EXECUTE IMMEDIATE qry
            );
            LET cur_Resultset_1 CURSOR
            FOR
                cur;
            OPEN cur_Resultset_1;
-- Cursor logic
    CLOSE cur_Resultset_1;
END;
$$;


CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC2 (min_salary NUMERIC)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
        DECLARE
            cur RESULTSET;
BEGIN
            cur := (
                EXECUTE IMMEDIATE 'SELECT id, name FROM employees WHERE salary > ' || min_salary
            );
            LET cur_Resultset_2 CURSOR
            FOR
                cur;
            OPEN cur_Resultset_2;
-- Cursor logic
    CLOSE cur_Resultset_2;
END;
$$;
Copy
Cas : Utilisations multiples :
Code d’entrée :
Redshift
 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR()
LANGUAGE plpgsql
AS $$
DECLARE
  v_curs1 refcursor;
BEGIN
  OPEN v_curs1 FOR SELECT column1_name, column2_name FROM your_table;
-- Cursor logic
  CLOSE v_curs1;
  OPEN v_curs1 FOR SELECT column3_name, column4_name FROM your_table2;
-- Cursor logic
  CLOSE v_curs1;
 END;
$$;
Copy
Code de sortie :
Snowflake
 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
  DECLARE
   v_curs1 RESULTSET;
BEGIN
   v_curs1 := (
    SELECT column1_name, column2_name FROM your_table
   );
   LET v_curs1_Resultset_1 CURSOR
   FOR
    v_curs1;
   OPEN v_curs1_Resultset_1;
-- Cursor logic
  CLOSE v_curs1_Resultset_1;
   v_curs1 := (
    SELECT column3_name, column4_name FROM your_table2
   );
   LET v_curs1_Resultset_2 CURSOR
   FOR
    v_curs1;
   OPEN v_curs1_Resultset_2;
-- Cursor logic
  CLOSE v_curs1_Resultset_2;
 END;
$$;
Copy

Problèmes connus

Il n’y a pas de problème connu.

EWIs connexes.

Il n’y a aucun EWIs associé.