SnowConvert AI - Redshift - SQL Statements

Translation reference for all the supported statements by SnowConvert AI for Redshift.

CALL

Descrição

Executa um procedimento armazenado. O comando CALL deve incluir o nome do procedimento e os valores dos argumentos de entrada. Você deve chamar um procedimento armazenado usando a instrução CALL. (CALL de referência da linguagem Redshift SQL).

Sintaxe da gramática

 CALL sp_name ( [ argument ] [, ...] )
Copy

Amostra de padrões da origem

Cenário básico

Código de entrada:
Redshift
 CREATE PROCEDURE sp_insert_values(IN arg1 INT, IN arg2 DATE)
LANGUAGE plpgsql
AS
$$
BEGIN
    INSERT INTO event VALUES (arg1, arg2);
END;
$$;

CALL sp_insert_values(1, CURRENT_DATE);
Copy
Código de saída:
Redshift
 CREATE PROCEDURE sp_insert_values (arg1 INT, arg2 DATE)
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
    INSERT INTO event
    VALUES (:arg1, : arg2);
END;
$$;

CALL sp_insert_values(1, CURRENT_DATE());
Copy

Chamada usando o modo de parâmetros de saída (INOUT, OUT)

Código de entrada:
Redshift
 CREATE OR REPLACE PROCEDURE sp_calculate_sum_product(IN a NUMERIC, IN b NUMERIC, INOUT sum_result NUMERIC, INOUT product_result NUMERIC)
LANGUAGE plpgsql
AS $$
BEGIN
    sum_result := a + b;
    product_result := a * b;
END;
$$;

CREATE OR REPLACE PROCEDURE call_sp_calculate_sum_product()
LANGUAGE plpgsql
AS $$
DECLARE
    sum_value NUMERIC DEFAULT null;
    product_value NUMERIC DEFAULT null;
BEGIN
    CALL sp_calculate_sum_product(FLOOR(20.5)::NUMERIC, CEIL(20.7)::NUMERIC, sum_value, product_value);
    INSERT INTO test VALUES (sum_value, product_value);
END;
$$;

CALL call_sp_calculate_sum_product();
Copy
Código de saída:
Redshift
 CREATE OR REPLACE PROCEDURE sp_calculate_sum_product (a NUMERIC, b NUMERIC, sum_result OUT NUMERIC, product_result OUT NUMERIC)
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
    sum_result := a + b;
    product_result := a * b;
END;
$$;

CREATE OR REPLACE PROCEDURE call_sp_calculate_sum_product ()
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
    sum_value NUMERIC DEFAULT null;
    product_value NUMERIC DEFAULT null;
BEGIN
    CALL sp_calculate_sum_product(FLOOR(20.5)::NUMERIC, CEIL(20.7)::NUMERIC, : sum_value, : product_value);
    INSERT INTO test
    VALUES (:sum_value, : product_value);
END;
$$;

CALL call_sp_calculate_sum_product();
Copy

Problemas conhecidos

  • Output parameters from calls outside procedures won’t work.

CREATE DATABASE

Sintaxe da gramática

 CREATE DATABASE database_name 
[ { [ WITH ]
    [ OWNER [=] db_owner ]
    [ CONNECTION LIMIT { limit | UNLIMITED } ]
    [ COLLATE { CASE_SENSITIVE | CASE_INSENSITIVE } ]
    [ ISOLATION LEVEL { SERIALIZABLE | SNAPSHOT } ]
  }
  | { [ WITH PERMISSIONS ] FROM DATASHARE datashare_name ] OF [ ACCOUNT account_id ] NAMESPACE namespace_guid }
  | { FROM { { ARN '<arn>' } { WITH DATA CATALOG SCHEMA '<schema>' | WITH NO DATA CATALOG SCHEMA } }
             | { INTEGRATION '<integration_id>'} }
  | { IAM_ROLE  {default | 'SESSION' | 'arn:aws:iam::<account-id>:role/<role-name>' } }
Copy

Para obter mais informações, consulte a documentação de CREATE DATABASE do Redshift.

Amostra de padrões da origem

Amostras básicas

Código de entrada:
Redshift
 CREATE DATABASE database_name;
Copy
Código de saída:
Snowflake
 CREATE DATABASE IF NOT EXISTS database_name
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/25/2024" }}';
Copy

Cláusula de agrupamento

Código de entrada:
Redshift
 CREATE DATABASE database_collate
COLLATE CASE_INSENSITIVE;
Copy
Código de saída:
Snowflake
 CREATE DATABASE IF NOT EXISTS database_collate
DEFAULT_DDL_COLLATION='en-ci'
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/24/2024" }}';
Copy

Cláusula de limite de conexão

Código de entrada:
Redshift
 CREATE DATABASE database_connection
CONNECTION LIMIT UNLIMITED;
Copy
Código de saída:
Snowflake
 CREATE DATABASE IF NOT EXISTS database_connection
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/24/2024" }}';
Copy

Aviso

A cláusula de limite de conexão foi removida, pois a simultaneidade da conexão no snowflake é gerenciada pelo warehouse. Mais informações aqui.

Cláusula From ARN

Código de entrada:
Redshift
 CREATE DATABASE database_fromARN
FROM ARN 'arn' WITH NO DATA CATALOG SCHEMA IAM_ROLE 'arn:aws:iam::<account-id>:role/<role-name';
Copy
Código de saída:
Snowflake
 CREATE DATABASE IF NOT EXISTS database_fromARN
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/24/2024" }}';
Copy

Aviso

Essa cláusula foi removida porque é usada para fazer referência a recursos da Amazon, o que não é válido no Snowflake.

Cláusula From Datashare

Código de entrada
Redshift
 CREATE DATABASE database_fromDatashare
FROM DATASHARE datashare_name OF NAMESPACE 'namespace_guid';
Copy
Código de saída
Snowflake
 CREATE DATABASE IF NOT EXISTS  database_fromDatashare
FROM DATASHARE datashare_name OF NAMESPACE 'namespace_guid' !!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'FromDatashareAttribute' NODE ***/!!!
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/24/2024" }}';
Copy

Nota

A transformação do Datashare está planejada para ser entregue no futuro.

Cláusula Owner

Código de entrada
Redshift
 CREATE DATABASE database_Owner
OWNER db_owner
ENCODING 'encoding';
Copy
Código de saída
Snowflake
 CREATE DATABASE IF NOT EXISTS database_Owner
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/24/2024" }}';
Copy

Aviso

Observe que, nesse caso, a cláusula owner é removida do código, pois os bancos de dados do Snowflake são de propriedade de funções, não de usuários individuais. Para obter mais informações, consulte a documentação do Snowflake GRANT OWNERSHIP.

Cláusula Isolation Level

Código de entrada
Redshift
 CREATE DATABASE database_Isolation
ISOLATION LEVEL SNAPSHOT;
Copy
Código de saída
Snowflake
 CREATE DATABASE IF NOT EXISTS database_Isolation
ISOLATION LEVEL SNAPSHOT !!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'IsolationLevelAttribute' NODE ***/!!!
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/24/2024" }}';
Copy

Nota

A transformação para Isolation Level está planejada para ser entregue no futuro.

EWIs relacionados

  • SSC-EWI-0073: Revisão de equivalência funcional pendente

CREATE EXTERNAL TABLE

Descrição

Currently SnowConvert AI is transforming CREATE EXTERNAL TABLES to regular tables, that implies additional effort because data stored in external RedShift tables must be transferred to the Snowflake database.

Sintaxe da gramática

 CREATE EXTERNAL TABLE
external_schema.table_name
(column_name data_type [, ] )
[ PARTITIONED BY (col_name data_type [,  ] )]
[ { ROW FORMAT DELIMITED row_format |
  ROW FORMAT SERDE 'serde_name'
  [ WITH SERDEPROPERTIES ( 'property_name' = 'property_value' [, ...] ) ] } ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]

CREATE EXTERNAL TABLE
external_schema.table_name
[ PARTITIONED BY (col_name [,  ] ) ]
[ ROW FORMAT DELIMITED row_format ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
 AS
 { select_statement }
Copy

Clique aqui para acessar a especificação dessa sintaxe.

Amostra de padrões da origem

Código de entrada:

Redshift
 CREATE EXTERNAL TABLE
external_schema.sales_data
(
    sales_id INT,
    product_id INT,
    sales_amount DECIMAL(10, 2),
    sales_date DATE
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE
LOCATION 's3://mybucket/sales_data/';
Copy
Código de saída:
Snowflake
 --** SSC-FDM-0004 - EXTERNAL TABLE TRANSLATED TO REGULAR TABLE **
CREATE TABLE external_schema.sales_data
(
    sales_id INT,
    product_id INT,
    sales_amount DECIMAL(10, 2),
    sales_date DATE
)
--ROW FORMAT DELIMITED
--FIELDS TERMINATED BY ','
--STORED AS TEXTFILE
--LOCATION 's3://mybucket/sales_data/'
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/17/2024" }}'
;
Copy

Create External Table AS

Código de entrada:
Redshift
 CREATE EXTERNAL TABLE spectrum.partitioned_lineitem
PARTITIONED BY (l_shipdate, l_shipmode)
STORED AS parquet
LOCATION 'S3://amzn-s3-demo-bucket/cetas/partitioned_lineitem/'
AS SELECT l_orderkey, l_shipmode, l_shipdate, l_partkey FROM local_table;
Copy
Código de saída:
Snowflake
 --** SSC-FDM-0004 - EXTERNAL TABLE TRANSLATED TO REGULAR TABLE **
CREATE TABLE spectrum.partitioned_lineitem
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/17/2024" }}'
--PARTITIONED BY (l_shipdate, l_shipmode)
--STORED AS parquet
--LOCATION 'S3://amzn-s3-demo-bucket/cetas/partitioned_lineitem/'
AS SELECT l_orderkey, l_shipmode, l_shipdate, l_partkey FROM
local_table;
Copy

Recomendações

EWIs relacionados

  1. SSC-FDM-0004: Tabela externa convertida para tabela regular

CREATE MATERIALIZED VIEW

Descrição

In SnowConvert AI, Redshift Materialized Views are transformed into Snowflake Dynamic Tables. To properly configure Dynamic Tables, two essential parameters must be defined: TARGET_LAG and WAREHOUSE. If these parameters are left unspecified in the configuration options, SnowConvert AI will default to preassigned values during the conversion, as demonstrated in the example below.

Para obter mais informações sobre exibições materializadas, clique aqui.

Para obter detalhes sobre os parâmetros necessários para as tabelas dinâmicas, clique aqui.

Sintaxe da gramática

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

 CREATE MATERIALIZED VIEW mv_name
[ BACKUP { YES | NO } ]
[ table_attributes ]
[ AUTO REFRESH { YES | NO } ]
AS query          
Copy

Amostra de padrões da origem

Código de entrada:

Redshift
 CREATE MATERIALIZED VIEW mv_baseball AS
SELECT ball AS baseball FROM baseball_table;
Copy
Código de saída:
Snowflake
 CREATE DYNAMIC TABLE mv_baseball
--** SSC-FDM-0031 - DYNAMIC TABLE REQUIRED PARAMETERS SET BY DEFAULT **
TARGET_LAG='1 day'
WAREHOUSE=UPDATE_DUMMY_WAREHOUSE
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/26/2024",  "domain": "test" }}'
AS
    SELECT ball AS baseball FROM
        baseball_table;
Copy

Nota

Para obter a documentação dos atributos da tabela, você pode consultar a seguinte documentação:

Aviso

As cláusulas BACKUP e AUTO REFRESH foram excluídas porque não são aplicáveis em uma tabela dinâmica do Snowflake

Ewis relacionados

  • SSC-FDM-0031: Parâmetros necessários da tabela dinâmica definidos por padrão

CREATE SCHEMA

Sintaxe da gramática

 CREATE SCHEMA [ IF NOT EXISTS ] schema_name [ AUTHORIZATION username ]
           [ QUOTA {quota [MB | GB | TB] | UNLIMITED} ] [ schema_element [ ... ]

CREATE SCHEMA AUTHORIZATION username [ QUOTA {quota [MB | GB | TB] | UNLIMITED} ] 
[ schema_element [ ... ] ]
Copy

Para obter mais informações, consulte a documentação de Redshift CREATE SCHEMA.

Amostra de padrões da origem

Amostras básicas

Código de entrada:
Redshift
 CREATE SCHEMA s1;

CREATE SCHEMA IF NOT EXISTS s2;

CREATE SCHEMA s3
CREATE TABLE t1
(
    col1 INT
)
CREATE VIEW v1 AS SELECT * FROM t1;
Copy
Código de saída:
Snowflake
 CREATE SCHEMA IF NOT EXISTS s1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;

CREATE SCHEMA IF NOT EXISTS s2
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;

CREATE SCHEMA IF NOT EXISTS s3
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;
CREATE TABLE t1
(
    col1 INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;
CREATE VIEW v1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
AS SELECT * FROM
    t1;
Copy

Cláusula Authorization

Código de entrada:
Redshift
 CREATE SCHEMA s1 AUTHORIZATION miller;
Copy
Código de saída:
Snowflake
 CREATE SCHEMA IF NOT EXISTS s1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;
Copy

Aviso

Observe que, nesse caso, a cláusula Authorization é removida do código, pois os esquemas do Snowflake são de propriedade de funções, não de usuários individuais. Para obter mais informações, consulte a documentação do Snowflake GRANT OWNERSHIP.

Cláusula Quota

Código de entrada:
Redshift
 CREATE SCHEMA s1 QUOTA UNLIMITED;

CREATE SCHEMA s2 QUOTA 10 TB;
Copy
Código de saída:
Snowflake
 CREATE SCHEMA IF NOT EXISTS s1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;

CREATE SCHEMA IF NOT EXISTS s2
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;
Copy

Nota

No Snowflake, não é permitido definir uma cota por esquema. O gerenciamento de armazenamento é feito no nível da conta e do depósito, e o Snowflake lida com isso automaticamente. Por esse motivo, ele foi removido do código.

Criar autorização de esquema

No Redshift, quando o nome do esquema não é especificado, mas a cláusula de autorização é definida, um novo esquema é criado com o nome do proprietário. Por esse motivo, esse comportamento é replicado no Snowflake.

Código de entrada:
Redshift
 CREATE SCHEMA AUTHORIZATION miller;
Copy
Código de saída:
Snowflake
 CREATE SCHEMA IF NOT EXISTS miller
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/23/2024" }}'
;
Copy

EWIs relacionados

Não há problemas conhecidos.

CREATE FUNCTION

Descrição

This command defines a user-defined function (UDF) within the database. These functions encapsulate reusable logic that can be invoked within SQL queries.

Sintaxe da gramática

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

 CREATE [ OR REPLACE ] FUNCTION f_function_name
( { [py_arg_name  py_arg_data_type |
sql_arg_data_type } [ , ... ] ] )
RETURNS data_type
{ VOLATILE | STABLE | IMMUTABLE }
AS $$
  { python_program | SELECT_clause }
$$ LANGUAGE { plpythonu | sql }               
Copy

SQL Language

Volatility category

In Snowflake, VOLATILE and IMMUTABLE function volatility are functionally equivalent. Given that STABLE is inherently transformed to the default VOLATILE behavior, explicit use of STABLE will be delete.

Código de entrada:
Redshift
 CREATE OR REPLACE FUNCTION get_sale(INTEGER)
RETURNS FLOAT
STABLE
AS $$
SELECT price FROM sales where id = $1
$$ LANGUAGE SQL;
Copy
Código de saída:
Snowflake
 CREATE OR REPLACE FUNCTION get_sale (SC_ARG1 INTEGER)
RETURNS FLOAT
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 $$
SELECT price FROM
sales
where id = SC_ARG1
$$
;
Copy

Python Language

Within the SnowConvert AI scope, the Python language for CREATE FUNCTION statements is not supported. Consequently, the language plpythonu will be flagged with an EWI (SSC-EWI-0073), and its body could appear with parsing errors.

Código de entrada:

Redshift
 create function f_py_greater (a float, b float)
  returns float
stable
as $$
  if a > b:
    return a
  return b
$$ language plpythonu;
Copy
Código de saída:
Snowflake
 create function f_py_greater (a float, b float)
returns float
language plpythonu !!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'LANGUAGE PLPythonU' NODE ***/!!!
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 $$
-- ** SSC-EWI-0001 - UNRECOGNIZED TOKEN ON LINE '5' COLUMN '3' OF THE SOURCE CODE STARTING AT 'if'. EXPECTED 'STATEMENT' GRAMMAR. LAST MATCHING TOKEN WAS 'if' ON LINE '5' COLUMN '3'. **
--  if a > b:
--    return a
--  return b
$$
;
Copy

EWIs relacionados

Não há problemas conhecidos.

CREATE VIEW

Descrição

Esse comando cria uma visualização em um banco de dados, que é executada sempre que a visualização é referenciada em uma consulta. Usando a cláusula WITH NO SCHEMA BINDING, você pode criar exibições para uma tabela externa ou objetos que ainda não existem. Essa cláusula, no entanto, exige que você especifique o nome qualificado do objeto ou da tabela a que está fazendo referência.

Sintaxe da gramática

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

 CREATE [ OR REPLACE ] VIEW name [ ( column_name [, ...] ) ] AS query
[ WITH NO SCHEMA BINDING ]               
Copy

Amostra de padrões da origem

Considerando as cláusulas obrigatórias e opcionais no comando do Redshift, o resultado após a migração para o Snowflake é muito semelhante.

Código de entrada:

Redshift
 CREATE VIEW myuser
AS 
SELECT lastname FROM users;


CREATE VIEW myuser2
AS 
SELECT lastname FROM users2
WITH NO SCHEMA BINDING;
Copy
Código de saída:
Snowflake
 CREATE VIEW myuser
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/16/2025",  "domain": "test" }}'
AS
SELECT lastname FROM
users;

CREATE VIEW myuser2
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/16/2025",  "domain": "test" }}'
AS
SELECT lastname FROM
users2
!!!RESOLVE EWI!!! /*** SSC-EWI-RS0003 - WITH NO SCHEMA BINDING STATEMENT CAN NOT BE REMOVED DUE TO MISSING REFERENCES. ***/!!!
WITH NO SCHEMA BINDING;
Copy

Há algumas exceções, no entanto, de uma cláusula sem suporte do Redshift, portanto, um EWI foi implementado para cobrir esse caso.

EWIs relacionados

  • SSC-EWI-RS0003: A instrução sem vinculação de esquema não é compatível com o Snowflake.

DELETE

Descrição

Note

Essa sintaxe é totalmente compatível com o Snowflake.

Sintaxe da gramática

 [ WITH [RECURSIVE] common_table_expression [, common_table_expression , ...] ]
DELETE [ FROM ] { table_name | materialized_view_name }
    [ USING table_name, ... ]
    [ WHERE condition ]
Copy

Amostra de padrões da origem

Setup data

Redshift
 CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    department VARCHAR(255),
    manager_id INT REFERENCES employees(id)
);

INSERT INTO employees (id, name, department, manager_id) VALUES
(1, 'Alice', 'Sales', 2),
(2, 'Bob', 'Sales', 1),
(3, 'Charlie', 'Sales', 1),
(4, 'David', 'Marketing', 2),
(5, 'Eve', 'Marketing', 4),
(6, 'Frank', 'Marketing', 4),
(7, 'Grace', 'Engineering', 6),
(8, 'Helen', 'Engineering', 7),
(9, 'Ivy', 'Engineering', 7),
(10, 'John', 'Sales', 3),
(11, 'Joe', 'Engineering', 5);


CREATE TABLE departments (
    department_name VARCHAR(255)
);

INSERT INTO departments (department_name) VALUES
('Sales'), 
('Marketing'), 
('Engineering');
Copy

Cláusula From

Atualize uma tabela fazendo referência a informações de outras tabelas. No Redshift, a palavra-chave FROM é opcional, mas no Snowflake, ela é obrigatória. Portanto, ela será adicionada nos casos em que estiver faltando.

Código de entrada:
Redshift
 DELETE employees;

SELECT * FROM employees ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

Código de saída:
Snowflake
 DELETE FROM
    employees;
    
SELECT * FROM employees ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

Cláusula Where

Restringe as atualizações às linhas que correspondem a uma condição. Quando a condição for verdadeira, as colunas SET especificadas serão atualizadas. A condição pode ser um predicado simples em uma coluna ou uma condição baseada no resultado de uma subconsulta. Essa cláusula é totalmente equivalente no Snowflake.

Código de entrada:
Redshift
 DELETE FROM employees
WHERE department = 'Marketing';

SELECT * FROM employees
ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

1

Alice

Vendas

2

2

Bob

Vendas

1

3

Charlie

Vendas

1

7

Grace

Engenharia

6

8

Helen

Engenharia

7

9

Hera

Engenharia

7

10

John

Vendas

3

11

Joe

Engenharia

5

Código de saída:
Snowflake
 DELETE FROM
    employees
WHERE department = 'Marketing';

SELECT * FROM
    employees
ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

1

Alice

Vendas

2

2

Bob

Vendas

1

3

Charlie

Vendas

1

7

Grace

Engenharia

6

8

Helen

Engenharia

7

9

Hera

Engenharia

7

10

John

Vendas

3

11

Joe

Engenharia

5

Cláusula Using

Essa cláusula introduz uma lista de tabelas quando tabelas adicionais são referenciadas na condição da cláusula WHERE. Essa cláusula é totalmente equivalente no Snowflake.

Código de entrada:
Redshift
 DELETE FROM employees
USING departments d
WHERE employees.department = d.department_name
AND d.department_name = 'Sales';

SELECT * FROM employees ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

4

David

Marketing

2

5

Eve

Marketing

4

6

Frank

Marketing

4

7

Grace

Engenharia

6

8

Helen

Engenharia

7

9

Hera

Engenharia

7

11

Joe

Engenharia

5

Código de saída:
Snowflake
 DELETE FROM employees
USING departments d
WHERE employees.department = d.department_name
AND d.department_name = 'Sales';

SELECT * FROM employees ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

4

David

Marketing

2

5

Eve

Marketing

4

6

Frank

Marketing

4

7

Grace

Engenharia

6

8

Helen

Engenharia

7

9

Hera

Engenharia

7

11

Joe

Engenharia

5

Cláusula WITH

Essa cláusula especifica uma ou mais expressões comuns de tabela (CTE). Os nomes das colunas de saída são opcionais para CTEs não recursivos, mas obrigatórios para os recursivos.

Como essa cláusula não pode ser usada em uma instrução DELETE, ela é transformada em tabelas temporárias com suas consultas correspondentes. Depois que a instrução DELETE é executada, essas tabelas temporárias são descartadas para limpar, liberar recursos e evitar colisões de nomes ao criar tabelas na mesma sessão. Além disso, se existir uma tabela regular com o mesmo nome, ela terá precedência novamente, pois a tabela temporária tem prioridade sobre qualquer outra tabela com o mesmo nome na mesma sessão.

CTE Não recursivo
Código de entrada:
Redshift
 WITH sales_employees AS (
    SELECT id
    FROM employees
    WHERE department = 'Sales'
), engineering_employees AS (
    SELECT id
    FROM employees
    WHERE department = 'Engineering'
)
DELETE FROM employees
WHERE id IN (SELECT id FROM sales_employees)
   OR id IN (SELECT id FROM engineering_employees);

SELECT * FROM employees ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

4

David

Marketing

2

5

Eve

Marketing

4

6

Frank

Marketing

4

Código de saída:
Snowflake
 CREATE TEMPORARY TABLE sales_employees AS
SELECT id
FROM employees
WHERE department = 'Sales';

CREATE TEMPORARY TABLE engineering_employees AS
SELECT id
FROM employees
WHERE department = 'Engineering';

DELETE FROM
    employees
WHERE id IN (SELECT id FROM sales_employees)
   OR id IN (SELECT id FROM engineering_employees);
   
DROP TABLE sales_employees;
DROP TABLE engineering_employees;

SELECT * FROM
    employees
ORDER BY id;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

4

David

Marketing

2

5

Eve

Marketing

4

6

Frank

Marketing

4

CTE Recursivo
Código de entrada:
Redshift
 WITH RECURSIVE subordinate_hierarchy(id, name, department, level) AS (
    SELECT id, name, department, 0 as level
    FROM employees
    WHERE department = 'Marketing'

    UNION ALL

    SELECT e.id, e.name, e.department, sh.level + 1
    FROM employees e
    INNER JOIN subordinate_hierarchy sh ON e.manager_id = sh.id
)
DELETE FROM employees
WHERE id IN (SELECT id FROM subordinate_hierarchy);
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

1

Alice

Vendas

2

2

Bob

Vendas

1

3

Charlie

Vendas

1

10

John

Vendas

3

Código de saída:
Snowflake
 CREATE TEMPORARY TABLE subordinate_hierarchy AS
   WITH RECURSIVE subordinate_hierarchy(id, name, department, level) AS (
       SELECT id, name, department, 0 as level
       FROM
           employees
       WHERE department = 'Marketing'

       UNION ALL

       SELECT e.id, e.name, e.department, sh.level + 1
       FROM
           employees e
       INNER JOIN
               subordinate_hierarchy sh ON e.manager_id = sh.id
   )
   SELECT
       id,
       name,
       department,
       level
   FROM
       subordinate_hierarchy;
       
   DELETE FROM
   employees
   WHERE id IN (SELECT id FROM
           subordinate_hierarchy
   );
   
   DROP TABLE subordinate_hierarchy;
Copy
Result

ID

NAME

DEPARTMENT

MANAGER_ID

1

Alice

Vendas

2

2

Bob

Vendas

1

3

Charlie

Vendas

1

10

John

Vendas

3

Excluir exibição materializada

No Redshift, você pode aplicar a instrução DELETE a exibições materializadas usadas para ingestão de streaming. No Snowflake, essas exibições são transformadas em tabelas dinâmicas, e a instrução DELETE não pode ser usada em tabelas dinâmicas. Por esse motivo, um EWI será adicionado.

Código de entrada:
Redshift
 CREATE MATERIALIZED VIEW emp_mv AS
SELECT id, name, department FROM employees WHERE department = 'Engineering';

DELETE FROM emp_mv
WHERE id = 2;
Copy
Código de saída:
Snowflake
 CREATE DYNAMIC TABLE emp_mv
--** SSC-FDM-0031 - DYNAMIC TABLE REQUIRED PARAMETERS SET BY DEFAULT **
TARGET_LAG='1 day'
WAREHOUSE=UPDATE_DUMMY_WAREHOUSE
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/11/2025",  "domain": "test" }}'
AS
SELECT id, name, department FROM
employees
WHERE department = 'Engineering';
        
        
!!!RESOLVE EWI!!! /*** SSC-EWI-RS0008 - MATERIALIZED VIEW IS TRANSFORMED INTO A DYNAMIC TABLE, AND THE DELETE STATEMENT CANNOT BE USED ON DYNAMIC TABLES. ***/!!!
DELETE FROM
emp_mv
WHERE id = 2;
Copy

Problemas conhecidos

  • Replicar a funcionalidade da cláusula WITH requer a criação de tabelas temporárias que espelham cada Common Table Expression (CTE). No entanto, essa abordagem falha se uma tabela temporária com o mesmo nome já existir na sessão atual, causando um erro.

EWIs relacionados

  1. SSC-FDM-0031: Parâmetros necessários da tabela dinâmica definidos por padrão.

  2. SSC-EWI-RS0008: A instrução Delete não pode ser usada em tabelas dinâmicas.

EXECUTE

Descrição

The EXECUTE IMMEDIATE statement builds and runs a dynamic SQL statement in a single operation.

Native dynamic SQL uses the EXECUTE IMMEDIATE statement to process most dynamic SQL statements. (Redshift Language Reference EXECUTE Statement)

Sintaxe da gramática

 EXECUTE command-string [ INTO target ];
Copy

Amostra de padrões da origem

Concated Example

Código de entrada

Redshift

 CREATE OR REPLACE PROCEDURE create_dynamic_table(table_name VARCHAR) 
AS $$ 
DECLARE 
sql_statement VARCHAR; 
BEGIN 
sql_statement := 'CREATE TABLE IF NOT EXISTS ' || table_name || ' (id INT, value VARCHAR);'; 
EXECUTE sql_statement; 
END;
$$ LANGUAGE plpgsql; 
Copy

Código de saída

Snowflake
 CREATE OR REPLACE PROCEDURE create_dynamic_table (table_name VARCHAR)
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
sql_statement VARCHAR;
BEGIN
sql_statement := 'CREATE TABLE IF NOT EXISTS ' || table_name || ' (id INT, value VARCHAR)';
!!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
EXECUTE IMMEDIATE sql_statement;
END;
$$;
Copy

Function Transformation

Código de entrada
Redshift
 CREATE OR REPLACE PROCEDURE insert_with_dynamic()
AS $$
DECLARE
sql_statement VARCHAR;
BEGIN
sql_statement := 'insert into orders(order_date) values ("getdate"());';
EXECUTE sql_statement;
END;
$$ LANGUAGE plpgsql;
Copy
Código de saída
Snowflake
 CREATE OR REPLACE PROCEDURE insert_with_dynamic ()
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
sql_statement VARCHAR;
BEGIN
sql_statement := 'insert into orders (order_date) values (GETDATE())';
!!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
EXECUTE IMMEDIATE sql_statement;
END;
$$;
Copy

Error In Query Parsing

Código de entrada
Redshift
 CREATE OR REPLACE PROCEDURE bad_statement(table_name VARCHAR) 
AS $$ 
DECLARE 
sql_statement VARCHAR; 
BEGIN 
sql_statement := 'bad statement goes here'; 
EXECUTE sql_statement; 
END;
$$ LANGUAGE plpgsql;
Copy
Código de saída
Snowflake
 CREATE OR REPLACE PROCEDURE bad_statement (table_name VARCHAR)
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
sql_statement VARCHAR;
BEGIN
sql_statement := 'bad statement goes here';
!!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!!!!RESOLVE EWI!!! /*** SSC-EWI-0027 - THE FOLLOWING STATEMENT USES A VARIABLE/LITERAL WITH AN INVALID QUERY AND IT WILL NOT BE EXECUTED ***/!!!
EXECUTE IMMEDIATE sql_statement;
END;
$$;
Copy

INTO Clause

Código de entrada
Redshift
 CREATE OR REPLACE PROCEDURE get_max_id(table_name VARCHAR, OUT max_id INTEGER)
AS $$
DECLARE
    sql_statement VARCHAR;
BEGIN
    sql_statement := 'SELECT MAX(id) FROM ' || table_name || ';';
    EXECUTE sql_statement INTO max_id;
END;
$$ LANGUAGE plpgsql;
Copy
Código de saída
Snowflake
 CREATE OR REPLACE PROCEDURE get_max_id (table_name VARCHAR, max_id OUT 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
            sql_statement VARCHAR;
BEGIN
    sql_statement := 'SELECT
   MAX(id) FROM
   ' || table_name;
            !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
            EXECUTE IMMEDIATE sql_statement
                                            !!!RESOLVE EWI!!! /*** SSC-EWI-PG0007 - INTO CLAUSE IN DYNAMIC SQL IS NOT SUPPORTED IN SNOWFLAKE. ***/!!! INTO max_id;
END;
$$;
Copy

Problemas conhecidos

1. Execution results cannot be stored in variables.

SnowScripting does not support INTO nor BULK COLLECT INTO clauses. For this reason, results will need to be passed through other means.

2. Dynamic SQL Execution queries may be marked incorrectly as non-runnable.

In some scenarios there an execute statement may be commented regardless of being safe or non-safe to run so please take this into account:

EWIs relacionados

  1. SSC-EWI-0027: Variable with invalid query.

  2. SSC-EWI-0030: The statement below has usages of dynamic SQL.

INSERT

Descrição

Aviso

Essa sintaxe é parcialmente compatível com o Snowflake.

Sintaxe da gramática

 INSERT INTO table_name [ ( column [, ...] ) ]
{DEFAULT VALUES |
VALUES ( { expression | DEFAULT } [, ...] )
[, ( { expression | DEFAULT } [, ...] )
[, ...] ] |
query }
Copy

Amostra de padrões da origem

Setup data

Redshift
 CREATE TABLE employees (
    id INTEGER IDENTITY(1,1),
    name VARCHAR(100),
    salary INT DEFAULT 20000,
    department VARCHAR(50) DEFAULT 'Marketing'
);

CREATE TABLE new_employees (
    name VARCHAR(100),
    salary INT,
    department VARCHAR(50)
);

INSERT INTO new_employees (name, salary, department)
VALUES
    ('Grace Lee', 32000, 'Operations'),
    ('Hannah Gray', 26000, 'Finance');
Copy

Valores padrão

Ele insere uma linha completa com seus valores padrão. Se alguma coluna não tiver valores padrão, os valores NULL serão inseridos nessas colunas.

This clause cannot specify individual columns; it always inserts a complete row with its default values. Additionally, columns with the NOT NULL constraint cannot be included in the table definition. To replicate this behavior in Snowflake, SnowConvert AI insert a column with a DEFAULT value in the table. This action inserts a complete row, using the default value for every column.

Código de entrada:
Redshift
 CREATE TABLE employees (
    id INTEGER IDENTITY(1,1),
    name VARCHAR(100),
    salary INT DEFAULT 20000,
    department VARCHAR(50) DEFAULT 'Marketing'
);

INSERT INTO employees
DEFAULT VALUES;

SELECT * FROM employees ORDER BY id;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

NULL

20000

Marketing

Código de saída:
Snowflake
 CREATE TABLE employees (
    id INTEGER IDENTITY(1,1) ORDER,
    name VARCHAR(100),
    salary INT DEFAULT 20000,
    department VARCHAR(50) DEFAULT 'Marketing'
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}';

INSERT INTO employees (id)
VALUES (DEFAULT);

SELECT * FROM
    employees
ORDER BY id;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

NULL

20000

Marketing

Consulta

Insere uma ou mais linhas na tabela usando uma consulta. Todas as linhas produzidas pela consulta serão inseridas na tabela. A consulta deve retornar uma lista de colunas que seja compatível com as colunas da tabela, embora os nomes das colunas não precisem corresponder. Essa funcionalidade é totalmente equivalente no Snowflake.

Código de entrada:
Redshift
 INSERT INTO employees (name, salary, department)
SELECT name, salary, department FROM new_employees;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Grace Lee

32000

Operações

2

Hannah Gray

26000

Finance

Código de saída:
Snowflake
 INSERT INTO employees (name, salary, department)
SELECT name, salary, department FROM
    new_employees;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Grace Lee

32000

Operações

2

Hannah Gray

26000

Finance

Problemas conhecidos

  • Certas expressões não podem ser usadas na cláusula VALUES no Snowflake. Por exemplo, no Redshift, a função JSON_PARSE pode ser usada na cláusula VALUES para inserir um valor JSON em um tipo de dados SUPER. No Snowflake, entretanto, a função PARSE_JSON não pode ser usada na cláusula VALUES para inserir um valor JSON em um tipo de dados VARIANT. Em vez disso, uma consulta pode ser usada no lugar da cláusula VALUES. Para obter mais detalhes, consulte a documentação do Snowflake. Você também pode consultar o artigo a seguir para obter mais informações.

EWIs relacionados

Não há problemas conhecidos.

MERGE

Sintaxe da gramática

 MERGE INTO target_table 
USING source_table [ [ AS ] alias ] 
ON match_condition 
[ WHEN MATCHED THEN { UPDATE SET col_name = { expr } [,...] | DELETE }
WHEN NOT MATCHED THEN INSERT [ ( col_name [,...] ) ] VALUES ( { expr } [, ...] ) |
REMOVE DUPLICATES ]
Copy

Para obter mais informações, consulte a documentação MERGE do Redshift.

Amostra de padrões da origem

UPDATE - INSERT

Não há diferenças entre as linguagens. O código é mantido em sua forma original.

Código de entrada:
Redshift
 MERGE INTO target USING source ON target.id = source.id
WHEN MATCHED THEN UPDATE SET id = source.id, name = source.name
WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name);
Copy
Código de saída:
Snowflake
 --** SSC-FDM-RS0005 - REDSHIFT MERGE STATEMENT DOESN'T ALLOW DUPLICATES IN THE SOURCE TABLE. SNOWFLAKE BEHAVIOR MAY DIFFER IF THERE ARE DUPLICATE VALUES. **
MERGE INTO target USING source ON target.id = source.id
WHEN MATCHED THEN UPDATE SET id = source.id, name = source.name
WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name);
Copy

DELETE - INSERT

Não há diferenças entre as linguagens. O código é mantido em sua forma original.

Código de entrada:
Redshift
 MERGE INTO target USING source ON target.id = source.id
WHEN MATCHED THEN DELETE
WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name);
Copy
Código de saída:
Snowflake
 --** SSC-FDM-RS0005 - REDSHIFT MERGE STATEMENT DOESN'T ALLOW DUPLICATES IN THE SOURCE TABLE. SNOWFLAKE BEHAVIOR MAY DIFFER IF THERE ARE DUPLICATE VALUES. **
MERGE INTO target USING source ON target.id = source.id
WHEN MATCHED THEN DELETE
WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name);
Copy

REMOVE DUPLICATES

A cláusula REMOVE DUPLICATES não é compatível com o Snowflake, no entanto, há uma solução alternativa que pode emular o comportamento original.

O código de saída terá três novas instruções:

  • TEMPORARY TABLE com os valores duplicados da tabela de origem e de destino que correspondem à condição

  • Uma instrução INSERT que adiciona os valores pendentes à tabela de destino após a mesclagem

  • Uma instrução DROP que elimina a tabela temporária gerada.

Isso é necessário porque o comportamento de DROP DUPLICATES remove os valores duplicados da tabela de destino e, em seguida, insere os valores que correspondem à condição da tabela de origem.

Código de entrada:
Redshift
 CREATE TABLE target (id INT, name CHAR(10));
CREATE TABLE source (id INT, name CHAR(10));

INSERT INTO target VALUES (30, 'Tony'), (30, 'Daisy'), (11, 'Alice'), (23, 'Bill'), (23, 'Nikki');
INSERT INTO source VALUES (23, 'David'), (22, 'Clarence');

MERGE INTO target USING source ON target.id = source.id REMOVE DUPLICATES;
Copy
Results

ID

NAME

30

Daisy

22

Clarence

30

Tony

11

Alice

23

David

Código de saída:
Snowflake
 CREATE TABLE target (id INT, name CHAR(10))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}';

CREATE TABLE source (id INT, name CHAR(10))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}';

INSERT INTO target
VALUES (30, 'Tony'), (30, 'Daisy'), (11, 'Alice'), (23, 'Bill'), (23, 'Nikki');

INSERT INTO source
VALUES (23, 'David'), (22, 'Clarence');

CREATE TEMPORARY TABLE source_duplicates AS
SELECT DISTINCT
source.*
FROM
source
INNER JOIN
target
ON target.id = source.id;
--** SSC-FDM-RS0005 - REDSHIFT MERGE STATEMENT DOESN'T ALLOW DUPLICATES IN THE SOURCE TABLE. SNOWFLAKE BEHAVIOR MAY DIFFER IF THERE ARE DUPLICATE VALUES. **
MERGE INTO target
USING source ON target.id = source.id
WHEN MATCHED THEN
DELETE
WHEN NOT MATCHED THEN
INSERT
VALUES (source.id, source.name);
INSERT INTO target

SELECT
*
FROM
source_duplicates;

DROP TABLE IF EXISTS source_duplicates CASCADE;
Copy
Results

ID

NAME

22

Clarence

30

Tony

30

Daisy

11

Alice

23

David

Problemas conhecidos

Não há problemas conhecidos.

EWIs relacionados

  1. SSC-EWI-RS0009: Informações semânticas não encontradas para a tabela de origem.

  2. SSC-FDM-RS0005: Duplicatas não são permitidas na tabela de origem.

UPDATE

Descrição

Atualiza os valores em uma ou mais colunas da tabela quando uma condição é atendida. (Instrução Update de referência da linguagem Redshift SQL).

Note

Essa sintaxe é totalmente compatível com o Snowflake.

Sintaxe da gramática

 [ WITH [RECURSIVE] common_table_expression [, common_table_expression , ...] ]
            UPDATE table_name [ [ AS ] alias ] SET column = { expression | DEFAULT } [,...]

[ FROM fromlist ]
[ WHERE condition ]
Copy

Amostra de padrões da origem

Setup data

Redshift
 CREATE TABLE employees (
    id INTEGER IDENTITY(1,1),
    name VARCHAR(100),
    salary DECIMAL DEFAULT 20000,
    department VARCHAR(50) DEFAULT 'Marketing'
);

INSERT INTO employees (name, salary, department)
VALUES
    ('Alice', 500000, 'HR'),
    ('Bob', 600000, 'Engineering'),
    ('Charlie', 700000, 'Engineering'),
    ('David', 400000, 'Marketing'),
    ('Eve', 450000, 'HR'),
    ('Frank', 750000, 'Engineering'),
    ('Grace', 650000, 'Engineering'),
    ('Helen', 390000, 'Marketing'),
    ('Ivy', 480000, 'HR'),
    ('Jack', 420000, 'Engineering'),
    ('Ken', 700000, 'Marketing'),
    ('Liam', 600000, 'Engineering'),
    ('Mona', 470000, 'HR');

CREATE TABLE department_bonus (
    department VARCHAR(100),
    bonus DECIMAL
);

INSERT INTO department_bonus (department, bonus)
VALUES
    ('HR', 10000),
    ('Engineering', 50000),
    ('Marketing', 20000),
    ('Sales', 5000);
Copy

Alias

Embora a gramática do Snowflake não especifique que um alias de tabela possa ser usado, esse é um código válido no Snowflake.

Código de entrada:
Redshift
 UPDATE employees AS e
SET salary = salary + 5000
WHERE e.salary < 600000;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

505000

HR

2

Bob

600000

Engenharia

3

Charlie

700000

Engenharia

4

David

405000

Marketing

5

Eve

455000

HR

6

Frank

750000

Engenharia

7

Grace

650000

Engenharia

8

Helen

395000

Marketing

9

Hera

485000

HR

10

Jack

425000

Engenharia

11

Ken

700000

Marketing

12

Liam

600000

Engenharia

13

Mona

475000

HR

Código de saída:
Snowflake
 UPDATE employees AS e
SET salary = salary + 5000
WHERE e.salary < 600000;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

505000

HR

2

Bob

600000

Engenharia

3

Charlie

700000

Engenharia

4

David

405000

Marketing

5

Eve

455000

HR

6

Frank

750000

Engenharia

7

Grace

650000

Engenharia

8

Helen

395000

Marketing

9

Hera

485000

HR

10

Jack

425000

Engenharia

11

Ken

700000

Marketing

12

Liam

600000

Engenharia

13

Mona

475000

HR

Cláusula WITH

Essa cláusula especifica uma ou mais expressões comuns de tabela (CTE). Os nomes das colunas de saída são opcionais para CTEs não recursivos, mas obrigatórios para os recursivos.

Como essa cláusula não pode ser usada em uma instrução UPDATE, ela é transformada em tabelas temporárias com suas consultas correspondentes. Depois que a instrução UPDATE é executada, essas tabelas temporárias são descartadas para limpar, liberar recursos e evitar colisões de nomes ao criar tabelas na mesma sessão. Além disso, se existir uma tabela regular com o mesmo nome, ela terá precedência novamente, pois a tabela temporária tem prioridade sobre qualquer outra tabela com o mesmo nome na mesma sessão.

CTE Não recursivo
Código de entrada:
Redshift
 WITH avg_salary_cte AS (
    SELECT AVG(salary) AS avg_salary FROM employees
)
UPDATE employees
SET salary = (SELECT avg_salary FROM avg_salary_cte)
WHERE salary < 500000;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

500000

HR

2

Bob

600000

Engenharia

3

Charlie

700000

Engenharia

4

David

546923

Marketing

5

Eve

546923

HR

6

Frank

750000

Engenharia

7

Grace

650000

Engenharia

8

Helen

546923

Marketing

9

Hera

546923

HR

10

Jack

546923

Engenharia

11

Ken

700000

Marketing

12

Liam

600000

Engenharia

13

Mona

546923

HR

Código de saída:
Snowflake
 CREATE TEMPORARY TABLE avg_salary_cte AS
SELECT AVG(salary) AS avg_salary FROM
employees;

UPDATE employees
SET salary = (SELECT avg_salary FROM
      avg_salary_cte
)
WHERE salary < 500000;

DROP TABLE avg_salary_cte;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

500000

HR

2

Bob

600000

Engenharia

3

Charlie

700000

Engenharia

4

David

546923

Marketing

5

Eve

546923

HR

6

Frank

750000

Engenharia

7

Grace

650000

Engenharia

8

Helen

546923

Marketing

9

Hera

546923

HR

10

Jack

546923

Engenharia

11

Ken

700000

Marketing

12

Liam

600000

Engenharia

13

Mona

546923

HR

CTE Recursivo
Código de entrada:
Redshift
 WITH RECURSIVE bonus_updates(id, name, department, salary, level) AS (
    SELECT e.id,
           e.name,
           e.department,
           e.salary + CASE
                          WHEN db.bonus IS NOT NULL THEN db.bonus
                          ELSE 0
               END AS new_salary,
           1 AS level
    FROM employees e
    LEFT JOIN department_bonus db ON e.department = db.department
    UNION ALL
    SELECT e.id,
           e.name,
           e.department,
           e.salary + CASE
                          WHEN db.bonus IS NOT NULL THEN db.bonus
                          ELSE 0
               END + (e.salary * 0.05) AS new_salary,
           bu.level + 1
    FROM employees e
    JOIN department_bonus db ON e.department = db.department
    JOIN bonus_updates bu ON e.id = bu.id
    WHERE bu.level < 3
)
UPDATE employees
SET salary = bu.new_salary
FROM (SELECT id, AVG(salary) as new_salary FROM bonus_updates GROUP BY id) as bu
WHERE employees.id = bu.id
  AND bu.new_salary > employees.salary;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

526666

HR

2

Bob

670000

Engenharia

3

Charlie

773333

Engenharia

4

David

433333

Marketing

5

Eve

475000

HR

6

Frank

825000

Engenharia

7

Grace

721666

Engenharia

8

Helen

423000

Marketing

9

Hera

506000

HR

10

Jack

484000

Engenharia

11

Ken

743333

Marketing

12

Liam

670000

Engenharia

13

Mona

495668

HR

Código de saída:
Snowflake
 CREATE TEMPORARY TABLE bonus_updates AS
  --** SSC-FDM-0007 - MISSING DEPENDENT OBJECTS "employees", "department_bonus" **
 WITH RECURSIVE bonus_updates(id, name, department, salary, level) AS (
     SELECT e.id,
            e.name,
            e.department,
            e.salary + CASE
                           WHEN db.bonus IS NOT NULL THEN db.bonus
                           ELSE 0
                END AS new_salary,
            1 AS level
     FROM
            employees e
     LEFT JOIN
                           department_bonus db ON e.department = db.department
     UNION ALL
     SELECT e.id,
            e.name,
            e.department,
            e.salary + CASE
                           WHEN db.bonus IS NOT NULL THEN db.bonus
                           ELSE 0
                END + (e.salary * 0.05) AS new_salary,
            bu.level + 1
     FROM
            employees e
     JOIN
                           department_bonus db ON e.department = db.department
     JOIN
                           bonus_updates bu ON e.id = bu.id
     WHERE bu.level < 3
 )
 SELECT
     id,
     name,
     department,
     salary,
     level
 FROM
     bonus_updates;
     
UPDATE employees
SET salary = bu.new_salary
FROM (SELECT id, AVG(salary) as new_salary 
FROM bonus_updates 
GROUP BY id) as bu
WHERE employees.id = bu.id
  AND bu.new_salary > employees.salary;
 
DROP TABLE bonus_updates;
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

526667

HR

2

Bob

670000

Engenharia

3

Charlie

773333

Engenharia

4

David

433333

Marketing

5

Eve

475000

HR

6

Frank

825000

Engenharia

7

Grace

721667

Engenharia

8

Helen

423000

Marketing

9

Hera

506000

HR

10

Jack

484000

Engenharia

11

Ken

743333

Marketing

12

Liam

670000

Engenharia

13

Mona

495667

HR

Valores SETDEFAULT

Código de entrada:
Redshift
 UPDATE employees
SET salary = DEFAULT, department = 'Sales'
WHERE department = 'HR';
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

20000

Vendas

2

Bob

600000

Engenharia

3

Charlie

700000

Engenharia

4

David

400000

Marketing

5

Eve

20000

Vendas

6

Frank

750000

Engenharia

7

Grace

650000

Engenharia

8

Helen

390000

Marketing

9

Hera

20000

Vendas

10

Jack

420000

Engenharia

11

Ken

700000

Marketing

12

Liam

600000

Engenharia

13

Mona

20000

Vendas

Código de saída:
Snowflake
 UPDATE employees
SET salary = DEFAULT, department = 'Sales'
WHERE
    department = 'HR';
Copy
Result

ID

NAME

SALARY

DEPARTMENT

1

Alice

20000

Vendas

2

Bob

600000

Engenharia

3

Charlie

700000

Engenharia

4

David

400000

Marketing

5

Eve

20000

Vendas

6

Frank

750000

Engenharia

7

Grace

650000

Engenharia

8

Helen

390000

Marketing

9

Hera

20000

Vendas

10

Jack

420000

Engenharia

11

Ken

700000

Marketing

12

Liam

600000

Engenharia

13

Mona

20000

Vendas

Cláusula SET

Ele é responsável por modificar os valores nas colunas. Semelhante ao Snowflake, as consultas de atualização com várias correspondências por linha gerarão um erro quando o parâmetro de configuração ERROR_ON_NONDETERMINISTIC_UPDATE for definido como verdadeiro. Esse sinalizador funciona da mesma forma no Snowflake e até usa o mesmo nome, ERROR_ON_NONDETERMINISTIC_UPDATE.

No entanto, quando esse sinalizador é desativado, nenhum erro é retornado e uma das linhas correspondentes é usada para atualizar a linha de destino. A linha unida selecionada é não determinística e arbitrária em ambas as linguagens; o comportamento pode não ser consistente em todas as execuções, o que pode levar a inconsistências de dados.

Dados de configuração:
Redshift
 CREATE TABLE target (
  k INT,
  v INT
);

CREATE TABLE src (
  k INT,
  v INT
);

INSERT INTO target (k, v) VALUES (0, 10);

INSERT INTO src (k, v) VALUES
  (0, 14),
  (0, 15),
  (0, 16);
Copy
Código de entrada:
Redshift
 UPDATE target
  SET v = src.v
  FROM src
  WHERE target.k = src.k;


SELECT * FROM target;
Copy
Result

K

V

0

16

Código de saída:
Snowflake
 UPDATE target
  SET v = src.v
  FROM src
  WHERE target.k = src.k;


SELECT * FROM target;
Copy
Result

K

V

0

14

Problemas conhecidos

  • As consultas de atualização com várias correspondências por linha podem causar inconsistências nos dados. Embora ambas as plataformas tenham o sinalizador ERROR_ON_NONDETERMINISTIC_UPDATE, esses valores sempre serão não determinísticos. A Snowflake oferece recomendações para lidar com esses cenários. Clique aqui para obter mais detalhes.

  • Replicar a funcionalidade da cláusula WITH requer a criação de tabelas temporárias que espelham cada Common Table Expression (CTE). No entanto, essa abordagem falha se uma tabela temporária com o mesmo nome já existir na sessão atual, causando um erro.

EWIs relacionados

Não há problemas conhecidos.