In PostgreSQL kunnen we de STRING_AGG()
. gebruiken functie om kolommen uit een zoekopdracht terug te geven als een lijst met scheidingstekens.
Syntaxis
De syntaxis gaat als volgt:
string_agg ( value text, delimiter text ) → text
string_agg ( value bytea, delimiter bytea ) → bytea
We kunnen ook de ORDER BY
. gebruiken clausule en een DISTINCT
clausule vanuit deze functie, die de uitvoer van de functie beïnvloedt. Meer hierover hieronder.
Voorbeeld
Stel dat we de volgende query uitvoeren:
SELECT PetName
FROM Pets;
En we krijgen het volgende resultaat:
+---------+ | petname | +---------+ | Fluffy | | Fetch | | Scratch | | Wag | | Tweet | | Fluffy | | Bark | | Meow | +---------+ (8 rows)
We kunnen STRING_AGG()
. gebruiken om al die rijen terug te geven als een lijst met scheidingstekens.
Geef hiervoor de PetName
. door kolom als het eerste argument, en ons gekozen scheidingsteken als het tweede argument:
SELECT STRING_AGG(PetName, ',')
FROM Pets;
Resultaat:
+-------------------------------------------------+ | string_agg | +-------------------------------------------------+ | Fluffy,Fetch,Scratch,Wag,Tweet,Fluffy,Bark,Meow | +-------------------------------------------------+ (1 row)
Het scheidingsteken wijzigen
In het vorige voorbeeld koos ik een komma als scheidingsteken. Hier is het met een ander scheidingsteken:
SELECT STRING_AGG(PetName, '-')
FROM Pets;
Resultaat:
Fluffy-Fetch-Scratch-Wag-Tweet-Fluffy-Bark-Meow
We kunnen zelfs een lege string gebruiken om alle scheidingstekens te verwijderen (zodat de waarden aaneengeschakeld worden):
SELECT STRING_AGG(PetName, '')
FROM Pets;
En we krijgen het volgende resultaat:
FluffyFetchScratchWagTweetFluffyBarkMeow
Bestellen
We kunnen de ORDER BY
. gebruiken clausule binnen de STRING_AGG()
functie om zijn eigen output te bestellen:
SELECT STRING_AGG(PetName, ',' ORDER BY PetName ASC) FROM Pets;
Resultaat:
Bark,Fetch,Fluffy,Fluffy,Meow,Scratch,Tweet,Wag
Dat was in oplopende volgorde.
Hier is het in aflopende volgorde:
SELECT STRING_AGG(PetName, ',' ORDER BY PetName DESC) FROM Pets;
Resultaat:
Wag,Tweet,Scratch,Meow,Fluffy,Fluffy,Fetch,Bark
Merk op dat dit alleen de uitvoer van de STRING_AGG()
. sorteert functie – het is volledig onafhankelijk van elke volgorde die wordt toegepast op de SELECT
verklaring zelf.
De DISTINCT
Clausule
We kunnen de DISTINCT
. gebruiken clausule om unieke waarden te retourneren. Met andere woorden, als er dubbele waarden zijn, wordt slechts één exemplaar geretourneerd:
SELECT STRING_AGG(DISTINCT PetName, ',' ORDER BY PetName ASC) FROM Pets;
Resultaat:
Bark,Fetch,Fluffy,Meow,Scratch,Tweet,Wag
In dit geval Fluffy
verschijnt maar één keer. Wanneer we het uitvoeren zonder de DISTINCT
clausule, Fluffy
verschijnt twee keer:
SELECT STRING_AGG(PetName, ',' ORDER BY PetName ASC) FROM Pets;
Resultaat:
Bark,Fetch,Fluffy,Fluffy,Meow,Scratch,Tweet,Wag
Gegroepeerde zoekopdrachtresultaten
We kunnen STRING_AGG()
. opnemen in een zoekopdracht met een GROUP BY
clausule om een resultaat als dit te bereiken:
SELECT
PetTypeId,
STRING_AGG(PetName, ',' ORDER BY PetName ASC)
FROM Pets
GROUP BY PetTypeId
ORDER BY PetTypeId;
Resultaat:
+-----------+-----------------------+ | pettypeid | string_agg | +-----------+-----------------------+ | 1 | Tweet | | 2 | Fluffy,Meow,Scratch | | 3 | Bark,Fetch,Fluffy,Wag | +-----------+-----------------------+
In mijn database staan de daadwerkelijke namen van huisdiertypes in een andere tabel genaamd PetTypes
. We zouden daarom een INNER JOIN
. kunnen uitvoeren op de PetTypes
tabel om de werkelijke namen van huisdiertypes te krijgen:
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;
Resultaat:
+---------+-----------------------+ | pettype | string_agg | +---------+-----------------------+ | Bird | Tweet | | Cat | Fluffy,Meow,Scratch | | Dog | Bark,Fetch,Fluffy,Wag | +---------+-----------------------+