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

Operador


No SQLite, o ->> O operador extrai um subcomponente de um documento JSON e retorna uma representação SQL desse subcomponente.

O ->> O operador foi introduzido pela primeira vez no SQLite versão 3.38.0 (lançado em 22 de fevereiro de 2022).

Sintaxe


A sintaxe fica assim:
json ->> path

Onde json é o documento JSON e o path é o caminho para o subcomponente que queremos extrair dele.

Portanto, fornecemos um documento JSON à esquerda do operador e especificamos o caminho que queremos extrair à direita.

O ->> O operador sempre retorna uma representação SQL do subcomponente especificado. Para retornar uma representação JSON, use o -> operador em vez disso.

Exemplos


Aqui está um exemplo simples para demonstrar como o ->> operador funciona:
SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$';

Resultado:
{"name":"Wag","type":"Dog"}

Nesse caso, especifiquei um caminho de '$' que retorna o documento inteiro.

Vamos especificar outro caminho:
SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$.type';

Resultado:
Dog

Também podemos omitir o cifrão e o ponto final, assim:
SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> 'type';

Resultado:
Dog

Aqui está com um documento JSON maior:
SELECT '[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]' ->> '$[0]';

Resultado:
{"user":"Spike","age":30,"scores":[9,7,3]}

No SQLite, as matrizes são baseadas em zero e, portanto, especificando [0] retorna o primeiro elemento da matriz.

Se quiséssemos apenas obter as pontuações desse usuário, poderíamos fazer isso:
SELECT '[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]' ->> '$[0].scores';

Resultado:
[9,7,3]

Podemos ir ainda mais fundo e extrair uma pontuação específica:
SELECT '[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]' ->> '$[0].scores[1]';

Resultado:
7

Caminho inexistente


Se o caminho não existir no JSON, um valor nulo será retornado:
SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$.age';

Resultado:
null

Observe que no SQLite, você pode usar .nullvalue para especificar uma string para saída sempre que um valor nulo for retornado. No meu caso, eu já havia executado o seguinte comando:
.nullvalue null

Isso especifica que o texto null deve ser gerado sempre que um valor nulo é retornado. É por isso que o exemplo acima gera o texto null . Se eu não tivesse feito isso, o resultado poderia ter sido em branco.

JSON inválido


Se o primeiro argumento não for um JSON válido, um erro será gerado:
SELECT '{ "name" }' ->> '$';

Resultado:
Runtime error: malformed JSON

Caminho inválido


E se o segundo argumento não for um caminho válido, um erro será lançado:
SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$name';

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

Nesse caso, esqueci de incluir o ponto final (. ) entre o cifrão ($ ) e name .

No entanto, como mencionado, é possível omitir o cifrão e o ponto final:
SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> 'name';

Resultado:
Wag