Voorbereiding op SQL-sollicitatiegesprekken · Les

Oneindige recursie voorkomen

Cycli detecteren, dieptelimieten instellen en de recursiebewaking toepassen waarop elke interviewer let

Les 4 van 413 stappen

Oneindige recursie voorkomen is een gratis Voorbereiding op SQL-sollicitatiegesprekken-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 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.

De vraag achter de vraag

Nadat je een recursieve CTE hebt geschreven, stelt een scherpe interviewer de vraag: "Wat gebeurt er als de gegevens een cyclus bevatten?" Hiermee wordt gecontroleerd of je begrijpt dat recursie voor altijd kan doorgaan — en of je weet hoe je dat voorkomt.

Een cyclus ontstaat wanneer een hiërarchie naar zichzelf terugverwijst: A rapporteert aan B en B rapporteert aan A. Het naïeve recursieve deel blijft dan onbeperkt tussen beide heen en weer gaan.

Hoe een cyclus ontstaat

Bomen horen acyclisch te zijn, maar echte gegevens zijn rommelig. Door een foutieve update kan een werknemer zijn eigen (indirecte) manager worden. Een graaf — zoals "gebruikers die gebruikers volgen" — is van nature cyclisch.

Wanneer het recursieve deel een knooppunt opnieuw tegenkomt dat al bezocht is, produceert het dat knooppunt opnieuw, waardoor de kinderen opnieuw worden geactiveerd en de lus nooit leeg raakt. Recursie stopt alleen wanneer een stap geen rijen oplevert; een cyclus zorgt ervoor dat er altijd rijen worden geretourneerd.

Beveiliging 1: een dieptelimiet

De eenvoudigste veiligheidsmaatregel is een diepteteller met een limiet in het recursieve deel. Zelfs als er een cyclus bestaat, stopt de recursie bij die limiet.

Dit is een bot instrument — het begrenst ook legitiem diepe bomen — maar het is snel toe te passen en geschikt voor interviews.

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
    WHERE o.depth < 50
)
SELECT * FROM org;

Beveiliging 2: een bezocht pad

Een precieze beveiliging houdt het pad met bezochte knooppunten bij en weigert een knooppunt opnieuw te bezoeken als het al op het pad staat. Verzamel de id's in een tekenreeks of array en controleer of de id aanwezig is voordat je recursief verdergaat.

Zo stop je cycli precies, terwijl je op legitieme bomen nog steeds elke diepte toestaat.

WITH RECURSIVE org AS (
    SELECT id, name, manager_id,
           CAST(',' || id || ',' AS VARCHAR(2000)) AS path
    FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, e.manager_id,
           o.path || e.id || ','
    FROM employees e JOIN org o ON e.manager_id = o.id
    WHERE o.path NOT LIKE '%,' || e.id || ',%'
)
SELECT id, name, path FROM org;

Waarom de padcontrole werkt

De voorwaarde path NOT LIKE '%,' || e.id || ',%' betekent "volg deze verbinding alleen als de id van het kind nog niet in het pad staat." De komma's fungeren als scheidingstekens, zodat id 1 niet ten onrechte overeenkomt met id 15.

Als een cyclus ervoor zou zorgen dat een knooppunt opnieuw wordt bezocht, filtert de WHERE die rij weg, levert het recursieve deel uiteindelijk niets op en eindigt de recursie netjes.

Beveiliging 3: de ingebouwde CYCLE-clausule

Moderne versies van Postgres (14+) en de SQL-standaard bieden een ingebouwde CYCLE-clausule die de padcontrole automatiseert en cycli voor je markeert. Dit is het duidelijkste antwoord wanneer de databasemotor dit ondersteunt.

WITH RECURSIVE org AS (
    SELECT id, name, manager_id FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, e.manager_id
    FROM employees e JOIN org o ON e.manager_id = o.id
)
CYCLE id SET is_cycle USING cycle_path
SELECT id, name, is_cycle FROM org;

MAXRECURSION van SQL Server

SQL Server hanteert standaard een limiet van 100 recursieniveaus. Als een cyclus of diepe boom deze limiet overschrijdt, geeft de query een foutmelding in plaats van voor altijd door te lopen — een ingebouwde veiligheidsklep.

Je kunt de limiet verhogen of verwijderen met OPTION (MAXRECURSION n), waarbij 0 onbeperkt betekent. Als je de limiet verwijdert zonder padcontrole, ontstaat bij cyclische gegevens opnieuw het risico op een oneindige lus.

-- Cap recursion at 200 levels in SQL Server
SELECT * FROM org
OPTION (MAXRECURSION 200);

Cycli detecteren versus voorkomen

Interviewers kunnen onderscheid maken tussen twee doelen:

Voorkomen — de cyclische verbinding stilzwijgend overslaan zodat de query wordt voltooid, met de WHERE voor padcontrole.
Detecteren en rapporteren — zichtbaar maken welke rijen deel uitmaken van een cyclus, zodat een datateam de foutieve gegevens kan herstellen, met de vlag is_cycle van de CYCLE-clausule.

Beide kennen en weten wanneer je welke toepast, getuigt van senior-niveau.

Prestatieoverwegingen

Recursie kan ook zonder cycli duur zijn. Dit zijn adviezen die interviewers graag horen:

Indexeer de koppelkolom, bijvoorbeeld manager_id, zodat de koppeling in elke iteratie snel verloopt.
Filter vroeg in het anker, zodat je alleen de benodigde deelboom start en niet de hele tabel.
Vermijd SELECT * — neem alleen de kolommen mee die de recursie nodig heeft, plus je depth/path.

Een veilig sjabloon

Combineer de beveiligingen in een sjabloon die je onder druk kunt reproduceren: een dieptekolom als vangnet en een padcontrole als precieze beveiliging. Zelfs als een van beide voor schone gegevens overbodig is, laat je met beide zien dat je grondig werkt.

WITH RECURSIVE walk AS (
    SELECT id, parent_id, 1 AS depth,
           CAST(',' || id || ',' AS VARCHAR(4000)) AS path
    FROM nodes WHERE parent_id IS NULL
    UNION ALL
    SELECT n.id, n.parent_id, w.depth + 1,
           w.path || n.id || ','
    FROM nodes n JOIN walk w ON n.parent_id = w.id
    WHERE w.depth < 100
      AND w.path NOT LIKE '%,' || n.id || ',%'
)
SELECT id, depth FROM walk;

Veelvoorkomende valkuilen

Laatste valkuilen om te vermijden:

MAXRECURSION in SQL Server verwijderen zonder een andere beveiliging — daarmee breng je het risico op een oneindige lus terug.
Een kolom voor de padtekenreeks te kort declareren, waardoor afkapping optreedt en de beveiliging ongemerkt defect raakt.
Id's zonder komma's als scheidingstekens vergelijken, zodat id 1 ten onrechte overeenkomt met id 21.
Aannemen dat de gegevens acyclisch zijn alleen omdat ze dat "zouden moeten" zijn — vraag dit altijd na.

Korte controle

Kies de beveiliging die cycli precies stopt zonder legitieme diepte te begrenzen.

Beantwoord dit in de interactieve les

Samenvatting

Elk antwoord met een recursieve CTE moet aandacht besteden aan veiligheid:

Door cycli levert het recursieve deel nooit een lege uitkomst op, waardoor de recursie nooit stopt.
Dieptelimiet = snel vangnet; controle van het bezochte pad = precieze preventie van cycli; CYCLE-clausule = ingebouwde detectie in moderne engines.
MAXRECURSION 100 van SQL Server is een ingebouwde veiligheidsklep — verwijder deze niet zonder een andere beveiliging.
Indexeer de koppelkolom en beperk het anker voor betere prestaties.

Je kunt nu recursieve CTE's van begin tot eind schrijven, doorlopen, genereren en beveiligen.

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 “Oneindige recursie voorkomen” gratis?

Ja — de volledige tekst van “Oneindige recursie voorkomen” 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 “Oneindige recursie voorkomen”?

Cycli detecteren, dieptelimieten instellen en de recursiebewaking toepassen waarop elke interviewer let 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 4 van 4.

Hoe lang duurt de les “Oneindige recursie voorkomen”?

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