In MariaDB, JSON_ARRAYAGG() è una funzione incorporata che restituisce un array JSON contenente un elemento per ogni valore in un determinato set di valori JSON o SQL.
La funzione agisce su una colonna o un'espressione che restituisce un singolo valore. Ti consente di aggregare un set di risultati come un singolo array JSON. Ogni riga del set di risultati finisce come un singolo elemento nell'array.
Sintassi
La sintassi è questa:
JSON_ARRAYAGG([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[LIMIT {[offset,] row_count | row_count OFFSET offset}])Esempio
Supponiamo di interrogare una tabella:
SELECT PetName
FROM Pets;E ottieni il seguente set di risultati:
+---------+ | PetName | +---------+ | Fluffy | | Fetch | | Scratch | | Wag | | Tweet | | Fluffy | | Bark | | Meow | +---------+
Il risultato è una colonna e ogni riga contiene un nome di animale domestico diverso.
Diciamo che volevamo che tutti gli animali domestici fossero elencati in un array JSON (in modo che ogni nome di animale domestico fosse il proprio elemento dell'array).
Possiamo usare il JSON_ARRAYAGG() funzione per fare proprio questo:
SELECT JSON_ARRAYAGG(PetName)
FROM Pets;Risultato:
+-------------------------------------------------------------------+ | JSON_ARRAYAGG(PetName) | +-------------------------------------------------------------------+ | ["Fluffy","Fetch","Scratch","Wag","Tweet","Fluffy","Bark","Meow"] | +-------------------------------------------------------------------+
Tutto ciò che abbiamo fatto è stato passare il nome della colonna a JSON_ARRAYAGG() funzione.
Risultati distinti
Possiamo aggiungere il DISTINCT clausola per rimuovere i valori duplicati dall'array:
SELECT JSON_ARRAYAGG(DISTINCT PetName)
FROM Pets;Risultato:
+----------------------------------------------------------+ | JSON_ARRAYAGG(DISTINCT PetName) | +----------------------------------------------------------+ | ["Bark","Fetch","Fluffy","Meow","Scratch","Tweet","Wag"] | +----------------------------------------------------------+
Nota che Fluffy è stato incluso solo una volta qui, mentre Fluffy è stato incluso due volte nell'esempio precedente (perché ci sono due animali chiamati Fluffy ).
Ordina i risultati
Possiamo usare il ORDER BY clausola per specificare un ordine per gli elementi dell'array:
SELECT JSON_ARRAYAGG(PetName ORDER BY PetName DESC)
FROM Pets;Risultato:
+-------------------------------------------------------------------+ | JSON_ARRAYAGG(PetName ORDER BY PetName DESC) | +-------------------------------------------------------------------+ | ["Wag","Tweet","Scratch","Meow","Fluffy","Fluffy","Fetch","Bark"] | +-------------------------------------------------------------------+
Limita i risultati
Possiamo usare il LIMIT clausola per specificare un ordine per gli elementi dell'array:
SELECT JSON_ARRAYAGG(PetName LIMIT 3)
FROM Pets;Risultato:
+--------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 3) | +--------------------------------+ | ["Fluffy","Fetch","Scratch"] | +--------------------------------+
Possiamo anche utilizzare un offset per il LIMIT clausola:
SELECT JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2)
FROM Pets;Risultato:
+-----------------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2) | +-----------------------------------------+ | ["Scratch","Wag","Tweet"] | +-----------------------------------------+
In alternativa, possiamo omettere il LIMIT e OFFSET parole chiave e scambia i numeri (e separali con una virgola) per ottenere lo stesso risultato:
SELECT JSON_ARRAYAGG(PetName LIMIT 2, 3)
FROM Pets;Risultato:
+-----------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 2, 3) | +-----------------------------------+ | ["Scratch","Wag","Tweet"] | +-----------------------------------+
Risultati raggruppati
Possiamo usare l'SQL GROUP BY clausola per produrre array basati su un raggruppamento di un'altra colonna.
Supponiamo di aggiungere una colonna alla nostra query originale:
SELECT
PetTypeId,
PetName
FROM Pets;Risultato:
+-----------+---------+ | PetTypeId | PetName | +-----------+---------+ | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-----------+---------+
Ora abbiamo un PetTypeId colonna così come il PetName colonna. Questo corrisponde a un tipo di animale domestico a ciascun nome.
Ecco un esempio di utilizzo di GROUP BY clausola per raggruppare i nostri risultati in base a PetTypeId colonna durante l'utilizzo di JSON_ARRAYAGG() funzione:
SELECT
PetTypeId,
JSON_ARRAYAGG(PetName)
FROM Pets
GROUP BY PetTypeId;Risultato:
+-----------+---------------------------------+ | PetTypeId | JSON_ARRAYAGG(PetName) | +-----------+---------------------------------+ | 1 | ["Tweet"] | | 2 | ["Fluffy","Scratch","Meow"] | | 3 | ["Fetch","Wag","Fluffy","Bark"] | +-----------+---------------------------------+
Questo ci ha permesso di creare un array separato per ogni tipo di animale domestico.
La query seguente utilizza un INNER JOIN su un altro tavolo per restituire il tipo di animale domestico effettivo, non solo l'ID.
SELECT
pt.PetType,
p.PetName
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType;Risultato:
+---------+---------+ | PetType | PetName | +---------+---------+ | Bird | Tweet | | Cat | Scratch | | Cat | Fluffy | | Cat | Meow | | Dog | Wag | | Dog | Fetch | | Dog | Bark | | Dog | Fluffy | +---------+---------+
Possiamo vedere che ogni tipo di animale domestico è elencato nella prima colonna e il nome dell'animale domestico è elencato nella seconda colonna.
Ora usiamo il JSON_ARRAYAGG() funzione:
SELECT
pt.PetType,
JSON_ARRAYAGG(p.PetName)
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType;Risultato:
+---------+--------------------------+ | PetType | JSON_ARRAYAGG(p.PetName) | +---------+--------------------------+ | Bird | Tweet | | Cat | Scratch,Fluffy,Meow | | Dog | Wag,Fetch,Bark,Fluffy | +---------+--------------------------+
