SQLite JSON_EACH ()

Trong SQLite, json_each() là một hàm có giá trị bảng, đi giá trị JSON được cung cấp làm đối số đầu tiên của nó và trả về một bảng bao gồm một hàng cho mỗi phần tử mảng hoặc thành viên đối tượng.

Chúng tôi cung cấp giá trị JSON làm đối số khi chúng tôi gọi hàm.

Chúng ta có thể tùy chọn chuyển đối số thứ hai, đối số này chỉ định một đường dẫn để bắt đầu. Khi chúng tôi thực hiện việc này, json_each() coi đường dẫn đó là phần tử cấp cao nhất.

json_each() hàm chỉ đi các phần tử con trực tiếp của mảng hoặc đối tượng cấp cao nhất hoặc chỉ của chính phần tử cấp cao nhất nếu phần tử cấp cao nhất là một giá trị nguyên thủy. Để duyệt đệ quy qua cấu trúc con JSON, hãy sử dụng json_tree() thay vào đó.

Cú pháp

Chúng ta có thể sử dụng hàm theo những cách sau:

json_each(X)
json_each(X,P)

Trong đó X đại diện cho JSON và P là một đối số tùy chọn đại diện cho đường dẫn được coi là cấp cao nhất.

Ví dụ

Dưới đây là một ví dụ để chứng minh cách hoạt động:

SELECT * FROM json_each('{ "name" : "Woof", "age" : 10 }');

Kết quả:

+------+-------+---------+------+----+--------+---------+------+
| key  | value |  type   | atom | id | parent | fullkey | path |
+------+-------+---------+------+----+--------+---------+------+
| name | Woof  | text    | Woof | 2  | null   | $.name  | $    |
| age  | 10    | integer | 10   | 4  | null   | $.age   | $    |
+------+-------+---------+------+----+--------+---------+------+

Chúng ta có thể thấy rằng mỗi thành viên đối tượng có hàng riêng với một số thông tin hữu ích, chẳng hạn như kiểu của nó (giá trị văn bản SQL), đường dẫn, v.v.

Về id , theo tài liệu SQLite, đây là số quản lý nội bộ, việc tính toán số này có thể thay đổi trong các bản phát hành trong tương lai. Đảm bảo duy nhất là id cột sẽ khác nhau cho mọi hàng.

Cột mẹ luôn là null khi gọi json_each() . Cột này trở nên có ý nghĩa hơn khi sử dụng json_tree() .

Mảng

Trong ví dụ này, giá trị JSON là một mảng:

SELECT * FROM json_each('[ 10, 30, 45 ]');

Kết quả:

+-----+-------+---------+------+----+--------+---------+------+
| 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]    | $    |
+-----+-------+---------+------+----+--------+---------+------+

Chỉ định một đường dẫn

Chúng ta có thể sử dụng đối số thứ hai để chỉ định một đường dẫn được coi là cấp cao nhất.

Ví dụ:

SELECT * FROM json_each('{ "a" : 1, "b" : [ 4, 7, 8 ] }', '$.b');

Kết quả:

+-----+-------+---------+------+----+--------+---------+------+
| 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  |
+-----+-------+---------+------+----+--------+---------+------+

Tài liệu lớn hơn

Trong ví dụ này, chúng tôi sẽ sử dụng tài liệu JSON lớn hơn. Đầu tiên, hãy gọi json_each() mà không chỉ định đường dẫn:

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 ]
        }
        ]'
    );

Kết quả:

+-----+----------------------------------------------+--------+------+----+--------+---------+------+
| 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]    | $    |
+-----+----------------------------------------------+--------+------+----+--------+---------+------+

Trong trường hợp này, giá trị JSON của chúng ta là một mảng chứa ba đối tượng. Mỗi đối tượng được liệt kê trong kết quả.

Bây giờ, hãy gọi json_each() một lần nữa, nhưng lần này chúng tôi sẽ chỉ định một đường dẫn:

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]'
    );

Kết quả:

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

Trong trường hợp này, tôi đã chọn phần tử mảng thứ hai bằng cách chỉ định [1] (mảng bằng 0 dựa trên SQLite).

Kết quả là đầu ra chứa thông tin về phần tử mảng thứ hai.

Lần này chúng ta có thể thấy rằng path cột chứa $[1] .

Hãy đi sâu hơn:

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'
    );

Kết quả:

+-----+-------+---------+------+----+--------+----------------+-------------+
| 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 |
+-----+-------+---------+------+----+--------+----------------+-------------+

Bây giờ chúng ta nhận được một hàng cho mỗi phần tử trong scores mảng.

Lọc truy vấn

Chúng tôi có thể sửa đổi truy vấn của mình để lọc kết quả dựa trên một tiêu chí nhất định. Ví dụ:

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%';

Kết quả:

+---------+----------------------------------------------+
| fullkey |                    value                     |
+---------+----------------------------------------------+
| $[1]    | {"user":"Faye","age":25,"scores":[90,87,93]} |
+---------+----------------------------------------------+

Một ví dụ về cơ sở dữ liệu

Giả sử chúng ta có bảng sau:

SELECT * FROM guests;

Kết quả:

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

Bảng này được gọi là guests có hai cột. Cột đầu tiên chứa tên của khách và cột thứ hai chứa đơn đặt hàng bữa trưa của họ. Họ có thể gọi ba món ăn cho bữa trưa. Thứ tự bữa trưa của họ có dạng một mảng, trong đó mỗi món ăn là một phần tử trong mảng.

Dưới đây là ví dụ về việc chạy truy vấn kết hợp json_each() so với bảng này:

SELECT DISTINCT
    guest,
    lunch
FROM 
    guests, 
    json_each(lunch)
WHERE json_each.value LIKE 'Apple Juice';

Kết quả:

+-------+-------------------------------------------------+
| guest |                      lunch                      |
+-------+-------------------------------------------------+
| Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"]      |
| Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] |
| Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"]   |
+-------+-------------------------------------------------+

Tại đây, chúng tôi đã trả lại tất cả những khách đã đặt nước ép táo cùng với bữa trưa của họ, cùng với đơn đặt hàng bữa trưa đầy đủ của họ.

Nếu chúng tôi muốn trả lại tất cả những khách đã đặt hàng táo "một cái gì đó", chúng tôi có thể làm như sau:

SELECT DISTINCT
    guest,
    lunch
FROM 
    guests, 
    json_each(lunch)
WHERE json_each.value LIKE 'Apple%';

Kết quả:

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

Lưu ý rằng tôi đã sử dụng DISTINCT mệnh đề trong truy vấn của tôi. Điều này đảm bảo chúng tôi không trả lại nhiều hàng cho cùng một khách. Để chứng minh ý tôi, đây là truy vấn một lần nữa, nhưng không có DISTINCT mệnh đề:

SELECT
    guest,
    lunch
FROM 
    guests, 
    json_each(lunch)
WHERE json_each.value LIKE 'Apple%';

Kết quả:

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

Lần này Aisha xuất hiện hai lần. Đó là vì cô ấy đã gọi hai món táo cho bữa trưa - Bánh táo và Nước ép táo.