In MariaDB, JSON_ARRAYAGG() ist eine integrierte Funktion, die ein JSON-Array zurückgibt, das ein Element für jeden Wert in einem bestimmten Satz von JSON- oder SQL-Werten enthält.
Die Funktion wirkt auf eine Spalte oder einen Ausdruck, der zu einem einzelnen Wert ausgewertet wird. Es ermöglicht Ihnen, eine Ergebnismenge als einzelnes JSON-Array zu aggregieren. Jede Zeile der Ergebnismenge endet als einzelnes Element im Array.
Syntax
Die Syntax lautet wie folgt:
JSON_ARRAYAGG([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[LIMIT {[offset,] row_count | row_count OFFSET offset}]) Beispiel
Angenommen, wir fragen eine Tabelle ab:
SELECT PetName
FROM Pets; Und erhalten Sie die folgende Ergebnismenge:
+---------+| Tiername |+---------+| Flauschig || || holen Kratzer || Wag || Twittern || Flauschig || Rinde || Miau |+---------+
Das Ergebnis ist eine Spalte, und jede Zeile enthält einen anderen Kosenamen.
Nehmen wir an, wir wollten, dass alle Haustiere in einem JSON-Array aufgelistet werden (so dass jeder Haustiername ein eigenes Array-Element ist).
Wir können JSON_ARRAYAGG() verwenden Funktion, um genau das zu tun:
SELECT JSON_ARRAYAGG(PetName)
FROM Pets; Ergebnis:
Wir haben lediglich den Spaltennamen an JSON_ARRAYAGG() übergeben Funktion.
Eindeutige Ergebnisse
Wir können den DISTINCT hinzufügen -Klausel zum Entfernen doppelter Werte aus dem Array:
SELECT JSON_ARRAYAGG(DISTINCT PetName)
FROM Pets; Ergebnis:
Beachten Sie, dass Fluffy wurde hier nur einmal eingefügt, während Fluffy war im vorherigen Beispiel zweimal enthalten (weil es zwei Haustiere namens Fluffy gibt ).
Ergebnisse anordnen
Wir können den ORDER BY verwenden -Klausel, um eine Reihenfolge für die Array-Elemente anzugeben:
SELECT JSON_ARRAYAGG(PetName ORDER BY PetName DESC)
FROM Pets; Ergebnis:
Begrenzen Sie die Ergebnisse
Wir können das LIMIT verwenden -Klausel, um eine Reihenfolge für die Array-Elemente anzugeben:
SELECT JSON_ARRAYAGG(PetName LIMIT 3)
FROM Pets; Ergebnis:
+-------------------------------+| JSON_ARRAYAGG(PetName LIMIT 3) |+-------------------------------+| ["Flauschig","Fetch","Kratz"] |+-------------------------------+
Wir können auch einen Offset für das LIMIT verwenden Klausel:
SELECT JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2)
FROM Pets; Ergebnis:
+------------------------------------+| JSON_ARRAYAGG(Haustiername LIMIT 3 OFFSET 2) |+---------------------------------------- -+| ["Scratch","Wag","Tweet"] |+----------------------------------- ------+
Alternativ können wir das LIMIT weglassen und OFFSET Keywords, und vertauschen Sie die Zahlen (und trennen Sie sie durch ein Komma), um dasselbe Ergebnis zu erzielen:
SELECT JSON_ARRAYAGG(PetName LIMIT 2, 3)
FROM Pets; Ergebnis:
+-----------------------------------+| JSON_ARRAYAGG(PetName LIMIT 2, 3) |+-----------------------------------+| ["Scratch","Wag","Tweet"] |+----------------------------------- +
Gruppierte Ergebnisse
Wir können den SQL GROUP BY verwenden -Klausel, um Arrays basierend auf einer Gruppierung einer anderen Spalte zu erstellen.
Angenommen, wir fügen unserer ursprünglichen Abfrage eine Spalte hinzu:
SELECT
PetTypeId,
PetName
FROM Pets; Ergebnis:
+-----------+---------+| PetTypeId | Tiername |+-----------+---------+| 2 | Flauschig || 3 | || holen 2 | Kratzer || 3 | Wag || 1 | Twittern || 3 | Flauschig || 3 | Rinde || 2 | Miau |+-----------+---------+
Jetzt haben wir eine PetTypeId sowie der PetName Säule. Dies ordnet jedem Namen einen Pet-Typ zu.
Hier ist ein Beispiel für die Verwendung von GROUP BY -Klausel, um unsere Ergebnisse nach PetTypeId zu gruppieren -Spalte, während Sie JSON_ARRAYAGG() verwenden Funktion:
SELECT
PetTypeId,
JSON_ARRAYAGG(PetName)
FROM Pets
GROUP BY PetTypeId; Ergebnis:
+-----------+---------------------------------+ | PetTypeId | JSON_ARRAYAGG(Tiername) |+-----------+-------------------------------- -+| 1 | ["Twittern"] || 2 | ["Flauschig","Kratz","Miau"] || 3 | ["Fetch","Wag","Fluffy","Bark"] |+-----------+------------------- --------------+
Dadurch konnten wir für jeden Haustiertyp ein separates Array erstellen.
Die folgende Abfrage verwendet einen INNER JOIN in einer anderen Tabelle, um den tatsächlichen Tiertyp zurückzugeben, nicht nur die ID.
SELECT
pt.PetType,
p.PetName
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType; Ergebnis:
+---------+---------+| Haustiertyp | Tiername |+---------+---------+| Vogel | Twittern || Katze | Kratzer || Katze | Flauschig || Katze | Miau || Hund | Wag || Hund | || holen Hund | Rinde || Hund | Flauschig |+---------+---------+
Wir können sehen, dass jeder Pet-Typ in der ersten Spalte aufgeführt ist und der Name des Pets in der zweiten Spalte aufgeführt ist.
Lassen Sie uns nun JSON_ARRAYAGG() verwenden Funktion:
SELECT
pt.PetType,
JSON_ARRAYAGG(p.PetName)
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType; Ergebnis:
+---------+---------------------+| Haustiertyp | JSON_ARRAYAGG(p.PetName) |+---------+--------------------------+| Vogel | Twittern || Katze | Kratzen, Flauschig, Miau || Hund | Wedeln, Holen, Bellen, Flauschig |+---------+--------------------------+
