Hoe werken GROUP BY en HAVING?

Question

Accepted Answer

**`GROUP BY`** groepeert rijen die dezelfde waarde delen, zodat aggregaatfuncties per groep berekenen. **`HAVING`** filtert die groepen (net als `WHERE`, maar voor groepen/aggregaten). Samen vormen ze de kern van het samenvatten en analyseren van gegevens per categorie.

## GROUP BY — aggregaat per groep

```sql
SELECT country, COUNT(*) AS user_count, AVG(age) AS avg_age
FROM users
GROUP BY country;
-- one result row PER country, with that country's count and average age
```

`GROUP BY country` vouwt alle rijen van elk land in één groep samen, en aggregaatfuncties (`COUNT`, `AVG`) berekenen een waarde voor elke groep. Je kunt groeperen op meerdere kolommen:

```sql
GROUP BY country, city          -- a group per unique (country, city) combination
```

## HAVING — de groepen filteren

```sql
-- show only countries with MORE THAN 100 users
SELECT country, COUNT(*) AS user_count
FROM users
GROUP BY country
HAVING COUNT(*) > 100;          -- filter on the AGGREGATE
```

`HAVING` filtert *na* groepering, op aggregaatwaarden — iets wat `WHERE` niet kan (WHERE filtert individuele rijen vóór groepering).

## WHERE vs HAVING — een belangrijk verschil

```sql
SELECT country, COUNT(*) AS cnt
FROM users
WHERE active = true             -- WHERE: filter ROWS first (before grouping)
GROUP BY country
HAVING COUNT(*) > 100;          -- HAVING: filter GROUPS after (on aggregates)
```

```text
WHERE  → filters individual ROWS, runs BEFORE grouping, can't use aggregates
HAVING → filters GROUPS, runs AFTER grouping, used WITH aggregates
→ Use WHERE to filter rows, HAVING to filter aggregated groups. (Filter with WHERE
  first when possible — it's more efficient, reducing rows before grouping.)
```

## De uitvoeringsvolgor de

```text
FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY
(WHERE before grouping, HAVING after — which is why their roles differ)
```

## Waarom het belangrijk is

`GROUP BY` en `HAVING` zijn centraal voor **analytische SQL** — het samenvatten en analyseren van gegevens per categorie is een fundamentele, voortdurende behoefte (aantallen per regio, verkoop per product, gemiddelden per groep), dus inzicht hierin is essentieel. `GROUP BY` (rijen groeperen zodat aggregaten per groep berekenen) is de basis van deze samenvattingsquery's, en inzicht in hoe het rijen in groepen voor aggregatie ineenstort is noodzakelijk voor elk rapport of analyse.

Het **`WHERE` vs `HAVING` onderscheid** is bijzonder belangrijk en wordt vaak verward: `WHERE` filtert individuele rijen *vóór* groepering (en kan geen aggregaten gebruiken), terwijl `HAVING` groepen *na* groepering filtert (op aggregaatwaarden) — de verkeerde gebruiken leidt tot fouten of foutieve resultaten, en inzicht in wanneer elk van toepassing is (WHERE voor filtering op rijniveau, HAVING voor filtering op aggregaatniveau van groepen) is een sleutelvaardigheid.

Weten dat je eerst met WHERE filtert wanneer mogelijk (efficiënter — rijen reduceren vóór groepering) is een nuttige optimalisatie.

De verbinding met **uitvoeringsvolgorde** (WHERE vóór groepering, HAVING erna) verklaart waarom hun rollen verschillen.

Aangezien groepering en aggregaatfiltering alomtegenwoordig zijn in rapportage en data-analyse, en aangezien het WHERE-versus-HAVING-onderscheid zowel belangrijk is voor juistheid als algemeen verkeerd begrepen, is het beheersen van `GROUP BY` en `HAVING` — groeperen voor per-categorieaggregaten en het tweeledige filtermodel — kernkennis die veel wordt toegepast en essentieel is voor analytische SQL en een veelgesteld interviewonderwerp.