Rijen binnen één tabel vergelijken
Self-join-patronen voor het vinden van paren, duplicaten en aangrenzende records
Rijen binnen één tabel vergelijken is een gratis Voorbereiding op programmeerinterviews-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Voorbereiding op programmeerinterviews. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Voorbereiding op programmeerinterviews bevat in totaal 4 lessen.
Self joins voor vergelijking van rijen
Naast hiërarchieën is de andere belangrijke toepassing van een self join het vergelijken van rijen uit dezelfde tabel. In plaats van ouder en kind koppel je willekeurige rijen aan elkaar om duplicaten, bijna-overeenkomsten of aangrenzende records te vinden.
Het patroon is hetzelfde: geef de tabel twee aliassen en schrijf een ON-voorwaarde die de relatie uitdrukt tussen de twee rijen die je aan elkaar wilt koppelen.
Paren in dezelfde groep vinden
Een klassieke vraag: vind alle paren medewerkers die op dezelfde afdeling werken. Koppel de tabel aan zichzelf op een gelijke afdeling, maar houd de twee rijen verschillend.
De eenvoudige join zou elke medewerker ook aan zichzelf koppelen en elk paar twee keer opleveren. Dat lossen we hierna op.
SELECT a.name, b.name, a.department
FROM employees a
JOIN employees b ON a.department = b.department;Zelfkoppelingen en spiegelduplicaten verwijderen
Bij het koppelen binnen dezelfde groep zijn er twee problemen: een rij komt met zichzelf overeen (Alice met Alice) en elk paar verschijnt twee keer (Alice-Bob en Bob-Alice).
Los beide op met één ongelijkheidsvoorwaarde: a.id < b.id. Dit garandeert dat de twee rijen verschillend zijn en behoudt slechts één volgorde van elk paar.
SELECT a.name, b.name, a.department
FROM employees a
JOIN employees b
ON a.department = b.department
AND a.id < b.id;Waarom a.id < b.id en niet a.id <> b.id
Met a.id <> b.id verwijder je zelfkoppelingen, maar krijg je nog steeds beide volgordes terug, waardoor het aantal resultaten verdubbelt. Met a.id < b.id verwijder je zelfkoppelingen en verwijder je de spiegelduplicaten in één keer.
In sollicitatiegesprekken letten interviewers specifiek op de keuze tussen < en <>; die laat zien dat je de combinatoriek van self joins begrijpt.
-- <> keeps Alice-Bob AND Bob-Alice (duplicated)
-- < keeps only Alice-Bob (correct unique pairs)Dubbele rijen vinden
Als je records wilt vinden die op sleutelkolommen dubbel voorkomen, voer je een self join uit op die kolommen en vereist je verschillende primaire sleutels.
Hier vinden we klanten met hetzelfde e-mailadres. Met a.id < b.id behouden we elk duplicaatpaar één keer. Vaak is GROUP BY ... HAVING COUNT(*) > 1 duidelijker, maar met de self join zie je de daadwerkelijke probleemparen naast elkaar.
SELECT a.id, b.id, a.email
FROM customers a
JOIN customers b
ON a.email = b.email
AND a.id < b.id;Aangrenzende records vergelijken
Een veelvoorkomende taak voor analisten: vergelijk elke rij met de volgende rij in de reeks, bijvoorbeeld de verkoop van elke dag met die van de vorige dag. Met een self join kun je opeenvolgende rijen aan elkaar koppelen.
Hier koppelen we elke dag aan de rij van precies één dag eerder om een verschil te berekenen. Dit werkt wanneer er geen hiaten in de reeks zitten.
SELECT t.day, t.amount,
t.amount - y.amount AS change_vs_prev
FROM daily_sales t
JOIN daily_sales y
ON y.day = t.day - INTERVAL '1 day';Het hiatenprobleem bij self joins op aangrenzende rijen
De vorige query werkt niet als er een dag ontbreekt: er is geen rij van precies één dag eerder, waardoor die rij wegvalt bij een inner join of je NULL-waarden moet afhandelen.
Daarom sturen interviewers je vaak naar vensterfuncties zoals LAG voor 'vergelijken met de vorige rij'. Die gebruiken de positie in de volgorde in plaats van een overeenkomst op waarde en kunnen soepel omgaan met hiaten.
-- LAG handles gaps; the self join assumed contiguous days
SELECT day, amount,
amount - LAG(amount) OVER (ORDER BY day) AS change_vs_prev
FROM daily_sales;Self-join versus windowfunctie
Ken de afweging:
- Een self-join vergelijkt rijen op basis van een relatie tussen waarden (dezelfde afdeling, een eerdere datum). Dit is flexibel, maar kan rijen vermenigvuldigen en hiaten verkeerd verwerken.
- Een windowfunctie vergelijkt rijen op basis van hun rangpositie binnen een geordende partitie. Dit is duidelijker voor logica met vorige en volgende rijen.
Gebruik bij ‘vergelijken met de aangrenzende rij’ bij voorkeur LAG/LEAD. Gebruik bij ‘alle paren vinden die aan een voorwaarde voldoen’ de self-join; dat is daarvoor het natuurlijke hulpmiddel.
Rijen vinden die beter presteren dan hun collega's
Nog een patroon: vind werknemers die meer verdienen dan ten minste één collega op hun afdeling. Met een self-join druk je dit rechtstreeks uit.
We koppelen elke werknemer aan andere werknemers op dezelfde afdeling die minder verdienen en houden daarna de unieke werknemers over die voorkomen. Dit leest bijna als de Nederlandse zin zelf.
SELECT DISTINCT a.name, a.department, a.salary
FROM employees a
JOIN employees b
ON a.department = b.department
AND a.salary > b.salary;Let op rijvermenigvuldiging
Self-joins op een kolom zonder unieke waarden vermenigvuldigen rijen. Het vormen van paren binnen een afdeling met 100 mensen levert vóór het filteren ongeveer 100 x 100 kandidaatparen op.
Neem altijd het predicaat voor ontdubbeling op (a.id < b.id) en voeg DISTINCT of groepering toe als je alleen de rijen nodig hebt die deelnemen, niet elk paar. Benoem tijdens sollicitatiegesprekken dat je rekening houdt met deze rijvermenigvuldiging.
Het vergelijkingshulpmiddel kiezen
Beslisgids voor vergelijkingen binnen één tabel:
- Alle overeenkomende paren (duplicaten, combinaties binnen dezelfde groep): self-join met
a.id < b.id. - De vorige/volgende rij in een volgorde: windowfunctie (
LAG/LEAD). - Elke rij vergelijken met een groepsaggregaat: gecorreleerde subquery of windowaggregaat.
Korte controle
Je wilt elk uniek paar producten vinden die dezelfde categorie delen, zonder dat een product aan zichzelf wordt gekoppeld en zonder dubbele volgordes.
Samenvatting: rijen binnen één tabel vergelijken
Belangrijkste punten:
- Gebruik een self-join op de tabel om de eigen rijen aan elkaar te koppelen voor het vinden van duplicaten en combinaties binnen dezelfde groep.
- Gebruik
a.id < b.idom zelfparen en spiegelduplicaten met één predicaat te verwijderen. - Vergelijkingen van aangrenzende rijen met een self-join werken niet goed bij hiaten; gebruik voor logica met vorige en volgende rijen bij voorkeur
LAG/LEAD. - Houd bij het koppelen op kolommen zonder unieke waarden altijd rekening met rijvermenigvuldiging.
Leer Voorbereiding op programmeerinterviews met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 90
- Lessen
- 360
Veelgestelde vragen
Is de les “Rijen binnen één tabel vergelijken” gratis?
Ja — de volledige tekst van “Rijen binnen één tabel vergelijken” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Voorbereiding op programmeerinterviews wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Voorbereiding op programmeerinterviews bevat in totaal 4 lessen.
Wat leer ik in “Rijen binnen één tabel vergelijken”?
Self-join-patronen voor het vinden van paren, duplicaten en aangrenzende records Je oefent met Voorbereiding op programmeerinterviews door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Voorbereiding op programmeerinterviews te beginnen?
Ervaring vooraf is niet nodig. Voorbereiding op programmeerinterviews op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Rijen binnen één tabel vergelijken”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Voorbereiding op programmeerinterviews?
Ja. Elke les over Voorbereiding op programmeerinterviews bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- CROSS JOIN en cartesische producten
- SELF JOIN voor hiërarchieën
- Rijen binnen één tabel vergelijken
- Het juiste jointype kiezen