SQLite JSON_REPLACE()

Der SQLite json_replace() Mit der Funktion können wir einen vorhandenen Wert in einem JSON-Dokument durch einen anderen Wert ersetzen.

Wir übergeben das ursprüngliche JSON als erstes Argument, wenn wir die Funktion aufrufen, gefolgt vom Pfad des zu ersetzenden Werts, gefolgt vom zu ersetzenden Wert.

Bei Bedarf können wir auch mehrere Schlüssel/Wert-Paare ersetzen.

Syntax

So funktioniert es:

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

Wobei json repräsentiert das ursprüngliche JSON und path1, value1, path2, value2... sind zu ersetzende Pfad/Wert-Paare.

Beispiel

Hier ist ein einfaches Beispiel zur Veranschaulichung:

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

Ergebnis:

{"name":"Baldy"}

Hier habe ich den Wert von name aktualisiert Schlüssel von Fluffy an Baldy .

Wir können mehrere Schlüssel/Wert-Paare wie folgt aktualisieren:

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

Ergebnis:

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

Ich habe einfach mehr Schlüssel/Wert-Argumente hinzugefügt, als ich json_replace() aufgerufen habe .

Hier habe ich Zeilenumbrüche verwendet, um den Code besser lesbar zu machen. Es hätte alles in einer Zeile stehen können – das Ergebnis wäre dasselbe gewesen.

Was ist, wenn der Schlüssel nicht existiert?

Wenn der Schlüssel nicht bereits im JSON vorhanden ist, wird nichts ersetzt:

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

Ergebnis:

{"name":"Fluffy"}

Dies ist das Hauptmerkmal, das json_replace() unterscheidet Funktion aus json_set() und json_insert() Funktionen. Diese Funktionen fügen den Wert ein, wenn der Schlüssel noch nicht existiert.

Es ist jedoch möglich, neue Schlüssel effektiv mit json_replace() einzufügen durch Ersetzen des gesamten JSON-Objekts/Dokuments. Beispiel unten.

Das gesamte JSON-Dokument ersetzen

Wir können json_replace() verwenden um das gesamte JSON-Dokument durch ein anderes zu ersetzen:

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

Ergebnis:

{"name":"Baldy"}

So können wir effektiv neue Schlüssel in das Dokument einfügen:

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

Ergebnis:

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

Genau genommen haben wir keine neuen Schlüssel eingefügt. Wir haben einfach das ganze Dokument ersetzt. Aber das Ergebnis war ein JSON-Dokument, das Schlüssel enthält, die das Original nicht enthielt.

Eingebettetes Objekt ersetzen

Wir können auch eingebettete Objekte ersetzen:

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

Ergebnis:

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

Dabei habe ich json() verwendet Funktion, um mein Argument als JSON-String zurückzugeben. Folgendes passiert, wenn ich das nicht tue:

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

Ergebnis:

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

Das JSON-Dokument wird als Textwert anstelle eines JSON-Objekts eingefügt, und seine doppelten Anführungszeichen werden daher mit umgekehrten Schrägstrichen maskiert.

Allerdings können wir die einfachen Anführungszeichen nicht einfach entfernen, da dies zu einem Fehler führt:

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

Ergebnis:

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

Ohne einfache Anführungszeichen oder json() -Funktion erhalten wir einen Fehler, sobald sie auf die linke geschweifte Klammer trifft. Wir müssen daher einfache Anführungszeichen oder json() verwenden Funktion, abhängig davon, ob wir ein JSON-Objekt oder einen SQL-String/Textwert einfügen.

Eine andere Möglichkeit, ein JSON-Objekt einzufügen, ist die Verwendung von json_object() Funktion anstelle von json() Funktion:

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

Ergebnis:

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

Ein Array ersetzen

Dasselbe Konzept gilt für Arrays:

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

Ergebnis:

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

Wenn wir json() entfernen Funktion erhalten wir Folgendes:

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

Ergebnis:

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

Und wenn wir die einfachen Anführungszeichen entfernen, erhalten wir einen Fehler:

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

Ergebnis:

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

Wir können alternativ das json_array() verwenden Funktion anstelle von json() . Mit dieser Funktion können Sie ein Array basierend auf seinen Argumenten erstellen:

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

Ergebnis:

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

Werte an das Ende eines Arrays anhängen

Um Werte an das Ende eines Arrays anzuhängen, können wir entweder json_insert() verwenden oder json_set() Funktionen.

Wenn wir jedoch json_replace() verwenden müssen , können wir das gesamte Array durch ein anderes ersetzen, bei dem die zusätzlichen Werte am Ende des Arrays hinzugefügt wurden:

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

Ergebnis:

[1,2,3,4]

Aber wie gesagt, json_insert() und json_set() erlauben es Ihnen, tatsächlich Werte an das Array anzuhängen, ohne das gesamte Array zu ersetzen.

Array-Elemente ersetzen

Hier ist ein Beispiel für die Verwendung von json_replace() um ein Element innerhalb eines Arrays zu ersetzen:

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

Ergebnis:

[1,4,3]

Arrays sind nullbasiert, also [1] gibt das zweite Array-Element an.

Das json_set() Die Funktion kann auch verwendet werden, um vorhandene Elemente zu ersetzen. Die json_insert() Funktion erlaubt es uns nicht, vorhandene Elemente zu ersetzen.

Ungültige Pfade

Wir erhalten eine Fehlermeldung, wenn unser Pfad nicht wohlgeformt ist:

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

Ergebnis:

Runtime error: JSON path error near 'a'

In diesem Fall habe ich vergessen, $. einzufügen am Anfang des Weges.

Ungültige JSON-Dokumente

Außerdem erhalten wir eine Fehlermeldung, dass JSON nicht wohlgeformt ist:

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

Ergebnis:

Runtime error: malformed JSON

Diesmal sagt uns der Fehler, dass unser JSON fehlerhaft ist.