CASE-instructies in PostgreSQL

In deze tutorial leer je hoe je voorwaardelijke queries schrijft in PostgreSQL met de CASE-voorwaardelijke expressie van PostgreSQL.

Bijgewerkt 2 okt 2026 · 7 min lezen

Verken met AI

ChatGPT Claude Perplexity

Voorwaardelijke expressies zijn een van de meest fundamentele elementen van elke programmeerparadigma. Veelvoorkomende voorwaardelijke expressies zijn if-else-blokken en switch-cases. In PostgreSQL kun je voorwaardelijke expressies formuleren met een WHEN-THEN-case, die erg lijkt op if-else-blokken. In deze tutorial leer je hoe je dit doet.

Voordat je begint met het schrijven van voorwaardelijke queries, is het belangrijk dat je een lokale PostgreSQL-database opzet. Dat doe je in de eerste sectie van deze tutorial.

Let op: Om deze tutorial te kunnen volgen, moet je de basis van SQL en PostgreSQL kennen. Fris je geheugen gerust op met de volgende bronnen:

Een PostgreSQL-database lokaal opzetten

Volg dit artikel om de database op te zetten. Nadat je de back-up succesvol hebt teruggezet, zou je deze tabellen in de database moeten zien:

countries
route_table
station_table
train_table

In deze tutorial gebruiken we echter alleen de tabel countries. Voel je vrij om de tabellen in de databaseback-up te verkennen. Ook kun je je eigen databases en tabellen vormen. Als je de databaseback-up hebt teruggezet, zou je nu een tabel moeten hebben die is gevuld met gegevens over verschillende landen wereldwijd. Laten we de tabel countries nu heel kort verkennen.

De tabel `countries` heel kort verkennen

Na het terugzetten van de database kun je de tabel bekijken in de pgAdmin-interface, die wordt meegeleverd met de standaardinstallatie van PostgreSQL. Door een eenvoudige SELECT-instructie uit te voeren, kom je meer te weten over de kolommen, hun datatypes en ook de rijen die de tabel bevat -

De tabel bevat gegevens over in totaal 206 verschillende landen uit diverse regio's van de wereld. Hoeveel regio's precies? De onderstaande query geeft je het antwoord op die vraag.

SELECT COUNT(DISTINCT(region)) from countries;

Het blijkt dat er 23 verschillende regio's in deze tabel voorkomen, zoals West-Europa, Polynesië, het Midden-Oosten enzovoort. Je kunt de tabel zelf verkennen met snelle vragen en onderweg interessante feiten ontdekken. Laten we nu kijken naar de anatomie van een basis-PostgreSQL-CASE.

Introductie tot PostgreSQL-`CASE`

Hieronder staat de algemene vorm van een PostgreSQL-case met een WHEN-THEN-constructie -

CASE
     WHEN condition_1  THEN result_1
     WHEN condition_2  THEN result_2
     ...
     ELSE  result_n
END

Hier zijn een paar belangrijke punten om in gedachten te houden bij het opstellen van CASE's in PostgreSQL:

Elke conditie is een booleaanse expressie en op basis van de uitkomst wordt het resultaat gekozen. Als alle expressies die bij WHEN horen als False worden geëvalueerd, dan wordt het resultaat van het ELSE-gedeelte getoond. Als je het ELSE-gedeelte niet opgeeft, retourneert de query null.
Een conditie wordt doorgaans toegepast op een kolom die aanwezig is in de tabel waarop je werkt. Voorwaardelijke queryconstructies zoals hierboven worden meestal met SELECT-instructies gedaan. Houd er rekening mee dat de kolom waarop je de booleaanse expressies specificeert (in CASE) aanwezig moet zijn in de SELECT van je query. Maar wanneer je CASE samen met een where-clausule gebruikt, hoef je dit niet te volgen (daarover later meer).
Het datatype van de resultaten moet uniform zijn. Je kunt niet een string retourneren in result_1 en een integer in result_2 enzovoort.

Laten we nu in een paar voorbeelden duiken.

PostgreSQL-`CASE`'s schrijven

We beginnen eenvoudig. Je gaat nu een CASE schrijven om landen te groeperen op basis van het jaar van onafhankelijkheid. De onafhankelijkheidsjaren staan in de kolom indep_year. Stel dat je drie groepen onafhankelijkheidsjaren wilt hanteren. Je maakt hiervoor drie groepen -

Voor 1900 (indep_year < 1900)
Tussen 1900 en 1930 (indep_year <= 1930)
Na 1930 (indep_year > 1930)

Het eindresultaat van de query moet de volgende kolommen bevatten -

name (van het land)
continent (waar het land toe behoort)
indep_year
En de groep van onafhankelijkheidsjaren die je maakt. Laten we die indep_year_group noemen.

Laten we nu de query schrijven -

SELECT name, continent, indep_year,
    CASE WHEN indep_year < 1900 THEN 'before 1900'
         WHEN indep_year <= 1930 THEN 'between 1900 and 1930'
         ELSE 'after 1930' END
         AS indep_year_group
FROM countries
ORDER BY indep_year_group;

(De query is geïnspireerd op DataCamps cursus Joining Data in SQL.)

Na het uitvoeren van de query zie je veel landen, zoals Palestina, Puerto Rico, enz., waarvoor in de tabel geen onafhankelijkheidsjaar is opgegeven. Daarom kwamen ze in de groep between 1900 and 1930 terecht.

PostgreSQL-CASE's kunnen meerdere voorwaarden hebben. Er zijn een handvol invoeren in de tabel waarbij de naam van het land en de hoofdstad hetzelfde zijn. Je kunt dit toevoegen aan je eerder geconstrueerde CASE -

SELECT name, continent, indep_year,
    CASE WHEN (indep_year < 1900) AND (countries.name = countries.capital) THEN 'before 1900 and capital same'
         WHEN indep_year <= 1930 AND (countries.name = countries.capital) THEN 'between 1900 and 1930 and capital same'
         ELSE 'after 1930_and_no_same_capital' END
         AS indep_year_group
FROM countries
ORDER BY indep_year_group;

Een ander interessant aspect van CASE's is dat je ze kunt combineren met aggregatiefuncties zoals SUM(). Om een CASE te gebruiken met de aggregatiefunctie SUM(), heb je een andere tabel nodig waar dit zinvol is. Laten we een eenvoudige tabel student_grades maken met de volgende kolommen en datatypes -

student_name (string)
student_stream (string)
student_grade (character)

De volgende query maakt de tabel voor je -

CREATE TABLE student_grades
(student_name character varying,
student_stream character varying,
student_grade character);

Laten we nu een paar records in de tabel invoegen. Dat kan met enkele INSERT-instructies. Stel dat de tabel student_grades na het invoegen de volgende records bevat -

Nu schrijf je een CASE om de som te krijgen van studenten die tot bepaalde cijfergroepen behoren. Zoals je ziet zijn er volgens de instanties van de tabel drie verschillende cijfers — A, B en C. De voorwaardelijke query moet een output opleveren die lijkt op het volgende -

De query hiervoor -

SELECT
 SUM (
 CASE
 WHEN student_grade = 'A' THEN
 1
 ELSE
 0
 END
 ) AS "High Scoring",
 SUM (
 CASE
 WHEN student_grade = 'B' THEN
 1
 ELSE
 0
 END
 ) AS "Mid Scoring",
 SUM (
 CASE
 WHEN student_grade = 'C' THEN
 1
 ELSE
 0
 END
 ) AS "Low Scoring"
FROM
 student_grades;

Zo kun je CASE combineren met aggregatiefuncties om interessante inzichten uit de data te halen.

Conclusie en verder lezen

Dat was het voor deze tutorial. In deze tutorial heb je geleerd hoe je if-then-achtige voorwaarden in je SQL-queries verwerkt om tot interessante rapportages te komen. Je hebt meerdere voorbeelden doorlopen om deze vaardigheid te versterken. Als je op zoek bent naar meer uitdagende oefeningen, volg dan de volgende DataCamp-cursussen over SQL -

Laat me je vragen over deze tutorial gerust weten via de sectie Comments.

Onderwerpen

SQL

Data Science