Kategorien:

Semistrukturierte Datenfunktionen (Analyse)

PARSE_JSON

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

Siehe auch:

TRY_PARSE_JSON

Syntax

PARSE_JSON( <expr> )

Argumente

Ausdruck

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.

Nutzungshinweise

  • Diese Funktion unterstützt einen Eingabeausdruck mit einer maximalen komprimierten Größe von 8 MB.

  • 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 Variante zurück.

    • Die Funktion TO_JSON nutzt eine JSON-kompatible Variante 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 zwei Gründen nicht perfekt reziprok:

    • 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 äquivalente 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;

Führen Sie Abfragen auf den Daten aus:

select n, v, typeof(v) from vartab;
+---+------------------------+------------+
| 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              |            |
|   | }                      |            |
+---+------------------------+------------+

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               |
+---------------+--------------------------+------------------+--------------------+

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);

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 |                   |                                 |                              |
|             | }                    | }            |                   |                                 |                              |
+-------------+----------------------+--------------+-------------------+---------------------------------+------------------------------+

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                                                   |
+--------------------------------------+--------------------------------------------------------+--------------------------------------------------------+

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);

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 |                 |                     |
| }            |                 |                     |
+--------------+-----------------+---------------------+