MariaDB
 sql >> Base de données >  >> RDS >> MariaDB

MariaDB JSON_ARRAYAGG() expliqué

Dans MariaDB, JSON_ARRAYAGG() est une fonction intégrée qui renvoie un tableau JSON contenant un élément pour chaque valeur dans un ensemble donné de valeurs JSON ou SQL.

La fonction agit sur une colonne ou une expression qui donne une valeur unique. Il vous permet d'agréger un jeu de résultats en un seul tableau JSON. Chaque ligne du jeu de résultats se termine par un élément unique dans le tableau.

Syntaxe

La syntaxe ressemble à ceci :

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

Exemple

Supposons que nous interrogeons une table :

SELECT PetName
FROM Pets;

Et obtenez le jeu de résultats suivant :

+---------+| NomAnimal |+---------+| Moelleux || Récupérer || Gratter || Bouger || Tweeter || Moelleux || Écorce || Miaou |+---------+

Le résultat est une colonne et chaque ligne contient un nom d'animal différent.

Disons que nous voulions que tous les animaux soient répertoriés dans un tableau JSON (de sorte que chaque nom d'animal soit son propre élément de tableau).

Nous pouvons utiliser le JSON_ARRAYAGG() fonction pour faire exactement cela :

SELECT JSON_ARRAYAGG(PetName)
FROM Pets;

Résultat :

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

Tout ce que nous avons fait était de passer le nom de la colonne au JSON_ARRAYAGG() une fonction.

Des résultats distincts

Nous pouvons ajouter le DISTINCT clause pour supprimer les valeurs en double du tableau :

SELECT JSON_ARRAYAGG(DISTINCT PetName)
FROM Pets;

Résultat :

+------------------------------------------------------------ ------------+| JSON_ARRAYAGG(DISTINCT PetName) |+------------------------------------------------------- ---------------+| ["Aboie","Aller chercher","Duveteux","Miaou","Gratter","Tweet","Wag"] |+------------------- ---------------------------------------+

Remarquez que Fluffy n'a été inclus qu'une seule fois ici, alors que Fluffy a été inclus deux fois dans l'exemple précédent (car il y a deux animaux appelés Fluffy ).

Commander les résultats

Nous pouvons utiliser le ORDER BY clause pour spécifier un ordre pour les éléments du tableau :

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

Résultat :

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

Limiter les résultats

Nous pouvons utiliser le LIMIT clause pour spécifier un ordre pour les éléments du tableau :

SELECT JSON_ARRAYAGG(PetName LIMIT 3)
FROM Pets;

Résultat :

+---------------------------------------------+| JSON_ARRAYAGG(PetName LIMIT 3) |+--------------------------------+| ["Fluffy","Récupérer","Gratter"] |+--------------------------------+ 

 Nous pouvons également utiliser un décalage pour le LIMIT clause :
 
SELECT JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2)
FROM Pets; 
 

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

 Alternativement, nous pouvons omettre le LIMIT et OFFSET mots-clés, et inversez les chiffres (et séparez-les par une virgule) pour obtenir le même résultat :
 
SELECT JSON_ARRAYAGG(PetName LIMIT 2, 3)
FROM Pets; 
 

 Résultat :
 
+-----------------------------------+| JSON_ARRAYAGG(PetName LIMIT 2, 3) |+-----------------------------------+| ["Scratch","Wag","Tweet"] |+----------------------------------- +
 
Résultats groupés
 

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

 Supposons que nous ajoutions une colonne à notre requête d'origine :
 
SELECT 
    PetTypeId,
    PetName
FROM Pets; 
 

 Résultat :
 
+-----------+---------+| IDTypeAnimal | NomAnimal |+-----------+---------+| 2 | Moelleux || 3 | Récupérer || 2 | Gratter || 3 | Bouger || 1 | Tweeter || 3 | Moelleux || 3 | Écorce || 2 | Miaou |+-----------+---------+
 

 Nous avons maintenant un PetTypeId ainsi que le PetName colonne. Cela associe un type d'animal à chaque nom.
 

 Voici un exemple d'utilisation du GROUP BY clause pour regrouper nos résultats par le PetTypeId colonne lors de l'utilisation de JSON_ARRAYAGG() fonction :
 
SELECT 
    PetTypeId,
    JSON_ARRAYAGG(PetName)
FROM Pets
GROUP BY PetTypeId; 
 

 Résultat :
 
+-----------+---------------------------------------------+ | IDTypeAnimal | JSON_ARRAYAGG(PetName) |+-----------+-------------------------------- -+| 1 | ["Tweet"] || 2 | ["Moelleux","Gratter","Miaou"] || 3 | ["Aller chercher","Wag","Duveteux","Aboiement"] |+-----------+------------------- --------------+
 

 Cela nous a permis de créer un tableau séparé 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
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType; 
 

 Résultat :
 
+---------+---------+| TypeAnimal | NomAnimal |+---------+---------+| Oiseau | Tweeter || Chat | Gratter || Chat | Moelleux || Chat | Miaou || Chien | Bouger || Chien | Récupérer || Chien | Écorce || Chien | Moelleux |+---------+---------+
 

 Nous pouvons voir que chaque type d'animal est répertorié dans la première colonne et que le nom de l'animal est répertorié dans la deuxième colonne. 
 

 Utilisons maintenant le JSON_ARRAYAGG() fonction :
 
SELECT 
    pt.PetType,
    JSON_ARRAYAGG(p.PetName)
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType; 
 

 Résultat :
 
+---------+--------------------------+| TypeAnimal | JSON_ARRAYAGG(p.PetName) |+---------+--------------------------+| Oiseau | Tweeter || Chat | Gratter, Fluffy, Meow || Chien | Remuer, chercher, écorcer, moelleux |+---------+--------------------------+