SQLite JSON_EXTRACT()

No SQLite, o json_extract() A função extrai e retorna um ou mais valores de JSON bem formado.

Passamos o JSON como um argumento quando chamamos a função e ela retorna os valores aplicáveis.

Podemos especificar um ou mais caminhos para extrair do documento JSON.

Sintaxe

A sintaxe fica assim:

json_extract(X,P1,P2,...)

Onde X representa o documento JSON e P1,P2,... são caminhos que podemos usar para extrair partes específicas do documento JSON.

Exemplos

Aqui está um exemplo básico para demonstrar:

SELECT json_extract('{ "a" : 1 }', '$');

Resultado:

{"a":1}

Aqui, especifiquei um caminho de $ , que retorna todo o documento JSON.

Aqui está um exemplo com um documento JSON maior:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$'
);

Resultado:

{"dogs":[{"name":"Wag","scores":[7,9]},{"name":"Bark","scores":[3,4,8,7]},{"name":"Woof","scores":[3,2,1]}]}

Vamos alterar o caminho para que retornemos apenas os dogs variedade:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs'
);

Resultado:

[{"name":"Wag","scores":[7,9]},{"name":"Bark","scores":[3,4,8,7]},{"name":"Woof","scores":[3,2,1]}]

Vamos selecionar um dos elementos dentro do array:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[1]'
);

Resultado:

{"name":"Bark","scores":[3,4,8,7]}

As matrizes são baseadas em zero e, portanto, a contagem começa em 0 . Portanto, especificamos [1] para obter o segundo elemento dentro do dogs array, que por acaso é um objeto JSON.

Vamos aprofundar novamente e retornar apenas o nome do cachorro naquela posição no array:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[1].name'
);

Resultado:

Bark

Especificar vários caminhos

O json_extract() função nos permite selecionar vários caminhos:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[0].name',
'$.dogs[1].name',
'$.dogs[2].name'
);

Resultado:

["Wag","Bark","Woof"]

Nesse caso, retornei os nomes de todos os cães no dogs variedade.

Todos os nomes de cães são retornados em uma matriz.

Selecionando um caminho inexistente

Se apontarmos para um caminho que não existe, null é devolvido.

Primeiro, vamos definir .nullvalue para NULL :

.nullvalue NULL

O .nullvalue O comando dot nos permite fornecer uma string que será usada para substituir valores nulos. É uma das várias maneiras de substituir valores nulos por uma string no SQLite. Neste caso, defini-lo como NULL . Agora, qualquer valor nulo retornará NULL em vez de um resultado em branco.

Agora vamos chamar json_extract() , mas use um segundo argumento que aponta para um caminho inexistente:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.cats'
);

Resultado:

NULL

Caminhos inválidos

Receberemos um erro se nosso caminho não estiver bem formado:

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'dogs'
);

Resultado:

Runtime error: JSON path error near 'dogs'

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_extract('{ "Dogs" : }', 
'$'
);

Resultado:

Runtime error: malformed JSON

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

Tipos de devolução

A documentação do SQLite afirma o seguinte:

Se apenas um único caminho P1 for fornecido, o tipo de dados SQL do resultado será NULL para um valor JSON nulo, INTEGER ou REAL para um valor numérico JSON, um INTEGER zero para um valor falso JSON, um INTEGER um para um valor verdadeiro JSON, o texto sem aspas para um valor de string JSON e uma representação de texto para objetos JSON e valores de matriz. Se houver vários argumentos de caminho (P1, P2 e assim por diante), essa rotina retornará o texto SQLite, que é uma matriz JSON bem formada que contém os vários valores.

Compatibilidade com MySQL

A documentação do SQLite também nos alerta sobre uma incompatibilidade sutil entre as implementações SQLite e MySQL do json_extract() função.

Especificamente, afirma:

A versão MySQL de json_extract() sempre retorna JSON. A versão SQLite de json_extract() só retorna JSON se houver dois ou mais argumentos PATH (porque o resultado é então uma matriz JSON) ou se o único argumento PATH referenciar uma matriz ou objeto. No SQLite, se json_extract() tiver apenas um único argumento PATH e PATH referenciar um JSON nulo ou uma string ou um valor numérico, então json_extract() retornará o valor SQL NULL, TEXT, INTEGER ou REAL correspondente.

Basicamente, essa diferença só se torna aparente ao acessar valores individuais dentro do JSON que são strings ou NULLs.