De SQLite json_replace() functie stelt ons in staat om een bestaande waarde in een JSON-document te vervangen door een andere waarde.
We geven de originele JSON door als het eerste argument wanneer we de functie aanroepen, gevolgd door het pad van de te vervangen waarde, gevolgd door de te vervangen waarde.
We kunnen indien nodig ook meerdere sleutel/waarde-paren vervangen.
Syntaxis
Het werkt als volgt:
json_replace(json, path1, value1, path2, value2...)
Waar json staat voor de originele JSON, en path1, value1, path2, value2... zijn pad/waarde-paren die moeten worden vervangen.
Voorbeeld
Hier is een eenvoudig voorbeeld om te demonstreren:
SELECT json_replace('{ "name" : "Fluffy" }', '$.name', "Baldy");Resultaat:
{"name":"Baldy"}
Hier heb ik de waarde van de name . geüpdatet sleutel van Fluffy naar Baldy .
We kunnen meerdere sleutel/waarde-paren als volgt bijwerken:
SELECT json_replace('{
"name" : "Fluffy",
"age" : 10
}',
'$.name', "Baldy",
'$.age', 11
);Resultaat:
{"name":"Baldy","age":11}
Ik heb gewoon meer sleutel/waarde-argumenten toegevoegd toen ik json_replace() . aanriep .
Hier heb ik regeleinden gebruikt om de code leesbaarder te maken. Het had allemaal op één regel kunnen staan - het resultaat zou hetzelfde zijn geweest.
Wat als de sleutel niet bestaat?
Als de sleutel nog niet bestaat in de JSON, wordt er niets vervangen:
SELECT json_replace('{ "name" : "Fluffy" }', '$.age', 11);Resultaat:
{"name":"Fluffy"}
Dit is het belangrijkste kenmerk dat de json_replace() . onderscheidt functie van de json_set() en json_insert() functies. Die functies zullen de waarde invoegen als de sleutel nog niet bestaat.
Het is echter mogelijk om effectief nieuwe sleutels in te voegen met json_replace() door het hele JSON-object/document te vervangen. Voorbeeld hieronder.
Vervang het hele JSON-document
We kunnen json_replace() . gebruiken om het hele JSON-document te vervangen door een ander:
SELECT json_replace('{ "name" : "Fluffy" }', '$', json('{ "name" : "Baldy" }') );Resultaat:
{"name":"Baldy"} Dit stelt ons dus in staat om effectief nieuwe sleutels in het document in te voegen:
SELECT json_replace('{
"name" : "Fluffy"
}',
'$',
json('{
"name" : "Baldy" ,
"age" : 11
}'
)
);Resultaat:
{"name":"Baldy","age":11} Strikt genomen hebben we geen nieuwe sleutels ingevoegd. We hebben gewoon het hele document vervangen. Maar het resultaat was een JSON-document dat sleutels bevat die het origineel niet bevatte.
Een ingesloten object vervangen
We kunnen ook ingesloten objecten vervangen:
SELECT json_replace('
{
"a" : 1,
"b" : { "c" : 1 }
}',
'$.b',
json('{ "c" : 2 }')
);Resultaat:
{"a":1,"b":{"c":2}}
Toen ik dit deed, 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_replace('
{
"a" : 1,
"b" : { "c" : 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.
We kunnen de enkele aanhalingstekens echter niet zomaar verwijderen, omdat dit een fout oplevert:
SELECT json_replace('
{
"a" : 1,
"b" : { "c" : 1 }
}',
'$.b',
{ "c" : 2 }
);Resultaat:
Parse error: unrecognized token: "{"
"b" : { "c" : 1 } }', '$.b', { "c" : 2 } );
error here ---^
Zonder enkele aanhalingstekens of de json() functie krijgen we een foutmelding zodra deze de linker accolade tegenkomt. We moeten daarom enkele aanhalingstekens gebruiken of de json() functie, afhankelijk van of we een JSON-object of een SQL-tekenreeks/tekstwaarde invoegen.
Een andere manier om een JSON-object in te voegen is door de json_object() functie in plaats van de json() functie:
SELECT json_replace('
{
"a" : 1,
"b" : { "c" : 1 }
}',
'$.b',
json_object('c', 2)
);Resultaat:
{"a":1,"b":{"c":2}} Een array vervangen
Hetzelfde concept is van toepassing op arrays:
SELECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', json('[ 5, 6, 7 ]'));Resultaat:
{"a":[5,6,7]}
Als we de json() . verwijderen functie krijgen we dit:
SELECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', '[ 5, 6, 7 ]');Resultaat:
{"a":"[ 5, 6, 7 ]"} En als we de enkele aanhalingstekens verwijderen, krijgen we een foutmelding:
SELECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', [ 5, 6, 7 ]);Resultaat:
Parse error: no such column: 5, 6, 7 (17)
LECT json_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', [ 5, 6, 7 ]);
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_replace('{ "a" : [ 1, 2, 3 ] }', '$.a', json_array(5, 6, 7));Resultaat:
{"a":[5,6,7]} Waarden aan het einde van een array toevoegen
Om waarden aan het einde van een array toe te voegen, kunnen we de json_insert() gebruiken of json_set() functies.
Als we echter json_replace() . moeten gebruiken , kunnen we de hele array vervangen door een andere met de extra waarde(n) aan het einde van de array:
SELECT json_replace('[ 1, 2, 3 ]', '$', json('[ 1, 2, 3, 4 ]') );Resultaat:
[1,2,3,4]
Maar zoals gezegd, json_insert() en json_set() stelt u in staat om daadwerkelijk waarden aan de array toe te voegen zonder de hele array te vervangen.
Array-elementen vervangen
Hier is een voorbeeld van het gebruik van json_replace() om een element in een array te vervangen:
SELECT json_replace('[ 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_set() functie kan ook worden gebruikt om bestaande elementen te vervangen. Echter, de json_insert() functie staat ons niet toe om bestaande elementen te vervangen.
Ongeldige paden
We krijgen een foutmelding als ons pad niet goed is gevormd:
SELECT json_replace('{ "a" : 1 }', 'a', 2);Resultaat:
Runtime error: JSON path error near 'a'
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_replace('{ "a" : 1', '$.a', 2);Resultaat:
Runtime error: malformed JSON
Deze keer vertelt de fout ons dat onze JSON een verkeerde indeling heeft.