Ga naar hoofdinhoud

Top 34 MySQL-sollicitatievragen en -antwoorden voor 2026

Beheers MySQL met deze gids vol sollicitatievragen, met praktijkvoorbeelden en expert-tips om te excelleren in je volgende database-interview!
Bijgewerkt 2 jun 2026  · 15 min lezen

Is het je ooit opgevallen dat MySQL in bijna elke databasegerelateerde vacature-eis staat? Daar is een goede reden voor — MySQL drijft zo ongeveer alles aan, van je favoriete sociale mediaplatforms 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 senior rollen belangrijk zijn. Ook deel ik een paar tips die je helpen om vol zelfvertrouwen voor de dag te komen bij je volgende data-gerelateerde interviews. 

Wat is MySQL?

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

Het stond in de meest populaire DBMS in 2024-ranglijst. Toch liet een Stack Overflow Developer Survey in 2025 zien dat PostgreSQL voor het eerst MySQL voorbijstreefde als meest gebruikte database onder professionele developers.

Begrijp me niet verkeerd: MySQL is nog steeds enorm populair — met 40,5% gebruik onder developers in 2025 — en drijft nog altijd talloze webapplicaties, contentmanagementsystemen en enterprise-tools aan. En zeker als je met webapplicaties of de LAMP-stack werkt, is MySQL een topvaardigheid om te hebben.

Grafiek met de meest populaire databasesystemen in 2024, waarbij MySQL de populairste is, gevolgd door PostgreSQL.

In 2024 was MySQL wereldwijd het populairste open-source DBMS, met een score van 1061. Bron: Statista.

Basisvragen over MySQL

In de eerste interviewfase kan de interviewer basisvragen stellen om je begrip van fundamentele database- en MySQL-concepten te toetsen. 

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

Een database is een opslagcontainer die data bevat die we kunnen raadplegen, wijzigen en analyseren. Zo slaan sociale mediaplatforms bijvoorbeeld in databases op wie onze posts leuk hebben gevonden.

Een DBMS (Database Management System) is de software waarmee we met die data kunnen werken en deze 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 webgebaseerde applicaties. 

Zo verschilt MySQL van andere RDBMS'en:

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

MySQL is ideaal in scenario's waar snelheid en schaalbaarheid vereist zijn, maar voor complexere of enterprise-grade features kan PostgreSQL een betere keuze zijn.

3. Wat zijn de belangrijkste datatypen in MySQL?

MySQL ondersteunt verschillende datatypen, gecategoriseerd als:

  • Numeriek: INT, DECIMAL, FLOAT, DOUBLE, enz.

  • String: CHAR, VARCHAR, TEXT, BLOB.

  • Datum/tijd: DATE, DATETIME, TIMESTAMP, TIME.

  • JSON: Voor het opslaan van JSON-objecten.

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

INT slaat gehele getallen op zonder decimalen. Gebruik dit als er geen fracties nodig zijn. Daarentegen kan DECIMAL financiële waarden opslaan en is het geschikt voor precieze 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. 

Bijvoorbeeld, in een customers-tabel met klantinformatie heeft elke klant een unieke customer_id — in een andere tabel transactions (met aankooprecords) gebruiken we customer_id als foreign key. De customer_id in de transactions-tabel 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 in beide tabellen een match is.

  • LEFT JOIN: Geeft alle rijen van de linkertabel en de matchende rijen van de rechtertabel. Als er geen match is, wordt NULL teruggegeven voor de kolommen van de rechtertabel.

  • RIGHT JOIN: Vergelijkbaar met LEFT JOIN, geeft alle rijen van de rechtertabel en de matchende rijen van de linkertabel.

  • FULL JOIN: Combineert de resultaten van LEFT JOIN en RIGHT JOIN, inclusief niet-gematchte rijen uit beide tabellen. Let op: MySQL ondersteunt FULL JOIN niet native. Gebruik een UNION van een LEFT JOIN en een RIGHT JOIN om hetzelfde resultaat te bereiken.

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

Opdrachten als DELETE, TRUNCATE en DROP klinken vergelijkbaar, maar gedragen zich anders:

DELETE: Verwijdert rijen uit een tabel op basis van een voorwaarde. Kan worden teruggedraaid als het binnen 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 en data volledig, inclusief afhankelijkheden zoals indexen. Voorbeeld:

DROP TABLE employees;

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

Om tabellen te maken gebruik je CREATE TABLE, en om te 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 tussentijdse resultaten opslaan. Je kunt het gebruiken voor testen, filteren of het voorbereiden van data voordat je deze 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 geneste query) is een query binnen een andere query. Het verdeelt complexe databasebewerkingen in behapbare stappen. Zo kun je bijvoorbeeld een subquery maken om medewerkers 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 uiteenzetten:

  1. De binnenste query SELECT AVG(salary) FROM employees berekent eerst het gemiddelde salaris.

  2. De buitenste query gebruikt dit gemiddelde om medewerkers te vinden die er boven zitten. 

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

We gebruiken het INSERT-statement om data aan een tabel toe te voegen. De basis-syntax is:

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

Hier zijn een paar best practices bij het gebruik van INSERT:

  1. Specificeer je kolommen expliciet. Dit maakt de code duidelijker en voorkomt fouten als de tabelstructuur later verandert.

  2. Sla voor AUTO_INCREMENT-kolommen zoals ID's deze kolom over in het INSERT-statement. MySQL handelt dit automatisch af om dubbele ID's te voorkomen. 

  3. Wees consistent met aanhalingstekens voor strings. Zelf geef ik 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, oplopende 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 kun je een complexe query een naam geven en deze als een tabel gebruiken voor toekomstige queries. Zo hoef je niet telkens de volledige query uit te typen.

Om bijvoorbeeld het opvragen van medewerkergegevens met bijbehorende afdelingsnamen te vereenvoudigen, kun je 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 opvragen alsof het een tabel is:

SELECT * FROM employee_details;

We kunnen via views echter niet de data invoegen en updaten. De meeste zijn alleen-lezen en voorkomen directe toegang tot de database, wat de dataveiligheid vergroot. Views kunnen soms queries vertragen, omdat bij elke toegang de onderliggende query wordt uitgevoerd.

MySQL-sollicitatievragen voor gevorderde beginners

In dit gedeelte behandelen we onderwerpen op gemiddeld niveau. Deze vragen zijn vooral bedoeld om je kennis van MySQL-datatypen 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, kun je ze gebruiken voor auditing en dataherstel. 

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 — MySQL's maximale DATETIME-waarde, gebruikt als sentinel om aan te geven: 'deze rij is momenteel actief'.

  • Update: De EndTime van de oorspronkelijke rij wordt bijgewerkt naar de huidige timestamp om deze als ongeldig te markeren. Vervolgens wordt een nieuwe rij met de bijgewerkte data aangemaakt, met StartTime op de huidige timestamp en EndTime als "voor 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 opvragen zoals die was op een specifiek tijdstip of over een periode. Bijvoorbeeld:

  • FOR SYSTEM_TIME AS OF '2024-01-01': Haalt de status 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 ze?

Transacties zijn een reeks 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:

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 in voor een kolom?

Een default-constraint in MySQL kent een standaardwaarde toe aan een kolom wanneer er bij een INSERT-bewerking geen expliciete waarde wordt opgegeven. Dit zorgt ervoor dat de kolom geldig is, zelfs als de gebruiker die tijdens het invoeren weglaat.

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.

Veld

Type

Null

Sleutel

Standaard

Extra

id

INT

NEE

PRI

NULL

AUTO_INCREMENT

name

VARCHAR(50)

JA

 

NULL

 

status

VARCHAR(10)

JA

 

active

 

Dit commando is nuttig omdat:

  • Het developers helpt de tabelschema's te begrijpen voordat ze queries schrijven.
  • Het kan worden gebruikt voor debugging, vooral bij onbekende databases.
  • Het identificeert snel constraints, zoals primary keys of standaardwaarden.

18. Wat is het verschil tussen CHAR en VARCHAR in MySQL?

Beide slaan tekst op, maar gaan anders met opslag om:

  • CHAR(n) slaat altijd precies n tekens op en vult met spaties aan als de waarde korter is. Het is fixed-length, wat het iets sneller kan maken voor kolommen waar alle waarden even lang zijn, zoals landcodes of statusvlaggen.

  • VARCHAR(n) slaat alleen de ingevoerde tekens op, tot een maximum van n. Het gebruikt minder opslag voor variabele-lengtedata, maar heeft een kleine overhead voor het bijhouden van de lengte.

CREATE TABLE example (
    country_code CHAR(2),      -- Always 2 chars, e.g. 'US', 'UK'
    email VARCHAR(255)         -- Variable length up to 255 chars
);

Vuistregel: gebruik CHAR voor vaste lengtes, VARCHAR voor de rest.

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() geeft het aantal tekens in een naam weer. 

  • 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 de tekst. Zo kun je bijvoorbeeld de maand uit de 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 voorkomens van "a" door "@" in voornamen.

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

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

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

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

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

Geavanceerde MySQL-sollicitatievragen

Geavanceerde vragen testen je vermogen om complexe MySQL-scenario's te beheren en geven de interviewer inzicht in je besluitvorming. 

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

In MySQL is een trigger een set acties die wordt uitgevoerd wanneer zich een database-event voordoet. Triggers kunnen vóór of na events zoals INSERT, UPDATE of DELETE worden uitgevoerd. 

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

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 maakt het toevoegen van een index 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 direct bij de relevante rijen kan komen. Een index verkort dus de zoektijd en versnelt queries. 

Indexen worden doorgaans geïmplementeerd met datastructuren zoals B-trees of hashtabellen, die efficiënte zoekopdrachten, lookups en range-scans mogelijk maken.

Zo maak je een index:

-- Without an index:
SELECT * FROM employees WHERE last_name = 'Smith';
-- Adding an index on the last_name column:
CREATE INDEX idx_last_name ON employees(last_name);
-- With the index, the database can quickly locate rows with 'Smith' in the last_name column.

Indexen hebben ook nadelen, bijvoorbeeld:

  • Tragere write-bewerkingen: INSERT, UPDATE en DELETE-bewerkingen zijn trager omdat de index telkens moet worden bijgewerkt.

  • Opslagkosten: Indexen vergen extra opslagruimte.

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

Voor gewicht is DECIMAL over het algemeen de veiligere keuze. Hoewel FLOAT en REAL decimale waarden kunnen opslaan, gebruiken ze floating-point rekenkunde, wat kleine afrondingsfouten kan introduceren.

Voor productgewichten waar nauwkeurigheid telt (bijv. verzendkosten, voorraad), geeft DECIMAL(8, 3) je precieze controle met 3 decimalen en zonder afrondingsverrassingen. FLOAT is alleen acceptabel als een kleine foutmarge oké is.

24. Hoe vind je dubbele rijen in SQL met een windowfunctie? 

Zo kun je duplicaten vinden met de windowfunctie 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 per product_name en category

3. Binnen elke groep worden rijen genummerd vanaf 1. 

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

Bijvoorbeeld, als we 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, waardoor databasebewerkingen efficiënter en beter onderhoudbaar worden. Laten we zien hoe je ze met parameters maakt en gebruikt aan de hand van een praktisch voorbeeld.

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 aanneemt:

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. Maak bijvoorbeeld een procedure die het aantal studenten met 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 van deze procedure op:

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. Een foreign key zorgt ervoor dat de waarden in een tabel overeenkomen met de unieke waarde in de verwijzende tabel.

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

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

Wanneer je dus een foreign key-constraint als volgt aanmaakt:

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

Dan handhaaft de database automatisch deze regels:

  • Elke CustomerID in de tabel Orders moet bestaan in de tabel Customers.

  • Pogingen om deze regels te schenden (zoals het invoegen van een ongeldige CustomerID) worden afgewezen.

Dit voorkomt datainconsistenties die serieuze problemen kunnen veroorzaken, zoals orders die niet aan echte klanten te koppelen zijn of rapporten met ontbrekende klantinformatie. 

MySQL-sollicitatievragen voor databasebeheerders

Solliciteer je specifiek naar een rol als databaseadministrator, dan zijn dit voorbeelden van vragen die je kunt krijgen.

27. Waarom zou een grote applicatie database-sharding gebruiken? Noem ook de uitdagingen. 

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

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

28. Leg de rol van redo logs uit bij MySQL crash recovery. 

Elke keer dat data in MySQL wordt gewijzigd, moet dit 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, je werkt het adres van een klant bij:

  1. MySQL schrijft deze wijziging eerst naar de redo log.
  2. Daarna bevestigt het je transactie als vastgelegd (committed).
  3. Uiteindelijk wordt de wijziging toegepast op de daadwerkelijke datafiles.

Crash recovery is belangrijk als MySQL crasht na stap 1 of 2 maar vóór stap 3. Bij het herstarten kijkt MySQL in de redo logs en voltooit het onafgemaakt werk door de in de redo logs vastgelegde wijzigingen opnieuw toe te passen. Zo gaan gecommitte transacties niet verloren, zelfs niet als MySQL op een ongelukkig moment crasht.

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

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

Storage-engine Belangrijkste features Beste voor
InnoDB Standaardengine. ACID-compliant, row-level locking, transacties en foreign keys. E-commerce, financiële systemen, alles waar dataintegriteit vereist is.
MyISAM Snelle reads, table-level locking. Geen transacties of foreign keys. Read-intensieve apps waar snelheid zwaarder weegt dan integriteit.
Memory Data in RAM. Extreem snel maar verdwijnt bij herstart. Caching, sessiebeheer, tijdelijke data.
CSV Slaat data op als platte CSV-bestanden. Geen indexering. Data-uitwisseling tussen apps of eenvoudige flat-fileopslag.
Archive Hoge compressie. Alleen INSERT en SELECT. Geen indexen. Logdata of historische records die zelden worden opgevraagd.
NDB (Clustered) Gedistribueerde opslag, hoge beschikbaarheid, fouttolerant, ondersteunt transacties. Grootschalige gedistribueerde apps met realtime performance.

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

Controleer eerst de huidige standaard storage-engine:

SHOW ENGINES;

InnoDB wordt aangeraden als standaardengine, omdat het belangrijke features ondersteunt, zoals:

  • ACID-transacties
  • Foreign key-constraints
  • Crashherstel
  • Row-level locking

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 door deze regel onder de sectie [mysqld] toe te voegen:

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 of er corruptie is. Voer vervolgens de volgende opdracht uit om de tabel te repareren: 

mysqlcheck --repair database_name table_name -u root -p

Reparaties kunnen in geval van zware corruptie tot dataverlies leiden, dus maak altijd eerst een back-up.

MySQL-sollicitatievragen op basis van scenario's en probleemoplossing

Deze vragen peilen je ervaring met complexe praktijkscenario's en je probleemoplossend vermogen.

32. Leg een scenario uit waarin je subqueries in MySQL hebt gebruikt.

Zo kun je op een vraag als deze reageren:

Ik beheerde in mijn vorige baan een e-commercedatabase en moest een productrapport voorbereiden. Het doel was om producten te vinden die bovengemiddelde omzet genereerden, wat subqueries vereiste om deze meerstapsanalyse 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 de baseline 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 sales-tabel haalde. Deze subquery fungeerde als dynamische drempel waartegen de prestaties van elk product werden afgezet.

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

Door de query zo op te zetten, kon ik high-performers in één databasebewerking 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 de bovenstaande vraag:

Onlangs werkte ik aan een project met twee hoofdtabellen — één met productverkoopdata en een andere 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 de verkooptransacties aan productdetails te koppelen:

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 het goed deden en welke aandacht nodig hadden.

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

Hier is een voorbeeldreactie op de bovenstaande vraag:

Ja, ik heb ruime ervaring met databasetriggers. In mijn recente rol heb ik een AFTER UPDATE-trigger geïmplementeerd voor het auditen van prijswijzigingen. 

Zo heb ik het aangepakt: ik maakte een trigger die automatisch de prijsgeschiedenis vastlegt zodra een productprijs verandert. Dit is het SQL-script dat ik heb ontwikkeld:

CREATE TRIGGER tr_AuditPriceChanges
AFTER UPDATE ON Products
FOR EACH ROW
BEGIN
    -- Only log if the price actually changed
    IF OLD.UnitPrice <> NEW.UnitPrice THEN
        INSERT INTO PriceAudit (
            ProductID,
            OldPrice,
            NewPrice,
            ChangedBy,
            ChangeDate,
            PercentageChange
        )
        VALUES (
            NEW.ProductID,
            OLD.UnitPrice,
            NEW.UnitPrice,
            CURRENT_USER(),
            NOW(),
            ROUND(((NEW.UnitPrice - OLD.UnitPrice) / OLD.UnitPrice * 100), 2)
        );
    END IF;
END;

Wat deze oplossing bijzonder effectief maakte:

  1. Hij vuurt alleen wanneer de prijs daadwerkelijk verandert.
  2. Hij legt de gebruiker vast die de wijziging doorvoert met SYSTEM_USER.
  3. Hij berekent de procentuele verandering voor rapportagedoeleinden.
  4. Er is een WHERE-clausule opgenomen om niet-wijzigingen te filteren die kunnen optreden door updates aan andere kolommen.

Ik heb ook foutafhandeling en logging toegevoegd toen we edgecases met NULL-prijzen zagen.

Tips voor het voorbereiden op een MySQL-sollicitatie

Begin je net aan je carrière, dan helpen deze tips je om je volgende interview te rocken:

Beheers de kernconcepten van MySQL: Leer de databasefundamentals zoals indexering, transacties en de query optimizer. Begrijp hoe MySQL queries verwerkt en datastorage beheert. Dit helpt je efficiënte queries te schrijven en je oplossingen tijdens het interview uit te leggen.

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 vertrouwen op te bouwen voor het interview.

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 basisbewaking. Je kunt ook verkennen hoe MySQL met Python werkt en relevante frameworks, zodat je kunt laten zien dat je in een echte ontwikkelomgeving uit de voeten kunt.

Conclusie

Dat was 'm! Ik heb de top 34 MySQL-sollicitatievragen behandeld om je te helpen je volgende baan te bemachtigen. Of je nu solliciteert naar een instapfunctie of een geavanceerde databasebeheerrol, je moet de MySQL-vaardigheden, query-optimalisatie en databasemanagement goed beheersen om op te vallen. 

Wil je je kennis van andere databasebeheersystemen 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
323.5K
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