MariaDB JSON_REMOVE() erklärt

In MariaDB JSON_REMOVE() ist eine integrierte Funktion, die Daten aus einem JSON-Dokument entfernt und das Ergebnis zurückgibt.

Syntax

Die Syntax lautet wie folgt:

JSON_REMOVE(json_doc, path[, path] ...)

Beispiel

Hier ist ein Beispiel zur Veranschaulichung.

SET @json = '{ "name" : "Wag", "type" : "Dog" }';

SELECT JSON_REMOVE(@json, '$.type');

Ergebnis:

+------------------------------+
| JSON_REMOVE(@json, '$.type') |
+------------------------------+
| {"name": "Wag"}              |
+------------------------------+

In diesem Fall haben wir das Datenelement type entfernt aus dem Dokument. Mit anderen Worten, der type Schlüssel und der zugehörige Wert wurden entfernt.

Arrays

JSON_REMOVE() kann verwendet werden, um das gesamte Array oder bestimmte Elemente innerhalb des Arrays zu entfernen.

Um das gesamte Array zu entfernen, verwenden Sie einfach den Schlüsselnamen:

SET @json = '{ "name" : "Wag", "scores" : [8, 7, 9] }';

SELECT JSON_REMOVE(@json, '$.scores');

Ergebnis:

+--------------------------------+
| JSON_REMOVE(@json, '$.scores') |
+--------------------------------+
| {"name": "Wag"}                |
+--------------------------------+

Dadurch wurde das gesamte Array aus dem Dokument entfernt.

Um ein Array-Element zu entfernen, geben Sie den Index des Elements an. Hier ist ein Beispiel für das Entfernen eines Array-Elements aus einem Array:

SET @json = '{ "name" : "Wag", "scores" : [8, 7, 9] }';

SELECT JSON_REMOVE(@json, '$.scores[1]');

Ergebnis:

+-----------------------------------+
| JSON_REMOVE(@json, '$.scores[1]') |
+-----------------------------------+
| {"name": "Wag", "scores": [8, 9]} |
+-----------------------------------+

In diesem Fall wurde das zweite Array-Element entfernt. Arrays sind nullbasiert, also $.scores[1] bezieht sich auf das zweite Element im Array.

Siehe unten, wie JSON_REMOVE() befasst sich mit dem Entfernen mehrerer Pfade innerhalb des Arrays.

Mehrere Pfade

Wenn Sie mehrere Pfade angeben, werden sie von links nach rechts ausgewertet. Das bedeutet, dass das Ergebnis der vorherigen Auswertung als Wert für die nächste verwendet wird.

Es lohnt sich, dies besonders zu beachten, wenn Elemente basierend auf ihrem Index aus einem Array entfernt werden.

Zuerst ist hier ein Beispiel, das mehrere Pfade aus einem Dokument entfernt, basierend auf ihrem Schlüssel:

SET @json = '
    { 
        "name" : "Wag", 
        "type" : "Dog",
        "weight" : 10
    }
';

SELECT JSON_REMOVE(@json, '$.type', '$.weight');

Ergebnis:

+------------------------------------------+
| JSON_REMOVE(@json, '$.type', '$.weight') |
+------------------------------------------+
| {"name": "Wag"}                          |
+------------------------------------------+

Jedes Schlüssel/Wert-Paar wurde wie erwartet entfernt.

Im nächsten Beispiel entfernen wir das Schlüssel/Wert-Paar nicht. Stattdessen entfernen wir mehrere Elemente aus einem Array:

SET @json = '{ "scores" : [ 0, 1, 2, 3, 4, 5 ] }';

SELECT 
    JSON_REMOVE(@json, '$.scores[2]', '$.scores[4]') AS a,
    JSON_REMOVE(@json, '$.scores[4]', '$.scores[2]') AS b;

Ergebnis:

+--------------------------+--------------------------+
| a                        | b                        |
+--------------------------+--------------------------+
| {"scores": [0, 1, 3, 4]} | {"scores": [0, 1, 3, 5]} |
+--------------------------+--------------------------+

In diesem Fall haben wir JSON_REMOVE() aufgerufen zweimal. Beide geben denselben zu entfernenden Array-Index an (2 und 4 ), aber wir vertauschen die Argumente beim zweiten Aufruf. Im ersten Beispiel lautet es 2 dann 4 (in dieser Reihenfolge). Im zweiten Beispiel ist es 4 dann 2 .

Dies führte bei jedem Anruf zu einem anderen Ergebnis. Wie bereits erwähnt, werden mehrere Pfade von links nach rechts ausgewertet, sodass die Reihenfolge das Ergebnis beeinflussen kann.

Hier ist ein weiteres Beispiel, das veranschaulicht, wie das Ergebnis ganz unterschiedlich sein kann, je nachdem, wie viele Pfade angegeben werden, welche und in welcher Reihenfolge:

SET @json = '{ "scores" : [ 0, 1, 2, 3, 4, 5 ] }';

SELECT 
    JSON_REMOVE(@json, '$.scores[0]', '$.scores[1]', '$.scores[5]') AS a,
    JSON_REMOVE(@json, '$.scores[1]', '$.scores[5]', '$.scores[0]') AS b,
    JSON_REMOVE(@json, '$.scores[5]', '$.scores[0]', '$.scores[1]') AS c,
    JSON_REMOVE(@json, '$.scores[5]', '$.scores[1]', '$.scores[0]') AS d,
    JSON_REMOVE(@json, '$.scores[1]', '$.scores[0]', '$.scores[5]') AS e,
    JSON_REMOVE(@json, '$.scores[0]', '$.scores[5]', '$.scores[1]') AS f;

Ergebnis (bei vertikaler Ausgabe):

a: {"scores": [1, 3, 4, 5]}
b: {"scores": [2, 3, 4, 5]}
c: {"scores": [1, 3, 4]}
d: {"scores": [2, 3, 4]}
e: {"scores": [2, 3, 4, 5]}
f: {"scores": [1, 3, 4, 5]}

Null-Argumente

Wenn irgendein Argument NULL ist , ist das Ergebnis NULL :

SELECT 
    JSON_REMOVE(null, '$.a') AS a,
    JSON_REMOVE('{"a":1}', null) AS b,
    JSON_REMOVE(null, null) AS c;

Ergebnis:

+------+------+------+
| a    | b    | c    |
+------+------+------+
| NULL | NULL | NULL |
+------+------+------+

Falsche Parameteranzahl

Aufruf von JSON_REMOVE() ohne Argument führt zu einem Fehler:

SELECT JSON_REMOVE();

Ergebnis:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'JSON_REMOVE'

Das Gleiche gilt, wenn nicht genügend Argumente übergeben werden:

SELECT JSON_REMOVE('{"a":1}');

Ergebnis:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'JSON_REMOVE'