MariaDB JSON_OBJECTAGG() expliqué

Dans MariaDB, JSON_OBJECTAGG() est une fonction intégrée qui renvoie un objet JSON contenant des paires clé-valeur, en fonction de ses deux arguments.

Syntaxe

La syntaxe ressemble à ceci :

JSON_OBJECTAGG(key, value)

La fonction accepte deux expressions qui évaluent une seule valeur, ou deux noms de colonne, comme arguments. Le premier argument est la clé et le second sa valeur.

Exemple

Voici un exemple simple pour illustrer :

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

Résultat :

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

Bien que cet exemple montre comment la fonction fonctionne, le véritable avantage se présente lorsque vous travaillez avec des colonnes ou d'autres expressions.

Vous trouverez ci-dessous des exemples qui utilisent des colonnes de base de données pour les arguments.

Un exemple de base de données

Supposons que nous interrogeons une table :

SELECT 
    PetName,
    DOB
FROM Pets;

Et obtenez le jeu de résultats suivant :

+---------+------------+
| 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       |
+---------+------------+

Exécutons maintenant une requête qui passe chaque colonne au JSON_OBJECTAGG() fonction, afin que les résultats soient renvoyés sous la forme d'un objet JSON :

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

Résultat :

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

Tout ce que nous avons fait était de passer les noms de colonne au JSON_OBJECTAGG() une fonction.

Nous avons également utilisé un WHERE clause pour réduire un peu les résultats.

Résultats groupés

Nous pouvons utiliser le SQL GROUP BY clause pour produire des objets JSON basés sur un regroupement d'une autre colonne.

Supposons que nous ajoutions une colonne à notre requête d'origine :

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Résultat :

+-----------+---------+------------+
| 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       |
+-----------+---------+------------+

Nous avons maintenant un PetTypeId ainsi que le PetName et DOB Colonnes. Cela associe un type d'animal à chaque animal.

Voici un exemple d'utilisation du GROUP BY clause pour regrouper nos résultats par le PetTypeId colonne en utilisant JSON_OBJECTAGG() fonction :

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

Résultat :

+-----------+--------------------------------------------------------------------------------+
| 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} |
+-----------+--------------------------------------------------------------------------------+

Cela nous a permis de créer un objet JSON distinct pour chaque type d'animal.

La requête suivante utilise un INNER JOIN sur une autre table pour renvoyer le type d'animal réel, pas seulement l'ID.

SELECT 
    pt.PetType,
    p.PetName,
    p.DOB
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType;

Résultat :

+---------+---------+------------+
| 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 |
+---------+---------+------------+

Nous pouvons voir que le type d'animal réel est maintenant répertorié dans la première colonne, au lieu de simplement l'ID du type d'animal.

Utilisons maintenant le JSON_OBJECTAGG() fonction :

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;

Résultat :

+---------+--------------------------------------------------------------------------------+
| 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"} |
+---------+--------------------------------------------------------------------------------+