In SQLite, json_tree() is een functie met tabelwaarde die de JSON-waarde laat lopen die als eerste argument is opgegeven en een tabel retourneert die uit één rij bestaat voor elk arrayelement of objectlid.
We geven de JSON-waarde als argument wanneer we de functie aanroepen.
We kunnen optioneel een tweede argument doorgeven, dat een pad specificeert om vanaf te beginnen. Wanneer we dit doen, json_tree() behandelt dat pad als het element op het hoogste niveau.
De json_tree() functie loopt recursief door de JSON-substructuur, beginnend met het element op het hoogste niveau. Gebruik de json_each() om alleen de directe onderliggende items van de array of het object op het hoogste niveau te lopen, of alleen het element op het hoogste niveau zelf als het element op het hoogste niveau een primitieve waarde is. functie in plaats daarvan.
Syntaxis
We kunnen de json_tree() gebruiken functioneren op de volgende manieren:
json_tree(X)
json_tree(X,P)Waar X vertegenwoordigt de JSON, en P is een optioneel argument dat het pad vertegenwoordigt dat als het hoogste niveau moet worden behandeld.
Voorbeeld
Hier is een voorbeeld om te demonstreren hoe het werkt:
SELECT * FROM json_tree('{ "name" : "Woof", "age" : 10 }');Resultaat:
+------+--------------------------+---------+------+----+--------+---------+------+
| 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 | $ |
+------+--------------------------+---------+------+----+--------+---------+------+ We kunnen zien dat elk objectlid zijn eigen rij heeft met wat nuttige informatie, zoals het type (SQL-tekstwaarde), pad, enz.
Met betrekking tot de id kolom, volgens de SQLite-documentatie is dit een intern huishoudnummer, waarvan de berekening in toekomstige releases kan veranderen. De enige garantie is dat de id kolom zal voor elke rij anders zijn.
Array
In dit voorbeeld is de JSON-waarde een array:
SELECT * FROM json_tree('[ 10, 30, 45 ]');Resultaat:
+------+------------+---------+------+----+--------+---------+------+ | 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] | $ | +------+------------+---------+------+----+--------+---------+------+
Geef een pad op
We kunnen een tweede argument gebruiken om een pad op te geven dat als het hoogste niveau moet worden behandeld.
Voorbeeld:
SELECT * FROM json_tree('{ "a" : 1, "b" : [ 4, 7, 8 ] }', '$.b');Resultaat:
+-----+---------+---------+------+----+--------+---------+------+ | 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 | +-----+---------+---------+------+----+--------+---------+------+
Groter document
In dit voorbeeld gebruiken we een groter JSON-document. Laten we eerst json_tree() . aanroepen zonder een pad op te geven:
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 ]
}
]'
);Resultaat:
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 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 |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+ In dit geval is onze JSON-waarde een array die drie objecten bevat. Elk object wordt vermeld in de resultaten en de leden van elk van die objecten worden vermeld, samen met hun respectieve waarden, enzovoort.
Laten we nu json_tree() . aanroepen nogmaals, maar deze keer zullen we een pad specificeren:
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]'
);Resultaat:
+--------+----------------------------------------------+---------+------+----+--------+----------------+-------------+
| 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 |
+--------+----------------------------------------------+---------+------+----+--------+----------------+-------------+
In dit geval heb ik het tweede array-element gekozen door [1] op te geven (arrays zijn gebaseerd op nul in SQLite).
Het resultaat is dat de boom beperkt is tot alleen het tweede array-element.
Laten we dieper gaan:
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'
);Resultaat:
+--------+------------+---------+------+----+--------+----------------+-------------+ | 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 | +--------+------------+---------+------+----+--------+----------------+-------------+
Hoe dieper we gaan, hoe minder rijen worden geretourneerd. Dat komt omdat we alleen een boom krijgen die begint bij het specifieke pad dat we hebben opgegeven.
De zoekopdracht filteren
We kunnen onze zoekopdracht aanpassen om de resultaten te filteren op basis van een bepaald criterium. Bijvoorbeeld:
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%';Resultaat:
+-----------+--------------------------------------------------------------+
| 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 |
+-----------+--------------------------------------------------------------+ We kunnen alleen de laatste rij retourneren door dit te doen:
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';Resultaat:
+------+-------+------+------+----+--------+-----------+------+ | key | value | type | atom | id | parent | fullkey | path | +------+-------+------+------+----+--------+-----------+------+ | user | Faye | text | Faye | 13 | 11 | $[1].user | $[1] | +------+-------+------+------+----+--------+-----------+------+
Bladknopen retourneren
We kunnen de resultaten beperken tot alleen bladknooppunten als we dat willen. Met "bladknooppunten" bedoel ik alleen die sleutels die geen verdere onderliggende elementen hebben.
Er zijn een aantal manieren om dit te doen.
Een optie is om alle objecten en arrays eruit te filteren:
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');Resultaat:
+------+-------+---------+-------+----+--------+----------------+-------------+ | 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 | +------+-------+---------+-------+----+--------+----------------+-------------+
Een andere manier om dit te doen is door het atom . te controleren kolom voor null-waarden. In het bijzonder zouden we alleen rijen retourneren waar deze kolom doesn't een null-waarde bevatten:
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;Resultaat:
+------+-------+---------+-------+----+--------+----------------+-------------+ | 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 | +------+-------+---------+-------+----+--------+----------------+-------------+
Het atom kolom is de SQL-waarde die overeenkomt met primitieve elementen - andere elementen dan JSON-arrays en objecten. Deze kolom is altijd null voor een JSON-array of object. De value kolom is hetzelfde als het atom kolom voor primitieve JSON-elementen, maar neemt de tekst-JSON-waarde voor arrays en objecten aan.
Een databasevoorbeeld
Stel dat we de volgende tabel hebben:
SELECT * FROM scores;Resultaat:
+---------+---------------------------------------------------------+
| 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]}] |
+---------+---------------------------------------------------------+
Deze tabel heet scores heeft twee kolommen. De eerste kolom bevat de naam van de docent en de tweede kolom bevat een JSON-document. Het JSON-document bevat studenten en hun scores.
Hier is een voorbeeld van het uitvoeren van een query die gebruikmaakt van json_tree() tegen deze tafel:
SELECT
teacher,
key AS student,
value
FROM
scores,
json_tree(students, '$[1].Liz')
WHERE json_tree.key = 'Liz';Resultaat:
+---------+---------+---------+ | teacher | student | value | +---------+---------+---------+ | Stacy | Liz | [5,8,7] | +---------+---------+---------+
Hier hebben we alle scores voor Liz geretourneerd, en we hebben ook haar leraar teruggestuurd.
De volgende zoekopdracht levert haar tweede score op:
SELECT
teacher,
key AS student,
value AS score
FROM
scores,
json_tree(students, '$[1].Liz')
WHERE json_tree.key = 1;Resultaat:
+---------+---------+-------+ | teacher | student | score | +---------+---------+-------+ | Stacy | 1 | 8 | +---------+---------+-------+