SnowConvert AI - Redshift - SQL Statements¶
Translation reference for all the supported statements by SnowConvert AI for Redshift.
CALL¶
Beschreibung¶
Führt eine gespeicherte Prozedur aus. Der Befehl CALL muss den Namen der Prozedur und die Werte der Eingabeargumente enthalten. Sie müssen eine gespeicherte Prozedur mit der Anweisung CALL aufrufen. (Redshift SQL-Referenz: CALL).
Grammatikalische Syntax¶
CALL sp_name ( [ argument ] [, ...] )
Beispielhafte Quellcode-Muster¶
Basis-Szenario¶
Eingabecode:¶
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);
Ausgabecode:¶
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());
Aufruf im Modus Ausgabeparameter (INOUT, OUT)¶
Eingabecode:¶
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();
Ausgabecode:¶
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();
Bekannte Probleme¶
Output parameters from calls outside procedures won’t work.
CREATE DATABASE¶
Grammatikalische Syntax¶
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>' } }
Weitere Informationen finden Sie in der Redshift [CREATE DATABASE
-Dokumentation](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE. html).
Beispielhafte Quellcode-Muster¶
Grundlegende Beispiele¶
Eingabecode:¶
Redshift¶
CREATE DATABASE database_name;
Ausgabecode:¶
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" }}';
COLLATE-Klausel¶
Eingabecode:¶
Redshift¶
CREATE DATABASE database_collate
COLLATE CASE_INSENSITIVE;
Ausgabecode:¶
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" }}';
CONNECTION LIMIT-Klausel¶
Eingabecode:¶
Redshift¶
CREATE DATABASE database_connection
CONNECTION LIMIT UNLIMITED;
Ausgabecode:¶
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" }}';
Warnung
Die CONNECTION LIMIT-Klausel wird entfernt, da die Verbindung in Snowflake von Warehouse verwaltet wird. Weitere Informationen finden Sie hier.
from ARN-Klausel¶
Eingabecode:¶
Redshift¶
CREATE DATABASE database_fromARN
FROM ARN 'arn' WITH NO DATA CATALOG SCHEMA IAM_ROLE 'arn:aws:iam::<account-id>:role/<role-name';
Ausgabecode:¶
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" }}';
Warnung
Diese Klausel wird entfernt, da sie zur Referenzierung von Amazon-Ressourcen verwendet wird, die in Snowflake nicht gültig sind.
OWNER-Klausel¶
Eingabecode¶
Redshift¶
CREATE DATABASE database_Owner
OWNER db_owner
ENCODING 'encoding';
Ausgabecode¶
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" }}';
Warnung
Bitte beachten Sie, dass in diesem Fall die OWNER-Klausel aus dem Code entfernt wird, da Snowflake-Datenbanken im Besitz von Rollen und nicht von einzelnen Benutzern sind. Weitere Informationen finden Sie in der Snowflake GRANT OWNERSHIP
-Dokumentation.
ISOLATION LEVEL-Klausel¶
Eingabecode¶
Redshift¶
CREATE DATABASE database_Isolation
ISOLATION LEVEL SNAPSHOT;
Ausgabecode¶
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" }}';
Bemerkung
Die Umstellung auf Isolationslevel ist für die Zukunft geplant.
Zugehörige EWIs¶
[SSC-EWI-0073](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0073): Überprüfung der Funktionsäquivalenz ausstehend
CREATE EXTERNAL TABLE¶
Beschreibung ¶
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.
Grammatikalische Syntax ¶
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 }
Klicken Sie [hier](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE. html), um die Spezifikation für diese Syntax aufzurufen.
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
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/';
Ausgabecode:¶
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" }}'
;
Create External Table AS¶
Eingabecode:¶
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;
Ausgabecode:¶
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;
Empfehlungen¶
Für die Verwendung von Create External Table in Snowflake lesen Sie bitte die Snowflake-Dokumentation.
Zugehörige EWIs¶
[SSC-FDM-0004](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0004): Externe Tabelle in reguläre Tabelle übersetzt
CREATE MATERIALIZED VIEW¶
Beschreibung¶
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.
Für weitere Informationen über materialisierte Ansichten klicken Sie hier.
Einzelheiten zu den erforderlichen Parametern für dynamische Tabellen finden Sie hier.
Grammatikalische Syntax¶
Im Folgenden finden Sie die SQL-Syntax zum Erstellen einer Ansicht in Amazon Redshift. Klicken Sie hier bis hier, um zur Redshift-Spezifikation für diese Syntax zu gelangen.
CREATE MATERIALIZED VIEW mv_name
[ BACKUP { YES | NO } ]
[ table_attributes ]
[ AUTO REFRESH { YES | NO } ]
AS query
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
Redshift¶
CREATE MATERIALIZED VIEW mv_baseball AS
SELECT ball AS baseball FROM baseball_table;
Ausgabecode:¶
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;
Bemerkung
Die Dokumentation zu den Tabellenattributen finden Sie in der folgenden Dokumentation:
Warnung
Die BACKUP- und AUTO REFRESH-Klauseln werden gelöscht, da sie in einer dynamischen Tabelle von Snowflake nicht anwendbar sind
Zugehörige EWIs¶
[SSC-FDM-0031](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0031): Erforderliche Parameter der dynamischen Tabelle standardmäßig eingestellt
CREATE SCHEMA¶
Grammatikalische Syntax¶
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 [ ... ] ]
Weitere Informationen finden Sie in der [Redshift CREATE SCHEMA
- Dokumentation](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA. html).
Beispielhafte Quellcode-Muster¶
Grundlegende Beispiele¶
Eingabecode:¶
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;
Ausgabecode:¶
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;
QUOTA-Klausel¶
Eingabecode:¶
Redshift¶
CREATE SCHEMA s1 QUOTA UNLIMITED;
CREATE SCHEMA s2 QUOTA 10 TB;
Ausgabecode:¶
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" }}'
;
Bemerkung
In Snowflake ist es nicht erlaubt, eine Quote pro Schema zu definieren. Die Speicherverwaltung erfolgt auf Konto- und Warehouse-Level und wird von Snowflake automatisch durchgeführt. Aus diesem Grund wird sie aus dem Code entfernt.
Zugehörige EWIs¶
Es gibt keine bekannten Probleme.
CREATE FUNCTION¶
Beschreibung¶
This command defines a user-defined function (UDF) within the database. These functions encapsulate reusable logic that can be invoked within SQL queries.
Grammatikalische Syntax¶
Im Folgenden finden Sie die SQL-Syntax zum Erstellen einer Ansicht in Amazon Redshift. Klicken Sie [hier](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW. html) bis hier, um zur Redshift-Spezifikation für diese Syntax zu gelangen.
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 }
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.
Eingabecode:¶
Redshift¶
CREATE OR REPLACE FUNCTION get_sale(INTEGER)
RETURNS FLOAT
STABLE
AS $$
SELECT price FROM sales where id = $1
$$ LANGUAGE SQL;
Ausgabecode:¶
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
$$
;
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.
Eingabecode:¶
Redshift¶
create function f_py_greater (a float, b float)
returns float
stable
as $$
if a > b:
return a
return b
$$ language plpythonu;
Ausgabecode:¶
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
$$
;
Zugehörige EWIs¶
Es gibt keine bekannten Probleme.
CREATE VIEW¶
Beschreibung¶
Dieser Befehl erstellt eine Ansicht in einer Datenbank, die jedes Mal ausgeführt wird, wenn die Ansicht in einer Abfrage referenziert wird. Mit der Klausel WITH NO SCHEMA BINDING können Sie Ansichten auf eine externe Tabelle oder auf Objekte erstellen, die noch nicht existieren. Diese Klausel verlangt jedoch, dass Sie den qualifizierten Namen des Objekts oder der Tabelle angeben, auf die Sie verweisen.
Grammatikalische Syntax¶
Im Folgenden finden Sie die SQL-Syntax zum Erstellen einer Ansicht in Amazon Redshift. Klicken Sie [hier](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW. html) bis hier, um zur Redshift-Spezifikation für diese Syntax zu gelangen.
CREATE [ OR REPLACE ] VIEW name [ ( column_name [, ...] ) ] AS query
[ WITH NO SCHEMA BINDING ]
Beispielhafte Quellcode-Muster¶
Unter Berücksichtigung der obligatorischen und optionalen Klauseln in Redshifts Befehl ist die Ausgabe nach der Migration zu Snowflake sehr ähnlich.
Eingabecode:¶
Redshift¶
CREATE VIEW myuser
AS
SELECT lastname FROM users;
CREATE VIEW myuser2
AS
SELECT lastname FROM users2
WITH NO SCHEMA BINDING;
Ausgabecode:¶
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;
Es gibt jedoch einige Ausnahmen von einer nicht unterstützten Klausel von Redshift, daher wurde ein EWI implementiert, um diesen Fall abzudecken.
Zugehörige EWIs¶
[SSC-EWI-RS0003](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/redshiftEWI. md#ssc-ewi-rs0003): Die Anweisung ohne Schemabindung wird in Snowflake nicht unterstützt.
DELETE¶
Beschreibung¶
Löscht Zeilen aus Tabellen. (Redshift SQL-Referenz: DELETE-Anweisung).
Note
Diese Syntax wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
[ WITH [RECURSIVE] common_table_expression [, common_table_expression , ...] ]
DELETE [ FROM ] { table_name | materialized_view_name }
[ USING table_name, ... ]
[ WHERE condition ]
Beispielhafte Quellcode-Muster¶
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');
FROM-Klausel¶
Aktualisieren Sie eine Tabelle, indem Sie Informationen aus anderen Tabellen referenzieren. In Redshift ist das Schlüsselwort FROM optional, aber in Snowflake ist es obligatorisch. Daher wird sie in Fällen, in denen sie fehlt, hinzugefügt.
Eingabecode:¶
Redshift¶
DELETE employees;
SELECT * FROM employees ORDER BY id;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
Ausgabecode:¶
Snowflake¶
DELETE FROM
employees;
SELECT * FROM employees ORDER BY id;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
WHERE-Klausel¶
Schränkt Aktualisierungen auf Zeilen ein, die eine Bedingung erfüllen. Wenn die Bedingung den Wert „true“ liefert, werden die angegebenen SET-Spalten aktualisiert. Die Bedingung kann ein einfaches Prädikat für eine Spalte sein oder eine Bedingung, die auf dem Ergebnis einer Unterabfrage basiert. Diese Klausel ist in Snowflake vollständig gleichwertig.
Eingabecode:¶
Redshift¶
DELETE FROM employees
WHERE department = 'Marketing';
SELECT * FROM employees
ORDER BY id;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
1 |
Alice |
Sales |
2 |
2 |
Bob |
Sales |
1 |
3 |
Charlie |
Sales |
1 |
7 |
Grace |
Engineering |
6 |
8 |
Helen |
Engineering |
7 |
9 |
Ivy |
Engineering |
7 |
10 |
John |
Sales |
3 |
11 |
Joe |
Engineering |
5 |
Ausgabecode:¶
Snowflake¶
DELETE FROM
employees
WHERE department = 'Marketing';
SELECT * FROM
employees
ORDER BY id;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
1 |
Alice |
Sales |
2 |
2 |
Bob |
Sales |
1 |
3 |
Charlie |
Sales |
1 |
7 |
Grace |
Engineering |
6 |
8 |
Helen |
Engineering |
7 |
9 |
Ivy |
Engineering |
7 |
10 |
John |
Sales |
3 |
11 |
Joe |
Engineering |
5 |
USING-Klausel¶
Diese Klausel führt eine Liste von Tabellen ein, wenn in der Bedingung der WHERE-Klausel auf zusätzliche Tabellen verwiesen wird. Diese Klausel ist in Snowflake vollständig gleichwertig.
Eingabecode:¶
Redshift¶
DELETE FROM employees
USING departments d
WHERE employees.department = d.department_name
AND d.department_name = 'Sales';
SELECT * FROM employees ORDER BY id;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
4 |
David |
Marketing |
2 |
5 |
Eva |
Marketing |
4 |
6 |
Frank |
Marketing |
4 |
7 |
Grace |
Engineering |
6 |
8 |
Helen |
Engineering |
7 |
9 |
Ivy |
Engineering |
7 |
11 |
Joe |
Engineering |
5 |
Ausgabecode:¶
Snowflake¶
DELETE FROM employees
USING departments d
WHERE employees.department = d.department_name
AND d.department_name = 'Sales';
SELECT * FROM employees ORDER BY id;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
4 |
David |
Marketing |
2 |
5 |
Eva |
Marketing |
4 |
6 |
Frank |
Marketing |
4 |
7 |
Grace |
Engineering |
6 |
8 |
Helen |
Engineering |
7 |
9 |
Ivy |
Engineering |
7 |
11 |
Joe |
Engineering |
5 |
WITH-Klausel.¶
Diese Klausel gibt einen oder mehrere allgemeine Tabellenausdrücke (CTE) an. Die Namen der Ausgabespalten sind optional für nicht-rekursive CTEs, aber obligatorisch für rekursive.
Da diese Klausel nicht in einer DELETE-Anweisung verwendet werden kann, wird sie in temporäre Tabellen mit ihren entsprechenden Abfragen umgewandelt. Nachdem die Anweisung DELETE ausgeführt wurde, werden diese temporären Tabellen gelöscht, um aufzuräumen, Ressourcen freizugeben und Namenskollisionen bei der Erstellung von Tabellen innerhalb derselben Sitzung zu vermeiden. Wenn außerdem eine reguläre Tabelle mit demselben Namen existiert, hat diese wieder Vorrang, da die temporäre Tabelle Vorrang vor jeder anderen Tabelle mit demselben Namen in derselben Sitzung hat.
Nicht-rekursive CTE¶
Eingabecode:¶
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;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
4 |
David |
Marketing |
2 |
5 |
Eva |
Marketing |
4 |
6 |
Frank |
Marketing |
4 |
Ausgabecode:¶
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;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
4 |
David |
Marketing |
2 |
5 |
Eva |
Marketing |
4 |
6 |
Frank |
Marketing |
4 |
Rekursiv CTE¶
Eingabecode:¶
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);
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
1 |
Alice |
Sales |
2 |
2 |
Bob |
Sales |
1 |
3 |
Charlie |
Sales |
1 |
10 |
John |
Sales |
3 |
Ausgabecode:¶
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;
Result¶
ID |
NAME |
DEPARTMENT |
MANAGER_ID |
---|---|---|---|
1 |
Alice |
Sales |
2 |
2 |
Bob |
Sales |
1 |
3 |
Charlie |
Sales |
1 |
10 |
John |
Sales |
3 |
Materialisierte Ansicht löschen¶
In Redshift können Sie die Anweisung DELETE auf materialisierte Ansichten anwenden, die für Streaming-Aufnahme verwendet werden. In Snowflake werden diese Ansichten in dynamische Tabellen umgewandelt, und die DELETE-Anweisung kann nicht für dynamische Tabellen verwendet werden. Aus diesem Grund wird eine EWI hinzugefügt.
Eingabecode:¶
Redshift¶
CREATE MATERIALIZED VIEW emp_mv AS
SELECT id, name, department FROM employees WHERE department = 'Engineering';
DELETE FROM emp_mv
WHERE id = 2;
Ausgabecode:¶
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;
Bekannte Probleme ¶
Um die Funktionalität der
WITH
-Klausel zu replizieren, müssen temporäre Tabellen erstellt werden, die jeden allgemeinen Tabellenausdruck (Common Table Expression, CTE) widerspiegeln. Dieser Ansatz schlägt jedoch fehl, wenn in der aktuellen Sitzung bereits eine temporäre Tabelle mit demselben Namen existiert, was einen Fehler verursacht.
Zugehörige EWIs¶
[SSC-FDM-0031](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0031): Standardmäßig festgelegte erforderliche Parameter für dynamische Tabellen.
[SSC-EWI-RS0008](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/redshiftEWI. md#ssc-ewi-rs0008): Die DELETE-Anweisung kann nicht für dynamische Tabellen verwendet werden.
EXECUTE¶
Beschreibung¶
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)
Grammatikalische Syntax¶
EXECUTE command-string [ INTO target ];
Beispielhafte Quellcode-Muster¶
Concated Example
Eingabecode
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;
Ausgabecode
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;
$$;
Function Transformation¶
Eingabecode¶
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;
Ausgabecode¶
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;
$$;
Error In Query Parsing¶
Eingabecode¶
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;
Ausgabecode¶
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;
$$;
INTO Clause¶
Eingabecode¶
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;
Ausgabecode¶
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;
$$;
Bekannte Probleme¶
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:
Zugehörige EWIs¶
SSC-EWI-0027: Variable with invalid query.
SSC-EWI-0030: The statement below has usages of dynamic SQL.
INSERT¶
Beschreibung¶
Fügt neue Zeilen in eine Tabelle ein. (Redshift SQL-Referenz: INSERT-Anweisung).
Warnung
Diese Syntax wird in Snowflake teilweise unterstützt.
Grammatikalische Syntax¶
INSERT INTO table_name [ ( column [, ...] ) ]
{DEFAULT VALUES |
VALUES ( { expression | DEFAULT } [, ...] )
[, ( { expression | DEFAULT } [, ...] )
[, ...] ] |
query }
Beispielhafte Quellcode-Muster¶
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');
Standardwerte¶
Es wird eine komplette Zeile mit ihren Standardwerten eingefügt. Wenn es Spalten gibt, die keine Standardwerte haben, werden in diese Spalten NULL-Werte eingefügt.
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.
Eingabecode:¶
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;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
NULL |
20000 |
Marketing |
Ausgabecode:¶
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;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
NULL |
20000 |
Marketing |
Abfrage¶
Fügen Sie mit Hilfe einer Abfrage eine oder mehrere Zeilen in die Tabelle ein. Alle Zeilen, die durch die Abfrage erzeugt werden, werden in die Tabelle eingefügt. Die Abfrage muss eine Spaltenliste zurückgeben, die mit den Spalten der Tabelle kompatibel ist, obwohl die Spaltennamen nicht übereinstimmen müssen. Diese Funktionalität ist in Snowflake vollständig gleichwertig.
Eingabecode:¶
Redshift¶
INSERT INTO employees (name, salary, department)
SELECT name, salary, department FROM new_employees;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Grace Lee |
32000 |
Operationen |
2 |
Hannah Gray |
26000 |
Finanzen |
Ausgabecode:¶
Snowflake¶
INSERT INTO employees (name, salary, department)
SELECT name, salary, department FROM
new_employees;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Grace Lee |
32000 |
Operationen |
2 |
Hannah Gray |
26000 |
Finanzen |
Bekannte Probleme ¶
Bestimmte Ausdrücke können nicht in der VALUES-Klausel in Snowflake verwendet werden. In Redshift kann zum Beispiel die Funktion [JSON_PARSE](https://docs.aws.amazon.com/redshift/latest/dg/JSON_PARSE. html) innerhalb der VALUES-Klausel verwendet werden, um einen JSON-Wert in einen SUPER-Datentyp einzufügen. In Snowflake kann die Funktion PARSE_JSON jedoch nicht in der VALUES-Klausel verwendet werden, um einen JSON-Wert in einen VARIANT-Datentyp einzufügen. Stattdessen kann eine Abfrage anstelle der VALUES-Klausel verwendet werden. Weitere Einzelheiten entnehmen Sie bitte der Snowflake-Dokumentation. Weitere Informationen finden Sie auch im folgenden Artikel.
Zugehörige EWIs¶
Es gibt keine bekannten Probleme.
MERGE¶
Grammatikalische Syntax¶
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 ]
Weitere Informationen finden Sie in der Redshift MERGE-Dokumentation.
Beispielhafte Quellcode-Muster¶
UPDATE - INSERT¶
Es gibt keine Unterschiede zwischen den beiden Sprachen. Der Code wird in seiner ursprünglichen Form beibehalten.
Eingabecode:¶
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);
Ausgabecode:¶
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);
DELETE - INSERT¶
Es gibt keine Unterschiede zwischen den beiden Sprachen. Der Code wird in seiner ursprünglichen Form beibehalten.
Eingabecode:¶
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);
Ausgabecode:¶
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);
REMOVE DUPLICATES¶
Die Klausel REMOVE DUPLICATES wird in Snowflake nicht unterstützt. Es gibt jedoch einen Umgehungsmöglichkeit, mit der die ursprüngliche Verhaltensweise emuliert werden kann.
Der Ausgabecode wird drei neue Anweisungen enthalten:
Eine TEMPORARY TABLE mit den doppelten Werten aus der Quell- und Zieltabelle, die die Bedingung erfüllen
Eine INSERT-Anweisung, die die ausstehenden Werte nach der Zusammenführung zur Zieltabelle hinzufügt
Eine DROP-Anweisung, die die erzeugte temporäre Tabelle löscht.
Diese sind notwendig, da die Verhaltensweise von DROP DUPLICATES die doppelten Werte aus der Zieltabelle entfernt und dann die Werte, die der Bedingung entsprechen, aus der Quelltabelle einfügt.
Eingabecode:¶
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;
Results¶
ID |
NAME |
---|---|
30 |
Daisy |
22 |
Clarence |
30 |
Tony |
11 |
Alice |
23 |
David |
Ausgabecode:¶
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;
Results¶
ID |
NAME |
---|---|
22 |
Clarence |
30 |
Tony |
30 |
Daisy |
11 |
Alice |
23 |
David |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs¶
[SSC-EWI-RS0009](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/redshiftEWI. md#ssc-ewi-rs0009): Semantische Informationen für die Quelltabelle nicht gefunden.
[SSC-FDM-RS0005](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/redshiftFDM. md#ssc-fdm-rs0005): Duplikate in der Quelltabelle nicht erlaubt.
UPDATE¶
Beschreibung¶
Aktualisiert Werte in einer oder mehreren Tabellenspalten, wenn eine Bedingung erfüllt ist. (Redshift SQL-Referenz: UPDATE-Anweisung).
Note
Diese Syntax wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
[ WITH [RECURSIVE] common_table_expression [, common_table_expression , ...] ]
UPDATE table_name [ [ AS ] alias ] SET column = { expression | DEFAULT } [,...]
[ FROM fromlist ]
[ WHERE condition ]
Beispielhafte Quellcode-Muster¶
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);
Alias¶
Obwohl die Grammatik von Snowflake nicht vorschreibt, dass ein Tabellenalias verwendet werden kann, ist dies in Snowflake gültiger Code.
Eingabecode:¶
Redshift¶
UPDATE employees AS e
SET salary = salary + 5000
WHERE e.salary < 600000;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
505000 |
HR |
2 |
Bob |
600000 |
Engineering |
3 |
Charlie |
700000 |
Engineering |
4 |
David |
405000 |
Marketing |
5 |
Eva |
455000 |
HR |
6 |
Frank |
750000 |
Engineering |
7 |
Grace |
650000 |
Engineering |
8 |
Helen |
395000 |
Marketing |
9 |
Ivy |
485000 |
HR |
10 |
Jack |
425000 |
Engineering |
11 |
Ken |
700000 |
Marketing |
12 |
Liam |
600000 |
Engineering |
13 |
Mona |
475000 |
HR |
Ausgabecode:¶
Snowflake¶
UPDATE employees AS e
SET salary = salary + 5000
WHERE e.salary < 600000;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
505000 |
HR |
2 |
Bob |
600000 |
Engineering |
3 |
Charlie |
700000 |
Engineering |
4 |
David |
405000 |
Marketing |
5 |
Eva |
455000 |
HR |
6 |
Frank |
750000 |
Engineering |
7 |
Grace |
650000 |
Engineering |
8 |
Helen |
395000 |
Marketing |
9 |
Ivy |
485000 |
HR |
10 |
Jack |
425000 |
Engineering |
11 |
Ken |
700000 |
Marketing |
12 |
Liam |
600000 |
Engineering |
13 |
Mona |
475000 |
HR |
WITH-Klausel.¶
Diese Klausel gibt einen oder mehrere allgemeine Tabellenausdrücke (CTE) an. Die Namen der Ausgabespalten sind optional für nicht-rekursive CTEs, aber obligatorisch für rekursive.
Da diese Klausel nicht in einer UPDATE-Anweisung verwendet werden kann, wird sie in temporäre Tabellen mit ihren entsprechenden Abfragen umgewandelt. Nachdem die Anweisung UPDATE ausgeführt wurde, werden diese temporären Tabellen gelöscht, um aufzuräumen, Ressourcen freizugeben und Namenskollisionen bei der Erstellung von Tabellen innerhalb derselben Sitzung zu vermeiden. Wenn außerdem eine reguläre Tabelle mit demselben Namen existiert, hat diese wieder Vorrang, da die temporäre Tabelle Vorrang vor jeder anderen Tabelle mit demselben Namen in derselben Sitzung hat.
Nicht-rekursive CTE¶
Eingabecode:¶
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;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
500000 |
HR |
2 |
Bob |
600000 |
Engineering |
3 |
Charlie |
700000 |
Engineering |
4 |
David |
546923 |
Marketing |
5 |
Eva |
546923 |
HR |
6 |
Frank |
750000 |
Engineering |
7 |
Grace |
650000 |
Engineering |
8 |
Helen |
546923 |
Marketing |
9 |
Ivy |
546923 |
HR |
10 |
Jack |
546923 |
Engineering |
11 |
Ken |
700000 |
Marketing |
12 |
Liam |
600000 |
Engineering |
13 |
Mona |
546923 |
HR |
Ausgabecode:¶
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;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
500000 |
HR |
2 |
Bob |
600000 |
Engineering |
3 |
Charlie |
700000 |
Engineering |
4 |
David |
546923 |
Marketing |
5 |
Eva |
546923 |
HR |
6 |
Frank |
750000 |
Engineering |
7 |
Grace |
650000 |
Engineering |
8 |
Helen |
546923 |
Marketing |
9 |
Ivy |
546923 |
HR |
10 |
Jack |
546923 |
Engineering |
11 |
Ken |
700000 |
Marketing |
12 |
Liam |
600000 |
Engineering |
13 |
Mona |
546923 |
HR |
Rekursiv CTE¶
Eingabecode:¶
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;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
526666 |
HR |
2 |
Bob |
670000 |
Engineering |
3 |
Charlie |
773333 |
Engineering |
4 |
David |
433333 |
Marketing |
5 |
Eva |
475000 |
HR |
6 |
Frank |
825000 |
Engineering |
7 |
Grace |
721666 |
Engineering |
8 |
Helen |
423000 |
Marketing |
9 |
Ivy |
506000 |
HR |
10 |
Jack |
484000 |
Engineering |
11 |
Ken |
743333 |
Marketing |
12 |
Liam |
670000 |
Engineering |
13 |
Mona |
495668 |
HR |
Ausgabecode:¶
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;
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
526667 |
HR |
2 |
Bob |
670000 |
Engineering |
3 |
Charlie |
773333 |
Engineering |
4 |
David |
433333 |
Marketing |
5 |
Eva |
475000 |
HR |
6 |
Frank |
825000 |
Engineering |
7 |
Grace |
721667 |
Engineering |
8 |
Helen |
423000 |
Marketing |
9 |
Ivy |
506000 |
HR |
10 |
Jack |
484000 |
Engineering |
11 |
Ken |
743333 |
Marketing |
12 |
Liam |
670000 |
Engineering |
13 |
Mona |
495667 |
HR |
SETDEFAULT-Werte¶
Eingabecode:¶
Redshift¶
UPDATE employees
SET salary = DEFAULT, department = 'Sales'
WHERE department = 'HR';
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
20000 |
Sales |
2 |
Bob |
600000 |
Engineering |
3 |
Charlie |
700000 |
Engineering |
4 |
David |
400000 |
Marketing |
5 |
Eva |
20000 |
Sales |
6 |
Frank |
750000 |
Engineering |
7 |
Grace |
650000 |
Engineering |
8 |
Helen |
390000 |
Marketing |
9 |
Ivy |
20000 |
Sales |
10 |
Jack |
420000 |
Engineering |
11 |
Ken |
700000 |
Marketing |
12 |
Liam |
600000 |
Engineering |
13 |
Mona |
20000 |
Sales |
Ausgabecode:¶
Snowflake¶
UPDATE employees
SET salary = DEFAULT, department = 'Sales'
WHERE
department = 'HR';
Result¶
ID |
NAME |
SALARY |
DEPARTMENT |
---|---|---|---|
1 |
Alice |
20000 |
Sales |
2 |
Bob |
600000 |
Engineering |
3 |
Charlie |
700000 |
Engineering |
4 |
David |
400000 |
Marketing |
5 |
Eva |
20000 |
Sales |
6 |
Frank |
750000 |
Engineering |
7 |
Grace |
650000 |
Engineering |
8 |
Helen |
390000 |
Marketing |
9 |
Ivy |
20000 |
Sales |
10 |
Jack |
420000 |
Engineering |
11 |
Ken |
700000 |
Marketing |
12 |
Liam |
600000 |
Engineering |
13 |
Mona |
20000 |
Sales |
SET-Klausel.¶
Sie ist für die Änderung der Werte in den Spalten verantwortlich. Ähnlich wie bei Snowflake werden Aktualisierungsabfragen mit mehreren Übereinstimmungen pro Zeile einen Fehler auslösen, wenn der Konfigurationsparameter ERROR_ON_NONDETERMINISTIC_UPDATE auf „true“ gesetzt ist. Dieses Flag funktioniert in Snowflake auf die gleiche Weise und verwendet sogar den gleichen Namen: ERROR_ON_NONDETERMINISTIC_UPDATE.
Wenn dieses Flag jedoch deaktiviert ist, wird kein Fehler zurückgegeben, und eine der übereinstimmenden Zeilen wird zur Aktualisierung der Zielzeile verwendet. Die ausgewählte verbundene Zeile ist in beiden Sprachen nicht deterministisch und willkürlich. Die Verhaltensweise ist möglicherweise bei verschiedenen Ausführungen nicht konsistent, was zu Dateninkonsistenzen führen kann.
Datenkonfiguration:¶
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);
Eingabecode:¶
Redshift¶
UPDATE target
SET v = src.v
FROM src
WHERE target.k = src.k;
SELECT * FROM target;
Result¶
K |
V |
---|---|
0 |
16 |
Ausgabecode:¶
Snowflake¶
UPDATE target
SET v = src.v
FROM src
WHERE target.k = src.k;
SELECT * FROM target;
Result¶
K |
V |
---|---|
0 |
14 |
Bekannte Probleme ¶
Aktualisierungsabfragen mit mehreren Übereinstimmungen pro Zeile können zu Dateninkonsistenzen führen. Obwohl beide Plattformen über das Kennzeichen ERROR_ON_NONDETERMINISTIC_UPDATE verfügen, sind diese Werte immer nicht deterministisch. Snowflake bietet Empfehlungen für den Umgang mit diesen Szenarien. Klicken Sie hier für weitere Details.
Um die Funktionalität der
WITH
-Klausel zu replizieren, müssen temporäre Tabellen erstellt werden, die jeden allgemeinen Tabellenausdruck (Common Table Expression, CTE) widerspiegeln. Dieser Ansatz schlägt jedoch fehl, wenn in der aktuellen Sitzung bereits eine temporäre Tabelle mit demselben Namen existiert, was einen Fehler verursacht.
Zugehörige EWIs¶
Es gibt keine bekannten Probleme.