In MariaDB, JSON_ARRAYAGG() is een ingebouwde functie die een JSON-array retourneert met een element voor elke waarde in een bepaalde set JSON- of SQL-waarden.
De functie werkt op een kolom of een expressie die resulteert in een enkele waarde. Hiermee kunt u een resultatenset samenvoegen als een enkele JSON-array. Elke rij van de resultatenset eindigt als een enkel element in de array.
Syntaxis
De syntaxis gaat als volgt:
JSON_ARRAYAGG([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[LIMIT {[offset,] row_count | row_count OFFSET offset}])Voorbeeld
Stel dat we een tabel opvragen:
SELECT PetName
FROM Pets;En krijg de volgende resultatenset:
+---------+ | PetName | +---------+ | Fluffy | | Fetch | | Scratch | | Wag | | Tweet | | Fluffy | | Bark | | Meow | +---------+
Het resultaat is één kolom en elke rij bevat een andere koosnaam.
Laten we zeggen dat we wilden dat alle huisdieren in een JSON-array zouden worden vermeld (zodat elke huisdierennaam zijn eigen array-element was).
We kunnen de JSON_ARRAYAGG() . gebruiken functie om precies dat te doen:
SELECT JSON_ARRAYAGG(PetName)
FROM Pets;Resultaat:
+-------------------------------------------------------------------+ | JSON_ARRAYAGG(PetName) | +-------------------------------------------------------------------+ | ["Fluffy","Fetch","Scratch","Wag","Tweet","Fluffy","Bark","Meow"] | +-------------------------------------------------------------------+
Het enige wat we deden was de kolomnaam doorgeven aan de JSON_ARRAYAGG() functie.
Afzonderlijke resultaten
We kunnen de DISTINCT . toevoegen clausule om dubbele waarden uit de array te verwijderen:
SELECT JSON_ARRAYAGG(DISTINCT PetName)
FROM Pets;Resultaat:
+----------------------------------------------------------+ | JSON_ARRAYAGG(DISTINCT PetName) | +----------------------------------------------------------+ | ["Bark","Fetch","Fluffy","Meow","Scratch","Tweet","Wag"] | +----------------------------------------------------------+
Merk op dat Fluffy was hier slechts één keer opgenomen, terwijl Fluffy was twee keer opgenomen in het vorige voorbeeld (omdat er twee huisdieren zijn genaamd Fluffy ).
Bestel de resultaten
We kunnen de ORDER BY . gebruiken clausule om een volgorde voor de array-elementen te specificeren:
SELECT JSON_ARRAYAGG(PetName ORDER BY PetName DESC)
FROM Pets;Resultaat:
+-------------------------------------------------------------------+ | JSON_ARRAYAGG(PetName ORDER BY PetName DESC) | +-------------------------------------------------------------------+ | ["Wag","Tweet","Scratch","Meow","Fluffy","Fluffy","Fetch","Bark"] | +-------------------------------------------------------------------+
Beperk de resultaten
We kunnen de LIMIT . gebruiken clausule om een volgorde voor de array-elementen te specificeren:
SELECT JSON_ARRAYAGG(PetName LIMIT 3)
FROM Pets;Resultaat:
+--------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 3) | +--------------------------------+ | ["Fluffy","Fetch","Scratch"] | +--------------------------------+
We kunnen ook een offset gebruiken voor de LIMIT clausule:
SELECT JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2)
FROM Pets;Resultaat:
+-----------------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2) | +-----------------------------------------+ | ["Scratch","Wag","Tweet"] | +-----------------------------------------+
Als alternatief kunnen we de LIMIT . weglaten en OFFSET trefwoorden, en wissel de getallen om (en scheid ze met een komma) om hetzelfde resultaat te krijgen:
SELECT JSON_ARRAYAGG(PetName LIMIT 2, 3)
FROM Pets;Resultaat:
+-----------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 2, 3) | +-----------------------------------+ | ["Scratch","Wag","Tweet"] | +-----------------------------------+
Gegroepeerde resultaten
We kunnen de SQL GROUP BY . gebruiken clausule om arrays te produceren op basis van een groepering van een andere kolom.
Stel dat we een kolom toevoegen aan onze oorspronkelijke zoekopdracht:
SELECT
PetTypeId,
PetName
FROM Pets;Resultaat:
+-----------+---------+ | PetTypeId | PetName | +-----------+---------+ | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-----------+---------+
Nu hebben we een PetTypeId kolom en de PetName kolom. Dit komt overeen met een huisdiertype voor elke naam.
Hier is een voorbeeld van het gebruik van de GROUP BY clausule om onze resultaten te groeperen op de PetTypeId kolom bij gebruik van de JSON_ARRAYAGG() functie:
SELECT
PetTypeId,
JSON_ARRAYAGG(PetName)
FROM Pets
GROUP BY PetTypeId;Resultaat:
+-----------+---------------------------------+ | PetTypeId | JSON_ARRAYAGG(PetName) | +-----------+---------------------------------+ | 1 | ["Tweet"] | | 2 | ["Fluffy","Scratch","Meow"] | | 3 | ["Fetch","Wag","Fluffy","Bark"] | +-----------+---------------------------------+
Hierdoor konden we voor elk huisdiertype een aparte array maken.
De volgende query gebruikt een INNER JOIN op een andere tafel om het werkelijke huisdiertype terug te geven, niet alleen de ID.
SELECT
pt.PetType,
p.PetName
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType;Resultaat:
+---------+---------+ | PetType | PetName | +---------+---------+ | Bird | Tweet | | Cat | Scratch | | Cat | Fluffy | | Cat | Meow | | Dog | Wag | | Dog | Fetch | | Dog | Bark | | Dog | Fluffy | +---------+---------+
We kunnen zien dat elk huisdiertype in de eerste kolom staat en de huisdiernaam in de tweede kolom.
Laten we nu de JSON_ARRAYAGG() . gebruiken functie:
SELECT
pt.PetType,
JSON_ARRAYAGG(p.PetName)
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType;Resultaat:
+---------+--------------------------+ | PetType | JSON_ARRAYAGG(p.PetName) | +---------+--------------------------+ | Bird | Tweet | | Cat | Scratch,Fluffy,Meow | | Dog | Wag,Fetch,Bark,Fluffy | +---------+--------------------------+