MariaDB JSON_OBJECTAGG() Objaśnienie

W MariaDB, JSON_OBJECTAGG() to wbudowana funkcja, która zwraca obiekt JSON zawierający pary klucz-wartość na podstawie jego dwóch argumentów.

Składnia

Składnia wygląda tak:

JSON_OBJECTAGG(key, value)

Funkcja przyjmuje jako argumenty dwa wyrażenia, których wynikiem jest pojedyncza wartość lub dwie nazwy kolumn. Pierwszym argumentem jest klucz, a drugim jego wartość.

Przykład

Oto prosty przykład do zademonstrowania:

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

Wynik:

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

Chociaż ten przykład pokazuje, jak działa funkcja, prawdziwe korzyści pojawiają się podczas pracy z kolumnami lub innymi wyrażeniami.

Poniżej znajdują się przykłady, które używają kolumn bazy danych jako argumentów.

Przykład bazy danych

Załóżmy, że wysyłamy zapytanie do tabeli:

SELECT 
    PetName,
    DOB
FROM Pets;

I uzyskaj następujący zestaw wyników:

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

Uruchommy teraz zapytanie, które przekazuje każdą kolumnę do JSON_OBJECTAGG() funkcja, dzięki czemu wyniki są zwracane jako obiekt JSON:

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

Wynik:

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

Wszystko, co zrobiliśmy, to przekazanie nazw kolumn do JSON_OBJECTAGG() funkcjonować.

Użyliśmy również WHERE klauzula, aby nieco zawęzić wyniki.

Zgrupowane wyniki

Możemy użyć SQL GROUP BY klauzula do tworzenia obiektów JSON na podstawie grupowania innej kolumny.

Załóżmy, że dodajemy kolumnę do naszego oryginalnego zapytania:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Wynik:

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

Teraz mamy PetTypeId kolumna oraz PetName i DOB kolumny. To dopasowuje typ zwierzaka do każdego zwierzaka.

Oto przykład użycia GROUP BY klauzula grupująca nasze wyniki według PetTypeId kolumna podczas korzystania z JSON_OBJECTAGG() funkcja:

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

Wynik:

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

To pozwoliło nam stworzyć osobny obiekt JSON dla każdego typu zwierzaka.

Poniższe zapytanie używa INNER JOIN na innym stole, aby zwrócić rzeczywisty typ zwierzaka, a nie tylko identyfikator.

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

Wynik:

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

Widzimy, że rzeczywisty typ zwierzaka jest teraz wymieniony w pierwszej kolumnie, a nie tylko identyfikator typu zwierzaka.

Teraz użyjmy JSON_OBJECTAGG() funkcja:

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;

Wynik:

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