MariaDB JSON_OBJECTAGG() Vysvětleno

V MariaDB, JSON_OBJECTAGG() je vestavěná funkce, která vrací objekt JSON obsahující páry klíč–hodnota na základě svých dvou argumentů.

Syntaxe

Syntaxe vypadá takto:

JSON_OBJECTAGG(key, value)

Funkce přijímá jako argumenty dva výrazy, které se vyhodnotí jako jedna hodnota nebo názvy dvou sloupců. První argument je klíč a druhý je jeho hodnota.

Příklad

Zde je jednoduchý příklad k demonstraci:

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

Výsledek:

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

Ačkoli tento příklad demonstruje, jak funkce funguje, skutečný přínos přichází při práci se sloupci nebo jinými výrazy.

Níže jsou uvedeny příklady, které pro argumenty používají sloupce databáze.

Příklad databáze

Předpokládejme, že se dotazujeme na tabulku:

SELECT 
    PetName,
    DOB
FROM Pets;

A získejte následující sadu výsledků:

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

Nyní spustíme dotaz, který předá každý sloupec do JSON_OBJECTAGG() funkce, takže výsledky jsou vráceny jako objekt JSON:

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

Výsledek:

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

Vše, co jsme udělali, bylo předat názvy sloupců do JSON_OBJECTAGG() funkce.

Také jsme použili WHERE klauzule, abyste výsledky trochu zúžili.

Skupinové výsledky

Můžeme použít SQL GROUP BY klauzule k vytváření objektů JSON na základě seskupení jiného sloupce.

Předpokládejme, že do našeho původního dotazu přidáme sloupec:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Výsledek:

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

Nyní máme PetTypeId stejně jako PetName a DOB sloupců. To odpovídá typu zvířete pro každé zvíře.

Zde je příklad použití GROUP BY klauzule k seskupení našich výsledků podle PetTypeId při použití JSON_OBJECTAGG() funkce:

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

Výsledek:

+-----------+--------------------------------------------------------------------------------+
| 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 nám umožnilo vytvořit samostatný objekt JSON pro každý typ domácího mazlíčka.

Následující dotaz používá INNER JOIN na jiný stůl, abyste vrátili skutečný typ zvířete, nikoli pouze ID.

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

Výsledek:

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

Vidíme, že skutečný typ mazlíčka je nyní uveden v prvním sloupci, nikoli pouze ID typu zvířete.

Nyní použijeme JSON_OBJECTAGG() funkce:

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;

Výsledek:

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