Catégories :: Fonctions de conversion , Fonctions de données semi-structurées et structurées (conversion)

TO_JSON¶

Convertit une valeur VARIANT en une chaîne contenant la représentation JSON de la valeur.

Syntaxe¶

TO_JSON( <expr> )

Copy

Arguments¶

expr: Expression de type VARIANT contenant des informations valides JSON.

Renvoie¶

Renvoie une valeur de type VARCHAR.

Si l’entrée est NULL, la fonction renvoie NULL.

Notes sur l’utilisation¶

Si l’entrée est NULL, la sortie est NULL aussi. Si l’entrée est un VARIANT qui contient JSON null, alors la valeur retournée est la chaîne "null" (c’est-à-dire le mot « null » entouré de guillemets doubles). Voir les exemples ci-dessous.
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 VARIANT compatible avec JSON.
- La fonction TO_JSON utilise une VARIANT 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 ces raisons :
- Les chaînes vides, et les chaînes ne contenant que des espaces, ne sont pas traitées réciproquement. Par exemple, la valeur de retour de PARSE_JSON('') est NULL, mais la valeur de retour de TO_JSON(NULL) est NULL, et non pas la réciproque ''.
- 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.
Par exemple, 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¶

Les exemples suivants utilisent la fonction TO_JSON.

Insérer des valeurs VARIANT et les convertir en chaînes avec une requête¶

Créez et remplissez une table. L’instruction INSERT utilise la fonction PARSE_JSON pour insérer une valeur VARIANT dans la colonne v de la table.

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

Copy

Interrogez les données et utilisez la fonction TO_JSON pour convertir la valeur VARIANT en chaîne.

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

Copy

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

Traitement des valeurs NULL avec les fonctions PARSE_JSON et TO_JSON¶

L’exemple suivant montre comment PARSE_JSON et TO_JSON traitent les valeurs NULL :

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

Comparaison de PARSE_JSON avec TO_JSON¶

Les exemples suivants illustrent la relation entre les fonctions PARSE_JSON et TO_JSON.

Cet exemple crée une table avec une colonne VARCHAR et une colonne VARIANT. L’instruction INSERT insère une valeur VARCHAR et l’instruction UPDATE génère une valeur JSON qui correspond à cette valeur VARCHAR.

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

Cette requête montre que TO_JSON et PARSE_JSON sont des fonctions conceptuellement réciproques :

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

Cependant, les fonctions ne sont pas exactement réciproques. Des différences dans les espaces ou l’ordre des paires clé-valeur peuvent empêcher la sortie de correspondre à l’entrée. Par exemple :

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