Dans MariaDB, JSON_REMOVE() est une fonction intégrée qui supprime les données d'un document JSON et renvoie le résultat.
Syntaxe
La syntaxe ressemble à ceci :
JSON_REMOVE(json_doc, path[, path] ...) Exemple
Voici un exemple pour illustrer.
SET @json = '{ "name" : "Wag", "type" : "Dog" }';
SELECT JSON_REMOVE(@json, '$.type'); Résultat :
+------------------------------+| JSON_REMOVE(@json, '$.type') |+------------------------------+| {"name":"Wag"} |+------------------------------+
Dans ce cas, nous avons supprimé le membre de données type à partir du document. En d'autres termes, le type key et sa valeur associée ont été supprimées.
Tableaux
JSON_REMOVE() peut être utilisé pour supprimer tout le tableau ou des éléments spécifiques dans le tableau.
Pour supprimer tout le tableau, utilisez simplement le nom de la clé :
SET @json = '{ "name" : "Wag", "scores" : [8, 7, 9] }';
SELECT JSON_REMOVE(@json, '$.scores'); Résultat :
+---------------------------------------------+| JSON_REMOVE(@json, '$.scores') |+--------------------------------+| {"name":"Wag"} |+---------------------------------------------+ Cela a supprimé tout le tableau du document.
Pour supprimer un élément de tableau, spécifiez l'index de l'élément. Voici un exemple de suppression d'un élément de tableau d'un tableau :
SET @json = '{ "name" : "Wag", "scores" : [8, 7, 9] }';
SELECT JSON_REMOVE(@json, '$.scores[1]'); Résultat :
+-----------------------------------+| JSON_REMOVE(@json, '$.scores[1]') |+----------------------------------------------- -+| {"name":"Wag", "scores":[8, 9]} |+----------------------------- ------+
Dans ce cas, le deuxième élément du tableau a été supprimé. Les tableaux sont basés sur zéro, et donc $.scores[1] fait référence au deuxième élément du tableau.
Voir ci-dessous pour savoir comment JSON_REMOVE() traite de la suppression de plusieurs chemins dans le tableau.
Chemins multiples
Lorsque vous fournissez plusieurs chemins, ils sont évalués de gauche à droite. Cela signifie que le résultat de l'évaluation précédente est utilisé comme valeur pour la suivante.
Il est utile d'être particulièrement attentif à cela lors de la suppression d'éléments d'un tableau en fonction de leur index.
Tout d'abord, voici un exemple qui supprime plusieurs chemins d'un document, en fonction de leur clé :
SET @json = '
{
"name" : "Wag",
"type" : "Dog",
"weight" : 10
}
';
SELECT JSON_REMOVE(@json, '$.type', '$.weight'); Résultat :
+-------------------------------------------------------+| JSON_REMOVE(@json, '$.type', '$.weight') |+------------------------------- -----------+| {"name":"Wag"} |+----------------------------------------------------- ---+ Chaque paire clé/valeur a été supprimée comme prévu.
Dans l'exemple suivant, nous ne supprimons pas la paire clé/valeur. Au lieu de cela, nous supprimons plusieurs éléments d'un tableau :
SET @json = '{ "scores" : [ 0, 1, 2, 3, 4, 5 ] }';
SELECT
JSON_REMOVE(@json, '$.scores[2]', '$.scores[4]') AS a,
JSON_REMOVE(@json, '$.scores[4]', '$.scores[2]') AS b; Résultat :
+--------------------------+---------------------------- -------+| un | b |+-----------------------------------+-------------------- ------+| {"scores":[0, 1, 3, 4]} | {"scores":[0, 1, 3, 5]} |+--------------------------+------ --------------------+
Dans ce cas, nous avons appelé JSON_REMOVE() à deux reprises. Les deux spécifient le même index de tableau à supprimer (2 et 4 ), mais nous échangeons les arguments lors du deuxième appel. Dans le premier exemple, il va 2 puis 4 (dans cet ordre). Dans le deuxième exemple, c'est 4 puis 2 .
Cela produisait un résultat différent pour chaque appel. Comme mentionné, plusieurs chemins sont évalués de gauche à droite, et l'ordre peut donc affecter le résultat.
Voici un autre exemple qui illustre comment le résultat peut être très différent, selon le nombre de chemins spécifiés, lesquels et dans quel ordre :
SET @json = '{ "scores" : [ 0, 1, 2, 3, 4, 5 ] }';
SELECT
JSON_REMOVE(@json, '$.scores[0]', '$.scores[1]', '$.scores[5]') AS a,
JSON_REMOVE(@json, '$.scores[1]', '$.scores[5]', '$.scores[0]') AS b,
JSON_REMOVE(@json, '$.scores[5]', '$.scores[0]', '$.scores[1]') AS c,
JSON_REMOVE(@json, '$.scores[5]', '$.scores[1]', '$.scores[0]') AS d,
JSON_REMOVE(@json, '$.scores[1]', '$.scores[0]', '$.scores[5]') AS e,
JSON_REMOVE(@json, '$.scores[0]', '$.scores[5]', '$.scores[1]') AS f; Résultat (en utilisant la sortie verticale) :
a :{"scores":[1, 3, 4, 5]}b :{"scores":[2, 3, 4, 5]}c :{"scores":[1, 3, 4 ]}d :{"scores" :[2, 3, 4]}e :{"scores":[2, 3, 4, 5]}f :{"scores":[1, 3, 4, 5] } Arguments nuls
Si un argument est NULL , le résultat est NULL :
SELECT
JSON_REMOVE(null, '$.a') AS a,
JSON_REMOVE('{"a":1}', null) AS b,
JSON_REMOVE(null, null) AS c;
Résultat :
+------+------+------+| un | b | c |+------+------+------+| NUL | NUL | NULL |+------+------+------+
Nombre de paramètres incorrect
Appel de JSON_REMOVE() sans argument génère une erreur :
SELECT JSON_REMOVE();
Résultat :
ERREUR 1582 (42000) :Nombre de paramètres incorrect dans l'appel à la fonction native 'JSON_REMOVE'
C'est pareil quand pas assez d'arguments sont passés :
SELECT JSON_REMOVE('{"a":1}');
Résultat :
ERREUR 1582 (42000) :Nombre de paramètres incorrect dans l'appel à la fonction native 'JSON_REMOVE'
