kodi/markdown_to_skillstown
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Eerste upload

Browse Source
This commit is contained in:
Nico Martijn Hendriks
2026-05-09 08:33:11 +02:00
parent c755e10a77
commit 8435e62e9a
838 changed files with 174200 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Hoofdstuk 04 - Basisqueries.md
+600
View File
@@ -0,0 +1,600 @@
# Hoofdstuk 4 - Basisqueries
---
## Terugblik
In hoofdstuk 3 heb je kennisgemaakt met SQL als declaratieve taal: je schrijft wat je wilt, niet hoe de database dat uitrekent. Je hebt de drie groepen van SQL leren kennen - DML, DDL en DCL - en de fitworks-database geïnstalleerd. Die database staat nu klaar.
> **Neem even 30 seconden.** In hoofdstuk 3 stond al een korte SELECT-query als voorbeeld. Kon je op dat moment al raden wat hij deed? En nu, na het lezen van de beschrijving van DDL en DML, zou je dan anders antwoorden? Bewaar dat gevoel - aan het einde van dit hoofdstuk kijk je terug op je eigen redenering.
---
## Opening
Je bent systeembeheerder bij FitWorks. De vestigingsmanager loopt op je af: "Kun jij me snel een lijst geven van alle leden die geen telefoonnummer hebben ingevuld? We willen ze via e-mail aanschrijven." Een simpele vraag. Maar hoe stel je die aan een database?
Je kunt niet op een knop klikken. Er bestaat geen menu-optie "geef me leden zonder telefoon". Je hebt een instructie nodig die de database begrijpt - precies, ondubbelzinnig, in de juiste volgorde. Dat is een query. En er zit een addertje onder het gras in die vraag over telefoonnummers. Dat addertje heet NULL. Je ontdekt hem in sectie 4.3.
---
## Leerdoelen
Na dit hoofdstuk kun je:
- een query schrijven met `SELECT`, `FROM` en `WHERE` en uitleggen wat elk onderdeel doet;
- resultaten filteren met vergelijkingsoperatoren, `BETWEEN`, `IN` en logische operators `AND`, `OR` en `NOT`;
- uitleggen wat NULL is, waarom je er niet op kunt filteren met `=`, en hoe je dat correct doet met `IS NULL`;
- resultaten sorteren met `ORDER BY` en dubbele waarden verwijderen met `DISTINCT`;
- kolomaliassen toewijzen met `AS` en vaste tekst (literals) in een query opnemen;
- voor- en achternamen samenvoegen met `CONCAT` en datatypes omzetten met `CAST`.
---
## 4.1 SELECT en FROM - je eerste query
### De balie vraagt, de database antwoordt
Het is dinsdagochtend bij FitWorks en een trainer vraagt aan de receptie: "Wie staat er allemaal ingeschreven?" De receptioniste opent phpMyAdmin, typt een instructie en krijgt binnen een seconde een lijst op het scherm. Die instructie is klein maar compleet:
```sql
SELECT voornaam, achternaam
FROM leden;
```
Dit is een volledige SQL-query. Ze bestaat uit twee onderdelen. `SELECT` zegt welke kolommen je wilt zien, gescheiden door komma's. `FROM` zegt uit welke tabel die kolommen komen. Zonder `FROM` weet de database niet waar hij moet zoeken. Zonder `SELECT` weet hij niet wat hij moet tonen. Ze zijn onlosmakelijk verbonden.
![Anatomie van een SELECT-query met SELECT, FROM en WHERE](afbeeldingen/hoofdstuk-04/hoofdstuk_04_scherm_01_select_from_anatomie.svg)
De volgorde is vastgelegd: `SELECT` altijd eerst, dan `FROM`, dan pas eventuele aanvullingen zoals `WHERE`. SQL klaagt direct als je die volgorde omdraait. Het is geen aanbeveling - het is een syntaxregel.
### Alle kolommen tegelijk: de asterisk
Soms wil je snel alle kolommen zien die een tabel bevat, zonder ze één voor één op te noemen. Dat doe je met de asterisk (`*`):
```sql
SELECT *
FROM leden;
```
De `*` is een verkorting voor "geef me alles". Handig bij het verkennen van een tabel. In de praktijk gebruik je `*` spaarzaam: het haalt onnodig veel data op, maakt je query minder leesbaar en kan vertragen als een tabel tientallen kolommen heeft. Maar als leergereedschap bij het doorzoeken van fitworks is het prima.
> **Kolomnamen in fitworks zijn altijd lowercase.** Schrijf dus `voornaam`, niet `Voornaam` of `VOORNAAM`. MySQL maakt op de meeste systemen geen onderscheid tussen hoofd- en kleine letters in kolomnamen, maar consequent lowercase schrijven voorkomt verwarring.
### Mini-oefening
Je wilt de e-mailadressen en geboortedatums van alle leden zien. Welke query schrijf je?
```sql
-- Schrijf hier jouw query
```
**Antwoord:**
```sql
SELECT email, geboortedatum
FROM leden;
```
---
## 4.2 WHERE - filteren op voorwaarden
### Niet 400 rijen, maar precies de rijen die je nodig hebt
De tabel `leden` bevat zo'n 400 rijen. Als je de manager een overzicht stuurt van actieve leden, heb je die 400 rijen niet nodig. Je wilt alleen de rijen waarbij `actief` gelijk is aan `1`. Daarvoor gebruik je `WHERE`.
`WHERE` is een filter. De database loopt alle rijen van de opgegeven tabel langs en geeft alleen de rijen terug die voldoen aan de voorwaarde die jij opgeeft. Rijen die er niet aan voldoen, worden stilletjes weggelaten.
```sql
SELECT voornaam, achternaam, email
FROM leden
WHERE actief = 1;
```
`WHERE` staat altijd na `FROM`. De volgorde `SELECT - FROM - WHERE` is onwrikbaar. Typ je `WHERE` voor `FROM`, dan krijg je een foutmelding.
### Vergelijkingsoperatoren
In een `WHERE`-clausule vergelijk je een kolom met een waarde. Voor die vergelijking gebruik je een operator. Het diagram hieronder geeft een overzicht van de meestgebruikte operators met voorbeelden uit de fitworks-database.
![Overzicht van WHERE-operatoren met voorbeelden uit fitworks](afbeeldingen/hoofdstuk-04/hoofdstuk_04_scherm_02_where_operatoren.svg)
Twee operators verdienen extra toelichting.
**BETWEEN** filtert op een bereik, inclusief de grenswaarden zelf. Dit is handig als je iets zoekt binnen een prijsklasse of een tijdvak:
```sql
SELECT naam, prijs_per_maand
FROM abonnementen
WHERE prijs_per_maand BETWEEN 20 AND 40;
```
Dit geeft abonnementen terug waarvan de prijs 20, 40 of iets daartussenin bedraagt. Let op: beide grenzen tellen mee.
**IN** laat je meerdere toegestane waarden opgeven als een lijst, zonder een reeks `OR`-voorwaarden te schrijven. Het resultaat is hetzelfde, maar de query is compacter en beter leesbaar:
```sql
SELECT betaling_id, bedrag, status
FROM betalingen
WHERE status IN ('betaald', 'openstaand');
```
Dit is identiek aan `WHERE status = 'betaald' OR status = 'openstaand'`. Bij twee waarden maakt het weinig uit, maar bij vijf of zes wordt `IN` een stuk overzichtelijker.
### Logische operators: AND, OR en NOT
Voorwaarden kun je combineren. `AND` eist dat beide voorwaarden gelden:
```sql
SELECT voornaam, achternaam
FROM leden
WHERE actief = 1
AND locatie_id = 2;
```
Alleen rijen waarbij actief gelijk is aan 1 én locatie_id gelijk aan 2, komen door het filter. Als één van beide niet klopt, valt de rij af.
`OR` is ruimer: minstens één voorwaarde moet kloppen:
```sql
SELECT betaling_id, bedrag, status
FROM betalingen
WHERE status = 'mislukt'
OR status = 'openstaand';
```
Elke betaling die mislukt is, of openstaand is, of allebei - al die rijen verschijnen in het resultaat.
`NOT` keert een voorwaarde om. Gebruik het spaarzaam, want `!=` of `<>` is in de meeste gevallen leesbaarder:
```sql
SELECT voornaam, achternaam
FROM leden
WHERE NOT actief = 0;
```
Dit is logisch gelijk aan `WHERE actief = 1` - maar minder direct leesbaar.
### Tekst en getallen: aanhalingstekens
Er is een belangrijk verschil in notatie. Getallen schrijf je zonder aanhalingstekens: `actief = 1`. Tekst schrijf je altijd tussen enkele aanhalingstekens: `status = 'betaald'`. Gebruik je dubbele aanhalingstekens voor tekst, dan klaagt MySQL. In de fitworks-database zijn kolomnamen nooit geciteerd - ze staan altijd zonder aanhalingstekens in de query.
### Reflectievraag
De vestigingsmanager wil weten welke trainers bij FitWorks locatie 1 werken en ook een specialisatie hebben opgegeven. Welke query schrijf je? Denk goed na over de voorwaarde voor "heeft een specialisatie".
*(Schrijf je antwoord op voordat je verder gaat.)*
---
### Modelantwoord - reflectievraag 4.2
> **Mogelijk antwoord**
>
> De tabel `trainers` bevat een kolom `specialisatie`. Die kolom kan leeg zijn - dat betekent in een database niet een lege string, maar NULL. Om alleen de trainers te tonen die een specialisatie hebben ingevuld, gebruik je `IS NOT NULL`. Dat concept leer je in de volgende sectie uitgebreid kennen.
>
> ```sql
> SELECT voornaam, achternaam, specialisatie
> FROM trainers
> WHERE locatie_id = 1
> AND specialisatie IS NOT NULL;
> ```
>
> `AND` zorgt ervoor dat beide voorwaarden tegelijk waar moeten zijn. Een trainer zonder specialisatie of van een andere locatie valt af.
---
## 4.3 NULL - de onzichtbare valkuil
### Een waarde die geen waarde is
Terug naar de vraag van de vestigingsmanager: leden zonder telefoonnummer. Wat staat er in de database als iemand geen nummer heeft opgegeven? Geen nul. Geen lege string. Er staat iets anders: **NULL**.
NULL is de afwezigheid van een waarde. Het is geen getal, geen tekst, geen spatie. Het is simpelweg: er is geen informatie. De database zegt letterlijk "ik weet het niet." Dat is een fundamenteel ander concept dan "de waarde is nul" of "de waarde is leeg".
In fitworks kom je NULL op meerdere plekken tegen. De kolom `tussenvoegsel` in de tabel `leden` is NULL voor iedereen zonder tussenvoegsel - niet "", maar NULL. De kolom `telefoon` is NULL als een lid geen nummer heeft opgegeven. De kolom `specialisatie` bij `trainers` is NULL als dat veld bij indiensttreding niet is ingevuld.
### Waarom werkt `= NULL` niet?
Dit is de meest gemaakte fout bij beginners, en de meest gevaarlijke - want je krijgt geen foutmelding. Je schrijft:
```sql
-- Dit werkt NIET zoals je denkt
SELECT voornaam, achternaam
FROM leden
WHERE telefoon = NULL;
```
De query wordt uitgevoerd. MySQL klaagt niet. Maar je krijgt nul resultaten, ook als er tientallen leden zonder telefoonnummer zijn. Hoe kan dat?
In SQL is NULL geen gewone waarde die je kunt vergelijken. De uitdrukking `NULL = NULL` is niet waar. Ze is ook niet onwaar. Ze is onbekend. En een vergelijking met een onbekende uitkomst beschouwt SQL als niet-waar. Elke rij valt dan af, ook als het telefoonnummer werkelijk leeg is.
De database redeneert zo: "Is het telefoonnummer van dit lid gelijk aan NULL? Ik weet het niet - want NULL is onbekend." En als het onbekend is, wordt de rij niet meegenomen.
### De juiste aanpak: IS NULL en IS NOT NULL
De database heeft speciale commando's gemaakt voor NULL-controles, omdat de gewone vergelijkingsoperator niet werkt:
```sql
-- Leden zonder telefoonnummer
SELECT voornaam, achternaam
FROM leden
WHERE telefoon IS NULL;
-- Leden met telefoonnummer
SELECT voornaam, achternaam
FROM leden
WHERE telefoon IS NOT NULL;
```
![NULL-afhandeling: het verschil tussen = NULL en IS NULL](afbeeldingen/hoofdstuk-04/hoofdstuk_04_scherm_03_null_afhandeling.svg)
`IS NULL` is de enige correcte manier om te controleren of een kolom geen waarde bevat. `IS NOT NULL` doet het omgekeerde: die filtert op rijen waar wél een waarde staat.
### Wat er misgaat als je dit negeert
Het probleem met `= NULL` is verraderlijk: de query geeft geen foutmelding en lijkt normaal te werken - maar geeft stilletjes een leeg resultaat. Stel, je levert als systeembeheerder een rapport op basis van die query aan de manager. Ze ziet een lege lijst en denkt: "Alle leden hebben een telefoonnummer." Niemand ziet dat de data ontbreekt. Beslissingen op basis van dat rapport zijn daardoor onjuist, zonder dat iemand het weet.
> **Onthoud:** NULL vergelijk je nooit met `=`. Altijd `IS NULL` of `IS NOT NULL`.
### Mini-oefening
De vestigingsmanager wil een lijst van alle lestypes waarbij de beschrijving niet is ingevuld. Schrijf de query.
```sql
-- Schrijf hier jouw query
```
**Antwoord:**
```sql
SELECT naam, duur_minuten, niveau
FROM lestypes
WHERE beschrijving IS NULL;
```
---
## 4.4 ORDER BY en DISTINCT - sorteren en ontdubbelen
### ORDER BY: jij bepaalt de volgorde
De database geeft rijen terug in de volgorde die hem uitkomt - dat is meestal de volgorde waarin de rijen zijn opgeslagen, maar daar kun je niet op rekenen. Als je een ledenlijst wilt gesorteerd op inschrijfdatum, heb je `ORDER BY` nodig.
```sql
SELECT voornaam, achternaam, lid_sinds
FROM leden
ORDER BY lid_sinds;
```
Standaard sorteert `ORDER BY` **oplopend** (van vroeg naar laat, van klein naar groot). Dat heet `ASC` (ascending). Wil je de nieuwste inschrijvingen bovenaan, draai je de volgorde om met `DESC` (descending):
```sql
SELECT voornaam, achternaam, lid_sinds
FROM leden
ORDER BY lid_sinds DESC;
```
Je kunt ook op meerdere kolommen sorteren. De database sorteert eerst op de eerste kolom en, bij gelijke waarden daarin, op de tweede:
```sql
SELECT achternaam, voornaam, lid_sinds
FROM leden
ORDER BY achternaam, voornaam;
```
Dit levert een alfabetische ledenlijst op achternaam, met bij gelijke achternaam een alfabetische sortering op voornaam. `ORDER BY` staat altijd als laatste in de query - na `WHERE`:
```sql
SELECT voornaam, achternaam, lid_sinds
FROM leden
WHERE actief = 1
ORDER BY lid_sinds DESC;
```
![ORDER BY sorteert resultaten, DISTINCT verwijdert duplicaten](afbeeldingen/hoofdstuk-04/hoofdstuk_04_scherm_04_order_by_distinct.svg)
### DISTINCT: elk resultaat slechts één keer
Stel, je wilt weten welke specialisaties er bij FitWorks-trainers voorkomen. Je schrijft:
```sql
SELECT specialisatie
FROM trainers;
```
Je krijgt 12 rijen - één per trainer. Maar meerdere trainers kunnen dezelfde specialisatie hebben: "Yoga" verschijnt misschien drie keer. Als je alleen de unieke specialisaties wilt zien, gebruik je `DISTINCT`:
```sql
SELECT DISTINCT specialisatie
FROM trainers;
```
`DISTINCT` zet je direct na `SELECT`. Het verwijdert rijen die in alle geselecteerde kolommen identiek zijn. Staat er vier keer "Yoga" in de resultaten, dan zie je er nog maar één.
Een veelgemaakte misvatting: `DISTINCT` werkt niet per kolom apart, maar op de combinatie van alle geselecteerde kolommen. `SELECT DISTINCT specialisatie, voornaam` geeft unieke combinaties van specialisatie én voornaam - niet unieke specialisaties per kolom. Wil je alleen unieke specialisaties, selecteer dan ook alleen die kolom.
### Reflectievraag
Je wilt een lijst van alle abonnementsnamen met hun maandprijs, gesorteerd van duurste naar goedkoopste. Welke query schrijf je? En wat verandert er als je `DISTINCT` toevoegt - en wanneer maakt dat verschil?
*(Schrijf je antwoord op voordat je verder gaat.)*
---
### Modelantwoord - reflectievraag 4.4
> **Mogelijk antwoord**
>
> Abonnementsnamen en prijzen staan in de tabel `abonnementen`. Sorteren van duurste naar goedkoopste vraagt om `ORDER BY prijs_per_maand DESC`.
>
> ```sql
> SELECT naam, prijs_per_maand
> FROM abonnementen
> ORDER BY prijs_per_maand DESC;
> ```
>
> `DISTINCT` toevoegen verandert hier niets, want in fitworks zijn abonnementsnamen uniek. Maar als je alleen `SELECT DISTINCT naam` zou schrijven zonder prijs, dan filtert `DISTINCT` wel dubbele namen eruit. Het verschil zit hem dus in wat je selecteert: voeg je meer kolommen toe, dan worden meer combinaties als uniek beschouwd.
---
## 4.5 Kolomaliassen en literals
### Een kolom een andere naam geven
Stel, je draait een rapport voor de vestigingsmanager. Ze ziet een overzicht met kolomnamen als `voornaam`, `lid_sinds` en `locatie_id`. Die namen zijn prima voor een databaseontwikkelaar - maar minder leesbaar voor iemand die gewend is aan Excel. Met een **alias** geef je een kolom in het resultaat een andere naam, zonder de tabel te veranderen.
Een alias schrijf je met het sleutelwoord `AS`, direct na de kolomnaam:
```sql
SELECT voornaam AS Voornaam,
achternaam AS Achternaam,
lid_sinds AS 'Lid sinds'
FROM leden;
```
Het resultaat toont de kolomkoppen "Voornaam", "Achternaam" en "Lid sinds". De tabeldefinitie in de database verandert niet - de alias bestaat alleen in dit resultaat. Als een alias een spatie bevat, zet je hem tussen enkele aanhalingstekens.
![Kolomaliassen maken query-resultaten leesbaarder](afbeeldingen/hoofdstuk-04/hoofdstuk_04_scherm_05_aliassen_literals.svg)
Waarom is dit nuttig? Omdat dezelfde query in de ene context voor een manager draait en in een andere context voor een ontwikkelaar. De alias laat je het resultaat aanpassen aan de lezer, zonder de query zelf fundamenteel te veranderen.
### Literals: vaste tekst in elk resultaat
Een **literal** is een vaste waarde die je direct in een query schrijft - geen kolom, maar een stuk tekst of een getal dat voor elke rij hetzelfde is. Literals zijn handig om context mee te geven aan een resultaat.
```sql
SELECT voornaam,
achternaam,
'FitWorks lid' AS type
FROM leden
WHERE actief = 1;
```
Elke rij in het resultaat krijgt een extra kolom "type" met de waarde `FitWorks lid`. De database vult die waarde automatisch in voor elke rij die het filter doorkomt. Een literal verandert nooit per rij - hij is altijd hetzelfde, vandaar de naam. Dit is nuttig als je twee queryresultaten samenvoegt en ze wilt markeren met een label, of als je een rapport met vaste context wilt exporteren.
### Mini-oefening
Schrijf een query die de naam en maandprijs van alle abonnementen toont, met als kolomkoppen "Abonnementsnaam" en "Maandprijs". Sorteer op prijs, laagste eerst.
```sql
-- Schrijf hier jouw query
```
**Antwoord:**
```sql
SELECT naam AS Abonnementsnaam,
prijs_per_maand AS Maandprijs
FROM abonnementen
ORDER BY prijs_per_maand;
```
---
## 4.6 Concatenatie en CAST
### Kolommen samenvoegen: CONCAT
Bij FitWorks is de voornaam opgeslagen in de kolom `voornaam` en de achternaam in `achternaam`. Dat is goed ontwerp - want dan kun je sorteren op achternaam, zoeken op voornaam, en filteren op elk deel afzonderlijk. Maar als je een overzicht wilt met de volledige naam als één kolom, heb je `CONCAT` nodig.
`CONCAT` plakt twee of meer waarden achter elkaar. Je geeft de waarden als argumenten mee, gescheiden door komma's:
```sql
SELECT CONCAT(voornaam, ' ', achternaam) AS volledige_naam
FROM leden;
```
Het resultaat bevat één kolom "volledige_naam" met waarden als `Sophie Bakker` of `Tom Jansen`. De spatie tussen voornaam en achternaam voeg je zelf toe als literal - de database doet dat niet automatisch.
Maar in fitworks hebben sommige leden een tussenvoegsel. Je wilt dan iets als `Tom van der Berg`, niet `Tom van der Berg` met een dubbele spatie of `Tom Berg` zonder tussenvoegsel. De oplossing gebruikt `COALESCE`, een functie die NULL vervangt door een opgegeven standaardwaarde:
```sql
SELECT CONCAT(
voornaam, ' ',
COALESCE(CONCAT(tussenvoegsel, ' '), ''),
achternaam
) AS volledige_naam
FROM leden;
```
`COALESCE(CONCAT(tussenvoegsel, ' '), '')` zegt: als `tussenvoegsel` NULL is, gebruik dan een lege string. Als het er wél is, plak er een spatie achter. Zo staat de naam altijd correct opgemaakt.
> **Even terzijde:** `COALESCE` is een handige functie voor NULL-situaties. Je ziet hem vaker terugkomen in latere hoofdstukken. Voor nu is het genoeg om te weten dat hij bestaat en wat hij doet.
### Datatypes omzetten: CAST
Elke waarde in een database heeft een datatype: tekst (`VARCHAR`, `CHAR`), getal (`INT`, `DECIMAL`), datum (`DATE`), enzovoort. Soms wil je een waarde als een ander type gebruiken - een getal weergeven als tekst zodat je er iets voor kunt plakken, of een datum omzetten naar een leesbaar formaat. Daarvoor is `CAST`.
```sql
SELECT naam,
CONCAT('Prijs: ', CAST(prijs_per_maand AS CHAR)) AS prijsweergave
FROM abonnementen;
```
`CAST(prijs_per_maand AS CHAR)` zet het decimale getal `29.95` om naar de tekst `'29.95'`. Daarna kan `CONCAT` er de vaste tekst `'Prijs: '` voor plakken. Zonder `CAST` zou MySQL in sommige situaties klagen dat je een getal en een string probeert samen te voegen.
![CONCAT plakt waarden samen, CAST zet datatypes om](afbeeldingen/hoofdstuk-04/hoofdstuk_04_scherm_06_concatenatie_cast.svg)
De meestgebruikte CAST-conversies in MySQL zijn:
| Van | Naar | Gebruik |
|-----|------|---------|
| Getal | Tekst | `CAST(prijs_per_maand AS CHAR)` |
| Tekst | Geheel getal | `CAST('42' AS UNSIGNED)` |
| Datum | Tekst | `CAST(geboortedatum AS CHAR)` |
### Mini-oefening
Schrijf een query die de volledige naam van elke trainer toont (voornaam, spatie, achternaam) in één kolom genaamd "Trainer". Gebruik de tabel `trainers`.
```sql
-- Schrijf hier jouw query
```
**Antwoord:**
```sql
SELECT CONCAT(voornaam, ' ', achternaam) AS Trainer
FROM trainers;
```
---
## Quiz
### Vraag 1
Je wilt alle betalingen zien met status `mislukt` of `openstaand`, gesorteerd van hoog naar laag bedrag. Welke query is correct?
**A)**
```sql
SELECT betaling_id, bedrag, status
FROM betalingen
WHERE status = 'mislukt' OR 'openstaand'
ORDER BY bedrag DESC;
```
**B)**
```sql
SELECT betaling_id, bedrag, status
FROM betalingen
WHERE status IN ('mislukt', 'openstaand')
ORDER BY bedrag DESC;
```
**C)**
```sql
SELECT betaling_id, bedrag, status
FROM betalingen
WHERE status IN ('mislukt', 'openstaand')
ORDER BY bedrag ASC;
```
**D)**
```sql
SELECT betaling_id, bedrag, status
FROM betalingen
WHERE status = 'mislukt' OR status = 'openstaand'
ORDER BY bedrag ASC;
```
**Correct antwoord: B**
*Toelichting:* Optie B gebruikt `IN` voor de statusfilter - dat is syntactisch correct en compact. `ORDER BY bedrag DESC` sorteert van hoog naar laag, zoals gevraagd. Optie A is syntactisch fout: `OR 'openstaand'` zonder kolomnaam werkt niet. Opties C en D gebruiken `ASC`, waardoor de volgorde omgekeerd is aan wat gevraagd wordt.
---
### Vraag 2
Welke query geeft correct alle leden terug die geen tussenvoegsel hebben?
**A)**
```sql
SELECT voornaam, achternaam
FROM leden
WHERE tussenvoegsel = NULL;
```
**B)**
```sql
SELECT voornaam, achternaam
FROM leden
WHERE tussenvoegsel = '';
```
**C)**
```sql
SELECT voornaam, achternaam
FROM leden
WHERE tussenvoegsel IS NULL;
```
**D)**
```sql
SELECT voornaam, achternaam
FROM leden
WHERE tussenvoegsel IS NOT NULL;
```
**Correct antwoord: C**
*Toelichting:* Optie C is de enige correcte aanpak. NULL vergelijk je nooit met `=` - die vergelijking levert altijd "onbekend" op en geeft nul resultaten, ook als er tientallen rijen zonder tussenvoegsel zijn. Optie B zoekt naar een lege string, maar in fitworks is een ontbrekend tussenvoegsel opgeslagen als NULL, niet als een lege string - die zijn fundamenteel anders. Optie D geeft het tegenovergestelde: leden mét tussenvoegsel.
---
### Vraag 3
Een collega schrijft deze query en ziet dat de kolom `specialisatie` nog steeds herhaalde waarden bevat:
```sql
SELECT DISTINCT specialisatie, voornaam
FROM trainers;
```
Wat is de oorzaak?
**A)** `DISTINCT` werkt alleen op de eerste geselecteerde kolom.
**B)** `DISTINCT` verwijdert dubbele rijen op basis van alle geselecteerde kolommen tegelijk. Twee trainers met dezelfde specialisatie maar een andere voornaam zijn geen duplicaat.
**C)** `DISTINCT` moet altijd gecombineerd worden met `ORDER BY`.
**D)** `DISTINCT` werkt niet op tekst-kolommen als `specialisatie`.
**Correct antwoord: B**
*Toelichting:* `DISTINCT` kijkt naar de combinatie van alle geselecteerde kolommen. Als twee trainers dezelfde specialisatie maar een andere voornaam hebben, beschouwt MySQL ze als twee unieke rijen. Wil je alleen unieke specialisaties zien, selecteer dan ook alleen die kolom: `SELECT DISTINCT specialisatie FROM trainers;`
---
## Samenvatting
`SELECT` en `FROM` vormen het hart van elke query. `SELECT` bepaalt welke kolommen je ziet, `FROM` bepaalt de tabel. Ze zijn verplicht en staan altijd in die volgorde.
Met `WHERE` filter je welke rijen je terugkrijgt. Je gebruikt vergelijkingsoperatoren (`=`, `!=`, `<`, `>`, `BETWEEN`, `IN`) en logische operators (`AND`, `OR`, `NOT`) om voorwaarden te combineren. Tekst staat altijd tussen enkele aanhalingstekens.
NULL is de afwezigheid van een waarde - niet nul, niet leeg, maar onbekend. Je kunt er nooit op filteren met `=`. Gebruik altijd `IS NULL` of `IS NOT NULL`.
Met `ORDER BY` sorteer je resultaten op een of meerdere kolommen, oplopend (`ASC`) of aflopend (`DESC`). `DISTINCT` verwijdert rijen die op alle geselecteerde kolommen identiek zijn.
Kolomaliassen (`AS`) geven een kolom een andere naam in het resultaat. Literals zijn vaste waarden die je direct in de query opneemt. `CONCAT` plakt meerdere waarden aaneen. `CAST` zet een waarde om naar een ander datatype.
---
## Vooruitblik
Je hebt nu de basis in handen om de fitworks-database te bevragen. Maar er is meer. Wat als je leden wilt zoeken op een deel van hun achternaam - iedereen wiens naam begint met "van"? Of wil weten hoe oud iemand is op basis van hun geboortedatum? Daarvoor heb je gereedschap nodig dat verder gaat dan de basisoperatoren. In hoofdstuk 5 leer je werken met tekstbewerkingen (waaronder `LIKE` voor zoeken op patronen) en datumfuncties. Je gaat de data niet alleen ophalen - je gaat er echt mee werken.