PricingLoginStart free
Voorbereiding op programmeerinterviews · Les

COUNT(*) versus COUNT(column) versus COUNT(DISTINCT)

De klassieke vraag over hoe elke COUNT-vorm omgaat met NULL's en duplicaten

Les 1 van 413 stappen

COUNT(*) versus COUNT(column) versus COUNT(DISTINCT) is een gratis Voorbereiding op programmeerinterviews-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Voorbereiding op programmeerinterviews. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Voorbereiding op programmeerinterviews bevat in totaal 4 lessen.

De vraag die je krijgt

Als je een SQL-sollicitatiegesprek voert, verwacht dit dan binnen de eerste tien minuten: Wat is het verschil tussen COUNT(*), COUNT(column) en COUNT(DISTINCT column)?

Het lijkt triviaal, maar interviewers gebruiken dit om te controleren of je echt begrijpt hoe aggregaties omgaan met NULL-waarden en duplicaten. Een zelfverzekerd, nauwkeurig antwoord laat zien dat je echte query's hebt geschreven en niet alleen syntaxis uit je hoofd hebt geleerd.

In deze les bouwen we een ijzersterk mentaal model op, zodat je direct kunt antwoorden en kunt uitleggen waarom.

COUNT(*) telt rijen

COUNT(*) telt rijen. Het kijkt helemaal niet naar kolomwaarden, dus NULL-waarden zijn niet relevant. Als de tabel 100 rijen bevat, retourneert COUNT(*) zonder meer 100.

Het sterretje vermenigvuldigt hier geen kolommen en breidt ze ook niet uit. Het is een speciaal teken dat betekent: "tel elke rij die aan de voorwaarden voldoet". Dit is de vorm die je gebruikt wanneer de vraag simpelweg is: "hoeveel records?"

SELECT COUNT(*) AS total_rows
FROM employees;

Voorbeeldgegevens om mee te redeneren

Laten we alles aan één kleine tabel koppelen. Stel je een tabel employees voor met een kolom department die NULL mag bevatten:

  • Alice, Verkoop
  • Bob, Verkoop
  • Carol, NULL
  • Dan, Techniek
  • Eve, NULL

Dat zijn in totaal 5 rijen. Drie rijen hebben een afdelingswaarde (Verkoop, Verkoop, Techniek) en twee rijen hebben NULL. Houd deze aantallen in gedachten; we tellen deze tabel op drie verschillende manieren.

COUNT(column) slaat NULL-waarden over

COUNT(column) telt alleen de rijen waarin die kolom niet NULL is. Het negeert NULL-waarden volledig.

Op onze voorbeeldgegevens retourneert COUNT(department) 3, niet 5, omdat twee afdelingswaarden NULL zijn. Dit is het belangrijkste feit van de hele les: COUNT op een kolom telt nooit NULL-waarden.

SELECT COUNT(department) AS depts_present
FROM employees;
-- returns 3 on our sample data

De twee tot nu toe vergelijken

Naast elkaar op dezelfde tabel met 5 rijen:

  • COUNT(*) = 5 (elke rij)
  • COUNT(department) = 3 (afdelingen die niet NULL zijn)

Het verschil ertussen, 5 min 3, is gelijk aan het aantal afdelingen met NULL. Een handige interviewtruc: COUNT(*) - COUNT(col) geeft het aantal NULL-waarden in die kolom zonder dat je een aparte WHERE-clausule hoeft te schrijven.

SELECT COUNT(*) - COUNT(department) AS null_departments
FROM employees;
-- returns 2

COUNT(DISTINCT column)

COUNT(DISTINCT column) telt het aantal unieke waarden die niet NULL zijn. Eerst worden duplicaten verwijderd, daarna worden NULL-waarden genegeerd en vervolgens wordt geteld wat overblijft.

In onze gegevens zijn de unieke afdelingswaarden Verkoop en Techniek, dus retourneert COUNT(DISTINCT department) 2. De twee NULL-waarden tellen niet mee en de dubbele vermelding van Verkoop wordt één waarde.

SELECT COUNT(DISTINCT department) AS unique_depts
FROM employees;
-- returns 2

Alle drie samen

Het volledige overzicht van onze tabel met 5 rijen:

  • COUNT(*) = 5 — rijen
  • COUNT(department) = 3 — waarden die niet NULL zijn
  • COUNT(DISTINCT department) = 2 — unieke waarden die niet NULL zijn

Als je deze volgorde kunt opdreunen, eerst rekening houdend met NULL en daarna met duplicaten, begrijp je het hele concept. Elke vorm retourneert een waarde die kleiner dan of gelijk is aan de vorm erboven.

SELECT
  COUNT(*)                       AS rows_total,
  COUNT(department)              AS depts_present,
  COUNT(DISTINCT department)     AS unique_depts
FROM employees;

Een uitgewerkt voorbeeld uit een sollicitatiegesprek

Interviewers verpakken dit vaak anders: "Hoeveel medewerkers zijn aan een afdeling toegewezen en hoeveel unieke afdelingen bestaan er?"

Het eerste deel is COUNT(department) (toegewezen betekent niet NULL). Het tweede deel is COUNT(DISTINCT department). Herkennen aan welke COUNT elke formulering gekoppeld is, is precies de vaardigheid die wordt getoetst.

SELECT
  COUNT(department)          AS assigned_employees,
  COUNT(DISTINCT department) AS distinct_departments
FROM employees;

COUNT met een voorwaarde

Een geliefde vervolgvraag: tel alleen rijen die aan een voorwaarde voldoen. Een nette, overdraagbare truc is COUNT over een CASE-expressie. Omdat COUNT(column) NULL-waarden overslaat, laat je CASE NULL teruggeven voor rijen die je wilt uitsluiten.

Hier tellen we medewerkers in Verkoop. CASE levert alleen voor rijen van Verkoop een waarde op en anders NULL, dus COUNT telt alleen die rijen.

SELECT
  COUNT(CASE WHEN department = 'Sales' THEN 1 END) AS sales_count
FROM employees;
-- returns 2

Veelgemaakte fouten om te vermijden

Let op deze valkuilen die interviewers inbouwen:

  • Ervan uitgaan dat COUNT(column) gelijk is aan COUNT(*) — dat is alleen zo wanneer de kolom geen NULL-waarden bevat.
  • Denken dat COUNT(DISTINCT col) NULL als één unieke waarde meetelt — dat doet het niet.
  • COUNT(1) schrijven in de verwachting dat NULL-waarden worden overgeslagen — het gedraagt zich als COUNT(*) en telt alle rijen.

Noem deze punten uit jezelf in een sollicitatiegesprek om te laten zien dat je de materie goed beheerst.

COUNT(1) en COUNT(constant)

Kandidaten vragen vaak welke vorm sneller is, COUNT(*) of COUNT(1). Het antwoord: ze zijn semantisch identiek — beide tellen elke rij, ongeacht NULL-waarden — en moderne optimizers behandelen ze hetzelfde. Er is dus geen echt prestatieverschil.

De constante in COUNT(1) is nooit NULL, dus er wordt nooit een rij overgeslagen. Geef voor de duidelijkheid de voorkeur aan COUNT(*); dat is de gebruikelijke vorm.

SELECT COUNT(*) AS a, COUNT(1) AS b
FROM employees;
-- a and b are always equal

Snelle controle

Toets je mentale model aan de hand van de voorbeeldtabel.

Beantwoord dit in de interactieve les

Samenvatting

Je beheerst nu de meest gestelde aggregatievraag:

  • COUNT(*) telt elke rij, inclusief NULL-waarden.
  • COUNT(column) telt alleen waarden die niet NULL zijn.
  • COUNT(DISTINCT column) telt unieke waarden die niet NULL zijn.
  • COUNT(*) - COUNT(col) geeft het aantal NULL-waarden zonder extra werk.
  • COUNT(1) is gelijk aan COUNT(*) — NULL-waarden worden niet overgeslagen en er is geen snelheidsverschil.

Zeg het helder en onderbouw het met de reden. Hierna: hoe SUM en AVG omgaan met NULL-waarden.

Gratis beginnen

Leer Voorbereiding op programmeerinterviews met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
90
Lessen
360
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “COUNT(*) versus COUNT(column) versus COUNT(DISTINCT)” gratis?

Ja — de volledige tekst van “COUNT(*) versus COUNT(column) versus COUNT(DISTINCT)” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Voorbereiding op programmeerinterviews wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Voorbereiding op programmeerinterviews bevat in totaal 4 lessen.

Wat leer ik in “COUNT(*) versus COUNT(column) versus COUNT(DISTINCT)”?

De klassieke vraag over hoe elke COUNT-vorm omgaat met NULL's en duplicaten Je oefent met Voorbereiding op programmeerinterviews door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Voorbereiding op programmeerinterviews te beginnen?

Ervaring vooraf is niet nodig. Voorbereiding op programmeerinterviews op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “COUNT(*) versus COUNT(column) versus COUNT(DISTINCT)”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Voorbereiding op programmeerinterviews?

Ja. Elke les over Voorbereiding op programmeerinterviews bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. COUNT(*) versus COUNT(column) versus COUNT(DISTINCT)
  2. SUM en AVG met NULL's
  3. MIN, MAX en aggregatie van niet-numerieke waarden
  4. Aggregaties zonder GROUP BY
← Terug naar Voorbereiding op programmeerinterviews