Voorbereiding op SQL-sollicitatiegesprekken · Les

Anker- en recursieve leden

De tweedelige structuur van een recursieve CTE en de werking van beëindiging

Les 1 van 413 stappen

Anker- en recursieve leden is een gratis Voorbereiding op SQL-sollicitatiegesprekken-les op CoddyKit. Dit is les 1 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 SQL-sollicitatiegesprekken. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Voorbereiding op SQL-sollicitatiegesprekken bevat in totaal 4 lessen.

Waarom recursieve CTE's aan bod komen

Wanneer een interviewer je een organigram, een stuklijst of een categorisatieboom geeft en naar iedere afstammeling vraagt, test diegene of je naar een recursieve CTE grijpt. Met gewone koppelingen kun je maar een vast aantal niveaus doorlopen; recursie werkt tot een willekeurige diepte.

De kenmerkende formulering in zo'n vraag is "tot elke diepte" of "helemaal naar beneden". Dat is je aanwijzing. In deze les leer je de tweedelige structuur die iedere recursieve CTE heeft: het anker en het recursieve deel.

De tweedelige basisstructuur

Een recursieve CTE bevat altijd het sleutelwoord WITH RECURSIVE (Postgres, SQLite, MySQL 8+; SQL Server laat RECURSIVE weg) en een gedeelte met twee query's die met UNION ALL worden gecombineerd:

Ankerdeel — de startrijen, wordt één keer uitgevoerd.
Recursief deel — verwijst naar de naam van de CTE zelf en wordt herhaaldelijk uitgevoerd.

Onthoud deze basisstructuur; interviewers vragen je graag om die uit het hoofd te schrijven.

WITH RECURSIVE cte AS (
    -- anchor member
    SELECT ...
    UNION ALL
    -- recursive member
    SELECT ... FROM cte JOIN ...
)
SELECT * FROM cte;

Wat het anker doet

Het ankerdeel is een gewone query zonder verwijzing naar de CTE. Het levert de startrijen op — het beginpunt op niveau nul. Voor een organigram is dat meestal de CEO (de rij waarvan de manager NULL is); voor een getallenreeks is het het eerste getal.

Het anker wordt precies één keer uitgevoerd. De uitvoer ervan wordt de eerste reeks rijen die aan de recursieve stap wordt doorgegeven.

-- Anchor: the top of the hierarchy
SELECT id, name, manager_id, 1 AS depth
FROM employees
WHERE manager_id IS NULL

Wat het recursieve deel doet

Het recursieve deel verwijst op naam naar de CTE. Bij elke iteratie koppelt het de rijen die door de vorige iteratie zijn geproduceerd aan de basistabel om het volgende niveau te vinden.

Het ziet niet de volledige CTE tot dan toe — alleen de rijen die in de direct voorafgaande stap zijn toegevoegd. Dit is het belangrijkste denkmodel waarop interviewers doorvragen.

-- Recursive: children of the rows found so far
SELECT e.id, e.name, e.manager_id, c.depth + 1
FROM employees e
JOIN cte c ON e.manager_id = c.id

Alles samenvoegen

Combineer het ankerdeel en het recursieve deel met UNION ALL; daarna voert het databasesysteem de iteraties automatisch uit. Elke doorgang voegt het volgende niveau toe totdat het recursieve deel nul rijen oplevert. Op dat moment stopt de recursie.

Hier staat een volledig uitvoerbare wandeling door een organigram die ook depth bijhoudt.

WITH RECURSIVE org AS (
    SELECT id, name, manager_id, 1 AS depth
    FROM employees
    WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, e.manager_id, o.depth + 1
    FROM employees e
    JOIN org o ON e.manager_id = o.id
)
SELECT id, name, depth FROM org ORDER BY depth, id;

Hoe beëindiging werkt

De recursie stopt wanneer het recursieve deel geen nieuwe rijen oplevert. Er is geen expliciete lusteller nodig — de koppeling vindt vanzelf geen resultaten meer zodra je de bladeren van de boom bereikt.

In het voorbeeld met het organigram vindt de koppeling in de volgende iteratie geen kinderen meer wanneer je werknemers zonder directe ondergeschikten bereikt. De koppeling levert dan een lege uitvoer op en het databasesysteem stopt. Dit zelfbeëindigende gedrag begrijpen is een klassieke vervolgvraag.

UNION ALL versus UNION

Interviewers vragen vaak waarom we UNION ALL gebruiken en niet UNION. Daar zijn twee redenen voor:

Prestaties — UNION verwijdert in elke iteratie dubbele rijen, wat veel rekenwerk kost.
Correctheid — in een boom kunnen dubbele rijen meestal niet voorkomen, dus dubbele rijen verwijderen is verspild werk.

Gebruik UNION alleen wanneer de structuur een graaf is en je herhaalde knooppunten bewust wilt samenvoegen — maar voor bescherming tegen cycli zijn expliciete controles beter (die komen later aan bod).

Diepte en pad bijhouden

Met twee extra kolommen worden recursieve resultaten veel bruikbaarder; er wordt in sollicitatiegesprekken ook vaak naar gevraagd:

depth — begin in het anker op 1 en tel in het recursieve deel 1 op.
path — verzamel de keten van id's of namen, zodat je de route van de wortel naar het knooppunt kunt zien.

Een path als tekenreeks opbouwen werkt later ook als hulpmiddel om cycli te detecteren.

WITH RECURSIVE org AS (
    SELECT id, name, manager_id, 1 AS depth,
           CAST(name AS VARCHAR(1000)) AS path
    FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, e.manager_id, o.depth + 1,
           o.path || ' > ' || e.name
    FROM employees e JOIN org o ON e.manager_id = o.id
)
SELECT name, depth, path FROM org;

Kolomtypen moeten overeenkomen

Een subtiele valkuil: het ankerdeel en het recursieve deel moeten hetzelfde aantal kolommen met compatibele typen opleveren. Als je een tekenreeks voor path opbouwt, moet de beginwaarde van het anker breed genoeg worden geconverteerd (bijvoorbeeld naar VARCHAR(1000)), anders kan het databasesysteem de waarde afkappen of tijdens latere iteraties een typeconflictfout geven.

Dit is precies het soort detail dat een interviewer inbouwt om te zien of je een recursieve CTE echt hebt uitgevoerd in plaats van er alleen over te hebben gelezen.

Voorbeeld met een stuklijst

Dezelfde basisstructuur lost ook een probleem met een stuklijst op: geef een onderdeel op en vermeld ieder subonderdeel tot op willekeurige diepte. Het anker selecteert de bovenste samenstelling; het recursieve deel volgt de koppelingen van parent_part naar child_part.

Let erop dat de structuur identiek is aan die van het organigram — alleen de kolomnamen veranderen. Herkennen dat één basisstructuur op veel problemen past, is de echte vaardigheid voor het sollicitatiegesprek.

WITH RECURSIVE bom AS (
    SELECT child_part, parent_part, 1 AS lvl
    FROM parts WHERE parent_part = 'ENGINE'
    UNION ALL
    SELECT p.child_part, p.parent_part, b.lvl + 1
    FROM parts p JOIN bom b ON p.parent_part = b.child_part
)
SELECT child_part, lvl FROM bom;

Opmerkingen per dialect

Een korte spiekbrief voor verschillende dialecten die interviewers waarderen:

PostgreSQL, SQLite, MySQL 8+: WITH RECURSIVE name AS (...).
SQL Server: gewoon WITH name AS (...) — het sleutelwoord RECURSIVE is impliciet en er geldt standaard een MAXRECURSION van 100.
Oracle: ondersteunt zowel recursieve CTE's als de oudere syntaxis CONNECT BY.

Door te zeggen dat "SQL Server het woord RECURSIVE niet gebruikt" laat je zien dat je echt breed onderlegd bent.

Snelle controle

Test je begrip van de tweedelige structuur.

Beantwoord dit in de interactieve les

Samenvatting

Je beheerst nu de basisstructuur van een recursieve CTE:

WITH RECURSIVE + anker + UNION ALL + recursief deel.
Het anker levert niveau nul en wordt één keer uitgevoerd.
Het recursieve deel koppelt de vorige iteratie aan de basistabel en wordt uitgevoerd totdat het geen rijen meer oplevert.
Gebruik UNION ALL, houd depth en path bij en zorg dat de kolomtypen compatibel zijn.

Hierna pas je deze basisstructuur toe om een echt organigram naar beneden en naar boven te doorlopen.

Gratis beginnen

Leer SQL 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: 30
Lessen: 120

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Anker- en recursieve leden” gratis?

Ja — de volledige tekst van “Anker- en recursieve leden” 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 SQL-sollicitatiegesprekken wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Voorbereiding op SQL-sollicitatiegesprekken bevat in totaal 4 lessen.

Wat leer ik in “Anker- en recursieve leden”?

De tweedelige structuur van een recursieve CTE en de werking van beëindiging Je oefent met Voorbereiding op SQL-sollicitatiegesprekken 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 SQL-sollicitatiegesprekken te beginnen?

Ervaring vooraf is niet nodig. Voorbereiding op SQL-sollicitatiegesprekken 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 1 van 4.

Hoe lang duurt de les “Anker- en recursieve leden”?

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 SQL-sollicitatiegesprekken?

Ja. Elke les over Voorbereiding op SQL-sollicitatiegesprekken 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

Anker- en recursieve leden
Een organigram doorlopen
Reeksen met getallen en datums genereren
Oneindige recursie voorkomen

← Terug naar Voorbereiding op SQL-sollicitatiegesprekken