Kategorien:: Funktionen für semistrukturierte und strukturierte Daten (Analyse)

PARSE_JSON¶

Interpretiert eine Eingabezeichenfolge als JSON-Dokument und erzeugt einen VARIANT-Wert.

Sie können die Funktion PARSE_JSON verwenden, wenn Sie Eingabedaten im JSON-Format haben. Mit dieser Funktion können Sie Daten aus dem JSON-Format in die Formate ARRAY oder OBJECT konvertieren und diese Daten direkt in einem VARIANT-Wert speichern. Sie können die Daten dann analysieren oder manipulieren.

Siehe auch:: TRY_PARSE_JSON

Syntax¶

PARSE_JSON( <expr> )

Copy

Argumente¶

expr: Ein Ausdruck vom Typ Zeichenfolge (z. B. VARCHAR), der gültige JSON-Informationen enthält.

Rückgabewerte¶

Gibt einen Wert vom Typ VARIANT zurück, der ein JSON-Dokument enthält.

Wenn die Eingabe NULL lautet, gibt die Funktion NULL zurück.

Diese Funktion gibt keinen strukturierten Typ zurück.

Nutzungshinweise¶

Diese Funktion unterstützt einen Eingabeausdruck mit einer maximalen komprimierten Größe von 8 MB.
Wenn die PARSE_JSON-Funktion mit einer leeren Zeichenfolge oder mit einer Zeichenfolge, die nur Leerzeichen enthält, aufgerufen wird, gibt die Funktion NULL zurück (anstatt einen Fehler auszulösen), auch wenn eine leere Zeichenfolge in JSON nicht gültig ist. Dadurch muss bei Eingaben, die leere Zeichenfolgen sind, die Verarbeitung nicht abgebrochen werden.
Wenn der Eingabewert NULL ist, ist auch der Ausgabewert NULL. Wenn die Eingabezeichenfolge jedoch 'null' ist, wird das als JSON-Nullwert interpretiert, sodass das Ergebnis nicht SQL NULL ist, sondern ein gültiger VARIANT-Wert, der null enthält. Siehe die Beispiele unten.
Beim Analysieren von Dezimalzahlen versucht PARSE_JSON, die Genauigkeit der Darstellung zu erhalten, indem 123,45 als NUMBER (5,2) und nicht als DOUBLE-Wert behandelt. Zahlen in wissenschaftlicher Notation (z. B. 1,2345e+02) oder Zahlen, die aufgrund von Bereichs- oder Skalierungsbeschränkungen nicht als Festkomma-Dezimalzahlen werden können, werden jedoch als DOUBLE-Werte gespeichert. Da JSON-Werte wie TIMESTAMP, DATE, TIME oder BINARY nativ nicht darstellt, müssen diese diese als Zeichenfolgen dargestellt werden.
In JSON ist ein Objekt (auch als „Wörterbuch“ oder „Hash“ bezeichnet) eine ungeordnete Menge von Schlüssel-Wert-Paaren.

TO_JSON und PARSE_JSON sind (fast) konverse oder reziproke Funktionen.
- Die Funktion PARSE_JSON nutzt eine Zeichenfolge als Eingabe und gibt eine JSON-kompatible VARIANT-Wert zurück.
- Die Funktion TO_JSON nutzt einen JSON-kompatiblen VARIANT-Wert und gibt eine Zeichenfolge zurück.
Folgendes ist (konzeptionell) wahr (true), wenn X eine Zeichenfolge ist, die gültiges JSON enthält:

X = TO_JSON(PARSE_JSON(X));

So ist zum Beispiel Folgendes (konzeptionell) wahr (true):

'{"pi":3.14,"e":2.71}' = TO_JSON(PARSE_JSON('{"pi":3.14,"e":2.71}'))

Die Funktionen sind jedoch aus folgenden Gründen nicht perfekt reziprok:
- Leere Zeichenfolgen und Zeichenfolgen, die nur Leerzeichen enthalten, werden nicht reziprok behandelt. Zum Beispiel ist der Rückgabewert von PARSE_JSON('') NULL, aber der Rückgabewert von TO_JSON(NULL) ist NULL, nicht der Kehrwert von ''.
- Die Reihenfolge der Schlüssel-Wert-Paare in der von TO_JSON erzeugten Zeichenfolge ist nicht vorhersehbar.
- Die von TO_JSON erzeugte Zeichenfolge kann weniger Leerzeichen enthalten als die an PARSE_JSON übergebene Zeichenfolge.
Folgende Angaben sind beispielweise äquivalent in JSON, aber keine äquivalenten Zeichenfolgen:
- {"pi": 3.14, "e": 2.71}
- {"e":2.71,"pi":3.14}

Beispiele¶

Die folgenden Beispiele verwenden die Funktion PARSE_JSON.

Speichern von Werten verschiedener Datentypen in einer VARIANT-Spalte¶

In diesem Beispiel werden verschiedene Datentypen in einer VARIANT-Spalte gespeichert, indem PARSE_JSON zum Analysieren von Zeichenfolgen aufgerufen wird.

Erstellen Sie eine Tabelle, und befüllen Sie diese. Die INSERT-Anweisung verwendet PARSE_JSON, um VARIANT-Werte in die Spalte v der Tabelle einzufügen.

CREATE OR REPLACE TABLE vartab (n NUMBER(2), v VARIANT);

INSERT INTO vartab
  SELECT column1 AS n, PARSE_JSON(column2) AS v
    FROM VALUES (1, 'null'), 
                (2, null), 
                (3, 'true'),
                (4, '-17'), 
                (5, '123.12'), 
                (6, '1.912e2'),
                (7, '"Om ara pa ca na dhih"  '), 
                (8, '[-1, 12, 289, 2188, false,]'), 
                (9, '{ "x" : "abc", "y" : false, "z": 10} ') 
       AS vals;

Copy

Abfragen auf den Daten ausführen Die Abfrage verwendet die Funktion TYPEOF, um die Datentypen der in VARIANT-Werten gespeicherten Werte anzuzeigen.

SELECT n, v, TYPEOF(v)
  FROM vartab
  ORDER BY n;

Copy

+---+------------------------+------------+
| N | V                      | TYPEOF(V)  |
|---+------------------------+------------|
| 1 | null                   | NULL_VALUE |
| 2 | NULL                   | NULL       |
| 3 | true                   | BOOLEAN    |
| 4 | -17                    | INTEGER    |
| 5 | 123.12                 | DECIMAL    |
| 6 | 1.912000000000000e+02  | DOUBLE     |
| 7 | "Om ara pa ca na dhih" | VARCHAR    |
| 8 | [                      | ARRAY      |
|   |   -1,                  |            |
|   |   12,                  |            |
|   |   289,                 |            |
|   |   2188,                |            |
|   |   false,               |            |
|   |   undefined            |            |
|   | ]                      |            |
| 9 | {                      | OBJECT     |
|   |   "x": "abc",          |            |
|   |   "y": false,          |            |
|   |   "z": 10              |            |
|   | }                      |            |
+---+------------------------+------------+

Verarbeitung von NULL-Werten mit den Funktionen PARSE_JSON und TO_JSON¶

Das folgende Beispiel zeigt, wie PARSE_JSON und TO_JSON NULL-Werten verarbeiten:

SELECT TO_JSON(NULL), TO_JSON('null'::VARIANT),
       PARSE_JSON(NULL), PARSE_JSON('null');

Copy

+---------------+--------------------------+------------------+--------------------+
| TO_JSON(NULL) | TO_JSON('NULL'::VARIANT) | PARSE_JSON(NULL) | PARSE_JSON('NULL') |
|---------------+--------------------------+------------------+--------------------|
| NULL          | "null"                   | NULL             | null               |
+---------------+--------------------------+------------------+--------------------+

Vergleich von PARSE_JSON und TO_JSON¶

Die folgenden Beispiele veranschaulichen die Beziehung zwischen den Funktionen PARSE_JSON und TO_JSON.

In diesem Beispiel wird eine Tabelle mit einer VARCHAR-Spalte und einer VARIANT-Spalte erstellt. Die INSERT-Anweisung fügt einen VARCHAR-Wert ein, und die UPDATE-Anweisung generiert einen JSON-Wert, der mit diesem VARCHAR-Wert übereinstimmt.

CREATE OR REPLACE TABLE jdemo2 (
  varchar1 VARCHAR, 
  variant1 VARIANT);

INSERT INTO jdemo2 (varchar1) VALUES ('{"PI":3.14}');

UPDATE jdemo2 SET variant1 = PARSE_JSON(varchar1);

Copy

Die folgende Abfrage zeigt, dass TO_JSON und PARSE_JSON konzeptionell reziproke Funktionen sind:

SELECT varchar1, 
       PARSE_JSON(varchar1), 
       variant1, 
       TO_JSON(variant1),
       PARSE_JSON(varchar1) = variant1, 
       TO_JSON(variant1) = varchar1
  FROM jdemo2;

Copy

+-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------+
| VARCHAR1    | PARSE_JSON(VARCHAR1) | VARIANT1     | TO_JSON(VARIANT1) | PARSE_JSON(VARCHAR1) = VARIANT1 | TO_JSON(VARIANT1) = VARCHAR1 |
|-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------|
| {"PI":3.14} | {                    | {            | {"PI":3.14}       | True                            | True                         |
|             |   "PI": 3.14         |   "PI": 3.14 |                   |                                 |                              |
|             | }                    | }            |                   |                                 |                              |
+-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------+

Die Funktionen sind jedoch nicht genau reziprok. Unterschiede in Leerzeichen oder in der Reihenfolge der Schlüssel-Wert-Paare können dazu führen, dass die Ausgabe nicht mit der Eingabe übereinstimmt. Beispiel:

SELECT TO_JSON(PARSE_JSON('{"b":1,"a":2}')),
       TO_JSON(PARSE_JSON('{"b":1,"a":2}')) = '{"b":1,"a":2}',
       TO_JSON(PARSE_JSON('{"b":1,"a":2}')) = '{"a":2,"b":1}';

Copy

+--------------------------------------+--------------------------------------------------------+--------------------------------------------------------+
| TO_JSON(PARSE_JSON('{"B":1,"A":2}')) | TO_JSON(PARSE_JSON('{"B":1,"A":2}')) = '{"B":1,"A":2}' | TO_JSON(PARSE_JSON('{"B":1,"A":2}')) = '{"A":2,"B":1}' |
|--------------------------------------+--------------------------------------------------------+--------------------------------------------------------|
| {"a":2,"b":1}                        | False                                                  | True                                                   |
+--------------------------------------+--------------------------------------------------------+--------------------------------------------------------+

Vergleich von PARSE_JSON und TO_VARIANT¶

Obwohl sowohl die Funktion PARSE_JSON als auch die Funktion TO_VARIANT eine Zeichenfolge annehmen und einen VARIANT-Wert zurückgeben können, sind sie nicht gleichwertig. Das folgende Beispiel erstellt eine Tabelle mit zwei VARIANT-Spalten. Dann verwendet er PARSE_JSON, um einen Wert in eine Spalte einzufügen und TO_VARIANT, um einen Wert in die andere Spalte einzufügen.

CREATE OR REPLACE TABLE jdemo3 (
  variant1 VARIANT,
  variant2 VARIANT);

INSERT INTO jdemo3 (variant1, variant2)
  SELECT
    PARSE_JSON('{"PI":3.14}'),
    TO_VARIANT('{"PI":3.14}');

Copy

Die Abfrage unten zeigt, dass die Funktionen VARIANT-Werte zurückgeben, die Werte unterschiedlicher Datentypen speichern.

SELECT variant1,
       TYPEOF(variant1),
       variant2,
       TYPEOF(variant2),
       variant1 = variant2
  FROM jdemo3;

Copy

+--------------+------------------+-----------------+------------------+---------------------+
| VARIANT1     | TYPEOF(VARIANT1) | VARIANT2        | TYPEOF(VARIANT2) | VARIANT1 = VARIANT2 |
|--------------+------------------+-----------------+------------------+---------------------|
| {            | OBJECT           | "{\"PI\":3.14}" | VARCHAR          | False               |
|   "PI": 3.14 |                  |                 |                  |                     |
| }            |                  |                 |                  |                     |
+--------------+------------------+-----------------+------------------+---------------------+