Kategorien:: Konvertierungsfunktionen , Funktionen für semistrukturierte und strukturierte Daten (Umwandlung)

TO_JSON¶

Konvertiert einen VARIANT-Wert in eine Zeichenfolge, die die JSON-Darstellung des Wertes enthält.

Syntax¶

TO_JSON( <expr> )

Copy

Argumente¶

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

Rückgabewerte¶

Gibt einen Wert vom Typ VARCHAR zurück.

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

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). Siehe die Beispiele unten.
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 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 TO_JSON.

Einfügen von VARIANT-Werten und Konvertierung in Zeichenfolgen mit einer Abfrage¶

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

CREATE OR REPLACE TABLE jdemo1 (v VARIANT);
INSERT INTO jdemo1 SELECT PARSE_JSON('{"food":"bard"}');

Copy

Fragen Sie die Daten ab und verwenden Sie die Funktion TO_JSON, um den VARIANT-Wert in eine Zeichenfolge zu konvertieren.

SELECT v, v:food, TO_JSON(v) FROM jdemo1;

Copy

+------------------+--------+-----------------+
| V                | V:FOOD | TO_JSON(V)      |
|------------------+--------+-----------------|
| {                | "bard" | {"food":"bard"} |
|   "food": "bard" |        |                 |
| }                |        |                 |
+------------------+--------+-----------------+

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