Hoe je 3 tabellen in SQL joint: methoden en voorbeelden

Leer hoe je effectief drie tabellen in SQL kunt joinen. Ontdek praktische methoden en voorbeelden om je datamanipulatievaardigheden te verbeteren. Beheers SQL-joins met gemak.

Bijgewerkt 1 jun 2026 · 7 min lezen

Hoewel SQL-joins vaak worden gebruikt om gegevens uit twee tabellen te combineren, hoef je daar niet te stoppen. Je kunt data uit drie of zelfs meer tabellen samenvoegen om nog complexere relaties en inzichten in je data te ontdekken.

In dit artikel laat ik je aan de hand van voorbeelden zien hoe je drie tabellen in SQL joint; we bekijken ook database-specifieke implementaties en best practices. Ik raad ook sterk aan om onze cursussen Introduction to SQL en Learn SQL te volgen voor alle belangrijke basiskennis.

TL;DR

Gebruik INNER JOIN als je alleen records wilt die in alle tabellen overeenkomen, LEFT JOIN als je alles uit de hoofdtafel wilt, zelfs zonder matches, en RIGHT JOIN als de meest rechtse tabel prioriteit heeft.
SQL verwerkt joins van links naar rechts, dus de volgorde is belangrijk. Bouw je queries stap voor stap op en controleer de resultaten gaandeweg.
Voor betere performance: indexeer je joinkolommen, filter vroeg met WHERE, join eerst kleinere tabellen en selecteer alleen de kolommen die je nodig hebt.

De stappen om 3 tabellen in SQL te joinen

Drie tabellen joinen in SQL stelt je in staat complexe queries uit te voeren om gegevens uit meerdere tabellen op te halen. Bij het joinen van drie tabellen gebruiken we de JOIN-clause om data uit deze tabellen te combineren.

Stel dat je de volgende drie tabellen hebt: Customers, Products en Orders.

Voorbeeld van de tabel Customers in SQL. Afbeelding door de auteur.

Voorbeeld van de tabel Products in SQL. Afbeelding door de auteur.

Voorbeeld van de tabel Orders in SQL. Afbeelding door de auteur.

Eerst kun je de tabellen Customers en Orders joinen om te laten zien welke klanten bestellingen hebben geplaatst en hun bestelgegevens, zoals order_id, order_date en de bestelde quantity.

-- Select data from Customers
SELECT 
    Customers.customer_id, 
    Customers.first_name, 
    Customers.last_name, 
    Orders.order_id, 
    Orders.order_date, 
    Orders.quantity 
FROM Customers
-- Join Orders table
INNER JOIN Orders 
ON Customers.customer_id = Orders.customer_id;

Voorbeeld van een SQL JOIN van de tabellen Customers en Orders. Afbeelding door de auteur.

Tot slot kun je de drie tabellen Customers, Orders en Products combineren om een volledig beeld te krijgen van klanten, hun bestellingen, de producten die ze kochten en de totale kosten per bestelling.

-- Select data starting with Customers
SELECT 
    Customers.customer_id,
    Customers.first_name,
    Customers.last_name,
    Orders.order_id,
    Orders.order_date,
    Products.product_name,
    Orders.quantity,
    Products.price,
    (Orders.quantity * Products.price) AS total_cost -- Total cost calculation
FROM Customers
-- Join the Orders table based on customer_id
INNER JOIN Orders 
ON Customers.customer_id = Orders.customer_id
-- Join the Products table based on product_id
INNER JOIN Products 
ON Orders.product_id = Products.product_id;

Voorbeeld van een SQL JOIN met drie tabellen. Afbeelding door de auteur.

Laten we kijken naar praktische voorbeelden van het gebruik van INNER JOIN, LEFT JOIN en RIGHT JOIN om drie tabellen te joinen. Bekijk onze tutorial Introduction to SQL Joins om meer te leren over de verschillende soorten joins en voorbeelden.

Voorbeelden van het joinen van 3 tabellen in SQL

Laten we nu enkele praktische voorbeelden bekijken met INNER JOIN, LEFT JOIN en RIGHT JOIN om drie tabellen te joinen.

Als je vastloopt bij de betekenis van een van deze joins en je meer wilt oefenen om de juiste technieken echt onder de knie te krijgen, schrijf je dan in voor onze cursus Joining Data in SQL. Die helpt je niet alleen met SQL-joins, maar leert je ook over relationele verzamelingenleer en subqueries.

Gebruik van INNER JOIN

Een INNER JOIN haalt records op met overeenkomende waarden in alle drie de tabellen en filtert elk record zonder match weg. INNER JOIN is ideaal wanneer je alleen resultaten nodig hebt met directe relaties in alle betrokken tabellen.

Stel, je hebt drie tabellen: Customers, Orders en Products. De onderstaande query haalt alleen de klanten op die bestellingen hebben geplaatst en bevat details voor de producten die aan elke bestelling zijn gekoppeld.

-- Select customer details, order information, and associated product names
SELECT 
    Customers.customer_id, 
    Customers.customer_name, 
    Orders.order_id, 
    Products.product_name 
-- Select from Customers table
FROM Customers
    -- Join Orders table
    INNER JOIN Orders 
        ON Customers.customer_id = Orders.customer_id
    -- Join Products table
    INNER JOIN Products 
        ON Orders.product_id = Products.product_id;

Gebruik van LEFT JOIN

De LEFT JOIN retourneert alle records uit de eerste (linker) tabel en eventuele overeenkomende records uit de andere twee tabellen. Als er geen match is, worden NULL-waarden teruggegeven voor kolommen uit de rechtertabel. De LEFT JOIN is handig wanneer je alle records uit de hoofdtafel wilt ophalen, zelfs als sommige rijen geen gerelateerde data in de andere tabellen hebben.

In het volgende voorbeeld verschijnen alle klanten in het resultaat, zelfs als ze geen bestelling hebben geplaatst. De datavelden geven NULL-waarden terug als er geen overeenkomende bestel- of productgegevens zijn.

-- Select customer details, order information, and product names
SELECT 
    Customers.customer_id, 
    Customers.customer_name,
    Orders.order_id, 
    Products.product_name
FROM Customers
    -- Join Orders table
    LEFT JOIN Orders 
        ON Customers.customer_id = Orders.customer_id
    -- Join Products table
    LEFT JOIN Products 
        ON Orders.product_id = Products.product_id;

Ter info: LEFT JOIN is hetzelfde als LEFT OUTER JOIN in SQL. We hebben een tutorial met details: SQL LEFT JOIN vs. LEFT OUTER JOIN.

Gebruik van RIGHT JOIN

Een RIGHT JOIN haalt alle records op uit de derde (meest rechtse) tabel en eventuele overeenkomende records uit de linkertabellen. Hoewel RIGHT JOIN minder gebruikelijk is, is het toch handig wanneer je de records in de meest rechtse tabel wilt prioriteren.

In een voorraadanalyse wil je bijvoorbeeld weten welke producten bestellingen of klantinteracties hebben. Alle producten worden in de onderstaande query weergegeven, inclusief eventuele gerelateerde bestel- of klantgegevens. Als er producten zijn die niet zijn besteld, tonen de velden order_id en customer_name NULL.

-- Select customer details, order information, and product names
SELECT 
    Customers.customer_id,
    Customers.customer_name,
    Orders.order_id,
    Products.product_name
 -- Select from Customers table
FROM Customers
 -- Join Orders table
    RIGHT JOIN Orders 
        ON Customers.customer_id = Orders.customer_id
 -- Join Products table
    RIGHT JOIN Products 
        ON Orders.product_id = Products.product_id;

Hoewel de bovenstaande voorbeelden het gebruik van één type join (INNER JOIN, LEFT JOIN of RIGHT JOIN) laten zien, is het heel goed mogelijk—en vaak nodig—om verschillende joingtypen in dezelfde query te combineren om complexere dataverhoudingen aan te kunnen. Je kunt bijvoorbeeld een LEFT JOIN gebruiken om alle records uit één tabel op te nemen, terwijl je binnen dezelfde query een INNER JOIN gebruikt voor een andere relatie.

Daarbij is het goed om te weten dat SQL joins sequentieel van links naar rechts verwerkt, dus de volgorde bepaalt hoe tabellen worden gecombineerd en hoe NULL-waarden worden afgehandeld. Daarom begon ik dit artikel met het proces in twee stappen te laten zien. Je query stap voor stap opbouwen en de resultaten tussentijds verifiëren is de juiste aanpak. LEFT JOIN gevolgd door INNER JOIN is vaak anders dan INNER JOIN gevolgd door LEFT JOIN.

Waarom we 3 tabellen in SQL moeten joinen

Laten we even stilstaan bij databaseontwerp. De reden dat het tegenwoordig vaak nodig is om joins over meer dan twee tabellen te maken, is dat databasetransformatie via normalisatie nu gebruikelijk is. Databases (en eigenlijk de mensen die databases ontwerpen) doen dit door informatie te organiseren in afzonderlijke, gerelateerde tabellen. Dit is bedoeld om redundantie te elimineren (en ook om andere redenen). Deze decompositie van de database betekent dat gegevens die betrekking hebben op verschillende entiteiten—zoals de tabellen Customers, Orders en Products die we hierboven bekeken—apart worden opgeslagen.

Met andere woorden: omdat data zo vaak wordt opgeslagen in een genormaliseerd databaseschema, vereist het ophalen van informatie vaak het combineren van gegevens uit meerdere tabellen. Daarom moeten we weten hoe we queries schrijven die veel joins maken, want simpel gezegd: zo is de data waarschijnlijk gestructureerd. Onze cursus Database Design is een goede bron over deze ideeën.

Database-specifieke joinfuncties

Hoewel SQL-joins consistent zijn in de meeste relationele databases, zijn er enkele verschillen in het afhandelen van meerdere joins met drie of meer tabellen. Laten we kijken naar database-specifieke implementaties en aandachtspunten om valkuilen en optimalisatieproblemen te vermijden.

MySQL

MySQL presteert doorgaans goed met basisjoins, maar kan moeite hebben met complexe queries met meerdere tabellen. Het EXPLAIN-commando van MySQL is handig om joinperformance te begrijpen en manieren te vinden om queries te optimaliseren met indexering of herschrijven. MySQL ondersteunt ook het keyword STRAIGHT_JOIN, dat de joinvolgorde forceert en de queryperformance kan verbeteren in gevallen waarin de standaard joinoptimalisatie niet ideaal is.

PostgreSQL

De krachtige optimizer van PostgreSQL maakt het zeer efficiënt voor complexe joins, zelfs met grote datasets. De ondersteuning voor recursieve queries met de clause WITH RECURSIVE maakt het mogelijk hiërarchische data over meerdere tabellen te joinen. De windowfuncties van PostgreSQL zijn geavanceerd en kunnen joins aanvullen door rij-voor-rijanalyse binnen een gejoinde dataset mogelijk te maken.

SQL Server

SQL Server staat specifieke join hints toe (MERGE JOIN, LOOP JOIN en HASH JOIN) om het standaardgedrag te overschrijven, wat de performance van joins met meerdere tabellen kan verbeteren. De operators CROSS APPLY en OUTER APPLY in SQL Server zijn krachtige tools voor het joinen van tabellen met table-valued functions en bieden meer flexibiliteit in queries met meerdere tabellen.

Ik raad aan om de cursus Introduction to SQL Server van DataCamp te volgen om de verschillende functionaliteiten van SQL Server bij het opvragen van data te begrijpen. Probeer ook ons SQL Server Fundamentals-skilltrack om je vaardigheden in het joinen van tabellen en data-analyse te verbeteren. Het SQL Server Developer-carrièrepad rust je uit met de vaardigheden om je queries in SQL Server te schrijven, te troubleshooten en te optimaliseren.

Oracle SQL

Oracle ondersteunt alle standaardjoins en biedt unieke opties zoals NATURAL JOIN, die tabellen automatisch joint op basis van overeenkomende kolomnamen. De ondersteuning van Oracle voor hiërarchische queries met CONNECT BY kan soms de behoefte aan extra joins verminderen door geneste data efficiënter af te handelen.

Best practices bij het joinen van 3 tabellen in SQL

Drie tabellen joinen in SQL kan de complexiteit van queries vergroten en de performance beïnvloeden, vooral naarmate de hoeveelheid data groeit. De volgende best practices en optimalisatietechnieken verbeteren de queryperformance.

Gebruik passende indexering: Indexeer kolommen die vaak in joincondities worden gebruikt om het ophalen van data te versnellen door de hoeveelheid gescande data te verminderen.
Filter vroeg met WHERE- en JOIN-condities: Plaats filtercondities direct in de JOIN- of WHERE-clause om de hoeveelheid data die in volgende joins verwerkt moet worden te reduceren, wat de performance verbetert.
Overweeg joinvolgorde en -type: Join bij meerdere tabellen eerst de kleinere tabellen om de dataset zo snel mogelijk te minimaliseren. Vermijd LEFT- of RIGHT-joins als je analyse geen unmatched records vereist.
Beperk geselecteerde kolommen met SELECT: Vermijd SELECT * om onnodige kolommen op te nemen. Selecteer expliciet de benodigde kolommen om de hoeveelheid teruggegeven data per tabel te verminderen, wat het geheugenverbruik verkleint en de performance verbetert.
Gebruik subqueries of tijdelijke tabellen voor complexe joins: Overweeg om de query op te splitsen in kleinere delen met subqueries voor zeer complexe joins. Voor joins die herhaaldelijk complexe queries omvatten, kun je overwegen om tussenresultaten in tijdelijke tabellen op te slaan om verwerkingstijd te besparen, vooral bij queries met uitgebreide berekeningen.

Conclusie en verder leren

Drie tabellen joinen in SQL stelt je in staat data uit meerdere tabellen te combineren voor grondige data-analyse en databasebeheer. Door de juiste technieken te beheersen, zorg je ervoor dat je code efficiënt, schaalbaar en performant is.

Wil je een bekwame data-analist worden, bekijk dan ons carrièrepad Associate Data Analyst in SQL om de benodigde vaardigheden te leren. De cursus Reporting in SQL is ook geschikt als je wilt leren hoe je professionele dashboards bouwt met SQL. Tot slot raad ik aan om de SQL Associate Certification te behalen om je beheersing van SQL voor data-analyse aan te tonen en je cv te laten opvallen.