MariaDB JSON_REMOVE() Förklarad

I MariaDB, JSON_REMOVE() är en inbyggd funktion som tar bort data från ett JSON-dokument och returnerar resultatet.

Syntax

Syntaxen ser ut så här:

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

Exempel

Här är ett exempel att visa.

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

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

Resultat:

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

I det här fallet tog vi bort datamedlemmen type från dokumentet. Med andra ord, type nyckel och dess tillhörande värde togs bort.

Arrayer

JSON_REMOVE() kan användas för att ta bort hela arrayen, eller specifika element inom arrayen.

För att ta bort hela arrayen, använd helt enkelt nyckelnamnet:

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

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

Resultat:

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

Det tog bort hela arrayen från dokumentet.

För att ta bort ett matriselement, ange elementets index. Här är ett exempel på hur du tar bort ett arrayelement från en array:

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

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

Resultat:

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

I det här fallet togs det andra arrayelementet bort. Arrayer är nollbaserade, och så $.scores[1] hänvisar till det andra elementet i arrayen.

Se nedan för hur JSON_REMOVE() handlar om att ta bort flera sökvägar inom arrayen.

Flera vägar

När du tillhandahåller flera vägar utvärderas de från vänster till höger. Det betyder att resultatet från den tidigare utvärderingen används som värde för nästa.

Det lönar sig att vara särskilt uppmärksam på detta när du tar bort element från en array baserat på deras index.

Först, här är ett exempel som tar bort flera sökvägar från ett dokument, baserat på deras nyckel:

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

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

Resultat:

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

Varje nyckel/värdepar togs bort som förväntat.

I nästa exempel tar vi inte bort nyckel/värdeparet. Istället tar vi bort flera element från en 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;

Resultat:

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

I det här fallet kallade vi JSON_REMOVE() dubbelt. Båda anger samma arrayindex att ta bort (2 och 4 ), men vi byter argument runt i det andra samtalet. I det första exemplet går det till 2 sedan 4 (i den ordningen). I det andra exemplet är det 4 sedan 2 .

Detta gav olika resultat för varje samtal. Som nämnts utvärderas flera vägar från vänster till höger, så ordningen kan påverka resultatet.

Här är ett annat exempel som illustrerar hur resultatet kan vara ganska olika, beroende på hur många sökvägar som anges, vilka och i vilken ordning:

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;

Resultat (med vertikal utdata):

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]}

Nollargument

Om något argument är NULL , resultatet är NULL :

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

Resultat:

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

Felaktig parameterräkning

Anropar JSON_REMOVE() utan argument resulterar i ett fel:

SELECT JSON_REMOVE();

Resultat:

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

Det är samma sak när inte tillräckligt många argument skickas:

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

Resultat:

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