SnowConvert AI - Redshift - SELECT INTO¶
Beschreibung¶
Gibt Zeilen aus Tabellen, Ansichten und benutzerdefinierten Funktionen zurück und fügt sie in eine neue Tabelle ein. (Redshift SQL-Referenz: SELECT-Anweisung)
Grammatikalische Syntax¶
[ WITH with_subquery [, ...] ]
SELECT
[ TOP number ] [ ALL | DISTINCT ]
* | expression [ AS output_name ] [, ...]
INTO [ TEMPORARY | TEMP ] [ TABLE ] new_table
[ FROM table_reference [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ { UNION | INTERSECT | { EXCEPT | MINUS } } [ ALL ] query ]
[ ORDER BY expression
[ ASC | DESC ]
[ LIMIT { number | ALL } ]
[ OFFSET start ]
Weitere Informationen finden Sie unter den folgenden Links:
FROM-Klausel.¶
Beschreibung¶
Die
FROM
-Klausel in einer Abfrage listet die Tabellenverweise (Tabellen, Ansichten und Unterabfragen) auf, aus denen die Daten ausgewählt werden. Wenn mehrere Tabellenreferenzen aufgeführt sind, müssen die Tabellen unter Verwendung der entsprechenden Syntax entweder in derFROM
-Klausel oder derWHERE
-Klausel verbunden werden. Wenn keine Verknüpfungskriterien angegeben werden, verarbeitet das System die Abfrage als Cross-Join. (Redshift SQL-Referenz: FROM-Klausel)
Warnung
Die FROM-Klausel wird in Snowflake teilweise unterstützt. Entpivotieren von Objekten wird derzeit nicht unterstützt.
Grammatikalische Syntax¶
FROM table_reference [, ...]
<table_reference> ::=
with_subquery_table_name [ table_alias ]
table_name [ * ] [ table_alias ]
( subquery ) [ table_alias ]
table_reference [ NATURAL ] join_type table_reference
[ ON join_condition | USING ( join_column [, ...] ) ]
table_reference PIVOT (
aggregate(expr) [ [ AS ] aggregate_alias ]
FOR column_name IN ( expression [ AS ] in_alias [, ...] )
) [ table_alias ]
table_reference UNPIVOT [ INCLUDE NULLS | EXCLUDE NULLS ] (
value_column_name
FOR name_column_name IN ( column_reference [ [ AS ]
in_alias ] [, ...] )
) [ table_alias ]
UNPIVOT expression AS value_alias [ AT attribute_alias ]
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
);
INSERT INTO employee(id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
CREATE TABLE department (
id INT,
name VARCHAR(50),
manager_id INT
);
INSERT INTO department(id, name, manager_id) VALUES
(1, 'HR', 100),
(2, 'Sales', 101),
(3, 'Engineering', 102),
(4, 'Marketing', 103);
SELECT e.name AS employee_name, d.name AS department_name
INTO employees_in_department
FROM employee e
INNER JOIN department d ON e.manager_id = d.manager_id;
Results¶
EMPLOYEE_NAME |
DEPARTMENT_NAME |
---|---|
John |
HR |
Jorge |
Sales |
Kwaku |
Sales |
Liu |
Sales |
Mateo |
Engineering |
Nikki |
Marketing |
Paulo |
Marketing |
Richard |
Marketing |
Sofía |
Engineering |
Ausgabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/06/2025", "domain": "test" }}';
INSERT INTO employee (id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
CREATE TABLE department (
id INT,
name VARCHAR(50),
manager_id INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/06/2025", "domain": "test" }}';
INSERT INTO department (id, name, manager_id) VALUES
(1, 'HR', 100),
(2, 'Sales', 101),
(3, 'Engineering', 102),
(4, 'Marketing', 103);
CREATE TABLE IF NOT EXISTS employees_in_department AS
SELECT e.name AS employee_name, d.name AS department_name
FROM
employee e
INNER JOIN
department d ON e.manager_id = d.manager_id;
Results¶
EMPLOYEE_NAME | DEPARTMENT_NAME |
---|---|
John | HR |
Jorge | Sales |
Kwaku | Sales |
Liu | Sales |
Mateo | Engineering |
Nikki | Marketing |
Paulo | Marketing |
Richard | Marketing |
Sofía | Engineering |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
GROUP BY-Klausel.¶
Beschreibung¶
Die
GROUP BY
-Klausel identifiziert die Gruppierungsspalten für die Abfrage. Gruppierungsspalten müssen deklariert werden, wenn die Abfrage Aggregate mit Standardfunktionen wieSUM
,AVG
undCOUNT
berechnet. (Redshift SQL-Referenz: GROUP BY-Klausel)
Note
Die GROUP BY-Klausel wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
GROUP BY expression [, ...]
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
);
INSERT INTO employee(id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
SELECT
manager_id,
COUNT(id) AS total_employees
INTO manager_employees
FROM employee
GROUP BY manager_id
ORDER BY manager_id;
Results¶
MANAGER_ID |
TOTAL_EMPLOYEES |
---|---|
100 |
1 |
101 |
3 |
102 |
2 |
103 |
3 |
104 |
3 |
1 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/06/2025", "domain": "test" }}';
INSERT INTO employee (id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
CREATE TABLE IF NOT EXISTS manager_employees AS
SELECT
manager_id,
COUNT(id) AS total_employees
FROM
employee
GROUP BY manager_id
ORDER BY manager_id;
Results¶
MANAGER_ID |
TOTAL_EMPLOYEES |
---|---|
100 |
1 |
101 |
3 |
102 |
2 |
103 |
3 |
104 |
3 |
1 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
HAVING-Klausel.¶
Beschreibung¶
Die
HAVING
-Klausel wendet eine Bedingung auf das gruppierte Resultset an, das eine Abfrage zurückgibt. (Redshift SQL-Referenz: HAVING-Klausel)
Note
Die HAVING-Klausel wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
[ HAVING condition ]
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
);
INSERT INTO employee(id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
SELECT manager_id, COUNT(id) AS total_employees
INTO manager_employees
FROM
employee
GROUP BY manager_id
HAVING COUNT(id) > 2
ORDER BY manager_id;
Results¶
MANAGER_ID |
TOTAL_EMPLOYEES |
---|---|
101 |
3 |
103 |
3 |
104 |
3 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/06/2025", "domain": "test" }}';
INSERT INTO employee (id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
CREATE TABLE IF NOT EXISTS manager_employees AS
SELECT manager_id, COUNT(id) AS total_employees
FROM
employee
GROUP BY manager_id
HAVING COUNT(id) > 2
ORDER BY manager_id;
Results¶
MANAGER_ID |
TOTAL_EMPLOYEES |
---|---|
101 |
3 |
103 |
3 |
104 |
3 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
LIMIT- und OFFSET-Klauseln¶
Beschreibung¶
Die LIMIT- und OFFSET-Klauseln rufen die in der Zahl angegebene Anzahl von Zeilen ab und überspringen sie.
Note
Die LIMIT- und OFFSET-Klauseln werden in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
[ LIMIT { number | ALL } ]
[ OFFSET start ]
Beispielhafte Quellcode-Muster¶
LIMIT-Anzahl¶
Eingabecode:¶
Redshift¶
SELECT id, name, manager_id, salary
INTO limited_employees
FROM employee
LIMIT 5;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
100 |
Carlos |
120000,00 |
|
101 |
John |
100 |
90000,00 |
102 |
Jorge |
101 |
95000,00 |
103 |
Kwaku |
101 |
105000,00 |
104 |
Paulo |
102 |
110000,00 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE IF NOT EXISTS limited_employees AS
SELECT id, name, manager_id, salary
FROM
employee
LIMIT 5;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
100 |
Carlos |
120000,00 |
|
101 |
John |
100 |
90000,00 |
102 |
Jorge |
101 |
95000,00 |
103 |
Kwaku |
101 |
105000,00 |
104 |
Paulo |
102 |
110000,00 |
LIMIT ALL¶
Eingabecode:¶
Redshift¶
SELECT id, name, manager_id, salary
INTO limited_employees
FROM employee
LIMIT ALL;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
100 |
Carlos |
120000,00 |
|
101 |
John |
100 |
90000,00 |
102 |
Jorge |
101 |
95000,00 |
103 |
Kwaku |
101 |
105000,00 |
104 |
Paulo |
102 |
110000,00 |
105 |
Richard |
102 |
85000,00 |
106 |
Mateo |
103 |
95000,00 |
107 |
Liu |
103 |
108000,00 |
108 |
Zhang |
104 |
95000,00 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE IF NOT EXISTS limited_employees AS
SELECT id, name, manager_id, salary
FROM
employee
LIMIT NULL;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
100 |
Carlos |
120000,00 |
|
101 |
John |
100 |
90000,00 |
102 |
Jorge |
101 |
95000,00 |
103 |
Kwaku |
101 |
105000,00 |
104 |
Paulo |
102 |
110000,00 |
105 |
Richard |
102 |
85000,00 |
106 |
Mateo |
103 |
95000,00 |
107 |
Liu |
103 |
108000,00 |
108 |
Zhang |
104 |
95000,00 |
OFFSET ohne LIMIT¶
Snowflake unterstützt nicht OFFSET ohne LIMIT. LIMIT wird nach der Transformation mit NULL hinzugefügt, was dem Standard-LIMIT entspricht.
Eingabecode:¶
Redshift¶
SELECT id, name, manager_id, salary
INTO limited_employees
FROM employee
OFFSET 5;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
105 |
Richard |
102 |
85000,00 |
106 |
Mateo |
103 |
95000,00 |
107 |
Liu |
103 |
108000,00 |
108 |
Zhang |
104 |
95000,00 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE IF NOT EXISTS limited_employees AS
SELECT id, name, manager_id, salary
FROM
employee
LIMIT NULL
OFFSET 5;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
105 |
Richard |
102 |
85000,00 |
106 |
Mateo |
103 |
95000,00 |
107 |
Liu |
103 |
108000,00 |
108 |
Zhang |
104 |
95000,00 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
Lokale Variablen und Parameter¶
Beschreibung¶
Redshift ermöglicht auch SELECT INTO-Variablen, wenn die Anweisung innerhalb von gespeicherten Prozeduren ausgeführt wird.
Note
Dieses Muster wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
SELECT [ select_expressions ] INTO target [ select_expressions ] FROM ...;
Beispielhafte Quellcode-Muster¶
SELECT INTO mit Ausdrücken auf der linken Seite¶
Eingabecode:¶
Redshift¶
CREATE OR REPLACE PROCEDURE test_sp1(out param1 int)
AS $$
DECLARE
var1 int;
BEGIN
select 10, 100 into param1, var1;
END;
$$ LANGUAGE plpgsql;
Results¶
param1 |
---|
10 |
Ausgabecode:¶
Snowflake¶
CREATE OR REPLACE PROCEDURE test_sp1 (param1 OUT int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "07/16/2025", "domain": "no-domain-provided" }}'
AS $$
DECLARE
var1 int;
BEGIN
select 10, 100 into
: param1,
: var1;
END;
$$;
Results¶
TEST_SP1 |
---|
{ „param1“: 10 } |
SELECT INTO mit Ausdrücken auf der rechten Seite¶
Eingabecode:¶
Redshift¶
CREATE OR REPLACE PROCEDURE test_sp1(out param1 int)
AS $$
DECLARE
var1 int;
BEGIN
select into param1, var1 10, 100;
END;
$$ LANGUAGE plpgsql;
Results¶
param1 |
---|
10 |
Ausgabecode:¶
Da Snowflake diese Grammatik für SELECT INTO nicht unterstützt, werden die Ausdrücke auf die linke Seite der INTO verschoben.
Snowflake¶
CREATE OR REPLACE PROCEDURE test_sp1 (param1 OUT int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "07/16/2025", "domain": "no-domain-provided" }}'
AS $$
DECLARE
var1 int;
BEGIN
select
10, 100
into
: param1,
: var1;
END;
$$;
Results¶
TEST_SP1 |
---|
{ „param1“: 10 } |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
ORDER BY-Klausel.¶
Beschreibung¶
Die
ORDER BY
-Klausel sortiert das Resultset einer Abfrage. (Redshift SQL-Referenz: ORDER BY-Klausel)
Note
The ORDER BY-Klausel wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
[ ORDER BY expression [ ASC | DESC ] ]
[ NULLS FIRST | NULLS LAST ]
[ LIMIT { count | ALL } ]
[ OFFSET start ]
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT,
salary DECIMAL(10, 2)
);
INSERT INTO employee (id, name, manager_id, salary) VALUES
(100, 'Carlos', NULL, 120000.00),
(101, 'John', 100, 90000.00),
(102, 'Jorge', 101, 95000.00),
(103, 'Kwaku', 101, 105000.00),
(104, 'Paulo', 102, 110000.00),
(105, 'Richard', 102, 85000.00),
(106, 'Mateo', 103, 95000.00),
(107, 'Liu', 103, 108000.00),
(108, 'Zhang', 104, 95000.00);
SELECT id, name, manager_id, salary
INTO salaries
FROM employee
ORDER BY salary DESC NULLS LAST, name ASC NULLS FIRST
LIMIT 5
OFFSET 2;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
107 |
Liu |
103 |
108000,00 |
103 |
Kwaku |
101 |
105000,00 |
102 |
Jorge |
101 |
95000,00 |
106 |
Mateo |
103 |
95000,00 |
108 |
Zhang |
104 |
95000,00 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT,
salary DECIMAL(10, 2)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/06/2025", "domain": "test" }}';
INSERT INTO employee (id, name, manager_id, salary) VALUES
(100, 'Carlos', NULL, 120000.00),
(101, 'John', 100, 90000.00),
(102, 'Jorge', 101, 95000.00),
(103, 'Kwaku', 101, 105000.00),
(104, 'Paulo', 102, 110000.00),
(105, 'Richard', 102, 85000.00),
(106, 'Mateo', 103, 95000.00),
(107, 'Liu', 103, 108000.00),
(108, 'Zhang', 104, 95000.00);
CREATE TABLE IF NOT EXISTS salaries AS
SELECT id, name, manager_id, salary
FROM
employee
ORDER BY salary DESC NULLS LAST, name ASC NULLS FIRST
LIMIT 5
OFFSET 2;
Results¶
ID |
NAME |
MANAGER_ID |
SALARY |
---|---|---|---|
107 |
Liu |
103 |
108000,00 |
103 |
Kwaku |
101 |
105000,00 |
102 |
Jorge |
101 |
95000,00 |
106 |
Mateo |
103 |
95000,00 |
108 |
Zhang |
104 |
95000,00 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
SELECT-Liste¶
Beschreibung¶
Die SELECT-Liste nennt die Spalten, Funktionen und Ausdrücke, die die Abfrage zurückgeben soll. Die Liste stellt die Ausgabe der Abfrage dar. (Redshift SQL-Referenz: SELECT-Liste)
Note
Die Startoptionen für Abfragen werden in Snowflake vollständig unterstützt. Denken Sie nur daran, dass in Snowflake die Optionen DISTINCT
und ALL
am Anfang der Abfrage stehen müssen.
Bemerkung
Wenn Ihre Anwendung in Redshift Fremdschlüssel oder ungültige Primärschlüssel zulässt, kann dies dazu führen, dass Abfragen falsche Ergebnisse liefern. Eine SELECT DISTINCT-Abfrage könnte zum Beispiel doppelte Zeilen zurückgeben, wenn die Primärschlüsselspalte nicht alle eindeutigen Werte enthält. (Redshift SQL-Referenz: SELECT-Liste)
Grammatikalische Syntax¶
SELECT
[ TOP number ]
[ ALL | DISTINCT ] * | expression [ AS column_alias ] [, ...]
Beispielhafte Quellcode-Muster¶
TOP-Klausel¶
Eingabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
);
INSERT INTO employee(id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
SELECT TOP 5 id, name, manager_id
INTO top_employees
FROM employee;
SELECT * FROM top_employees;
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
100 |
Carlos |
null |
101 |
John |
100 |
102 |
Jorge |
101 |
103 |
Kwaku |
101 |
110 |
Liu |
101 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE employee
(
id INT,
name VARCHAR(20),
manager_id INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/06/2025", "domain": "test" }}';
INSERT INTO employee (id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
CREATE TABLE IF NOT EXISTS top_employees AS
SELECT TOP 5 id, name, manager_id
FROM
employee;
SELECT * FROM
top_employees;
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
100 |
Carlos |
null |
101 |
John |
100 |
102 |
Jorge |
101 |
103 |
Kwaku |
101 |
110 |
Liu |
101 |
ALL¶
Eingabecode:¶
Redshift¶
SELECT ALL manager_id
INTO manager
FROM employee;
Results¶
MANAGER_ID |
---|
null |
100 |
101 |
101 |
101 |
102 |
103 |
103 |
103 |
104 |
104 |
102 |
104 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE IF NOT EXISTS manager AS
SELECT ALL manager_id
FROM
employee;
Results¶
MANAGER_ID |
---|
null |
100 |
101 |
101 |
101 |
102 |
103 |
103 |
103 |
104 |
104 |
102 |
104 |
DISTINCT¶
Eingabecode:¶
Redshift¶
SELECT DISTINCT manager_id
INTO manager
FROM employee;
Results¶
MANAGER_ID |
---|
null |
100 |
101 |
102 |
103 |
104 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE IF NOT EXISTS manager AS
SELECT DISTINCT manager_id
FROM
employee;
Results¶
MANAGER_ID |
---|
null |
100 |
101 |
102 |
103 |
104 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
UNION, INTERSECT und EXCEPT¶
Beschreibung¶
Die
UNION
-,INTERSECT
- undEXCEPT
-Mengenoperatoren werden verwendet, um die Ergebnisse von zwei separaten Abfrageausdrücken zu vergleichen und zusammenzuführen. (Redshift SQL-Referenz: Mengenoperatoren)
Note
Set-Operatoren werden in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
query
{ UNION [ ALL ] | INTERSECT | EXCEPT | MINUS }
query
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
Redshift¶
SELECT id, name, manager_id
INTO some_employees
FROM
employee
WHERE manager_id = 101
UNION
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 102
UNION ALL
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 101
INTERSECT
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 103
EXCEPT
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 104;
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
103 |
Kwaku |
101 |
110 |
Liu |
101 |
102 |
Jorge |
101 |
106 |
Mateo |
102 |
201 |
Sofía |
102 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE IF NOT EXISTS some_employees AS
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 101
UNION
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 102
UNION ALL
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 101
INTERSECT
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 103
EXCEPT
SELECT id, name, manager_id
FROM
employee
WHERE manager_id = 104;
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
102 |
Jorge |
101 |
103 |
Kwaku |
101 |
110 |
Liu |
101 |
106 |
Mateo |
102 |
201 |
Sofía |
102 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
WHERE-Klausel.¶
Beschreibung¶
Die
WHERE
-Klausel enthält Bedingungen, die entweder Tabellen verbinden oder Prädikate auf Spalten in Tabellen anwenden. (Redshift SQL-Referenz: WHERE-Klausel)
Note
Die WHERE-Klausel wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
[ WHERE condition ]
Beispielhafte Quellcode-Muster¶
Eingabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
);
INSERT INTO employee(id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
SELECT id, name, manager_id
INTO employee_names
FROM employee
WHERE name LIKE 'J%';
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
101 |
John |
100 |
102 |
Jorge |
101 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "02/06/2025", "domain": "test" }}';
INSERT INTO employee (id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
CREATE TABLE IF NOT EXISTS employee_names AS
SELECT id, name, manager_id
FROM
employee
WHERE name LIKE 'J%' ESCAPE '\\';
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
101 |
John |
100 |
102 |
Jorge |
101 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.
WITH-Klausel.¶
Beschreibung¶
Eine
WITH
-Klausel ist eine optionale Klausel, die der SELECT INTO in einer Abfrage vorausgeht. DieWITH
-Klausel definiert eine oder mehrere common_table_expressions. Jeder gemeinsame Tabellenausdruck (CTE) definiert eine temporäre Tabelle, die einer View-Definition ähnlich ist. Sie können diese temporären Tabellen in derFROM
-Klausel referenzieren. (Redshift SQL-Referenz: WITH-Klausel)
Note
Die WITH-Klausel wird in Snowflake vollständig unterstützt.
Grammatikalische Syntax¶
[ WITH [RECURSIVE] common_table_expression [, common_table_expression , ...] ]
--Where common_table_expression can be either non-recursive or recursive.
--Following is the non-recursive form:
CTE_table_name [ ( column_name [, ...] ) ] AS ( query )
--Following is the recursive form of common_table_expression:
CTE_table_name (column_name [, ...] ) AS ( recursive_query )
Beispielhafte Quellcode-Muster¶
Nicht-rekursive Form¶
Eingabecode:¶
Redshift¶
CREATE TABLE orders (
order_id INT,
customer_id INT,
order_date DATE,
total_amount DECIMAL(10,2)
);
INSERT INTO orders (order_id, customer_id, order_date, total_amount)
VALUES
(1, 101, '2024-02-01', 250.00),
(2, 102, '2024-02-02', 600.00),
(3, 103, '2024-02-03', 150.00),
(4, 104, '2024-02-04', 750.00),
(5, 105, '2024-02-05', 900.00);
WITH HighValueOrders AS (
SELECT
order_id,
customer_id,
order_date,
total_amount
FROM orders
WHERE total_amount > 500
)
SELECT * INTO high_value_orders FROM HighValueOrders;
SELECT * FROM high_value_orders;
Results¶
ORDER_ID |
CUSTOMER_ID |
ORDER_DATE |
TOTAL_AMOUNT |
---|---|---|---|
2 |
102 |
2024-02-02 |
600,00 |
4 |
104 |
2024-02-04 |
750,00 |
5 |
105 |
2024-02-05 |
900,00 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE orders (
order_id INT,
customer_id INT,
order_date DATE,
total_amount DECIMAL(10,2)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "03/03/2025", "domain": "test" }}';
INSERT INTO orders (order_id, customer_id, order_date, total_amount)
VALUES
(1, 101, '2024-02-01', 250.00),
(2, 102, '2024-02-02', 600.00),
(3, 103, '2024-02-03', 150.00),
(4, 104, '2024-02-04', 750.00),
(5, 105, '2024-02-05', 900.00);
CREATE TABLE IF NOT EXISTS high_value_orders AS
WITH HighValueOrders AS (
SELECT
order_id,
customer_id,
order_date,
total_amount
FROM
orders
WHERE total_amount > 500
)
SELECT *
FROM
HighValueOrders;
SELECT * FROM
high_value_orders;
Results¶
ORDER_ID |
CUSTOMER_ID |
ORDER_DATE |
TOTAL_AMOUNT |
---|---|---|---|
2 |
102 |
2024-02-02 |
600,00 |
4 |
104 |
2024-02-04 |
750,00 |
5 |
105 |
2024-02-05 |
900,00 |
Rekursive Form¶
Eingabecode:¶
Redshift¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
);
INSERT INTO employee(id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
WITH RECURSIVE john_org(id, name, manager_id, level)
AS
(
SELECT id, name, manager_id, 1 AS level
FROM employee
WHERE name = 'John'
UNION ALL
SELECT e.id, e.name, e.manager_id, level + 1 AS next_level
FROM employee e, john_org j
WHERE e.manager_id = j.id and level < 4
)
SELECT DISTINCT id, name, manager_id into new_org FROM john_org ORDER BY manager_id;
SELECT * FROM new_org;
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
101 |
John |
100 |
103 |
Kwaku |
101 |
102 |
Jorge |
101 |
110 |
Liu |
101 |
106 |
Mateo |
102 |
201 |
Sofía |
102 |
105 |
Richard |
103 |
110 |
Nikki |
103 |
104 |
Paulo |
103 |
120 |
Saanvi |
104 |
200 |
Shirley |
104 |
205 |
Zhang |
104 |
Ausgabecode:¶
Snowflake¶
CREATE TABLE employee (
id INT,
name VARCHAR(20),
manager_id INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "07/11/2025", "domain": "no-domain-provided" }}';
INSERT INTO employee (id, name, manager_id) VALUES
(100, 'Carlos', null),
(101, 'John', 100),
(102, 'Jorge', 101),
(103, 'Kwaku', 101),
(110, 'Liu', 101),
(106, 'Mateo', 102),
(110, 'Nikki', 103),
(104, 'Paulo', 103),
(105, 'Richard', 103),
(120, 'Saanvi', 104),
(200, 'Shirley', 104),
(201, 'Sofía', 102),
(205, 'Zhang', 104);
CREATE TABLE IF NOT EXISTS new_org AS
WITH RECURSIVE john_org(id, name, manager_id, level)
AS
(
SELECT id, name, manager_id, 1 AS level
FROM
employee
WHERE name = 'John'
UNION ALL
SELECT e.id, e.name, e.manager_id, level + 1 AS next_level
FROM
employee e,
john_org j
WHERE e.manager_id = j.id and level < 4
)
SELECT DISTINCT id, name, manager_id
FROM
john_org
ORDER BY manager_id;
SELECT * FROM
new_org;
Results¶
ID |
NAME |
MANAGER_ID |
---|---|---|
101 |
John |
100 |
103 |
Kwaku |
101 |
102 |
Jorge |
101 |
110 |
Liu |
101 |
106 |
Mateo |
102 |
201 |
Sofía |
102 |
105 |
Richard |
103 |
110 |
Nikki |
103 |
104 |
Paulo |
103 |
120 |
Saanvi |
104 |
200 |
Shirley |
104 |
205 |
Zhang |
104 |
Bekannte Probleme¶
Es gibt keine bekannten Probleme.
Zugehörige EWIs.¶
Es gibt keine zugehörigen EWIs.