SnowConvert: Instruções Redshift SQL¶
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).
Aviso
Essa sintaxe é parcialmente compatível com o Snowflake. As chamadas de procedimento que usam parâmetros de saída serão marcadas com a tag SSC-EWI-0073. Essa transformação será realizada no futuro.
Sintaxe da gramática¶
CALL sp_name ( [ argument ] [, ...] )
Amostra de padrões da origem¶
Cenário básico¶
Código de entrada:¶
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);
Código de saída:¶
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": "03/14/2025", "domain": "test" }}'
AS
$$
BEGIN
INSERT INTO event
VALUES (:arg1, : arg2);
END;
$$;
CALL sp_insert_values(1, CURRENT_DATE());
Chamada usando o modo de parâmetros de saída (INOUT, OUT)¶
Código de entrada:¶
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();
Código de saída:¶
CREATE OR REPLACE PROCEDURE sp_calculate_sum_product (a NUMERIC, b NUMERIC, sum_result NUMERIC, product_result NUMERIC)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "03/14/2025", "domain": "test" }}'
AS $$
BEGIN
sum_result := a + b;
product_result := a * b;
RETURN OBJECT_CONSTRUCT('sum_result', :sum_result, 'product_result', :product_result);
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": "03/14/2025", "domain": "test" }}'
AS $$
DECLARE
sum_value NUMERIC DEFAULT NULL;
product_value NUMERIC DEFAULT NULL;
BEGIN
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'CALL' NODE ***/!!!
CALL sp_calculate_sum_product(FLOOR(20.5), CEIL(20.7), sum_value, product_value);
INSERT INTO test
VALUES (:sum_value, : product_value);
END;
$$;
CALL call_sp_calculate_sum_product();
Problemas conhecidos¶
No momento, não há suporte para parâmetros de saída em chamadas de procedimento.
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>' } }
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:¶
CREATE DATABASE database_name;
Código de saída:¶
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" }}';
Cláusula de agrupamento¶
Código de entrada:¶
CREATE DATABASE database_collate
COLLATE CASE_INSENSITIVE;
Código de saída:¶
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" }}';
Cláusula de limite de conexão¶
Código de entrada:¶
CREATE DATABASE database_connection
CONNECTION LIMIT UNLIMITED;
Código de saída:¶
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" }}';
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:¶
CREATE DATABASE database_fromARN
FROM ARN 'arn' WITH NO DATA CATALOG SCHEMA IAM_ROLE 'arn:aws:iam::<account-id>:role/<role-name';
Código de saída:¶
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" }}';
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 Owner¶
Código de entrada¶
CREATE DATABASE database_Owner
OWNER db_owner
ENCODING 'encoding';
Código de saída¶
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" }}';
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¶
CREATE DATABASE database_Isolation
ISOLATION LEVEL SNAPSHOT;
Código de saída¶
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" }}';
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 ¶
Atualmente, o Snowconvert está transformando CREATE EXTERNAL TABLES
em tabelas regulares, o que implica um esforço adicional, pois os dados armazenados em tabelas RedShift externas devem ser transferidos para o banco de dados do Snowflake.
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 }
Clique aqui para acessar a especificação dessa sintaxe.
Amostra de padrões da origem¶
Código de entrada:¶
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/';
Código de saída:¶
--** 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" }}'
;
Create External Table AS¶
Código de entrada:¶
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;
Código de saída:¶
--** 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;
Recomendações¶
Para saber como usar Create External Table no Snowflake, você pode consultar a documentação do Snowflake
EWIs relacionados¶
SSC-FDM-0004: Tabela externa convertida para tabela regular
CREATE MATERIALIZED VIEW¶
Descrição¶
No Snowconvert, as exibições materializadas do Redshift são transformadas em tabelas dinâmicas do Snowflake. Para configurar corretamente as tabelas dinâmicas, dois parâmetros essenciais devem ser definidos: TARGET_LAG e WAREHOUSE. Se esses parâmetros não forem especificados nas opções de configuração, o Snowconvert usará como padrão os valores predefinidos durante a conversão, conforme demonstrado no exemplo abaixo.
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
Amostra de padrões da origem¶
Código de entrada:¶
CREATE MATERIALIZED VIEW mv_baseball AS
SELECT ball AS baseball FROM baseball_table;
Código de saída:¶
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;
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 [ ... ] ]
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:¶
CREATE SCHEMA s1;
CREATE SCHEMA IF NOT EXISTS s2;
CREATE SCHEMA s3
CREATE TABLE t1
(
col1 INT
)
CREATE VIEW v1 AS SELECT * FROM t1;
Código de saída:¶
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;
Cláusula Quota¶
Código de entrada:¶
CREATE SCHEMA s1 QUOTA UNLIMITED;
CREATE SCHEMA s2 QUOTA 10 TB;
Código de saída:¶
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" }}'
;
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.
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 ]
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:¶
CREATE VIEW myuser
AS
SELECT lastname FROM users;
CREATE VIEW myuser2
AS
SELECT lastname FROM users2
WITH NO SCHEMA BINDING;
Código de saída:¶
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;
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¶
Exclui linhas das tabelas. (Instrução Delete de referência da linguagem Redshift SQL).
Essa sintaxe é totalmente compatível com o Snowflake.
Grammar Syntax
[ WITH [RECURSIVE] common_table_expression [, common_table_expression , ...] ]
DELETE [ FROM ] { table_name | materialized_view_name }
[ USING table_name, ... ]
[ WHERE condition ]
Sample Source Patterns
Dados de configuração
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');
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.
Input Code:
DELETE employees;
SELECT * FROM employees ORDER BY id;
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
Output Code:
DELETE FROM
employees;
SELECT * FROM employees ORDER BY id;
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.
Input Code:
DELETE FROM employees
WHERE department = 'Marketing';
SELECT * FROM employees
ORDER BY id;
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 |
Output Code:
DELETE FROM
employees
WHERE department = 'Marketing';
SELECT * FROM
employees
ORDER BY id;
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.
Input Code:
DELETE FROM employees
USING departments d
WHERE employees.department = d.department_name
AND d.department_name = 'Sales';
SELECT * FROM employees ORDER BY id;
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 |
Output Code:
DELETE FROM employees
USING departments d
WHERE employees.department = d.department_name
AND d.department_name = 'Sales';
SELECT * FROM employees ORDER BY id;
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
Input Code:
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;
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
4 |
David |
Marketing |
2 |
5 |
Eve |
Marketing |
4 |
6 |
Frank |
Marketing |
4 |
Output Code:
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;
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
4 |
David |
Marketing |
2 |
5 |
Eve |
Marketing |
4 |
6 |
Frank |
Marketing |
4 |
CTE Recursivo
Input Code:
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);
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
1 |
Alice |
Vendas |
2 |
2 |
Bob |
Vendas |
1 |
3 |
Charlie |
Vendas |
1 |
10 |
John |
Vendas |
3 |
Output Code:
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;
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.
Input Code:
CREATE MATERIALIZED VIEW emp_mv AS
SELECT id, name, department FROM employees WHERE department = 'Engineering';
DELETE FROM emp_mv
WHERE id = 2;
Output Code:
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;
Known Issues
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.
Related EWIs
SSC-FDM-0031: Parâmetros necessários da tabela dinâmica definidos por padrão.
SSC-EWI-RS0008: A instrução Delete não pode ser usada em tabelas dinâmicas.
INSERT
Description
Insere novas linhas em uma tabela. (Instrução Insert de referência da linguagem Redshift SQL).
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 }
Amostra de padrões da origem¶
Dados de configuração¶
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');
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.
Essa cláusula não pode especificar colunas individuais; ela sempre insere uma linha completa com seus valores padrão. Além disso, as colunas com a restrição NOT NULL não podem ser incluídas na definição da tabela. Para replicar esse comportamento no Snowflake, o SnowConvert insere uma coluna com um valor DEFAULT na tabela. Essa ação insere uma linha completa, usando o valor padrão para cada coluna.
Código de entrada:¶
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;
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
NULL |
20000 |
Marketing |
Código de saída:¶
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;
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:¶
INSERT INTO employees (name, salary, department)
SELECT name, salary, department FROM new_employees;
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Grace Lee |
32000 |
Operações |
2 |
Hannah Gray |
26000 |
Finance |
Código de saída:¶
INSERT INTO employees (name, salary, department)
SELECT name, salary, department FROM
new_employees;
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 ]
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:¶
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);
Código de saída:¶
--** 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);
DELETE - INSERT¶
Não há diferenças entre as linguagens. O código é mantido em sua forma original.
Código de entrada:¶
MERGE INTO target USING source ON target.id = source.id
WHEN MATCHED THEN DELETE
WHEN NOT MATCHED THEN INSERT VALUES (source.id, source.name);
Código de saída:¶
--** 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);
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:¶
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;
ID |
NAME |
---|---|
30 |
Daisy |
22 |
Clarence |
30 |
Tony |
11 |
Alice |
23 |
David |
Código de saída:¶
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;
ID |
NAME |
---|---|
22 |
Clarence |
30 |
Tony |
30 |
Daisy |
11 |
Alice |
23 |
David |
Problemas conhecidos¶
Não há problemas conhecidos.
EWIs relacionados¶
SSC-EWI-RS0009: Informações semânticas não encontradas para a tabela de origem.
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).
Essa sintaxe é totalmente compatível com o Snowflake.
Grammar Syntax
[ WITH [RECURSIVE] common_table_expression [, common_table_expression , ...] ]
UPDATE table_name [ [ AS ] alias ] SET column = { expression | DEFAULT } [,...]
[ FROM fromlist ]
[ WHERE condition ]
Sample Source Patterns
Setup data
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);
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.
Input Code:
UPDATE employees AS e
SET salary = salary + 5000
WHERE e.salary < 600000;
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 |
Output Code:
UPDATE employees AS e
SET salary = salary + 5000
WHERE e.salary < 600000;
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 |
WITH clause
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.
Non-Recursive CTE
Input Code:
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;
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 |
Output Code:
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;
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 |
Recursive CTE
Input Code:
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;
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 |
Output Code:
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;
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
Input Code:
UPDATE employees
SET salary = DEFAULT, department = 'Sales'
WHERE department = 'HR';
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 |
Output Code:
UPDATE employees
SET salary = DEFAULT, department = 'Sales'
WHERE
department = 'HR';
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:
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);
Input Code:
UPDATE target
SET v = src.v
FROM src
WHERE target.k = src.k;
SELECT * FROM target;
K |
V |
---|---|
0 |
16 |
Output Code:
UPDATE target
SET v = src.v
FROM src
WHERE target.k = src.k;
SELECT * FROM target;
K |
V |
---|---|
0 |
14 |
Known Issues
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.
Related EWIs
Não há problemas conhecidos.
CREATE TABLE AS
Description
Cria uma nova tabela com base em uma consulta. O proprietário dessa tabela é o usuário que emite o comando.
Para obter mais informações, consulte a documentação CREATE TABLE AS
.
Grammar Syntax
CREATE [ [ LOCAL ] { TEMPORARY | TEMP } ]
TABLE table_name
[ ( column_name [, ... ] ) ]
[ BACKUP { YES | NO } ]
[ table_attributes ]
AS query
where table_attributes are:
[ DISTSTYLE { AUTO | EVEN | ALL | KEY } ]
[ DISTKEY( distkey_identifier ) ]
[ [ COMPOUND | INTERLEAVED ] SORTKEY( column_name [, ...] ) ]
Início da tabela: BACKUP
Description
Permite que o Amazon Redshift ajuste automaticamente o tipo de codificação de todas as colunas da tabela para otimizar o desempenho da consulta. No Snowflake, o conceito de BACKUP
, como visto em outros bancos de dados, não é diretamente aplicável. O Snowflake lida automaticamente com o backup e a recuperação de dados por meio de seus recursos integrados, como Time Travel e Fail-safe, eliminando a necessidade de operações manuais de backup. Por esses motivos, a instrução BACKUP
é removida durante o processo de transformação
Clique aqui para navegar até a página de documentação do Amazon Redshift para essa sintaxe.
Grammar Syntax
BACKUP { YES | NO }
Sample Source Patterns
Opção de NO
Um FDM é adicionado, pois o Snowflake, por padrão, sempre cria um backup da tabela criada.
Código de entrada:
CREATE TABLE table1
BACKUP NO
AS SELECT * FROM table_test;
Código de saída:
CREATE TABLE table1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/10/2025", "domain": "test" }}'
----** SSC-FDM-RS0001 - BACKUP NO OPTION NOT SUPPORTED. DATA STORAGE IS AUTOMATICALLY HANDLED BY SNOWFLAKE. **
--BACKUP NO
AS SELECT * FROM
table_test;
Opção de YES
A opção é removida, pois o Snowflake, por padrão, aplica um backup à tabela criada.
Código de entrada:
CREATE TABLE table1
BACKUP YES
AS SELECT * FROM table_test;
Código de saída:
CREATE TABLE table1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/10/2025", "domain": "test" }}'
AS SELECT * FROM
table_test;
Related EWIs
SSC-FDM-RS0001: «Option» não é compatível. O armazenamento de dados é tratado automaticamente pelo Snowflake.
Início da tabela: COLUMNS
Description
O nome de uma coluna na nova tabela. Se nenhum nome de coluna for fornecido, os nomes das colunas serão retirados dos nomes das colunas de saída da consulta.
Clique aqui para navegar até a página de documentos do Amazon Redshift para essa sintaxe.
Grammar Syntax
( column_name [, ... ] )
Sample Source Patterns
Input Code:
CREATE TABLE table1
(
col1, col2, col3
)
AS SELECT col1, col2, col3 FROM table_test;
Código de saída:
CREATE TABLE table1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
(
col1, col2, col3
)
AS SELECT col1, col2, col3 FROM
table_test;
Related EWIs
Não há problemas conhecidos.
Início da tabela: LOCAL
Description
No Amazon Redshift, LOCAL TEMPORARY
ou TEMP
são usados para criar tabelas temporárias que existem apenas durante a sessão. Essas tabelas são específicas da sessão e são automaticamente excluídas quando a sessão termina. Eles são úteis para armazenar resultados intermediários ou dados de trabalho sem afetar o esquema permanente do banco de dados.
Clique aqui para navegar até a página de documentos do Amazon Redshift para essa sintaxe.
Grammar Syntax
LOCAL { TEMPORARY | TEMP }
Sample Source Patterns
Input Code:
CREATE LOCAL TEMP TABLE table1
AS SELECT FROM table_test;
Output Code:
CREATE LOCAL TEMP TABLE table1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
AS SELECT FROM
table_test;
Related EWIs
Não há problemas conhecidos.
Atributos da tabela: DISTKEY
Description
No Amazon Redshift, o DISTKEY
é usado para distribuir dados entre os nós do cluster para otimizar o desempenho da consulta. O Snowflake, no entanto, lida automaticamente com a distribuição e o armazenamento de dados sem precisar de chaves de distribuição explícitas. Devido às diferenças na arquitetura e nas abordagens de gerenciamento de dados, o Snowflake não tem um equivalente direto ao DISTKEY
do Redshift. Por esses motivos, a instrução DISTKEY
é removida durante o processo de transformação
Clique aqui para navegar até a página de documentação do Amazon Redshift para essa sintaxe.
Grammar Syntax
DISTKEY ( column_name )
Sample Source Patterns
Input Code:
CREATE TABLE table1
DISTKEY (col1)
AS SELECT * FROM table_test;
Output Code:
CREATE TABLE table1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/10/2025", "domain": "test" }}'
----** SSC-FDM-RS0001 - DISTKEY OPTION NOT SUPPORTED. DATA STORAGE IS AUTOMATICALLY HANDLED BY SNOWFLAKE. **
--DISTKEY (col1)
AS SELECT * FROM
table_test;
Related EWIs
SSC-FDM-RS0001: «Option» não é compatível. O armazenamento de dados é tratado automaticamente pelo Snowflake.
Atributos da tabela: DISTSTYLE
Description
Palavra-chave que define o estilo de distribuição de dados para toda a tabela.
Clique aqui para navegar até a página de documentação do Amazon Redshift para essa sintaxe.
Grammar Syntax
DISTSTYLE { AUTO | EVEN | KEY | ALL }
Sample Source Patterns
Input Code:
CREATE TABLE table1
DISTSTYLE AUTO
AS SELECT * FROM table_test;
CREATE TABLE table2
DISTSTYLE EVEN
AS SELECT * FROM table_test;
CREATE TABLE table3
DISTSTYLE ALL
AS SELECT * FROM table_test;
CREATE TABLE table4
DISTSTYLE KEY
DISTKEY (col1)
AS SELECT * FROM table_test;
Output Code:
CREATE TABLE table1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
----** SSC-FDM-RS0001 - DISTSTYLE AUTO OPTION NOT SUPPORTED. DATA STORAGE IS AUTOMATICALLY HANDLED BY SNOWFLAKE. **
--DISTSTYLE AUTO
AS SELECT * FROM
table_test;
CREATE TABLE table2
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
----** SSC-FDM-RS0001 - DISTSTYLE EVEN OPTION NOT SUPPORTED. DATA STORAGE IS AUTOMATICALLY HANDLED BY SNOWFLAKE. **
--DISTSTYLE EVEN
AS SELECT * FROM
table_test;
CREATE TABLE table3
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
----** SSC-FDM-RS0001 - DISTSTYLE ALL OPTION NOT SUPPORTED. DATA STORAGE IS AUTOMATICALLY HANDLED BY SNOWFLAKE. **
--DISTSTYLE ALL
AS SELECT * FROM
table_test;
CREATE TABLE table4
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
----** SSC-FDM-RS0001 - DISTSTYLE KEY OPTION NOT SUPPORTED. DATA STORAGE IS AUTOMATICALLY HANDLED BY SNOWFLAKE. **
--DISTSTYLE KEY
----** SSC-FDM-RS0001 - DISTKEY OPTION NOT SUPPORTED. DATA STORAGE IS AUTOMATICALLY HANDLED BY SNOWFLAKE. **
--DISTKEY (col1)
AS SELECT * FROM
table_test;
Related EWIs
SSC-FDM-RS0001: «Option» não é compatível. O armazenamento de dados é tratado automaticamente pelo Snowflake.
Atributos da tabela: SORTKEY
Description
A palavra-chave que especifica que a coluna é a chave de classificação da tabela. No Snowflake, o SORTKEY
do Redshift pode ser migrado para o CLUSTER BY
porque ambos otimizam o armazenamento de dados para o desempenho da consulta. O CLUSTER BY
no Snowflake organiza os dados em colunas específicas, de forma semelhante a como o SORTKEY
ordena os dados no Redshift.
Clique aqui para navegar até a página de documentação do Amazon Redshift para essa sintaxe.
Grammar Syntax
[ COMPOUND | INTERLEAVED ] SORTKEY( column_name [, ...] )
Sample Source Patterns
Input Code:
CREATE TABLE table1 (
col1,
col2,
col3,
col4
)
COMPOUND SORTKEY (col1, col3)
AS SELECT * FROM table_test;
CREATE TABLE table2 (
col1
)
INTERLEAVED SORTKEY (col1)
AS SELECT * FROM table_test;
CREATE TABLE table3 (
col1
)
SORTKEY (col1)
AS SELECT * FROM table_test;
Output Code:
CREATE TABLE table1
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
(
col1,
col2,
col3,
col4
)
--** SSC-FDM-RS0002 - THE PERFORMANCE OF THE CLUSTER BY MAY VARY COMPARED TO THE PERFORMANCE OF SORTKEY **
CLUSTER BY (col1, col3)
AS SELECT * FROM
table_test;
CREATE TABLE table2
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
(
col1
)
--** SSC-FDM-RS0002 - THE PERFORMANCE OF THE CLUSTER BY MAY VARY COMPARED TO THE PERFORMANCE OF SORTKEY **
CLUSTER BY (col1)
AS SELECT * FROM
table_test;
CREATE TABLE table3
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "09/17/2024" }}'
(
col1
)
--** SSC-FDM-RS0002 - THE PERFORMANCE OF THE CLUSTER BY MAY VARY COMPARED TO THE PERFORMANCE OF SORTKEY **
CLUSTER BY (col1)
AS SELECT * FROM
table_test;
Related EWIs
SSC-FDM-RS0002: O desempenho de CLUSTER BY pode variar em comparação com o desempenho de Sortkey.