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