MariaDB JSON_ARRAYAGG() Forklaret

I MariaDB, JSON_ARRAYAGG() er en indbygget funktion, der returnerer et JSON-array, der indeholder et element for hver værdi i et givet sæt af JSON- eller SQL-værdier.

Funktionen virker på en kolonne eller et udtryk, der evalueres til en enkelt værdi. Det giver dig mulighed for at samle et resultatsæt som et enkelt JSON-array. Hver række i resultatsættet ender som et enkelt element i arrayet.

Syntaks

Syntaksen ser sådan ud:

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

Eksempel

Antag, at vi forespørger i en tabel:

SELECT PetName
FROM Pets; 

Og få følgende resultatsæt:

+--------+| Kæledyrsnavn |+--------+| Fluffy || Hent || Ridse || Wag || Tweet || Fluffy || Bark || Mjav |+---------+

Resultatet er én kolonne, og hver række indeholder et andet kæledyrsnavn.

Lad os sige, at vi ønskede, at alle kæledyrene skulle være opført i et JSON-array (så at hvert kæledyrsnavn var sit eget array-element).

Vi kan bruge JSON_ARRAYAGG() funktion til at gøre netop det:

SELECT JSON_ARRAYAGG(PetName)
FROM Pets; 

Resultat:

+---------------------------------------------- ----------------------+| JSON_ARRAYAGG(PetName) |+-------------------------------------------------------- ----------------------------+| ["Fluffy","Fetch","Scratch","Wag","Tweet","Fluffy","Bark","Meow"] |+--------- -------------------------------------------------- --+

Det eneste, vi gjorde, var at videregive kolonnenavnet til JSON_ARRAYAGG() fungere.

Særlige resultater

Vi kan tilføje DISTINCT klausul for at fjerne duplikerede værdier fra arrayet:

SELECT JSON_ARRAYAGG(DISTINCT PetName)
FROM Pets; 

Resultat:

+---------------------------------------------- ------------+| JSON_ARRAYAGG(DISTINCT PetName) |+-------------------------------------------------------- ---------------+| ["Bark","Fetch","Fluffy","Meow","Scratch","Tweet","Wag"] |+-------------------------- -----------------------------------------------+

Bemærk, at Fluffy blev kun inkluderet én gang her, hvorimod Fluffy blev inkluderet to gange i det foregående eksempel (fordi der er to kæledyr kaldet Fluffy ).

Bestil resultaterne

Vi kan bruge ORDER BY klausul for at angive en rækkefølge for array-elementerne:

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

Resultat:

+---------------------------------------------- ----------------------+| JSON_ARRAYAGG(PetName ORDER BY PetName DESC) |+---------------------------------------- --------------------------+| ["Wag","Tweet","Scratch","Meow","Fluffy","Fluffy","Fetch","Bark"] |+--------- -------------------------------------------------- --+

Begræns resultaterne

Vi kan bruge LIMIT klausul for at angive en rækkefølge for array-elementerne:

SELECT JSON_ARRAYAGG(PetName LIMIT 3)
FROM Pets; 

Resultat:

+--------------------------------+| JSON_ARRAYAGG(PetName LIMIT 3) |+--------------------------------+| ["Fluffy","Fetch","Scratch"] |+----------------------------------------+ 

 Vi kan også bruge en offset for LIMIT klausul:
 
SELECT JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2)
FROM Pets; 
 

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

 Alternativt kan vi udelade LIMIT og OFFSET søgeord, og skift tallene rundt (og adskil dem med et komma) for at opnå det samme resultat:
 
SELECT JSON_ARRAYAGG(PetName LIMIT 2, 3)
FROM Pets; 
 

 Resultat:
 
+----------------------------------------+| JSON_ARRAYAGG(PetName LIMIT 2, 3) |+----------------------------------------+| ["Scratch","Wag","Tweet"] |+------------------------------------------------ +
 
Grupperte resultater
 

 Vi kan bruge SQL GROUP BY klausul for at producere arrays baseret på en gruppering af en anden kolonne.
 

 Antag, at vi tilføjer en kolonne til vores oprindelige forespørgsel:
 
SELECT 
    PetTypeId,
    PetName
FROM Pets; 
 

 Resultat:
 
+-----------+---------+| PetTypeId | Kæledyrsnavn |+-----------+---------+| 2 | Fluffy || 3 | Hent || 2 | Ridse || 3 | Wag || 1 | Tweet || 3 | Fluffy || 3 | Bark || 2 | Mjav |+-----------+---------+
 

 Nu har vi et PetTypeId kolonnen samt PetName kolonne. Dette matcher en kæledyrstype til hvert navn.
 

 Her er et eksempel på brug af GROUP BY klausul for at gruppere vores resultater efter PetTypeId kolonne, mens du bruger JSON_ARRAYAGG() funktion:
 
SELECT 
    PetTypeId,
    JSON_ARRAYAGG(PetName)
FROM Pets
GROUP BY PetTypeId; 
 

 Resultat:
 
+------+----------------------------------+ | PetTypeId | JSON_ARRAYAGG(PetName) |+-----+-------------------------------- -+| 1 | ["Tweet"] || 2 | ["Fluffy","Scratch","Meow"] || 3 | ["Fetch","Wag","Fluffy","Bark"] |+------+------------------- --------------+
 

 Dette gjorde det muligt for os at oprette et separat array for hver kæledyrstype.
 

 Følgende forespørgsel bruger en INNER JOIN på et andet bord for at returnere den faktiske kæledyrstype, ikke kun ID'et.
 
SELECT 
    pt.PetType,
    p.PetName
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType; 
 

 Resultat:
 
+--------+---------+| PetType | Kæledyrsnavn |+--------+---------+| Fugl | Tweet || Kat | Ridse || Kat | Fluffy || Kat | Mjav || Hund | Wag || Hund | Hent || Hund | Bark || Hund | Fluffy |+--------+---------+
 

 Vi kan se, at hver kæledyrstype er angivet i den første kolonne, og kæledyrsnavnet er angivet i den anden kolonne. 
 

 Lad os nu bruge JSON_ARRAYAGG() funktion:
 
SELECT 
    pt.PetType,
    JSON_ARRAYAGG(p.PetName)
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType; 
 

 Resultat:
 
+--------+---------------------------------+| PetType | JSON_ARRAYAGG(p.PetName) |+--------+--------------------------------+| Fugl | Tweet || Kat | Scratch,Fluffy,Meow || Hund | Wag,Fetch,Bark,Fluffy |+--------+--------------------------------+