Catégories :

Fonctions de conversion , Fonctions de données semi-structurées (conversion)

TO_JSON

Convertit n’importe quelle valeur VARIANT en une chaîne contenant la représentation JSON de la valeur. Si l’entrée est NULL, le résultat est également NULL.

Syntaxe

TO_JSON( <expr> )

Arguments

expr

Expression de type VARIANT contenant des informations valides JSON.

Notes sur l’utilisation

  • Un objet JSON (également appelé « dictionnaire » ou « hachage ») est un ensemble non ordonné de paires clé-valeur. Lorsque TO_JSON génère une chaîne, l’ordre des paires clé-valeur dans cette chaîne n’est pas prévisible.

  • TO_JSON et PARSE_JSON sont des fonctions (presque) inverses ou réciproques.

    La fonction PARSE_JSON prend une chaîne en entrée et renvoie une variante compatible avec JSON. La fonction TO_JSON utilise une variante compatible avec JSON et renvoie une chaîne. Conceptuellement, ce qui suit est vrai si X est une chaîne contenant du code JSON valide :

    X = TO_JSON(PARSE_JSON(X));

    Par exemple, ce qui suit est vrai (conceptuellement) :

    '{"pi":3.14,"e":2.71}' = TO_JSON(PARSE_JSON('{"pi":3.14,"e":2.71}'))

    Cependant, les fonctions ne sont pas parfaitement réciproques pour deux raisons :

    • L’ordre des paires clé-valeur dans la chaîne produite par TO_JSON n’est pas prévisible.

    • La chaîne produite par TO_JSON peut avoir moins d’espaces que la chaîne transmise à PARSE_JSON.

    Les éléments suivants sont des équivalents JSON, mais pas des chaînes équivalentes :

    • {"pi": 3.14, "e": 2.71}

    • {"e":2.71,"pi":3.14}

Exemples

Voici un bref exemple de TO_JSON et PARSE_JSON :

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

Sortie :

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

L’exemple suivant illustre la relation entre PARSE_JSON, TO_JSON et TO_VARIANT :

Créez une table et ajoutez des données VARCHAR, VARIANT génériques et VARIANT compatibles avec JSON :

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

Cette requête montre que TO_JSON et PARSE_JSON sont effectivement des fonctions réciproques (s’il n’y a pas de différences d’espaces) :

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

Sortie :

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

Bien que PARSE_JSON et TO_VARIANT puissent prendre une chaîne et renvoyer une variante, ils ne sont pas équivalents. Le code suivant utilise PARSE_JSON pour mettre à jour une colonne et TO_VARIANT pour mettre à jour l’autre colonne (la mise à jour vers la colonne variante1 n’est pas nécessaire, car elle a déjà été mise à jour à l’aide d’un appel de fonction identique. Toutefois, le code ci-dessous le met à jour pour que vous puissiez voir côte à côte quelles fonctions sont appelées pour mettre à jour les colonnes) :

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

La sortie montre que la sortie de parse_json() et celle de to_variant() ne sont pas les mêmes. Outre les différences triviales dans les espaces, il existe des différences plus importantes au niveau des guillemets.

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