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. # Tutorial: Abfragen verschachtelter Daten mit Amazon Redshift Spectrum Dieses Tutorial zeigt, wie Sie verschachtelte Daten mit Redshift Spectrum abfragen. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte. **Topics** + [-Übersicht](#tutorial-nested-data-overview) + [Schritt 1: Erstellen einer externen Tabelle mit verschachtelten Daten](#tutorial-nested-data-create-table) + [Schritt 2: Abfragen Ihrer verschachtelten Daten in Amazon S3 mit SQL-Erweiterungen](#tutorial-query-nested-data-sqlextensions) + [Anwendungsfälle für verschachtelte Daten](nested-data-use-cases.md) + [Einschränkungen bei verschachtelten Daten (Vorschau)](nested-data-restrictions.md) + [Serialisieren komplexer verschachtelter JSON-Datentypen](serializing-complex-JSON.md) ## -Übersicht Amazon Redshift Spectrum unterstützt das Abfragen verschachtelter Daten in den Dateiformaten ORC, JSON und Ion. Redshift Spectrum greift mittels externer Tabellen auf die Daten zu. Sie können externe Tabellen erstellen, die die komplexen Datentypen `struct`, `array` und `map` verwenden. Angenommen, Ihre Datendatei enthält die folgenden Daten in Amazon S3 in einem Ordner mit dem Namen `customers`. Obwohl kein einziges Stammelement vorhanden ist, stellt jedes JSON-Objekt in diesen Stichprobendaten eine Zeile in einer Tabelle dar. ``` {"id": 1, "name": {"given": "John", "family": "Smith"}, "phones": ["123-457789"], "orders": [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}] } {"id": 2, "name": {"given": "Jenny", "family": "Doe"}, "phones": ["858-8675309", "415-9876543"], "orders": [] } {"id": 3, "name": {"given": "Andy", "family": "Jones"}, "phones": [], "orders": [{"shipdate": "2018-03-02T08:02:15.000Z", "price": 13.50}] } ``` Sie können mithilfe von Amazon Redshift Spectrum verschachtelte Daten in Dateien abfragen. Das folgende Tutorial veranschaulicht die Vorgehensweise hierfür mit Apache-Parquet-Daten. ### Voraussetzungen Wenn Sie noch nicht mit Redshift Spectrum vertraut sind, befolgen Sie die Schritte unter [Erste Schritte mit Amazon Redshift Spectrum](c-getting-started-using-spectrum.md), bevor Sie fortfahren. Um ein externes Schema zu erstellen, ersetzen Sie den ARN der IAM-Rolle im folgenden Befehl durch den Rollen-ARN, den Sie im Abschnitt [Erstellen einer IAM-Rolle](c-getting-started-using-spectrum.md#c-getting-started-using-spectrum-create-role) festgelegt haben. Führen Sie dann den Befehl in Ihrem SQL-Client aus. ``` create external schema spectrum from data catalog database 'myspectrum_db' iam_role 'arn:aws:iam::123456789012:role/myspectrum_role' create external database if not exists; ``` ## Schritt 1: Erstellen einer externen Tabelle mit verschachtelten Daten Sie können die [Quelldaten](https://s3.amazonaws.com/redshift-downloads/tickit/spectrum/customers/customer_file1) anzeigen, indem Sie sie von Amazon S3 herunterladen. Um die externe Tabelle für dieses Tutorial zu erstellen, führen Sie den folgenden Befehl aus. ``` CREATE EXTERNAL TABLE spectrum.customers ( id int, name struct, phones array, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Im voranstehenden Beispiel verwendet die externe Tabelle `spectrum.customers` die Datentypen `struct` und `array`, um Spalten mit verschachtelten Daten zu definieren. Amazon Redshift Spectrum unterstützt das Abfragen verschachtelter Daten in den Dateiformaten ORC, JSON und Ion. Der Parameter `STORED AS` für Apache-Parquet-Dateien lautet `PARQUET`. Der Parameter `LOCATION` muss auf den Amazon S3-Ordner verweisen, der die verschachtelten Daten oder Dateien enthält. Weitere Informationen finden Sie unter [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Sie können die Typen `array` und `struct` auf jeder beliebigen Ebene verschachteln. So können Sie z. B. eine Spalte mit dem Namen `toparray` definieren; siehe folgendes Beispiel. ``` toparray array>>>> ``` Außerdem können Sie wie für Spalte `struct` im folgenden Beispiel veranschaulicht auch `x`-Typen verschachteln. ``` x struct > > ``` ## Schritt 2: Abfragen Ihrer verschachtelten Daten in Amazon S3 mit SQL-Erweiterungen Redshift Spectrum unterstützt das Abfragen komplexer `array`-, `map`- und `struct`-Typen durch Erweiterungen der Amazon-Redshift-SQL-Syntax. ### Erweiterung 1: Zugriff auf Structs-Spalten Sie können Daten aus `struct`-Spalten extrahieren. Dazu verwenden Sie eine punktierte Schreibweise, die Feldnamen in Pfade verkettet. Die folgende Abfrage gibt z. B. Vor- und Nachnamen von Kunden zurück. Auf den Vornamen wird über den langen Pfad `c.name.given` zugegriffen. Auf den Nachnamen wird über den langen Pfad `c.name.family` zugegriffen. ``` SELECT c.id, c.name.given, c.name.family FROM spectrum.customers c; ``` Die vorhergehende Abfrage gibt die folgenden Daten zurück. ``` id | given | family ---|-------|------- 1 | John | Smith 2 | Jenny | Doe 3 | Andy | Jones (3 rows) ``` Ein `struct`-Element kann eine Spalte eines anderen `struct`-Elements sein, das wiederum auf einer beliebigen anderen Ebene eine Spalte eines anderen `struct`-Elements sein kann. Die Pfade, die auf Spalten in solchen tief verschachtelten `struct`-Elementen zugreifen können willkürlich lang sein. Betrachten Sie sich z. B. die Definition der Spalte `x` im folgenden Beispiel. ``` x struct > > ``` Sie können auf die Daten in `e` als `x.b.d.e` zugreifen. ### Erweiterung 2: Übergreifende Arrays in einer FROM-Klausel Sie können Daten aus `array`-Spalten (und damit auch aus `map`-Spalten) extrahieren, indem Sie die `array`-Spalten in einer `FROM`-Klausel anstelle von Tabellennamen angeben. Die Erweiterung gilt für die `FROM`-Klausel der Hauptabfrage sowie auch für die `FROM`-Klauseln von Unterabfragen. Sie können auf `array`-Elemente nach Position verweisen, also beispielsweise `c.orders[0]` angeben (Vorschau). Durch das Kombinieren von übergreifenden `arrays` mit Joins können Sie die Verschachtelung auf verschiedene Weise aufheben, wie in den folgenden Anwendungsfällen beschrieben. #### Aufheben der Verschachtelung mit Inner Joins Die folgende Abfrage wählt Kunden IDs - und Auftragsversanddaten für Kunden aus, die Bestellungen haben. Die SQL-Erweiterung in der FROM-Klausel `c.orders o` ist vom Alias `c` abhängig. ``` SELECT c.id, o.shipdate FROM spectrum.customers c, c.orders o ``` Für jeden Kunden `c`, für den Aufträge vorhanden sind, gibt die `FROM`-Klausel für jeden Auftrag `o` des Kunden `c` eine Zeile zurück. Diese Zeile kombiniert die Kundenzeile `c` und die Auftragszeile `o`. Die `SELECT`-Klausel behält dann nur `c.id` und `o.shipdate` bei. Dies führt zu folgendem Ergebnis. ``` id| shipdate --|---------------------- 1 |2018-03-01 11:59:59 1 |2018-03-01 09:10:00 3 |2018-03-02 08:02:15 (3 rows) ``` Der Alias `c` bietet Zugriff auf die Kundenfelder, und der Alias `o` bietet Zugriff auf die Auftragsfelder. Die Semantik ist mit Standard-SQL vergleichbar. Sie können sich die `FROM`-Klausel so vorstellen, als würde die folgende verschachtelte Schleife ausgeführt werden, gefolgt von `SELECT` zur Auswahl der auszugebenden Felder. ``` for each customer c in spectrum.customers for each order o in c.orders output c.id and o.shipdate ``` Daher erscheinen Kunden, für die keine Aufträge vorhanden sind, nicht im Ergebnis. Sie können sich das auch so vorstellen, als ob die `FROM`-Klausel einen `JOIN` mit der `customers`-Tabelle und dem `orders`-Array durchführen wurde. Sie können die Abfrage daher auch wie im folgenden Beispiel veranschaulicht schreiben. ``` SELECT c.id, o.shipdate FROM spectrum.customers c INNER JOIN c.orders o ON true ``` **Anmerkung** Wenn ein Schema mit dem Namen `c` mit einer Tabelle mit dem Namen `orders` vorhanden ist, dann bezieht sich `c.orders` auf die Tabelle `orders` und nicht auf die Array-Spalte von `customers`. #### Aufheben der Verschachtelung mit Left Joins Die folgende Abfrage gibt alle Kundennamen und deren Aufträge aus. Für Kunden, die keinen Auftrag erteilt haben, wird dennoch der Kundenname zurückgegeben. In diesem Fall ist der Wert der Auftragsspalten jedoch NULL, wie im folgenden Beispiel für Jenny Doe veranschaulicht. ``` SELECT c.id, c.name.given, c.name.family, o.shipdate, o.price FROM spectrum.customers c LEFT JOIN c.orders o ON true ``` Die vorhergehende Abfrage gibt die folgenden Daten zurück. ``` id | given | family | shipdate | price ----|---------|---------|----------------------|-------- 1 | John | Smith | 2018-03-01 11:59:59 | 100.5 1 | John | Smith | 2018-03-01 09:10:00 | 99.12 2 | Jenny | Doe | | 3 | Andy | Jones | 2018-03-02 08:02:15 | 13.5 (4 rows) ``` ### Erweiterung 3: Direkter Zugriff auf ein Array von Skalaren über einen Alias Wenn sich der Alias `p` in einer `FROM`-Klausel über ein Array von Skalaren erstreckt, bezeichnet die Abfrage die `p`-Werte als `p`. Die folgende Abfrage ergibt z. B. Paare aus Kundennamen und Telefonnummern. ``` SELECT c.name.given, c.name.family, p AS phone FROM spectrum.customers c LEFT JOIN c.phones p ON true ``` Die vorhergehende Abfrage gibt die folgenden Daten zurück. ``` given | family | phone -------|----------|----------- John | Smith | 123-4577891 Jenny | Doe | 858-8675309 Jenny | Doe | 415-9876543 Andy | Jones | (4 rows) ``` ### Erweiterung 4: Zugriff auf Zuordnungselemente Redshift Spectrum verarbeitet den `map`-Datentyp als einen `array`-Typ, der `struct`-Typen mit einer `key`-Spalte und einer `value`-Spalte enthält. `key` muss vom Typ `scalar` sein; der Wert kann ein beliebiger Datentyp sein. Der folgende Code erstellt z. B. eine externe Tabelle mit einem `map`-Element zum Speichern von Telefonnummern. ``` CREATE EXTERNAL TABLE spectrum.customers2 ( id int, name struct, phones map, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Da sich ein `map`-Typ wie ein `array`-Typ mit den Spalten `key` und `value` verhält, können Sie sich die vorhergehenden Schemen so vorstellen, als wären sie die folgenden Schemen. ``` CREATE EXTERNAL TABLE spectrum.customers3 ( id int, name struct, phones array>, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Die folgende Abfrage gibt die Namen von Kunden mit Mobiltelefonnummer und die Nummer für jeden Namen zurück. Die Zuordnungsabfrage wird genauso wie die Abfrage eines verschachtelten `array` aus `struct`-Typen verarbeitet. Die folgende Abfrage gibt nur Daten zurück, wenn Sie die externe Tabelle wie zuvor beschrieben erstellt haben. ``` SELECT c.name.given, c.name.family, p.value FROM spectrum.customers c, c.phones p WHERE p.key = 'mobile'; ``` **Anmerkung** Der `key`-Wert für ein `map`-Element ist bei den Dateitypen Ion und JSON vom Typ `string`. # Anwendungsfälle für verschachtelte Daten In diesem Thema werden Anwendungsfälle für verschachtelte Daten beschrieben. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte. Sie können die zuvor beschriebenen Erweiterungen mit den gewöhnlichen SQL-Funktionen kombinieren. Die folgenden Anwendungsfälle veranschaulichen einige häufige Kombinationen. Anhand dieser Beispiele soll demonstriert werden, wie Sie verschachtelte Daten anwenden können. Sie sind nicht Teil des Tutorials. **Topics** + [Aufnehmen verschachtelter Daten](#ingesting-nested-data) + [Aggregieren verschachtelter Daten mit Unterabfragen](#aggregating-with-subquery) + [Verknüpfen von Amazon Redshift und verschachtelten Daten](#joining-redshift-data) ## Aufnehmen verschachtelter Daten Sie können eine `CREATE TABLE AS`-Anweisung verwenden, um Daten aus einer externen Tabelle mit komplexen Datentypen aufzunehmen. Die folgende Abfrage extrahiert alle Kunden und ihre Telefonnummern aus der externen Tabelle mithilfe von `LEFT JOIN` und speichert sie in der Amazon-Redshift-Tabelle `CustomerPhones`. ``` CREATE TABLE CustomerPhones AS SELECT c.name.given, c.name.family, p AS phone FROM spectrum.customers c LEFT JOIN c.phones p ON true; ``` ## Aggregieren verschachtelter Daten mit Unterabfragen Sie können eine Unterabfrage zum Aggregieren von verschachtelten Daten verwenden. Die folgende Abbildung veranschaulicht dieses Konzept. ``` SELECT c.name.given, c.name.family, (SELECT COUNT(*) FROM c.orders o) AS ordercount FROM spectrum.customers c; ``` Die folgenden Daten werden zurückgegeben. ``` given | family | ordercount --------|----------|-------------- Jenny | Doe | 0 John | Smith | 2 Andy | Jones | 1 (3 rows) ``` **Anmerkung** Wenn Sie verschachtelte Daten durch Gruppieren nach der übergeordneten Zeile aggregieren, ist die effizienteste Methode dafür die, die im vorherigen Beispiel veranschaulicht wird. Im diesem Beispiel werden die verschachtelten `c.orders`-Zeilen nach der ihnen übergeordneten Zeile `c` gruppiert. Wenn Ihnen bekannt ist, dass `id` für jeden `customer`-Eintrag eindeutig und jeder `o.shipdate`-Eintrag niemals null ist, können Sie alternativ dazu wie im folgenden Beispiel gezeigt aggregieren. Dieser Ansatz ist in der Regel jedoch nicht so effizient wie das vorherige Beispiel. ``` SELECT c.name.given, c.name.family, COUNT(o.shipdate) AS ordercount FROM spectrum.customers c LEFT JOIN c.orders o ON true GROUP BY c.id, c.name.given, c.name.family; ``` Sie können die Abfrage auch mit einer Unterabfrage in der `FROM`-Klausel schreiben, die sich auf einen Alias (`c`) der Vorgängerabfrage bezieht und Array-Daten extrahiert. Das folgende Beispiel illustriert diese Herangehensweise. ``` SELECT c.name.given, c.name.family, s.count AS ordercount FROM spectrum.customers c, (SELECT count(*) AS count FROM c.orders o) s; ``` ## Verknüpfen von Amazon Redshift und verschachtelten Daten Sie können Amazon-Redshift-Daten auch mit verschachtelten Daten in einer externen Tabelle verknüpfen. Angenommen, Sie haben die folgenden verschachtelten Daten in Amazon S3. ``` CREATE EXTERNAL TABLE spectrum.customers2 ( id int, name struct, phones array, orders array> ); ``` Nehmen wir außerdem an, Sie haben die folgende Tabelle in Amazon Redshift. ``` CREATE TABLE prices ( id int, price double precision ); ``` Die folgende Abfrage findet basierend auf dem Vorangehenden die Gesamtzahl und Gesamtmenge der Käufe eines jeden Kundens. Das folgende Beispiel dient nur zur Veranschaulichung. Es gibt nur Daten zurück, wenn Sie die Tabellen wie zuvor beschrieben erstellt haben. ``` SELECT c.name.given, c.name.family, COUNT(o.date) AS ordercount, SUM(p.price) AS ordersum FROM spectrum.customers2 c, c.orders o, prices p ON o.item = p.id GROUP BY c.id, c.name.given, c.name.family; ``` # Einschränkungen bei verschachtelten Daten (Vorschau) In diesem Thema werden Einschränkungen beim Lesen verschachtelter Daten mit Redshift Spectrum beschrieben. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte. **Anmerkung** Die in der folgenden Liste mit (Vorschau) gekennzeichneten Einschränkungen gelten nur für Vorschau-Cluster, die in den folgenden Regionen erstellt wurden. USA Ost (Ohio): (us-east-2) USA Ost (Nord-Virginia): (us-east-1) USA West (Nordkalifornien) (us-west-1) Asien-Pazifik (Tokyo) (ap-northeast-1) Europa (Irland) (eu-west-1) Europa (Stockholm) (eu-north-1) Weitere Informationen zum Einrichten von Vorschau-Clustern finden Sie unter [Erstellen eines Vorschau-Clusters](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#cluster-preview) im *Amazon-Redshift-Verwaltungshandbuch*. Die folgenden Einschränkungen gelten für verschachtelte Daten: + Ein `array`- oder `map`-Typ kann andere `array`- oder `map`-Typen enthalten, sofern Abfragen für die verschachtelten `arrays` oder `maps` keine `scalar`-Werte zurückgeben. (Vorschau) + Amazon Redshift Spectrum unterstützt komplexe Datentypen nur als externe Tabellen. + Die Ergebnisspalten der Unterabfrage müssen sich auf oberster Ebene befinden. (Vorschau) + Wenn sich ein `OUTER JOIN`-Ausdruck auf eine verschachtelte Tabelle bezieht, darf er sich nur auf die betreffende Tabelle und ihre verschachtelten Arrays (und Zuordnungen) beziehen. Wenn sich ein `OUTER JOIN`-Ausdruck nicht auf eine verschachtelte Tabelle bezieht, kann er sich auf eine beliebige Anzahl nicht verschachtelter Tabellen beziehen. + Wenn sich eine `FROM`-Klausel in einer Unterabfrage auf eine verschachtelte Tabelle bezieht, darf sie sich auf keine andere Tabelle beziehen. + Wenn eine Unterabfrage von einer verschachtelten Tabelle abhängig ist, die sich auf eine übergeordnete Tabelle bezieht, kann die Unterabfrage die übergeordnete Tabelle nur in der `FROM`-Klausel verwenden. Sie können die übergeordnete Tabelle in keiner anderen Klausel, wie z. B. einer `SELECT`- oder `WHERE`-Klausel, verwenden. Die folgende Abfrage wird beispielsweise nicht ausgeführt, da sich die `SELECT`-Klausel der Unterabfrage auf die übergeordnete Tabelle `c` bezieht. ``` SELECT c.name.given FROM spectrum.customers c WHERE (SELECT COUNT(c.id) FROM c.phones p WHERE p LIKE '858%') > 1; ``` Die folgende Abfrage funktioniert, da die übergeordnete Tabelle `c` nur in der `FROM`-Klausel der Unterabfrage verwendet wird. ``` SELECT c.name.given FROM spectrum.customers c WHERE (SELECT COUNT(*) FROM c.phones p WHERE p LIKE '858%') > 1; ``` + Eine Unterabfrage, die an anderer Stelle als die `FROM`-Klausel auf verschachtelte Daten zugreift, muss einen einzelnen Wert zurückgeben. Die einzigen Ausnahmen sind `(NOT) EXISTS`-Operatoren in einer `WHERE`-Klausel. + `(NOT) IN` wird nicht unterstützt. + Die maximale Verschachtelungstiefe aller verschachtelter Typen ist 100. Diese Einschränkung gilt für alle Dateiformate (Parquet, ORC, Ion und JSON). + Aggregations-Unterabfragen, die auf verschachtelte Daten zugreifen, dürfen nur auf `arrays` und `maps` in ihrer `FROM`-Klausel verweisen, nicht auf eine externe Tabelle. + Das Abfragen der Pseudospalten verschachtelter Daten in einer Redshift-Spectrum-Tabelle wird nicht unterstützt. Weitere Informationen finden Sie unter [Pseudospalten](c-spectrum-external-tables.md#c-spectrum-external-tables-pseudocolumns). + Wenn Sie Daten aus Array- oder Map-Spalten extrahieren, indem Sie diese in einer `FROM`-Klausel angeben, können Sie nur Werte aus diesen Spalten auswählen, wenn es sich um `scalar`-Werte handelt. Die folgenden Abfragen versuchen beispielsweise beide, Elemente aus einem Array auszuwählen (`SELECT`). Die Abfrage, die `arr.a` auswählt, funktioniert, da es sich bei `arr.a` um einen `scalar`-Wert handelt. Die zweite Abfrage funktioniert nicht, da `array` ein Array ist, das in der `FROM`-Klausel aus `s3.nested table` extrahiert wurde. (Vorschau) ``` SELECT array_column FROM s3.nested_table; array_column ----------------- [{"a":1},{"b":2}] SELECT arr.a FROM s3.nested_table t, t.array_column arr; arr.a ----- 1 --This query fails to run. SELECT array FROM s3.nested_table tab, tab.array_column array; ``` Sie können in der `FROM`-Klausel keine Arrays oder Maps verwenden, die selbst aus anderen Arrays oder Maps stammen. Um Arrays oder andere komplexe Strukturen auszuwählen, die in anderen Arrays verschachtelt sind, könnten Sie Indizes in der `SELECT`-Anweisung verwenden. # Serialisieren komplexer verschachtelter JSON-Datentypen In diesem Thema wird gezeigt, wie verschachtelte Daten im JSON-Format serialisiert werden. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte. Eine Alternative zu den in diesem Tutorial demonstrierten Methoden besteht darin, verschachtelte Sammlungsspalten der obersten Ebene als serialisierten JSON-Datentyp abzufragen. Sie können die Serialisierung verwenden, um verschachtelte Daten als JSON mit Redshift Spectrum zu untersuchen, zu konvertieren und aufzunehmen. Diese Methode wird für ORC-, JSON-, Ion- und Parquet-Formate unterstützt. Verwenden Sie den Sitzungskonfigurationsparameter `json_serialization_enable`, um das Serialisierungsverhalten zu konfigurieren. Wenn diese Einstellung festgelegt ist, werden komplexe JSON-Datentypen in VARCHAR(65535) serialisiert. Auf den verschachtelten JSON-Datentyp kann mit [JSON-Funktionen](json-functions.md) zugegriffen werden. Weitere Informationen finden Sie unter [json\$1serialization\$1enable](r_json_serialization_enable.md). Beispiel: Ohne die Einstellung von `json_serialization_enable` schlagen die folgenden Abfragen, die auf verschachtelte Spalten direkt zugreifen, fehl. ``` SELECT * FROM spectrum.customers LIMIT 1; => ERROR: Nested tables do not support '*' in the SELECT clause. SELECT name FROM spectrum.customers LIMIT 1; => ERROR: column "name" does not exist in customers ``` Das Einstellen von `json_serialization_enable` ermöglicht das direkte Abfragen von Sammlungen der obersten Ebene. ``` SET json_serialization_enable TO true; SELECT * FROM spectrum.customers order by id LIMIT 1; id | name | phones | orders ---+--------------------------------------+----------------+---------------------------------------------------------------------------------------------------------------------- 1 | {"given": "John", "family": "Smith"} | ["123-457789"] | [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}] SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": "John", "family": "Smith"} ``` Beachten Sie die folgenden Elemente, wenn Sie verschachtelte JSON-Datentypen serialisieren. + Wenn Sammlungsspalten als VARCHAR(65535) serialisiert werden, kann auf ihre verschachtelten Unterfelder nicht direkt als Teil der Abfragesyntax zugegriffen werden (z. B. in der Filter-Klausel). JSON-Funktionen können jedoch für den Zugriff auf verschachtelte JSON-Datentypen verwendet werden. + Die folgenden spezialisierten Darstellungen werden nicht unterstützt: + ORC-Vereinigungen + ORC-Zuordnungen mit komplexen Typenschlüsseln + Ion-Datagramme + Ion SEXP + Zeitstempel werden als serialisierte ISO-Zeichenfolgen zurückgegeben. + Primitive Zuordnungsschlüssel werden zu einer Zeichenfolge heraufgestuft (z. B. `1` zu `"1"`). + Nullwerte der obersten Ebene werden als serialisiert. NULLs + Wenn die Serialisierung die maximale VARCHAR-Größe von 65535 übersteigt, wird die Zelle auf NULL gesetzt. ## Serialisieren komplexer Typen, die JSON-Zeichenfolgen enthalten Standardmäßig werden Zeichenfolgenwerte, die in verschachtelten Sammlungen enthalten sind, als Escape-JSON-Zeichenfolgen serialisiert. Escaping kann unerwünscht sein, wenn die Zeichenfolgen gültige JSON-Ausdrücke sind. Stattdessen sollten Sie verschachtelte VARCHAR-serialisierte Unterelemente oder Felder direkt als JSON schreiben. Aktivieren Sie dieses Verhalten mit der Konfiguration `json_serialization_parse_nested_strings` auf Sitzungsebene. Wenn `json_serialization_enable` und `json_serialization_parse_nested_strings` eingestellt sind, werden gültige JSON-Werte inline ohne Escape-Zeichen serialisiert. Wenn der Wert kein gültiger JSON-Ausdruck ist, wird er escaped, als ob der `json_serialization_parse_nested_strings`-Konfigurationswert nicht festgelegt wäre. Weitere Informationen finden Sie unter [json\$1serialization\$1parse\$1nested\$1strings](r_json_serialization_parse_nested_strings.md). Angenommen, die Daten aus dem vorherigen Beispiel enthielten JSON als komplexen `structs`-Typ in im VARCHAR(20)-Feld `name`: ``` name --------- {"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"} ``` Wenn `json_serialization_parse_nested_strings` eingestellt ist, wird die Spalte `name` wie folgt serialisiert: ``` SET json_serialization_enable TO true; SET json_serialization_parse_nested_strings TO true; SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": {"first":"John","middle":"James"}, "family": "Smith"} ``` Anstatt wie folgt escaped zu werden: ``` SET json_serialization_enable TO true; SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"} ```