Drie of meer tabellen koppelen
Joins aan elkaar koppelen en redeneren over tussentijdse resultatensets
Drie of meer tabellen koppelen is een gratis Voorbereiding op programmeerinterviews-les op CoddyKit. Dit is les 4 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.
JOINs vormen een keten, geen vertakking
Echte interviewproblemen stoppen zelden bij twee tabellen. Je krijgt vragen over het koppelen van drie, vier of meer tabellen. Het belangrijkste inzicht om de chaos beheersbaar te maken: een koppeling van meerdere tabellen is gewoon een reeks koppelingen tussen twee tabellen.
De database koppelt de eerste twee tabellen tot een tussenresultaat en koppelt dat resultaat vervolgens aan de derde tabel, enzovoort. Als je over één koppeling kunt redeneren, kun je ook over een hele keten redeneren.
Het schema met drie tabellen
We breiden ons voorbeeld uit met een derde tabel. Nu hebben we klanten, hun bestellingen en de producten waarnaar elke bestelling verwijst.
customers(id, name)orders(id, customer_id, product_id, amount)products(id, title)
Twee relaties verbinden ze: orders.customer_id = customers.id en orders.product_id = products.id.
customers(id, name)
orders(id, customer_id, product_id, amount)
products(id, title)De basisquery met drie tabellen
Stapel de joins na elkaar. Elke JOIN ... ON voegt een tabel toe en beschrijft hoe die verbonden is met wat eraan voorafging.
Lees de query van boven naar beneden: begin bij orders, voeg de bijbehorende klant toe en voeg daarna het bijbehorende product toe. Elke rij van orders krijgt een naam en een producttitel.
SELECT c.name, p.title, o.amount
FROM orders o
JOIN customers c ON c.id = o.customer_id
JOIN products p ON p.id = o.product_id;Denk in tussenresultaten
Het denkmodel dat joins met meerdere tabellen eenvoudig maakt: stel je na elke JOIN het tussenresultaat tot dan toe voor.
- Na join 1: orders + klantkolommen.
- Na join 2: dat resultaat + productkolommen.
De volgende ON-clausule kan verwijzen naar elke kolom die al in het tussenresultaat staat. Daarom bepaalt de volgorde van joins wat je in elke ON kunt schrijven.
Elke ON ziet eerdere tabellen
Een belangrijk gevolg: de ON-clausule van een latere join mag verwijzen naar elke tabel die eerder is gejoint, niet alleen naar de tabel die wordt toegevoegd.
Hier koppelt de derde join aan o (orders), dat al binnen bereik was. Je zou een vierde tabel ook aan c of p kunnen koppelen, omdat beide al deel uitmaken van het lopende resultaat.
SELECT c.name, p.title, w.region
FROM orders o
JOIN customers c ON c.id = o.customer_id
JOIN products p ON p.id = o.product_id
JOIN warehouses w ON w.id = o.warehouse_id; -- refers to oBegin bij de centrale tabel
Praktische tip voor live-interviews: begin in FROM met de feitentabel / centrale tabel (meestal de tabel in het midden van de relaties) en werk daarna naar buiten toe naar de opzoektabellen.
Orders staat in het midden en bevat vreemde sleutels naar zowel customers als products. Daarom houdt beginnen bij orders elke ON-clausule eenvoudig en verwijst elke clausule vooruit.
-- orders is central: it links to both sides
FROM orders o
JOIN customers c ON c.id = o.customer_id
JOIN products p ON p.id = o.product_idFan-out stapelt zich op in ketens
Alles wat je over fan-out hebt geleerd geldt nog steeds, en het stapelt zich op. Als elke bestelling veel items heeft en elk item veel belastingregels, vermenigvuldigt het aantal rijen zich bij elke stap.
Wanneer een aggregaat in een query met meerdere joins te groot lijkt, vermoed dan een fan-out die door een van de middelste joins is geïntroduceerd en controleer de granulariteit van elke join afzonderlijk.
-- rows = orders * items_per_order * tax_rows_per_item
SELECT o.id
FROM orders o
JOIN order_items i ON i.order_id = o.id
JOIN item_taxes t ON t.item_id = i.id;Join-typen combineren in een keten
Je kunt INNER- en LEFT-joins combineren in één query, maar de volgorde is belangrijk. Zodra een LEFT JOIN NULL-waarden introduceert, kan een latere INNER JOIN die naar die NULL-kolommen verwijst de behouden rijen verwijderen.
Hier: als een klant geen bestelling heeft, behoudt de LEFT JOIN die klant met NULL voor product_id, en verwijdert de daaropvolgende INNER JOIN met products de klant weer. Dat is een makkelijke fout om onder druk te maken.
SELECT c.name, p.title
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
JOIN products p ON p.id = o.product_id;
-- the INNER products join can cancel the LEFT JOINOuter joins behouden
Om klanten zonder bestellingen tot het einde te behouden, maak je de volgende join ook LEFT. NULL-waarden stromen dan veilig door tot het einde.
Vuistregel: zodra je een outer join gebruikt, blijf je outer joins gebruiken voor elke tabel die aan de optionele tak hangt.
SELECT c.name, p.title
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
LEFT JOIN products p ON p.id = o.product_id;
-- customers with no orders are now kept (NULL title)Aliassen worden essentieel op schaal
Bij vier of vijf tabellen kunnen meerdere tabellen kolomnamen als id, name of created_at delen. Korte, consistente aliassen voorkomen dubbelzinnigheid en houden de query leesbaar.
Kies aliassen die iets van de tabel suggereren (c, o, p) en kwalificeer elke kolom. Interviewers zien je gebruik van aliassen als een teken van hoe je SQL voor productie schrijft.
SELECT c.id AS customer_id,
o.id AS order_id,
p.id AS product_id,
p.title
FROM orders o
JOIN customers c ON c.id = o.customer_id
JOIN products p ON p.id = o.product_id;Koppeltabellen voor veel-op-veelrelaties
Wanneer twee entiteiten een veel-op-veelrelatie hebben, staat er een derde koppel- (verbindings-)tabel tussen en join je via die tabel. Studenten en cursussen zijn via inschrijvingen met elkaar verbonden.
Het herkennen dat je via een koppeltabel moet werken, is op zichzelf al een veelvoorkomend signaal in interviews.
SELECT s.name, c.title
FROM students s
JOIN enrollments e ON e.student_id = s.id
JOIN courses c ON c.id = e.course_id;Korte controle
Redeneer over een keten met gemengde joins.
Samenvatting: drie of meer tabellen joinen
Denk hieraan tijdens het interview:
- Een join met meerdere tabellen is een keten van joins tussen twee tabellen; redeneer na elke stap over het tussenresultaat.
- Een latere ON-clausule kan verwijzen naar elke eerdere tabel in de keten.
- Begin bij de centrale tabel en werk naar de opzoektabellen.
- Fan-out stapelt zich op bij joins; controleer de granulariteit bij elke stap.
- Een INNER JOIN na een LEFT JOIN kan die tenietdoen; blijf outer joins gebruiken om optionele rijen te behouden.
- Veel-op-veelrelaties worden via een koppeltabel gejoint.
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 “Drie of meer tabellen koppelen” gratis?
Ja — de volledige tekst van “Drie of meer tabellen koppelen” 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 “Drie of meer tabellen koppelen”?
Joins aan elkaar koppelen en redeneren over tussentijdse resultatensets 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 4 van 4.
Hoe lang duurt de les “Drie of meer tabellen koppelen”?
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
- Hoe INNER JOIN rijen koppelt
- ON versus WHERE bij joins
- Join fan-out en rijvermenigvuldiging
- Drie of meer tabellen koppelen