En SQLite, json_tree() es una función con valores de tabla que recorre el valor JSON proporcionado como su primer argumento y devuelve una tabla que consta de una fila para cada elemento de matriz o miembro de objeto.
Proporcionamos el valor JSON como argumento cuando llamamos a la función.
Opcionalmente, podemos pasar un segundo argumento, que especifica una ruta desde la que empezar. Cuando hacemos esto, json_tree() trata esa ruta como el elemento de nivel superior.
El json_tree() La función recorre recursivamente la subestructura JSON comenzando con el elemento de nivel superior. Para recorrer solo los elementos secundarios inmediatos de la matriz u objeto de nivel superior, o solo el elemento de nivel superior en sí mismo si el elemento de nivel superior es un valor primitivo, use json_each() en su lugar.
Sintaxis
Podemos usar el json_tree() funcionan de las siguientes maneras:
json_tree(X)
json_tree(X,P)Donde X representa el JSON y P es un argumento opcional que representa la ruta a tratar como de nivel superior.
Ejemplo
Aquí hay un ejemplo para demostrar cómo funciona:
SELECT * FROM json_tree('{ "name" : "Woof", "age" : 10 }');Resultado:
+------+--------------------------+---------+------+----+--------+---------+------+
| key | value | type | atom | id | parent | fullkey | path |
+------+--------------------------+---------+------+----+--------+---------+------+
| null | {"name":"Woof","age":10} | object | null | 0 | null | $ | $ |
| name | Woof | text | Woof | 2 | 0 | $.name | $ |
| age | 10 | integer | 10 | 4 | 0 | $.age | $ |
+------+--------------------------+---------+------+----+--------+---------+------+ Podemos ver que cada miembro del objeto tiene su propia fila con información útil, como su tipo (valor de texto SQL), ruta, etc.
Con respecto al id columna, de acuerdo con la documentación de SQLite, este es un número de mantenimiento interno, cuyo cálculo podría cambiar en versiones futuras. La única garantía es que el id la columna será diferente para cada fila.
Matriz
En este ejemplo, el valor JSON es una matriz:
SELECT * FROM json_tree('[ 10, 30, 45 ]');Resultado:
+------+------------+---------+------+----+--------+---------+------+ | key | value | type | atom | id | parent | fullkey | path | +------+------------+---------+------+----+--------+---------+------+ | null | [10,30,45] | array | null | 0 | null | $ | $ | | 0 | 10 | integer | 10 | 1 | 0 | $[0] | $ | | 1 | 30 | integer | 30 | 2 | 0 | $[1] | $ | | 2 | 45 | integer | 45 | 3 | 0 | $[2] | $ | +------+------------+---------+------+----+--------+---------+------+
Especifique una ruta
Podemos usar un segundo argumento para especificar una ruta para tratar como el nivel superior.
Ejemplo:
SELECT * FROM json_tree('{ "a" : 1, "b" : [ 4, 7, 8 ] }', '$.b');Resultado:
+-----+---------+---------+------+----+--------+---------+------+ | key | value | type | atom | id | parent | fullkey | path | +-----+---------+---------+------+----+--------+---------+------+ | b | [4,7,8] | array | null | 4 | null | $.b | $ | | 0 | 4 | integer | 4 | 5 | 4 | $.b[0] | $.b | | 1 | 7 | integer | 7 | 6 | 4 | $.b[1] | $.b | | 2 | 8 | integer | 8 | 7 | 4 | $.b[2] | $.b | +-----+---------+---------+------+----+--------+---------+------+
Documento más grande
En este ejemplo, usaremos un documento JSON más grande. Primero, llamemos a json_tree() sin especificar una ruta:
SELECT * FROM json_tree('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]'
);Resultado:
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| key | value | type | atom | id | parent | fullkey | path |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| null | [{"user":"Spike","age":30,"scores":[9,7,3]},{"user":"Faye"," | array | null | 0 | null | $ | $ |
| null | age":25,"scores":[90,87,93]},{"user":"Jet","age":40,"scores | null | null | null | null | null | null |
| null | ":[50,38,67]}] | null | null | null | null | null | null |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 0 | {"user":"Spike","age":30,"scores":[9,7,3]} | object | null | 1 | 0 | $[0] | $ |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| user | Spike | text | Spike | 3 | 1 | $[0].user | $[0] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| age | 30 | integer | 30 | 5 | 1 | $[0].age | $[0] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| scores | [9,7,3] | array | null | 7 | 1 | $[0].scores | $[0] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 0 | 9 | integer | 9 | 8 | 7 | $[0].scores[0] | $[0].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 1 | 7 | integer | 7 | 9 | 7 | $[0].scores[1] | $[0].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 2 | 3 | integer | 3 | 10 | 7 | $[0].scores[2] | $[0].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 1 | {"user":"Faye","age":25,"scores":[90,87,93]} | object | null | 11 | 0 | $[1] | $ |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| user | Faye | text | Faye | 13 | 11 | $[1].user | $[1] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| age | 25 | integer | 25 | 15 | 11 | $[1].age | $[1] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| scores | [90,87,93] | array | null | 17 | 11 | $[1].scores | $[1] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 0 | 90 | integer | 90 | 18 | 17 | $[1].scores[0] | $[1].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 1 | 87 | integer | 87 | 19 | 17 | $[1].scores[1] | $[1].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 2 | 93 | integer | 93 | 20 | 17 | $[1].scores[2] | $[1].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 2 | {"user":"Jet","age":40,"scores":[50,38,67]} | object | null | 21 | 0 | $[2] | $ |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| user | Jet | text | Jet | 23 | 21 | $[2].user | $[2] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| age | 40 | integer | 40 | 25 | 21 | $[2].age | $[2] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| scores | [50,38,67] | array | null | 27 | 21 | $[2].scores | $[2] |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 0 | 50 | integer | 50 | 28 | 27 | $[2].scores[0] | $[2].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 1 | 38 | integer | 38 | 29 | 27 | $[2].scores[1] | $[2].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 2 | 67 | integer | 67 | 30 | 27 | $[2].scores[2] | $[2].scores |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+ En este caso, nuestro valor JSON es una matriz que contiene tres objetos. Cada objeto se enumera en los resultados, y cada uno de los miembros de esos objetos se enumeran, junto con sus respectivos valores, y así sucesivamente.
Ahora, llamemos a json_tree() de nuevo, pero esta vez especificaremos una ruta:
SELECT * FROM json_tree('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]',
'$[1]'
);Resultado:
+--------+----------------------------------------------+---------+------+----+--------+----------------+-------------+
| key | value | type | atom | id | parent | fullkey | path |
+--------+----------------------------------------------+---------+------+----+--------+----------------+-------------+
| null | {"user":"Faye","age":25,"scores":[90,87,93]} | object | null | 11 | null | $[0] | $ |
| user | Faye | text | Faye | 13 | 11 | $[0].user | $[0] |
| age | 25 | integer | 25 | 15 | 11 | $[0].age | $[0] |
| scores | [90,87,93] | array | null | 17 | 11 | $[0].scores | $[0] |
| 0 | 90 | integer | 90 | 18 | 17 | $[0].scores[0] | $[0].scores |
| 1 | 87 | integer | 87 | 19 | 17 | $[0].scores[1] | $[0].scores |
| 2 | 93 | integer | 93 | 20 | 17 | $[0].scores[2] | $[0].scores |
+--------+----------------------------------------------+---------+------+----+--------+----------------+-------------+
En este caso, elegí el segundo elemento de la matriz especificando [1] (las matrices están basadas en cero en SQLite).
El resultado es que el árbol está limitado solo al segundo elemento de la matriz.
Profundicemos:
SELECT * FROM json_tree('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]',
'$[1].scores'
);Resultado:
+--------+------------+---------+------+----+--------+----------------+-------------+ | key | value | type | atom | id | parent | fullkey | path | +--------+------------+---------+------+----+--------+----------------+-------------+ | scores | [90,87,93] | array | null | 17 | null | $[0].scores | $[0] | | 0 | 90 | integer | 90 | 18 | 17 | $[0].scores[0] | $[0].scores | | 1 | 87 | integer | 87 | 19 | 17 | $[0].scores[1] | $[0].scores | | 2 | 93 | integer | 93 | 20 | 17 | $[0].scores[2] | $[0].scores | +--------+------------+---------+------+----+--------+----------------+-------------+
Cuanto más profundizamos, menos filas se devuelven. Eso es porque solo obtenemos un árbol que comienza en la ruta específica que especificamos.
Filtrado de la consulta
Podemos modificar nuestra consulta para filtrar los resultados en función de un criterio dado. Por ejemplo:
SELECT
fullkey,
value
FROM json_tree('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]'
)
WHERE json_tree.value LIKE '%Faye%';Resultado:
+-----------+--------------------------------------------------------------+
| fullkey | value |
+-----------+--------------------------------------------------------------+
| $ | [{"user":"Spike","age":30,"scores":[9,7,3]},{"user":"Faye"," |
| null | age":25,"scores":[90,87,93]},{"user":"Jet","age":40,"scores |
| null | ":[50,38,67]}] |
+-----------+--------------------------------------------------------------+
| $[1] | {"user":"Faye","age":25,"scores":[90,87,93]} |
+-----------+--------------------------------------------------------------+
| $[1].user | Faye |
+-----------+--------------------------------------------------------------+ Podemos devolver solo la última fila haciendo esto:
SELECT *
FROM json_tree('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]'
)
WHERE json_tree.value = 'Faye';Resultado:
+------+-------+------+------+----+--------+-----------+------+ | key | value | type | atom | id | parent | fullkey | path | +------+-------+------+------+----+--------+-----------+------+ | user | Faye | text | Faye | 13 | 11 | $[1].user | $[1] | +------+-------+------+------+----+--------+-----------+------+
Nodos hoja de retorno
Podemos limitar los resultados a solo nodos hoja si queremos. Por "nodos de hoja", me refiero solo a aquellas claves que no tienen más elementos secundarios.
Hay un par de maneras de hacer esto.
Una opción es filtrar todos los objetos y matrices:
SELECT *
FROM json_tree('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]'
)
WHERE json_tree.type NOT IN ('object','array');Resultado:
+------+-------+---------+-------+----+--------+----------------+-------------+ | key | value | type | atom | id | parent | fullkey | path | +------+-------+---------+-------+----+--------+----------------+-------------+ | user | Spike | text | Spike | 3 | 1 | $[0].user | $[0] | | age | 30 | integer | 30 | 5 | 1 | $[0].age | $[0] | | 0 | 9 | integer | 9 | 8 | 7 | $[0].scores[0] | $[0].scores | | 1 | 7 | integer | 7 | 9 | 7 | $[0].scores[1] | $[0].scores | | 2 | 3 | integer | 3 | 10 | 7 | $[0].scores[2] | $[0].scores | | user | Faye | text | Faye | 13 | 11 | $[1].user | $[1] | | age | 25 | integer | 25 | 15 | 11 | $[1].age | $[1] | | 0 | 90 | integer | 90 | 18 | 17 | $[1].scores[0] | $[1].scores | | 1 | 87 | integer | 87 | 19 | 17 | $[1].scores[1] | $[1].scores | | 2 | 93 | integer | 93 | 20 | 17 | $[1].scores[2] | $[1].scores | | user | Jet | text | Jet | 23 | 21 | $[2].user | $[2] | | age | 40 | integer | 40 | 25 | 21 | $[2].age | $[2] | | 0 | 50 | integer | 50 | 28 | 27 | $[2].scores[0] | $[2].scores | | 1 | 38 | integer | 38 | 29 | 27 | $[2].scores[1] | $[2].scores | | 2 | 67 | integer | 67 | 30 | 27 | $[2].scores[2] | $[2].scores | +------+-------+---------+-------+----+--------+----------------+-------------+
Otra forma de hacerlo es verificar el atom columna para valores nulos. Específicamente, solo devolveríamos filas donde esta columna doesn't contener un valor nulo:
SELECT *
FROM json_tree('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]'
)
WHERE atom IS NOT NULL;Resultado:
+------+-------+---------+-------+----+--------+----------------+-------------+ | key | value | type | atom | id | parent | fullkey | path | +------+-------+---------+-------+----+--------+----------------+-------------+ | user | Spike | text | Spike | 3 | 1 | $[0].user | $[0] | | age | 30 | integer | 30 | 5 | 1 | $[0].age | $[0] | | 0 | 9 | integer | 9 | 8 | 7 | $[0].scores[0] | $[0].scores | | 1 | 7 | integer | 7 | 9 | 7 | $[0].scores[1] | $[0].scores | | 2 | 3 | integer | 3 | 10 | 7 | $[0].scores[2] | $[0].scores | | user | Faye | text | Faye | 13 | 11 | $[1].user | $[1] | | age | 25 | integer | 25 | 15 | 11 | $[1].age | $[1] | | 0 | 90 | integer | 90 | 18 | 17 | $[1].scores[0] | $[1].scores | | 1 | 87 | integer | 87 | 19 | 17 | $[1].scores[1] | $[1].scores | | 2 | 93 | integer | 93 | 20 | 17 | $[1].scores[2] | $[1].scores | | user | Jet | text | Jet | 23 | 21 | $[2].user | $[2] | | age | 40 | integer | 40 | 25 | 21 | $[2].age | $[2] | | 0 | 50 | integer | 50 | 28 | 27 | $[2].scores[0] | $[2].scores | | 1 | 38 | integer | 38 | 29 | 27 | $[2].scores[1] | $[2].scores | | 2 | 67 | integer | 67 | 30 | 27 | $[2].scores[2] | $[2].scores | +------+-------+---------+-------+----+--------+----------------+-------------+
El atom columna es el valor SQL correspondiente a los elementos primitivos, elementos que no sean matrices y objetos JSON. Esta columna siempre es null para una matriz u objeto JSON. El value la columna es lo mismo que el atom columna para elementos JSON primitivos, pero toma el valor JSON de texto para matrices y objetos.
Un ejemplo de base de datos
Supongamos que tenemos la siguiente tabla:
SELECT * FROM scores;Resultado:
+---------+---------------------------------------------------------+
| teacher | students |
+---------+---------------------------------------------------------+
| Zohan | [{"Amy":[10,8,9]},{"Josh":[3,2,4]},{"Igor":[7,6,5]}] |
| Stacy | [{"Pete":[5,3,1]},{"Liz":[5,8,7]},{"Jet":[9,5,7]}] |
| Aisha | [{"Zolton":[4,6,7]},{"Bree":[7,7,4]},{"Rohit":[9,8,8]}] |
+---------+---------------------------------------------------------+
Esta tabla llamada scores tiene dos columnas. La primera columna contiene el nombre del profesor y la segunda columna contiene un documento JSON. El documento JSON contiene estudiantes y sus puntajes.
Aquí hay un ejemplo de cómo ejecutar una consulta que usa json_tree() contra esta mesa:
SELECT
teacher,
key AS student,
value
FROM
scores,
json_tree(students, '$[1].Liz')
WHERE json_tree.key = 'Liz';Resultado:
+---------+---------+---------+ | teacher | student | value | +---------+---------+---------+ | Stacy | Liz | [5,8,7] | +---------+---------+---------+
Aquí, devolvimos todos los puntajes de Liz y también devolvimos a su maestro.
La siguiente consulta devuelve su segunda puntuación:
SELECT
teacher,
key AS student,
value AS score
FROM
scores,
json_tree(students, '$[1].Liz')
WHERE json_tree.key = 1;Resultado:
+---------+---------+-------+ | teacher | student | score | +---------+---------+-------+ | Stacy | 1 | 8 | +---------+---------+-------+
