Kategorien:

Konvertierungsfunktionen , Semistrukturierte Datenfunktionen (Umwandlung)

TO_JSON

Konvertiert einen VARIANT-Wert in eine Zeichenfolge, die die JSON-Darstellung des Wertes enthält. Wenn der Eingabewert NULL ist, ist auch das Ergebnis NULL.

Syntax

TO_JSON( <expr> )

Argumente

Ausdruck

Ein Ausdruck vom Typ VARIANT, der gültige JSON-Informationen enthält.

Rückgabewerte

Der zurückgegebene Wert ist vom Typ VARCHAR.

Nutzungshinweise

  • Wenn der Eingabewert NULL ist, ist auch der Ausgabewert NULL. Wenn der Eingabewert vom Typ VARIANT ist, der JSON null enthält, dann ist der Rückgabewert die Zeichenfolge '"null"' (d. h. das Wort „null“, umgeben von doppelten Anführungszeichen). Ein Beispiel ist im Abschnitt „Beispiele“ unten zu finden.

  • Ein JSON-Objekt (auch als „Wörterbuch“ oder „Hash“ bezeichnet) ist eine ungeordnete Menge von Schlüssel-Wert-Paaren. Wenn TO_JSON eine Zeichenfolge erzeugt, ist die Reihenfolge der Schlüssel-Wert-Paare in dieser Zeichenfolge nicht vorhersehbar.

  • 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

Dies ist ein kurzes Beispiel für TO_JSON und PARSE_JSON:

CREATE TABLE jdemo1 (v VARIANT);
INSERT INTO jdemo1 SELECT PARSE_JSON('{"food":"bard"}');
SELECT v, v:food, TO_JSON(v) FROM jdemo1;
+------------------+--------+-----------------+
| V                | V:FOOD | TO_JSON(V)      |
|------------------+--------+-----------------|
| {                | "bard" | {"food":"bard"} |
|   "food": "bard" |        |                 |
| }                |        |                 |
+------------------+--------+-----------------+

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