SnowConvert AI - Redshift - CREATE PROCEDURE

Descrição

Cria um novo procedimento armazenado ou substitui um procedimento existente para o banco de dados atual. (Procedimento Create da referência da linguagem Redshift SQL).

Consulte as definições a seguir para obter mais informações sobre cláusulas de procedimento:

Sintaxe da gramática

A seguir está a sintaxe SQL para criar um procedimento no Amazon Redshift. Clique aqui para acessar a especificação do Redshifts para essa sintaxe.

 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

Amostra de padrões da origem

Código de entrada:

Redshift

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

Código de saída:

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

Descrição

Se a assinatura do procedimento armazenado omitir o nome do argumento, você poderá declarar um alias para o argumento.

Não há suporte para isso no Snowflake.

Para obter equivalência funcional, os aliases serão removidos e todos os usos serão renomeados.

Quando um alias é declarado para um parâmetro sem nome, um nome gerado será criado para o parâmetro e os usos. Quando o alias for para um parâmetro com nome, o alias será substituído pelo nome real do parâmetro.

Sintaxe da gramática

 name ALIAS FOR $n;
Copy

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

ARGUMENTS MODE

Descrição

Os procedimentos armazenados do Amazon Redshift suportam parâmetros que podem ser passados durante a invocação do procedimento. Esses parâmetros permitem que você forneça valores de entrada, recupere valores de saída ou use-os para operações de entrada e saída. Abaixo, há uma explicação detalhada dos tipos de parâmetros, seus modos e exemplos de uso. O Snowflake suporta apenas valores de entrada.

IN (Parâmetros de entrada)

Finalidade: Usado para passar valores para o procedimento.

Modo padrão: Se nenhum modo for especificado, os parâmetros serão considerados IN.

Comportamento: Os valores passados para o procedimento não podem ser modificados dentro do procedimento.

OUT (Parâmetros de saída)

Finalidade: Usado para retornar valores do procedimento.

Comportamento: Os parâmetros podem ser modificados dentro do procedimento e são retornados ao chamador. Você não pode enviar um valor inicial.

INOUT (Parâmetros de entrada/saída)

Finalidade: Usado para passar valores para o procedimento e modificá-los para retornar valores atualizados.

Comportamento: Combina o comportamento de IN e OUT. Você deve enviar um valor inicial independentemente da saída.

Sintaxe da gramática

 [ argname ] [ argmode ] argtype
Copy

Amostra de padrões da origem

Código de entrada:

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

Problemas conhecidos

Não há problemas conhecidos.

EWIs relacionados

  1. SCC-EWI-0028 : Tipo não suportado pelo Snowflake.

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

PROCEDURE BODY

Descrição

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

Sintaxe da gramática

 AS
$Alias$
  procedure_body
$Alias$ 
Copy

Amostra de padrões da origem

Código de entrada:

Redshift
 CREATE OR REPLACE PROCEDURE SP()
AS 
$somename$
BEGIN
   NULL;
END;
$somename$ 
LANGUAGE plpgsql;
Copy
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

BLOCK STATEMENT

Descrição

PL/pgSQL é uma linguagem estruturada em blocos. O corpo completo de um procedimento é definido em um bloco, que contém declarações de variáveis e instruções PL/pgSQL. Uma instrução também pode ser um bloco ou subbloco aninhado.

Sintaxe da gramática

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

Amostra de padrões da origem

Código de entrada:

Redshift
 CREATE OR REPLACE PROCEDURE MY_PROCEDURE() 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

DECLARE

Descrição

Seção para declarar todas as variáveis de procedimento, exceto as variáveis de loop.\ O Redshift oferece suporte a várias seções DECLARE por instrução de bloco; como o Snowflake não oferece suporte a esse comportamento, elas devem ser mescladas em uma única instrução de declaração por bloco.

Sintaxe da gramática

 [ DECLARE declarations ]
Copy

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

EXCEPTION

Descrição

Quando ocorre uma exceção e você adiciona um bloco de tratamento de exceções, é possível escrever instruções RAISE e a maioria das outras instruções PL/pgSQL. Por exemplo, é possível gerar uma exceção com uma mensagem personalizada ou inserir um registro em uma tabela de registro.

Sintaxe da gramática

 EXCEPTION
  WHEN OTHERS THEN
    statements
Copy

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

LABEL

Descrição

Os rótulos são usados no Redshift para qualificar um bloco ou para usar a instrução EXIT ou END. O Snowflake não oferece suporte a rótulos.

Aviso

Como não há suporte para rótulos no Snowflake, será impresso um EWI.

Sintaxe da gramática

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

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs relacionados

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

NONATOMIC

Descrição

NONATOMIC faz o commit após cada instrução no procedimento armazenado. O Snowflake oferece suporte a um parâmetro AUTOCOMMIT. A configuração padrão para AUTOCOMMIT é TRUE (habilitada).

Enquanto o AUTOCOMMIT estiver ativado, cada instrução fora de uma transação explícita será tratada como se estivesse dentro de sua transação implícita de instrução única. Em outras palavras, essa instrução é automaticamente confirmada se for bem-sucedida e automaticamente revertida se falhar. Em outras palavras, o Snowflake funciona como NONATOMIC «por padrão».

Sintaxe da gramática

 NONATOMIC
Copy

Amostra de padrões da origem

Código de entrada:

Redshift
 CREATE OR REPLACE PROCEDURE SP_NONATOMIC()
NONATOMIC 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;
Copy
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

POSITIONAL ARGUMENTS

Descrição

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.

Sintaxe da gramática

 $n
Copy

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

RAISE

Descrição

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

(Redshift SQL Language Reference RAISE)

Note

RAISE are fully supported by Snowflake.

Sintaxe da gramática

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

No Amazon Redshift, a instrução RAISE é usada para gerar mensagens no console ou lançar exceções personalizadas. O Redshift permite que você especifique diferentes níveis para indicar a gravidade da mensagem. No Snowflake, essa funcionalidade pode ser emulada usando uma função definida pelo usuário (UDF) que faz uma chamada para o console, dependendo do nível especificado.

  1. Exceção: \ Quando o nível é «EXCEPTION», uma exceção personalizada é levantada com uma mensagem geral: «To view the EXCEPTION MESSAGE, you need to check the log.» O código de exceção é -20002, que informa ao usuário que a mensagem personalizada pode ser encontrada nos logs. Isso se deve a limitações no envio de exceções personalizadas no Snowflake.

  2. Aviso: \ Se o nível for «WARNING», SYSTEM$LOG_WARN é usado para imprimir a mensagem de aviso no registro do Snowflake, o que ajuda a destacar possíveis problemas sem interromper o fluxo de execução.

  3. Info: \ Para qualquer outro nível (como «INFO»), SYSTEM$LOG_INFO é usado para imprimir a mensagem no log do console, fornecendo feedback mais detalhado sobre o estado do sistema sem causar interrupções críticas.

Essa abordagem permite emular a funcionalidade dos níveis de gravidade do Redshift, adaptando-os à sintaxe e aos recursos do Snowflake, mantendo a flexibilidade e o controle sobre as mensagens e exceções geradas durante a execução.

Limitações

  • Para visualizar logs no Snowflake, é necessário ter privilégios específicos, como as funções ACCOUNTADMIN ou SECURITYADMIN.

  • Os logs no Snowflake não ficam disponíveis imediatamente e podem sofrer um pequeno atraso até que as informações fiquem visíveis.

  • As mensagens de erro personalizadas em exceções não são exibidas como no Redshift. Para visualizar as mensagens personalizadas, você deve acessar os logs diretamente.

For further information, please refer to the following page.

Amostra de padrões da origem

Código de entrada:

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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

RETURN

Descrição

A instrução RETURN retorna ao chamador a partir de um procedimento armazenado. (Return da referência da linguagem Redshift SQL).

A conversão da instrução de retorno do Amazon Redshift para o Snowflake é simples, considerando apenas a adição de um NULL à instrução de retorno no Snowflake.

Sintaxe da gramática

 RETURN;
Copy

Amostra de padrões da origem

Caso simples

Código de entrada:
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 ()
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;
Copy
Código de saída:
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

Quando o procedimento tem parâmetros de saída

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.

Código de entrada:
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (OUT output_value VARCHAR)
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;
Copy
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

SECURITY (DEFINER | INVOKER)

Descrição

A cláusula SECURITY nos procedimentos armazenados do Amazon Redshift define o contexto de controle de acesso e permissões sob o qual o procedimento é executado. Isso determina se o procedimento usa os privilégios do proprietário (criador) ou do chamador (usuário que invoca o procedimento).

Sintaxe da gramática

 [ { SECURITY INVOKER | SECURITY DEFINER } ]  
Copy

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

VARIABLE DECLARATION

Descrição

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

(Redshift SQL Language Reference Variable Declaration)

Note

As declarações de variáveis são totalmente compatíveis com o Snowflake.

Sintaxe da gramática

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

No Redshift, a palavra-chave CONSTANT impede a reatribuição de variáveis durante a execução. Como o Snowflake não oferece suporte a essa palavra-chave, ela é removida durante a transformação. Isso não afeta a funcionalidade, pois a lógica não deve tentar reatribuir uma variável constante.

A restrição NOT NULL no Redshift garante que não seja possível atribuir um valor nulo a uma variável e exige um valor padrão não nulo. Como o Snowflake não é compatível com essa restrição, ela é removida durante a transformação. No entanto, o valor padrão é mantido para manter a funcionalidade.

Uma variável declarada com um Refcursor é transformada para o tipo Resultset, para obter mais informações DECLARE REFCURSOR.

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não foram encontrados problemas.

EWIs relacionados

  1. SSC-FDM-PG0012: a restrição NOT NULL foi removida. Atribuir NULL a essa variável não causará mais falhas.

TRANSACTIONS

COMMIT

Descrição

Confirma a transação atual no banco de dados. Esse comando torna permanentes as atualizações do banco de dados da transação. (Referência da linguagem Redshift SQL COMMIT)

Sintaxe da gramática

COMMIT [WORK | TRANSACTION]

Copy

Amostra de padrões da origem

Dados de configuração

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

COMMIT com a palavra-chave TRANSACTION

A palavra-chave TRANSACTION não é compatível com o Snowflake. No entanto, como isso não afeta a funcionalidade, será simplesmente removido.

Redshift
Query
 COMMIT TRANSACTION;
Copy
Snowflake
Query
 COMMIT;
Copy

COMMIT em um procedimento de comportamento de transação padrão (sem a cláusula NONATOMIC)

Para evitar exceções de transações fora do escopo no Snowflake, os usos de COMMIT serão combinados com BEGIN TRANSACTION.

Quando vários comandos COMMIT estiverem presentes no procedimento, vários comandos BEGIN TRANSACTION serão gerados após cada COMMIT para emular o comportamento de transação do 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 em um procedimento com comportamento NONATOMIC

O comportamento NONATOMIC do Redshift é emulado no Snowflake usando o parâmetro de sessão AUTOCOMMIT definido como 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

Problemas conhecidos

1. COMMIT dentro de uma chamada de procedimento aninhado

No Redshift, quando uma instrução COMMIT é especificada em uma chamada de procedimento aninhado, o comando confirmará todo o trabalho pendente de instruções anteriores nos escopos atual e pai. O Snowflake não é compatível com o envio das ações do escopo principal; quando esse caso for detectado, será gerado um FDM.

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

Problemas conhecidos

Não há problemas conhecidos.

EWIs relacionados

  1. SSC-FDM-RS0006: O procedimento chamado contém usos de COMMIT/ROLLBACK, a modificação da transação atual em escopos filhos não é compatível com o Snowflake.

ROLLBACK

Descrição

Interrompe a transação atual e descarta todas as atualizações feitas por essa transação. (Referência da linguagem Redshift SQL ROLLBACK)

Sintaxe da gramática

ROLLBACK [WORK | TRANSACTION]

Copy

Amostra de padrões da origem

Dados de configuração

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

ROLLBACK com a palavra-chave TRANSACTION

A palavra-chave TRANSACTION não é compatível com o Snowflake. No entanto, como isso não afeta a funcionalidade, será simplesmente removido.

Redshift
Query
 ROLLBACK TRANSACTION;
Copy
Snowflake
Query
 ROLLBACK;
Copy

ROLLBACK em um procedimento de comportamento de transação padrão (sem a cláusula NONATOMIC)

Para evitar exceções de transações fora do escopo no Snowflake, os usos de ROLLBACK serão combinados com BEGIN TRANSACTION.

Quando várias instruções de controle de transação estiverem presentes no procedimento, várias instruções BEGIN TRANSACTION serão geradas após cada uma delas para emular o comportamento de transação do 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 em um procedimento com comportamento NONATOMIC

O comportamento NONATOMIC do Redshift é emulado no Snowflake usando o parâmetro de sessão AUTOCOMMIT definido como 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

Problemas conhecidos

1. ROLLBACK dentro de uma chamada de procedimento aninhado

No Redshift, quando uma instrução ROLLBACK é especificada em uma chamada de procedimento aninhado, o comando confirmará todo o trabalho pendente de instruções anteriores nos escopos atual e pai. O Snowflake não é compatível com o envio das ações do escopo principal; quando esse caso for detectado, será gerado um FDM.

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 de instruções DDL

No Snowflake, instruções DDL realizam um commit implícito sempre que são executadas dentro de um procedimento, tornando efetivo todo o trabalho anterior à execução do DDL, bem como o próprio DDL. Isso faz com que a instrução ROLLBACK não seja capaz de descartar quaisquer alterações anteriores a esse ponto; esse problema será informado por meio de um 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

Problemas conhecidos

Não há problemas conhecidos.

EWIs relacionados

  1. SSC-FDM-RS0006: O procedimento chamado contém usos de COMMIT/ROLLBACK, a modificação da transação atual em escopos filhos não é compatível com o Snowflake.

  2. SSC-FDM-RS0007: as instruções DDL executam um COMMIT automático, ROLLBACK não funcionará como esperado.

TRUNCATE

Descrição

Exclui todas as linhas de uma tabela sem fazer uma varredura de tabela (TRUNCATE da referência da linguagem Redshift SQL)

Sintaxe da gramática

TRUNCATE [TABLE] table_name

Copy

Amostra de padrões da origem

Dados de configuração

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

TRUNCATE em um procedimento de comportamento de transação padrão (sem a cláusula NONATOMIC)

Como a instrução TRUNCATE confirma automaticamente a transação em que é executada, qualquer um de seus usos gerará uma instrução COMMIT no Snowflake para emular esse comportamento.

Como uma instrução COMMIT é gerada, a mesma geração de instrução BEGIN TRANSACTION será aplicada a TRUNCATE. Para obter mais informações, consulte a especificação de conversão 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 em um procedimento com comportamento NONATOMIC

O comportamento NONATOMIC do Redshift é emulado no Snowflake usando o parâmetro de sessão AUTOCOMMIT definido como 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

Problemas conhecidos

1. TRUNCATE dentro de uma chamada de procedimento aninhado

No Redshift, quando uma instrução COMMIT é especificada em uma chamada de procedimento aninhado, o comando confirmará todo o trabalho pendente de instruções anteriores nos escopos atual e pai. O Snowflake não é compatível com o envio das ações do escopo principal; quando esse caso for detectado, será gerado um FDM.

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

Problemas conhecidos

Não há problemas conhecidos.

EWIs relacionados

  1. SSC-FDM-RS0006: O procedimento chamado contém usos de COMMIT/ROLLBACK, a modificação da transação atual em escopos filhos não é compatível com o Snowflake.

CONDITIONS

CASE

Descrição

A instrução CASE no Redshift permite que você retorne valores com base em condições, possibilitando a lógica condicional nas consultas. Ela tem duas formas: simples e pesquisada. (Condicionais da referência da linguagem Redshift SQL: Case).

Caso simples

Uma simples instrução CASE oferece execução condicional com base na igualdade de operandos.

Note

O Simple Case é totalmente suportado pelo Snowflake.

Sintaxe da gramática

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

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Caso pesquisado

Note

Searched Case é totalmente suportado pelo Snowflake.

Sintaxe da gramática

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

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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 sem ELSE

No Redshift, quando uma expressão CASE é executada e nenhuma das condições validadas é atendida, e não há nenhum ELSE definido, a exceção “CASE NOT FOUND” é acionada. No Snowflake, o código é executado, mas não retorna nenhum resultado. Para manter a mesma funcionalidade no Snowflake nesse cenário, uma exceção com o mesmo nome será declarada e executada se nenhuma das condições de CASE for atendida.

Note

Case Without Else é totalmente suportado pela Snowflake.

Código de entrada:
Redshift
 CREATE OR REPLACE PROCEDURE procedure1 (input_value INT)
AS $$
BEGIN
  CASE input_value
  WHEN 1 THEN
   NULL;
  END CASE;
END;
$$ LANGUAGE plpgsql;
Copy
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

IF

Descrição

Essa instrução permite que você tome decisões com base em determinadas condições. (Condicionais da referência da linguagem Redshift SQL: 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.

Sintaxe da gramática

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

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

LOOPS

Descrição

Essas instruções são usadas para repetir um bloco de código até a condição especificada. (Loops da referência da linguagem Redshift SQL).

CONTINUE FOR LOOP WHILE EXIT

CONTINUE

Descrição

Quando as condições de CONTINUE forem verdadeiras, o loop poderá continuar a execução; quando forem falsas, o loop será interrompido. (Condicionais da referência da linguagem Redshift SQL: CONTINUE).

Aviso

CONTINUE tem suporte parcial do Snowflake.

Sintaxe da gramática

 CONTINUE [ label ] [ WHEN expression ];
Copy

Amostra de padrões da origem

Código de entrada:

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

Saída do console

1

2

3

4

6

7

Código de saída:
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

Saída do console

1

2

3

4

6

7

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

EXIT

Descrição

Interrompa a execução do loop quando as condições definidas na instrução WHEN forem verdadeiras (Condicionais da referência da linguagem Redshift SQL: EXIT).

Aviso

EXIT tem suporte parcial do Snowflake.

Sintaxe da gramática

 EXIT [ label ] [ WHEN expression ];
Copy

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

FOR

Sintaxe da gramática

Variante de inteiro

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

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

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

LOOP

Descrição

Um loop simples define um loop incondicional que é repetido indefinidamente até ser encerrado por uma instrução EXIT ou RETURN. (Condicionais da referência da linguagem Redshift SQL: Loop simples).

Aviso

O Loop simples tem suporte parcial do Snowflake.

Sintaxe da gramática

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

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

WHILE

Sintaxe da gramática

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

Amostra de padrões da origem

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

CURSORS

CLOSE CURSOR

Descrição

Fecha todos os recursos livres associados a um cursor aberto. (Close Cursor da referência da linguagem Redshift SQL).

Note

Essa sintaxe é totalmente compatível com o Snowflake.

Sintaxe da gramática

 CLOSE cursor
Copy

Amostra de padrões da origem

Código de entrada:

Redshift
 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   CLOSE cursor1;
END;
$$;
Copy
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

FETCH CURSOR

Descrição

Recupera linhas usando um cursor. (Fetch da referência da linguagem Redshift SQL)

Informações de transformação

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

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

Amostra de padrões da origem

Dados de configuração

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

A instrução FETCH into do Redshift é totalmente equivalente no 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

Problemas conhecidos

1. Não há suporte para Fetch sem variáveis de destino

O Snowflake exige que a instrução FETCH especifique a cláusula INTO com as variáveis em que os valores de linha obtidos serão armazenados. Quando uma instrução FETCH for encontrada no código sem nenhuma cláusula INTO, será gerado um EWI.

Código de entrada:

 FETCH FORWARD FROM cursor1;
Copy

Código de saída:

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

Problemas conhecidos

Não há problemas conhecidos.

EWIs relacionados

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

OPEN CURSOR

Descrição

Antes que você possa usar um cursor para recuperar linhas, ele deve ser aberto. (Open Cursor da referência da linguagem Redshift SQL).

Note

Essa sintaxe é totalmente compatível com o Snowflake.

Sintaxe da gramática

 OPEN bound_cursor_name [ ( argument_values ) ];
Copy

Amostra de padrões da origem

Dados de configuração

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

Abrir o cursor sem argumentos

Código de entrada:
Redshift
 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   OPEN cursor1;
END;
$$;
Copy
Código de saída:
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

Abrir o cursor com argumentos

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

Abrir o cursor com parâmetros de procedimento ou variáveis locais

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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

DECLARE CURSOR

Descrição

Define um novo cursor. Use um cursor para recuperar algumas linhas de cada vez do conjunto de resultados de uma consulta maior. (Declare Cursor da referência da linguagem Redshift SQL).

Note

Essa sintaxe é totalmente compatível com o Snowflake.

Sintaxe da gramática

 name CURSOR [ ( arguments ) ] FOR query 
Copy

Amostra de padrões da origem

Código de entrada:

Código de entrada:

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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.

DECLARE REFCURSOR

Descrição

Um tipo de dados refcursor simplesmente contém uma referência a um cursor. Você pode criar uma variável de cursor declarando-a como uma variável do tipo refcursor

(Declaração Refcursor da referência da linguagem Redshift SQL)

Note

As declarações de refcursor são totalmente compatíveis com o Snowflake.

Sintaxe da gramática

 DECLARE
name refcursor;
Copy

Como o Snowflake não é compatível com o tipo de dados REFCURSOR, sua funcionalidade é replicada pela conversão da variável REFCURSOR em um tipo RESULTSET. A consulta usada para abrir o REFCURSOR é atribuída à variável RESULTSET, após o que um novo cursor é criado e vinculado à variável RESULTSET. Além disso, todas as referências ao REFCURSOR original dentro da lógica do cursor são atualizadas para usar o novo cursor, replicando assim a funcionalidade original.

Amostra de padrões da origem

Caso: uso único

Código de entrada:
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
Código de saída:
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
Caso: Cursor com Sql dinâmico
Código de entrada:
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
Código de saída:
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
Caso: Múltiplos usos:
Código de entrada:
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
Código de saída:
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

Problemas conhecidos

Não há problemas conhecidos.

EWIs Relacionados.

Não há EWIs relacionados.