W SQLite, json_tree() to funkcja z wartościami przechowywanymi w tabeli, która przeszukuje wartość JSON podaną jako pierwszy argument i zwraca tabelę składającą się z jednego wiersza dla każdego elementu tablicy lub elementu obiektu.
Podajemy wartość JSON jako argument, gdy wywołujemy funkcję.
Opcjonalnie możemy przekazać drugi argument, który określa ścieżkę startową. Kiedy to zrobimy, json_tree() traktuje tę ścieżkę jako element najwyższego poziomu.
json_tree() funkcja rekursywnie przechodzi przez podstrukturę JSON, zaczynając od elementu najwyższego poziomu. Aby przejść tylko do bezpośrednich elementów podrzędnych tablicy lub obiektu najwyższego poziomu, lub tylko do samego elementu najwyższego poziomu, jeśli element najwyższego poziomu jest wartością pierwotną, użyj json_each() zamiast tego.
Składnia
Możemy użyć json_tree() działają w następujący sposób:
json_tree(X)
json_tree(X,P)Gdzie X reprezentuje JSON, a P jest opcjonalnym argumentem, który reprezentuje ścieżkę, którą należy traktować jako najwyższy poziom.
Przykład
Oto przykład pokazujący, jak to działa:
SELECT * FROM json_tree('{ "name" : "Woof", "age" : 10 }');Wynik:
+------+--------------------------+---------+------+----+--------+---------+------+
| 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 | $ |
+------+--------------------------+---------+------+----+--------+---------+------+ Widzimy, że każdy element obiektu ma swój własny wiersz z przydatnymi informacjami, takimi jak typ (wartość tekstowa SQL), ścieżka itp.
Odnośnie id kolumna, zgodnie z dokumentacją SQLite jest to wewnętrzny numer porządkowy, którego obliczenia mogą ulec zmianie w przyszłych wydaniach. Jedyną gwarancją jest to, że id kolumna będzie inna dla każdego wiersza.
Tablica
W tym przykładzie wartość JSON jest tablicą:
SELECT * FROM json_tree('[ 10, 30, 45 ]');Wynik:
+------+------------+---------+------+----+--------+---------+------+ | 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] | $ | +------+------------+---------+------+----+--------+---------+------+
Określ ścieżkę
Możemy użyć drugiego argumentu, aby określić ścieżkę, która będzie traktowana jako najwyższy poziom.
Przykład:
SELECT * FROM json_tree('{ "a" : 1, "b" : [ 4, 7, 8 ] }', '$.b');Wynik:
+-----+---------+---------+------+----+--------+---------+------+ | 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 | +-----+---------+---------+------+----+--------+---------+------+
Większy dokument
W tym przykładzie użyjemy większego dokumentu JSON. Najpierw wywołajmy json_tree() bez określania ścieżki:
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 ]
}
]'
);Wynik:
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+
| 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 |
+--------+--------------------------------------------------------------+---------+-------+------+--------+----------------+-------------+ W tym przypadku naszą wartością JSON jest tablica zawierająca trzy obiekty. Każdy obiekt jest wymieniony w wynikach, a każdy z członków tych obiektów jest wymieniony wraz z odpowiednimi wartościami i tak dalej.
Teraz wywołajmy json_tree() ponownie, ale tym razem określimy ścieżkę:
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]'
);Wynik:
+--------+----------------------------------------------+---------+------+----+--------+----------------+-------------+
| 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 |
+--------+----------------------------------------------+---------+------+----+--------+----------------+-------------+
W tym przypadku wybrałem drugi element tablicy, określając [1] (tablice mają wartość zero w SQLite).
W rezultacie drzewo jest ograniczone tylko do drugiego elementu tablicy.
Przejdźmy głębiej:
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'
);Wynik:
+--------+------------+---------+------+----+--------+----------------+-------------+ | 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 | +--------+------------+---------+------+----+--------+----------------+-------------+
Im głębiej idziemy, tym mniej wierszy jest zwracanych. Dzieje się tak, ponieważ otrzymujemy tylko drzewo, które zaczyna się na określonej przez nas ścieżce.
Filtrowanie zapytania
Możemy zmodyfikować nasze zapytanie, aby filtrować wyniki na podstawie podanych kryteriów. Na przykład:
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%';Wynik:
+-----------+--------------------------------------------------------------+
| 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 |
+-----------+--------------------------------------------------------------+ Możemy zwrócić tylko ostatni wiersz w ten sposób:
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';Wynik:
+------+-------+------+------+----+--------+-----------+------+ | key | value | type | atom | id | parent | fullkey | path | +------+-------+------+------+----+--------+-----------+------+ | user | Faye | text | Faye | 13 | 11 | $[1].user | $[1] | +------+-------+------+------+----+--------+-----------+------+
Powrotne węzły liści
Możemy ograniczyć wyniki tylko do węzłów liści, jeśli chcemy. Przez „węzły liści” rozumiem tylko te klucze, które nie mają dalszych elementów potomnych.
Można to zrobić na kilka sposobów.
Jedną z opcji jest odfiltrowanie wszystkich obiektów i tablic:
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');Wynik:
+------+-------+---------+-------+----+--------+----------------+-------------+ | 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 | +------+-------+---------+-------+----+--------+----------------+-------------+
Innym sposobem na to jest sprawdzenie atom kolumna dla wartości null. W szczególności zwrócilibyśmy tylko wiersze, w których ta kolumna doesn't zawierają wartość pustą:
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;Wynik:
+------+-------+---------+-------+----+--------+----------------+-------------+ | 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 | +------+-------+---------+-------+----+--------+----------------+-------------+
atom kolumna to wartość SQL odpowiadająca elementom pierwotnym – elementom innym niż tablice i obiekty JSON. Ta kolumna jest zawsze null dla tablicy lub obiektu JSON. value kolumna jest taka sama jak atom kolumna dla pierwotnych elementów JSON, ale przyjmuje wartość tekstową JSON dla tablic i obiektów.
Przykład bazy danych
Załóżmy, że mamy następującą tabelę:
SELECT * FROM scores;Wynik:
+---------+---------------------------------------------------------+
| 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]}] |
+---------+---------------------------------------------------------+
Ta tabela o nazwie scores ma dwie kolumny. Pierwsza kolumna zawiera nazwisko nauczyciela, a druga kolumna zawiera dokument JSON. Dokument JSON zawiera uczniów i ich wyniki.
Oto przykład uruchomienia zapytania, które używa json_tree() w stosunku do tej tabeli:
SELECT
teacher,
key AS student,
value
FROM
scores,
json_tree(students, '$[1].Liz')
WHERE json_tree.key = 'Liz';Wynik:
+---------+---------+---------+ | teacher | student | value | +---------+---------+---------+ | Stacy | Liz | [5,8,7] | +---------+---------+---------+
Tutaj zwróciliśmy wszystkie wyniki dla Liz, a także zwróciliśmy jej nauczyciela.
Następujące zapytanie zwraca jej drugi wynik:
SELECT
teacher,
key AS student,
value AS score
FROM
scores,
json_tree(students, '$[1].Liz')
WHERE json_tree.key = 1;Wynik:
+---------+---------+-------+ | teacher | student | score | +---------+---------+-------+ | Stacy | 1 | 8 | +---------+---------+-------+
