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. # Abfragen halbstrukturierter Daten Mit Amazon Redshift können Sie neben Ihren strukturierten Daten auch halbstrukturierte Daten wie JSON, Avro oder Ion abfragen und analysieren. Halbstrukturierte Daten sind Daten, die über ein flexibles Schema verfügen, das hierarchische oder verschachtelte Strukturen ermöglicht. In den folgenden Abschnitten wird das Abfragen halbstrukturierter Daten mithilfe der Unterstützung offener Datenformate durch Amazon Redshift veranschaulicht, so dass Sie wertvolle Informationen aus komplexen Datenstrukturen gewinnen können. Amazon Redshift verwendet die PartiQL-Sprache, um SQL-kompatiblen Zugriff auf relationale, halbstrukturierte und verschachtelte Daten zu bieten. PartiQL arbeitet mit dynamischen Typen. Dies ermöglicht eine intuitive Filterung, Verknüpfung und Aggregation für die Kombination strukturierter, halbstrukturierter und verschachtelter Datensätze. Die PartiQL-Syntax verwendet Punktschreibweise und Array-Subscript für die Pfadnavigation beim Zugriff auf verschachtelte Daten. Es ermöglicht auch die FROM-Klauselelemente über Arrays zu iterieren und für Unnest-Operationen zu verwenden. Nachfolgend werden die verschiedenen Abfragemuster beschrieben, die die Verwendung des SUPER-Datentyps mit Pfad- und Array-Navigation, Aufheben der Verschachtelung, Entpivotieren und Joins kombinieren. Weitere Informationen zu PartiQL finden Sie unter [PartiQL – eine SQL-kompatible Abfragesprache für Amazon Redshift](super-partiql.md). ## Navigation Amazon Redshift verwendet PartiQL, um die Navigation in Arrays und Strukturen mithilfe der [...]-Klammer bzw. Punktschreibweise zu ermöglichen. Darüber hinaus können Sie die Navigation mithilfe von Punktschreibweise und Arrays mithilfe der Klammernotation in Strukturen mischen. Die folgende Anweisung wählt beispielsweise nur das dritte Element in einem Array aus, das eine Ebene tief in einem SUPER-Objekt verschachtelt ist: ``` SELECT super_object.array[2]; array --------------- third_element ``` Sie können die Punkt- und Klammernotation verwenden, wenn Sie Datenoperationen wie Filtern, Verknüpfen und Aggregation ausführen. Sie können diese Notationen in einer Abfrage verwenden, in der normalerweise Spaltenverweise vorhanden sind. Die folgende Anweisung wählt beispielsweise die Anzahl der Ereignisse mit dem Typ `UPDATED` aus. ``` SELECT COUNT(*) FROM test_json WHERE all_data.data.pnr.events[0]."eventType" = 'UPDATED'; eventType | count -----------+------- "UPDATED" | 1 ``` Ausführlichere Beispiele für die Verwendung der PartiQL-Navigation finden Sie unter [Beispiele für die Verwendung halbstrukturierter Daten in Amazon Redshift](super-examples.md). ## Aufheben der Verschachtelung von Abfragen Zur Aufhebung der Verschachtelung von Abfragen bietet Amazon Redshift zwei Möglichkeiten, über SUPER-Arrays zu iterieren: PartiQL-Syntax und die UNNEST-Operation in der FROM-Klausel. Beide Methoden zum Entfernen von Verschachtelungen führen zu derselben Ausgabe. Informationen zur UNNEST-Operation finden Sie unter [FROM-Klausel](r_FROM_clause30.md). Beispiele für die Verwendung der UNNEST-Operation finden Sie unter [Beispiele für UNNEST](r_FROM_clause-unnest-examples.md). Amazon Redshift verwendet die PartiQL-Syntax zur Navigation in SUPER-Arrays in der FROM-Klausel einer Abfrage. Das folgende Beispiel nutzt das vorherige Beispiel und iteriert über die Attributwerte für `c_orders`. ``` SELECT orders.*, o FROM customer_orders orders, orders.c_orders o; ``` Die PartiQL-Syntax zum Aufheben der Verschachtelung mithilfe des FROM-Klauselelements `x (AS) y` bedeutet, dass `y` über jeden (SUPER)-Wert in (SUPER)-Array-Ausdruck x iteriert. In diesem Fall ist `x` ein SUPER-Ausdruck und `y` ist ein Alias für `x`. Der linke Operand kann auch die Punkt- und Klammernotation für die reguläre Navigation verwenden. Im folgenden Beispiel ist `customer_orders_lineitem c` die Iteration über die Basistabelle `customer_order_lineitem` und `c.c_orders o` ist die Iteration über das Array `c.c_orders`. Um über das Attribut `o_lineitems` zu iterieren, also ein Array innerhalb eines Arrays, fügen Sie mehrere Klauseln hinzu, etwa so: ``` SELECT c.*, o, l FROM customer_orders_lineitem c, c.c_orders o, o.o_lineitems l; ``` Amazon Redshift unterstützt auch einen Array-Index, wenn mit dem AT-Schlüsselwort über das Array iteriert wird. Die Klausel `x AS y AT z` iteriert über Array `x` und generiert das Feld `z,`, das der Array-Index ist. Das folgende Beispiel zeigt die Funktionsweise eines Array-Index. ``` SELECT c_name, orders.o_orderkey AS orderkey, index AS orderkey_index FROM customer_orders_lineitem c, c.c_orders AS orders AT index ORDER BY orderkey_index; c_name | orderkey | orderkey_index -------------------+----------+---------------- Customer#000008251 | 3020007 | 0 Customer#000009452 | 4043971 | 0 (2 rows) ``` Das folgende Beispiel iteriert über ein skalares Array. ``` CREATE TABLE bar AS SELECT json_parse('{"scalar_array": [1, 2.3, 45000000]}') AS data; SELECT element, index FROM bar AS b, b.data.scalar_array AS element AT index; index | element -------+---------- 0 | 1 1 | 2.3 2 | 45000000 (3 rows) ``` Im folgenden Beispiel wird über ein Array mit mehreren Ebenen iteriert. Das Beispiel nutzt mehrere Klauseln zum Aufheben der Verschachtelung, um in die innersten Arrays zu iterieren. Das AS-Array `f.multi_level_array` iteriert über `multi_level_array`. Das Array-AS-Element ist die Iteration über die Arrays innerhalb von `multi_level_array`. ``` CREATE TABLE foo AS SELECT json_parse('[[1.1, 1.2], [2.1, 2.2], [3.1, 3.2]]') AS multi_level_array; SELECT array, element FROM foo AS f, f.multi_level_array AS array, array AS element; element | array ---------+--------- 1.1 | [1.1,1.2] 1.2 | [1.1,1.2] 2.1 | [2.1,2.2] 2.2 | [2.1,2.2] 3.1 | [3.1,3.2] 3.2 | [3.1,3.2] (6 rows) ``` Weitere Informationen über die FROM-Klausel finden Sie unter [FROM-Klausel](r_FROM_clause30.md). Weitere Beispiele für das Aufheben der Verschachtelung von SUPER-Abfragen finden Sie unter [Beispiele für die Verwendung halbstrukturierter Daten in Amazon Redshift](super-examples.md). ## Entpivotieren von Objekten Um Objekte zu entpivotieren, verwendet Amazon Redshift die PartiQL-Syntax, um über SUPER-Objekte zu iterieren. Dazu verwendet es die FROM-Klausel einer Abfrage mit dem Schlüsselwort UNPIVOT. Im folgenden Beispiel ist der Ausdruck das Objekt `c.c_orders[0]`. In der Beispielabfrage wird über jedes von dem Objekt zurückgegebene Attribut iteriert. ``` SELECT attr as attribute_name, json_typeof(val) as value_type FROM customer_orders_lineitem c, UNPIVOT c.c_orders[0] AS val AT attr WHERE c_custkey = 9451; attribute_name | value_type -----------------+------------ o_orderstatus | string o_clerk | string o_lineitems | array o_orderdate | string o_shippriority | number o_totalprice | number o_orderkey | number o_comment | string o_orderpriority | string (9 rows) ``` Wie beim Aufheben der Verschachtelung ist die Syntax zum Entpivotieren eine Erweiterung der FROM-Klausel. Der Unterschied ist, dass die Syntax zum Entpivotieren das Schlüsselwort UNPIVOT verwendet, um anzuzeigen, dass es über ein Objekt anstelle eines Arrays iteriert. Das AS `value_alias` wird zur Iteration über alle Werte innerhalb eines Objekts und das AT `attribute_alias` zum Iterieren über alle Attribut verwendet. Betrachten Sie folgende Syntax: ``` UNPIVOT expression AS value_alias [ AT attribute_alias ] ``` Amazon Redshift unterstützt das Unpivoting von Objekten und das Aufheben der Verschachtelung von Arrays in einer einzigen FROM-Klausel: ``` SELECT attr as attribute_name, val as object_value FROM customer_orders_lineitem c, c.c_orders AS o, UNPIVOT o AS val AT attr WHERE c_custkey = 9451; ``` Wenn Sie das Entpivotieren von Objekten verwenden, unterstützt Amazon Redshift kein korreliertes Entpivotieren. Angenommen den Fall, es gibt mehrere Beispiele für Entpivotieren in verschiedenen Abfrageebenen und das innere Entpivotieren verweist auf das äußere. Amazon Redshift unterstützt diese Art von mehrfachem Entpivotieren nicht. Weitere Informationen über die FROM-Klausel finden Sie unter [FROM-Klausel](r_FROM_clause30.md). Beispiele für die Verwendung von Pivoting mit dem Typ SUPER finden Sie unter [Beispiele für die Verwendung halbstrukturierter Daten in Amazon Redshift](super-examples.md). ## Dynamische Typisierung Die dynamische Eingabe erfordert keine explizite Umwandlung von Daten, die aus den Punkt- und Klammerpfaden extrahiert werden. Amazon Redshift verwendet die dynamische Typisierung, um schemalose SUPER-Daten zu verarbeiten, ohne dass die Datentypen deklariert werden müssen, bevor Sie sie in Ihrer Abfrage verwenden. Bei der dynamischen Typisierung werden die Ergebnisse der Navigation in SUPER-Datenspalten verwendet, ohne sie explizit in Amazon-Redshift-Typen umwandeln zu müssen. Dynamische Typisierung ist am nützlichsten in Joins und GROUP-BY-Klauseln. Im folgenden Beispiel wird eine SELECT-Anweisung verwendet, die keine explizite Umwandlung der Punkt- und Klammerausdrücke in die üblichen Amazon-Redshift-Typen erfordert. Informationen zur Typkompatibilität und Konvertierung finden Sie unter [Kompatibilität von Typen und Umwandlung zwischen Typen](c_Supported_data_types.md#r_Type_conversion). Sehen Sie sich das folgende Beispiel an, das nach Zeilen sucht, in denen der Status einer Bestellung `shipped` ist: ``` SELECT c_orders[0].o_orderkey FROM customer_orders_lineitem WHERE c_orders[0].o_orderstatus = 'shipped'; ``` Das Gleichheitszeichen in dieser Beispielabfrage wird als `true` evaluiert, wenn der Wert c\$1orders[0].o\$1orderstatus die Zeichenfolge „shipped“ ist. In allen anderen Fällen wird das Gleichheitszeichen als `false` evaluiert, einschließlich der Fälle, in denen die Argumente der Gleichheit unterschiedliche Typen sind. Wenn der Bestellstatus beispielsweise eine Ganzzahl ist, wird die zugehörige Zeile nicht ausgewählt. ### Dynamische und statische Typisierung Ohne dynamische Typisierung können Sie nicht bestimmen, ob c\$1orders[0].o\$1orderstatus eine Zeichenfolge, eine Ganzzahl oder eine Struktur ist. Sie können nur feststellen, dass c\$1orders[0].o\$1orderstatus ein SUPER-Datentyp ist, bei dem es sich um einen Amazon-Redshift-Skalar, ein Array oder eine Struktur handeln kann. Der statische Typ von c\$1orders[0].o\$1orderstatus ist ein SUPER-Datentyp. Üblicherweise ist ein Typ implizit ein statischer Typ in SQL. Amazon Redshift verwendet dynamische Typisierung für die Verarbeitung von schemalosen Daten. Wenn die Abfrage die Daten auswertet, erweist sich c\$1orders[0].o\$1orderstatus als ein bestimmter Typ. Beispielsweise kann die Auswertung von c\$1orders[0].o\$1orderstatus auf dem ersten Datensatz von customer\$1orders\$1lineitem zu einer Ganzzahl führen. Die Auswertung des zweiten Datensatzes kann zu einer Zeichenfolge führen. Dies sind die dynamischen Typen des Ausdrucks. Wenn Sie einen SQL-Operator oder eine SQL-Funktion mit Punkt- und Klammerausdrücken verwenden, die dynamische Typen haben, erzeugt Amazon Redshift ähnliche Ergebnisse wie bei der Verwendung des Standard-SQL-Operators bzw. der Standard-SQL-Funktion mit den jeweiligen statischen Typen. Wenn in diesem Beispiel der dynamische Typ des Pfadausdrucks eine Zeichenfolge ist, ist der Vergleich mit der Zeichenfolge „P“ sinnvoll. Immer wenn der dynamische Typ von c\$1orders[0].o\$1orderstatus ein anderer Datentyp außer eine Zeichenfolge ist, gibt die Gleichheit false zurück. Andere Funktionen geben null zurück, wenn falsch eingegebene Argumente verwendet werden. Im folgenden Beispiel wird die vorherige Abfrage mit statischer Eingabe geschrieben: ``` SELECT c_custkey FROM customer_orders_lineitem WHERE CASE WHEN JSON_TYPEOF(c_orders[0].o_orderstatus) = 'string' THEN c_orders[0].o_orderstatus::VARCHAR = 'P' ELSE FALSE END; ``` Beachten Sie die folgende Unterscheidung zwischen Gleichheitsprädikaten und Vergleichsprädikaten. Wenn Sie im vorherigen Beispiel das Gleichheitsprädikat durch ein less-than-or-equal Prädikat ersetzen, ergibt die Semantik Null statt False. ``` SELECT c_orders[0]. o_orderkey FROM customer_orders_lineitem WHERE c_orders[0].o_orderstatus <= 'P'; ``` Wenn in diesem Beispiel c\$1orders[0].o\$1orderstatus eine Zeichenfolge ist, gibt Amazon Redshift true zurück, wenn sie alphabetisch gleich oder kleiner als „P“ ist. Amazon Redshift gibt false zurück, wenn sie alphabetisch größer als „P“ ist. Wenn c\$1orders[0].o\$1orderstatus jedoch keine Zeichenfolge ist, gibt Amazon Redshift null zurück, da Amazon Redshift Werte verschiedener Typen nicht vergleichen kann, wie in der folgenden Abfrage dargestellt: ``` SELECT c_custkey FROM customer_orders_lineitem WHERE CASE WHEN JSON_TYPEOF(c_orders[0].o_orderstatus) = 'string' THEN c_orders[0].o_orderstatus::VARCHAR <= 'P' ELSE NULL END; ``` Dynamische Typisierung schließt keine Vergleiche von Typen aus, die minimal vergleichbar sind. Beispielsweise können Sie Amazon-Redshift-Skalartypen von sowohl CHAR als auch VARCHAR in SUPER konvertieren. Sie sind als Zeichenfolgen vergleichbar, einschließlich des Ignorierens nachstehender Leerzeichen, ähnlich wie bei CHAR- und VARCHAR-Typen von Amazon Redshift. In ähnlicher Weise sind Ganzzahlen, Dezimalzahlen und Gleitkommawerte als SUPER-Werte vergleichbar. Speziell für Dezimalspalten kann jeder Wert auch einen anderen Maßstab haben. In Amazon Redshift gelten sie weiterhin als dynamische Typen. Amazon Redshift unterstützt auch die Gleichheit von Objekten und Arrays, die als deep equal ausgewertet werden, z. B. die ausführliche Auswertung von Objekten oder Arrays und der Vergleich aller Attribute. Verwenden Sie deep equal mit Vorsicht, da die Durchführung zeitaufwendig sein kann. ### Verwenden der dynamischen Typisierung für Joins Bei Joins passt die dynamische Typisierung automatisch Werte mit unterschiedlichen dynamischen Typen an, ohne eine lange CASE-WHEN-Analyse durchzuführen, um herauszufinden, welche Datentypen möglicherweise angezeigt werden. Nehmen wir beispielsweise an, dass Ihre Organisation das Format geändert hat, das sie für Teileschlüssel verwendet hat. Die ursprünglichen ganzzahligen Teilschlüssel werden durch Zeichenfolgen-Teilschlüssel ersetzt, wie „A55“, und später wieder durch Array-Teilschlüssel ersetzt, wie ['X', 10], die eine Zeichenfolge und eine Zahl kombinieren. Amazon Redshift muss keine langwierige Fallanalyse zu Teileschlüsseln durchführen und kann Joins verwenden, wie im folgenden Beispiel gezeigt. ``` SELECT c.c_name ,l.l_extendedprice ,l.l_discount FROM customer_orders_lineitem c ,c.c_orders o ,o.o_lineitems l ,supplier_partsupp s ,s.s_partsupps ps WHERE l.l_partkey = ps.ps_partkey AND c.c_nationkey = s.s_nationkey ORDER BY c.c_name; ``` Das folgende Beispiel zeigt, wie komplex und ineffizient dieselbe Abfrage ohne dynamische Typisierung sein kann: ``` SELECT c.c_name ,l.l_extendedprice ,l.l_discount FROM customer_orders_lineitem c ,c.c_orders o ,o.o_lineitems l ,supplier_partsupp s ,s.s_partsupps ps WHERE CASE WHEN IS_INTEGER(l.l_partkey) AND IS_INTEGER(ps.ps_partkey) THEN l.l_partkey::integer = ps.ps_partkey::integer WHEN IS_VARCHAR(l.l_partkey) AND IS_VARCHAR(ps.ps_partkey) THEN l.l_partkey::varchar = ps.ps_partkey::varchar WHEN IS_ARRAY(l.l_partkey) AND IS_ARRAY(ps.ps_partkey) AND IS_VARCHAR(l.l_partkey[0]) AND IS_VARCHAR(ps.ps_partkey[0]) AND IS_INTEGER(l.l_partkey[1]) AND IS_INTEGER(ps.ps_partkey[1]) THEN l.l_partkey[0]::varchar = ps.ps_partkey[0]::varchar AND l.l_partkey[1]::integer = ps.ps_partkey[1]::integer ELSE FALSE END AND c.c_nationkey = s.s_nationkey ORDER BY c.c_name; ``` ## Bei Abfragen wird nicht zwischen Groß- und Kleinschreibung unterschieden Sie können Zeichenkettenvergleiche für SUPER-Daten ohne Berücksichtigung der Groß- und Kleinschreibung durchführen, indem Sie die Funktion COLLATE verwenden oder indem Sie die Sortierung auf Spalten- oder Datenbankebene festlegen. Weitere Hinweise zum Festlegen der Sortierung bei der Tabellenerstellung finden Sie unter. [CREATE TABLE](r_CREATE_TABLE_NEW.md) Hinweise zum Sortierverhalten mit SUPER-Datenoperatoren und Funktionen finden Sie unter. [Kollationierungsverhalten](operators-functions.md#collation-behavior) Im folgenden Beispiel wird die COLLATE-Funktion für Zeichenkettenwerte verwendet, die aus SUPER-Daten extrahiert wurden. ``` CREATE TABLE events (data SUPER); INSERT INTO events VALUES (JSON_PARSE('{"status": "Active", "name": "Event1"}')); INSERT INTO events VALUES (JSON_PARSE('{"status": "ACTIVE", "name": "Event2"}')); INSERT INTO events VALUES (JSON_PARSE('{"status": "active", "name": "Event3"}')); SELECT data.name FROM events WHERE COLLATE(data.status::VARCHAR, 'case_insensitive') = 'active'; name ---------- "Event1" "Event2" "Event3" (3 rows) ``` Sie können bei der Tabellenerstellung auch eine SUPER-Spalte definieren, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird. In diesem Fall wird bei allen Zeichenkettenvergleichen in der Spalte nicht zwischen Groß- und Kleinschreibung unterschieden. ``` CREATE TABLE events_ci (data SUPER COLLATE CASE_INSENSITIVE); INSERT INTO events_ci VALUES (JSON_PARSE('{"status": "Active"}')); INSERT INTO events_ci VALUES (JSON_PARSE('{"status": "ACTIVE"}')); SELECT * FROM events_ci WHERE data.status::VARCHAR = 'active'; data ----------------------- {"status":"Active"} {"status":"ACTIVE"} (2 rows) ``` ## Lax-Semantik Standardmäßig geben Navigationsvorgänge für SUPER-Werte null zurück, anstatt einen Fehler zurückzugeben, wenn die Navigation ungültig ist. Die Objektnavigation ist ungültig, wenn der SUPER-Wert kein Objekt ist oder wenn der SUPER-Wert ein Objekt ist, aber nicht den Attributnamen enthält, der in der Abfrage verwendet wird. Die folgende Abfrage greift beispielsweise auf einen ungültigen Attributnamen in der SUPER-Datenspalte cdata zu: ``` SELECT c.c_orders.something FROM customer_orders_lineitem c; ``` Die Array-Navigation gibt null zurück, wenn der SUPER-Wert kein Array ist oder der Array-Index außerhalb der Grenzen liegt. Die folgende Abfrage gibt null zurück, da c\$1orders[1][1] außerhalb der Grenzen liegt. ``` SELECT c.c_orders[1][1] FROM customer_orders_lineitem c; ``` Lax-Semantik ist besonders nützlich, wenn dynamische Typisierung verwendet wird, um einen SUPER Wert zu konvertieren. Wenn ein SUPER Wert in den falschen Typ umgewandelt wird, wird null anstelle eines Fehlers zurückgegeben, wenn die Umwandlung ungültig ist. Die folgende Abfrage gibt beispielsweise null zurück, da sie den Zeichenfolgenwert 'Good' des Objektattributs o\$1orderstatus nicht in INTEGER umwandeln kann. Amazon Redshift gibt einen Fehler für eine Umwandlung von VARCHAR zu INTEGER zurück, aber nicht für eine SUPER-Umwandlung. ``` SELECT c.c_orders.o_orderstatus::integer FROM customer_orders_lineitem c; ``` ## Order by (Sortieren nach) Amazon Redshift definiert keine SUPER-Vergleiche zwischen Werten mit verschiedenen dynamischen Typen. Ein SUPER-Wert, der eine Zeichenfolge ist, ist weder kleiner noch größer als ein SUPER-Wert, der eine Zahl ist. Um ORDER-BY-Klauseln mit SUPER-Spalten zu verwenden, definiert Amazon Redshift eine Gesamtsortierung zwischen verschiedenen Typen, die beachtet werden müssen, wenn Amazon Redshift SUPER-Werte mithilfe von ORDER-BY-Klauseln anordnet. Die Reihenfolge zwischen dynamischen Typen ist boolesch, Zahl, Zeichenfolge, Array, Objekt. Ein Beispiel für die Verwendung von GROUP BY und ORDER BY in einer SUPER-Abfrage finden Sie unter [Filtern halbstrukturierter Daten](super-examples.md#super-examples-filter).