Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Beispiele für PIVOT und UNPIVOT
PIVOT und UNPIVOT sind Parameter in der FROM-Klausel, die die Abfrageausgabe von Zeilen in Spalten bzw. von Spalten in Zeilen drehen. Sie stellen tabellarische Abfrageergebnisse in einem leicht lesbaren Format dar. In den folgenden Beispielen wird anhand von Testdaten und Abfragen ihre Verwendung dargestellt.
Weitere Informationen zu diesen und anderen Parametern finden Sie unter [FROM-Klausel](https://docs.aws.amazon.com/redshift/latest/dg/r_FROM_clause30.html).
## Beispiele für PIVOT
Richten Sie die Beispieltabelle und -daten ein und verwenden Sie sie, um die folgenden Beispielabfragen auszuführen.
```
CREATE TABLE part (
partname varchar,
manufacturer varchar,
quality int,
price decimal(12, 2)
);
INSERT INTO part VALUES ('prop', 'local parts co', 2, 10.00);
INSERT INTO part VALUES ('prop', 'big parts co', NULL, 9.00);
INSERT INTO part VALUES ('prop', 'small parts co', 1, 12.00);
INSERT INTO part VALUES ('rudder', 'local parts co', 1, 2.50);
INSERT INTO part VALUES ('rudder', 'big parts co', 2, 3.75);
INSERT INTO part VALUES ('rudder', 'small parts co', NULL, 1.90);
INSERT INTO part VALUES ('wing', 'local parts co', NULL, 7.50);
INSERT INTO part VALUES ('wing', 'big parts co', 1, 15.20);
INSERT INTO part VALUES ('wing', 'small parts co', NULL, 11.80);
```
PIVOT auf `partname` mit einer `AVG`-Aggregation auf `price`.
```
SELECT *
FROM (SELECT partname, price FROM part) PIVOT (
AVG(price) FOR partname IN ('prop', 'rudder', 'wing')
);
```
Die Abfrage führt zur folgenden Ausgabe.
```
prop | rudder | wing
---------+----------+---------
10.33 | 2.71 | 11.50
```
Im vorherigen Beispiel werden die Ergebnisse in Spalten umgewandelt. Das folgende Beispiel zeigt eine `GROUP BY`-Abfrage, die die Durchschnittspreise in Zeilen und nicht in Spalten zurückgibt.
```
SELECT partname, avg(price)
FROM (SELECT partname, price FROM part)
WHERE partname IN ('prop', 'rudder', 'wing')
GROUP BY partname;
```
Die Abfrage führt zur folgenden Ausgabe.
```
partname | avg
----------+-------
prop | 10.33
rudder | 2.71
wing | 11.50
```
Ein `PIVOT`-Beispiel mit `manufacturer` als impliziter Spalte.
```
SELECT *
FROM (SELECT quality, manufacturer FROM part) PIVOT (
count(*) FOR quality IN (1, 2, NULL)
);
```
Die Abfrage führt zur folgenden Ausgabe.
```
manufacturer | 1 | 2 | null
-------------------+----+----+------
local parts co | 1 | 1 | 1
big parts co | 1 | 1 | 1
small parts co | 1 | 0 | 2
```
Eingabetabellenspalten, die nicht in der `PIVOT`-Definition referenziert sind, werden implizit zur Ergebnistabelle hinzugefügt. Dies ist zum Beispiel bei der `manufacturer`-Spalte im vorigen Beispiel der Fall. Das Beispiel zeigt auch, dass `NULL` ein gültiger Wert für den `IN`-Operator ist.
`PIVOT` im obigen Beispiel gibt ähnliche Informationen zurück wie die folgende Abfrage, die `GROUP BY` umfasst. Der Unterschied besteht darin, dass `PIVOT` den Wert `0` für Spalte `2` und den Hersteller `small parts co` zurückgibt. Die `GROUP BY`-Abfrage enthält keine entsprechende Zeile. In dem meisten Fällen fügt `PIVOT` `NULL` ein, wenn eine Zeile keine Eingabedaten für eine bestimmte Spalte aufweist. Das Zählaggregat gibt jedoch nicht `NULL` zurück und `0` ist der Standardwert.
```
SELECT manufacturer, quality, count(*)
FROM (SELECT quality, manufacturer FROM part)
WHERE quality IN (1, 2) OR quality IS NULL
GROUP BY manufacturer, quality
ORDER BY manufacturer;
```
Die Abfrage führt zur folgenden Ausgabe.
```
manufacturer | quality | count
---------------------+---------+-------
big parts co | | 1
big parts co | 2 | 1
big parts co | 1 | 1
local parts co | 2 | 1
local parts co | 1 | 1
local parts co | | 1
small parts co | 1 | 1
small parts co | | 2
```
Der PIVOT-Operator akzeptiert optionale Aliase auf dem Aggregatausdruck und jedem Wert für den `IN`-Operator. Verwenden Sie Aliase, um die Spaltennamen anzupassen. Wenn kein Aggregatalias vorliegt, werden nur `IN`-Listenaliase verwendet. Andernfalls wird das Aggregatalias an den Spaltennamen angefügt (mit einem Unterstrich, um die Namen auseinanderzuhalten).
```
SELECT *
FROM (SELECT quality, manufacturer FROM part) PIVOT (
count(*) AS count FOR quality IN (1 AS high, 2 AS low, NULL AS na)
);
```
Die Abfrage führt zur folgenden Ausgabe.
```
manufacturer | high_count | low_count | na_count
-------------------+-------------+-----------+----------
local parts co | 1 | 1 | 1
big parts co | 1 | 1 | 1
small parts co | 1 | 0 | 2
```
Richten Sie die folgende Beispieltabelle und -daten ein und verwenden Sie sie, um die folgenden Beispielabfragen auszuführen. Die Daten stellen Buchungstermine für eine Reihe von Hotels dar.
```
CREATE TABLE bookings (
booking_id int,
hotel_code char(8),
booking_date date,
price decimal(12, 2)
);
INSERT INTO bookings VALUES (1, 'FOREST_L', '02/01/2023', 75.12);
INSERT INTO bookings VALUES (2, 'FOREST_L', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (3, 'FOREST_L', '02/04/2023', 85.54);
INSERT INTO bookings VALUES (4, 'FOREST_L', '02/08/2023', 75.00);
INSERT INTO bookings VALUES (5, 'FOREST_L', '02/11/2023', 75.00);
INSERT INTO bookings VALUES (6, 'FOREST_L', '02/14/2023', 90.00);
INSERT INTO bookings VALUES (7, 'FOREST_L', '02/21/2023', 60.00);
INSERT INTO bookings VALUES (8, 'FOREST_L', '02/22/2023', 85.00);
INSERT INTO bookings VALUES (9, 'FOREST_L', '02/27/2023', 90.00);
INSERT INTO bookings VALUES (10, 'DESERT_S', '02/01/2023', 98.00);
INSERT INTO bookings VALUES (11, 'DESERT_S', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (12, 'DESERT_S', '02/04/2023', 85.00);
INSERT INTO bookings VALUES (13, 'DESERT_S', '02/05/2023', 75.00);
INSERT INTO bookings VALUES (14, 'DESERT_S', '02/06/2023', 34.00);
INSERT INTO bookings VALUES (15, 'DESERT_S', '02/09/2023', 85.00);
INSERT INTO bookings VALUES (16, 'DESERT_S', '02/12/2023', 23.00);
INSERT INTO bookings VALUES (17, 'DESERT_S', '02/13/2023', 76.00);
INSERT INTO bookings VALUES (18, 'DESERT_S', '02/14/2023', 85.00);
INSERT INTO bookings VALUES (19, 'OCEAN_WV', '02/01/2023', 98.00);
INSERT INTO bookings VALUES (20, 'OCEAN_WV', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (21, 'OCEAN_WV', '02/04/2023', 85.00);
INSERT INTO bookings VALUES (22, 'OCEAN_WV', '02/06/2023', 75.00);
INSERT INTO bookings VALUES (23, 'OCEAN_WV', '02/09/2023', 34.00);
INSERT INTO bookings VALUES (24, 'OCEAN_WV', '02/12/2023', 85.00);
INSERT INTO bookings VALUES (25, 'OCEAN_WV', '02/13/2023', 23.00);
INSERT INTO bookings VALUES (26, 'OCEAN_WV', '02/14/2023', 76.00);
INSERT INTO bookings VALUES (27, 'OCEAN_WV', '02/16/2023', 85.00);
INSERT INTO bookings VALUES (28, 'CITY_BLD', '02/01/2023', 98.00);
INSERT INTO bookings VALUES (29, 'CITY_BLD', '02/02/2023', 75.00);
INSERT INTO bookings VALUES (30, 'CITY_BLD', '02/04/2023', 85.00);
INSERT INTO bookings VALUES (31, 'CITY_BLD', '02/12/2023', 75.00);
INSERT INTO bookings VALUES (32, 'CITY_BLD', '02/13/2023', 34.00);
INSERT INTO bookings VALUES (33, 'CITY_BLD', '02/17/2023', 85.00);
INSERT INTO bookings VALUES (34, 'CITY_BLD', '02/22/2023', 23.00);
INSERT INTO bookings VALUES (35, 'CITY_BLD', '02/23/2023', 76.00);
INSERT INTO bookings VALUES (36, 'CITY_BLD', '02/24/2023', 85.00);
```
In dieser Beispielabfrage werden die Buchungsdatensätze zusammengezählt, um eine Gesamtsumme für jede Woche zu erhalten. Das Enddatum für jede Woche wird zu einem Spaltennamen.
```
SELECT * FROM
(SELECT
booking_id,
(date_trunc('week', booking_date::date) + '5 days'::interval)::date as enddate,
hotel_code AS "hotel code"
FROM bookings
) PIVOT (
count(booking_id) FOR enddate IN ('2023-02-04','2023-02-11','2023-02-18')
);
```
Die Abfrage führt zur folgenden Ausgabe.
```
hotel code | 2023-02-04 | 2023-02-11 | 2023-02-18
------------+-------------+------------+----------
FOREST_L | 3 | 2 | 1
DESERT_S | 4 | 3 | 2
OCEAN_WV | 3 | 3 | 3
CITY_BLD | 3 | 1 | 2
```
Amazon Redshift unterstützt CROSSTAB, um mehrere Spalten zu pivotieren. Mit einer Abfrage wie der folgenden können Sie jedoch Zeilendaten in Spalten ändern, ähnlich wie bei einer Aggregation mit PIVOT. Dabei werden dieselben Buchungsbeispieldaten wie im vorherigen Beispiel verwendet.
```
SELECT
booking_date,
MAX(CASE WHEN hotel_code = 'FOREST_L' THEN 'forest is booked' ELSE '' END) AS FOREST_L,
MAX(CASE WHEN hotel_code = 'DESERT_S' THEN 'desert is booked' ELSE '' END) AS DESERT_S,
MAX(CASE WHEN hotel_code = 'OCEAN_WV' THEN 'ocean is booked' ELSE '' END) AS OCEAN_WV
FROM bookings
GROUP BY booking_date
ORDER BY booking_date asc;
```
Die Beispielabfrage ergibt Buchungsdaten, die neben kurzen Ausdrücken aufgeführt sind und angeben, welche Hotels gebucht wurden.
```
booking_date | forest_l | desert_s | ocean_wv
---------------+------------------+------------------+--------------------
2023-02-01 | forest is booked | desert is booked | ocean is booked
2023-02-02 | forest is booked | desert is booked | ocean is booked
2023-02-04 | forest is booked | desert is booked | ocean is booked
2023-02-05 | | desert is booked |
2023-02-06 | | desert is booked |
```
Im Folgenden finden Sie Nutzungshinweise für `PIVOT`:
+ `PIVOT`kann auf Tabellen, Unterabfragen und allgemeine Tabellenausdrücke () angewendet werden. CTEs `PIVOT`kann nicht auf irgendwelche `JOIN` Ausdrücke, rekursive CTEs Ausdrücke oder `UNPIVOT` Ausdrücke angewendet werden. `PIVOT` Ebenfalls nicht unterstützt werden nicht verschachtelte `SUPER`-Ausdrücke sowie verschachtelte Redshift-Spectrum-Tabellen.
+ `PIVOT` unterstützt die Aggregatfunktionen `COUNT`, `SUM`, `MIN`, `MAX` und `AVG`.
+ Der `PIVOT`-Aggregatausdruck muss ein Aufruf einer unterstützten Aggregatfunktion sein. Komplexe Ausdrücke, die auf dem Aggregat aufbauen, werden nicht unterstützt. Die Aggregatargumente können keine Verweise auf Tabellen enthalten, bei denen es sich nicht um die `PIVOT`-Eingabetabelle handelt. Korrelierte Verweise auf eine übergeordnete Abfrage werden ebenfalls nicht unterstützt. Das Aggregatargument kann Unterabfragen enthalten. Diese können intern oder in der `PIVOT`-Eingabetabelle korreliert werden.
+ Die `PIVOT IN`-Listenwerte können keine Spaltenverweise oder Unterabfragen sein. Alle Werte müssen mit dem `FOR`-Spaltenverweis typenkompatibel sein.
+ Wenn die `IN`-Listenwerte keine Aliase haben, generiert `PIVOT` Standardspaltennamen. Bei konstanten `IN`-Werten wie etwa „abc“ oder „5“ ist der Spaltennamen die Konstante. Bei komplexen Ausdrücken ist der Spaltenname ein Amazon-Redshift-Standardname wie etwa `?column?`.
## Beispiele für UNPIVOT
Richten Sie die Beispieldaten ein und verwenden Sie sie, um die folgenden Beispiele auszuführen.
```
CREATE TABLE count_by_color (quality varchar, red int, green int, blue int);
INSERT INTO count_by_color VALUES ('high', 15, 20, 7);
INSERT INTO count_by_color VALUES ('normal', 35, NULL, 40);
INSERT INTO count_by_color VALUES ('low', 10, 23, NULL);
```
`UNPIVOT` in den Eingabespalten rot, grün und blau.
```
SELECT *
FROM (SELECT red, green, blue FROM count_by_color) UNPIVOT (
cnt FOR color IN (red, green, blue)
);
```
Die Abfrage führt zur folgenden Ausgabe.
```
color | cnt
-------+-----
red | 15
red | 35
red | 10
green | 20
green | 23
blue | 7
blue | 40
```
Standardmäßig werden `NULL`-Werte in der Eingabespalte übersprungen und ergeben keine Ergebniszeile.
Das folgende Beispiel zeigt `UNPIVOT` mit `INCLUDE NULLS`.
```
SELECT *
FROM (
SELECT red, green, blue
FROM count_by_color
) UNPIVOT INCLUDE NULLS (
cnt FOR color IN (red, green, blue)
);
```
Die resultierende Ausgabe sieht wie folgt aus.
```
color | cnt
-------+-----
red | 15
red | 35
red | 10
green | 20
green |
green | 23
blue | 7
blue | 40
blue |
```
Wenn der Parameter `INCLUDING NULLS` festgelegt wurde, generieren `NULL`-Eingabewerte Ergebniszeilen.
`The following query shows UNPIVOT` mit `quality` als impliziter Spalte.
```
SELECT *
FROM count_by_color UNPIVOT (
cnt FOR color IN (red, green, blue)
);
```
Die Abfrage führt zur folgenden Ausgabe.
```
quality | color | cnt
---------+-------+-----
high | red | 15
normal | red | 35
low | red | 10
high | green | 20
low | green | 23
high | blue | 7
normal | blue | 40
```
Spalten der Eingabetabelle, die nicht in der `UNPIVOT`-Definition referenziert sind, werden implizit zur Ergebnistabelle hinzugefügt. Im Beispiel ist dies bei der `quality`-Spalte der Fall.
Das folgende Beispiel zeigt `UNPIVOT` mit Aliasen für Werte in der `IN`-Liste.
```
SELECT *
FROM count_by_color UNPIVOT (
cnt FOR color IN (red AS r, green AS g, blue AS b)
);
```
Die vorige Abfrage führt zu der folgenden Ausgabe.
```
quality | color | cnt
---------+-------+-----
high | r | 15
normal | r | 35
low | r | 10
high | g | 20
low | g | 23
high | b | 7
normal | b | 40
```
Der `UNPIVOT`-Operator akzeptiert optionale Aliase auf jedem `IN`-Listenwert. Jeder Alias ermöglicht die Anpassung der Daten in jeder `value`-Spalte.
Im Folgenden finden Sie Nutzungshinweise für `UNPIVOT`.
+ `UNPIVOT`kann auf Tabellen, Unterabfragen und allgemeine Tabellenausdrücke () CTEs angewendet werden. `UNPIVOT`kann nicht auf irgendwelche `JOIN` Ausdrücke, rekursive CTEs Ausdrücke oder `UNPIVOT` Ausdrücke angewendet werden. `PIVOT` Ebenfalls nicht unterstützt werden nicht verschachtelte `SUPER`-Ausdrücke sowie verschachtelte Redshift-Spectrum-Tabellen.
+ Die Liste `UNPIVOT IN` darf nur Spaltenverweise auf Eingabetabellen enthalten. Die `IN`-Listenspalten müssen einen gemeinsamen Typ haben, mit dem sie alle kompatibel sind. Die `UNPIVOT`-Wertspalte hat diesen gemeinsamen Typ. Der `UNPIVOT`-Spaltenname hat den Typ `VARCHAR`.
+ Wenn ein `IN`-Listenwert keinen Alias hat, verwendet `UNPIVOT` den Spaltennamen als Standardwert.