SQLiteJSON_EXTRACT()

En SQLite, el json_extract() La función extrae y devuelve uno o más valores de JSON bien formado.

Pasamos el JSON como argumento cuando llamamos a la función, y devuelve los valores aplicables.

Podemos especificar una o más rutas para extraer del documento JSON.

Sintaxis

La sintaxis es así:

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

Donde X representa el documento JSON y P1,P2,... son rutas que podemos usar para extraer partes específicas del documento JSON.

Ejemplos

Aquí hay un ejemplo básico para demostrarlo:

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

Resultado:

{"a":1}

Aquí, especifiqué una ruta de $ , que devuelve el documento JSON completo.

Aquí hay un ejemplo con un documento JSON más grande:

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

Cambiemos la ruta para devolver solo los dogs matriz:

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

Seleccionemos uno de los elementos dentro de la matriz:

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

Las matrices se basan en cero, por lo que el recuento comienza en 0 . Por lo tanto, especificamos [1] para obtener el segundo elemento dentro de los dogs matriz, que resulta ser un objeto JSON.

Profundicemos nuevamente y devolvamos solo el nombre del perro en esa posición en la matriz:

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

Especifique varias rutas

El json_extract() La función nos permite seleccionar múltiples rutas:

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

En este caso, devolví los nombres de todos los perros en el dogs matriz.

Todos los nombres de perros se devuelven en una matriz.

Seleccionar una ruta inexistente

Si apuntamos a una ruta que no existe, null es devuelto.

Primero, configuremos .nullvalue a NULL :

.nullvalue NULL

El .nullvalue El comando dot nos permite proporcionar una cadena que se usará para reemplazar valores nulos. Es una de las varias formas en que puede reemplazar valores nulos con una cadena en SQLite. En este caso, lo configuré en NULL . Ahora, cualquier valor nulo devolverá NULL en lugar de un resultado en blanco.

Ahora llamemos a json_extract() , pero usa un segundo argumento que apunta a una ruta 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

Rutas no válidas

Obtendremos un error si nuestra ruta no está bien formada:

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'

En este caso, olvidé incluir $. al frente del camino.

Documentos JSON no válidos

También obtendremos un error de que JSON no está bien formado:

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

Resultado:

Runtime error: malformed JSON

Esta vez el error nos dice que nuestro JSON está mal formado.

Tipos de devolución

La documentación de SQLite establece lo siguiente:

Si solo se proporciona una única ruta P1, entonces el tipo de datos SQL del resultado es NULL para un JSON nulo, INTEGER o REAL para un valor numérico JSON, INTEGER cero para un valor JSON falso, INTEGER uno para un valor JSON verdadero, el texto entrecomillado para un valor de cadena JSON y una representación de texto para objetos JSON y valores de matriz. Si hay varios argumentos de ruta (P1, P2, etc.), esta rutina devuelve texto SQLite, que es una matriz JSON bien formada que contiene los distintos valores.

Compatibilidad MySQL

La documentación de SQLite también nos advierte sobre una sutil incompatibilidad entre las implementaciones de SQLite y MySQL del json_extract() función.

Específicamente, establece:

La versión MySQL de json_extract() siempre devuelve JSON. La versión SQLite de json_extract() solo devuelve JSON si hay dos o más argumentos PATH (porque el resultado es una matriz JSON) o si el único argumento PATH hace referencia a una matriz u objeto. En SQLite, si json_extract() tiene solo un único argumento PATH y ese PATH hace referencia a un valor nulo de JSON, una cadena o un valor numérico, entonces json_extract() devuelve el valor SQL NULL, TEXT, INTEGER o REAL correspondiente.

Básicamente, esta diferencia solo se hace evidente cuando se accede a valores individuales dentro del JSON que son cadenas o NULL.