{
  "assessmentTests": {
    "sql_test": {
      "name": "SQL Test",
      "desc": "30 scenariavragen over filtering, joins, aggregatie, subquery's en window functions — ontdek of uw SQL overeenkomt met wat een vacature bedoelt met SQL-bekwaamheid.",
      "recommendation": "Uw SQL-vaardigheidsprofiel",
      "results": {
        "beginner": {
          "name": "Beginner",
          "desc": "U kunt een werkende SELECT-statement schrijven en filteren op enkele voorwaarden, maar de vragen die u hebt gemist clusteren rond NULL-afhandeling en join-mechanica in plaats van syntaxis — het vergelijken van een kolom met NULL met =, wat LEFT JOIN werkelijk behoudt, hoe de grenzen van BETWEEN werken. Dit gaat niet over slecht zijn in databases; dit zijn de specifieke regels die mensen tegenhouden die SQL door trial and error hebben geleerd in plaats van uit de standaard. Ze zijn belangrijk bij het werk omdat elke regel een plek is waar een zoekopdracht een waarschijnlijk ogende maar verkeerde rijtelname retourneert.",
          "recommendation": "Begin met drie dingen, in deze volgorde: waarom WHERE col = NULL nooit iets overeenkomt (en IS NULL is vereist in plaats daarvan), hoe INNER JOIN niet-overeenkomende rijen weggooit terwijl LEFT JOIN ze behoudt, en de exacte grenzen die BETWEEN omvat. Zowel Mode Analytics' SQL-handleiding als de PostgreSQL-documentatie behandelen alle drie met uitvoerbare voorbeelden."
        },
        "intermediate": {
          "name": "Intermediate",
          "desc": "U handelt dagelijkse rapportagequery's comfortabel af — joins, GROUP BY, duidelijk filteren — en zou niet vertraagd worden door routinematig dashboard- of ad-hoc analysewerk. De kloof tussen hier en Advanced is vooral wat er gebeurt wanneer clausules interageren: een WHERE-clausule op de samengevoegde tabel die stilletjes een LEFT JOIN terug in een INNER JOIN verandert, een join die rijtellingen uitwaaiiert voordat een aggregaat erop wordt toegepast, een NOT IN die stilletjes niets retourneert omdat een NULL in de subquery is binnengeslopen. Dit zijn het soort bugs die een snelle visuele controle doorstaan en alleen verschijnen wanneer iemand het totaal met een ander rapport vergelijkt.",
          "recommendation": "Richt u op hoe clausules interageren in plaats van wat elk er alleen doet: WHERE-filtering op de rechterkant kolommen van een LEFT JOIN, rijvermenigvuldiging van one-to-many joins voordat u aggregeert, en waarom NOT IN breekt in aanwezigheid van NULLs (EXISTS doet dit meestal niet). Vervolgens HAVING vs WHERE, omdat die splitsing mensen tegenhouden die beide clausules al individueel kennen."
        },
        "advanced": {
          "name": "Advanced",
          "desc": "Dit is het niveau dat de meeste vacatures met \"sterke SQL\" bedoelen. U leest een multi-join-zoekopdracht en kunt het aantal rijen ervan voordat u het uitvoert voorspellen, u weet waarom een resultatenset is veranderd in plaats van alleen dat het is gebeurd, en u grijpt naar een CTE of een window function in plaats van een geneste subquery wanneer dat het duidelijkere gereedschap is. Wat deze band van de top scheidt, is de defensieve kant van het werk: weten welke ranking-functie moet worden gebruikt wanneer gelijkspel belangrijk is, wat een transactie isoleert van een gelijktijdige sessie, en wat een ontbrekende ON DELETE-regel werkelijk op het databaseniveau doet.",
          "recommendation": "Duw in de delen die gegevens beschermen die andere mensen ook aanraken: het verschil tussen RANK, DENSE_RANK en ROW_NUMBER onder gelijkspel, wat COMMIT werkelijk zichtbaar maakt en voor wie, en foreign key-gedrag op DELETE. Gebruik The Index newsletter's of SQL for Devs' diepgravingen over window functions en transactie-isolatie als volgende stop voor beide."
        },
        "expert": {
          "name": "Expert",
          "desc": "U scoorde aan de top van elke sectie — filtering en NULL-semantica, joins en set-operaties, aggregatie en subquery's, en window functions, CTEs en beperkingen. In de praktijk betekent dit dat u een multi-join rapportagequery van een vreemde kunt krijgen en kunt uitleggen waarom het het aantal rijen retourneert dat het doet, niet alleen wat de syntaxis zegt dat het moet doen, wat de moeilijkere en waardevolere vaardigheid is. Op dit niveau is de querytaal zelden de beperkende factor; de limiet is meestal het schemaontwerp of de grootte van de gegevens eronder.",
          "recommendation": "De opbrengsten zijn nu in uitvoeringsplannen en ontwerp: EXPLAIN-output lezen voordat u aanneemt dat een query traag is, indexeringsstrategie als een afweging tegen schrijfkosten in plaats van een gratis winst, en normalisatiebeslissingen die standhouden naarmate een schema groeit. Als u wordt gescreend voor een rol, beschrijf een querydefect zoals de join fan-out of de NOT IN/NULL-val die u in productie hebt gevonden in plaats van SQL-functies te noemen — dit demonstreert het redeneren, niet alleen het vocabulaire."
        }
      },
      "questions": [
        {
          "question": "Een tabel heeft een nullable kolom age. U voert SELECT * FROM users WHERE age = NULL uit. Hoeveel rijen retourneert dit, zelfs als meerdere rijen age ingesteld op NULL hebben?",
          "options": [
            {
              "icon": "",
              "label": "Elke rij waar age NULL is, omdat = NULL overeenkomt als elke andere waarde"
            },
            {
              "icon": "",
              "label": "Nul — het vergelijken van iets met NULL met = produceert UNKNOWN, nooit TRUE, dus geen rijen komen overeen; IS NULL is vereist"
            },
            {
              "icon": "",
              "label": "Een syntaxfout — NULL kan niet aan de rechterkant van = verschijnen"
            },
            {
              "icon": "",
              "label": "Elke rij in de tabel, omdat NULL-vergelijkingen standaard naar TRUE gaan"
            }
          ]
        },
        {
          "question": "U voert SELECT DISTINCT department, role FROM employees uit. Wat verwijdert DISTINCT duplicaten van?",
          "options": [
            {
              "icon": "",
              "label": "De combinatie van department en role samen — een rij wordt alleen verwijderd als beide kolommen exact overeenkomen met een andere rij"
            },
            {
              "icon": "",
              "label": "Alleen duplicate department waarden, waarbij elke role behouden blijft"
            },
            {
              "icon": "",
              "label": "Alleen duplicate role waarden, waarbij elke department behouden blijft"
            },
            {
              "icon": "",
              "label": "Niets — DISTINCT werkt alleen met een enkele kolom"
            }
          ]
        },
        {
          "question": "Een kolomnaam is gefilterd met WHERE name LIKE 'A_'. Welke van deze waarden overeenkomt: 'A', 'Al', 'Ana', 'Ally'?",
          "options": [
            {
              "icon": "",
              "label": "'A' — de underscore is optioneel en overeenkomt nul of meer tekens"
            },
            {
              "icon": "",
              "label": "'Al' — de underscore overeenkomt exact één teken, dus LIKE 'A_' overeenkomt met een willekeurig teken-string van twee tekens beginnend met A"
            },
            {
              "icon": "",
              "label": "'Ana' en 'Ally' — de underscore overeenkomt met een willekeurig aantal volgende tekens"
            },
            {
              "icon": "",
              "label": "Alle vier waarden komen overeen, omdat LIKE lengte negeert"
            }
          ]
        },
        {
          "question": "Een price kolom is gefilterd met WHERE price BETWEEN 10 AND 20. Worden rijen met price exact 10 of exact 20 opgenomen?",
          "options": [
            {
              "icon": "",
              "label": "Nee — BETWEEN sluit beide eindpunten uit"
            },
            {
              "icon": "",
              "label": "Ja — BETWEEN is inclusief aan beide uiteinden, gelijk aan price >= 10 AND price <= 20"
            },
            {
              "icon": "",
              "label": "Alleen price = 10 is opgenomen; de bovengrens is exclusief"
            },
            {
              "icon": "",
              "label": "Alleen price = 20 is opgenomen; de ondergrens is exclusief"
            }
          ]
        },
        {
          "question": "Een tabel orders heeft 10 rijen, en 3 van hen hebben een NULL shipped_date. Wat retourneert SELECT COUNT(*) FROM orders, en wat retourneert SELECT COUNT(shipped_date) FROM orders?",
          "options": [
            {
              "icon": "",
              "label": "10, dan 10 — COUNT telt altijd rijen ongeacht NULLs"
            },
            {
              "icon": "",
              "label": "7, dan 7 — beide vormen slaan NULL rijen over"
            },
            {
              "icon": "",
              "label": "10, dan 7 — COUNT(*) telt elke rij, COUNT(column) telt alleen rijen waarbij die kolom niet NULL is"
            },
            {
              "icon": "",
              "label": "10, dan 3 — COUNT(column) telt alleen de NULL-waarden"
            }
          ]
        },
        {
          "question": "U voert SELECT name, salary FROM employees ORDER BY 2 DESC uit. Waarnaar verwijst de 2?",
          "options": [
            {
              "icon": "",
              "label": "Een syntaxfout — ORDER BY accepteert alleen kolomnamen, geen nummers"
            },
            {
              "icon": "",
              "label": "De tweede rij van het resultaat"
            },
            {
              "icon": "",
              "label": "Een letterlijke waarde van 2, gebruikt als een tiebreaker"
            },
            {
              "icon": "",
              "label": "De tweede kolom in de SELECT-lijst, salary — ORDER BY accepteert een kolompositionummer als afkorting"
            }
          ]
        },
        {
          "question": "In standaard SQL, wat evalueert 'Ana' || ' ' || 'Lee' naar?",
          "options": [
            {
              "icon": "",
              "label": "Een syntaxfout — SQL heeft geen concatenatie-operator"
            },
            {
              "icon": "",
              "label": "3 — || wordt behandeld als een booleaanse OR en retourneert een getal"
            },
            {
              "icon": "",
              "label": "'AnaLee' — || voegt samen zonder spaties te behouden"
            },
            {
              "icon": "",
              "label": "'Ana Lee' — || is de standaard SQL string-concatenatie-operator"
            }
          ]
        },
        {
          "question": "Welke van deze is exact gelijk aan WHERE status IN ('open', 'pending', 'review')?",
          "options": [
            {
              "icon": "",
              "label": "WHERE status = 'open' AND status = 'pending' AND status = 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status != 'open' OR status != 'pending' OR status != 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status = 'open' OR status = 'pending' OR status = 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status LIKE 'open,pending,review'"
            }
          ]
        },
        {
          "question": "customers heeft 100 rijen; 20 van hen hebben nooit een bestelling geplaatst. U voert SELECT c.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id uit. Verschijnen de 20 klanten zonder bestellingen in het resultaat?",
          "options": [
            {
              "icon": "",
              "label": "Ja, elk één keer, met o.id weergegeven als NULL"
            },
            {
              "icon": "",
              "label": "Ja, maar alleen als zij ook in een WHERE-clausule voorkomen"
            },
            {
              "icon": "",
              "label": "Nee — INNER JOIN retourneert alleen rijen die een overeenkomst hebben in beide tabellen, dus klanten zonder bestellingen worden volledig verwijderd"
            },
            {
              "icon": "",
              "label": "Ja, geduplificeerd eenmaal per kolom in orders"
            }
          ]
        },
        {
          "question": "U wilt elke klant ongeacht of zij bestellingen hebben, dus u schrijft SELECT c.id, o.total FROM customers c LEFT JOIN orders o ON c.id = o.customer_id WHERE o.total > 100. Retourneert dit nog steeds klanten met nul bestellingen?",
          "options": [
            {
              "icon": "",
              "label": "Nee — filteren op o.total in de WHERE-clausule verwijdert de NULL-rijen die LEFT JOIN produceerde voor niet-overeenkomende klanten, dus het gedraagt zich als een INNER JOIN"
            },
            {
              "icon": "",
              "label": "Ja — LEFT JOIN behoudt altijd elke rij van customers, ongeacht wat volgt"
            },
            {
              "icon": "",
              "label": "Ja, met o.total weergegeven als 0 voor klanten zonder bestellingen"
            },
            {
              "icon": "",
              "label": "Nee — LEFT JOIN converteert zichzelf stilletjes naar een RIGHT JOIN wanneer een WHERE-clausule wordt toegevoegd"
            }
          ]
        },
        {
          "question": "Een employees tabel heeft een id kolom en een manager_id kolom die naar een andere rij's id wijst. Om elke werknemer naast de naam van hun manager op te sommen, voegt u de tabel aan zichzelf toe: SELECT e.name, m.name FROM employees e JOIN employees m ON e.manager_id = m.id. Hoe heet dit patroon?",
          "options": [
            {
              "icon": "",
              "label": "Een cross join — elke werknemer wordt gematcht met elke manager"
            },
            {
              "icon": "",
              "label": "Een recursieve join — het haalt de volledige management chain op"
            },
            {
              "icon": "",
              "label": "Een self-join — dezelfde tabel wordt aan zichzelf gekoppeld met twee verschillende aliassen"
            },
            {
              "icon": "",
              "label": "Dit is ongeldig SQL — een tabel kan niet aan zichzelf worden gekoppeld"
            }
          ]
        },
        {
          "question": "Twee SELECT-zoekopdrachten met dezelfde kolommen worden gecombineerd met UNION. Als beide zoekopdrachten een identieke rij retourneren, hoeveel kopieën van die rij verschijnen in het uiteindelijke resultaat?",
          "options": [
            {
              "icon": "",
              "label": "Één — UNION verwijdert duplicate rijen over het gecombineerde resultaat; UNION ALL zou beide kopieën behouden"
            },
            {
              "icon": "",
              "label": "Twee — UNION behoudt elke rij van beide zoekopdrachten"
            },
            {
              "icon": "",
              "label": "Nul — UNION verwijdert elke rij die in beide zoekopdrachten voorkomt"
            },
            {
              "icon": "",
              "label": "Het hangt ervan af welke zoekopdracht de rij eerst vermeldde"
            }
          ]
        },
        {
          "question": "Tabel sizes heeft 3 rijen en colors heeft 4 rijen. Hoeveel rijen retourneert SELECT * FROM sizes CROSS JOIN colors?",
          "options": [
            {
              "icon": "",
              "label": "7 — CROSS JOIN telt de rijtellingen bij elkaar op"
            },
            {
              "icon": "",
              "label": "12 — een CROSS JOIN retourneert elke mogelijke combinatie van rijen uit beide tabellen (3 x 4)"
            },
            {
              "icon": "",
              "label": "3 — CROSS JOIN retourneert één rij per rij in de eerste tabel"
            },
            {
              "icon": "",
              "label": "0 — CROSS JOIN vereist een ON-voorwaarde of het retourneert niets"
            }
          ]
        },
        {
          "question": "orders heeft 1 rij voor order #100, en order_items heeft 3 rijen voor order #100 (één per regelitem). U voert SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100 uit. Hoeveel rijen worden geretourneerd voor order #100?",
          "options": [
            {
              "icon": "",
              "label": "3 — de join produceert één uitvoerrij per overeenkomende order_items rij, dus de enkele rij van order #100 wordt eenmaal per regelitem herhaald"
            },
            {
              "icon": "",
              "label": "1 — orders heeft slechts één rij voor order #100, dus de join kan er niet meer produceren"
            },
            {
              "icon": "",
              "label": "4 — één rij voor de bestelling plus één per regelitem"
            },
            {
              "icon": "",
              "label": "0 — het joinen van een tabel met één rij naar een tabel met drie rijen op een niet-unieke sleutel mislukt"
            }
          ]
        },
        {
          "question": "SELECT c.name, o.id FROM customers c RIGHT JOIN orders o ON c.id = o.customer_id retourneert dezelfde rijen als welke van deze?",
          "options": [
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM orders o LEFT JOIN customers c ON c.id = o.customer_id — de tafel-volgorde omwisselen en LEFT JOIN gebruiken in plaats van RIGHT JOIN is gelijk"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM customers c LEFT JOIN orders o ON c.id = o.customer_id"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM orders o CROSS JOIN customers c"
            }
          ]
        },
        {
          "question": "In standaard SQL, u voert SELECT department, name, AVG(salary) FROM employees GROUP BY department uit. Is dit een geldige zoekopdracht?",
          "options": [
            {
              "icon": "",
              "label": "Ja — GROUP BY hoeft alleen department op te nemen omdat het eerst wordt vermeld"
            },
            {
              "icon": "",
              "label": "Nee — name wordt geselecteerd maar noch samengevoegd noch in GROUP BY vermeld, en standaard SQL vereist dat elke niet-samengevoegde geselecteerde kolom in de GROUP BY-clausule verschijnt"
            },
            {
              "icon": "",
              "label": "Ja — SQL kiest automatisch één willekeurige naam per afdeling"
            },
            {
              "icon": "",
              "label": "Nee — AVG() kan niet met GROUP BY in dezelfde zoekopdracht worden gecombineerd"
            }
          ]
        },
        {
          "question": "U wilt afdelingen waarvan het gemiddelde salaris 80000 overschrijdt. Welke clausule filtert op een samengevoegde waarde zoals AVG(salary) na groepering — WHERE of HAVING?",
          "options": [
            {
              "icon": "",
              "label": "WHERE — HAVING wordt alleen gebruikt met UNION-zoekopdrachten"
            },
            {
              "icon": "",
              "label": "Beide werken identiek met aggregate-functies"
            },
            {
              "icon": "",
              "label": "Geen van beide — aggregatie filteren vereist een subquery"
            },
            {
              "icon": "",
              "label": "HAVING — WHERE filtert afzonderlijke rijen voordat groepering plaatsvindt, HAVING filtert groepen na aggregatie"
            }
          ]
        },
        {
          "question": "U schrijft SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000. Voert dit uit?",
          "options": [
            {
              "icon": "",
              "label": "Ja — aliassen die in SELECT worden gedefinieerd, zijn altijd beschikbaar voor WHERE in dezelfde zoekopdracht"
            },
            {
              "icon": "",
              "label": "Ja, maar alleen voor numerieke aliassen"
            },
            {
              "icon": "",
              "label": "Nee — AS is niet toegestaan in een WHERE-gefilterde zoekopdracht"
            },
            {
              "icon": "",
              "label": "Nee — WHERE wordt geëvalueerd voordat SELECT de alias new_salary toewijst, dus de alias bestaat op dat moment in de uitvoering nog niet"
            }
          ]
        },
        {
          "question": "SELECT name FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = e.department). Waarom heet dit een gecorreleerde subquery?",
          "options": [
            {
              "icon": "",
              "label": "Omdat het een JOIN gebruikt in plaats van een WHERE-clausule"
            },
            {
              "icon": "",
              "label": "De binnenste subquery verwijst naar e.department van de buitenste zoekopdracht, dus deze moet voor elke rij die de buitenste zoekopdracht overweegt opnieuw worden geëvalueerd"
            },
            {
              "icon": "",
              "label": "Omdat het meer dan één kolom retourneert"
            },
            {
              "icon": "",
              "label": "Omdat het precies eenmaal wordt uitgevoerd voordat de buitenste zoekopdracht begint"
            }
          ]
        },
        {
          "question": "Een subquery SELECT manager_id FROM employees retourneert enkele NULL-waarden samen met echte id's. U voert SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees) uit. Wat gebeurt er?",
          "options": [
            {
              "icon": "",
              "label": "Het retourneert elke werknemer die geen manager is, waarbij NULLs worden genegeerd"
            },
            {
              "icon": "",
              "label": "Het retourneert nul rijen — een enkele NULL in de NOT IN-lijst maakt elke vergelijking UNKNOWN, dus geen rij kan aan de voorwaarde voldoen"
            },
            {
              "icon": "",
              "label": "Het genereert een fout omdat NOT IN niet met subquery's kan worden gebruikt"
            },
            {
              "icon": "",
              "label": "Het retourneert elke werknemer, omdat NULL als een wildcard wordt behandeld"
            }
          ]
        },
        {
          "question": "SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id). Wat retourneert dit?",
          "options": [
            {
              "icon": "",
              "label": "Elke klant die minstens één rij in orders heeft — EXISTS controleert alleen of de subquery rijen retourneert, niet welke waarden ze bevatten"
            },
            {
              "icon": "",
              "label": "Elke klant, omdat SELECT 1 altijd waar retourneert"
            },
            {
              "icon": "",
              "label": "Een fout, omdat de subquery een getal selecteert in plaats van een kolomnaam"
            },
            {
              "icon": "",
              "label": "Alleen klanten met exact één bestelling"
            }
          ]
        },
        {
          "question": "U schrijft SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c, en een bepaalde klant heeft 3 rijen in orders. Wat gebeurt er wanneer deze zoekopdracht wordt uitgevoerd?",
          "options": [
            {
              "icon": "",
              "label": "Het retourneert de eerste overeenkomende order_id en negeert de andere twee stilletjes"
            },
            {
              "icon": "",
              "label": "Het retourneert een door komma's gescheiden lijst van alle drie order_ids"
            },
            {
              "icon": "",
              "label": "Het retourneert 3 rijen voor die klant, één per bestelling"
            },
            {
              "icon": "",
              "label": "Het genereert een fout bij runtime — een scalaire subquery in de SELECT-lijst moet hooguit één rij retourneren, en deze retourneert drie"
            }
          ]
        },
        {
          "question": "Vier rijen delen het hoogste score. Met RANK() ORDER BY score DESC krijgen alle vier rank 1. Welke rank krijgt de volgende rij eronder?",
          "options": [
            {
              "icon": "",
              "label": "5 — RANK() laat een gat achter gelijk aan het aantal rijen met gelijkspel voordat verder gaat"
            },
            {
              "icon": "",
              "label": "2 — RANK() wordt altijd precies één verhoogd na gelijkspel"
            },
            {
              "icon": "",
              "label": "1 — elke volgende rij krijgt ook rank 1"
            },
            {
              "icon": "",
              "label": "4 — RANK() herstart het tellen vanaf het aantal rijen met gelijkspel"
            }
          ]
        },
        {
          "question": "Vier rijen delen het hoogste score. Met DENSE_RANK() ORDER BY score DESC krijgen alle vier rank 1. Welke rank krijgt de volgende rij eronder?",
          "options": [
            {
              "icon": "",
              "label": "5 — DENSE_RANK() gedraagt zich precies als RANK()"
            },
            {
              "icon": "",
              "label": "1 — DENSE_RANK() wijst dezelfde rang toe aan elke resterende rij"
            },
            {
              "icon": "",
              "label": "2 — DENSE_RANK() laat nooit gaten achter, dus de volgende onderscheidende waarde krijgt altijd de volgende opeenvolgende rang"
            },
            {
              "icon": "",
              "label": "3 — DENSE_RANK() slaat één rang per gelijkspelgroep over"
            }
          ]
        },
        {
          "question": "SUM(amount) OVER (PARTITION BY region ORDER BY amount) wordt aan een zoekopdracht toegevoegd. Wat doet PARTITION BY region hier?",
          "options": [
            {
              "icon": "",
              "label": "Het herstart de lopende som afzonderlijk voor elke regio, in plaats van op het gehele resultaat op te tellen"
            },
            {
              "icon": "",
              "label": "Het filtert de resultaten op één regio"
            },
            {
              "icon": "",
              "label": "Het groepeert en voegt de rijen samen tot één per regio, zoals GROUP BY"
            },
            {
              "icon": "",
              "label": "Het sorteert de regio's alfabetisch voordat het optelt"
            }
          ]
        },
        {
          "question": "ROW_NUMBER() OVER (ORDER BY score DESC) wordt toegepast op vijf rijen, twee waarvan exact gelijk in score zijn. Kunnen twee rijen ooit hetzelfde rijnummer ontvangen?",
          "options": [
            {
              "icon": "",
              "label": "Ja — rijen met gelijkspel delen altijd hetzelfde rijnummer"
            },
            {
              "icon": "",
              "label": "Alleen als PARTITION BY ook wordt gebruikt"
            },
            {
              "icon": "",
              "label": "Het hangt ervan af of het gelijkspel in de eerste of laatste positie staat"
            },
            {
              "icon": "",
              "label": "Nee — ROW_NUMBER() wijst altijd een uniek, strikt toenemend getal toe aan elke rij, zelfs als waarden gelijk zijn"
            }
          ]
        },
        {
          "question": "WITH high_earners AS (SELECT * FROM employees WHERE salary > 100000) SELECT department, COUNT(*) FROM high_earners GROUP BY department. Wat is high_earners?",
          "options": [
            {
              "icon": "",
              "label": "Een common table expression (CTE) — een benoemde, tijdelijke resultatenset die de rest van de zoekopdracht kan refereren als een tabel"
            },
            {
              "icon": "",
              "label": "Een permanente tabel die in de database is aangemaakt"
            },
            {
              "icon": "",
              "label": "Een weergave die blijft bestaan nadat de zoekopdracht is voltooid"
            },
            {
              "icon": "",
              "label": "Een opgeslagen procedure die afzonderlijk moet worden aangeroepen"
            }
          ]
        },
        {
          "question": "Een kolom is gedeclareerd als PRIMARY KEY. Kunt u een rij invoegen waarbij die kolom NULL is?",
          "options": [
            {
              "icon": "",
              "label": "Ja — PRIMARY KEY dwingt alleen uniciteit af, niet NULL-ness"
            },
            {
              "icon": "",
              "label": "Ja, maar slechts één NULL-rij is toegestaan, hetzelfde als een UNIQUE-beperking"
            },
            {
              "icon": "",
              "label": "Nee — een PRIMARY KEY-kolom is impliciet NOT NULL, dus het invoegen van NULL erin wordt geweigerd"
            },
            {
              "icon": "",
              "label": "Het hangt ervan af of de kolom ook een standaardwaarde heeft"
            }
          ]
        },
        {
          "question": "Binnen een open transactie, u voert een UPDATE uit maar hebt nog geen COMMIT uitgevoerd. Vanuit een tweede, aparte verbinding met de database, is die update zichtbaar?",
          "options": [
            {
              "icon": "",
              "label": "Ja — alle verbindingen zien elke schrijfbewerking op het moment dat deze wordt uitgevoerd"
            },
            {
              "icon": "",
              "label": "Ja, maar alleen als de tweede verbinding ook een transactie opent"
            },
            {
              "icon": "",
              "label": "Het hangt alleen ervan af welke tabel is bijgewerkt"
            },
            {
              "icon": "",
              "label": "Nee — een onbevestigde wijziging is alleen zichtbaar binnen de transactie die het heeft gemaakt, totdat COMMIT het duurzaam maakt en zichtbaar voor anderen"
            }
          ]
        },
        {
          "question": "products.category_id heeft een FOREIGN KEY-beperking die verwijst naar categories.id. U probeert een rij uit categories te verwijderen die nog steeds producten erop wijzen, zonder ON DELETE-regel opgegeven. Wat gebeurt er?",
          "options": [
            {
              "icon": "",
              "label": "De categorie-rij wordt verwijderd en de overeenkomende products.category_id-waarden worden automatisch ingesteld op NULL"
            },
            {
              "icon": "",
              "label": "De categorie-rij wordt verwijderd en elk product dat naar dit verwees, wordt ook verwijderd"
            },
            {
              "icon": "",
              "label": "De DELETE wordt geweigerd — het standaard foreign key-gedrag blokkeert het verwijderen van een gerefereerde rij terwijl afhankelijke rijen er nog naar wijzen"
            },
            {
              "icon": "",
              "label": "De DELETE slaagt stilletjes, waardoor products' category_id naar een categorie wijst die niet meer bestaat"
            }
          ]
        }
      ],
      "optionOrderVersion": "e0466e547cfd8a45"
    }
  }
}