Top 99 SQL-sollicitatievragen en -antwoorden voor 2026

SQL-sollicitatievragen in een oogopslag

SQL-interviews lijken vaak op de manier waarop mensen de taal daadwerkelijk leren.

In het begin gaat het om vocabulaire en grammatica, zoals weten wat een join is, hoe SELECT werkt, en het verschil tussen DDL en DML.

Naarmate je vertrouwder raakt, verschuift de focus van "kun je een query schrijven" naar "kun je de juiste query schrijven." Je leert begrijpen wanneer een index helpt, waarom normalisatie ertoe doet, en hoe subtiel verschillende commando’s zoals DELETE en TRUNCATE zich onder de motorkap gedragen.

Op senior niveau wordt de syntax verondersteld bekend te zijn en draait de echte test om probleemoplossing: omgaan met duplicaten, NULLs, ties en rankinglogica met windowfuncties en CTE’s, en redeneren over transacties, gelijktijdigheid en performance. 

Voor intermediate practitioners

1. Functies in SQL. Je moet aggregate en scalar functies kennen, evenals ingebouwde en door de gebruiker gedefinieerde functies.

2. Geavanceerde commando’s. Vragen kunnen onderwerpen behandelen zoals joins, primary en foreign keys, indexen en SQL-relaties.

3. Databaseontwerp. Verwacht vragen over normalisatie, denormalisatie en de verschillen tussen diverse SQL-statements zoals DELETE, TRUNCATE en DROP.

4. Geavanceerde queries. Je kunt vragen krijgen over subqueries, zowel geneste als gecorreleerde, en hoe je specifieke taken uitvoert zoals het vinden van de n-de hoogste waarde in een kolom.

Algemene SQL-sollicitatievragen

Voor ze je technische vragen stellen, kan je interviewer eerst wat algemene vragen stellen over je totale ervaring met SQL.\

Maak je geen zorgen als je ervaring met SQL beperkt is: dit weet je interviewer waarschijnlijk al uit je cv. Aangezien ze toch met je willen praten, is je profiel als goede match voor hun bedrijf beoordeeld. Bovendien is het helemaal prima als je slechts met één SQL-dialect hebt gewerkt. Onthoud dat alle SQL-dialecten behoorlijk op elkaar lijken. Vertrouwd zijn met één dialect is daarom een solide basis om andere dialecten te leren.

1. Wat is SQL?

Het staat voor Structured Query Language en is een programmeertaal die wordt gebruikt om te communiceren met relationele databasebeheersystemen (RDBMS). Dit omvat het ophalen, bijwerken, invoegen en verwijderen van data uit tabellen.

2. Wat zijn SQL-dialecten? Geef enkele voorbeelden.

De verschillende versies van SQL, zowel gratis als betaald, worden ook wel SQL-dialecten genoemd. Alle dialecten van SQL hebben een zeer vergelijkbare syntax en verschillen slechts beperkt in aanvullende functionaliteit. Enkele voorbeelden zijn Microsoft SQL Server, PostgreSQL, MySQL, SQLite, T-SQL en Oracle.

3. Wat zijn de belangrijkste toepassingen van SQL?

Met SQL kunnen we:

• tabellen in een database maken, verwijderen en bijwerken
• data in een tabel benaderen, manipuleren en wijzigen
• de benodigde informatie uit één of meerdere tabellen opvragen en samenvatten
• bepaalde rijen of kolommen aan een tabel toevoegen of eruit verwijderen

SQL-sollicitatievragen voor beginners 

Je interviewer kan het gesprek op gang brengen met de makkelijkere vragen:

4. Wat is een SQL-statement?

Ook bekend als een SQL-commando. Het is een tekenreeks die door de SQL-engine wordt geïnterpreteerd als een geldig commando en dienovereenkomstig wordt uitgevoerd. Enkele voorbeelden van SQL-statements zijn SELECT, CREATE, DELETE, DROP, REVOKE, enzovoort.

5. Wat is een SQL-query?

Een query is een stukje code in SQL om data uit een database te benaderen of te wijzigen.

Er zijn twee soorten SQL-queries: queries voor data-opvraging en datamanipulatie. De eerste categorie wordt gebruikt om de benodigde data op te halen (waaronder ook het beperken, groeperen, sorteren van data, data uit meerdere tabellen halen, enz.), terwijl de tweede wordt gebruikt om data te maken, toe te voegen, verwijderen, bijwerken en hernoemen.

6. Wat is een SQL-subquery?

Ook wel een inner query genoemd: een query die in een andere (outer) query is geplaatst. Een subquery kan voorkomen in clausules zoals SELECT, FROM, WHERE, UPDATE, enz. Het is ook mogelijk om een subquery binnen een andere subquery te hebben. De binnenste subquery wordt eerst uitgevoerd en het resultaat wordt doorgegeven aan de omvattende query (of subquery).

7. Wat is een SQL-join?

Een clausule die wordt gebruikt om records uit twee of meer tabellen te combineren en op te halen. SQL-tabellen kunnen worden gejoined op basis van de relatie tussen de kolommen van die tabellen. Bekijk onze SQL joins-tutorial voor meer context, plus onze gids met SQL-join-sollicitatievragen. 

8. Wat is een SQL-commentaar?

Een voor mensen leesbare toelichting op wat een bepaald stuk code doet. SQL-codecommentaar kan uit één regel bestaan (voorafgegaan door twee streepjes --) of meerdere regels beslaan (als volgt: /*comment_text*/). Wanneer de SQL-engine draait, worden codecommentaren genegeerd. Het doel van SQL-commentaar is om de code begrijpelijker te maken voor mensen die deze later lezen.

9. Wat is een SQL-alias?

Een tijdelijke naam die aan een tabel (of kolom in een tabel) wordt gegeven tijdens het uitvoeren van een bepaalde SQL-query. Aliassen worden gebruikt om de leesbaarheid te verbeteren en de code compacter te maken. Een alias wordt geïntroduceerd met het sleutelwoord AS:

SELECT col_1 AS column
FROM table_name;

Technische SQL-sollicitatievragen

Laten we nu doorgaan met de technische SQL-sollicitatievragen en mogelijke antwoorden daarop.

Bij technische vragen is het het beste om zo precies mogelijk te antwoorden. Te vage antwoorden kunnen overkomen als een poging om af te dwalen van het onderwerp en mogelijk extra vragen oproepen waar je je minder zeker over voelt.

Al met al kun je met SQL een database op meerdere manieren bevragen. Bovendien integreert SQL eenvoudig met andere programmeertalen, zoals Python of R, zodat we hun gecombineerde kracht kunnen benutten.

10. Welke typen SQL-commando’s ken je?

• Data Definition Language (DDL) – om de structuur van een database te definiëren en te wijzigen.
• Data Manipulation Language (DML) – om data in een database te benaderen, manipuleren en wijzigen.
• Data Control Language (DCL) – om gebruikers toegang tot data in de database te beheren en privileges te geven of in te trekken voor een specifieke gebruiker of groep gebruikers.
• Transaction Control Language (TCL) – om transacties in een database te beheren.
• Data Query Language (DQL) – om queries op de data in een database uit te voeren om de benodigde informatie op te halen.

11. Geef enkele voorbeelden van veelgebruikte SQL-commando’s.

• DDL: CREATE, ALTER TABLE, DROP, TRUNCATE en ADD COLUMN

• DML: UPDATE, DELETE en INSERT

• DCL: GRANT en REVOKE

• TCL: COMMIT, SET TRANSACTION, ROLLBACK en SAVEPOINT

• DQL: – SELECT

12. Wat is DBMS, en welke typen DBMS ken je?

Dit staat voor Database Management System, een softwarepakket dat wordt gebruikt om verschillende bewerkingen uit te voeren op de data die in een database is opgeslagen, zoals benaderen, bijwerken, opschonen, invoegen en verwijderen van data. Er zijn verschillende typen DBMS, zoals relationeel, hiërarchisch, netwerk-, grafen- of objectgeoriënteerd. Deze typen zijn gebaseerd op de manier waarop data in het systeem wordt georganiseerd, gestructureerd en opgeslagen.

13. Wat is RDBMS? Geef enkele voorbeelden van RDBMS.

Dit staat voor Relational Database Management System. Het is het meest gebruikte type DBMS voor het werken met data die in meerdere tabellen is opgeslagen en via gedeelde keys aan elkaar is gerelateerd. De programmeertaal SQL is ontworpen om met RDBMS te communiceren. Voorbeelden van RDBMS zijn MySQL, PostgreSQL, Oracle, MariaDB, enz.

14. Wat zijn tabellen en velden in SQL?

Een tabel is een geordende set gerelateerde data die in tabelvorm is opgeslagen, d.w.z. in rijen en kolommen. Een veld is een andere benaming voor een kolom van een tabel.

15. Welke typen SQL-subqueries ken je?

• Single-row – retourneert hoogstens één rij.
• Multi-row – retourneert ten minste twee rijen.
• Multi-column – retourneert ten minste twee kolommen.
• Correlated – een subquery die gerelateerd is aan informatie uit de outer query.
• Nested – een subquery binnen een andere subquery.

16. Wat is een constraint en waarom gebruik je constraints?

Een set voorwaarden die het type data definiëren dat in elke kolom van een tabel kan worden ingevoerd. Constraints zorgen voor dataintegriteit in een tabel en blokkeren ongewenste acties.

17. Welke SQL-constraints ken je?

• DEFAULT – levert een standaardwaarde voor een kolom.

• UNIQUE – staat alleen unieke waarden toe.

• NOT NULL – staat alleen niet-NULL-waarden toe.

• PRIMARY KEY – staat alleen unieke en strikt niet-NULL-waarden toe (NOT NULL en UNIQUE).

• FOREIGN KEY – zorgt voor gedeelde keys tussen twee of meer tabellen.

18. Welke typen joins ken je?

• (INNER) JOIN – retourneert alleen die records die voldoen aan een gedefinieerde joinvoorwaarde in beide (of alle) tabellen. Dit is de standaard SQL-join.

• LEFT (OUTER) JOIN – retourneert alle records uit de linkertabel en die records uit de rechtertabel die voldoen aan een gedefinieerde joinvoorwaarde.

• RIGHT (OUTER) JOIN – retourneert alle records uit de rechtertabel en die records uit de linkertabel die voldoen aan een gedefinieerde joinvoorwaarde.

• FULL (OUTER) JOIN – retourneert alle records uit beide (of alle) tabellen. Dit kun je zien als een combinatie van left en right joins.

Let op: FULL OUTER JOIN wordt ondersteund door PostgreSQL, SQL Server, Oracle en MySQL 8.0 en hoger, maar MySQL staat dit alleen toe via UNION-patronen; ondertussen ondersteunt SQLite geen RIGHT JOIN, wat kan worden nagebootst met LEFT JOIN in combinatie met UNION.

19. Wat is een primary key in SQL?

Een kolom (of meerdere kolommen) van een tabel waarop de PRIMARY KEY-constraint is toegepast om unieke en niet-NULL-waarden in die kolom te garanderen. Met andere woorden, een primary key is een combinatie van de NOT NULL- en UNIQUE-constraints. De primary key identificeert elke record in de tabel uniek.

Gerelateerd concept — Surrogaatkey: Een surrogaatkey is een kunstmatig gegenereerde identifier (meestal een sequentieel geheel getal of UUID) die aan elke record wordt toegekend, onafhankelijk van de daadwerkelijke datavelden. In tegenstelling tot natuurlijke keys (bijv. een e-mailadres) blijven surrogaatkeys stabiel wanneer bedrijfsdata verandert, waardoor ze in productiedatabases vaak als primary key worden gebruikt.

 Elke tabel kan hoogstens één PRIMARY KEY definiëren (die samengesteld kan zijn). Een PRIMARY KEY  wordt sterk aanbevolen maar is niet door alle engines strikt vereist.

20. Wat is een unique key in SQL?

Een kolom (of meerdere kolommen) van een tabel waarop de UNIQUE-constraint is toegepast om unieke waarden in die kolom te garanderen, inclusief een mogelijke NULL-waarde (hoogstens één).

Let op: 

• SQL Server: Slechts één NULL toegestaan, tenzij je een gefilterde index gebruikt.
• PostgreSQL / Oracle / MySQL: Meerdere NULL's toegestaan omdat NULL <> NULL.

21. Wat is een foreign key in SQL? 

Een kolom (of meerdere kolommen) van een tabel waarop de FOREIGN KEY- (of UNIQUE-key-) constraint is toegepast om deze kolom te koppelen aan de primary key in een andere tabel (of meerdere tabellen). Het doel van foreign keys is om verschillende tabellen in een database met elkaar verbonden te houden.

22. Wat is een SQL-index?

Een speciale datastructuur die is gekoppeld aan een databasetabel en wordt gebruikt om belangrijke delen ervan op te slaan en snellere zoek- en ophaalacties mogelijk te maken. Indexen zijn vooral efficiënt voor grote databases, waar ze de queryprestaties aanzienlijk verbeteren.

23. Welke typen indexen ken je?

• Unieke index – staat geen duplicaten toe in een tabelkolom en helpt zo de dataintegriteit te behouden.
• Clustered index – bepaalt de fysieke volgorde van records van een databasetabel en zoekt data op basis van keywaarden. Een tabel kan slechts één clustered index hebben.
• Non-clustered index – bewaart de volgorde van tabelrecords die niet overeenkomt met de fysieke ordening van de daadwerkelijke data op de schijf. Dit betekent dat de data op de ene plek is opgeslagen en een non-clustered index op een andere. Een tabel kan meerdere non-clustered indexen hebben.

24. Wat is een schema?

Een verzameling van structurele elementen van een database, zoals tabellen, stored procedures, indexen, functies en triggers. Het toont de algehele databasearchitectuur, specificeert de relaties tussen verschillende objecten in een database en definieert verschillende toegangsrechten ervoor. Lees onze gids over databaseschema’s voor meer diepgang.

25. Wat is een SQL-operator?

Een gereserveerd teken, een tekencombinatie of een sleutelwoord dat in SQL-queries wordt gebruikt om een specifieke bewerking uit te voeren. SQL-operatoren worden vaak gebruikt met de WHERE-clausule om een voorwaarde(n) te stellen voor het filteren van data.

26. Welke typen SQL-operatoren ken je?

• Aritmetisch (+, -, *, /, enz.)

• Vergelijking (>, <, =, >=, enz.)

• Samengesteld (+=, -=, *=, /=, enz.)

• Logisch (AND, OR, NOT, BETWEEN, enz.)

• String (%, _, +, ^, enz.)

• Set (UNION, UNION ALL, INTERSECT en MINUS (of EXCEPT))

27. Wat is een clausule?

Een voorwaarde die aan een SQL-query wordt opgelegd om de data te filteren en zo het gewenste resultaat te verkrijgen. Enkele voorbeelden zijn WHERE, LIMIT, HAVING, LIKE, AND, OR, ORDER BY, enz.

28. Welke veelvoorkomende statements worden gebruikt met de SELECT-query?

De meest voorkomende zijn FROM, GROUP BY, JOIN, WHERE, ORDER BY, LIMIT en HAVING.

29. Hoe maak je een tabel in SQL?

Met hetCREATE TABLE-statement. Om bijvoorbeeld een tabel met drie kolommen van vooraf gedefinieerde datatypes te maken, gebruiken we de volgende syntax:

CREATE TABLE table_name (col_1 datatype,
                         col_2 datatype,
                         col_3 datatype);

30. Hoe werk je een tabel bij?

Met het UPDATE-statement. De syntax is:

UPDATE table_name
SET col_1 = value_1, col_2 = value_2
WHERE condition;

31. Hoe verwijder je een tabel uit een database?

Met het DROP TABLE-statement. De syntax is: DROP TABLE table_name;.

32. Hoe krijg je het aantal records in een tabel?

Met de COUNT()-aggregatiefunctie met een asterisk als argument: SELECT COUNT(*) FROM table_name;.

33. Hoe sorteer je records in een tabel?

Met het ORDER BY-statement:

SELECT * FROM table_name
ORDER BY col_1;

We kunnen aangeven dat we een aflopende sortering nodig hebben met het sleutelwoord DESC; anders is de sortering standaard oplopend. Ook kunnen we op meer dan één kolom sorteren en per kolom afzonderlijk oplopend of aflopend specificeren. Bijvoorbeeld:

SELECT * FROM table_name
ORDER BY col_1 DESC, col_3, col_6 DESC;

34. Hoe selecteer je alle kolommen uit een tabel?

Met de asterisk * bij het SELECT-statement. De syntax is: SELECT * FROM table_name;.

35. Hoe selecteer je gemeenschappelijke records uit twee tabellen?

Met het INTERSECT-statement:

SELECT col1, col2 FROM table_1
INTERSECT
SELECT col1, col2 FROM table_2;

Let op: INTERSECT vereist hetzelfde aantal kolommen en compatibele types.

36. Wat is het DISTINCT-statement en hoe gebruik je het?

Dit statement wordt gebruikt met SELECT om duplicaten te filteren en alleen unieke waarden uit een kolom van een tabel te retourneren. De syntax is:

SELECT DISTINCT col_1
FROM table_name;

37. Wat zijn relaties? Geef enkele voorbeelden.

Relaties zijn de verbindingen en correlaties tussen entiteiten; ze geven in feite aan hoe twee of meer tabellen in een database met elkaar zijn verbonden. Zo kan een ID van dezelfde klant zowel in een tabel met verkoopdata als in een klantentabel voorkomen.

38. Wat is een NULL-waarde? Hoe verschilt die van nul of een lege spatie?

Een NULL-waarde geeft de afwezigheid van data aan voor een bepaalde cel van een tabel. Nul daarentegen is een geldige numerieke waarde en een lege string is een legale string van lengte nul.

39. Wat is het verschil tussen SQL en NoSQL?

SQL-databases zijn relationeel, gestructureerd en gebruiken tabellen met vooraf gedefinieerde schema’s, terwijl NoSQL-databases niet-relationeel, schemaloos zijn en ontworpen om ongestructureerde of semi-gestructureerde data te verwerken.

40. Wat zijn enkele veelvoorkomende uitdagingen bij het werken met SQL-databases?

Uitdagingen zijn onder meer het tunen van performance voor grote datasets, het beheren van indexeringsstrategieën, het waarborgen van dataintegriteit met constraints, omgaan met gelijktijdige transacties en het optimaliseren van query-uitvoering.

Intermediate SQL-sollicitatievragen

41. Wat is een Common Table Expression (CTE)?

Een Common Table Expression (CTE) is een tijdelijke benoemde resultaatset waarnaar je kunt verwijzen binnen een SELECT-, INSERT-, UPDATE- of DELETE-statement. CTE’s verbeteren de leesbaarheid van queries en stellen je in staat complexe queries op te splitsen in eenvoudigere, herbruikbare delen. De syntax gebruikt het sleutelwoord WITH:

WITH sales_summary AS (
  SELECT product_id, SUM(amount) AS total_sales
  FROM sales
  GROUP BY product_id
)
SELECT p.product_name, s.total_sales
FROM products p
JOIN sales_summary s ON p.id = s.product_id
WHERE s.total_sales > 10000;

CTE’s zijn bijzonder handig voor recursieve queries (hiërarchische data zoals organogrammen) en wanneer je meerdere keren naar dezelfde subquery moet verwijzen.

42. Wat zijn windowfuncties en hoe verschillen ze van aggregatiefuncties?

Windowfuncties voeren berekeningen uit over een set rijen die gerelateerd zijn aan de huidige rij, zonder het resultaat samen te vouwen tot één enkele uitvoerrij zoals aggregatiefuncties doen. Ze gebruiken de OVER()-clausule om het venster van rijen te definiëren.

Belangrijke windowfuncties zijn:

• ROW_NUMBER() – kent een unieke opeenvolgende nummering toe aan elke rij
• RANK() – kent een rang toe met gaten bij gelijke waarden
• DENSE_RANK() – kent een rang toe zonder gaten bij gelijke waarden
• LAG() / LEAD() – toegang tot data uit vorige/volgende rijen
• SUM() OVER(), AVG() OVER() – lopende of cumulatieve berekeningen

Voorbeeld: Running total van sales berekenen

SELECT 
  order_date,
  amount,
  SUM(amount) OVER (ORDER BY order_date) AS running_total
FROM orders;

43. Wat is het verschil tussen RANK(), DENSE_RANK() en ROW_NUMBER()?

Alle drie zijn ranking-windowfuncties, maar ze gaan anders om met gelijke waarden:

• ROW_NUMBER() – kent altijd unieke opeenvolgende nummers toe (1, 2, 3, 4...), ook bij gelijke waarden
• RANK() – kent dezelfde rang toe bij gelijke waarden, en slaat dan nummers over (1, 2, 2, 4...)
• DENSE_RANK() – kent dezelfde rang toe bij gelijke waarden, zonder over te slaan (1, 2, 2, 3...)

SELECT 
  name, 
  score,
  ROW_NUMBER() OVER (ORDER BY score DESC) AS row_num,
  RANK() OVER (ORDER BY score DESC) AS rank,
  DENSE_RANK() OVER (ORDER BY score DESC) AS dense_rank
FROM students;

Gebruik DENSE_RANK() bij het zoeken naar de "n-de hoogste" waarde waarbij gelijke waarden dezelfde positie moeten delen.

In deze sectie bekijken we de meest populaire intermediate SQL-vragen en -antwoorden, zodat je weet wat je van je interviewer kunt verwachten.

44. Wat is een functie in SQL?

Een databaseobject dat een set SQL-statements vertegenwoordigt die vaak voor een bepaalde taak worden gebruikt. Een functie neemt invoerparameters aan, voert berekeningen of andere bewerkingen daarop uit en retourneert het resultaat. Functies verbeteren de leesbaarheid van code en voorkomen herhaling van dezelfde codesnippets.

45. Welke typen SQL-functies ken je?

• Aggregatiefuncties – werken op meerdere, meestal gegroepeerde records voor de opgegeven kolommen van een tabel en retourneren één waarde (meestal per groep).
• Scalairfuncties – werken op elke individuele waarde en retourneren één waarde.

Anderzijds kunnen SQL-functies ingebouwd zijn (door het systeem gedefinieerd) of user-defined (door de gebruiker gemaakt voor specifieke behoeften).

46. Welke SQL-aggregatiefuncties ken je?

• AVG() – retourneert de gemiddelde waarde

• SUM() – retourneert de som van waarden

• MIN() – retourneert de minimumwaarde

• MAX() – retourneert de maximumwaarde

• COUNT() – retourneert het aantal rijen, inclusief die met NULL-waarden

47. Welke SQL-scalairfuncties ken je?

• LEN() (in andere SQL-dialecten – LENGTH()) – retourneert de lengte van een string, inclusief spaties

• UCASE() (in andere SQL dialecten – UPPER()) – retourneert een string in hoofdletters

• LCASE() (in andere SQL dialecten – LOWER()) – retourneert een string in kleine letters

• INITCAP() – retourneert een string in titelcasus (d.w.z. elk woord van de string begint met een hoofdletter)

• MID() (in andere SQL dialecten – SUBSTR()) – extraheert een substring uit een string

• ROUND() – retourneert de numerieke waarde afgerond op een opgegeven aantal decimalen

• NOW() – retourneert de huidige datum en tijd

48. Wat zijn case-manipulatiefuncties in SQL?

Case-manipulatiefuncties vormen een subset van tekstfuncties en worden gebruikt om de lettercase van tekstdata te wijzigen. Met deze functies kunnen we data omzetten naar hoofdletters, kleine letters of titelcasus.

• UCASE() (in andere SQL dialecten – UPPER()) – retourneert een string in hoofdletters

• LCASE() (in andere SQL dialecten – LOWER()) – retourneert een string in kleine letters

• INITCAP() – retourneert een string in titelcasus (d.w.z. elk woord van de string begint met een hoofdletter)

49. Wat zijn tekstringmanipulatiefuncties in SQL?

Tekstringmanipulatiefuncties vormen een subset van tekstfuncties en worden gebruikt om tekstdata te wijzigen.

• CONCAT() – voegt twee of meer stringwaarden samen door de tweede string achter de eerste te plaatsen

• SUBSTRING()/SUBSTR() – retourneert een deel van een string op basis van opgegeven begin- en eindpunten

• LENGTH() (in andere SQL dialecten – LEN()) – retourneert de lengte van een string, inclusief spaties

• REPLACE() – vervangt alle voorkomens van een gedefinieerde substring in een gegeven string door een andere substring

• INSTR() – retourneert de numerieke positie van een gedefinieerde substring in een gegeven string

• LPAD() en RPAD() – leveren padding van het linker-/rechterteken voor rechts-/linksuitgelijnde waarden

• TRIM() – verwijdert alle gedefinieerde tekens, evenals witruimtes, van de linker-, rechter- of beide uiteinden van een gegeven string

50. Wat is het verschil tussen lokale en globale variabelen?

Lokale variabelen zijn alleen toegankelijk binnen de functie waarin ze zijn gedeclareerd. Globale variabelen daarentegen, gedeclareerd buiten elke functie, worden opgeslagen in vaste geheugenstructuren en kunnen in het hele programma worden gebruikt.

51. Wat is het verschil tussen SQL en PL/SQL?

Er is geen verschil tussen LEFT JOIN en LEFT OUTER JOIN. Ze zijn uitwisselbaar. In SQL is het sleutelwoord OUTER optioneel, dus LEFT JOIN is simpelweg een afkorting voor LEFT OUTER JOIN. Beide retourneren alle records uit de linkertabel en de overeenkomende records uit de rechtertabel.

53. Wat is indexering in SQL en hoe verbetert het de performance?

Indexering creëert een speciale datastructuur die het ophalen van data versnelt doordat de database rijen efficiënter kan vinden. Het werkt als een geoptimaliseerde opzoektabel, waardoor volledige tabelscans minder vaak nodig zijn. Te veel indexen kunnen echter insert-, update- en delete-bewerkingen vertragen doordat indexen moeten worden bijgehouden.

54. Wat is een stored procedure en hoe verschilt die van een functie?

Een stored procedure is een voorgecompileerde set SQL-statements die als een eenheid wordt uitgevoerd om een taak uit te voeren. Procedures kunnen data of schema-objecten wijzigen, transacties beheren en nul of meer resultaatsets retourneren. Functies daarentegen worden doorgaans gebruikt in SQL-expressies, moeten een waarde retourneren (scalair of tabelvormig) en zijn in veel databases beperkt in bijwerkingen. Exact gedrag verschilt per DB (bijv. T-SQL heeft scalair- en tabelvormige functies; PostgreSQL maakt onderscheid tussen functies en procedures).

55. Wat is de standaard sorteervolgorde met het ORDER BY-statement, en hoe wijzig je die?

Standaard is oplopend (NULLS FIRST/LAST verschilt per DB). Gebruik per kolom de sleutelwoorden ASC/DESC als volgt:

SELECT * FROM table_name 
ORDER BY col_1 DESC;

56. Wat zijn SQL-setoperatoren?

• UNION – retourneert de records verkregen door ten minste één van twee queries (exclusief duplicaten)

• UNION ALL – retourneert de records verkregen door ten minste één van twee queries (inclusief duplicaten)

• INTERSECT – retourneert de records die door beide queries zijn verkregen

• EXCEPT (in MySQL en Oracle MINUS genoemd) – retourneert alleen de records die door de eerste query zijn verkregen maar niet door de tweede

57. Welke operator gebruik je in een query voor pattern matching?

De LIKE-operator in combinatie met de wildcards % en _. De %-wildcard staat voor elk aantal tekens, inclusief nul, terwijl _ – strikt één teken vertegenwoordigt.

58. Wat is het verschil tussen een primary key en een unique key in SQL?

Hoewel beide soorten keys unieke waarden in een kolom van een tabel garanderen, identificeert de eerste elke record van de tabel uniek, en de tweede voorkomt duplicaten in die kolom.

59. Wat is een samengestelde primary key in SQL?

De primary key van een tabel, gebaseerd op meerdere kolommen.

60. Wat is de typische volgorde van SQL-clausules in een SELECT-statement?

SELECT – FROM – JOIN – ON – WHERE – GROUP BY – HAVING – ORDER BY – LIMIT

61. In welke volgorde voert de interpreter de gebruikelijke statements in de SELECT-query uit?

Dit is de SQL-uitvoervolgorde: 

FROM → ON → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT/OFFSET (FETCH)

62. Wat is een view in SQL?

Een virtuele tabel met een subset van data die uit één of meer databasetabellen (of andere views) wordt opgehaald. Standaard views slaan geen data op; gematerialiseerde views wel. Views kunnen queries vereenvoudigen, logica inkapselen en, gecombineerd met privileges, kolommen/rijen beperken. Ze kunnen data uit meerdere tabellen joinen/aggregeren.

63. Kunnen we een view maken op basis van een andere view in SQL?

Ja. Dit staat ook bekend als geneste views. We moeten echter voorkomen dat we meerdere views nesten, omdat de code dan moeilijk te lezen en te debuggen wordt.

64. Kunnen we een view nog gebruiken als de oorspronkelijke tabel is verwijderd?

Nee. Alle views die op die tabel zijn gebaseerd, worden ongeldig nadat de basistabel is verwijderd. Als we zo’n view toch proberen te gebruiken, krijgen we een foutmelding.

65. Welke typen SQL-relaties ken je?

• One-to-one – elke record in de ene tabel correspondeert met slechts één record in een andere tabel
• One-to-many – elke record in de ene tabel correspondeert met meerdere records in een andere tabel
• Many-to-many – elke record in beide tabellen correspondeert met meerdere records in de andere tabel

66. Welke mogelijke waarden kan een BOOLEAN-datavelden hebben?

In sommige SQL-dialecten, zoals PostgreSQL, bestaat het BOOLEAN-datatype expliciet en neemt het de waarden TRUE, FALSE of NULL aan. In andere dialecten, zoals Microsoft SQL Server, wordt het BIT-datatype gebruikt om Booleaanse waarden als gehele getallen op te slaan: 1 (true) of 0 (false).

67. Wat is normalisatie in SQL?

Normalisatie is een proces in databaseontwerp waarbij data wordt georganiseerd en herstructureren om redundantie, afhankelijkheid, duplicatie en inconsistentie te verminderen. Dit leidt tot verbeterde dataintegriteit, meer tabellen binnen de database, efficiëntere data-toegang en beveiligingscontrole, en grotere queryflexibiliteit.

68. Wat is denormalisatie in SQL?

Denormalisatie is het tegenovergestelde proces van normalisatie: het introduceert dataredundantie en combineert data uit meerdere tabellen. Denormalisatie optimaliseert de performance van de database-infrastructuur in situaties waarin leesbewerkingen belangrijker zijn dan schrijfbewerkingen, omdat het complexe joins helpt vermijden en de uitvoeringstijd van queries verkort.

69. Wat is het verschil tussen het hernoemen van een kolom en er een alias aan geven?

Een kolom hernoemen betekent de daadwerkelijke naam permanent wijzigen in de oorspronkelijke tabel. Een alias toekennen aan een kolom betekent deze een tijdelijke naam geven tijdens het uitvoeren van een SQL-query, met als doel de code leesbaarder en compacter te maken.

70. Wat is het verschil tussen geneste en gecorreleerde subqueries?

Een gecorreleerde subquery is een inner query genest in een grotere (outer) query die voor de uitvoering verwijst naar waarden uit de outer query; met andere woorden, een gecorreleerde subquery is afhankelijk van de outer query. Een niet-gecorreleerde subquery daarentegen is niet afhankelijk van data uit de outer query en kan onafhankelijk worden uitgevoerd.

71. Wat is het verschil tussen clustered en non-clustered indexen?

Een clustered index bepaalt de fysieke volgorde van records in een tabel en zoekt data op basis van keywaarden, terwijl een non-clustered index de volgorde van records bewaart die niet overeenkomt met de fysieke volgorde van de daadwerkelijke data op de schijf. Een tabel kan slechts één clustered index hebben maar meerdere non-clustered indexen.

72. Wat doet de CASE()-functie?

De manier om if-then-else-logica in SQL te implementeren. Deze functie controleert sequentieel de opgegeven voorwaarden in de WHEN-clausules en retourneert de waarde uit de overeenkomstige THEN-clausule wanneer de eerste voorwaarde is voldaan. Als geen van de voorwaarden is voldaan, retourneert de functie de waarde uit de ELSE-clausule als die is opgegeven; anders retourneert hij NULL. De syntax is:

CASE
    WHEN condition_1 THEN value_1
    WHEN condition_2 THEN value_2
    WHEN condition_3 THEN value_3
    ...
    ELSE value
END;

73. Wat is het verschil tussen de statements DELETE en TRUNCATE?

DELETE is een DML-commando (Data Manipulation Language) dat wordt gebruikt om één of meer rijen uit een tabel te verwijderen op basis van een voorwaarde in de WHERE-clausule. Het is omkeerbaar alleen als het is ingekapseld in een transactie (via ROLLBACK).

TRUNCATE is een DDL-commando (Data Definition Language) dat alle rijen uit een tabel verwijdert door pagina’s vrij te geven. Het is sneller maar in het algemeen onomkeerbaar, en kan niet worden gebruikt op tabellen waarnaar een foreign key verwijst.

74. Wat is het verschil tussen de statements DROP en TRUNCATE?

DROP verwijdert een tabel volledig uit de database, inclusief de tabelstructuur en alle bijbehorende constraints, relaties met andere tabellen en toegangsrechten. TRUNCATE verwijdert alle rijen uit een tabel zonder de tabelstructuur en constraints te beïnvloeden.  Beide zijn DDL. DROP verwijdert de tabel en de metadata; TRUNCATE verwijdert alle rijen maar behoudt de tabeldefinitie. Performance en transactioneel gedrag hangen af van de DB-engine.

75. Wat is het verschil tussen de statements HAVING en WHERE?

De eerste werkt op geaggregeerde data nadat deze gegroepeerd zijn, terwijl de tweede elke rij individueel controleert. Als beide statements in een query voorkomen, staan ze in de volgende volgorde:WHERE – GROUP BY – HAVING. De SQL-engine interpreteert ze ook in die volgorde.

76. Hoe voeg je een record toe aan een tabel?

Met het INSERT INTO -statement in combinatie met VALUES. De syntax is:

INSERT INTO table_name
VALUES (value_1, value_2, ...);

77. Hoe verwijder je een record uit een tabel?

Met het DELETE-statement. De syntax is:

DELETE FROM table_name
WHERE condition;

Zo kunnen we ook meerdere records verwijderen als ze aan de opgegeven voorwaarde voldoen.

78. Hoe voeg je een kolom toe aan een tabel?

Met het ALTER TABLE-statement in combinatie met ADD. De syntax is:

ALTER TABLE table_name
ADD column_name datatype;

79. Hoe hernoem je een kolom van een tabel?

Met het ALTER TABLE-statement in combinatie met RENAME COLUMN ... TO ... De syntax is:

ALTER TABLE table_name
RENAME COLUMN old_column_name TO new_column_name;

80. Hoe verwijder je een kolom uit een tabel?

Met het ALTER TABLE-statement in combinatie met DROP COLUMN. De syntax is:

ALTER TABLE table_name
DROP COLUMN column_name;

81. Hoe selecteer je alle even of alle oneven records in een tabel?

Door de rest bij deling door 2 te controleren. In sommige SQL-versies (bijv. PostgreSQL en MySQL) gebruiken we de MOD-functie; in andere (Microsoft SQL Server en SQLite) – de modulo-operator (%). Om alle even records te selecteren met MOD:

SELECT * FROM table_name
WHERE MOD(ID_column, 2) = 0;

Om alle even records te selecteren met %:

SELECT * FROM table_name 
WHERE ID_column % 2 = 0;

Om alle oneven records te selecteren is de syntax in beide gevallen identiek, behalve dat we de ongelijk-operator <> gebruiken in plaats van =.

82. Hoe voorkom je dubbele records bij het maken van een query?

Met het DISTINCT-statement in combinatie met SELECT of door een unique key voor die tabel te maken.

83. Hoe voeg je meerdere rijen in een tabel in?

Met het INSERT INTO-statement in combinatie met VALUES. De syntax is:

INSERT INTO table_name
VALUES (value_1, value_2, ...),
      (value_3, value_4, ...),
      (value_5, value_6, ...),
      ...;

84. Hoe vind je de n-de hoogste waarde in een kolom van een tabel?

Gebruik windowfuncties om correct met gelijke waarden om te gaan:

SELECT column_name
FROM (
  SELECT column_name, DENSE_RANK() OVER (ORDER BY column_name DESC) AS rnk
  FROM table_name
) t
WHERE rnk = :n;

Voor de n-de rij op volgorde (zonder rekening te houden met ties): ORDER BY column_name DESC OFFSET n-1 ROWS FETCH NEXT 1 ROW ONLY.

85. Hoe vind je waarden in een tekstkolom van een tabel die met een bepaalde letter beginnen?

Met de LIKE-operator in combinatie met de wildcards % en _. Stel dat we alle achternamen in een tabel willen vinden die beginnen met "A". De query is:

SELECT * FROM table_name
WHERE surname LIKE 'A_';

Hier gaan we ervan uit dat een achternaam minstens twee letters moet bevatten. Zonder deze aanname (dus dat een achternaam ook alleen A kan zijn) is de query als volgt:

SELECT * FROM table_name
WHERE surname LIKE 'A%';

86. Hoe vind je de laatste id in een tabel?

De eenvoudigste methode is de aggregatiefunctie MAX() te gebruiken.

SELECT MAX(id) AS highest_id
FROM table_name;

Met ORDER BY en LIMIT of TOP

SELECT id
FROM table_name
ORDER BY id DESC
LIMIT 1;

87. Hoe selecteer je willekeurige rijen uit een tabel?

Met de RAND()-functie in combinatie met ORDER BY en LIMIT. In sommige SQL-dialecten, zoals PostgreSQL, heet dit RANDOM(). Bijvoorbeeld, de volgende code retourneert vijf willekeurige rijen uit een tabel in MySQL:

SELECT * FROM table_name
ORDER BY RAND()
LIMIT 5;

Scenariogebaseerde SQL-sollicitatievragen

Scenariogebaseerde vragen testen je vermogen om echte zakelijke problemen met SQL op te lossen. Interviewers gebruiken deze om niet alleen je syntaxiskennis te beoordelen, maar ook je probleemaanpak en je vaardigheid om randgevallen zoals duplicaten, NULL-waarden en ties af te handelen.

88. Hoe vind en verwijder je dubbele records uit een tabel?

Duplicaten vinden:

SELECT email, COUNT(*) AS duplicate_count
FROM users
GROUP BY email
HAVING COUNT(*) > 1;

Duplicaten verwijderen (één record behouden):

WITH duplicates AS (
  SELECT id, 
         ROW_NUMBER() OVER (PARTITION BY email ORDER BY id) AS rn
  FROM users
)
DELETE FROM users 
WHERE id IN (SELECT id FROM duplicates WHERE rn > 1);

Deze aanpak gebruikt een CTE met ROW_NUMBER() om duplicaten te identificeren en behoudt het record met de laagste ID.

89. Hoe bereken je een running total (cumulatieve som)?

Gebruik de SUM()-windowfunctie met een ORDER BY-clausule:

SELECT 
  transaction_date,
  amount,
  SUM(amount) OVER (ORDER BY transaction_date) AS running_total
FROM transactions;

Voor een running total per categorie (bijv. per klant):

SELECT 
  customer_id,
  transaction_date,
  amount,
  SUM(amount) OVER (
    PARTITION BY customer_id 
    ORDER BY transaction_date
  ) AS customer_running_total
FROM transactions;

90. Hoe vind je werknemers die meer verdienen dan het gemiddelde salaris in hun afdeling?

Dit is een klassiek scenario voor een gecorreleerde subquery:

SELECT e.name, e.department, e.salary
FROM employees e
WHERE e.salary > (
  SELECT AVG(salary) 
  FROM employees 
  WHERE department = e.department
);

Alternatief met een windowfunctie:

SELECT name, department, salary
FROM (
  SELECT 
    name, 
    department, 
    salary,
    AVG(salary) OVER (PARTITION BY department) AS dept_avg
  FROM employees
) t
WHERE salary > dept_avg;

91. Hoe vind je gaten in een getallenreeks (bijv. ontbrekende factuurnummers)?

Gebruik LEAD() om elke waarde met de volgende te vergelijken:

SELECT 
  invoice_number,
  LEAD(invoice_number) OVER (ORDER BY invoice_number) AS next_invoice,
  LEAD(invoice_number) OVER (ORDER BY invoice_number) - invoice_number - 1 AS gap_size
FROM invoices
WHERE LEAD(invoice_number) OVER (ORDER BY invoice_number) - invoice_number > 1;

Dit identificeert waar de kloof tussen opeenvolgende factuurnummers groter is dan 1.

92. Hoe vind je klanten die in opeenvolgende maanden aankopen hebben gedaan?

Gebruik LAG() om te vergelijken met de vorige rij:

WITH monthly_purchases AS (
  SELECT 
    customer_id,
    DATE_TRUNC('month', purchase_date) AS purchase_month,
    LAG(DATE_TRUNC('month', purchase_date)) OVER (
      PARTITION BY customer_id 
      ORDER BY DATE_TRUNC('month', purchase_date)
    ) AS prev_month
  FROM purchases
  GROUP BY customer_id, DATE_TRUNC('month', purchase_date)
)
SELECT DISTINCT customer_id
FROM monthly_purchases
WHERE purchase_month = prev_month + INTERVAL '1 month';

93. Hoe pivot je data van rijen naar kolommen?

Gebruik conditionele aggregatie met CASE-statements:

SELECT 
  product_name,
  SUM(CASE WHEN EXTRACT(MONTH FROM sale_date) = 1 THEN amount ELSE 0 END) AS jan_sales,
  SUM(CASE WHEN EXTRACT(MONTH FROM sale_date) = 2 THEN amount ELSE 0 END) AS feb_sales,
  SUM(CASE WHEN EXTRACT(MONTH FROM sale_date) = 3 THEN amount ELSE 0 END) AS mar_sales
FROM sales
GROUP BY product_name;

Sommige databases (SQL Server, Oracle) hebben hiervoor native PIVOT-syntax.

94. Hoe vind je de top 3 producten qua omzet in elke categorie?

Gebruik DENSE_RANK() met PARTITION BY:

WITH ranked_products AS (
  SELECT 
    category,
    product_name,
    SUM(sales_amount) AS total_sales,
    DENSE_RANK() OVER (
      PARTITION BY category 
      ORDER BY SUM(sales_amount) DESC
    ) AS sales_rank
  FROM sales
  GROUP BY category, product_name
)
SELECT category, product_name, total_sales
FROM ranked_products
WHERE sales_rank <= 3
ORDER BY category, sales_rank;

95. Wat zijn ACID-eigenschappen in databasetransacties?

ACID is een acroniem voor de vier kerneigenschappen die betrouwbare database-transacties garanderen:

• Atomicity: Een transactie is "alles of niets" – ofwel alle operaties zijn succesvol, of geen enkele
• Consistency: Een transactie brengt de database van een geldige staat naar een andere, met behoud van alle gedefinieerde regels en constraints
• Isolation: Gelijktijdige transacties beïnvloeden elkaar niet; elke transactie ziet een consistente snapshot van de data
• Durability: Zodra een transactie is gecommit, blijven de wijzigingen bestaan, zelfs als het systeem crasht

Voorbeeldtransactie:

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

COMMIT;

96. Wat is een deadlock en hoe voorkom je die?

Een deadlock treedt op wanneer twee of meer transacties op elkaar wachten om locks vrij te geven, waardoor een cirkelafhankelijkheid ontstaat waarbij geen van beide kan doorgaan.

Voorbeeldscenario: Transactie A vergrendelt Tabel X en wacht op Tabel Y, terwijl Transactie B Tabel Y vergrendelt en wacht op Tabel X.

Preventiestrategieën:

• Consistente lockvolgorde: Verkrijg locks altijd in dezelfde volgorde in alle transacties
• Houd transacties kort: Commit of rollback zo snel mogelijk
• Gebruik passende isolatieniveaus: Lagere isolatieniveaus verminderen lock-contentie
• Benader alleen vereiste data: Vermijd het vergrendelen van onnodige rijen
• Afhandelen van deadlock-retries: De meeste databases detecteren en lossen deadlocks automatisch op door één transactie terug te draaien

97. Hoe optimaliseer je een traag lopende SQL-query?

Belangrijke optimalisatiestrategieën:

• Voeg passende indexen toe: Maak indexen op kolommen die in WHERE-, JOIN- en ORDER BY-clausules worden gebruikt

• Analyseer uitvoeringsplannen: Gebruik EXPLAIN (PostgreSQL/MySQL) of EXPLAIN PLAN (Oracle) om knelpunten te identificeren

• Vermijd SELECT *: Haal alleen de kolommen op die je nodig hebt

• Gebruik JOINs in plaats van subqueries: JOIN’s zijn vaak efficiënter dan gecorreleerde subqueries

• Beperk resultaatsets: Gebruik LIMIT/TOP wanneer je niet alle rijen nodig hebt

• Vermijd functies op geïndexeerde kolommen: WHERE YEAR(date_col) = 2026 kan geen index gebruiken; gebruik in plaats daarvan WHERE date_col >= '2026-01-01'

• Overweeg partitionering: Voor zeer grote tabellen, partitioneer op datum of categorie

98. Hoe ga je om met NULL-waarden in berekeningen en vergelijkingen?

NULL staat voor ontbrekende of onbekende data en vereist speciale behandeling:

• Vergelijkingen: Gebruik IS NULL of IS NOT NULL in plaats van = NULL

• COALESCE(): Retourneert de eerste niet-NULL-waarde: COALESCE(column, 'default')

• NULLIF(): Retourneert NULL als twee waarden gelijk zijn: NULLIF(a, b)

• ISNULL() / NVL(): Databasespecifieke functies om NULL-waarden te vervangen

SELECT 
  name,
  COALESCE(phone, email, 'No contact') AS contact_info,
  CASE WHEN status IS NULL THEN 'Unknown' ELSE status END AS status
FROM customers;

99. Hoe vind je de langste reeks opeenvolgende inlogdagen voor een gebruiker?

Dit is een geavanceerd "eilanden en gaten"-probleem:

WITH login_groups AS (
  SELECT 
    user_id,
    login_date,
    login_date - ROW_NUMBER() OVER (
      PARTITION BY user_id 
      ORDER BY login_date
    ) * INTERVAL '1 day' AS group_id
  FROM user_logins
)
SELECT 
  user_id,
  MIN(login_date) AS streak_start,
  MAX(login_date) AS streak_end,
  COUNT(*) AS streak_length
FROM login_groups
GROUP BY user_id, group_id
ORDER BY streak_length DESC
LIMIT 1;

De truc is om van elke datum een rijnummer af te trekken – opeenvolgende datums leveren dezelfde "group_id" op.

Je team upskillen met SQL

Hoewel voorbereiding op SQL-interviews cruciaal is voor werkzoekenden en hiring managers, is het net zo belangrijk voor bedrijven om te investeren in doorlopende SQL-training voor hun teams. Met data kunnen werken is belangrijker dan ooit, dus ervoor zorgen dat je medewerkers sterke SQL-vaardigheden hebben kan een gamechanger zijn voor het succes van je bedrijf.

Ben je teamleider of ondernemer en wil je dat je hele team vaardig is in SQL, dan biedt DataCamp for Business op maat gemaakte trainingsprogramma’s die je medewerkers kunnen helpen SQL-vaardigheden te beheersen, van de basis tot geavanceerde concepten. We kunnen bieden:

• Gerichte leerroutes: Aanpasbaar aan het huidige vaardigheidsniveau en de zakelijke behoeften van je team.
• Hands-on oefenen: Scenarios uit de praktijk en oefeningen die het leren versterken en de retentie verbeteren.
• Voortgangsmeting: Tools om de voortgang van je team te monitoren en te beoordelen, zodat ze hun leerdoelen behalen.

Investeren in SQL-upskilling via platforms zoals DataCamp vergroot niet alleen de capaciteiten van je team, maar geeft je bedrijf ook een strategisch voordeel, waardoor je concurrerend blijft en resultaten behaalt. Praat met iemand van ons team en vraag vandaag nog een demo aan. 

Conclusie

Kort samengevat hebben we de 99 essentiële SQL-sollicitatievragen voor beginners, intermediate en scenariogebaseerde situaties en de juiste antwoorden daarop besproken. Hopelijk helpt deze informatie je om je voor te bereiden op het interview en je zekerder te voelen, of je nu zoekt naar een baan in SQL of kandidaten interviewt voor een intermediate SQL-functie.

Als je denkt dat je meer training nodig hebt om je beter voor te bereiden op een interview, bekijk dan onze volledige lijst met SQL-cursussen:

• Introduction to SQL
• SQL Foundations
• Data Analyst in SQL
• Exploratory Data Analysis in SQL
• SQL for Business Analysts
• Analyzing Business Data in SQL
• Intermediate SQL
• Intermediate SQL Server
• Applying SQL to Real-World Problems
• SQL Server for Database Administrators