MariaDB JSON_OBJECTAGG() Обяснено

В MariaDB, JSON_OBJECTAGG() е вградена функция, която връща JSON обект, съдържащ двойки ключ-стойност, въз основа на двата му аргумента.

Синтаксис

Синтаксисът е така:

JSON_OBJECTAGG(key, value)

Функцията приема два израза, които се оценяват на една стойност или две имена на колони, като аргументи. Първият аргумент е ключът, а вторият е неговата стойност.

Пример

Ето един прост пример за демонстрация:

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

Резултат:

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

Въпреки че този пример демонстрира как работи функцията, истинската полза идва при работа с колони или други изрази.

По-долу са дадени примери, които използват колони на базата данни за аргументите.

Пример за база данни

Да предположим, че правим заявка за таблица:

SELECT 
    PetName,
    DOB
FROM Pets;

И вземете следния набор от резултати:

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

Нека сега изпълним заявка, която предава всяка колона към JSON_OBJECTAGG() функция, така че резултатите да се връщат като JSON обект:

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

Резултат:

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

Всичко, което направихме, беше да предадем имената на колоните към JSON_OBJECTAGG() функция.

Използвахме и WHERE клауза, за да стесните малко резултатите.

Групирани резултати

Можем да използваме SQL GROUP BY клауза за създаване на JSON обекти въз основа на групиране на друга колона.

Да предположим, че добавяме колона към нашата оригинална заявка:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Резултат:

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

Сега имаме PetTypeId колона, както и PetName и DOB колони. Това съответства на тип домашен любимец за всеки домашен любимец.

Ето пример за използване на GROUP BY клауза за групиране на нашите резултати по PetTypeId колона, докато използвате JSON_OBJECTAGG() функция:

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

Резултат:

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

Това ни позволи да създадем отделен JSON обект за всеки тип домашен любимец.

Следната заявка използва INNER JOIN на друга таблица, за да върнете действителния тип домашен любимец, а не само ID.

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

Резултат:

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

Можем да видим, че действителният тип домашен любимец вече е посочен в първата колона, вместо само идентификационния номер на типа домашен любимец.

Сега нека използваме JSON_OBJECTAGG() функция:

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;

Резултат:

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