SQLite fournit plusieurs fonctions pour insérer, définir et remplacer des valeurs dans un document JSON. Plus précisément, il fournit json_insert() , json_set() , et json_replace() .
Ces fonctions effectuent des tâches similaires et vous pouvez parfois les utiliser de manière interchangeable jusqu'à un certain point.
Mais il y a certainement une nette différence entre chaque fonction.
La différence
Le tableau suivant décrit la différence entre ces fonctions :
| Fonction | Ecraser s'il existe déjà ? | Créer si n'existe pas ? |
|---|---|---|
json_insert() | Non | Oui |
json_replace() | Oui | Non |
json_set() | Oui | Oui |
La différence entre ces fonctions réside donc dans la manière dont elles traitent les clés/valeurs existantes et inexistantes.
Exemples
Voici quelques exemples simples pour montrer comment chaque fonction traite les clés/valeurs existantes et inexistantes.
Lorsque la clé existe déjà
Voici comment chaque fonction gère la mise à jour d'une clé qui existe déjà :
SELECT
json_insert('{ "a" : 1 }', '$.a', 2) AS json_insert,
json_replace('{ "a" : 1 }', '$.a', 2) AS json_replace,
json_set('{ "a" : 1 }', '$.a', 2) AS json_set; Résultat :
+-------------+-------------+----------+| json_insertion | json_replace | json_set |+-------------+-------------+----------+| {"a":1} | {"a":2} | {"a":2} |+-------------+----------------------+----------+
Nous pouvons voir que json_insert() n'a rien mis à jour, mais les deux autres fonctions l'ont fait.
C'est la même chose avec les tableaux :
SELECT
json_insert('[ 1, 2, 3 ]', '$[1]', 4) AS json_insert,
json_replace('[ 1, 2, 3 ]', '$[1]', 4) AS json_replace,
json_set('[ 1, 2, 3 ]', '$[1]', 4) AS json_set;
Résultat :
+-------------+-------------+----------+| json_insertion | json_replace | json_set |+-------------+-------------+----------+| [1,2,3] | [1,4,3] | [1,4,3] |+-------------+-------------+----------+ Lorsque la clé n'existe pas
Voici ce qui se passe lorsque la clé n'existe pas :
SELECT
json_insert('{ "a" : 1 }', '$.b', 2) AS json_insert,
json_replace('{ "a" : 1 }', '$.b', 2) AS json_replace,
json_set('{ "a" : 1 }', '$.b', 2) AS json_set;
Résultat :
+---------------+----------------------+--------------- +| json_insertion | json_replace | json_set |+---------------+----------------------+---------------+ | {"a":1,"b":2} | {"a":1} | {"a":1,"b":2} |+---------------+--------------+---- -----------+
Nous pouvons voir que json_replace() n'a pas inséré la nouvelle paire clé/valeur, mais les deux autres fonctions l'ont fait.
Même chose avec les tableaux :
SELECT
json_insert('[ 1, 2, 3 ]', '$[3]', 4) AS json_insert,
json_replace('[ 1, 2, 3 ]', '$[3]', 4) AS json_replace,
json_set('[ 1, 2, 3 ]', '$[3]', 4) AS json_set;
Résultat :
+-------------+-------------+-----------+| json_insertion | json_replace | json_set |+-------------+-------------+------------+| [1,2,3,4] | [1,2,3] | [1,2,3,4] |+-------------+----------------------+---------- -+
Cela peut également être fait en utilisant le [#] chemin :
SELECT
json_insert('[ 1, 2, 3 ]', '$[#]', 4) AS json_insert,
json_replace('[ 1, 2, 3 ]', '$[#]', 4) AS json_replace,
json_set('[ 1, 2, 3 ]', '$[#]', 4) AS json_set;
Résultat :
+-------------+-------------+-----------+| json_insertion | json_replace | json_set |+-------------+-------------+------------+| [1,2,3,4] | [1,2,3] | [1,2,3,4] |+-------------+----------------------+---------- -+
L'un des avantages de l'utilisation de [#] est que vous n'avez pas besoin de savoir combien d'éléments sont déjà dans le tableau.
