Introductie tot SQL-joins

In deze tutorial leer je over de werking van joins in SQL en de verschillende types.

Bijgewerkt 1 jun 2026 · 9 min lezen

Tijdens je data-analyse in SQL moet je vaak meerdere tabellen bekijken en ze joinen om de gewenste resultaten te krijgen. Tabellen joinen voor data-analyse is ook een vereiste vaardigheid voor een data scientist. In deze tutorial leer je over verschillende soorten joins die je kunt uitvoeren in PostgreSQL. Je bestudeert eerst de basisconcepten van joins in SQL, daarna leer je de verschillende typen joins en wat hun syntaxis is in PostgreSQL. Je rondt deze tutorial af door verschillende soorten join-queries uit te voeren met twee tabellen. Om mee te kunnen doen, moet je bekend zijn met de basis van SQL en met het schrijven van eenvoudige queries in PostgreSQL. Als je op zoek bent naar bronnen om dit te leren, zijn de volgende nuttig:

Beginner’s Guide to PostgreSQL
Intro to SQL for Data Science-cursus van DataCamp

Laten we beginnen.

TL;DR

SQL-joins laten je data uit twee of meer tabellen combineren met behulp van een gemeenschappelijke kolom.
INNER JOIN geeft alleen overeenkomende rijen terug, terwijl varianten van OUTER JOIN (LEFT, RIGHT, FULL) niet-overeenkomende rijen van één of beide kanten behouden en de gaten opvullen met NULL.
CROSS JOIN produceert elke mogelijke combinatie van rijen (het cartesisch product), en SELF JOIN laat je een tabel met zichzelf joinen — handig om rijen binnen dezelfde dataset te vergelijken.
Semi-joins en anti-joins, geschreven als subqueries met IN of NOT IN, filteren rijen uit één tabel op basis van of ze wel of niet voldoen aan voorwaarden in een andere tabel.

De database-omgeving in PostgreSQL instellen

Voordat je de basis van SQL-joins bestudeert, is het een goed idee om een paar tabellen te maken voor je analyses. Je hebt minimaal twee tabellen nodig met ten minste één gemeenschappelijke kolom. Hoewel je self-join-queries op dezelfde tabel kunt uitvoeren, negeren we dat voor nu even.

Je kunt alle SQL-bewerkingen uitvoeren in een tool genaamd pgAdmin, die meestal wordt meegeleverd met de installatie van PostgreSQL. Open pgAdmin en maak een database (geef het een naam naar keuze) om de tabellen te maken als je geen bestaande database hebt om mee verder te gaan. Vervolgens kun je de volgende twee tabellen maken met de opgegeven specificaties:

student_name (id, name)
student_stream (id, stream)

Let op dat beide tabellen de kolom id gemeen hebben. Je kunt de volgende CREATE-statements gebruiken om de tabellen te maken:

Voor student_name -

CREATE TABLE student_name
(
id smallint,
name "char"[]
);

Voor student_stream -

CREATE TABLE student_stream
(
id smallint,
stream "char"[]
);

Laten we nu wat records in de tabellen invoegen.

Voor student_name -

INSERT INTO student_name(id, name) VALUES (1, 'Sayak');

INSERT INTO student_name(id, name) VALUES (2, 'Alex');

INSERT INTO student_name(id, name) VALUES (3, 'Sameer');

INSERT INTO student_name(id, name) VALUES (4, 'Rick');

Voor student_stream -

INSERT INTO student_stream(id, stream) VALUES (1, 'CS');

INSERT INTO student_stream(id, stream) VALUES (1, 'IT');

INSERT INTO student_stream(id, stream) VALUES (2, 'ECE');

INSERT INTO student_stream(id, stream) VALUES (9, 'ECE');

De tabelinhoud zou er als volgt uit moeten zien als je de bovenstaande queries hebt uitgevoerd zonder iets te wijzigen:

Je hebt nu twee eenvoudige tabellen klaarstaan. Laten we nu verdergaan met de basis van SQL-joins.

SQL-joins – basis

SQL-joins stellen je in staat om twee of meer (soms slechts één) tabellen samen te voegen met behulp van gemeenschappelijke identifiers. Neem het voorbeeld van de twee tabellen die je hebt gemaakt: beide tabellen hebben de kolom id gemeen. Je kunt je afvragen waarom je zou moeten joinen in SQL. Laten we dit kort bespreken.

Door beperkingen van normalisatie heb je mogelijk niet alle benodigde informatie in één enkele tabel. Normalisatie is niet alleen wenselijk maar ook noodzakelijk om consistentie te behouden, redundantie te verminderen en invoeg- en update-anomalieën te voorkomen. Bekijk de bovenstaande twee tabellen opnieuw. Stel dat je de studierichtingen wilt achterhalen waarin Sayak is ingeschreven. Om dit te beantwoorden, moet je de twee tabellen joinen (subqueries kunnen ook worden gebruikt, maar dat laten we nu even buiten beschouwing) en vervolgens verder gaan.

Om twee tabellen te joinen, moet er iets gemeenschappelijks tussen beide zijn. Betekent dit dat beide tabellen minstens één kolom met dezelfde naam moeten hebben? Of wat is precies die voorwaarde?

De tabellen die je wilt joinen hoeven geen kolom met dezelfde naam te hebben, maar logisch moeten ze wel overeenkomen, oftewel: hun datatypes moeten hetzelfde zijn. Je kunt geen twee tabellen joinen die een kolom met dezelfde naam maar verschillende datatypes hebben. Laten we nu de verschillende soorten SQL-joins bestuderen.

Verschillende typen SQL-joins

In dit deel bestudeer je meerdere soorten SQL-joins:

INNER JOIN
- Self-join
OUTER JOIN
- LEFT JOIN
- RIGHT JOIN
- FULL JOIN
CROSS JOIN
Semi-join en anti-join

PostgreSQL biedt aparte sleutelwoorden voor de joins die in hoofdletters vermeld staan. Laten we ze één voor één bekijken. Eerst bekijk je de joins visueel en daarna voer je de bijbehorende join-queries uit in PostgreSQL.

INNER JOIN

Bekijk het volgende diagram om INNER JOIN visueel te begrijpen:

In het bovenstaande voorbeeld is de kolom waarnaar wordt gekeken de id-kolom. INNER JOIN negeert de rest van de rijen waarvoor de waarden niet in beide tabellen voorkomen. Laten we nu een query in PostgreSQL uitvoeren die een INNER JOIN uitvoert tussen de twee tabellen — student_name en student_stream.

Na het uitvoeren van de volgende query krijg je het resultaat zoals weergegeven in de bovenstaande figuur:

SELECT s1.id, s1.name, s2.stream
FROM student_name AS s1
INNER JOIN student_stream AS s2
ON s1.id = s2.id;

s1 en s2 zijn aliassen voor de twee tabellen. Je gebruikte het sleutelwoord ON samen met INNER JOIN. De query kan ook worden uitgevoerd met het sleutelwoord USING:

SELECT s1.id, s1.name, s2.stream
FROM student_name AS s1
INNER JOIN student_stream AS s2
USING (id);

Self-join stelt je in staat dezelfde tabel te joinen. Maar wanneer is dit handig? Stel dat je een tabel hebt met de volgende kolommen:

Country
Continent

Nu wil je twee landen opsommen op zo’n manier dat hun continenten hetzelfde zijn. De volgende figuur geeft je een idee van het verwachte resultaat:

OUTER JOIN

OUTER JOIN kan verder worden onderverdeeld in drie typen:

LEFT JOIN of Left Outer JOIN: Het volgende diagram geeft je een goed beeld van LEFT JOIN in SQL:

Let op dat, in tegenstelling tot INNER JOIN, LEFT JOIN de records uit de linkertabel (t.o.v. de volgorde die je in je query opgeeft) ophaalt waarvoor er geen overeenkomende entry in de rechtertabel was. Dit vertelt je dus dat Sameer en Rick zich voor geen enkele studiestroom hebben ingeschreven. De bijbehorende query hiervoor is:

SELECT s1.id, s1.name, s2.stream
FROM student_name AS s1
LEFT JOIN student_stream AS s2
ON s1.id = s2.id;

RIGHT JOIN of Right Outer JOIN: RIGHT JOIN is precies het tegenovergestelde van LEFT JOIN:

RIGHT JOIN kan je helpen de studiestroom (of stromen) te vinden waarvoor geen enkele student is ingeschreven. De query hiervoor is:

SELECT s1.id, s1.name, s2.stream
FROM student_name AS s1
RIGHT JOIN student_stream AS s2
ON s1.id = s2.id;

FULL JOIN of Full Outer JOIN: met FULL JOIN combineer je LEFT JOIN en RIGHT JOIN in één geheel:

De bijbehorende query is:

SELECT s1.id, s1.name, s2.stream
FROM student_name AS s1
FULL JOIN student_stream AS s2
ON s1.id = s2.id;

Let op dat je alle bovenstaande OUTER JOIN-queries ook kunt uitvoeren met het sleutelwoord USING. Laten we nu CROSS JOIN bekijken.

CROSS JOIN

CROSS JOIN is in wezen het cartesisch product tussen twee elementen uitgedrukt in SQL. Stel dat je alle mogelijke combinaties tussen twee tabellen of zelfs binnen één tabel nodig hebt. Daarvoor gebruik je CROSS JOIN. De volgende figuur toont dit concept visueel:

Je hebt al twee tabellen om dit te testen. Om alle mogelijke combinaties tussen de id-kolommen van de tabellen student_name en student_stream te krijgen, kun je de volgende query uitvoeren:

SELECT s1.id, s2.id
FROM student_name AS s1
CROSS JOIN student_stream AS s2;

En je krijgt het volgende resultaat:

Bekijk nu de andere twee soorten joins waarvoor PostgreSQL geen directe sleutelwoorden biedt.

Semi-join en anti-join

Laten we de tabellen bekijken die je eerder in de tutorial hebt aangemaakt:

Semi Join-queries worden doorgaans uitgevoerd in de vorm van subqueries, waarbij rijen uit de eerste tabel worden opgepikt op basis van een voorwaarde (of een set voorwaarden) die overeenkomt in de tweede tabel. Laten we aannemen dat de linkertabel de eerste tabel is en de rechtertabel de tweede.

Anti Join-queries zijn precies het tegenovergestelde. Bij Anti Join worden rijen uit de eerste tabel opgepikt op basis van een voorwaarde (of een set voorwaarden) die niet overeenkomt in de tweede tabel. Hier is een diagram om dit visueel te begrijpen:

De query om de Semi Join te realiseren is:

select id, name
from student_name
where id IN
(select id from student_stream where stream
IN ('CS', 'IT', 'ECE'));

Evenzo is de query die Anti Join in dit geval realiseert:

select id, name
from student_name
where id NOT IN
(select id from student_stream where stream
IN ('CS', 'IT', 'ECE'));

Let op het gebruik van NOT in de bovenstaande query.

Je SQL-join-vaardigheden naar een hoger niveau tillen

Dat was het voor deze tutorial. Je hebt een reeks verschillende soorten SQL-joins bestudeerd en je ook vertrouwd gemaakt met hun PostgreSQL-syntaxis. Wil je uitdagende oefenopgaven met SQL-joins doen, volg dan de DataCamp-cursus Joining Data in SQL. Sterker nog, materiaal uit die cursus is als referentie gebruikt voor deze tutorial.

Laat me je vragen weten in de sectie Comments.

Onderwerpen

SQL

Data-analyse