MariaDB JSON_OBJECTAGG () Giải thích

Trong MariaDB, JSON_OBJECTAGG() là một hàm tích hợp trả về một đối tượng JSON có chứa các cặp khóa-giá trị, dựa trên hai đối số của nó.

Cú pháp

Cú pháp như sau:

JSON_OBJECTAGG(key, value)

Hàm chấp nhận hai biểu thức đánh giá một giá trị hoặc hai tên cột làm đối số. Đối số đầu tiên là khóa và đối số thứ hai là giá trị của nó.

Ví dụ

Dưới đây là một ví dụ đơn giản để chứng minh:

SELECT JSON_OBJECTAGG("name", "Homer");

Kết quả:

+---------------------------------+
| JSON_OBJECTAGG("name", "Homer") |
+---------------------------------+
| {"name":"Homer"}                |
+---------------------------------+

Mặc dù ví dụ này trình bày cách hoạt động của hàm, nhưng lợi ích thực sự sẽ mang lại khi làm việc với các cột hoặc các biểu thức khác.

Dưới đây là các ví dụ sử dụng cột cơ sở dữ liệu cho các đối số.

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

Giả sử chúng ta truy vấn một bảng:

SELECT 
    PetName,
    DOB
FROM Pets;

Và nhận được tập hợp kết quả sau:

+---------+------------+
| PetName | DOB        |
+---------+------------+
| Fluffy  | 2020-11-20 |
| Fetch   | 2019-08-16 |
| Scratch | 2018-10-01 |
| Wag     | 2020-03-15 |
| Tweet   | 2020-11-28 |
| Fluffy  | 2020-09-17 |
| Bark    | NULL       |
| Meow    | NULL       |
+---------+------------+

Bây giờ chúng ta hãy chạy một truy vấn chuyển từng cột đến JSON_OBJECTAGG() để các kết quả được trả về dưới dạng một đối tượng JSON:

SELECT JSON_OBJECTAGG(PetName, DOB)
FROM Pets
WHERE DOB < '2020-04-01';

Kết quả:

+--------------------------------------------------------------------+
| JSON_OBJECTAGG(PetName, DOB)                                       |
+--------------------------------------------------------------------+
| {"Fetch":"2019-08-16", "Scratch":"2018-10-01", "Wag":"2020-03-15"} |
+--------------------------------------------------------------------+

Tất cả những gì chúng tôi đã làm là chuyển tên cột vào JSON_OBJECTAGG() hàm số.

Chúng tôi cũng đã sử dụng WHERE để thu hẹp kết quả xuống một chút.

Kết quả được nhóm

Chúng ta có thể sử dụng SQL GROUP BY mệnh đề để tạo các đối tượng JSON dựa trên nhóm của một cột khác.

Giả sử chúng ta thêm một cột vào truy vấn ban đầu của mình:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Kết quả:

+-----------+---------+------------+
| PetTypeId | PetName | DOB        |
+-----------+---------+------------+
|         2 | Fluffy  | 2020-11-20 |
|         3 | Fetch   | 2019-08-16 |
|         2 | Scratch | 2018-10-01 |
|         3 | Wag     | 2020-03-15 |
|         1 | Tweet   | 2020-11-28 |
|         3 | Fluffy  | 2020-09-17 |
|         3 | Bark    | NULL       |
|         2 | Meow    | NULL       |
+-----------+---------+------------+

Bây giờ chúng ta có một PetTypeId cũng như PetName và DOB cột. Điều này phù hợp với loại vật nuôi cho từng vật nuôi.

Đây là ví dụ về việc sử dụng GROUP BY mệnh đề nhóm các kết quả của chúng tôi theo PetTypeId trong khi sử dụng JSON_OBJECTAGG() chức năng:

SELECT 
    PetTypeId,
    JSON_OBJECTAGG(PetName, DOB)
FROM Pets
GROUP BY PetTypeId;

Kết quả:

+-----------+--------------------------------------------------------------------------------+
| PetTypeId | JSON_OBJECTAGG(PetName, DOB)                                                   |
+-----------+--------------------------------------------------------------------------------+
|         1 | {"Tweet":"2020-11-28"}                                                         |
|         2 | {"Fluffy":"2020-11-20", "Scratch":"2018-10-01", "Meow":null}                   |
|         3 | {"Fetch":"2019-08-16", "Wag":"2020-03-15", "Fluffy":"2020-09-17", "Bark":null} |
+-----------+--------------------------------------------------------------------------------+

Điều này cho phép chúng tôi tạo một đối tượng JSON riêng biệt cho từng loại vật nuôi.

Truy vấn sau sử dụng INNER JOIN trên một bảng khác để trả về loại vật nuôi thực tế, không chỉ ID.

SELECT 
    pt.PetType,
    p.PetName,
    p.DOB
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType;

Kết quả:

+---------+---------+------------+
| PetType | PetName | DOB        |
+---------+---------+------------+
| Bird    | Tweet   | 2020-11-28 |
| Cat     | Scratch | 2018-10-01 |
| Cat     | Fluffy  | 2020-11-20 |
| Cat     | Meow    | NULL       |
| Dog     | Wag     | 2020-03-15 |
| Dog     | Fetch   | 2019-08-16 |
| Dog     | Bark    | NULL       |
| Dog     | Fluffy  | 2020-09-17 |
+---------+---------+------------+

Chúng ta có thể thấy rằng loại vật nuôi thực tế hiện được liệt kê trong cột đầu tiên, thay vì chỉ ID loại vật nuôi.

Bây giờ, hãy sử dụng JSON_OBJECTAGG() chức năng:

SELECT 
    pt.PetType,
    JSON_OBJECTAGG(p.PetName, p.DOB)
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType;

Kết quả:

+---------+--------------------------------------------------------------------------------+
| PetType | JSON_OBJECTAGG(p.PetName, p.DOB)                                               |
+---------+--------------------------------------------------------------------------------+
| Bird    | {"Tweet":"2020-11-28"}                                                         |
| Cat     | {"Scratch":"2018-10-01", "Fluffy":"2020-11-20", "Meow":null}                   |
| Dog     | {"Wag":"2020-03-15", "Fetch":"2019-08-16", "Bark":null, "Fluffy":"2020-09-17"} |
+---------+--------------------------------------------------------------------------------+