JSON_INSERT() vs JSON_SET() vs JSON_REPLACE() in SQLite

SQLite fornisce diverse funzioni per l'inserimento, l'impostazione e la sostituzione di valori in un documento JSON. In particolare, fornisce json_insert() , json_set() e json_replace() .

Queste funzioni svolgono attività simili e a volte puoi usarle in modo intercambiabile fino a un certo punto.

Ma c'è sicuramente una chiara differenza tra ciascuna funzione.

La differenza

La tabella seguente illustra la differenza tra queste funzioni:

Quindi la differenza tra queste funzioni sta nel modo in cui gestiscono chiavi/valori esistenti e inesistenti.

Esempi

Ecco alcuni semplici esempi per dimostrare come ogni funzione gestisce chiavi/valori esistenti e inesistenti.

Quando la chiave esiste già

Ecco come ogni funzione si occupa dell'aggiornamento di una chiave già esistente:

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;

Risultato:

+-------------+--------------+----------+
| json_insert | json_replace | json_set |
+-------------+--------------+----------+
| {"a":1}     | {"a":2}      | {"a":2}  |
+-------------+--------------+----------+

Possiamo vedere che json_insert() non ha aggiornato nulla, ma le altre due funzioni lo hanno fatto.

È una cosa simile con gli array:

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;

Risultato:

+-------------+--------------+----------+
| json_insert | json_replace | json_set |
+-------------+--------------+----------+
| [1,2,3]     | [1,4,3]      | [1,4,3]  |
+-------------+--------------+----------+

Quando la chiave non esiste

Ecco cosa succede quando la chiave non esiste:

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;

Risultato:

+---------------+--------------+---------------+
|  json_insert  | json_replace |   json_set    |
+---------------+--------------+---------------+
| {"a":1,"b":2} | {"a":1}      | {"a":1,"b":2} |
+---------------+--------------+---------------+

Possiamo vedere che json_replace() non ha inserito la nuova coppia chiave/valore, ma le altre due funzioni l'hanno fatto.

Stessa cosa con gli array:

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;

Risultato:

+-------------+--------------+-----------+
| json_insert | json_replace | json_set  |
+-------------+--------------+-----------+
| [1,2,3,4]   | [1,2,3]      | [1,2,3,4] |
+-------------+--------------+-----------+

Questo può essere fatto anche usando il [#] percorso:

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;

Risultato:

+-------------+--------------+-----------+
| json_insert | json_replace | json_set  |
+-------------+--------------+-----------+
| [1,2,3,4]   | [1,2,3]      | [1,2,3,4] |
+-------------+--------------+-----------+

Uno dei vantaggi dell'utilizzo di [#] è che non è necessario sapere quanti elementi sono già presenti nell'array.