PARSE_JSON¶

Syntax¶

PARSE_JSON( <expr> )

Argumente¶

expr

Ein Ausdruck eines Zeichenfolgentyps (z. B. VARCHAR), der gültige JSON-Informationen enthält.

Rückgabewerte¶

Der zurückgegebene Wert ist vom Typ VARIANT und enthält ein JSON-Dokument.

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. Ein Beispiel ist im Abschnitt „Beispiele“ unten zu finden.

• Beim Analysieren von Dezimalzahlen versucht PARSE_JSON, die Genauigkeit der Darstellung zu erhalten, indem 123,45 als NUMBER(5,2) und nicht als DOUBLE behandelt wird. Zahlen in wissenschaftlicher Notation (z. B. 1,2345e+02) oder Zahlen, die aufgrund von Bereichs- oder Skalierungsbegrenzungen nicht als Festkomma-Dezimalzahlen gespeichert werden können, werden hingegen als DOUBLE gespeichert. Da JSON Werte wie TIMESTAMP, DATE, TIME oder BINARY nativ nicht darstellt, müssen 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. Beispielsweise ist der Rückgabewert von PARSE_JSON('') NULL, aber der Rückgabewert von TO_JSON(NULL) ist nicht ''.

  • 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¶

Hier ein Beispiel für das Speichern verschiedener Datentypen in einer VARIANT-Spalte, indem PARSE_JSON zum Analysieren (Parsen) von Zeichenfolgen aufgerufen wird:

Erstellen Sie eine Tabelle, und befüllen Sie diese. Beachten Sie, dass die Anweisung INSERT die Funktion PARSE_JSON verwendet.

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

Führen Sie Abfragen auf den Daten aus:

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

Copy

Das folgende Beispiel zeigt die Verarbeitung von NULL-Werten für PARSE_JSON und TO_JSON:

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

Copy

Im folgenden Beispiel wird die Beziehung zwischen PARSE_JSON, TO_JSON und TO_VARIANT veranschaulicht:

Erstellen Sie eine Tabelle, und fügen Sie VARCHAR-, generische VARIANT- und JSON-kompatible VARIANT-Daten hinzu: Die INSERT-Anweisung fügt einen VARCHAR-Wert ein, und die UPDATE-Anweisung generiert einen JSON-Wert, der diesem VARCHAR entspricht.

CREATE or replace TABLE jdemo2 (varchar1 VARCHAR, variant1 VARIANT,
    variant2 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;
+-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------+
| 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 |                   |                                 |                              |
|             | }                    | }            |                   |                                 |                              |
+-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------+

Copy

Die Funktionen sind jedoch nicht exakt reziprok: Unterschiede im 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}'
    ;
+--------------------------------------+--------------------------------------------------------+--------------------------------------------------------+
| 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                                                   |
+--------------------------------------+--------------------------------------------------------+--------------------------------------------------------+

Copy

PARSE_JSON und TO_VARIANT können zwar beide eine Zeichenfolge als Eingabe nutzen und eine Variante zurückgeben, sie sind aber nicht äquivalent. Der folgende Code verwendet PARSE_JSON zum Aktualisieren einer Spalte und TO_VARIANT zum Aktualisieren der anderen Spalte. (Die Aktualisierung der Spalte variant1 ist nicht erforderlich, da sie zuvor mit einem identischen Funktionsaufruf aktualisiert wurde. Der nachfolgende Code sorgt jedoch für eine erneute Aktualisierung, sodass Sie genau sehen können, welche Funktionen zum Aktualisieren der Spalten aufgerufen werden):

UPDATE jdemo2 SET
    variant1 = PARSE_JSON(varchar1),
    variant2 = TO_VARIANT(varchar1);

Copy

Die Abfrage unten zeigt, dass sich die Ausgabe von PARSE_JSON und die Ausgabe von TO_VARIANT unterscheiden. Neben den unbedeutenden Unterschieden bezüglich Leerzeichen gibt es größere Unterschiede bei den Anführungszeichen.

SELECT variant1, variant2, variant1 = variant2 FROM jdemo2;
+--------------+-----------------+---------------------+
| VARIANT1     | VARIANT2        | VARIANT1 = VARIANT2 |
|--------------+-----------------+---------------------|
| {            | "{\"PI\":3.14}" | False               |
|   "PI": 3.14 |                 |                     |
| }            |                 |                     |
+--------------+-----------------+---------------------+

Copy