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. # JSON-Funktionen **Topics** + [Funktion JSON\$1PARSE](JSON_PARSE.md) + [Funktion CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md) + [Funktion JSON\$1SERIALISE](JSON_SERIALIZE.md) + [Funktion JSON\$1SERIALIZE\$1TO\$1VARBYTE](JSON_SERIALIZE_TO_VARBYTE.md) + [Textbasierte JSON-Funktionen](text-json-functions.md) **Anmerkung** Wir empfehlen die Verwendung der folgenden Funktionen für die Arbeit mit JSON: [Funktion JSON\$1PARSE](JSON_PARSE.md) [Funktion CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md) [Funktion JSON\$1SERIALISE](JSON_SERIALIZE.md) [Funktion JSON\$1SERIALIZE\$1TO\$1VARBYTE](JSON_SERIALIZE_TO_VARBYTE.md) Mit JSON\$1PARSE müssen Sie JSON-Text nur einmal bei der Aufnahme in einen Wert des Typs SUPER konvertieren. Danach können Sie mit den SUPER-Werten arbeiten. Amazon Redshift analysiert SUPER-Werte effizienter als VARCHAR, die Ausgabe für die textbasierten JSON-Funktionen. Weitere Informationen zum Arbeiten mit dem Datentyp SUPER finden Sie unter [Halbstrukturierte Daten in Amazon Redshift](super-overview.md). Wenn Sie einen vergleichsweise kleinen Satz von Schlüssel-Wert-Paaren speichern müssen, können Sie vielleicht Platz sparen, indem Sie die Daten im JSON-Format speichern. Da JSON-Zeichenfolgen in einer einzigen Spalte gespeichert werden können, kann die Verwendung von JSON effizienter als das Speichern Ihrer Daten im Tabellenformat sein. Angenommen, Sie haben eine Sparse-Tabelle, in der zahlreiche Spalten alle möglichen Attribute vollständig darstellen müssen, die meisten Spaltenwerte für eine bestimmte Zeile oder Spalte jedoch NULL sind. Wenn Sie zum Speichern JSON verwenden, können Sie die Daten für eine Zeile in Schlüssel:Wert-Paaren ein einer einzelnen JSON-Zeichenfolge speichern und die kaum ausgefüllten Tabellenspalten beseitigen. Zusätzlich können Sie JSON-Zeichenfolgen leicht ändern, so dass diese weitere Schlüssel:Wert-Paare speichern, ohne einer Tabelle Spalten hinzufügen zu müssen. Sie sollten JSON nur in bestimmten Fällen verwenden. JSON ist keine gute Wahl, wenn es um das Speichern größerer Datensätze geht, da JSON aufgrund der Tatsache, dass disparate Daten in einer einzigen Spalte gespeichert werden, die Spaltenspeicherarchitektur von Amazon Redshift nicht nutzt. Obwohl Amazon Redshift JSON-Funktionen über CHAR- und VARCHAR-Spalten unterstützt, empfehlen wir, SUPER für die Verarbeitung von Daten im JSON-Serialisierungsformat zu verwenden. SUPER verwendet eine schemalose Post-Parse-Darstellung, die hierarchische Daten effizient abfragen kann. Weitere Informationen zum SUPER-Datentyp finden Sie unter [Halbstrukturierte Daten in Amazon Redshift](super-overview.md). JSON verwendet UTF-8-kodierte Textzeichenfolgen. Daher können JSON-Zeichenfolgen als CHAR- oder VARCHAR-Datentypen gespeichert werden. JSON-Zeichenfolgen müssen ein korrektes JSON-Format aufweisen, das den folgenden Regeln entspricht: + Der JSON-Wert kann auf Stammverzeichnisebene ein JSON-Objekt oder ein JSON-Array sein. Ein JSON-Objekt ist ein nicht geordneter Satz von durch Komma getrennten Schlüssel:Wert-Paaren, eingeschlossen in geschweiften Klammern. Beispiel: `{"one":1, "two":2} ` + Ein JSON-Array ist ein geordneter Satz von durch Komma getrennten Werten, eingeschlossen in eckigen Klammern. Ein Beispiel ist folgendes: `["first", {"one":1}, "second", 3, null] ` + JSON-Arrays verwenden einen nullbasierten Index. Das erste Element in einem Array befindet sich an Position 0. In einem Schlüssel:Wert-Paar in JSON ist der Schlüssel eine Zeichenfolge in doppelten Anführungszeichen. + Ein JSON-Wert kann jeder der folgenden Werte sein: + JSON-Objekt + Array + Zeichenfolge + Mit doppelten Anführungszeichen dargestellt + number + Beinhaltet Ganzzahlen, Dezimalzahlen und Gleitkommazahlen + Boolesch + Null + Leere Objekte und leere Arrays sind gültige JSON-Werte. + JSON-Felder unterscheiden zwischen Groß- und Kleinschreibung. + Leerzeichen zwischen JSON-Strukturelementen (wie `{ }, [ ]`) werden ignoriert. Die Amazon-Redshift-JSON-Funktionen und der Amazon-Redshift-COPY-Befehl verwenden dieselben Methoden, um mit Daten im JSON-Format zu arbeiten. Weitere Informationen zur Arbeit mit JSON finden Sie unter . [COPY von JSON-Format](copy-usage_notes-copy-from-json.md) # Funktion JSON\$1PARSE Die Funktion JSON\$1PARSE analysiert Daten im JSON-Format und konvertiert sie in die `SUPER`-Darstellung. Verwenden Sie die JSON\$1PARSE-Funktion, um mit dem Befehl INSERT oder UPDATE in den `SUPER`-Datentyp aufzunehmen. Wenn Sie JSON\$1PARSE() zum Parsing von JSON-Zeichenfolgen in `SUPER`-Werte verwenden, gelten bestimmte Einschränkungen. Weitere Informationen finden Sie unter [Parsing-Optionen für SUPER](super-configurations.md#parsing-options-super). ## Syntax ``` JSON_PARSE( {json_string | binary_value} ) ``` ## Argumente *json\$1string* Ein Ausdruck, der eine serialisierte JSON-Zeichenfolge als Datentyp `VARBYTE` oder `VARCHAR` zurückgibt. *binary\$1value* Ein Binärwert des Datentyps VARBYTE. ## Rückgabetyp `SUPER` ## Beispiele Verwenden Sie das folgende Beispiel, um das JSON-Array `[10001,10002,"abc"]` in den Datentyp `SUPER` zu konvertieren. ``` SELECT JSON_PARSE('[10001,10002,"abc"]'); +---------------------+ | json_parse | +---------------------+ | [10001,10002,"abc"] | +---------------------+ ``` Verwenden Sie das folgende Beispiel, um sicherzustellen, dass die Funktion das JSON-Array in den Datentyp `SUPER` konvertiert hat. Weitere Informationen finden Sie unter [Die Funktion JSON\$1TYPEOF](r_json_typeof.md). ``` SELECT JSON_TYPEOF(JSON_PARSE('[10001,10002,"abc"]')); +-------------+ | json_typeof | +-------------+ | array | +-------------+ ``` # Funktion CAN\$1JSON\$1PARSE Die Funktion CAN\$1JSON\$1PARSE analysiert Daten im JSON-Format und gibt `true` zurück, wenn das Ergebnis mithilfe der Funktion JSON\$1PARSE in einen `SUPER`-Wert konvertiert werden kann. ## Syntax ``` CAN_JSON_PARSE( {json_string | binary_value} ) ``` ## Argumente *json\$1string* Ein Ausdruck, der serialisierte JSON-Datentypen im `VARCHAR`-Format zurückgibt. *binary\$1value* Ein Binärwert des Datentyps VARBYTE. ## Rückgabetyp `BOOLEAN` ## Nutzungshinweise + CAN\$1JSON\$1PARSE gibt für leere Zeichenketten „false“ zurück. Gibt NULL zurück, wenn das Eingabeargument null ist. ## Beispiele Das folgende Beispiel zeigt, wie CAN\$1JSON\$1PARSE auf einem korrekt formatierten JSON-Array unter Verwendung einer CASE-Bedingung ausgeführt wird. Es gibt „true“ zurück, so dass Amazon Redshift die Funktion JSON\$1PARSE für den Beispielwert ausführt. ``` SELECT CASE WHEN CAN_JSON_PARSE('[10001,10002,"abc"]') THEN JSON_PARSE('[10001,10002,"abc"]') END; case --------------------- '[10001,10002,"abc"]' ``` Das folgende Beispiel zeigt, wie CAN\$1JSON\$1PARSE unter Verwendung einer CASE-Bedingung auf einem Wert ausgeführt wird, der nicht das JSON-Format hart. Es gibt „false“ zurück, so dass Amazon Redshift stattdessen das Segment in der ELSE-Klausel der CASE-Bedingung zurückgibt. ``` SELECT CASE WHEN CAN_JSON_PARSE('This is a string.') THEN JSON_PARSE('This is a string.') ELSE 'This is not JSON.' END; case --------------------- "This is not JSON." ``` # Funktion JSON\$1SERIALISE Die Funktion JSON\$1SERIALISE serialisiert einen `SUPER`-Ausdruck in eine textbasierte JSON-Darstellung gemäß RFC 8259. Weitere Informationen zu diesem RFC finden Sie unter [The JavaScript Object Notation (](https://tools.ietf.org/html/rfc8259)JSON) Data Interchange Format. Das `SUPER`-Größenlimit entspricht ungefähr dem Blocklimit, und das `VARCHAR`-Limit ist kleiner als das `SUPER`-Größenlimit. Daher gibt die Funktion JSON\$1SERIALISE einen Fehler zurück, wenn das JSON-Format das VARCHAR-Limit des Systems überschreitet. Wenn Sie die Größe eines `SUPER`-Ausdrucks überprüfen möchten, sehen Sie sich die Funktion [JSON\$1SIZE](r_json_size.md) an. ## Syntax ``` JSON_SERIALIZE(super_expression) ``` ## Argumente *super\$1expression* Ein `SUPER`-Ausdruck oder eine Spalte. ## Rückgabetyp `VARCHAR` **Anmerkung** Der zurückgegebene VARCHAR-Wert ist immer eine JSON-Zeichenfolge ungleich Null. Wenn *super\$1expression* NULL ist, gibt JSON\$1SERIALIZE die JSON-Zeichenfolge `'null'` zurück. ## Beispiele Verwenden Sie das folgende Beispiel, um den `SUPER`-Wert einer Zeichenfolge zu serialisieren. ``` SELECT JSON_SERIALIZE(JSON_PARSE('[10001,10002,"abc"]')); +---------------------+ | json_serialize | +---------------------+ | [10001,10002,"abc"] | +---------------------+ ``` # Funktion JSON\$1SERIALIZE\$1TO\$1VARBYTE Die Funktion JSON\$1SERIALIZE\$1TO\$1VARBYTE konvertiert einen `SUPER`-Wert in eine ähnliche JSON-Zeichenfolge wie bei JSON\$1SERIALIZE(), jedoch in einem `VARBYTE`-Wert gespeichert. ## Syntax ``` JSON_SERIALIZE_TO_VARBYTE(super_expression) ``` ## Argumente *super\$1expression* Ein `SUPER`-Ausdruck oder eine Spalte. ## Rückgabetyp `VARBYTE` ## Beispiele Verwenden Sie das folgende Beispiel, um einen `SUPER`-Wert zu serialisieren und das Ergebnis im `VARBYTE`-Format zurückzugeben. ``` SELECT JSON_SERIALIZE_TO_VARBYTE(JSON_PARSE('[10001,10002,"abc"]')); +----------------------------------------+ | json_serialize_to_varbyte | +----------------------------------------+ | 5b31303030312c31303030322c22616263225d | +----------------------------------------+ ``` Verwenden Sie das folgende Beispiel, um einen `SUPER`-Wert zu serialisieren und das Ergebnis im `VARCHAR`-Format zu übertragen. Weitere Informationen finden Sie unter [CAST-Funktion](r_CAST_function.md). ``` SELECT CAST((JSON_SERIALIZE_TO_VARBYTE(JSON_PARSE('[10001,10002,"abc"]'))) AS VARCHAR); +---------------------------+ | json_serialize_to_varbyte | +---------------------------+ | [10001,10002,"abc"] | +---------------------------+ ``` # Textbasierte JSON-Funktionen Die Funktionen in diesem Abschnitt analysieren JSON-Werte als VARCHAR. Für die Analyse von JSON empfehlen wir Ihnen, stattdessen die folgenden Funktionen zu verwenden, die JSON-Werte als SUPER analysieren. Amazon Redshift analysiert SUPER-Werte effizienter als VARCHAR. + [Funktion JSON\$1PARSE](JSON_PARSE.md) + [Funktion CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md) + [Funktion JSON\$1SERIALISE](JSON_SERIALIZE.md) + [Funktion JSON\$1SERIALIZE\$1TO\$1VARBYTE](JSON_SERIALIZE_TO_VARBYTE.md) **Topics** + [Die Funktion IS\$1VALID\$1JSON](IS_VALID_JSON.md) + [Die Funktion IS\$1VALID\$1JSON\$1ARRAY](IS_VALID_JSON_ARRAY.md) + [Die Funktion JSON\$1ARRAY\$1LENGTH](JSON_ARRAY_LENGTH.md) + [Die Funktion „JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT“](JSON_EXTRACT_ARRAY_ELEMENT_TEXT.md) + [Die Funktion JSON\$1EXTRACT\$1PATH\$1TEXT](JSON_EXTRACT_PATH_TEXT.md) # Die Funktion IS\$1VALID\$1JSON **Anmerkung** CAN\$1JSON\$1PARSE und die zugehörigen Funktionen analysieren JSON-Werte als SUPER, was Amazon Redshift effizienter analysiert als VARCHAR. Anstatt IS\$1VALID\$1JSON zu verwenden, empfehlen wir Ihnen, Ihre JSON-Zeichenketten mit [Funktion CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md) zu validieren. Die IS\$1VALID\$1JSON-Funktion validiert eine JSON-Zeichenfolge. Die Funktion gibt den Booleschen Wert `true` zurück, wenn die Zeichenfolge eine korrekte JSON-Formatierung aufweist, oder `false`, wenn die Formatierung falsch ist. Verwenden Sie , um ein JSON-Array zu validieren. [Die Funktion IS\$1VALID\$1JSON\$1ARRAY](IS_VALID_JSON_ARRAY.md) Weitere Informationen finden Sie unter [JSON-Funktionen](json-functions.md). ## Syntax ``` IS_VALID_JSON('json_string') ``` ## Argumente *json\$1string* Eine Zeichenfolge oder ein Ausdruck, die/der zu einer JSON-Zeichenfolge ausgewertet wird. ## Rückgabetyp `BOOLEAN` ## Beispiele Verwenden Sie das folgende Beispiel, um eine Tabelle zu erstellen und JSON-Zeichenfolgen zum Testen einzufügen. ``` CREATE TABLE test_json(id int IDENTITY(0,1), json_strings VARCHAR); -- Insert valid JSON strings -- INSERT INTO test_json(json_strings) VALUES ('{"a":2}'), ('{"a":{"b":{"c":1}}}'), ('{"a": [1,2,"b"]}'); -- Insert invalid JSON strings -- INSERT INTO test_json(json_strings) VALUES ('{{}}'), ('{1:"a"}'), ('[1,2,3]'); ``` Verwenden Sie das folgende Beispiel, um die Zeichenfolgen des vorherigen Beispiels zu validieren. ``` SELECT id, json_strings, IS_VALID_JSON(json_strings) FROM test_json ORDER BY id; +----+---------------------+---------------+ | id | json_strings | is_valid_json | +----+---------------------+---------------+ | 0 | {"a":2} | true | | 4 | {"a":{"b":{"c":1}}} | true | | 8 | {"a": [1,2,"b"]} | true | | 12 | {{}} | false | | 16 | {1:"a"} | false | | 20 | [1,2,3] | false | +----+---------------------+---------------+ ``` # Die Funktion IS\$1VALID\$1JSON\$1ARRAY **Anmerkung** JSON\$1PARSE und die zugehörigen Funktionen analysieren JSON-Werte als SUPER, was Amazon Redshift effizienter analysiert als VARCHAR. Anstatt IS\$1VALID\$1JSON\$1ARRAY zu verwenden, empfehlen wir Ihnen, Ihre JSON-Zeichenketten mit [Funktion JSON\$1PARSE](JSON_PARSE.md) zu analysieren, um einen SUPER-Wert zu erhalten. Verwenden Sie dann die [Die Funktion IS\$1ARRAY](r_is_array.md)-Funktion, um zu überprüfen, ob das Array korrekt formatiert ist. Die IS\$1VALID\$1JSON\$1ARRAY-Funktion validiert ein JSON-Array. Die Funktion gibt den Booleschen Wert `true` zurück, wenn das Array eine korrekte JSON-Formatierung aufweist, oder `false`, wenn die Formatierung falsch ist. Verwenden Sie , um eine JSON-Zeichenfolge zu validieren. [Die Funktion IS\$1VALID\$1JSON](IS_VALID_JSON.md) Weitere Informationen finden Sie unter [JSON-Funktionen](json-functions.md). ## Syntax ``` IS_VALID_JSON_ARRAY('json_array') ``` ## Argumente *json\$1array* Eine Zeichenfolge oder ein Ausdruck, die/der zu einem JSON-Array ausgewertet wird. ## Rückgabetyp `BOOLEAN` ## Beispiele Verwenden Sie das folgende Beispiel, um eine Tabelle zu erstellen und JSON-Zeichenfolgen zum Testen einzufügen. ``` CREATE TABLE test_json_arrays(id int IDENTITY(0,1), json_arrays VARCHAR); -- Insert valid JSON array strings -- INSERT INTO test_json_arrays(json_arrays) VALUES('[]'), ('["a","b"]'), ('["a",["b",1,["c",2,3,null]]]'); -- Insert invalid JSON array strings -- INSERT INTO test_json_arrays(json_arrays) VALUES('{"a":1}'), ('a'), ('[1,2,]'); ``` Verwenden Sie das folgende Beispiel, um die Zeichenfolgen des vorherigen Beispiels zu validieren. ``` SELECT json_arrays, IS_VALID_JSON_ARRAY(json_arrays) FROM test_json_arrays ORDER BY id; +------------------------------+---------------------+ | json_arrays | is_valid_json_array | +------------------------------+---------------------+ | [] | true | | ["a","b"] | true | | ["a",["b",1,["c",2,3,null]]] | true | | {"a":1} | false | | a | false | | [1,2,] | false | +------------------------------+---------------------+ ``` # Die Funktion JSON\$1ARRAY\$1LENGTH **Anmerkung** JSON\$1PARSE und die zugehörigen Funktionen analysieren JSON-Werte als SUPER, was Amazon Redshift effizienter analysiert als VARCHAR. Anstatt JSON\$1ARRAY\$1LENGTH zu verwenden, empfehlen wir Ihnen, Ihre JSON-Zeichenketten mit [Funktion JSON\$1PARSE](JSON_PARSE.md) zu analysieren, um einen SUPER-Wert zu erhalten. Verwenden Sie dann [Funktion GET\$1ARRAY\$1LENGTH](get_array_length.md), um die Länge Ihres Arrays zu ermitteln. Die Funktion JSON\$1ARRAY\$1LENGTH gibt die Anzahl von Elementen im äußeren Array einer JSON-Zeichenfolge zurück. Wenn das Argument *null\$1if\$1invalid* auf `true` gesetzt und die JSON-Zeichenfolge ungültig ist, gibt die Funktion anstatt eines Fehlers `NULL` zurück. Weitere Informationen finden Sie unter [JSON-Funktionen](json-functions.md). ## Syntax ``` JSON_ARRAY_LENGTH('json_array' [, null_if_invalid ] ) ``` ## Argumente *json\$1array* Ein korrekt formatiertes JSON-Array. *null\$1if\$1invalid* (Optional) Ein `BOOLEAN`-Wert, der angibt, ob anstatt eines Fehlers `NULL` zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Geben Sie `true` (`t`) an, damit `NULL` zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Geben Sie `false` (`f`) an, damit ein Fehler zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Der Standardwert ist `false`. ## Rückgabetyp `INTEGER` ## Beispiele Verwenden Sie das folgende Beispiel, um die Anzahl der Elemente im Array zurückzugeben. ``` SELECT JSON_ARRAY_LENGTH('[11,12,13,{"f1":21,"f2":[25,26]},14]'); +-------------------+ | json_array_length | +-------------------+ | 5 | +-------------------+ ``` Verwenden Sie das folgende Beispiel, um einen Fehler zurückzugeben, weil die JSON-Eingabezeichenfolge ungültig ist. ``` SELECT JSON_ARRAY_LENGTH('[11,12,13,{"f1":21,"f2":[25,26]},14'); ERROR: invalid json array object [11,12,13,{"f1":21,"f2":[25,26]},14 ``` Verwenden Sie das folgende Beispiel, um *null\$1if\$1invalid* auf *true* zu setzen, sodass die Anweisung anstatt eines Fehlers `NULL` zurückgibt, wenn die JSON-Eingabezeichenfolge ungültig ist. ``` SELECT JSON_ARRAY_LENGTH('[11,12,13,{"f1":21,"f2":[25,26]},14',true); +-------------------+ | json_array_length | +-------------------+ | NULL | +-------------------+ ``` # Die Funktion „JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT“ **Anmerkung** JSON\$1PARSE und die zugehörigen Funktionen analysieren JSON-Werte als SUPER, was Amazon Redshift effizienter analysiert als VARCHAR. Anstatt JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT zu verwenden, empfehlen wir Ihnen, Ihre JSON-Zeichenketten mit [Funktion JSON\$1PARSE](JSON_PARSE.md) zu analysieren, um einen SUPER-Wert zu erhalten. Fragen Sie dann das gewünschte Element anhand seines Array-Index ab und verwenden Sie dabei die `value[element position]` Syntax. Weitere Informationen zum Abfragen von Array-Elementen in SUPER-Werten finden Sie unter [Abfragen halbstrukturierter Daten](query-super.md). Die Funktion JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT gibt ein JSON-Array-Element im äußersten Array einer JSON-Zeichenfolge unter Verwendung eines nullbasierten Index zurück. Das erste Element in einem Array befindet sich an Position 0. Wenn der Index negativ ist oder sich außerhalb des Bereichs befindet, gibt JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT `NULL` zurück. Wenn das Argument *null\$1if\$1invalid* auf `TRUE` gesetzt und die JSON-Zeichenfolge ungültig ist, gibt die Funktion anstatt eines Fehlers `NULL` zurück. Weitere Informationen finden Sie unter [JSON-Funktionen](json-functions.md). ## Syntax ``` JSON_EXTRACT_ARRAY_ELEMENT_TEXT('json string', pos [, null_if_invalid ] ) ``` ## Argumente *json\$1string* Eine korrekt formatierte JSON-Zeichenfolge. *pos* Eine `INTEGER`, die unter Verwendung eines nullbasierten Array-Index den Index des Array-Elements darstellt, das zurückgegeben werden soll. *null\$1if\$1invalid* (Optional) Ein `BOOLEAN`-Wert, der angibt, ob anstatt eines Fehlers `NULL` zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Geben Sie `true` (`t`) an, damit `NULL` zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Geben Sie `false` (`f`) an, damit ein Fehler zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Der Standardwert ist `false`. ## Rückgabetyp `VARCHAR` Eine `VARCHAR`-Zeichenfolge, die das JSON-Array-Element darstellt, das von *pos* referenziert wird. ## Beispiele Verwenden Sie das folgende Beispiel, um ein Array-Element an Position 2 zurückzugeben, das das dritte Element eines null-basierten Array-Index ist. ``` SELECT JSON_EXTRACT_ARRAY_ELEMENT_TEXT('[111,112,113]', 2); +---------------------------------+ | json_extract_array_element_text | +---------------------------------+ | 113 | +---------------------------------+ ``` Verwenden Sie das folgende Beispiel, um einen Fehler zurückzugeben, weil die JSON-Eingabezeichenfolge ungültig ist. ``` SELECT JSON_EXTRACT_ARRAY_ELEMENT_TEXT('["a",["b",1,["c",2,3,null,]]]',1); ERROR: invalid json array object ["a",["b",1,["c",2,3,null,]]] ``` Verwenden Sie das folgende Beispiel, um *null\$1if\$1invalid* auf *true* zu setzen, sodass die Anweisung anstatt eines Fehlers `NULL` zurückgibt, wenn die JSON-Eingabezeichenfolge ungültig ist. ``` SELECT JSON_EXTRACT_ARRAY_ELEMENT_TEXT('["a",["b",1,["c",2,3,null,]]]',1,true); +---------------------------------+ | json_extract_array_element_text | +---------------------------------+ | NULL | +---------------------------------+ ``` Betrachten Sie die folgenden Beispiele: Wenn die bereitgestellte JSON-Zeichenfolge oder der Index NULL ist, gibt JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT NULL zurück, unabhängig vom Wert anderer Parameter. ``` --Statement where json_string is NULL. SELECT json_extract_array_element_text(NULL, 0) json_extract_array_element_text --------------------------------- NULL --Statement where pos is NULL and json_string is invalid JSON. SELECT json_extract_array_element_text('invalid_json', NULL); json_extract_array_element_text --------------------------------- NULL --Statement where json_string is NULL and null_if_invalid is FALSE. SELECT json_extract_array_element_text(NULL, 0, FALSE); json_extract_array_element_text --------------------------------- NULL ``` Betrachten Sie die folgenden Beispiele: Wenn *null\$1if\$1invalid* TRUE ist, gibt JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT NULL zurück, wenn *json\$1string* ein ungültiges JSON ist. Wenn *null\$1if\$1invalid* FALSE ist oder nicht gesetzt ist, gibt die Funktion einen Fehler zurück, wenn *json\$1string* ungültig ist. ``` --Statement with invalid JSON where null_if_invalid is TRUE. SELECT json_extract_array_element_text('invalid_json', 0, TRUE); json_extract_array_element_text --------------------------------- NULL --Statement with invalid JSON where null_if_invalid is FALSE. SELECT json_extract_array_element_text('invalid_json', 0); ERROR: JSON parsing error ``` Betrachten Sie das folgende Beispiel, in dem *json\$1string* gültiges JSON ist und *pos* auf einen JSON-`null`Wert verweist. In diesem Fall gibt JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT NULL zurück, unabhängig vom Wert von *null\$1if\$1invalid*. ``` --Statement selecting a null value. SELECT json_extract_array_element_text('[null]', 0); json_extract_array_element_text ---------------------------------- NULL ``` # Die Funktion JSON\$1EXTRACT\$1PATH\$1TEXT **Anmerkung** JSON\$1PARSE und die zugehörigen Funktionen analysieren JSON-Werte als SUPER, was Amazon Redshift effizienter analysiert als VARCHAR. Anstatt JSON\$1EXTRACT\$1PATH\$1TEXT zu verwenden, empfehlen wir Ihnen, Ihre JSON-Zeichenketten mit [Funktion JSON\$1PARSE](JSON_PARSE.md) zu analysieren, um einen SUPER-Wert zu erhalten. Fragen Sie dann das gewünschte Element mithilfe der `value.attribute`-Syntax ab. Weitere Informationen zum Abfragen von Array-Elementen in SUPER-Werten finden Sie unter [Abfragen halbstrukturierter Daten](query-super.md). Die Funktion JSON\$1EXTRACT\$1PATH\$1TEXT gibt den Wert für das Schlüssel-Wert-Paar zurück, auf das in einer Reihe von Pfadelementen in einer JSON-Zeichenfolge verwiesen wird. Der JSON-Pfad kann bis zu einer Tiefe von fünf Ebenen verschachtelt sein. Pfadelemente unterscheiden zwischen Groß- und Kleinschreibung. Wenn in der JSON-Zeichenfolge ein Pfadelement nicht vorhanden ist, gibt JSON\$1EXTRACT\$1PATH\$1TEXT `NULL` zurück. Wenn das Argument *null\$1if\$1invalid* auf `TRUE` gesetzt und die JSON-Zeichenfolge ungültig ist, gibt die Funktion anstatt eines Fehlers `NULL` zurück. JSON\$1EXTRACT\$1PATH\$1TEXT hat eine maximale Datengröße von 64 KB. Wenn also ein JSON-Datensatz größer als 64 KB ist, führt die Verarbeitung mit JSON\$1EXTRACT\$1PATH\$1TEXT zu einem Fehler. Informationen zu zusätzlichen JSON-Funktionen finden Sie unter [JSON-Funktionen](json-functions.md). Weitere Informationen zur Arbeit mit JSON finden Sie unter [COPY von JSON-Format](copy-usage_notes-copy-from-json.md). ## Syntax ``` JSON_EXTRACT_PATH_TEXT('json_string', 'path_elem' [,'path_elem'[, …] ] [, null_if_invalid ] ) ``` ## Argumente *json\$1string* Eine korrekt formatierte JSON-Zeichenfolge. *path\$1elem* Ein Pfadelement in einer JSON-Zeichenfolge. Es ist mindestens ein Pfadelement erforderlich. Es können zusätzliche Pfadelemente angegeben werden, bis zu einer Tiefe von fünf Ebenen. *null\$1if\$1invalid* (Optional) Ein `BOOLEAN`-Wert, der angibt, ob anstatt eines Fehlers `NULL` zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Geben Sie `TRUE` (`t`) an, damit `NULL` zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Geben Sie `FALSE` (`f`) an, damit ein Fehler zurückgegeben wird, wenn die JSON-Eingabezeichenfolge ungültig ist. Der Standardwert ist `FALSE`. Amazon Redshift erkennt in einer JSON-Zeichenfolge `\n` als Zeichen für neue Zeilen und `\t` als Tabulatorzeichen. Um einen Backslash zu laden, muss ein Backslash als Escape-Zeichen verwendet werden (`\\`). Weitere Informationen finden Sie unter [Escape-Zeichen in JSON](copy-usage_notes-copy-from-json.md#copy-usage-json-escape-characters). ## Rückgabetyp `VARCHAR` Eine `VARCHAR`-Zeichenfolge, die den JSON-Wert darstellt, der von den Pfadelementen referenziert wird. ## Beispiele Verwenden Sie das folgende Beispiel, um den Wert für den Pfad `'f4', 'f6'` zurückzugeben. ``` SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}','f4', 'f6'); +------------------------+ | json_extract_path_text | +------------------------+ | star | +------------------------+ ``` Verwenden Sie das folgende Beispiel, um einen Fehler zurückzugeben, weil die JSON-Eingabezeichenfolge ungültig ist. ``` SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}','f4', 'f6'); ERROR: invalid json object {"f2":{"f3":1},"f4":{"f5":99,"f6":"star"} ``` Verwenden Sie das folgende Beispiel, um *null\$1if\$1invalid* auf *TRUE* zu setzen, so dass die Anweisung bei einem ungültigen JSON anstatt eines Fehlers `NULL` zurückgibt. ``` SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}','f4', 'f6',true); +------------------------+ | json_extract_path_text | +------------------------+ | NULL | +------------------------+ ``` Betrachten Sie das folgende Beispiel, bei dem den Wert für den Pfad `'farm', 'barn', 'color'` zurückgegeben wird, wobei sich der abgerufene Wert auf der dritten Ebene befindet. Dieses Beispiel ist mit einem JSON-Lint-Tool formatiert, um das Lesen zu vereinfachen. ``` SELECT JSON_EXTRACT_PATH_TEXT('{ "farm": { "barn": { "color": "red", "feed stocked": true } } }', 'farm', 'barn', 'color'); +------------------------+ | json_extract_path_text | +------------------------+ | red | +------------------------+ ``` Verwenden Sie das folgende Beispiel, um `NULL` zurückzugeben, da das `'color'`-Element fehlt. Dieses Beispiel ist mit einem JSON-Lint-Tool formatiert. ``` SELECT JSON_EXTRACT_PATH_TEXT('{ "farm": { "barn": {} } }', 'farm', 'barn', 'color'); +------------------------+ | json_extract_path_text | +------------------------+ | NULL | +------------------------+ ``` Wenn das JSON-Format gültig ist, wird beim Versuch, ein fehlendes Element zu extrahieren, `NULL` zurückgegeben. Verwenden Sie das folgende Beispiel, um den Wert für den Pfad `'house', 'appliances', 'washing machine', 'brand'` zurückzugeben. ``` SELECT JSON_EXTRACT_PATH_TEXT('{ "house": { "address": { "street": "123 Any St.", "city": "Any Town", "state": "FL", "zip": "32830" }, "bathroom": { "color": "green", "shower": true }, "appliances": { "washing machine": { "brand": "Any Brand", "color": "beige" }, "dryer": { "brand": "Any Brand", "color": "white" } } } }', 'house', 'appliances', 'washing machine', 'brand'); +------------------------+ | json_extract_path_text | +------------------------+ | Any Brand | +------------------------+ ``` Im folgenden Beispiel wird eine Beispieltabelle erstellt und mit SUPER-Werten aufgefüllt. Anschließend wird der Wert für den Pfad `'f2'` für beide Zeilen zurückgegeben. ``` CREATE TABLE json_example(id INT, json_text SUPER); INSERT INTO json_example VALUES (1, JSON_PARSE('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}')), (2, JSON_PARSE('{ "farm": { "barn": { "color": "red", "feed stocked": true } } }')); SELECT * FROM json_example; id | json_text ------------+-------------------------------------------- 1 | {"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}} 2 | {"farm":{"barn":{"color":"red","feed stocked":true}}} SELECT id, JSON_EXTRACT_PATH_TEXT(JSON_SERIALIZE(json_text), 'f2') FROM json_example; id | json_text ------------+-------------------------------------------- 1 | {"f3":1} 2 | ``` Betrachten Sie die folgenden Beispiele: Das angegebene *path\$1elem* ist NULL, so dass JSON\$1EXTRACT\$1PATH\$1TEXT unabhängig vom Wert aller anderen Parameter NULL zurückgibt. ``` --Statement where path_elem is NULL and json_string is valid JSON. SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}',NULL); json_extract_path_text ------------------------ NULL --Statement where only one path_elem is NULL. SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}','f4',NULL); json_extract_path_text ------------------------ NULL --Statement where path_elem is NULL and json_string is invalid JSON. SELECT json_extract_path_text('invalid_json', NULL); json_extract_path_text ------------------------ NULL --Statement where path_elem is NULL and null_if_invalid is FALSE. SELECT json_extract_path_text(NULL, 0, FALSE); json_extract_path_text ------------------------ NULL ``` Betrachten Sie die folgenden Beispiele: Wenn *null\$1if\$1invalid* TRUE ist, gibt JSON\$1EXTRACT\$1PATH\$1TEXT NULL zurück, wenn *json\$1string* ein ungültiges JSON ist. Wenn *null\$1if\$1invalid* FALSE ist oder nicht gesetzt ist, gibt die Funktion einen Fehler zurück, wenn *json\$1string* ungültig ist. ``` --Statement with invalid JSON where null_if_invalid is TRUE. SELECT json_extract_path_text('invalid_json', 0, TRUE); json_extract_path_text ------------------------ NULL --Statement with invalid JSON where null_if_invalid is FALSE. SELECT json_extract_path_text('invalid_json', 0, FALSE); ERROR: JSON parsing error ``` Betrachten Sie die folgenden Beispiele, in denen *json\$1string* gültiges JSON ist und *path\$1elem* sich auf einen JSON-`null`Wert bezieht. In diesem Fall gibt JSON\$1EXTRACT\$1PATH\$1TEXT NULL zurück. Wenn *path\$1elem* auf einen nicht existierenden Wert verweist, gibt JSON\$1EXTRACT\$1PATH\$1TEXT ebenfalls NULL zurück, unabhängig vom Wert von *null\$1if\$1invalid*. ``` --Statement selecting a null value. SELECT json_extract_path_text('[null]', 0); json_extract_path_text ------------------------- NULL --Statement selecting a non-existing value. SELECT json_extract_path_text('{}', 'a'); json_extract_path_text ------------------------- NULL ```