MariaDB JSON_REMOVE() explicado

No MariaDB, JSON_REMOVE() é uma função interna que remove dados de um documento JSON e retorna o resultado.

Sintaxe

A sintaxe fica assim:

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

Exemplo

Aqui está um exemplo para demonstrar.

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

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

Resultado:

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

Neste caso, removemos o membro de dados type do documento. Em outras palavras, o type chave e seu valor associado foram removidos.

Matrizes

JSON_REMOVE() pode ser usado para remover todo o array ou elementos específicos dentro do array.

Para remover todo o array, basta usar o nome da chave:

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

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

Resultado:

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

Isso removeu toda a matriz do documento.

Para remover um elemento de matriz, especifique o índice do elemento. Aqui está um exemplo de remoção de um elemento de array de um array:

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

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

Resultado:

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

Nesse caso, o segundo elemento da matriz foi removido. Arrays são baseados em zero, então $.scores[1] refere-se ao segundo elemento na matriz.

Veja abaixo como JSON_REMOVE() lida com a remoção de vários caminhos dentro da matriz.

Vários caminhos

Ao fornecer vários caminhos, eles são avaliados da esquerda para a direita. Isso significa que o resultado da avaliação anterior é usado como valor para a próxima.

Vale a pena estar especialmente atento a isso ao remover elementos de uma matriz com base em seu índice.

Primeiro, aqui está um exemplo que remove vários caminhos de um documento, com base em sua chave:

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

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

Resultado:

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

Cada par de chave/valor foi removido conforme o esperado.

No próximo exemplo, não removemos o par chave/valor. Em vez disso, removemos vários elementos de um 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;

Resultado:

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

Neste caso chamamos JSON_REMOVE() duas vezes. Ambos especificam o mesmo índice de array para remover (2 e 4 ), mas trocamos os argumentos na segunda chamada. No primeiro exemplo, vai 2 então 4 (naquela ordem). No segundo exemplo, é 4 então 2 .

Isso produziu um resultado diferente para cada chamada. Conforme mencionado, vários caminhos são avaliados da esquerda para a direita e, portanto, a ordem pode afetar o resultado.

Aqui está outro exemplo que ilustra como o resultado pode ser bem diferente, dependendo de quantos caminhos são especificados, quais e em qual ordem:

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;

Resultado (usando saída vertical):

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

Argumentos nulos

Se algum argumento for NULL , o resultado é NULL :

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

Resultado:

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

Contagem de parâmetros incorreta

Chamando JSON_REMOVE() sem um argumento resulta em um erro:

SELECT JSON_REMOVE();

Resultado:

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

É o mesmo quando não são passados argumentos suficientes:

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

Resultado:

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