Top 99 SQL-sollicitatievragen en -antwoorden voor 2026

SQL-sollicitatievragen in vogelvlucht

• Beginnervragen behandelen SQL-basics: statements, queries, joins, subqueries en veelgebruikte commando’s (DDL, DML, DCL, TCL)
• Vragen voor gevorderde beginners testen functies, indexering, normalisatie, views en de verschillen tussen DELETE/TRUNCATE/DROP
• Scenariogebaseerde vragen beoordelen probleemoplossing in de praktijk: duplicaten vinden, running totals berekenen, omgaan met NULL-waarden en windowfuncties gebruiken
• Belangrijke onderwerpen om te beheersen: CTE’s (Common Table Expressions), windowfuncties (ROW_NUMBER, RANK, DENSE_RANK), ACID-eigenschappen en query-optimalisatie
• Praktijktip: Richt je op het uitleggen van je denkproces, niet alleen op het schrijven van de juiste syntax

Door dit artikel heen verkennen we een reeks SQL-sollicitatievragen en -antwoorden voor beginners en halfgevorderden. Zoek je een overzicht, bekijk dan hieronder onze toptips:

Voor beginners

1. Algemene vragen. Verwacht vragen over je ervaring, de SQL-dialecten waarmee je bekend bent en je vaardigheidsniveau.
2. Technische vragen. Deze gaan over de basis van SQL, zoals wat het is, de toepassingen, SQL-statements, SQL-commando’s en soorten SQL-queries, enzovoort.

Voor halfgevorderde practitioners

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

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

3. Databasemodelering. 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 over hoe je specifieke taken uitvoert, zoals het vinden van de n-de hoogste waarde in een kolom.

Algemene SQL-sollicitatievragen

Voordat je technische vragen krijgt, kan de interviewer je eerst wat algemene vragen stellen over je algehele ervaring met SQL.\

Maak je geen zorgen als je ervaring met SQL beperkt is: dat weet je interviewer waarschijnlijk al uit je cv. Omdat ze toch geïnteresseerd zijn om met je te praten, werd je profiel gezien als een goede match voor hun bedrijf. Het is ook helemaal prima als je alleen met één SQL-dialect hebt gewerkt. Onthoud dat alle SQL-dialecten vrij vergelijkbaar zijn. Vertrouwd zijn met één dialect is dus een solide basis om de rest te leren.

1. Wat is SQL?

Dit staat voor Structured Query Language, en het is een programmeertaal die wordt gebruikt om te communiceren met relationele databasebeheersystemen (RDBMS). Dit omvat het ophalen, bijwerken, invoegen en verwijderen van gegevens 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 SQL-dialecten hebben een zeer vergelijkbare syntax en verschillen slechts minimaal 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
• gegevens in een tabel benaderen, manipuleren en wijzigen
• de benodigde informatie uit één of meerdere tabellen ophalen 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 wel een SQL-commando genoemd. Het is een tekenreeks die door de SQL-engine wordt geïnterpreteerd als een geldig commando en dienovereenkomstig wordt uitgevoerd. Voorbeelden van SQL-statements zijn SELECT, CREATE, DELETE, DROP, REVOKE, enzovoort.

5. Wat is een SQL-query?

Een query is een stuk code, geschreven in SQL, om gegevens uit een database te benaderen of te wijzigen.

Er zijn twee soorten SQL-queries: queries voor gegevensopvraag en gegevenswijziging. De eerste gebruik je om de benodigde gegevens op te halen (waaronder ook het beperken, groeperen en sorteren van gegevens, het ophalen uit meerdere tabellen, enz.), terwijl de tweede worden gebruikt om gegevens te maken, toe te voegen, te verwijderen, bij te werken en te hernoemen.

6. Wat is een SQL-subquery?

Ook wel een inner query genoemd: een query die in een andere query (de 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 meerdere tabellen te combineren en op te halen. SQL-tabellen kunnen worden gejoint op basis van de relatie tussen kolommen van die tabellen. Bekijk onze SQL joins-tutorial voor meer context, plus onze speciale gids met SQL-join-sollicitatievragen. 

8. Wat is een SQL-opmerking (comment)?

Een voor mensen leesbare toelichting op wat een bepaald stuk code doet. SQL-codeopmerkingen kunnen eenregelig zijn (voorafgegaan door een dubbele streep --) of meerdere regels beslaan (als volgt: /*comment_text*/). Wanneer de SQL-engine draait, worden codeopmerkingen genegeerd. Het doel van SQL-comments is om de code begrijpelijker te maken voor toekomstige lezers.

9. Wat is een SQL-alias?

Een tijdelijke naam die aan een tabel (of een 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 naar de technische SQL-sollicitatievragen en mogelijke antwoorden daarop.

Bij technische vragen is de beste strategie om zo precies mogelijk te antwoorden. Te brede antwoorden kunnen overkomen als uitweiden en bovendien extra vragen oproepen waar je je minder zeker over voelt.

SQL maakt het mogelijk om op meerdere manieren een database te bevragen. Daarnaast 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 toegang te krijgen tot gegevens in een database, ze te manipuleren en te wijzigen.
• Data Control Language (DCL) – om gebruikersrechten tot de gegevens in de database te beheren en privileges te geven of in te trekken voor specifieke gebruikers of groepen.
• Transaction Control Language (TCL) – om transacties in een database te beheren.
• Data Query Language (DQL) – om queries op de gegevens in een database uit te voeren en 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 waarmee je verschillende bewerkingen kunt uitvoeren op de gegevens die in een database zijn opgeslagen, zoals benaderen, bijwerken, opschonen, invoegen en verwijderen. Er zijn verschillende typen DBMS, zoals relationeel, hiërarchisch, netwerk-, graf- of objectgeoriënteerd. Deze typen zijn gebaseerd op hoe gegevens in het systeem worden 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 gegevens die zijn opgeslagen in meerdere tabellen die met elkaar samenhangen via gedeelde keys. 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 gegevens die in tabelvorm is opgeslagen, d.w.z. in rijen en kolommen. Een veld is een andere term voor een kolom van een tabel.

15. Welke typen SQL-subqueries ken je?

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

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

Een set voorwaarden die het type gegevens definieert 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 – voorziet in gedeelde keys tussen twee of meer tabellen.

18. Welke typen joins ken je?

• (INNER) JOIN – retourneert alleen de 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 het 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 uniek elk record van de tabel. Elke tabel kan hoogstens één PRIMARY KEY definiëren (die samengesteld mag zijn). Een PRIMARY KEY  wordt sterk aanbevolen maar niet door elke engine 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 (maximaal éé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 daarvan op te slaan en sneller zoeken en ophalen van gegevens mogelijk te maken. Indexen zijn vooral efficiënt voor grote databases, waar ze de query-prestaties aanzienlijk verbeteren.

23. Welke typen indexen ken je?

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

24. Wat is een schema?

Een verzameling structurele database-elementen zoals tabellen, stored procedures, indexen, functies en triggers. Het toont de algehele database-architectuur, specificeert de relaties tussen diverse objecten in een database en definieert verschillende toegangsrechten voor die objecten. Lees onze database-schemagids voor meer inzicht.

25. Wat is een SQL-operator?

Een gereserveerd teken, een combinatie van tekens 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 (of voorwaarden) te definiëren voor het filteren van gegevens.

26. Welke typen SQL-operatoren ken je?

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

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

• Samenstelling (+=, -=, *=, /=, 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 wordt opgelegd aan een SQL-query om de gegevens te filteren en zo het gewenste resultaat te krijgen. Enkele voorbeelden zijn WHERE, LIMIT, HAVING, LIKE, AND, OR, ORDER BY, enz.

28. Wat zijn enkele veelgebruikte statements bij 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 het CREATE TABLE-statement. Bijvoorbeeld, om een tabel te maken met drie kolommen met vooraf gedefinieerde datatypen, 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 een aflopende volgorde aangeven met het sleutelwoord DESC; anders is de volgorde standaard oplopend. Ook kunnen we sorteren op meer dan één kolom en voor elke kolom afzonderlijk oplopend of aflopend instellen. 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 typen.

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 terug te geven. 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, oftewel hoe twee of meer tabellen in een database zich tot elkaar verhouden. Zo kan een ID van dezelfde klant voorkomen in een tabel met verkoopgegevens en in een klantentabel.

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

Een NULL-waarde geeft de afwezigheid van gegevens voor een bepaalde cel van een tabel aan. Nul is daarentegen een geldige numerieke waarde, en een lege string is een geldige tekenreeks met 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 en schemaloos zijn en ontworpen om ongestructureerde of semi-gestructureerde gegevens te verwerken.

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

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

SQL-sollicitatievragen voor halfgevorderden

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

Een Common Table Expression (CTE) is een tijdelijke benoemde resultaatset waar je binnen een SELECT-, INSERT-, UPDATE- of DELETE-statement naar kunt verwijzen. CTE’s verbeteren de leesbaarheid van queries en laten je complexe queries opdelen 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 vooral handig voor recursieve queries (hiërarchische data zoals organigrammen) 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 rij zoals aggregatiefuncties doen. Ze gebruiken de OVER()-clausule om het venster van rijen te definiëren.

Belangrijke windowfuncties zijn onder meer:

• ROW_NUMBER() – kent een uniek volgnummer 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() – benadert data uit vorige/volgende rijen
• SUM() OVER(), AVG() OVER() – running- of cumulatieve berekeningen

Voorbeeld: Running total van omzet 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 volgnummering 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() wanneer je de "n-de hoogste" waarde zoekt waarbij gelijke waarden dezelfde positie moeten delen.

In deze sectie bekijken we de populairste 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 codefragmenten.

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).
• Scalar-functies – werken op elke individuele waarde en retourneren één waarde.

Anderzijds kunnen SQL-functies ingebouwd zijn (door het systeem gedefinieerd) of door de gebruiker gedefinieerd (gemaakt door de gebruiker 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-scalarfuncties 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 omgezet naar hoofdletters

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

• INITCAP() – retourneert een string omgezet naar titelstijl (d.w.z. elk woord 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 zijn een subset van tekensfuncties en worden gebruikt om de lettergrootte (case) van tekstgegevens te wijzigen. Met deze functies kunnen we gegevens omzetten naar hoofdletters, kleine letters of titelstijl.

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

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

• INITCAP() – retourneert een string omgezet naar titelstijl (d.w.z. elk woord begint met een hoofdletter)

49. Wat zijn character-manipulatiefuncties in SQL?

Character-manipulatiefuncties zijn een subset van tekensfuncties en worden gebruikt om tekstgegevens 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 aan de linker-/rechterkant voor rechts-/links-uitgelijnde waarden

• TRIM() – verwijdert alle gedefinieerde tekens, evenals spaties, 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 inwisselbaar. SQL staat het sleutelwoord OUTER optioneel toe, dus LEFT JOIN is simpelweg een verkorte vorm van 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 prestaties?

Indexering creëert een speciale datastructuur die het ophalen van gegevens versnelt doordat de database rijen efficiënter kan vinden. Het werkt als een geoptimaliseerde opzoektabel, waardoor volledige tabelscans minder vaak nodig zijn. Overmatige indexering kan echter insert-, update- en delete-bewerkingen vertragen vanwege het onderhoud van indexen.

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

Een stored procedure is een vooraf gecompileerde set SQL-statements die als eenheid wordt uitgevoerd om een taak te volbrengen. Procedures kunnen data of schema-objecten wijzigen, transacties beheren en nul of meer resultsets retourneren. Functies daarentegen worden meestal gebruikt in SQL-expressies, moeten een waarde retourneren (scalaire of tabelwaarde) en zijn in veel databases beperkt in bijwerkingen. Exact gedrag verschilt per DB (bijv. T-SQL heeft scalaire en tabelwaarde-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-set-operatoren?

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

• UNION ALL – retourneert de records die door ten minste één van twee queries zijn verkregen (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 patroonherkenning?

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 typen keys unieke waarden in een kolom van een tabel afdwingen, identificeert de eerste elk record van de tabel uniek, terwijl de tweede duplicaten in die kolom voorkomt.

59. Wat is een samengestelde (composite) primary key?

De primary key van een tabel die op meerdere kolommen is gebaseerd.

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 gangbare statements in de SELECT-query uit?

Hier is de SQL-uitvoeringsvolgorde: 

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 gegevens die uit een of meer databasetabellen (of andere views) zijn opgehaald. Standaardviews slaan geen gegevens op; gematerialiseerde views wel. Views kunnen queries vereenvoudigen, logica inkapselen en, gecombineerd met privileges, kolommen/rijen beperken. Ze kunnen gegevens uit meerdere tabellen joinen/aggregmeren.

63. Kunnen we een view baseren op een andere view in SQL?

Ja. Dit wordt ook wel geneste views genoemd. We moeten echter vermijden om meerdere views te nesten, omdat de code dan lastig te lezen en te debuggen wordt.

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

Nee. Elke view die op die tabel is gebaseerd, wordt ongeldig na het verwijderen van de basistabel. Als we zo’n view toch proberen te gebruiken, krijgen we een foutmelding.

65. Welke typen SQL-relaties ken je?

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

66. Wat zijn de mogelijke waarden van een BOOLEAN-veld?

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 op te slaan als gehele getallen 1 (waar) of 0 (onwaar).

67. Wat is normalisatie in SQL?

Normalisatie is een proces van databaseontwerp waarbij gegevens zo worden georganiseerd en herstructureerd dat redundantie, afhankelijkheid, duplicatie en inconsistentie worden verminderd. Dit leidt tot verbeterde dataintegriteit, meer tabellen binnen de database, efficiëntere gegevenstoegang en -beveiliging en grotere queryflexibiliteit.

68. Wat is denormalisatie in SQL?

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

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

Een kolom hernoemen betekent dat je de daadwerkelijke naam permanent wijzigt in de originele tabel. Een alias geven betekent dat je die kolom tijdelijk een naam geeft 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 die genest is in een grotere (outer) query en die verwijst naar waarden uit de outer query voor de uitvoering, wat betekent dat een gecorreleerde subquery afhankelijk is van de outer query. Een niet-gecorreleerde subquery is daarentegen niet afhankelijk van gegevens uit de outer query en kan los daarvan worden uitgevoerd.

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

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

72. Wat is de CASE()-functie?

De manier om if-then-else-logica in SQL te implementeren. Deze functie controleert opeenvolgend de opgegeven voorwaarden in de WHEN-clausules en retourneert de waarde uit de bijbehorende THEN-clausule zodra de eerste voorwaarde is vervuld. Als geen van de voorwaarden is vervuld, retourneert de functie de waarde uit de ELSE-clausule indien aanwezig, anders retourneert ze 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 alleen omkeerbaar als het is verpakt 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 die door een foreign key worden gerefereerd.

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. Prestaties 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 gegevens nadat ze zijn gegroepeerd, terwijl de tweede elke rij afzonderlijk controleert. Als beide statements in een query staan, verschijnen 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;

Op deze manier 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 unieke key voor die tabel te maken.

83. Hoe voeg je veel rijen tegelijk in in een tabel?

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?

Met 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 (gelijkheid negerend): ORDER BY column_name DESC OFFSET n-1 ROWS FETCH NEXT 1 ROW ONLY.

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

Met de LIKE-operator in combinatie met de wildcards % en _. Stel, we willen alle achternamen vinden in een tabel 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 bevat. Zonder die aanname (waarbij een achternaam ook 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 die 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 probleemoplossende aanpak en je vermogen om met randgevallen zoals duplicaten, NULL-waarden en gelijke waarden om te gaan.

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 reeks nummers (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 deden?

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 draai (pivot) je gegevens van rijen naar kolommen?

Gebruik voorwaardelijke 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 native PIVOT-syntax voor deze bewerking.

94. Hoe vind je de top 3 producten per categorie op basis van verkoop?

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 bewerkingen slagen, of geen enkele
• Consistency: Een transactie brengt de database van een geldige staat naar een andere, waarbij alle gedefinieerde regels en constraints worden gehandhaafd
• Isolation: Gelijktijdige transacties verstoren elkaar niet; elke transactie ziet een consistente momentopname van de gegevens
• 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 lock-volgorde: Verkrijg locks altijd in dezelfde volgorde in alle transacties
• Houd transacties kort: Commit of rollback zo snel mogelijk
• Gebruik passende isolatieniveaus: Lagere niveaus verminderen lock-contentie
• Benader alleen benodigde data: Vermijd het vergrendelen van onnodige rijen
• Ga om met 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 geschikte 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: JOINs 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 gegevens 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 aaneengesloten reeks 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 volgnummer af te trekken – opeenvolgende datums leveren dezelfde "group_id" op.

Je team upskillen met SQL

Hoewel SQL-interviewvoorbereiding cruciaal is voor werkzoekenden en hiring managers, is het voor bedrijven net zo belangrijk om continu in SQL-training voor hun teams te investeren. 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 leerpaden: Aanpasbaar aan het huidige vaardigheidsniveau en de bedrijfsbehoeften van je team.
• Hands-on oefenen: Praktijksituaties en oefeningen die het leren versterken en de retentie verbeteren.
• Voortgangsbewaking: 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 capabilities van je team, maar geeft je bedrijf ook een strategisch voordeel, zodat je competitief blijft en resultaat levert. Praat met iemand van ons team en vraag vandaag nog een demo aan. 

Conclusie

Kortom, we hebben de 99 essentiële SQL-sollicitatievragen voor beginners, halfgevorderden en scenariogebaseerde situaties en de juiste antwoorden daarop besproken. Hopelijk helpt deze informatie je om je klaar te stomen voor het interview en je zelfverzekerder te voelen, of je nu een baan in SQL zoekt of kandidaten voor een intermediate SQL-rol aanneemt.

Heb je meer training nodig om je beter voor te bereiden op een interview, overweeg dan de volgende SQL-cursussen en tracks van DataCamp:

• 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
• PostgreSQL Summary Stats and Window Functions