Dans PostgreSQL, nous pouvons utiliser le STRING_AGG() fonction pour renvoyer les colonnes d'une requête sous forme de liste délimitée.
Syntaxe
La syntaxe ressemble à ceci :
string_agg ( value text, delimiter text ) → text
string_agg ( value bytea, delimiter bytea ) → bytea
Nous pouvons également utiliser le ORDER BY clause et un DISTINCT clause de l'intérieur de cette fonction, qui affecte la sortie de la fonction. Plus d'informations ci-dessous.
Exemple
Supposons que nous lancions la requête suivante :
SELECT PetName
FROM Pets;Et nous obtenons le résultat suivant :
+---------+ | petname | +---------+ | Fluffy | | Fetch | | Scratch | | Wag | | Tweet | | Fluffy | | Bark | | Meow | +---------+ (8 rows)
Nous pouvons utiliser STRING_AGG() pour renvoyer toutes ces lignes sous forme de liste délimitée.
Pour cela, passez le PetName colonne comme premier argument, et notre délimiteur choisi comme deuxième argument :
SELECT STRING_AGG(PetName, ',')
FROM Pets;Résultat :
+-------------------------------------------------+ | string_agg | +-------------------------------------------------+ | Fluffy,Fetch,Scratch,Wag,Tweet,Fluffy,Bark,Meow | +-------------------------------------------------+ (1 row)
Changer le délimiteur
Dans l'exemple précédent, j'ai choisi une virgule comme délimiteur. Le voici avec un délimiteur différent :
SELECT STRING_AGG(PetName, '-')
FROM Pets;Résultat :
Fluffy-Fetch-Scratch-Wag-Tweet-Fluffy-Bark-Meow
Nous pouvons même utiliser une chaîne vide pour supprimer tous les séparateurs (afin que les valeurs soient concaténées) :
SELECT STRING_AGG(PetName, '')
FROM Pets;Et nous obtenons le résultat suivant :
FluffyFetchScratchWagTweetFluffyBarkMeow
Commander
Nous pouvons utiliser le ORDER BY clause dans STRING_AGG() fonction pour ordonner sa propre sortie :
SELECT STRING_AGG(PetName, ',' ORDER BY PetName ASC) FROM Pets;Résultat :
Bark,Fetch,Fluffy,Fluffy,Meow,Scratch,Tweet,Wag
C'était par ordre croissant.
Le voici par ordre décroissant :
SELECT STRING_AGG(PetName, ',' ORDER BY PetName DESC) FROM Pets;Résultat :
Wag,Tweet,Scratch,Meow,Fluffy,Fluffy,Fetch,Bark
Notez que cela ne trie que la sortie de STRING_AGG() fonction - elle est complètement indépendante de tout ordre appliqué au SELECT déclaration elle-même.
Le DISTINCT Article
Nous pouvons utiliser le DISTINCT clause pour retourner des valeurs uniques. En d'autres termes, s'il y a des valeurs en double, une seule occurrence est renvoyée :
SELECT STRING_AGG(DISTINCT PetName, ',' ORDER BY PetName ASC) FROM Pets;Résultat :
Bark,Fetch,Fluffy,Meow,Scratch,Tweet,Wag
Dans ce cas, Fluffy n'apparaît qu'une seule fois. Lorsque nous l'exécutons sans le DISTINCT clause, Fluffy apparaît deux fois :
SELECT STRING_AGG(PetName, ',' ORDER BY PetName ASC) FROM Pets;Résultat :
Bark,Fetch,Fluffy,Fluffy,Meow,Scratch,Tweet,Wag
Résultats de requête groupés
Nous pouvons inclure STRING_AGG() dans une requête avec un GROUP BY clause pour obtenir un résultat comme celui-ci :
SELECT
PetTypeId,
STRING_AGG(PetName, ',' ORDER BY PetName ASC)
FROM Pets
GROUP BY PetTypeId
ORDER BY PetTypeId;Résultat :
+-----------+-----------------------+ | pettypeid | string_agg | +-----------+-----------------------+ | 1 | Tweet | | 2 | Fluffy,Meow,Scratch | | 3 | Bark,Fetch,Fluffy,Wag | +-----------+-----------------------+
Dans ma base de données, les noms réels des types d'animaux se trouvent dans une autre table appelée PetTypes . Nous pourrions donc exécuter un INNER JOIN sur les PetTypes table pour obtenir les noms réels des types d'animaux :
SELECT
pt.PetType,
STRING_AGG(p.PetName, ',' ORDER BY p.PetName ASC)
FROM Pets p
INNER JOIN PetTypes pt ON
p.PetTypeId = pt.PetTypeId
GROUP BY pt.PetType
ORDER BY pt.PetType ASC;Résultat :
+---------+-----------------------+ | pettype | string_agg | +---------+-----------------------+ | Bird | Tweet | | Cat | Fluffy,Meow,Scratch | | Dog | Bark,Fetch,Fluffy,Wag | +---------+-----------------------+
