Dalam SQLite, json_each() adalah fungsi bernilai tabel yang menjalankan nilai JSON yang diberikan sebagai argumen pertamanya dan mengembalikan tabel yang terdiri dari satu baris untuk setiap elemen larik atau anggota objek.
Kami memberikan nilai JSON sebagai argumen saat kami memanggil fungsi.
Kita dapat secara opsional meneruskan argumen kedua, yang menentukan jalur untuk memulai. Saat kita melakukan ini, json_each() memperlakukan jalur tersebut sebagai elemen tingkat atas.
json_each() function hanya menjalankan anak-anak langsung dari array atau objek tingkat atas, atau hanya elemen tingkat atas itu sendiri jika elemen tingkat atas adalah nilai primitif. Untuk menelusuri substruktur JSON secara rekursif, gunakan json_tree() sebagai gantinya.
Sintaks
Kita dapat menggunakan fungsi dengan cara berikut:
json_each(X)
json_each(X,P)Di mana X mewakili JSON, dan P adalah argumen opsional yang mewakili jalur untuk diperlakukan sebagai level teratas.
Contoh
Berikut adalah contoh untuk mendemonstrasikan cara kerjanya:
SELECT * FROM json_each('{ "name" : "Woof", "age" : 10 }');Hasil:
+------+-------+---------+------+----+--------+---------+------+ | key | value | type | atom | id | parent | fullkey | path | +------+-------+---------+------+----+--------+---------+------+ | name | Woof | text | Woof | 2 | null | $.name | $ | | age | 10 | integer | 10 | 4 | null | $.age | $ | +------+-------+---------+------+----+--------+---------+------+
Kita dapat melihat bahwa setiap anggota objek memiliki barisnya sendiri dengan beberapa informasi yang berguna, seperti tipenya (nilai teks SQL), jalur, dll.
Tentang id kolom, menurut dokumentasi SQLite ini adalah nomor rumah tangga internal, yang perhitungannya mungkin berubah di rilis mendatang. Satu-satunya jaminan adalah bahwa id kolom akan berbeda untuk setiap baris.
Kolom induk selalu null saat memanggil json_each() . Kolom ini menjadi lebih bermakna saat menggunakan json_tree() .
Array
Dalam contoh ini, nilai JSON adalah array:
SELECT * FROM json_each('[ 10, 30, 45 ]');Hasil:
+-----+-------+---------+------+----+--------+---------+------+ | key | value | type | atom | id | parent | fullkey | path | +-----+-------+---------+------+----+--------+---------+------+ | 0 | 10 | integer | 10 | 1 | null | $[0] | $ | | 1 | 30 | integer | 30 | 2 | null | $[1] | $ | | 2 | 45 | integer | 45 | 3 | null | $[2] | $ | +-----+-------+---------+------+----+--------+---------+------+
Tentukan Jalur
Kita dapat menggunakan argumen kedua untuk menentukan jalur yang akan diperlakukan sebagai level teratas.
Contoh:
SELECT * FROM json_each('{ "a" : 1, "b" : [ 4, 7, 8 ] }', '$.b');Hasil:
+-----+-------+---------+------+----+--------+---------+------+ | key | value | type | atom | id | parent | fullkey | path | +-----+-------+---------+------+----+--------+---------+------+ | 0 | 4 | integer | 4 | 5 | null | $.b[0] | $.b | | 1 | 7 | integer | 7 | 6 | null | $.b[1] | $.b | | 2 | 8 | integer | 8 | 7 | null | $.b[2] | $.b | +-----+-------+---------+------+----+--------+---------+------+
Dokumen Lebih Besar
Dalam contoh ini kita akan menggunakan dokumen JSON yang lebih besar. Pertama, panggil json_each() tanpa menentukan jalur:
SELECT * FROM json_each('[
{
"user" : "Spike",
"age" : 30,
"scores" : [ 9, 7, 3 ]
},
{
"user" : "Faye",
"age" : 25,
"scores" : [ 90, 87, 93 ]
},
{
"user" : "Jet",
"age" : 40,
"scores" : [ 50, 38, 67 ]
}
]'
);Hasil:
+-----+----------------------------------------------+--------+------+----+--------+---------+------+
| key | value | type | atom | id | parent | fullkey | path |
+-----+----------------------------------------------+--------+------+----+--------+---------+------+
| 0 | {"user":"Spike","age":30,"scores":[9,7,3]} | object | N/A | 1 | N/A | $[0] | $ |
| 1 | {"user":"Faye","age":25,"scores":[90,87,93]} | object | N/A | 11 | N/A | $[1] | $ |
| 2 | {"user":"Jet","age":40,"scores":[50,38,67]} | object | N/A | 21 | N/A | $[2] | $ |
+-----+----------------------------------------------+--------+------+----+--------+---------+------+ Dalam hal ini, nilai JSON kami adalah array yang berisi tiga objek. Setiap objek terdaftar dalam hasil.
Sekarang, panggil json_each() lagi, tapi kali ini kita akan menentukan jalur:
SELECT * FROM json_each('[
{
"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]'
);Hasil:
+--------+------------+---------+------+----+--------+-------------+------+ | key | value | type | atom | id | parent | fullkey | path | +--------+------------+---------+------+----+--------+-------------+------+ | user | Faye | text | Faye | 13 | null | $[1].user | $[1] | | age | 25 | integer | 25 | 15 | null | $[1].age | $[1] | | scores | [90,87,93] | array | null | 17 | null | $[1].scores | $[1] | +--------+------------+---------+------+----+--------+-------------+------+
Dalam hal ini saya memilih elemen array kedua dengan menentukan [1] (array berbasis nol di SQLite).
Hasilnya adalah output berisi informasi tentang elemen array kedua.
Kali ini kita dapat melihat bahwa path kolom berisi $[1] .
Mari kita masuk lebih dalam:
SELECT * FROM json_each('[
{
"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'
);Hasil:
+-----+-------+---------+------+----+--------+----------------+-------------+ | key | value | type | atom | id | parent | fullkey | path | +-----+-------+---------+------+----+--------+----------------+-------------+ | 0 | 90 | integer | 90 | 18 | null | $[1].scores[0] | $[1].scores | | 1 | 87 | integer | 87 | 19 | null | $[1].scores[1] | $[1].scores | | 2 | 93 | integer | 93 | 20 | null | $[1].scores[2] | $[1].scores | +-----+-------+---------+------+----+--------+----------------+-------------+
Sekarang kita mendapatkan baris untuk setiap elemen dalam scores larik.
Memfilter Kueri
Kami dapat memodifikasi kueri kami untuk memfilter hasil berdasarkan kriteria yang diberikan. Misalnya:
SELECT
fullkey,
value
FROM json_each('[
{
"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_each.value LIKE '%Faye%';Hasil:
+---------+----------------------------------------------+
| fullkey | value |
+---------+----------------------------------------------+
| $[1] | {"user":"Faye","age":25,"scores":[90,87,93]} |
+---------+----------------------------------------------+ Contoh Basis Data
Misalkan kita memiliki tabel berikut:
SELECT * FROM guests;Hasil:
+-------+--------------------------------------------------+ | guest | lunch | +-------+--------------------------------------------------+ | Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"] | | Amy | ["Vegetable Quiche", "Apple", "Fruit Juice"] | | Rohit | ["Beef Curry", "Dragonfruit", "Vegetable Juice"] | | Igor | ["Chicken Pie", "Jackfruit", "Fruit Juice"] | | Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] | | Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"] | +-------+--------------------------------------------------+
Tabel ini disebut guests memiliki dua kolom. Kolom pertama berisi nama tamu, dan kolom kedua berisi pesanan makan siang mereka. Mereka dapat memesan tiga hidangan untuk makan siang. Pesanan makan siang mereka dalam bentuk array, di mana setiap hidangan adalah elemen dalam array.
Berikut adalah contoh menjalankan kueri yang menggabungkan json_each() terhadap tabel ini:
SELECT DISTINCT
guest,
lunch
FROM
guests,
json_each(lunch)
WHERE json_each.value LIKE 'Apple Juice';Hasil:
+-------+-------------------------------------------------+ | guest | lunch | +-------+-------------------------------------------------+ | Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"] | | Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] | | Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"] | +-------+-------------------------------------------------+
Di sini, kami mengembalikan semua tamu yang memesan jus apel dengan makan siang mereka, bersama dengan pesanan makan siang lengkap mereka.
Jika kita ingin mengembalikan semua tamu yang memesan apel "sesuatu", kita bisa melakukan ini:
SELECT DISTINCT
guest,
lunch
FROM
guests,
json_each(lunch)
WHERE json_each.value LIKE 'Apple%';Hasil:
+-------+-------------------------------------------------+ | guest | lunch | +-------+-------------------------------------------------+ | Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"] | | Amy | ["Vegetable Quiche", "Apple", "Fruit Juice"] | | Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] | | Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"] | +-------+-------------------------------------------------+
Perhatikan bahwa saya menggunakan DISTINCT klausa dalam kueri saya. Ini memastikan kami tidak mendapatkan beberapa baris yang dikembalikan untuk tamu yang sama. Untuk menunjukkan apa yang saya maksud, inilah kuerinya lagi, tetapi tanpa DISTINCT klausa:
SELECT
guest,
lunch
FROM
guests,
json_each(lunch)
WHERE json_each.value LIKE 'Apple%';Hasil:
+-------+-------------------------------------------------+ | guest | lunch | +-------+-------------------------------------------------+ | Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"] | | Amy | ["Vegetable Quiche", "Apple", "Fruit Juice"] | | Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] | | Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"] | | Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"] | +-------+-------------------------------------------------+
Kali ini Aisha muncul dua kali. Itu karena dia memesan dua hidangan apel untuk makan siang – Apple Pie dan Apple Juice.
