Ga naar hoofdinhoud

Top 34 MySQL-sollicitatievragen en -antwoorden voor 2026

Beheers MySQL met deze gids vol sollicitatievragen, met praktijkvoorbeelden en tips van experts om te excelleren in je volgende database-interview!
Bijgewerkt 16 apr 2026  · 15 min lezen

Is het je ooit opgevallen dat MySQL in bijna elke database-gerelateerde vacature-eis staat? Daar is een goede reden voor — MySQL drijft zowat alles aan, van je favoriete socialmediaplatforms tot de apps die je dagelijks gebruikt.

Ik heb deze gids samengesteld om je te helpen met MySQL-sollicitatievragen. Ik behandel alles: van de basis die junior developers moeten kennen tot de complexere onderwerpen die voor seniorrollen relevant zijn. Ook deel ik wat tips om zelfverzekerd over te komen in je volgende data-gerelateerde interviews. 

Wat is MySQL?

MySQL is een open-source RDBMS (relational database management system) dat is gebouwd op SQL en data ordent in gestructureerde tabellen. Het is ontwikkeld door Oracle Corporation.

Het stond in 2024 bovenaan als populairste DBMS omdat steeds meer bedrijven hun data naar MySQL migreren. Daarom is het, als je een databasebaan wilt, zo belangrijk dat je MySQL en relationele databases begrijpt. 

Grafiek met de populairste databasesystemen in 2024, met MySQL als populairste, gevolgd door PostgreSQL.

Sinds juni 2024 is MySQL ’s werelds populairste open-source databasebeheersysteem (DBMS), met een rankingscore van 1061. Bron: Statista.

Basis MySQL-sollicitatievragen

In de beginfase van het gesprek kan de interviewer basisvragen stellen om je begrip van database- en MySQL-concepten te toetsen. 

1. Wat is een database en hoe verschilt die van een DBMS? 

Een database is een opslagcontainer met data die we kunnen openen, wijzigen en analyseren. Zo slaan socialmediaplatforms bijvoorbeeld in databases op wie onze posts heeft geliked.

Een DBMS (Database Management System) is de software waarmee we met die data kunnen werken en die kunnen beheren, bijvoorbeeld door gebruikers aan te maken en hun toegang te beheren. MySQL is een van de populairste DBMS-opties. Andere voorbeelden zijn PostgreSQL, MongoDB en Microsoft SQL Server.

2. Hoe verschilt MySQL van andere relationele databasebeheersystemen?

MySQL is een open-source relationeel databasebeheersysteem (RDBMS) dat SQL gebruikt om data te beheren. Het staat bekend om zijn gebruiksgemak, snelheid en compatibiliteit met webapplicaties. 

Zo verschilt MySQL van andere RDBMS’en:

  • Eenvoud en performance: MySQL wordt vaak geroemd om zijn eenvoud en geoptimaliseerde prestaties, waardoor het een favoriet is onder webdevelopers en startups.
  • Geavanceerde features: Hoewel MySQL uitblinkt in gebruiksgemak, kan het geavanceerde features missen die andere RDBMS’en zoals PostgreSQL bieden, zoals uitgebreidere ondersteuning voor ACID-transacties, geavanceerde indexering en een breder scala aan datatypes.
  • Storage-engines: In MySQL kun je per tabel verschillende storage-engines kiezen (bijv. InnoDB, MyISAM), wat flexibiliteit geeft voor specifieke use-cases.

MySQL is ideaal in scenario’s waar snelheid en schaalbaarheid belangrijk zijn, maar voor complexere of enterprise-features is PostgreSQL soms een betere keuze.

3. Wat zijn de belangrijkste datatypes in MySQL?

MySQL ondersteunt verschillende datatypes, onderverdeeld in:

  • Numeriek: INT, DECIMAL, FLOAT, DOUBLE, enz.
  • Tekenreeks: CHAR, VARCHAR, TEXT, BLOB.
  • Datum/tijd: DATE, DATETIME, TIMESTAMP, TIME.
  • JSON: Voor het opslaan van JSON-objecten.

4. Wat is het verschil tussen de datatypes INT en DECIMAL? 

INT slaat gehele getallen op zonder decimalen. Je gebruikt het als je geen fracties nodig hebt. DECIMAL daarentegen kan financiële waarden opslaan en is geschikt voor nauwkeurige berekeningen met decimalen. 

5. Hoe verschilt DATE van DATETIME in MySQL? 

De DATE-functie in MySQL slaat de datum op in jaar-, maand- en dagformaat: 

YYYY-MM-DD

De DATETIME-functie slaat de datum met tijd op en ziet er zo uit: 

YYYY-MM-DD HH:MM:SS 

6. Wat is een foreign key en hoe gebruik je die in databases? 

Een foreign key is een veld in de ene tabel dat verwijst naar de primary key van een andere tabel. 

In een customers-tabel met klantinformatie heeft elke klant bijvoorbeeld een unieke customer_id. In een andere tabel, transactions (met aankooprecords), gebruiken we customer_id als foreign key. De customer_id in de transactietabel koppelt elke aankoop aan een specifieke klant in de customers -tabel.

Zo ziet dat eruit in SQL:

CREATE TABLE customers (
    customer_id INT PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100)
);
CREATE TABLE transactions (
    transaction_id INT PRIMARY KEY,
    customer_id INT,
    amount DECIMAL(10,2),
    date DATE,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);

7. Wat zijn de verschillen tussen INNER JOIN, LEFT JOIN, RIGHT JOIN en FULL JOIN?

Joins combineren rijen uit twee of meer tabellen op basis van gerelateerde kolommen. Dit zijn de verschillen:

  • INNER JOIN: Geeft rijen terug waar een match is in beide tabellen.
  • LEFT JOIN: Geeft alle rijen uit de linkertabel en de matchende rijen uit de rechtertabel. Als er geen match is, wordt NULL teruggegeven voor de kolommen van de rechtertabel.
  • RIGHT JOIN: Vergelijkbaar met LEFT JOIN, maar geeft alle rijen uit de rechtertabel en de matchende rijen uit de linkertabel.
  • FULL JOIN: Combineert de resultaten van LEFT JOIN en RIGHT JOIN, inclusief niet-gematchte rijen uit beide tabellen.

8. Wat is het verschil tussen DELETE, TRUNCATE en DROP in MySQL?

Commando’s als DELETE, TRUNCATE en DROP klinken vergelijkbaar, maar ze gedragen zich verschillend:

  • DELETE: Verwijdert rijen uit een tabel op basis van een voorwaarde. Kan worden teruggedraaid als het in een transactie gebeurt. Voorbeeld:
DELETE FROM employees WHERE department_id = 5;
  • TRUNCATE: Verwijdert alle rijen uit een tabel, maar laat de tabelstructuur intact. Is sneller dan DELETE en kan niet worden teruggedraaid. Voorbeeld:
TRUNCATE TABLE employees;
  • DROP: Verwijdert de tabelstructuur én data volledig, inclusief afhankelijkheden zoals indexen. Voorbeeld:
DROP TABLE employees;

9. Hoe maak en wijzig je een tabel in MySQL? Geef voorbeelden.

Voor het aanmaken van tabellen gebruik je CREATE TABLE en voor wijzigen meestal ALTER TABLE. Enkele voorbeelden:

  • Tabel maken:
CREATE TABLE employees (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(50), department VARCHAR(50));
  • Wijzigen om een kolom toe te voegen:
ALTER TABLE employees ADD COLUMN salary DECIMAL(10, 2);

10. Wat is een tijdelijke tabel in SQL? 

Een tijdelijke tabel bestaat alleen tijdens de huidige databasesessie. Zodra we de sessie sluiten, wordt de tabel verwijderd. Dit type tabel kan tijdelijk tussenresultaten opslaan. Je kunt het gebruiken voor testen, filteren of het voorbereiden van data voordat je die in een permanente tabel zet.

Hier is een voorbeeld:

CREATE TEMPORARY TABLE temp_employees (
    id INT,
    name VARCHAR(50)
);
INSERT INTO temp_employees VALUES (1, 'John Doe');
SELECT * FROM temp_employees;

11. Wat is een subquery in MySQL? Leg uit met een voorbeeld. 

Een subquery (ook wel nested query) is genest binnen een andere query. Het breekt complexe databasehandelingen op in behapbare stappen. Je kunt bijvoorbeeld een subquery maken om werknemers te vinden die boven het gemiddelde verdienen: 

SELECT first_name, last_name, salary
FROM employees
WHERE salary > (
    SELECT AVG(salary)
    FROM employees
);

Laten we dit opsplitsen:

  1. De inner query SELECT AVG(salary) FROM employees berekent eerst het gemiddelde salaris.
  2. De outer query gebruikt dit gemiddelde om werknemers te vinden die daarboven zitten. 

12. Hoe gebruik je een INSERT-statement in MySQL om data aan een tabel toe te voegen? Heb je ook best practices? 

We kunnen INSERT() gebruiken om data aan een tabel toe te voegen. De basis-syntaxis is:

INSERT INTO table_name (column1, column2, ...) 
VALUES (value1, value2, ...); 

Hier zijn enkele best practices die je kunt volgen wanneer je INSERT() gebruikt:

  1. Noem je kolommen expliciet. Dit maakt de code duidelijker en voorkomt fouten als de tabelstructuur later verandert.
  2. Sla bij AUTO_INCREMENT-kolommen zoals ID’s deze over in het INSERT()-statement. MySQL regelt dit automatisch om dubbele ID’s te voorkomen. 
  3. Wees consistent met aanhalingstekens voor strings. Ik geef zelf de voorkeur aan enkele aanhalingstekens, maar beide werken.
  4. Als je meerdere rijen invoegt, kan dat in één statement voor betere performance.

13. Wat is het belang van het attribuut AUTO_INCREMENT in MySQL?

Het attribuut AUTO_INCREMENT in MySQL genereert unieke, opeenvolgende nummers voor een kolom, meestal de primary key van een tabel.

Zo maak je een tabel met een AUTO_INCREMENT-kolom:

CREATE TABLE employees (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50),
    department VARCHAR(50)
);

En zo voeg je er rijen aan toe:

INSERT INTO employees (name, department) VALUES ('John Doe', 'Sales');
INSERT INTO employees (name, department) VALUES ('Jane Smith', 'Marketing');

14. Wat is een view in MySQL? 

Een view is een opgeslagen query die werkt als een virtuele tabel. Hiermee kunnen we een complexe query een naam geven en die als tabel gebruiken voor toekomstige queries. Zo hoef je niet telkens de hele query opnieuw te typen.

Om het opvragen van werknemersgegevens met hun afdelingsnamen te vereenvoudigen, kun je bijvoorbeeld een view maken:

CREATE VIEW employee_details AS
SELECT 
    e.id,
    e.name,
    d.department_name,
    e.salary
FROM 
    employees e
JOIN 
    departments d ON e.department_id = d.department_id;

Je kunt de view employee_details nu net als een tabel bevragen:

SELECT * FROM employee_details;

We kunnen via views echter niet de data invoegen of updaten. De meeste zijn read-only en voorkomen directe toegang tot de database, wat de dataveiligheid verbetert. Views kunnen soms queries vertragen, omdat de onderliggende query telkens wordt uitgevoerd wanneer je de view benadert.

Gemiddelde MySQL-sollicitatievragen

In deze sectie behandelen we onderwerpen op gemiddeld niveau. Deze vragen worden vooral gesteld om je kennis van MySQL-datatypes en -structuur te testen.

15. Wat zijn system-versioned tables en hoe werken ze? 

System-versioned tables bewaren een volledige geschiedenis van wijzigingen in een tabel. Omdat ze eerdere versies van elke rij bijhouden, kunnen we ze gebruiken voor auditing en herstel van data. 

Ze werken door twee extra kolommen toe te voegen — StartTime en EndTime — om vast te leggen wanneer elke rij geldig is. Wanneer we data invoegen, updaten of verwijderen, worden deze tijdstempels bijgewerkt:

  • Insert: Er wordt een nieuwe rij toegevoegd met StartTime op de huidige timestamp en EndTime op 9999-12-31 23:59:59 (of vergelijkbaar, voor "altijd"). Dit geeft aan dat de rij momenteel geldig is.
  • Update: De EndTime van de oorspronkelijke rij wordt op de huidige timestamp gezet om aan te geven dat deze niet langer geldig is. Vervolgens wordt een nieuwe rij met de bijgewerkte data aangemaakt, met StartTime op de huidige timestamp en EndTime op "altijd".
  • Delete: De EndTime van de bestaande rij wordt bijgewerkt naar de huidige timestamp, wat aangeeft dat de rij niet langer geldig is.

Met de SQL-clausule FOR SYSTEM_TIME kun je de tabel bevragen om de staat op een specifiek tijdstip of over een periode te zien. Bijvoorbeeld:

  • FOR SYSTEM_TIME AS OF '2024-01-01': Haalt de staat van de tabel op zoals die was op 1 januari 2024.
  • FOR SYSTEM_TIME BETWEEN '2024-01-01' AND '2024-12-31': Toont alle rijen die binnen dit datumbereik geldig waren.

16. Wat zijn MySQL-transacties en hoe gebruik je die?

Transacties zijn een set bewerkingen die als één geheel worden uitgevoerd. Ze waarborgen dataintegriteit door toe te staan dat alle bewerkingen samen slagen of falen.

Zo gebruik je ze bijvoorbeeld:

START TRANSACTION;
UPDATE accounts SET balance = balance - 500 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 500 WHERE account_id = 2;
COMMIT; -- Slaat wijzigingen definitief op
-- of
ROLLBACK; -- Draait wijzigingen terug

17. Wat is een default constraint in MySQL? Hoe stel je een standaardwaarde voor een kolom in?

Een default constraint in MySQL kent een standaardwaarde toe aan een kolom als er tijdens een INSERT-actie geen expliciete waarde is opgegeven. Zo blijft de kolom geldig, ook als de gebruiker die overslaat bij het invoeren van data.

Zo maak je een tabel met een standaardwaarde:

CREATE TABLE employees (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50),
    status VARCHAR(10) DEFAULT 'active'
);

Vervolgens kun je een rij invoegen zonder status te specificeren:

INSERT INTO employees (name) VALUES ('John Doe');

Deze aanpak verkleint de kans op NULL of ongeldige data in kritieke kolommen en vereenvoudigt queries doordat je standaardgevallen niet expliciet hoeft af te handelen.

Resultaat:

Veld

Type

Null

Sleutel

Standaard

Extra

id

INT

NEE

PRI

NULL

AUTO_INCREMENT

name

VARCHAR(50)

JA

 

NULL

 

status

VARCHAR(10)

JA

 

active

 

Dit is nuttig omdat:

  • Ontwikkelaars de tableschema’s begrijpen voordat ze queries schrijven.
  • Het kan worden gebruikt voor debugging, vooral bij onbekende databases.
  • Je snel constraints zoals primary keys of defaults identificeert.

19. Hoe gebruik je stringfuncties in SQL om tekst te beheren? 

Verschillende stringfuncties in SQL werken met namen en andere tekstdata. Bijvoorbeeld:

  • De functie LENGTH() toont het aantal tekens in een naam. 
  • UPPER() en LOWER() zetten tekst om naar respectievelijk hoofd- of kleine letters. 
  • CONCAT() voegt voor- en achternaam samen in één kolom. 
  • SUBSTRING() haalt specifieke delen uit tekst. Zo kun je bijvoorbeeld de maand uit een geboortedatum halen. 

Hier is een voorbeeldquery:

SELECT 
    UPPER(first_name) AS upper_name,
    CONCAT(first_name, ' ', last_name) AS full_name,
    SUBSTRING(birthdate, 6, 2) AS birth_month,
    TRIM(last_name) AS trimmed_last_name,
    REPLACE(first_name, 'a', '@') AS replaced_name
FROM employees;

Deze query:

  • Zet namen om naar hoofdletters.
  • Combineert voor- en achternamen tot een volledige naam.
  • Haalt de geboortemaand uit een kolom birthdate.
  • Trimt spaties van achternamen.
  • Vervangt alle "a"’s door "@" in voornamen.

20. Hoe update je een specifieke rij in een database met SQL?

Gebruik het UPDATE-statement en de WHERE-clausule om het record te identificeren dat je wilt wijzigen. 

Als je bijvoorbeeld het genre van de film “Inception” uit 2010 wilt wijzigen naar “Sci-fi”, kun je deze query gebruiken: 

UPDATE movies
SET genre = 'Sci-Fi'
WHERE movie_title = 'Inception' AND year = 2010;

Hier geeft UPDATE movies de tabel aan die we willen bijwerken, en de WHERE-clausule richt zich op de rij waar de titel “Inception” is en het jaar “2010”. 

Geavanceerde MySQL-sollicitatievragen

Geavanceerde vragen toetsen je vermogen om complexe MySQL-scenario’s te beheren en geven de interviewer een idee van je beslisvaardigheden. 

21. Wat is een trigger in MySQL? Hoe implementeer je die? 

In MySQL is een trigger een set acties die wordt uitgevoerd wanneer een database-event plaatsvindt. Triggers kun je configureren om vóór of na events zoals INSERT, UPDATE of DELETE te draaien. 

Stel dat er een tabel orders is waarin nieuwe bestellingen worden toegevoegd. We kunnen een trigger maken die elke nieuwe order logt in een tabel order_history:

CREATE TRIGGER after_order_insert
AFTER INSERT ON orders
FOR EACH ROW
BEGIN
    INSERT INTO order_history (order_id, action, timestamp)
    VALUES (NEW.order_id, 'inserted', NOW());
END;

Na het uitvoeren van de trigger wordt de tabel order_history automatisch bijgewerkt:

history_id

order_id

action

timestamp

1

1

inserted

2024-12-24 10:00:00

2

2

inserted

2024-12-24 11:00:00

22. Waarom maken indexen SQL-queries sneller? 

Zonder index moet de database elke rij scannen om een specifieke entry te vinden. Een index werkt als een inhoudsopgave, waardoor de database snel de relevante rijen kan benaderen. Indexen verkorten dus de zoektijd en maken queries sneller. 

Indexen worden doorgaans geïmplementeerd met datastructuren zoals B-trees of hash-tabellen, waarmee zoekacties, lookups en range-scans efficiënt kunnen worden uitgevoerd.

Zo maak je een index:

-- Zonder index:
SELECT * FROM employees WHERE last_name = 'Smith';
-- Een index toevoegen op de kolom last_name:
CREATE INDEX idx_last_name ON employees(last_name);
-- Met de index kan de database snel rijen vinden met 'Smith' in de kolom last_name.

Indexen hebben ook nadelen, bijvoorbeeld:

  • Tragere schrijfbewerkingen: INSERT, UPDATE en DELETE-bewerkingen zijn trager omdat de index bij elke wijziging moet worden bijgewerkt.
  • Opslagkosten: Indexen vereisen extra opslagruimte.

23. Welk datatype gebruiken we voor het gewicht en de prijs van een product in een SQL-tabel, en waarom? 

We gebruiken FLOAT of REAL om gewicht op te slaan, omdat gewicht vaak decimalen bevat en een kleine foutmarge accepteert. Omdat deze datatypes benaderende waarden opslaan, zijn ze geschikter voor gewichtskolommen. 

Het datatype DECIMAL wordt vaak gebruikt voor prijzen, omdat financiële waarden zoals prijzen geen afrondingsfouten verdragen. Die nauwkeurigheid krijg je met een decimaal datatype (bijv. DECIMAL(10, 2) voor 10 cijfers, waarvan 2 na de komma).

24. Hoe vind je dubbele rijen in SQL met een window-functie? 

Zo kun je duplicaten vinden met de window-functie ROW_NUMBER():

WITH DuplicateCheck AS (
    SELECT product_name, 
           category,
           ROW_NUMBER() OVER(
               PARTITION BY product_name, category 
               ORDER BY id
           ) AS row_num
    FROM sales
)
SELECT *
FROM DuplicateCheck
WHERE row_num > 1;

Zo werkt dit:

1. ROW_NUMBER() kent een nummer toe aan elke rij in ons resultaat. 

2. PARTITION BY groepeert rijen op product_name en category

3. Binnen elke groep worden rijen genummerd vanaf 1. 

4. Elke row_num groter dan 1 wijst op een duplicaat. 

Als we bijvoorbeeld deze records hebben:

  • Product A, Categorie X, row_num = 1
  • Product A, Categorie X, row_num = 2 (duplicaat)
  • Product B, Categorie Y, row_num = 1

De query toont de tweede rij, omdat de row_num groter is dan 1.

25. Hoe maak en gebruik je een stored procedure met parameters in MySQL? Leg uit met een voorbeeld. 

Met stored procedures kun je complexe queries opslaan en hergebruiken, zodat databasehandelingen efficiënter en onderhoudbaar worden. Laten we met een praktisch voorbeeld zien hoe je ze maakt en gebruikt met parameters.

Stel, we hebben een studentendatabase en willen een procedure maken om studenten op leeftijd te filteren. Zo doen we dat:

Eerst maken we een eenvoudige stored procedure die een leeftijdsparameter accepteert:

CREATE PROCEDURE get_student_info(IN age INT)
BEGIN
    SELECT * FROM student WHERE student.age = age;
END;

Om deze procedure te gebruiken, CALL je haar met de gewenste leeftijd:

CALL get_student_info(21);

We kunnen procedures geavanceerder maken met outputparameters. Zo maken we bijvoorbeeld een procedure die het aantal studenten van een specifieke leeftijd telt:

CREATE PROCEDURE count_students_by_age(IN age INT, OUT student_count INT)
BEGIN
    SELECT COUNT(*) INTO student_count FROM students WHERE students.age = age;
END;

Zo haal je het resultaat op uit deze procedure:

SET @count = 0;
CALL count_students_by_age(21, @count);
SELECT @count AS total_students;

26. Waarom is referentiële integriteit belangrijk in een database? 

Referentiële integriteit houdt relaties tussen tabellen correct. Wanneer we een foreign key maken, zorgt die ervoor dat de waarden in een tabel overeenkomen met de unieke waarde in de verwezen tabel.

Een praktisch voorbeeld: Stel je beheert een e-commercedatabase. Je hebt een tabel Customers en een tabel Orders. Elke order moet bij een echte klant horen. Referentiële integriteit, geïmplementeerd via foreign keys, handhaaft deze relatie door te waarborgen dat:

  • Je geen order kunt aanmaken voor een niet-bestaande klant.
  • Je geen klant kunt verwijderen met bestaande orders (tenzij je specifiek configureert wat er met die orders moet gebeuren).
  • Je de klant-ID niet kunt wijzigen als die klant bestaande orders heeft.

Dus wanneer je een foreign key-constraint maakt zoals deze:

ALTER TABLE Orders
ADD FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID);

Dan handhaaft de database deze regels automatisch:

  • Elke CustomerID in de tabel Orders moet bestaan in de tabel Customers.
  • Pogingen om deze regels te schenden (zoals een ongeldige CustomerID invoegen) worden afgewezen.

Dit voorkomt datainconsistenties die serieuze problemen kunnen veroorzaken, zoals orders die niet te herleiden zijn naar echte klanten of rapportages met ontbrekende klantinformatie. 

MySQL-sollicitatievragen voor databasebeheerders

Als je specifiek solliciteert naar een rol als databasebeheerder, zijn dit enkele vragen die recruiters kunnen stellen.

27. Waarom zou een grote applicatie database-sharding gebruiken? En wat zijn de uitdagingen? 

Een grote applicatie gebruikt sharding om zeer veel data over meerdere servers te verdelen. Elk deel, of shard, bevat een kleiner deel van de data. Doordat de datalast wordt verspreid, is geen high-end hardware nodig. Hoewel snelheid en schaalbaarheid verbeteren, zijn er ook uitdagingen: 

  • Sommige queries zoals joins werken mogelijk niet, wat databeheer kan bemoeilijken. 
  • Als data groeit, kunnen shards overbelast raken, waardoor hotspots ontstaan die de performance vertragen. 

28. Leg de rol van redo logs uit bij MySQL-crashherstel. 

Elke keer dat data in MySQL wordt gewijzigd, moet die naar schijf worden geschreven. Direct naar datafiles schrijven is echter traag en riskant. Daarom schrijft MySQL, voordat het datafiles wijzigt, eerst op wat het gaat doen in de redo log. Dit is veiliger dan willekeurig datafiles bijwerken.

Stel dat je het adres van een klant bijwerkt:

  1. MySQL schrijft deze wijziging eerst naar de redo log.
  2. Het bevestigt vervolgens je transactie als committed.
  3. Uiteindelijk wordt de wijziging toegepast op de daadwerkelijke datafiles.

Crashherstel is belangrijk als MySQL crasht na stap 1 of 2 maar vóór stap 3. Wanneer MySQL opnieuw start, kijkt het in de redo logs en voltooit onafgemaakt werk door de vastgelegde wijzigingen af te spelen. Zo gaan gecommitte transacties niet verloren, zelfs niet als MySQL op een ongelukkig moment crasht.

29. Welke storage-engines zijn beschikbaar in MySQL en hoe verschillen ze?

MySQL ondersteunt meerdere storage engines, elk geoptimaliseerd voor verschillende use-cases. Hier is een vergelijking van de meest voorkomende:

Storage-engine

Kenmerken

Use-cases

InnoDB

- Standaard storage-engine.

- ACID-compatibel.

- Vergrendeling op rijniveau.

- Ondersteunt transacties en foreign keys.

Applicaties die hoge dataintegriteit vereisen, zoals e-commerceplatforms of financiële systemen.

MyISAM

- Snel bij leesintensieve workloads.

- Vergrendeling op tabelniveau.

- Geen ondersteuning voor transacties of foreign keys.

Leesintensieve applicaties waar snelheid belangrijker is dan dataintegriteit.

Memory

- Slaat data op in RAM.

- Zeer snel.

- Data gaat verloren bij herstart.

- Beperkte grootte.

Tijdelijke dataopslag, caching of sessiebeheer.

CSV

- Slaat data op in platte CSV-bestanden.

- Eenvoudige integratie met externe tools.

- Geen indexondersteuning.

Data-uitwisseling tussen applicaties of eenvoudige dataopslag zonder complexe querybehoeften.

Archive

- Geoptimaliseerd voor hoge compressie.

- Ondersteunt alleen INSERT en SELECT.

- Geen indexen.

Opslag van historische data of logs waarbij data zelden wordt opgehaald.

NDB (Clustered)

- Gedistribueerde opslag voor MySQL Cluster.

- Hoge beschikbaarheid en fouttolerantie.

- Ondersteunt transacties.

Grootschalige gedistribueerde applicaties die realtime prestaties vereisen.

30. Hoe stel je een standaard storage-engine in MySQL in? 

Controleer eerst de huidige standaard storage-engine:

SHOW ENGINES;

InnoDB wordt aanbevolen als standaardengine omdat het belangrijke features ondersteunt zoals:

  • ACID-compatibele transacties
  • Foreign key-constraints
  • Crashherstel
  • Vergrendeling op rijniveau

Om de standaardengine tijdelijk voor je huidige sessie te wijzigen, kun je gebruiken:

SET default_storage_engine = 'InnoDB';

Voor een permanente wijziging kun je het MySQL-configuratiebestand aanpassen en deze regel toevoegen onder de sectie [mysqld]:

default-storage-engine = InnoDB

31. Hoe repareer je corrupte tabellen in MySQL? 

Controleer eerst alle databases met dit commando: 

mysqlcheck --check --all-databases -u root -p

Dit scant alle tabellen en meldt eventuele corruptie. Voer daarna het volgende commando uit om de tabel te repareren: 

mysqlcheck --repair database_name table_name -u root -p

Reparaties kunnen bij ernstige corruptie tot dataverlies leiden, dus maak altijd eerst een back-up.

Scenario- en probleemoplossende MySQL-sollicitatievragen

Deze vragen peilen je ervaring met complexe praktijksituaties en je probleemoplossend vermogen.

32. Leg een scenario uit waarin je subqueries in MySQL gebruikte.

Zo kun je op zo’n vraag reageren:

Ik beheerde bij mijn vorige baan de database van een e-commercestore en moest een productrapport voorbereiden. Het doel was om producten te vinden die bovengemiddelde omzet genereerden. Daarvoor waren subqueries nodig om de analyse in meerdere stappen uit te voeren.

Dit is de SQL-query die ik hiervoor heb ontwikkeld:

SELECT 
    p.product_id,
    p.product_name,
    s.sales_amount
FROM products p
JOIN sales s ON p.product_id = s.product_id
WHERE s.sales_amount > (
    SELECT AVG(sales_amount)
    FROM sales
)
ORDER BY s.sales_amount DESC;

Eerst bepaalde ik het referentiepunt door de gemiddelde omzet over alle producten te berekenen. Dat deed ik met een subquery in de WHERE-clausule die AVG(sales_amount) uit de salestabel haalde. Deze subquery fungeerde als een dynamische drempel waartegen de performance van elk product kon worden afgezet.

De hoofdquery voegde vervolgens de tabellen products en sales samen om de relevante productdetails op te halen, terwijl de WHERE-clausule alle producten met omzet onder het gemiddelde eruit filterde. 

Door de query zo op te bouwen, kon ik toppresteerders in één databaseoperatie identificeren in plaats van meerdere losse queries te draaien.

33. Kun je een situatie uitleggen waarin je SQL-joins gebruikte om data uit meerdere tabellen te combineren? 

Hier is een voorbeeldantwoord op bovenstaande vraag:

Laatst werkte ik aan een project met twee hoofdtabellen — één met verkoopdata van producten en één met productdetails. Mijn taak was een rapport te maken met sales, productnaam, categorie en prijs.

Om de relevante data te combineren, gebruikte ik een INNER JOIN op de gemeenschappelijke kolom product_id om verkooptransacties te koppelen aan productdetails:

SELECT 
    s.sales_date,
    p.product_name,
    p.category,
    s.quantity_sold,
    p.price
FROM 
    sales s
INNER JOIN 
    products p
ON 
    s.product_id = p.product_id;

Het rapport gaf een duidelijk beeld van verkooptrends, waardoor stakeholders konden zien welke productcategorieën goed presteerden en welke aandacht nodig hadden.

34. Heb je ervaring met triggers? Leg uit hoe je die hebt gebruikt.

Hier is een voorbeeldreactie op bovenstaande vraag:

Ja, ik heb ruime ervaring met database-triggers. In mijn recente rol implementeerde ik een AFTER UPDATE-trigger voor het auditen van prijswijzigingen. 

Ik neem je mee door de implementatie: ik maakte een trigger die automatisch de prijshistorie vastlegt wanneer een productprijs verandert. Dit is het SQL-script dat ik heb ontwikkeld:

CREATE TRIGGER tr_AuditPriceChanges
ON Products
AFTER UPDATE AS
BEGIN
    -- Voer alleen uit als de prijs daadwerkelijk is gewijzigd
    IF UPDATE(UnitPrice)
    BEGIN
        INSERT INTO PriceAudit (
            ProductID,
            OldPrice,
            NewPrice,
            ChangedBy,
            ChangeDate,
            PercentageChange
        )
        SELECT 
            i.ProductID,
            d.UnitPrice AS OldPrice,
            i.UnitPrice AS NewPrice,
            SYSTEM_USER,
            GETDATE(),
            ROUND(((i.UnitPrice - d.UnitPrice) / d.UnitPrice * 100), 2)
        FROM INSERTED i
        JOIN DELETED d ON i.ProductID = d.ProductID
        WHERE i.UnitPrice <> d.UnitPrice;
    END
END;

Dit werkte bijzonder goed omdat:

  1. Hij alleen afgaat wanneer de prijs daadwerkelijk verandert.
  2. Hij de gebruiker vastlegt die de wijziging doorvoert met SYSTEM_USER.
  3. Hij het procentuele verschil berekent voor rapportagedoeleinden.
  4. Er een WHERE-clausule is opgenomen om non-changes uit te sluiten die kunnen optreden bij updates van andere kolommen.

Ook heb ik errorhandling en logging toegevoegd toen we edge-cases met NULL-prijzen zagen.

Tips voor de voorbereiding op een MySQL-sollicitatie

Begin je net aan je carrière, dan helpen deze tips je om te scoren in je komende interview:

Beheers de kernconcepten van MySQL: Leer de basis van databases zoals indexering, transacties en de query-optimizer. Begrijp hoe MySQL queries verwerkt en dataopslag beheert. Dit helpt je efficiënte queries te schrijven en je oplossingen tijdens het gesprek toe te lichten.

Doe praktijkervaring op: Installeer MySQL op je computer en oefen regelmatig. Maak testdatabases, schrijf verschillende soorten queries en probeer ze te optimaliseren. Echte oefening is de beste manier om te leren hoe alles werkt en zelfvertrouwen op te bouwen voor het gesprek.

Om je kennis verder op te frissen, bekijk de resources van DataCamp: 

Leer over MySQL-tools en -integraties: Maak je vertrouwd met MySQL Workbench of andere tools voor databasemanagement en basismonitoring. Je kunt ook verkennen hoe MySQL met Python werkt en relevante frameworks, zodat je laat zien dat je in een echte ontwikkelomgeving uit de voeten kunt.

Conclusie

Dat was ’m! Ik heb de 34 belangrijkste MySQL-sollicitatievragen behandeld om je te helpen je volgende baan te veroveren. Of je nu solliciteert op een juniorfunctie of een rol als data administrator, je hebt een stevige basis in MySQL, query-optimalisatie en databasemanagement nodig om op te vallen. 

Wil je je kennis van andere databasebeheersystemen verder uitbreiden, bekijk dan DataCamp’s SQL-cursussen.


Laiba Siddiqui's photo
Author
Laiba Siddiqui
LinkedIn
Twitter

Ik ben een contentstrateeg die graag complexe onderwerpen eenvoudig maakt. Ik heb bedrijven als Splunk, Hackernoon en Tiiny Host geholpen om boeiende en informatieve content te maken voor hun doelgroep.

Onderwerpen

Leer meer over SQL met deze cursussen!

Cursus

Gegevens manipuleren in SQL

4 Hr
317K
Bekijk detailsRight Arrow
Begin met de cursus
Meer zienRight Arrow
Gerelateerd

blog

AI vanaf nul leren in 2026: een complete gids van de experts

Ontdek alles wat je moet weten om in 2026 AI te leren, van tips om te beginnen tot handige resources en inzichten van industrie-experts.
Adel Nehme's photo

Adel Nehme

15 min

Meer zienMeer zien