SnowConvert AI - Redshift - CREATE PROCEDURE

Beschreibung

Erzeugt eine neue gespeicherte Prozedur oder ersetzt eine bestehende Prozedur für die aktuelle Datenbank. ([Redshift SQL-Referenz: Create Procedure](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_PROCEDURE. html)).

In den folgenden Definitionen finden Sie weitere Informationen zu Prozedurklauseln:

Grammatikalische Syntax

Im Folgenden finden Sie die SQL-Syntax zum Erstellen einer Prozedur in Amazon Redshift. Klicken Sie [hier](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_PROCEDURE. html) bis hier, um zur Redshift-Spezifikation für diese Syntax zu gelangen.

 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

Beispielhafte Quellcode-Muster

Eingabecode:

Redshift

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

Ausgabecode:

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

Beschreibung

Wenn in der Signatur der gespeicherten Prozedur der Name des Arguments fehlt, können Sie einen Alias für das Argument deklarieren.

In Snowflake gibt es dafür keine Unterstützung.

Um eine Funktionsäquivalenz zu erreichen, werden die Aliase entfernt und alle Verwendungen umbenannt.

Wenn ein Alias für einen Parameter namenslos deklariert wird, wird ein generierter Name für den Parameter und die Verwendungen erstellt. Wenn der Alias für einen Parameter mit Namen steht, wird der Alias durch den echten Parameternamen ersetzt.

Grammatikalische Syntax

 name ALIAS FOR $n;
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

ARGUMENTS MODE

Beschreibung

Gespeicherte Prozeduren in Amazon Redshift unterstützen Parameter, die beim Aufruf der Prozedur übergeben werden können. Mit diesen Parametern können Sie Eingabewerte bereitstellen, Ausgabewerte abrufen oder sie für Eingabe- und Ausgabeoperationen verwenden. Im Folgenden finden Sie eine ausführliche Deklaration der Parametertypen, ihrer Modi und Beispiele für ihre Verwendung. Snowflake unterstützt nur Eingabewerte.

IN (Eingabeparameter)

Zweck: Wird verwendet, um Werte an die Prozedur zu übergeben.

Standardmodus: Wenn kein Modus angegeben wird, werden die Parameter als IN betrachtet.

Verhalten: An die Prozedur übergebene Werte können innerhalb der Prozedur nicht geändert werden.

OUT (Ausgabeparameter)

Zweck: Wird verwendet, um Werte aus der Prozedur zurückzugeben.

Verhalten: Parameter können innerhalb der Prozedur geändert werden und werden an den Aufrufer zurückgegeben. Sie können keinen Anfangswert senden.

INOUT (Eingabe-/Ausgabeparameter)

Zweck: Wird verwendet, um Werte an die Prozedur zu übergeben und sie zu ändern, um aktualisierte Werte zurückzugeben.

Verhalten: Kombiniert die Verhaltensweise von IN und OUT. Sie müssen unabhängig von der Ausgabe einen Anfangswert senden.

Grammatikalische Syntax

 [ argname ] [ argmode ] argtype
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

Redshift
CREATE OR REPLACE PROCEDURE SP_PARAMS(
IN PARAM1 INTEGER,
OUT PARAM2 INTEGER,
INOUT PARAM3 INTEGER)
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs

  1. [SCC-EWI-0028](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0028) : Typ wird von Snowflake nicht unterstützt.

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

PROCEDURE BODY

Beschreibung

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

Grammatikalische Syntax

 AS
$Alias$
  procedure_body
$Alias$ 
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

Redshift
 CREATE OR REPLACE PROCEDURE SP()
AS 
$somename$
BEGIN
   NULL;
END;
$somename$ 
LANGUAGE plpgsql;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

BLOCK STATEMENT

Beschreibung

PL/pgSQL ist eine blockstrukturierte Sprache. Der gesamte Body einer Prozedur wird in einem Block definiert, der Variablendeklarationen und PL/pgSQL-Anweisungen enthält. Eine Anweisung kann auch ein verschachtelter Block oder Unterblock sein.

Grammatikalische Syntax

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

Beispielhafte Quellcode-Muster

Eingabecode:

Redshift
 CREATE OR REPLACE PROCEDURE MY_PROCEDURE() 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

DECLARE

Beschreibung

Abschnitt, um alle Prozedurvariablen mit Ausnahme der Schleifenvariablen zu deklarieren. Redshift unterstützt mehrere DECLARE-Abschnitte pro Blockanweisung, da Snowflake dieses Verhaltensweise nicht unterstützt, müssen sie in einer einzigen Deklarationsanweisung pro Block zusammengefasst werden.

Grammatikalische Syntax

 [ DECLARE declarations ]
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

EXCEPTION

Beschreibung

Wenn eine Ausnahme auftritt und Sie einen Block für die Ausnahmebehandlung hinzufügen, können Sie RAISE-Anweisungen und die meisten anderen PL/pgSQL Anweisungen schreiben. Sie können zum Beispiel eine Ausnahme mit einer benutzerdefinierten Meldung auslösen oder einen Datensatz in eine Protokolltabelle einfügen.

Grammatikalische Syntax

 EXCEPTION
  WHEN OTHERS THEN
    statements
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

LABEL

Beschreibung

Labels werden in Redshift verwendet, um einen Block zu qualifizieren oder um die Anweisung EXIT oder END zu verwenden. Snowflake unterstützt keine Etiketten.

Warnung

Da Etiketten in Snowflake nicht unterstützt werden, wird ein EWI gedruckt.

Grammatikalische Syntax

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

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs

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

NONATOMIC

Beschreibung

Die NONATOMIC überträgt nach jeder Anweisung in der gespeicherten Prozedur. Snowflake unterstützt einen AUTOCOMMIT-Parameter. Die Standardeinstellung für AUTOCOMMIT ist TRUE (aktiviert).

Wenn AUTOCOMMIT aktiviert ist, wird jede Anweisung außerhalb einer expliziten Transaktion so behandelt, als befände sie sich innerhalb ihrer impliziten Einzelanweisungstransaktion. Mit anderen Worten, diese Anweisung wird automatisch ausgeführt, wenn sie erfolgreich ist, und automatisch zurückgesetzt, wenn sie fehlschlägt. Mit anderen Worten: Snowflake funktioniert „standardmäßig“ als NONATOMIC.

Grammatikalische Syntax

 NONATOMIC
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

Redshift
 CREATE OR REPLACE PROCEDURE SP_NONATOMIC()
NONATOMIC 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

POSITIONAL ARGUMENTS

Beschreibung

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.

Grammatikalische Syntax

 $n
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

RAISE

Beschreibung

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

(Redshift SQL Language Reference RAISE)

Note

RAISE are fully supported by Snowflake.

Grammatikalische Syntax

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

In Amazon Redshift wird die Anweisung RAISE verwendet, um Meldungen in der Konsole zu erzeugen oder benutzerdefinierte Ausnahmen auszulösen. Redshift ermöglicht es Ihnen, verschiedene Levels anzugeben, um den Schweregrad der Nachricht zu kennzeichnen. In Snowflake kann diese Funktionalität mit einer benutzerdefinierten Funktion (UDF) emuliert werden, die je nach angegebener Stufe einen Aufruf an die Konsole vornimmt.

  1. Ausnahme: \ Wenn der Level „EXCEPTION“ ist, wird eine benutzerdefinierte Ausnahme mit einer allgemeinen Meldung ausgelöst: „Um die EXCEPTION MESSAGE zu sehen, müssen Sie das Protokoll überprüfen.“ Der Ausnahmecode lautet -20002, der den Benutzer darüber informiert, dass die benutzerdefinierte Meldung in den Protokollen zu finden ist. Dies liegt an den Beschränkungen beim Senden von benutzerdefinierten Ausnahmen in Snowflake.

  2. Warnung: \ Wenn der Level WARNING ist, wird SYSTEM$LOG_WARN verwendet, um die Warnmeldung in das Snowflake-Protokoll zu drucken, was dazu beiträgt, mögliche Probleme hervorzuheben, ohne den Ausführungsfluss zu unterbrechen.

  3. Info: \ Für jedes andere Level (wie z. B. „INFO“) wird SYSTEM$LOG_INFO verwendet, um die Meldung in das Konsolenprotokoll zu drucken. So erhalten Sie eine detailliertere Rückmeldung über den Zustand des Systems, ohne kritische Störungen zu verursachen.

Dieser Ansatz ermöglicht es, die Funktionalität der Schweregrade von Redshift zu emulieren, sie an die Syntax und die Features von Snowflake anzupassen und gleichzeitig die Flexibilität und Kontrolle über die während der Ausführung generierten Meldungen und Ausnahmen zu behalten.

Beschränkungen

  • Um Protokolle in Snowflake einsehen zu können, benötigen Sie bestimmte Berechtigungen, wie z. B. die Rollen ACCOUNTADMIN oder SECURITYADMIN.

  • Die Protokolle in Snowflake sind nicht sofort verfügbar und können eine leichte Verzögerung aufweisen, bevor die Informationen sichtbar sind.

  • Personalisierte Fehlermeldungen in Ausnahmen werden nicht wie in Redshift angezeigt. Um benutzerdefinierte Nachrichten anzuzeigen, müssen Sie direkt auf die Protokolle zugreifen.

For further information, please refer to the following page.

Beispielhafte Quellcode-Muster

Eingabecode:

Redshift
 CREATE OR REPLACE PROCEDURE raise_example(IN user_id INT)
LANGUAGE plpgsql
AS $$
BEGIN
	RAISE EXCEPTION 'User % not exists.', user_id;
END;
$$;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

RETURN

Beschreibung

Die Anweisung RETURN kehrt von einer gespeicherten Prozedur zum Aufrufer zurück. (Redshift SQL-Referenz: Return).

Die Konvertierung der Rückgabeanweisung von Amazon Redshift zu Snowflake ist unkompliziert, es muss lediglich eine NULL zur Rückgabeanweisung auf Snowflake hinzugefügt werden.

Grammatikalische Syntax

 RETURN;
Copy

Beispielhafte Quellcode-Muster

Simple Case

Eingabecode:
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 ()
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;
Copy
Ausgabecode:
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

Wenn die Prozedur über Out-Parameter verfügt

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.

Eingabecode:
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (OUT output_value VARCHAR)
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

SECURITY (DEFINER | INVOKER)

Beschreibung

Die SECURITY-Klausel in den gespeicherte Prozeduren in Amazon Redshift definiert den Zugriffssteuerungs- und Berechtigungskontext, unter dem die Prozedur ausgeführt wird. Damit wird festgelegt, ob die Prozedur die Berechtigungen des Eigentümers (Ersteller) oder des Aufrufers (Benutzer, der die Prozedur aufruft) verwendet.

Grammatikalische Syntax

 [ { SECURITY INVOKER | SECURITY DEFINER } ]  
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

VARIABLE DECLARATION

Beschreibung

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

(Redshift SQL Language Reference Variable Declaration)

Note

Variablendeklarationen werden von Snowflake vollständig unterstützt.

Grammatikalische Syntax

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

In Redshift verhindert das Schlüsselwort CONSTANT die Neuzuweisung von Variablen während der Ausführung. Da Snowflake dieses Schlüsselwort nicht unterstützt, wird es bei der Transformation entfernt. Dies hat keinen Einfluss auf die Funktionalität, da die Logik nicht versuchen sollte, eine konstante Variable neu zuzuweisen.

Die NOT NULL-Einschränkung in Redshift stellt sicher, dass einer Variablen kein Nullwert zugewiesen werden kann und erfordert einen Standardwert, der nicht Null ist. Da Snowflake diese Einschränkung nicht unterstützt, wird sie bei der Transformation entfernt. Der Standardwert wird jedoch beibehalten, um die Funktionalität zu erhalten.

Eine Variable, die mit einem Refcursor deklariert wurde, wird in den Typ Resultset umgewandelt, für weitere Informationen DECLARE REFCURSOR.

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es wurden keine Probleme gefunden.

Zugehörige EWIs

  1. [SSC-FDM-PG0012](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/postgresqlFDM. md#ssc-fdm-pg0012): NOT NULL-Einschränkung wurde entfernt. Die Zuweisung von NULL an diese Variable führt nicht mehr zu einem Fehler.

TRANSACTIONS

COMMIT

Beschreibung

Bestätigt die aktuelle Transaktion in der Datenbank. Dieser Befehl macht die Datenbankaktualisierungen aus der Transaktion dauerhaft. (Redshift SQL-Referenz: COMMIT)

Grammatikalische Syntax

COMMIT [WORK | TRANSACTION]

Copy

Beispielhafte Quellcode-Muster

Datenkonfiguration

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

COMMIT mit dem Schlüsselwort TRANSACTION

Das Schlüsselwort TRANSACTION wird in Snowflake nicht unterstützt. Da es jedoch keine Auswirkungen auf die Funktionalität hat, wird es einfach entfernt.

Redshift
Query
 COMMIT TRANSACTION;
Copy
Snowflake
Query
 COMMIT;
Copy

COMMIT in einer Prozedur für das Standard-Transaktionsverhalten (ohne NONATOMIC-Klausel)

Um Ausnahmen bei Transaktionen außerhalb des Geltungsbereichs in Snowflake zu vermeiden, werden die Verwendungen von COMMIT mit BEGIN TRANSACTION abgeglichen.

Wenn mehrere COMMIT Anweisungen in der Prozedur vorhanden sind, werden nach jeder COMMIT-Anweisung mehrere BEGIN TRANSACTION-Anweisungen generiert, um das Transaktionsverhalten von Redshift zu emulieren.

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 in einer Prozedur mit NONATOMIC-Verhalten

Die NONATOMIC-Verhaltensweise von Redshift wird in Snowflake durch die Verwendung des Sitzungsparameters AUTOCOMMIT emuliert, der auf „true“ gesetzt ist.

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

Bekannte Probleme

1. COMMIT innerhalb eines verschachtelten Prozeduraufrufs

Wenn in Redshift eine COMMIT-Anweisung in einem verschachtelten Prozeduraufruf angegeben wird, überträgt der Befehl alle ausstehenden Arbeiten von vorherigen Anweisungen im aktuellen und übergeordneten Bereich. Die Übergabe der Aktionen des übergeordneten Bereichs wird in Snowflake nicht unterstützt. Wenn dieser Fall erkannt wird, wird eine FDM generiert.

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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs

  1. [SSC-FDM-RS0006](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/redshiftFDM. md#ssc-fdm-rs0006): Die aufgerufene Prozedur enthält Verwendungen von COMMIT/ROLLBACK, das Ändern der aktuellen Transaktion in untergeordneten Bereichen wird in Snowflake nicht unterstützt.

ROLLBACK

Beschreibung

Stoppt die aktuelle Transaktion und verwirft alle von dieser Transaktion vorgenommenen Aktualisierungen. (Redshift SQL-Referenz: ROLLBACK)

Grammatikalische Syntax

ROLLBACK [WORK | TRANSACTION]

Copy

Beispielhafte Quellcode-Muster

Datenkonfiguration

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

ROLLBACK mit dem Schlüsselwort TRANSACTION

Das Schlüsselwort TRANSACTION wird in Snowflake nicht unterstützt. Da es jedoch keine Auswirkungen auf die Funktionalität hat, wird es einfach entfernt.

Redshift
Query
 ROLLBACK TRANSACTION;
Copy
Snowflake
Query
 ROLLBACK;
Copy

ROLLBACK in einer Prozedur für das Standard-Transaktionsverhalten (ohne NONATOMIC-Klausel)

Um Ausnahmen bei Transaktionen außerhalb des Geltungsbereichs in Snowflake zu vermeiden, werden die Verwendungen von ROLLBACK mit BEGIN TRANSACTION abgeglichen.

Wenn mehrere Transaktionssteuerungsanweisungen in der Prozedur vorhanden sind, werden nach jeder dieser Anweisungen mehrere BEGIN TRANSACTION-Anweisungen generiert, um das Transaktionsverhalten von Redshift zu emulieren.

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 in einer Prozedur mit NONATOMIC-Verhalten

Die NONATOMIC-Verhaltensweise von Redshift wird in Snowflake durch die Verwendung des Sitzungsparameters AUTOCOMMIT emuliert, der auf „true“ gesetzt ist.

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

Bekannte Probleme

1. ROLLBACK innerhalb eines verschachtelten Prozeduraufrufs

Wenn in Redshift eine ROLLBACK-Anweisung in einem verschachtelten Prozeduraufruf angegeben wird, überträgt der Befehl alle ausstehenden Arbeiten von vorherigen Anweisungen im aktuellen und übergeordneten Bereich. Die Übergabe der Aktionen des übergeordneten Bereichs wird in Snowflake nicht unterstützt. Wenn dieser Fall erkannt wird, wird eine FDM generiert.

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 von DDL-Anweisungen

In Snowflake führen DDL-Anweisungen eine implizite Übergabe durch, wenn sie innerhalb einer Prozedur ausgeführt werden. Dadurch wird die gesamte Arbeit vor der Ausführung der DDL sowie die DDL selbst wirksam. Dies führt dazu, dass die Anweisung ROLLBACK nicht in der Lage ist, Änderungen vor diesem Zeitpunkt zu verwerfen. Dieses Problem wird durch eine FDM mitgeteilt.

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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs

  1. [SSC-FDM-RS0006](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/redshiftFDM. md#ssc-fdm-rs0006): Die aufgerufene Prozedur enthält Verwendungen von COMMIT/ROLLBACK, das Ändern der aktuellen Transaktion in untergeordneten Bereichen wird in Snowflake nicht unterstützt.

  2. [SSC-FDM-RS0007](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/redshiftFDM. md#ssc-fdm-rs0007): DDL-Anweisungen führen eine automatische COMMIT durch, ROLLBACK wird nicht wie erwartet funktionieren.

TRUNCATE

Beschreibung

Löscht alle Zeilen aus einer Tabelle, ohne einen Tabellenscan durchzuführen(Redshift SQL-Referenz: TRUNCATE)

Grammatikalische Syntax

TRUNCATE [TABLE] table_name

Copy

Beispielhafte Quellcode-Muster

Datenkonfiguration

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

TRUNCATE in einer Prozedur für das Standard-Transaktionsverhalten (ohne NONATOMIC-Klausel)

Da die Anweisung TRUNCATE die Transaktion, in der sie ausgeführt wird, automatisch festschreibt, erzeugt jede ihrer Verwendungen eine Anweisung COMMIT in Snowflake, um diese Verhaltensweise zu emulieren.

Da eine COMMIT-Anweisung generiert wird, wird die gleiche BEGIN TRANSACTION-Anweisung auch für TRUNCATE generiert. Weitere Informationen finden Sie in der COMMIT-Übersetzungsspezifikation.

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 in einer Prozedur mit NONATOMIC-Verhalten

Die NONATOMIC-Verhaltensweise von Redshift wird in Snowflake durch die Verwendung des Sitzungsparameters AUTOCOMMIT emuliert, der auf „true“ gesetzt ist.

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

Bekannte Probleme

1. TRUNCATE innerhalb eines verschachtelten Prozeduraufrufs

Wenn in Redshift eine COMMIT-Anweisung in einem verschachtelten Prozeduraufruf angegeben wird, überträgt der Befehl alle ausstehenden Arbeiten von vorherigen Anweisungen im aktuellen und übergeordneten Bereich. Die Übergabe der Aktionen des übergeordneten Bereichs wird in Snowflake nicht unterstützt. Wenn dieser Fall erkannt wird, wird eine FDM generiert.

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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs

  1. [SSC-FDM-RS0006](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/redshiftFDM. md#ssc-fdm-rs0006): Die aufgerufene Prozedur enthält Verwendungen von COMMIT/ROLLBACK, das Ändern der aktuellen Transaktion in untergeordneten Bereichen wird in Snowflake nicht unterstützt.

CONDITIONS

CASE

Beschreibung

Mit der Anweisung CASE in Redshift können Sie Werte auf der Grundlage von Bedingungen zurückgeben und so bedingte Logik in Abfragen ermöglichen. Es gibt zwei Formen: einfach (simple) und gesucht (searched). (Redshift SQL-Referenz: Case-Bedingungen).

Simple Case

Eine einfache CASE-Anweisung ermöglicht die bedingte Ausführung auf der Grundlage der Gleichheit von Operanden.

Note

Simple Case wird von Snowflake vollständig unterstützt.

Grammatikalische Syntax

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

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Searched Case

Note

Searched Case wird von Snowflake vollständig unterstützt.

Grammatikalische Syntax

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

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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 ohne ELSE

Wenn in Redshift ein CASE Ausdruck ausgeführt wird und keine der überprüften Bedingungen erfüllt ist und keine ELSE definiert ist, wird die ‚CASE NOT FOUND‘-Ausnahme ausgelöst. In Snowflake wird der Code zwar ausgeführt, liefert aber kein Ergebnis. Um in diesem Szenario die gleiche Funktionalität in Snowflake beizubehalten, wird eine Ausnahme mit dem gleichen Namen deklariert und ausgeführt, wenn keine der CASE-Bedingungen erfüllt ist.

Note

Case ohne Else wird vollständig von Snowflake unterstützt.

Eingabecode:
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (input_value INT)
AS $$
BEGIN
  CASE input_value
  WHEN 1 THEN
   NULL;
  END CASE;
END;
$$ LANGUAGE plpgsql;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

IF

Beschreibung

Diese Anweisung ermöglicht es Ihnen, Entscheidungen auf der Grundlage bestimmter Bedingungen zu treffen. (Redshift SQL-Referenz: IF-Bedingungen).

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.

Grammatikalische Syntax

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

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

LOOPS

Beschreibung

Diese Anweisungen werden verwendet, um einen Codeblock zu wiederholen, bis die angegebene Bedingung erfüllt ist. (Redshift SQL-Referenz: Loops).

CONTINUE FOR LOOP WHILE EXIT

CONTINUE

Beschreibung

Wenn die CONTINUE-Bedingungen „true“ sind, kann die Schleife die Ausführung fortsetzen, wenn sie „false“ ist, wird die Schleife gestoppt. (Redshift SQL-Referenz: CONTINUE-Bedingungen).

Warnung

CONTINUE wird von Snowflake teilweise unterstützt.

Grammatikalische Syntax

 CONTINUE [ label ] [ WHEN expression ];
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

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

Konsolenausgabe

1

2

3

4

6

7

Ausgabecode:
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

Konsolenausgabe

1

2

3

4

6

7

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

EXIT

Beschreibung

Stoppen Sie die Ausführung der Schleife, wenn die in der WHEN-Anweisung definierten Bedingungen „true“ sind (Redshift SQL-Referenz: EXIT-Bedingungen).

Warnung

EXIT wird von Snowflake teilweise unterstützt.

Grammatikalische Syntax

 EXIT [ label ] [ WHEN expression ];
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

FOR

Grammatikalische Syntax

Ganzzahl-Variante

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

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

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

LOOP

Beschreibung

Eine einfache Schleife definiert eine unbedingte Schleife, die unbegrenzt wiederholt wird, bis sie durch eine EXIT- oder RETURN- Anweisung beendet wird. (Redshift SQL-Referenz: SIMPLE LOOP-Bedingungen).

Warnung

Einfache Schleifen werden von Snowflake teilweise unterstützt.

Grammatikalische Syntax

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

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

WHILE

Grammatikalische Syntax

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

Beispielhafte Quellcode-Muster

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

CURSORS

CLOSE CURSOR

Beschreibung

Schließt alle freien Ressourcen, die mit einem offenen Cursor verbunden sind(Redshift SQL-Referenz: CLOSE Cursor).

Note

Diese Syntax wird in Snowflake vollständig unterstützt.

Grammatikalische Syntax

 CLOSE cursor
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

Redshift
 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   CLOSE cursor1;
END;
$$;
Copy
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

FETCH CURSOR

Beschreibung

Ruft Zeilen mit Hilfe eines Cursors ab. (Redshift SQL-Referenz: Fetch)

Informationen zur Transformation

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

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

Beispielhafte Quellcode-Muster

Datenkonfiguration

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

Die FETCH INTO-Anweisung von Redshift ist in Snowflake völlig gleichwertig

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

Bekannte Probleme

1. Fetch ohne Zielvariablen wird nicht unterstützt

In Snowflake muss die Anweisung FETCH die Klausel INTO mit den Variablen angeben, in denen die abgerufenen Zeilenwerte gespeichert werden sollen. Wenn eine FETCH-Anweisung im Code gefunden wird, die keine INTO Klausel enthält, wird eine EWI generiert.

Eingabecode:

 FETCH FORWARD FROM cursor1;
Copy

Ausgabecode:

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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs

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

OPEN CURSOR

Beschreibung

Bevor Sie einen Cursor zum Abrufen von Zeilen verwenden können, muss er geöffnet werden. (Redshift SQL-Referenz: Open Cursor).

Note

Diese Syntax wird in Snowflake vollständig unterstützt.

Grammatikalische Syntax

 OPEN bound_cursor_name [ ( argument_values ) ];
Copy

Beispielhafte Quellcode-Muster

Datenkonfiguration

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

Cursor ohne Argumente öffnen

Eingabecode:
Redshift
 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   OPEN cursor1;
END;
$$;
Copy
Ausgabecode:
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

Cursor mit Argumenten öffnen

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

Cursor mit Prozedurparametern oder lokalen Variablen öffnen

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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

DECLARE CURSOR

Beschreibung

Definiert einen neuen Cursor. Verwenden Sie einen Cursor, um jeweils ein paar Zeilen aus dem Resultset einer größeren Abfrage abzurufen. (Redshift SQL-Referenz: DECLARE Cursor).

Note

Diese Syntax wird in Snowflake vollständig unterstützt.

Grammatikalische Syntax

 name CURSOR [ ( arguments ) ] FOR query 
Copy

Beispielhafte Quellcode-Muster

Eingabecode:

Eingabecode:

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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.

DECLARE REFCURSOR

Beschreibung

Ein refcursor-Datentyp enthält einfach einen Verweis auf einen Cursor. Sie können eine Cursor-Variable erstellen, indem Sie sie als Variable vom Typ refcursor deklarieren

(Redshift SQL-Referenz: Refcursor-Deklaration)

Note

Refcursor-Deklarationen werden von Snowflake vollständig unterstützt.

Grammatikalische Syntax

 DECLARE
name refcursor;
Copy

Da Snowflake den Datentyp REFCURSOR nicht unterstützt, wird seine Funktionalität durch Konvertierung der Variable REFCURSOR in den Typ RESULTSET repliziert. Die Abfrage, die zum Öffnen von REFCURSOR verwendet wird, wird der Variablen RESULTSET zugewiesen, woraufhin ein neuer Cursor erstellt und mit der Variablen RESULTSET verknüpft wird. Außerdem werden alle Verweise auf den ursprünglichen REFCURSOR innerhalb der Cursorlogik aktualisiert, um den neuen Cursor zu verwenden, wodurch die ursprüngliche Funktionalität wiederhergestellt wird.

Beispielhafte Quellcode-Muster

Fall: Einzelnutzung

Eingabecode:
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
Ausgabecode:
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
Fall: Cursor mit Dynamic Sql
Eingabecode:
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
Ausgabecode:
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
Fall: Mehrfachnutzung:
Eingabecode:
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
Ausgabecode:
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

Bekannte Probleme

Es gibt keine bekannten Probleme.

Zugehörige EWIs.

Es gibt keine zugehörigen EWIs.