MariaDB JSON_ARRAYAGG() Vysvětleno

V MariaDB, JSON_ARRAYAGG() je vestavěná funkce, která vrací pole JSON obsahující prvek pro každou hodnotu v dané sadě hodnot JSON nebo SQL.

Funkce působí na sloupec nebo výraz, který se vyhodnotí jako jediná hodnota. Umožňuje agregovat sadu výsledků jako jediné pole JSON. Každý řádek sady výsledků skončí jako jeden prvek v poli.

Syntaxe

Syntaxe vypadá takto:

JSON_ARRAYAGG([DISTINCT] expr [,expr ...]
             [ORDER BY {unsigned_integer | col_name | expr}
                 [ASC | DESC] [,col_name ...]]
             [LIMIT {[offset,] row_count | row_count OFFSET offset}]) 

Příklad

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

SELECT PetName
FROM Pets; 

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

+----------+| Jméno mazlíčka |+----------+| Načechraný || Načíst || Škrábnout || Wag || Tweet || Načechraný || Kůra || Mňau |+----------+

Výsledkem je jeden sloupec a každý řádek obsahuje jiné jméno mazlíčka.

Řekněme, že jsme chtěli, aby byla všechna domácí zvířata uvedena v poli JSON (takže každé jméno mazlíčka bylo svým vlastním prvkem pole).

Můžeme použít JSON_ARRAYAGG() funkce, která to udělá:

SELECT JSON_ARRAYAGG(PetName)
FROM Pets; 

Výsledek:

+---------------------------------------------- ----------------------+| JSON_ARRAYAGG(jméno domácího mazlíčka) |+-------------------------------------------- ------------------------+| ["Načechraný","Načíst","Škrábat","Wag","Tweet","Načechraný","Kůrat","Mňau"] |+--------------- -------------------------------------------------- --+

Vše, co jsme udělali, bylo předat název sloupce do JSON_ARRAYAGG() funkce.

Odlišné výsledky

Můžeme přidat DISTINCT klauzule k odstranění duplicitních hodnot z pole:

SELECT JSON_ARRAYAGG(DISTINCT PetName)
FROM Pets; 

Výsledek:

+---------------------------------------------- ------------+| JSON_ARRAYAGG(DISTINCT PetName) |+------------------------------------------- ----------------+| ["Štěkání","Aport","Načechraný","Mňau","Škrábání","Tweet","Wag"] |+------------------- ---------------------------------------+

Všimněte si, že Fluffy byl zde zahrnut pouze jednou, zatímco Fluffy byl v předchozím příkladu zahrnut dvakrát (protože existují dva mazlíčci s názvem Fluffy ).

Objednejte si výsledky

Můžeme použít ORDER BY klauzule k určení pořadí prvků pole:

SELECT JSON_ARRAYAGG(PetName ORDER BY PetName DESC)
FROM Pets; 

Výsledek:

+---------------------------------------------- ----------------------+| JSON_ARRAYAGG(Jméno domácího mazlíčka ORDER BY PetName DESC) |+---------------------------------------- ---------------------------+| ["Wag","Tweet","Scratch","Mňau","Načechraný","Načechraný","Načíst","Štěkat"] |+--------------- -------------------------------------------------- --+

Omezit výsledky

Můžeme použít LIMIT klauzule k určení pořadí prvků pole:

SELECT JSON_ARRAYAGG(PetName LIMIT 3)
FROM Pets; 

Výsledek:

+--------------------------------+| JSON_ARRAYAGG(PetName LIMIT 3) |+--------------------------------+| ["Načechraný","Načíst","Scratch"] |+--------------------------------+ 

 Můžeme také použít offset pro LIMIT klauzule:
 
SELECT JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2)
FROM Pets; 
 

 Výsledek:
 
+-----------------------------------------+| JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2) |+---------------------------------------- -+| ["Scratch","Wag","Tweet"] |+----------------------------------- ------+
 

 Případně můžeme vynechat LIMIT a OFFSET klíčová slova a zaměňte čísla (a oddělte je čárkou), abyste dosáhli stejného výsledku:
 
SELECT JSON_ARRAYAGG(PetName LIMIT 2, 3)
FROM Pets; 
 

 Výsledek:
 
+-----------------------------------+| JSON_ARRAYAGG(PetName LIMIT 2, 3) |+-----------------------------------+| ["Scratch","Wag","Tweet"] |+----------------------------------- +
 
Skupinové výsledky
 

 Můžeme použít SQL GROUP BY klauzule k vytváření polí 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
FROM Pets; 
 

 Výsledek:
 
+-----------+---------+| PetTypeId | Jméno mazlíčka |+-----------+---------+| 2 | Načechraný || 3 | Načíst || 2 | Škrábnout || 3 | Wag || 1 | Tweet || 3 | Načechraný || 3 | Kůra || 2 | Mňau |+-----------+---------+
 

 Nyní máme PetTypeId stejně jako PetName sloupec. To odpovídá typu domácího mazlíčka ke každému jménu.
 

 Zde je příklad použití GROUP BY klauzule k seskupení našich výsledků podle PetTypeId při použití JSON_ARRAYAGG() funkce:
 
SELECT 
    PetTypeId,
    JSON_ARRAYAGG(PetName)
FROM Pets
GROUP BY PetTypeId; 
 

 Výsledek:
 
+-----------+---------------------------------+ | PetTypeId | JSON_ARRAYAGG (jméno domácího mazlíčka) |+-----------+--------------------------------- -+| 1 | ["Tweet"] || 2 | ["Fluffy","Scratch","Mňau"] || 3 | ["Aport","Wag","Fluffy","Brk"] |+-----------+------------------- --------------+
 

 To nám umožnilo vytvořit samostatné pole 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
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType; 
 

 Výsledek:
 
+----------+---------+| PetType | Jméno mazlíčka |+----------+---------+| Pták | Tweet || Kočka | Škrábnout || Kočka | Načechraný || Kočka | Mňau || Pes | Wag || Pes | Načíst || Pes | Kůra || Pes | Načechraný |+---------+---------+
 

 Vidíme, že každý typ zvířete je uveden v prvním sloupci a jméno zvířete je uvedeno ve druhém sloupci. 
 

 Nyní použijeme JSON_ARRAYAGG() funkce:
 
SELECT 
    pt.PetType,
    JSON_ARRAYAGG(p.PetName)
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType; 
 

 Výsledek:
 
+---------+--------------------------+| PetType | JSON_ARRAYAGG(p.PetName) |+---------+--------------------------+| Pták | Tweet || Kočka | Scratch, Fluffy, Meow || Pes | Wag,Aport,Brk,Fluffy |+---------+--------------------------+