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 der FROM-Klausel oder der WHERE-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;

Ergebnisse¶


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;

Ergebnisse¶

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 wie SUM, AVG und COUNT berechnet. (Redshift SQL-Referenz: GROUP BY-Klausel)

Hinweis

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;

Ergebnisse¶


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;

Ergebnisse¶


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)

Hinweis

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;

Ergebnisse¶


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;

Ergebnisse¶


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.

Hinweis

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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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 also allows SELECT INTO variables when the statement is executed inside stored procedures.

Hinweis

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;

Ergebnisse¶


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;
$$;

Ergebnisse¶


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;

Ergebnisse¶


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;
$$;

Ergebnisse¶


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)

Hinweis

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;

Ergebnisse¶


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;

Ergebnisse¶


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)

Hinweis

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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


MANAGER_ID
null
100
101
102
103
104

Ausgabecode:¶

Snowflake¶

 CREATE TABLE IF NOT EXISTS manager AS
SELECT DISTINCT manager_id
FROM
employee;

Ergebnisse¶


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- und EXCEPT-Mengenoperatoren werden verwendet, um die Ergebnisse von zwei separaten Abfrageausdrücken zu vergleichen und zusammenzuführen. (Redshift SQL-Referenz: Mengenoperatoren)

Hinweis

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;

Ergebnisse¶


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;

Ergebnisse¶


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)

Hinweis

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%';

Ergebnisse¶


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 '\\';

Ergebnisse¶


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. Die WITH-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 der FROM-Klausel referenzieren. (Redshift SQL-Referenz: WITH-Klausel)

Hinweis

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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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;

Ergebnisse¶


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.