JSON functions - Lindorm - Centre de documentation Alibaba Cloud

Présentation des fonctions JSON

Catégorie de fonction	Nom de la fonction	Description de la fonction
Fonctions de construction JSON	json_object	Crée un objet JSON.
Fonctions de construction JSON	json_array	Crée un tableau JSON.
Fonctions d'extraction JSON	json_extract	Extrait une valeur d'un document JSON à un chemin spécifié.
	json_extract_string	Extrait une valeur à un chemin spécifié et la convertit en chaîne.
	json_extract_long	Extrait une valeur à un chemin spécifié et la convertit en entier long.
	json_extract_double	Extrait une valeur à un chemin spécifié et la convertit en nombre à virgule flottante.
Fonctions de vérification de contenu JSON	json_contains	Vérifie si un document JSON contient toutes les valeurs ou tous les objets spécifiés.
Fonctions de vérification de contenu JSON	json_contains_any	Vérifie si un document JSON contient au moins l'une des valeurs ou l'un des objets spécifiés.
Fonctions de mise à jour JSON	json_set	Insère ou met à jour des données dans un document JSON et renvoie le nouveau document. Cela équivaut à `json_insert` + `json_replace`.
	json_insert	Insère des données dans un document JSON et renvoie le nouveau document. Cette fonction insère un nouveau champ uniquement s'il n'existe pas déjà.
	json_replace	Remplace des données existantes dans un document JSON et renvoie le nouveau document. Cette fonction met à jour la valeur uniquement si le champ existe.
	json_remove	Supprime des données d'un document JSON à un chemin spécifié et renvoie le document modifié.
	json_upsert	Sémantiquement identique à `json_set`, mais cette fonction peut gérer les valeurs NULL.

Descriptions des fonctions

Fonctions de construction JSON

json_object

Crée un objet JSON.

Syntaxe :

json_object(key1, value1, key2, value2, ...)

Paramètres :

key : nom de la clé. Il doit s'agir d'une chaîne.
value : valeur. Elle peut être de n'importe quel type.

Exemples :

-- Create a simple object
SELECT json_object('name', 'Alice', 'age', 25);
-- Result: {"name": "Alice", "age": 25}

-- Use in an INSERT statement
UPSERT INTO users (id, data) VALUES (1, json_object('name', 'Charlie', 'city', 'Beijing'));

json_array

Crée un tableau JSON.

Syntaxe :

json_array(value1, value2, value3, ...)

Paramètres :

value : valeur. Elle peut être un scalaire, un objet ou un tableau.

Exemples :

-- Create a simple array
SELECT json_array('apple', 'banana', 'orange');
-- Result: ["apple", "banana", "orange"]

-- Use in an INSERT statement
UPSERT INTO products (id, tags) VALUES (1, json_array('electronics', 'mobile', 'smartphone'));

Fonctions d'extraction JSON

json_extract

Extrait une valeur d'un document JSON à un chemin spécifié.

Syntaxe :

json_extract(json_column, 'path')

Paramètres :

json_column : colonne ou expression de type JSON.
path : expression de chemin JSON, telle que $.field, $.array[0] ou $.nested.field.

Exemples :

-- Extract a simple field
SELECT json_extract('{"name": "Alice", "age": 25}', '$.name');
-- Result: "Alice"

-- Extract a nested field
SELECT json_extract('{"user": {"name": "Bob", "age": 30}}', '$.user.name');
-- Result: "Bob"

-- Extract an array element
SELECT json_extract('{"skills": ["Java", "Python"]}', '$.skills[0]');
-- Result: "Java"

-- Extract the entire array
SELECT json_extract('{"skills": ["Java", "Python"]}', '$.skills');
-- Result: ["Java", "Python"]

-- WHERE clause with a number
select * from tb where json_extract(c2, '$.k3.k4') > 5;

-- WHERE clause with a string
select * from tb where json_extract_string(c2, '$.k2') = '1';

Fonctions d'extraction typées : json_extract_type

json_extract_string

Extrait une valeur à un chemin spécifié et la convertit en chaîne. Si la valeur située au chemin n'est pas une chaîne, la fonction renvoie NULL par défaut.

SELECT json_extract_string('{"name": "Alice"}', '$.name');
-- Result: Alice (VARCHAR type)

SELECT json_extract_string('{"number": "30"}', '$.name');
-- Result: NULL. (The type is Number, which does not match.)

json_extract_long

Extrait une valeur à un chemin spécifié et la convertit en entier long. Si la valeur située au chemin n'est pas un nombre, Java Database Connectivity (JDBC) génère une erreur.

SELECT json_extract_long('{"id": 123456789}', '$.id');
-- Result: 123456789 (LONG type)

SELECT json_extract_long('{"id": 123456.789}', '$.id');
-- Throws an error

SELECT json_extract_long('{"id": "123456.789"}', '$.id');
-- Throws an error

json_extract_double

Extrait une valeur à un chemin spécifié et la convertit en nombre à virgule flottante. Si la valeur située au chemin n'est pas un nombre à virgule flottante, JDBC génère une erreur.

SELECT json_extract_double('{"id": 12345.56}', '$.id');
-- Result: 12345.56 (Double type)

SELECT json_extract_double('{"id": 12345}', '$.id');
-- Result: 12345.0 (Double type)

SELECT json_extract_double('{"id": "123456.789"}', '$.id');
-- Throws an error

Ces trois fonctions sont fortement typées. L'élément situé au chemin spécifié doit correspondre strictement au type attendu par la fonction. Dans le cas contraire, la fonction renvoie NULL ou génère une erreur. Vous pouvez configurer le cluster pour forcer la conversion de type, mais cela n'est pas recommandé. Nous vous conseillons de définir les types de données avant d'insérer des données JSON, car les types mixtes peuvent entraîner des problèmes logiques inattendus.

Fonctions de vérification de contenu JSON

json_contains

Vérifie si un document JSON contient toutes les valeurs ou tous les objets spécifiés.

Syntaxe :

json_contains(target, candidate[, path])

Paramètres :

target_json : obligatoire. Document JSON.
candidate_json : obligatoire. Document JSON à rechercher.
path : facultatif. Expression de chemin.

Pour plus d'informations sur les paramètres, consultez la section Informations supplémentaires sur les paramètres.

Valeur de retour :

1 (true) : la valeur spécifiée est trouvée.
0 (false) : la cible ne contient pas le candidat.

La fonction json_contains renvoie 1 si le document target_json contient le document candidate_json, et 0 dans le cas contraire. Si vous spécifiez le paramètre path, la fonction vérifie si les données situées au path spécifié contiennent le document candidate_json.

La fonction json_contains renvoie NULL dans les cas suivants :

Le chemin spécifié n'existe pas dans le document JSON.
L'un des paramètres est NULL.

Exemples :

-- Create a table and insert data
CREATE TABLE test_table (id INT, c1 VARCHAR, data JSON, PRIMARY KEY(id));
UPSERT INTO test_table (id, data) VALUES (1, NULL);
UPSERT INTO test_table (id, data) VALUES (2, '{"skills": ["Java", "Python"]}');
UPSERT INTO test_table (id, data) VALUES (3, '{"skills": ["Go", "C"]}');
UPSERT INTO test_table (id, data) VALUES (4, '{"technical_skills": ["Java", "Go", "Rust"]}');
UPSERT INTO test_table (id, data) VALUES (5, '["Java","C++", "JavaScript"]');
UPSERT INTO test_table (id, data) VALUES (6, '{"skills": "Java"}');
UPSERT INTO test_table (id, data) VALUES (7, '["Java", "C#"]');
UPSERT INTO test_table (id, data) VALUES (8, '{"skills": ["Go", "Rust"]}');

-- Two-parameter form. The default path is '$'.
mysql>  SELECT id, data FROM test_table WHERE json_contains(data, '["Java"]') and id>0 and id<10;
+------+------------------------------+
| id   | data                         |
+------+------------------------------+
|    5 | ["Java","C++", "JavaScript"] |
|    7 | ["Java", "C#"]               |
+------+------------------------------+
2 rows in set (0.01 sec)

-- Three-parameter form: Check a specified path
mysql>  SELECT id, data FROM test_table WHERE json_contains(data, '["Java"]', '$.skills') and id>0 and id<10;
+------+--------------------------------+
| id   | data                           |
+------+--------------------------------+
|    2 | {"skills": ["Java", "Python"]} |
+------+--------------------------------+
1 row in set (0.01 sec)

-- Contains both "Java" and "Go"
mysql>  SELECT id, data FROM test_table WHERE json_contains(data, '["Java","Go"]', '$.skills') and id>0 and id<10;
Empty set (0.02 sec)

-- The array or element contains the scalar "Java" 
mysql>  SELECT id, data FROM test_table WHERE json_contains(data, '"Java"', '$.skills') and id>0 and id<10;
+------+--------------------------------+
| id   | data                           |
+------+--------------------------------+
|    2 | {"skills": ["Java", "Python"]} |
|    6 | {"skills": "Java"}             |
+------+--------------------------------+
2 rows in set (0.01 sec)

-- The array element contains an array with only the scalar "Java". (For id=6, the JSON document at the path is a scalar. A subset of a scalar can only be a scalar, not an array.)
mysql>  SELECT id, data FROM test_table WHERE json_contains(data, '["Java"]', '$.skills') and id>0 and id<10;
+------+--------------------------------+
| id   | data                           |
+------+--------------------------------+
|    2 | {"skills": ["Java", "Python"]} |
+------+--------------------------------+
1 row in set (0.01 sec)

-- Check if the entire document contains an object
SELECT json_contains('{"a": 1, "b": 2}', '{"a": 1}');
-- Result: 1

-- Check if a specified path contains a value
SELECT json_contains('{"a": 1, "b": 2}', '1', '$.a');
-- Result: 1

SELECT json_contains('{"a": 1, "b": 2}', '1', '$.b');
-- Result: 0

-- Check for containment in an array
SELECT json_contains('{"skills": ["Java", "Python"]}', '"Java"', '$.skills');
-- Result: 1

Informations supplémentaires sur les paramètres

candidate_json est un document JSON. Vous devez représenter l'élément correspondant sous forme de chaîne JSON.
- Document JSON contenant le nombre 10 : '10'
- Document JSON contenant la chaîne « 10 » : '"10"'
- Document JSON contenant une liste de nombres : '[1,2,3]'
- Document JSON contenant une liste de chaînes : '["10","abc","key"]'
Un sous-ensemble d'un scalaire ne peut être qu'un scalaire. Un sous-ensemble d'un tableau peut être un élément ou un tableau.

Classifications des types JSON :
- Scalaire : chaîne, nombre (entier/double), booléen, null
- Type complexe : tableau, objet
Prenons la condition de vérification json_contains_any(skills, '["Java"]', '$.technical_skills'). Pour le JSON situé au chemin $.technical_skills :
- Si la valeur est {"technical_skills":"Java"}, la fonction renvoie false. Un sous-ensemble d'une chaîne ne peut pas être une liste.
- Si la valeur est {"technical_skills":["Java"]} ou {"technical_skills":["Java","Go"]}, la fonction renvoie true.
Prenons la condition de vérification json_contains_any(skills, '"Java"', '$.technical_skills') . Pour le JSON situé au chemin $.technical_skills :
- Si la valeur est {"technical_skills":"Java"}, la fonction renvoie true.
- Si la valeur est {"technical_skills":["Java"]} ou {"technical_skills":["Java","Go"]}, la fonction renvoie true.

json_contains_any

Vérifie si un document JSON contient au moins l'une des valeurs ou l'un des objets spécifiés.

Syntaxe :

La syntaxe est identique à celle de json_contains. Pour plus d'informations sur les différences, consultez la section Comparaison des fonctions de vérification de contenu JSON.

Exemples :

mysql> select json_contains_any('{"skills": ["Java", "Python"]}', '["Java", "Go"]');
+--------+
| EXPR$0 |
+--------+
|      0 |
+--------+
1 row in set (0.02 sec)

mysql> select json_contains_any('{"skills": ["Java", "Python"]}', '["Java", "Go"]','$.skills');
+--------+
| EXPR$0 |
+--------+
|      1 |
+--------+
1 row in set (0.03 sec)

-- Default two-parameter form. The path defaults to '$'.
mysql> SELECT id, data FROM test_table WHERE json_contains_any(data, '["Java", "Go"]') limit 10;
+------+------------------------------+
| id   | data                         |
+------+------------------------------+
|    5 | ["Java","C++", "JavaScript"] |
|    7 | ["Java", "C#"]               |
+------+------------------------------+
2 rows in set (0.01 sec)

-- Three-parameter form
mysql>  SELECT id, data FROM test_table WHERE json_contains_any(data, '["Java", "Go", "Rust"]', '$.skills') limit 10;
+------+--------------------------------+
| id   | data                           |
+------+--------------------------------+
|    2 | {"skills": ["Java", "Python"]} |
|    3 | {"skills": ["Go", "C"]}        |
|    6 | {"skills": "Java"}             |
|    8 | {"skills": ["Go", "Rust"]}     |
+------+--------------------------------+
4 rows in set (0.01 sec)

-- Check if it contains any value from the array
SELECT json_contains_any('{"skills": ["Java", "Python"]}', '["Java", "Go"]');
-- Result: 0
SELECT json_contains_any('{"skills": ["Java", "Python"]}', '["Java", "Go"]','$.skills');
-- Result: 1

-- Check at a specified path
SELECT json_contains_any('{"departments": ["Engineering", "Sales"]}', '["Marketing", "Engineering"]', '$.departments');
-- Result: 1

Fonctions de mise à jour JSON

json_set

Insère ou met à jour des données dans un document JSON et renvoie le document modifié. Cette fonction équivaut à la combinaison de json_insert et de json_replace.

Syntaxe :

json_set(json_column, 'path', new_value)

Comportement :

Si le chemin spécifié existe, cette fonction met à jour la valeur à cet emplacement.
Si le chemin spécifié n'existe pas, cette fonction insère la valeur à cet emplacement.
Si la colonne JSON est NULL, le résultat est également NULL. Aucune action n'est entreprise.

Exemples :

-- Update an existing field
UPSERT INTO test_table (id, data) VALUES (3, '{"name": "Charlie", "age": 30}');
UPDATE test_table SET data = json_set(data, '$.age', 31) WHERE id = 3;
-- Result: {"name": "Charlie", "age": 31}

-- Insert a new field
UPDATE test_table SET data = json_set(data, '$.department', 'Engineering') WHERE id = 3;
-- Result: {"name": "Charlie", "age": 31, "department": "Engineering"}

-- When the JSON column is NULL (key difference from json_upsert)
UPSERT INTO test_table (id,c1) VALUES (4,'test');
UPDATE test_table SET data = json_set(data, '$.name', 'David') WHERE id = 4;
-- Result: NULL

json_insert

Insère des données dans un document JSON et renvoie le document modifié. Cette fonction insère une nouvelle valeur uniquement si celle-ci n'existe pas déjà au chemin spécifié.

Syntaxe :

json_insert(json_column, 'path', new_value)

Comportement :

Si le chemin spécifié n'existe pas, cette fonction insère la valeur à cet emplacement.
Si le chemin spécifié existe déjà, cette fonction n'entreprend aucune action.

Exemples :

-- Insert a new field
UPSERT INTO test_table (id, data) VALUES (5, '{"name": "Eve"}');
UPDATE test_table SET data = json_insert(data, '$.age', 28) WHERE id = 5;
-- Result: {"name": "Eve", "age": 28}

-- Attempt to insert an existing field (no effect)
UPDATE test_table SET data = json_insert(data, '$.name', 'New Name') WHERE id = 5;
-- Result: {"name": "Eve", "age": 28} (The name field remains unchanged)

json_replace

Remplace des données existantes dans un document JSON et renvoie le document modifié. Cette fonction met à jour une valeur uniquement si celle-ci existe déjà au chemin spécifié.

Syntaxe :

json_replace(json_column, 'path', new_value)

Comportement :

Si le chemin spécifié existe, cette fonction met à jour la valeur à cet emplacement.
Si le chemin spécifié n'existe pas, cette fonction n'entreprend aucune action.

Exemples :

-- Update an existing field
UPSERT INTO test_table (id, data) VALUES (6, '{"name": "Frank", "age": 35}');
UPDATE test_table SET data = json_replace(data, '$.age', 36) WHERE id = 6;
-- Result: {"name": "Frank", "age": 36}

-- Attempt to update a non-existent field (no effect)
UPDATE test_table SET data = json_replace(data, '$.city', 'Shanghai') WHERE id = 6;
-- Result: {"name": "Frank", "age": 36} (No city field)

json_remove

Supprime des données d'un document JSON à un chemin spécifié et renvoie le document modifié.

Syntaxe :

json_remove(json_column, 'path')

Comportement :

Si le chemin spécifié existe, cette fonction supprime les données à cet emplacement.
Si le chemin spécifié n'existe pas, l'opération est sûre et aucune erreur ne se produit.

Exemples :

-- Delete a field
UPSERT INTO test_table (id, data) VALUES (7, '{"name": "Grace", "temp_field": "to_remove"}');
UPDATE test_table SET data = json_remove(data, '$.temp_field') WHERE id = 7;
-- Result: {"name": "Grace"}

-- Delete a non-existent field (safe)
UPDATE test_table SET data = json_remove(data, '$.nonexistent') WHERE id = 7;
-- Result: {"name": "Grace"} (No error)

json_upsert

Cette fonction est sémantiquement identique à json_set, mais elle peut gérer les valeurs NULL.

Syntaxe :

json_upsert(json_column, 'path', new_value)

Comportement :

Si la colonne JSON est NULL, cette fonction crée un nouvel objet : {path: new_value}
Si le chemin spécifié existe, cette fonction met à jour la valeur à cet emplacement.
Si le chemin spécifié n'existe pas, cette fonction insère la valeur à cet emplacement.

Exemples :

-- When the JSON column is NULL
CREATE TABLE test_table (id INT, c1 VARCHAR, data JSON, PRIMARY KEY(id));
UPSERT INTO test_table (id,c1) VALUES (1,'test');
UPDATE test_table SET data = json_upsert(data, '$.name', 'Alice') WHERE id = 1;
-- Result: {"name": "Alice"}

-- Update an existing field
UPSERT INTO test_table (id, data) VALUES (2, '{"name": "Bob", "age": 25}');
UPDATE test_table SET data = json_upsert(data, '$.age', 26) WHERE id = 2;
-- Result: {"name": "Bob", "age": 26}

-- Insert a new field
UPDATE test_table SET data = json_upsert(data, '$.city', 'Beijing') WHERE id = 2;
-- Result: {"name": "Bob", "age": 26, "city": "Beijing"}

Pour plus d'informations sur les différences entre ces fonctions de mise à jour JSON, consultez la rubrique Comparaison des fonctions de mise à jour JSON.

Récapitulatif de la comparaison des fonctions

Comparaison des fonctions de vérification de l'inclusion JSON

Fonction

Différence

json_contains

Pour json_contains, chaque élément de candidate_json doit également être un élément de target_json.

Autrement dit, candidate_json doit être un sous-ensemble de target_json.

json_contains_any

Pour json_contains_any, au moins un élément de candidate_json doit également être un élément de target_json.

Autrement dit, candidate_json et target_json doivent avoir au moins un élément en commun.

Comparaison des fonctions de mise à jour JSON

Fonction

Gestion des colonnes NULL

Le champ existe

Le champ n'existe pas

Cas d'utilisation principal

json_set

Reste NULL

Mise à jour

Insertion

Met à jour une colonne dont on sait qu'elle n'est pas NULL (conforme à la sémantique MySQL).

json_upsert

Crée un nouvel objet

Mise à jour

Insertion

Mises à jour polyvalentes. Effectue une insertion même si la colonne est NULL.

json_insert

Reste NULL

Aucune opération

Insertion

Insère uniquement les nouveaux champs.

json_replace

Reste NULL

Mise à jour

Aucune opération

Met à jour uniquement les champs existants.

json_remove

Reste NULL

Suppression

Aucune opération

Supprime des champs.

Prise en charge des index basés sur des fonctions

Syntaxe

create_index_statement ::=  CREATE INDEX [ index_name ]
                                ON table_name '(' index_identifier ')'
                              [INCLUDE include_identifier]
                              [ASYNC]
                                 [ index_options ]
index_identifier       ::=  '('json_extract_type(column, json_path)')'
include_identifier   ::= '('column_name1,...,column_namen ')'

Descriptions des paramètres

Paramètre	Description
index_name	Nom de la table d'index.
table_name	Nom de la table large.
json_extract_type	Extrait un champ d'un type de données spécifique d'une colonne JSON pour l'utiliser comme index secondaire. Si le type de données ne correspond pas, aucun index secondaire n'est créé. Les types de fonctions suivants sont pris en charge : json_extract_string json_extract_long json_extract_double
column	Nom de la colonne JSON.
json_path	Chemin dans la colonne JSON. Il est utilisé pour extraire la valeur à l'emplacement spécifié.
ASYNC	Crée l'index de manière asynchrone. Si vous n'ajoutez pas ASYNC, l'index est créé de manière synchrone.

Pour plus d'informations sur la prise en charge des index de recherche pour les fonctions JSON, consultez la rubrique Utilisation des index de recherche pour le type JSON Lindorm.

Fonctions prises en charge

Les fonctions JSON suivantes permettent la création d'index basés sur des fonctions :

Accélération des requêtes liées à json_extract et json_extract_type

json_extract_string(json_column, 'path')
json_extract_long(json_column, 'path')
json_extract_double(json_column, 'path')

Le langage SQL des tables larges Lindorm vous permet de créer des index secondaires pour les données situées à des chemins spécifiques au sein d'une colonne de type JSON. Toutefois, lors de la création d'un index secondaire, vous devez spécifier le type de la fonction json_extract pour la colonne JSON.

Accélération des requêtes liées à `json_contains`

json_contains(json_column, 'value', 'path')

Actuellement, les paramètres value et path doivent être des valeurs fixes. Les conditions de requête doivent être statiques.

Exemples de création d'index

-- Create an index for json_contains
CREATE INDEX idx_user_role ON test_table (json_contains(data, '"admin"', '$.roles')) INCLUDE(data) SYNC;

-- Create an index for json_extract_string
CREATE INDEX idx_user_city ON test_table (json_extract_string(data, '$.address.city')) INCLUDE(data) SYNC;

-- Create an index for json_extract_string without including columns
CREATE INDEX idx_user_city ON test_table (json_extract_string(data, '$.address.city'));

-- Create an index for json_extract_long
CREATE INDEX idx_user_age ON test_table (json_extract_long(data, '$.age')) INCLUDE(data) SYNC;

-- View the index creation result
SHOW INDEX FROM test_table;

Limites

Respectez toujours la syntaxe standard lors de l'utilisation de JsonPath.
Tenez compte de l'impact sur les performances des opérations JSON complexes.
Pour les chemins fréquemment interrogés, créez un index afin d'améliorer la vitesse de réponse des requêtes.

Gestion courante des erreurs

Chemin JSON non valide

Une erreur illegal json path se produit si le JsonPath n'est pas un JsonPath valide. Pour plus d'informations, consultez la page Définition de JsonPath par MySQL.
Valeur JSON non valide

json_contain candidate is not a valid value : vérifiez que le paramètre candidate est une chaîne JSON valide.
Avertissement d'analyse complète de la table

This query may be a full table scan and thus may have unpredictable performance : cet avertissement indique une analyse complète de la table inefficace. Vous pouvez créer un index pour accélérer la requête ou ajouter une clause LIMIT pour filtrer un sous-ensemble des données.

Recommandations

Choisissez la fonction de mise à jour appropriée

Sélectionnez json_upsert ou json_set en fonction de vos besoins métier.
Planification des index

Créez des index basés sur des fonctions pour les chemins JSON fréquemment interrogés.
Sécurité des types

Utilisez des fonctions d'extraction spécifiques aux types pour garantir l'exactitude des types de données. Évitez de mélanger des nombres et des chaînes numériques, ce qui peut provoquer une ambiguïté. Par exemple, évitez de mélanger le nombre 10 et la chaîne « 10 ».

Présentation des fonctions JSON

Descriptions des fonctions

Fonctions de construction JSON

json_object

json_array

Fonctions d'extraction JSON

json_extract

Fonctions d'extraction typées : json_extract_type

json_extract_string

json_extract_long

json_extract_double

Fonctions de vérification de contenu JSON

json_contains

json_contains_any

Fonctions de mise à jour JSON

json_set

json_insert

json_replace

json_remove

json_upsert

Récapitulatif de la comparaison des fonctions

Comparaison des fonctions de vérification de l'inclusion JSON

Comparaison des fonctions de mise à jour JSON

Prise en charge des index basés sur des fonctions

Syntaxe

Descriptions des paramètres

Fonctions prises en charge

Accélération des requêtes liées à json_extract et json_extract_type

Accélération des requêtes liées à json_contains

Exemples de création d'index

Limites

Gestion courante des erreurs

Recommandations

Accélération des requêtes liées à `json_contains`