SQLite JSON_REPLACE()

Le SQLite json_replace() permet de remplacer une valeur existante dans un document JSON par une autre valeur.

Nous passons le JSON d'origine comme premier argument lorsque nous appelons la fonction, suivi du chemin de la valeur à remplacer, suivi de la valeur à remplacer.

Nous pouvons également remplacer plusieurs paires clé/valeur si nécessaire.

Syntaxe

Cela fonctionne comme ceci :

json_replace(json, path1, value1, path2, value2...)

Où json représente le JSON d'origine, et path1, value1, path2, value2... sont des paires chemin/valeur à remplacer.

Exemple

Voici un exemple de base pour illustrer :

SELECT json_replace('{ "name" : "Fluffy" }', '$.name', "Baldy");

Résultat :

{"name":"Baldy"}

Ici, j'ai mis à jour la valeur du name clé de Fluffy à Baldy .

Nous pouvons mettre à jour plusieurs paires clé/valeur comme ceci :

SELECT json_replace('{ 
    "name" : "Fluffy", 
    "age" : 10
    }', 
    '$.name', "Baldy", 
    '$.age', 11 
    );

Résultat :

{"name":"Baldy","age":11}

J'ai simplement ajouté plus d'arguments clé/valeur lorsque j'ai appelé json_replace() .

Ici, j'ai utilisé des sauts de ligne pour rendre le code plus facile à lire. Tout aurait pu être sur une seule ligne - le résultat aurait été le même.

Et si la clé n'existe pas ?

Si la clé n'existe pas déjà dans le JSON, rien n'est remplacé :

SELECT json_replace('{ "name" : "Fluffy" }', '$.age', 11);

Résultat :

{"name":"Fluffy"}

C'est la principale caractéristique qui distingue le json_replace() fonction de json_set() et json_insert() les fonctions. Ces fonctions inséreront la valeur si la clé n'existe pas déjà.

Cependant, il est possible d'insérer efficacement de nouvelles clés avec json_replace() en remplaçant tout l'objet/document JSON. Exemple ci-dessous.

Remplacer l'intégralité du document JSON

Nous pouvons utiliser json_replace() pour remplacer tout le document JSON par un autre :

SELECT json_replace('{ "name" : "Fluffy" }', '$', json('{ "name" : "Baldy" }') );

Résultat :

{"name":"Baldy"}

Cela nous permet donc d'insérer efficacement de nouvelles clés dans le document :

SELECT json_replace('{ 
    "name" : "Fluffy" 
    }', 
    '$', 
    json('{ 
        "name" : "Baldy" ,
        "age" : 11
        }'
    ) 
);

Résultat :

{"name":"Baldy","age":11}

À proprement parler, nous n'avons pas inséré de nouvelles clés. Nous avons simplement remplacé tout le document. Mais le résultat était un document JSON contenant des clés que l'original ne contenait pas.

Remplacer un objet incorporé

Nous pouvons également remplacer les objets intégrés :

SELECT json_replace('
    { 
        "a" : 1, 
        "b" : { "c" : 1 } 
    }', 
    '$.b', 
    json('{ "c" : 2 }') 
    );

Résultat :

{"a":1,"b":{"c":2}}

Quand j'ai fait cela, j'ai utilisé le json() fonction pour renvoyer mon argument sous forme de chaîne JSON. Voici ce qui se passe lorsque je ne le fais pas :

SELECT json_replace('
    { 
        "a" : 1, 
        "b" : { "c" : 1 } 
    }', 
    '$.b', 
    '{ "c" : 2 }' 
    );

Résultat :

{"a":1,"b":"{ \"c\" : 2 }"}

Le document JSON est inséré en tant que valeur texte au lieu d'un objet JSON, et ses guillemets doubles sont donc échappés avec des barres obliques inverses.

Cependant, nous ne pouvons pas simplement supprimer les guillemets simples, car cela génère une erreur :

SELECT json_replace('
    { 
        "a" : 1, 
        "b" : { "c" : 1 } 
    }', 
    '$.b', 
    { "c" : 2 }
    );

Résultat :

Parse error: unrecognized token: "{"
        "b" : { "c" : 1 }      }',      '$.b',      { "c" : 2 }     );
                                      error here ---^

Sans guillemets simples ni json() fonction, nous obtenons une erreur dès qu'elle rencontre l'accolade gauche. Nous devons donc utiliser des guillemets simples ou le json() fonction, selon que nous insérons un objet JSON ou une valeur de chaîne/texte SQL.

Une autre façon d'insérer un objet JSON est d'utiliser le json_object() fonction au lieu de json() fonction :

SELECT json_replace('
    { 
        "a" : 1, 
        "b" : { "c" : 1 } 
    }', 
    '$.b', 
    json_object('c', 2) 
    );

Résultat :

{"a":1,"b":{"c":2}}

Remplacer une baie

Le même concept s'applique aux tableaux :

SELECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', json('[ 5, 6, 7 ]'));

Résultat :

{"a":[5,6,7]}

Si nous supprimons le json() fonction, nous obtenons ceci :

SELECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', '[ 5, 6, 7 ]');

Résultat :

{"a":"[ 5, 6, 7 ]"}

Et si nous supprimons les guillemets simples, nous obtenons une erreur :

SELECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', [ 5, 6, 7 ]);

Résultat :

Parse error: no such column:  5, 6, 7  (17)
  LECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', [ 5, 6, 7 ]);
                                      error here ---^

Nous pouvons également utiliser le json_array() fonction au lieu de json() . Cette fonction vous permet de créer un tableau basé sur ses arguments :

SELECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', json_array(5, 6, 7));

Résultat :

{"a":[5,6,7]}

Ajouter des valeurs à la fin d'un tableau

Pour ajouter des valeurs à la fin d'un tableau, nous pouvons utiliser soit le json_insert() ou json_set() les fonctions.

Cependant, si nous devons utiliser json_replace() , nous pouvons remplacer tout le tableau par un autre dont la ou les valeurs supplémentaires sont ajoutées à la fin du tableau :

SELECT json_replace('[ 1, 2, 3 ]', '$', json('[ 1, 2, 3, 4 ]') );

Résultat :

[1,2,3,4]

Mais comme mentionné, json_insert() et json_set() vous permettent d'ajouter des valeurs au tableau sans remplacer tout le tableau.

Remplacer les éléments du tableau

Voici un exemple d'utilisation de json_replace() pour remplacer un élément dans un tableau :

SELECT json_replace('[ 1, 2, 3 ]', '$[1]', 4 );

Résultat :

[1,4,3]

Les tableaux sont basés sur zéro, et donc [1] indique le deuxième élément du tableau.

Le json_set() La fonction peut également être utilisée pour remplacer des éléments existants. Cependant, le json_insert() fonction ne nous permet pas de remplacer des éléments existants.

Chemins non valides

Nous aurons une erreur si notre chemin n'est pas bien formé :

SELECT json_replace('{ "a" : 1 }', 'a', 2);

Résultat :

Runtime error: JSON path error near 'a'

Dans ce cas, j'ai oublié d'inclure $. au début du chemin.

Documents JSON non valides

Nous aurons également une erreur, le JSON n'est pas bien formé :

SELECT json_replace('{ "a" : 1', '$.a', 2);

Résultat :

Runtime error: malformed JSON

Cette fois, l'erreur nous indique que notre JSON est malformé.