SQLite JSON_SET()

De SQLite json_set() functie stelt ons in staat om een ​​waarde in een JSON-document in te voegen of te vervangen.

We geven de originele JSON door als het eerste argument wanneer we de functie aanroepen, gevolgd door een pad dat aangeeft waar de nieuwe waarde moet worden ingevoegd/vervangen, gevolgd door de waarde die moet worden ingevoegd/vervangen.

We kunnen indien nodig ook meerdere sleutel/waarde-paren invoegen/vervangen.

Syntaxis

Het werkt als volgt:

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

Waar json staat voor de originele JSON, en path1, value1, path2, value2... zijn pad/waarde-paren die we kunnen gebruiken om nieuwe waarden in het JSON-document in te voegen (of te vervangen, al naar gelang het geval).

Voorbeeld

Hier is een eenvoudig voorbeeld om te demonstreren:

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

Resultaat:

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

Hier heb ik een nieuw sleutel/waarde-paar ingevoegd ("b":2 ) in het JSON-document.

We kunnen meerdere sleutel/waarde-paren als volgt invoegen:

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

Resultaat:

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

Ik heb gewoon meer sleutel/waarde-argumenten toegevoegd toen ik json_set() . aanriep .

Waarden vervangen

Als de sleutel al bestaat, wordt de waarde vervangen door de nieuwe waarde:

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

Resultaat:

{"a":1,"b":3}

Dit is het belangrijkste verschil tussen json_set() en json_insert() . De json_insert() functie zal de waarde niet invoegen als de sleutel al bestaat.

Een andere manier om waarden te vervangen is door json_replace() . te gebruiken .

Een object invoegen

Hier is een voorbeeld van het invoegen van een JSON-object:

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

Resultaat:

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

In dit geval gebruikte ik de json() functie om mijn argument als een JSON-tekenreeks te retourneren. Dit is wat er gebeurt als ik dat niet doe:

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

Resultaat:

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

Het JSON-document wordt ingevoegd als een tekstwaarde in plaats van een JSON-object, en de dubbele aanhalingstekens worden daarom met backslashes geëscaped.

Het simpelweg verwijderen van de enkele aanhalingstekens resulteert echter in een fout:

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

Resultaat:

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

Zonder enkele aanhalingstekens of de json() functie krijgen we een foutmelding zodra deze de linker accolade tegenkomt.

Een andere manier om een ​​JSON-object in te voegen is door de json_object() functie in plaats van de json() functie:

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

Resultaat:

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

Een array invoegen

Hetzelfde geldt voor het invoegen van arrays:

SELECT json_set('{ "a" : 1 }', '$.b', json('[ 2, 3, 4 ]'));

Resultaat:

{"a":1,"b":[2,3,4]}

Als we de json() . verwijderen functie krijgen we dit:

SELECT json_set('{ "a" : 1 }', '$.b', '[ 2, 3, 4 ]');

Resultaat:

{"a":1,"b":"[ 2, 3, 4 ]"}

En als we de enkele aanhalingstekens verwijderen, krijgen we een foutmelding:

SELECT json_set('{ "a" : 1 }', '$.b', [ 2, 3, 4 ]);

Resultaat:

Parse error: no such column:  2, 3, 4 
  SELECT json_set('{ "a" : 1 }', '$.b', [ 2, 3, 4 ]);
                          error here ---^

We kunnen ook de json_array() . gebruiken functie in plaats van json() . Met die functie kun je een array maken op basis van zijn argumenten:

SELECT json_set('{ "a" : 1 }', '$.b', json_array( 2, 3, 4 ) );

Resultaat:

{"a":1,"b":[2,3,4]}

Waarden aan het einde van een array toevoegen

We kunnen json_set() . gebruiken om waarden toe te voegen aan het einde van een array.

Gebruik hiervoor een array-index van [#] :

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

Resultaat:

[1,2,3,4]

Hetzelfde principe is van toepassing op geneste arrays:

SELECT json_set('[ 1, [ "a", "b" ], 3 ]', '$[1][#]', "c" );

Resultaat:

[1,["a","b","c"],3]

Array-elementen vervangen

We kunnen json_set() . gebruiken om elementen in de array te vervangen:

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

Resultaat:

[1,4,3]

Arrays zijn gebaseerd op nul, en dus [1] geeft het tweede array-item aan.

De json_replace() functie kan ook worden gebruikt om bestaande elementen te vervangen. Nogmaals, dit is anders dan json_insert() , die bestaande elementen niet vervangt.

Ongeldige paden

We krijgen een foutmelding als ons pad niet goed is gevormd:

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

Resultaat:

Runtime error: JSON path error near 'b'

In dit geval ben ik vergeten $. aan de voorkant van het pad.

Ongeldige JSON-documenten

We krijgen ook een foutmelding dat de JSON niet goed is gevormd:

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

Resultaat:

Runtime error: malformed JSON

Deze keer vertelt de fout ons dat onze JSON een verkeerde indeling heeft.