Welke klanten hebben een bestelling? Die vraag kun je in T-SQL op drie manieren stellen: met een JOIN, met WHERE EXISTS of met IN. Voor de omgekeerde vraag, welke klanten géén bestelling hebben, heb je LEFT JOIN ... IS NULL, NOT EXISTS en NOT IN. Ze lijken hetzelfde te doen. Ze geven niet altijd hetzelfde resultaat.
Het korte antwoord:
- Heb je kolommen uit de andere tabel nodig? Gebruik een
JOIN. - Wil je alleen weten of er een rij is? Gebruik
EXISTS. - Wil je weten of er géén rij is? Gebruik
NOT EXISTS. - Gebruik
NOT INniet op een kolom die NULL kan zijn.
De testtabellen
Ik gebruik twee tabellen: 100.000 klanten en 1.000.000 bestellingen. De bestellingen horen bij 59.994 klanten. Honderd bestellingen hebben geen klant: KlantId is daar NULL. Dat komt in het echt ook voor, bijvoorbeeld bij een kassabon zonder klantkaart.
CREATE TABLE dbo.Klant( KlantId int NOT NULL PRIMARY KEY, Naam varchar(50) NOT NULL, Plaats varchar(50) NOT NULL);
CREATE TABLE dbo.Bestelling( BestellingId int NOT NULL PRIMARY KEY, KlantId int NULL, Besteldatum date NOT NULL, Bedrag decimal(10,2) NOT NULL);
-- 100.000 klantenWITH n AS ( SELECT TOP (100000) ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS i FROM sys.all_objects AS a CROSS JOIN sys.all_objects AS b)INSERT dbo.Klant (KlantId, Naam, Plaats)SELECT i, CONCAT('Klant ', i), CASE i % 4 WHEN 0 THEN 'Utrecht' WHEN 1 THEN 'Zwolle' WHEN 2 THEN 'Breda' ELSE 'Leeuwarden' ENDFROM n;
-- 1.000.000 bestellingen van 60.000 klanten; 100 zonder klant (NULL)WITH n AS ( SELECT TOP (1000000) ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS i FROM sys.all_objects AS a CROSS JOIN sys.all_objects AS b)INSERT dbo.Bestelling (BestellingId, KlantId, Besteldatum, Bedrag)SELECT i, CASE WHEN i % 10000 = 0 THEN NULL ELSE 1 + (i * 7919) % 60000 END, DATEADD(DAY, i % 1000, '20240101'), i % 500 + 0.95FROM n;Het script werkt ook op oudere versies, want het gebruikt geen GENERATE_SERIES. Ik heb alles gedraaid op SQL Server 2025 Developer Edition, eerst zonder en daarna met een index op Bestelling(KlantId). De reads hieronder zijn logical reads uit SET STATISTICS IO.
JOIN: als je kolommen uit de andere tabel nodig hebt
SELECT k.KlantId, k.NaamFROM dbo.Klant AS kJOIN dbo.Bestelling AS b ON b.KlantId = k.KlantId;Deze query geeft 999.900 rijen. Een JOIN maakt een rij voor elke match, dus een klant met 17 bestellingen staat er 17 keer in. Wil je weten welke klanten iets besteld hebben, dan is dat fout. Wil je elke bestelling met de naam van de klant, dan is het precies goed.
Een JOIN is ook de juiste keus als je iets uit de andere tabel optelt:
SELECT k.KlantId, k.Naam, SUM(b.Bedrag) AS OmzetFROM dbo.Klant AS kJOIN dbo.Bestelling AS b ON b.KlantId = k.KlantIdGROUP BY k.KlantId, k.Naam;Hier heb je b.Bedrag nodig. Met EXISTS kom je daar niet bij.
EXISTS: als je alleen wilt weten óf er iets is
SELECT k.KlantId, k.NaamFROM dbo.Klant AS kWHERE EXISTS (SELECT 1 FROM dbo.Bestelling AS b WHERE b.KlantId = k.KlantId);Deze query geeft 59.994 rijen: elke klant met een bestelling één keer. EXISTS is waar zodra de subquery een rij vindt. Wat er in de SELECT van de subquery staat, maakt niet uit. SELECT 1 is een gewoonte.
Veel mensen lossen de dubbele rijen van de JOIN op met DISTINCT:
SELECT DISTINCT k.KlantId, k.NaamFROM dbo.Klant AS kJOIN dbo.Bestelling AS b ON b.KlantId = k.KlantId;Dat geeft ook 59.994 rijen. Is EXISTS dan sneller? Niet in deze test. SQL Server 2025 maakte van beide queries hetzelfde plan, een Hash Match (Left Semi Join), met dezelfde reads: 1.375 op Klant en 3.650 op Bestelling. IN gaf ook hetzelfde plan. De optimizer ziet dat KlantId de primary key is en dat je alleen kolommen van Klant vraagt.
Het verschil zit in wat DISTINCT doet. Het voorkomt de dubbele rijen niet. Het haalt ze achteraf weg, en dan ook rijen die toevallig gelijk zijn. Vraag maar eens alleen de plaats:
-- 4 rijenSELECT DISTINCT k.PlaatsFROM dbo.Klant AS kJOIN dbo.Bestelling AS b ON b.KlantId = k.KlantId;
-- 59.994 rijenSELECT k.PlaatsFROM dbo.Klant AS kWHERE EXISTS (SELECT 1 FROM dbo.Bestelling AS b WHERE b.KlantId = k.KlantId);De eerste query geeft 4 plaatsen. De tweede geeft 59.994 klanten, met hun plaats. Welke je wilt, hangt van je vraag af. Met EXISTS staat die vraag in de query zelf. Met DISTINCT moet de lezer raden of het een bewuste keus was of een pleister.
NOT EXISTS of LEFT JOIN … IS NULL
Nu de omgekeerde vraag: welke klanten hebben nooit iets besteld?
SELECT k.KlantId, k.NaamFROM dbo.Klant AS kWHERE NOT EXISTS (SELECT 1 FROM dbo.Bestelling AS b WHERE b.KlantId = k.KlantId);
SELECT k.KlantId, k.NaamFROM dbo.Klant AS kLEFT JOIN dbo.Bestelling AS b ON b.KlantId = k.KlantIdWHERE b.KlantId IS NULL;Beide geven 40.006 klanten. SQL Server maakte van beide een Hash Match (Left Anti Semi Join), met dezelfde reads. Met de index werd het voor beide een Merge Join (Right Anti Semi Join). Qua snelheid maakt het hier dus niet uit.
Bij LEFT JOIN gaat het vaker mis in het resultaat. Er zijn twee valkuilen.
Een filter in de WHERE maakt er een inner join van
Stel, je wilt alle klanten, met hun bestellingen van 2026 als ze die hebben:
-- 269.000 rijen: de klanten zonder bestelling in 2026 zijn wegSELECT k.KlantId, k.Naam, b.BestellingIdFROM dbo.Klant AS kLEFT JOIN dbo.Bestelling AS b ON b.KlantId = k.KlantIdWHERE b.Besteldatum >= '20260101';
-- 352.860 rijen: alle klanten, met of zonder bestelling in 2026SELECT k.KlantId, k.Naam, b.BestellingIdFROM dbo.Klant AS kLEFT JOIN dbo.Bestelling AS b ON b.KlantId = k.KlantId AND b.Besteldatum >= '20260101';Bij een klant zonder match is b.Besteldatum NULL, en NULL >= '20260101' is niet waar. De WHERE gooit die klanten dus weg. SQL Server ziet dat ook: in het plan van de eerste query staat Hash Match (Inner Join), geen Left Outer Join. Een extra voorwaarde op de rechtertabel hoort in de ON.
Met NOT EXISTS heb je dat probleem niet. De voorwaarde staat in de subquery, en daar hoort hij:
SELECT k.KlantId, k.NaamFROM dbo.Klant AS kWHERE NOT EXISTS (SELECT 1 FROM dbo.Bestelling AS b WHERE b.KlantId = k.KlantId AND b.Besteldatum >= '20260101');Dat geeft 83.860 klanten zonder bestelling in 2026. De LEFT JOIN met de datum in de ON en WHERE b.BestellingId IS NULL gaf hetzelfde aantal en hetzelfde plan.
Test IS NULL op de juiste kolom
Kies de join-kolom of de primary key van de rechtertabel. Die is nooit NULL als er een match is. Test je een kolom die zelf NULL mag zijn, dan tel je ook klanten mee die wél een bestelling hebben, alleen met een lege waarde in die kolom.
Ik schreef eerder over verloren klanten berekenen met T-SQL. Dat is dezelfde vraag, per jaar.
NOT IN: de val met NULL
SELECT k.KlantId, k.NaamFROM dbo.Klant AS kWHERE k.KlantId NOT IN (SELECT b.KlantId FROM dbo.Bestelling AS b);Deze query geeft 0 rijen, terwijl je er 40.006 verwacht. De oorzaak zijn de honderd bestellingen met KlantId NULL. NOT IN betekent: niet gelijk aan de eerste waarde, en niet aan de tweede, enzovoort. Een vergelijking met NULL is niet waar en niet onwaar, maar onbekend. Dan is de hele voorwaarde onbekend, en valt elke klant weg. Microsoft waarschuwt er zelf voor op de pagina over IN: “Using null values in together with IN or NOT IN can produce unexpected results.”
Het plan is ook zwaarder. SQL Server moet apart controleren of er een NULL in de subquery zit. Dat zie je als een extra Nested Loops met een Row Count Spool. De reads op Bestelling gingen van 3.650 naar 4.058.
Je kunt het repareren met een filter in de subquery:
SELECT k.KlantId, k.NaamFROM dbo.Klant AS kWHERE k.KlantId NOT IN (SELECT b.KlantId FROM dbo.Bestelling AS b WHERE b.KlantId IS NOT NULL);Dat geeft weer 40.006 rijen. Maar je moet er elke keer aan denken, ook als de kolom vandaag geen NULL bevat en volgend jaar wel. Met NOT EXISTS hoef je dat niet.
IN zonder NOT heeft dit probleem niet. Microsoft noemt EXISTS en IN in de documentatie van EXISTS “semantically equivalent”, en in mijn test kregen ze hetzelfde plan.
Kijk naar het execution plan
Microsoft schrijft dat de optimizer zelf de beste manier kiest om een join uit te voeren, en dat je de uitvoering “can’t be reliably predicted”. In mijn tests herschreef de optimizer JOIN met DISTINCT en LEFT JOIN ... IS NULL naar dezelfde semi join en anti semi join als EXISTS en NOT EXISTS. Dat is geen garantie voor elke query die jij schrijft.
Twijfel je, open dan het actual execution plan. Staat er Left Semi Join of Anti Semi Join, dan heeft SQL Server begrepen dat het alleen om bestaan gaat. Staat er een Left Outer Join met daarna een Filter, dan haalt SQL Server eerst alle matches op en gooit ze daarna weg.
De index op Bestelling(KlantId) hielp alle varianten evenveel. Bij EXISTS gingen de reads op Bestelling van 3.650 naar 1.746, en op Klant van 1.375 naar 276. De keus tussen JOIN, EXISTS en LEFT JOIN veranderde daar niets aan.
Samengevat
| Vraag | Kies | Waarom |
|---|---|---|
| Kolommen uit beide tabellen | JOIN |
Je krijgt een rij per match, en dat wil je hier. |
| Heeft de klant een bestelling? | EXISTS |
Elke klant één keer, zonder DISTINCT. |
| Heeft de klant géén bestelling? | NOT EXISTS |
Veilig met NULL, en extra voorwaarden staan op de goede plek. |
| Alle klanten, met bestellingen als die er zijn | LEFT JOIN |
Zet voorwaarden op de rechtertabel in de ON. |
| Lijst van waarden zonder NULL | IN / NOT IN |
Alleen als de kolom NOT NULL is. |
In deze tests was de snelheid per paar gelijk. Je kiest dus op het resultaat dat je wilt.
Bronnen
Veelgestelde vragen
Wat is het verschil tussen JOIN en WHERE EXISTS in SQL Server?
Een JOIN geeft een rij voor elke match, dus een klant met 17 bestellingen komt 17 keer terug. WHERE EXISTS geeft elke klant één keer, zodra er minstens één bestelling is. Gebruik JOIN als je kolommen uit de andere tabel nodig hebt, en EXISTS als je alleen wilt weten of er iets is.
Is WHERE EXISTS sneller dan een JOIN met DISTINCT?
In de test met 100.000 klanten en een miljoen bestellingen maakte SQL Server 2025 voor beide hetzelfde plan, een Left Semi Join, met dezelfde logical reads. Het verschil zit in het resultaat: DISTINCT haalt ook rijen weg die toevallig gelijk zijn, zoals klanten in dezelfde plaats.
Waarom geeft NOT IN geen rijen terug in SQL Server?
Als de subquery van NOT IN één NULL teruggeeft, wordt de vergelijking UNKNOWN en valt elke rij weg. In de test gaf NOT IN 0 rijen door 100 bestellingen zonder klant. NOT EXISTS gaf de juiste 40.006 klanten.
Is LEFT JOIN met IS NULL hetzelfde als NOT EXISTS?
Meestal geeft het hetzelfde resultaat, en in de test maakte SQL Server er hetzelfde Anti Semi Join-plan van. Let op twee dingen: zet extra voorwaarden op de rechtertabel in de ON en niet in de WHERE, en test IS NULL op de join-kolom of de primary key.
Waarom wordt mijn LEFT JOIN een INNER JOIN?
Een filter op de rechtertabel in de WHERE gooit de rijen zonder match weg, want hun kolommen zijn NULL. SQL Server maakt er dan een Inner Join van. In de test gaf dat 269.000 rijen in plaats van 352.860. Zet het filter in de ON.
Reacties
Gerelateerde blogs
SQL Server on-premises of Microsoft Fabric: wat levert de overstap echt op?
Upgraden naar SQL Server 2025: wat levert het op en wat kost het?
Microsoft MDS end of life: je opties vóór 2028