Kategorien:

Konvertierungsfunktionen , Semistrukturierte Datenfunktionen (Umwandlung)

TO_JSON

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

Syntax

TO_JSON( <expr> )

Argumente

Ausdruck

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

Nutzungshinweise

• 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, wenn X eine Zeichenfolge ist, die gültige JSON enthält:

  X = TO_JSON(PARSE_JSON(X));

  Zum Beispiel ist Folgendes (konzeptionell) wahr:

  '{"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 sind äquivalente 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;

Ausgabe:

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

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:

 CREATE or replace TABLE jdemo2 (varchar1 VARCHAR, variant1 VARIANT, 
   variant2 VARIANT);
 -- Add a VARCHAR value.
 INSERT INTO jdemo2 (varchar1) VALUES ('{"PI":3.14}');
 -- Generate a JSON value that corresponds to the VARCHAR.
 UPDATE jdemo2 SET variant1 = PARSE_JSON(varchar1);

Diese Abfrage zeigt, dass TO_JSON und PARSE_JSON tatsächlich reziproke Funktionen sind (wenn es keine Leerzeichenunterschiede gibt):

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

Ausgabe:

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

Obwohl PARSE_JSON und TO_VARIANT jeweils eine Zeichenfolge als Eingabe nutzen und eine Variante zurückgeben können, sind sie 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 Seite an Seite sehen können, welche Funktionen zum Aktualisieren der Spalten aufgerufen werden):

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

Die Ausgabe zeigt, dass die Ausgabe von parse_json() und die Ausgabe von to_variant() nicht identisch sind. Neben den unbedeutenden Unterschieden bezüglich Leerzeichen gibt es größere Unterschiede bei den Anführungszeichen.

+--------------+-----------------+---------------------+
| VARIANT1     | VARIANT2        | VARIANT1 = VARIANT2 |
|--------------+-----------------+---------------------|
| {            | "{\"PI\":3.14}" | False               |
|   "PI": 3.14 |                 |                     |
| }            |                 |                     |
+--------------+-----------------+---------------------+