Spiegazione di MariaDB JSON_OBJECTAGG()

In MariaDB, JSON_OBJECTAGG() è una funzione incorporata che restituisce un oggetto JSON contenente coppie chiave-valore, in base ai suoi due argomenti.

Sintassi

La sintassi è questa:

JSON_OBJECTAGG(key, value)

La funzione accetta due espressioni che restituiscono un singolo valore o due nomi di colonna come argomenti. Il primo argomento è la chiave e il secondo è il suo valore.

Esempio

Ecco un semplice esempio da dimostrare:

SELECT JSON_OBJECTAGG("name", "Homer");

Risultato:

+---------------------------------+
| JSON_OBJECTAGG("name", "Homer") |
+---------------------------------+
| {"name":"Homer"}                |
+---------------------------------+

Sebbene questo esempio dimostri come funziona la funzione, il vero vantaggio si ottiene quando si lavora con colonne o altre espressioni.

Di seguito sono riportati esempi che utilizzano colonne di database per gli argomenti.

Un esempio di database

Supponiamo di interrogare una tabella:

SELECT 
    PetName,
    DOB
FROM Pets;

E ottieni il seguente set di risultati:

+---------+------------+
| PetName | DOB        |
+---------+------------+
| Fluffy  | 2020-11-20 |
| Fetch   | 2019-08-16 |
| Scratch | 2018-10-01 |
| Wag     | 2020-03-15 |
| Tweet   | 2020-11-28 |
| Fluffy  | 2020-09-17 |
| Bark    | NULL       |
| Meow    | NULL       |
+---------+------------+

Ora eseguiamo una query che passa ogni colonna a JSON_OBJECTAGG() funzione, in modo che i risultati vengano restituiti come un oggetto JSON:

SELECT JSON_OBJECTAGG(PetName, DOB)
FROM Pets
WHERE DOB < '2020-04-01';

Risultato:

+--------------------------------------------------------------------+
| JSON_OBJECTAGG(PetName, DOB)                                       |
+--------------------------------------------------------------------+
| {"Fetch":"2019-08-16", "Scratch":"2018-10-01", "Wag":"2020-03-15"} |
+--------------------------------------------------------------------+

Tutto ciò che abbiamo fatto è stato passare i nomi delle colonne a JSON_OBJECTAGG() funzione.

Abbiamo anche usato un WHERE clausola per restringere un po' i risultati.

Risultati raggruppati

Possiamo usare l'SQL GROUP BY clausola per produrre oggetti JSON basati su un raggruppamento di un'altra colonna.

Supponiamo di aggiungere una colonna alla nostra query originale:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Risultato:

+-----------+---------+------------+
| PetTypeId | PetName | DOB        |
+-----------+---------+------------+
|         2 | Fluffy  | 2020-11-20 |
|         3 | Fetch   | 2019-08-16 |
|         2 | Scratch | 2018-10-01 |
|         3 | Wag     | 2020-03-15 |
|         1 | Tweet   | 2020-11-28 |
|         3 | Fluffy  | 2020-09-17 |
|         3 | Bark    | NULL       |
|         2 | Meow    | NULL       |
+-----------+---------+------------+

Ora abbiamo un PetTypeId colonna così come il PetName e DOB colonne. Questo corrisponde a un tipo di animale domestico per ogni animale domestico.

Ecco un esempio di utilizzo di GROUP BY clausola per raggruppare i nostri risultati in base a PetTypeId colonna durante l'utilizzo di JSON_OBJECTAGG() funzione:

SELECT 
    PetTypeId,
    JSON_OBJECTAGG(PetName, DOB)
FROM Pets
GROUP BY PetTypeId;

Risultato:

+-----------+--------------------------------------------------------------------------------+
| PetTypeId | JSON_OBJECTAGG(PetName, DOB)                                                   |
+-----------+--------------------------------------------------------------------------------+
|         1 | {"Tweet":"2020-11-28"}                                                         |
|         2 | {"Fluffy":"2020-11-20", "Scratch":"2018-10-01", "Meow":null}                   |
|         3 | {"Fetch":"2019-08-16", "Wag":"2020-03-15", "Fluffy":"2020-09-17", "Bark":null} |
+-----------+--------------------------------------------------------------------------------+

Questo ci ha permesso di creare un oggetto JSON 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,
    p.DOB
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType;

Risultato:

+---------+---------+------------+
| PetType | PetName | DOB        |
+---------+---------+------------+
| Bird    | Tweet   | 2020-11-28 |
| Cat     | Scratch | 2018-10-01 |
| Cat     | Fluffy  | 2020-11-20 |
| Cat     | Meow    | NULL       |
| Dog     | Wag     | 2020-03-15 |
| Dog     | Fetch   | 2019-08-16 |
| Dog     | Bark    | NULL       |
| Dog     | Fluffy  | 2020-09-17 |
+---------+---------+------------+

Possiamo vedere che il tipo di animale domestico effettivo è ora elencato nella prima colonna, anziché solo l'ID del tipo di animale domestico.

Ora usiamo il JSON_OBJECTAGG() funzione:

SELECT 
    pt.PetType,
    JSON_OBJECTAGG(p.PetName, p.DOB)
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType;

Risultato:

+---------+--------------------------------------------------------------------------------+
| PetType | JSON_OBJECTAGG(p.PetName, p.DOB)                                               |
+---------+--------------------------------------------------------------------------------+
| Bird    | {"Tweet":"2020-11-28"}                                                         |
| Cat     | {"Scratch":"2018-10-01", "Fluffy":"2020-11-20", "Meow":null}                   |
| Dog     | {"Wag":"2020-03-15", "Fetch":"2019-08-16", "Bark":null, "Fluffy":"2020-09-17"} |
+---------+--------------------------------------------------------------------------------+