SQLite
 sql >> Base de Dados >  >> RDS >> SQLite

SQLite JSON_SET()


O SQLite json_set() A função nos permite inserir ou substituir um valor em um documento JSON.

Passamos o JSON original como primeiro argumento quando chamamos a função, seguido de um caminho que especifica onde inserir/substituir o novo valor, seguido do valor a inserir/substituir.

Também podemos inserir/substituir vários pares de chave/valor, se necessário.

Sintaxe


Funciona assim:
json_set(json, path1, value1, path2, value2...)

Onde json representa o JSON original e path1, value1, path2, value2... são pares de caminho/valor que podemos usar para inserir novos valores no documento JSON (ou substituir, conforme o caso).

Exemplo


Aqui está um exemplo básico para demonstrar:
SELECT json_set('{ "a" : 1 }', '$.b', 2);

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

Aqui, inseri um novo par chave/valor ("b":2 ) no documento JSON.

Podemos inserir vários pares de chave/valor como este:
SELECT json_set('{ "a" : 1 }', '$.b', 2, '$.c', 3 );

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

Eu simplesmente adicionei mais argumentos de chave/valor quando chamei json_set() .

Substituir valores


Se a chave já existir, seu valor será substituído pelo novo valor:
SELECT json_set('{ "a" : 1, "b" : 2 }', '$.b', 3);

Resultado:
{"a":1,"b":3}

Esta é a principal diferença entre json_set() e json_insert() . O json_insert() A função não inserirá o valor se a chave já existir.

Outra maneira de substituir valores é usar json_replace() .

Inserir um objeto


Aqui está um exemplo de inserção de um objeto JSON:
SELECT json_set('{ "a" : 1 }', '$.b', json('{ "c" : 2 }') );

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

Nesse caso, usei o json() função para retornar meu argumento como uma string JSON. Aqui está o que acontece quando eu não faço isso:
SELECT json_set('{ "a" : 1 }', '$.b', '{ "c" : 2 }' );

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

O documento JSON é inserido como um valor de texto em vez de um objeto JSON e, portanto, suas aspas duplas são escapadas com barras invertidas.

No entanto, simplesmente remover as aspas simples resulta em um erro:
SELECT json_set('{ "a" : 1 }', '$.b', { "c" : 2 } );

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

Sem aspas simples ou o json() função, obtemos um erro assim que encontra a chave esquerda.

Outra maneira de inserir um objeto JSON é usar o json_object() função em vez do json() função:
SELECT json_set('{ "a" : 1 }', '$.b', json_object('c', 2) );

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

Inserir uma matriz


É algo semelhante ao inserir matrizes:
SELECT json_set('{ "a" : 1 }', '$.b', json('[ 2, 3, 4 ]'));

Resultado:
{"a":1,"b":[2,3,4]}

Se removermos o json() função, obtemos isso:
SELECT json_set('{ "a" : 1 }', '$.b', '[ 2, 3, 4 ]');

Resultado:
{"a":1,"b":"[ 2, 3, 4 ]"}

E se removermos as aspas simples, obtemos um erro:
SELECT json_set('{ "a" : 1 }', '$.b', [ 2, 3, 4 ]);

Resultado:
Parse error: no such column:  2, 3, 4 
  SELECT json_set('{ "a" : 1 }', '$.b', [ 2, 3, 4 ]);
                          error here ---^

Alternativamente, podemos usar o json_array() função em vez de json() . Essa função permite que você crie uma matriz com base em seus argumentos:
SELECT json_set('{ "a" : 1 }', '$.b', json_array( 2, 3, 4 ) );

Resultado:
{"a":1,"b":[2,3,4]}

Anexar valores ao final de uma matriz


Podemos usar json_set() para acrescentar valores ao final de uma matriz.

Para fazer isso, use um índice de matriz de [#] :
SELECT json_set('[ 1, 2, 3 ]', '$[#]', 4 );

Resultado:
[1,2,3,4]

O mesmo princípio se aplica a matrizes aninhadas:
SELECT json_set('[ 1, [ "a", "b" ], 3 ]', '$[1][#]', "c" );

Resultado:
[1,["a","b","c"],3]

Substituir elementos da matriz


Podemos usar json_set() para substituir elementos na matriz:
SELECT json_set('[ 1, 2, 3 ]', '$[1]', 4 );

Resultado:
[1,4,3]

Arrays são baseados em zero, então [1] indica o segundo item da matriz.

O json_replace() A função também pode ser usada para substituir elementos existentes. Novamente, isso é diferente de json_insert() , que não substitui os elementos existentes.

Caminhos inválidos


Receberemos um erro se nosso caminho não estiver bem formado:
SELECT json_set('{ "a" : 1 }', 'b', 2);

Resultado:
Runtime error: JSON path error near 'b'

Nesse caso, esqueci de incluir $. na frente do caminho.

Documentos JSON inválidos


Também receberemos um erro de que o JSON não está bem formado:
SELECT json_set('{ "a" : 1', '$.b', 2);

Resultado:
Runtime error: malformed JSON

Desta vez, o erro nos diz que nosso JSON está malformado.