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 } ]
Amostra de padrões da origem¶
Código de entrada:¶
Redshift¶
CREATE PROCEDURE TEST_PROCEDURE()
LANGUAGE PLPGSQL
AS
$$
BEGIN
NULL;
END;
$$;
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;
$$;
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;
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;
$$;
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;
$$;
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
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;
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;
$$;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs relacionados¶
SCC-EWI-0028 : Tipo não suportado pelo Snowflake.
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$
Amostra de padrões da origem¶
Código de entrada:¶
Redshift¶
CREATE OR REPLACE PROCEDURE SP()
AS
$somename$
BEGIN
NULL;
END;
$somename$
LANGUAGE plpgsql;
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;
$$;
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 ];
Amostra de padrões da origem¶
Código de entrada:¶
Redshift¶
CREATE OR REPLACE PROCEDURE MY_PROCEDURE()
AS
$$
BEGIN
NULL;
END;
$$
LANGUAGE plpgsql;
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;
$$;
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 ]
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;
$$;
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;
$$;
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
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;
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;
$$;
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]
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;
$$;
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;
$$;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs relacionados¶
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
Amostra de padrões da origem¶
Código de entrada:¶
Redshift¶
CREATE OR REPLACE PROCEDURE SP_NONATOMIC()
NONATOMIC
AS
$$
BEGIN
NULL;
END;
$$
LANGUAGE plpgsql;
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;
$$;
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
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;
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;
$$;
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.
Note
RAISE are fully supported by Snowflake.
Sintaxe da gramática¶
RAISE level 'format' [, variable [, ...]];
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.
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.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.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
ouSECURITYADMIN
.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;
$$;
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;
$$;
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;
$$;
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;
$$;
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;
Amostra de padrões da origem¶
Caso simples¶
Código de entrada:¶
Redshift¶
CREATE OR REPLACE PROCEDURE procedure1 ()
AS
$$
BEGIN
RETURN;
END
$$ LANGUAGE plpgsql;
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
$$;
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;
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
$$;
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 } ]
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;
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;
$$;
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.
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 ];
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;
$$;
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;
$$;
Problemas conhecidos ¶
Não foram encontrados problemas.
EWIs relacionados¶
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]
Amostra de padrões da origem¶
Dados de configuração¶
Redshift¶
Query¶
CREATE TABLE transaction_values_test
(
col1 INTEGER
);
Snowflake¶
Query¶
CREATE TABLE transaction_values_test
(
col1 INTEGER
);
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;
Snowflake¶
Query¶
COMMIT;
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;
Result¶
+------+
| col1 |
+------+
| 120 |
| 121 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 120 |
| 121 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 12 |
| 13 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 12 |
| 13 |
+------+
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
$$;
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
$$;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs relacionados¶
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]
Amostra de padrões da origem¶
Dados de configuração¶
Redshift¶
Query¶
CREATE TABLE transaction_values_test
(
col1 INTEGER
);
Snowflake¶
Query¶
CREATE TABLE transaction_values_test
(
col1 INTEGER
);
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;
Snowflake¶
Query¶
ROLLBACK;
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;
Result¶
+------+
| col1 |
+------+
| 120 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 120 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 10 |
| 11 |
| 12 |
| 13 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 10 |
| 11 |
| 12 |
| 13 |
+------+
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
$$;
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
$$;
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
$$;
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
$$;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs relacionados¶
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.
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
Amostra de padrões da origem¶
Dados de configuração¶
Redshift¶
Query¶
CREATE TABLE transaction_values_test
(
col1 INTEGER
);
Snowflake¶
Query¶
CREATE TABLE transaction_values_test
(
col1 INTEGER
);
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;
Result¶
+------+
| col1 |
+------+
| 22 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 22 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 10 |
| 11 |
| 12 |
| 13 |
+------+
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;
Result¶
+------+
| col1 |
+------+
| 10 |
| 11 |
| 12 |
| 13 |
+------+
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
$$;
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
$$;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs relacionados¶
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;
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;
$$;
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;
$$;
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;
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;
$$;
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;
$$;
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;
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;
$$;
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;
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;
$$;
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;
$$;
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¶
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 ];
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;
$$;
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;
$$;
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 ];
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;
$$;
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;
$$;
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 ];
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;
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;
$$;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs Relacionados.¶
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 ];
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;
$$;
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;
$$;
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 ];
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;
$$;
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;
$$;
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
Amostra de padrões da origem¶
Código de entrada:¶
Redshift¶
CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
CLOSE cursor1;
END;
$$;
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;
$$;
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 ...];
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');
Snowflake¶
Query¶
CREATE TABLE cursor_example
(
col1 INTEGER,
col2 VARCHAR(20)
);
INSERT INTO cursor_example VALUES (10, 'hello');
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;
Result¶
+------+-------------+
| col1 | col2 |
+------+-------------+
| 10 | hello |
| 100 | hello world!|
+------+-------------+
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;
Result¶
+------+-------------+
| col1 | col2 |
+------+-------------+
| 10 | hello |
| 100 | hello world!|
+------+-------------+
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;
Código de saída:
!!!RESOLVE EWI!!! /*** SSC-EWI-PG0015 - FETCH CURSOR WITHOUT TARGET VARIABLES IS NOT SUPPORTED IN SNOWFLAKE ***/!!!
FETCH FORWARD FROM cursor1;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs relacionados¶
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 ) ];
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');
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');
Abrir o cursor sem argumentos¶
Código de entrada:¶
Redshift¶
CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
OPEN cursor1;
END;
$$;
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;
$$;
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;
Result¶
+------+-------+
| col1 | col2 |
+------+-------+
| 60 | hello |
+------+-------+
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;
Result¶
+------+-------+
| col1 | col2 |
+------+-------+
| 60 | hello |
+------+-------+
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);
Result¶
+------+-------+
| col1 | col2 |
+------+-------+
| 40 | hello |
+------+-------+
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);
Result¶
+------+-------+
| col1 | col2 |
+------+-------+
| 40 | hello |
+------+-------+
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
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;
$$;
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;
$$;
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 tiporefcursor
(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;
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;
$$;
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;
$$;
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;
$$;
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;
$$;
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;
$$;
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;
$$;
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs Relacionados.¶
Não há EWIs relacionados.