Wat zijn aggregatiefuncties (COUNT, SUM, AVG, enz.)?

Question

Accepted Answer

**Aggregatiefuncties** berekenen een enkele waarde uit een set rijen — `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`. Ze zijn essentieel voor het samenvatten van gegevens (totalen, gemiddelden, aantallen), vooral in combinatie met `GROUP BY`.

## De belangrijkste aggregatiefuncties

```sql
SELECT
  COUNT(*)        AS total_rows,        -- count all rows
  COUNT(email)    AS rows_with_email,    -- count NON-NULL emails (ignores NULLs!)
  SUM(amount)     AS total_amount,       -- sum of a column
  AVG(price)      AS average_price,      -- average
  MIN(price)      AS lowest,             -- minimum
  MAX(price)      AS highest             -- maximum
FROM orders;
```

Elke functie reduceert veel rijen tot één waarde. `SUM`/`AVG` werken op getallen; `MIN`/`MAX` op getallen, datums of tekst; `COUNT` op alles.

## COUNT(*) vs COUNT(kolom) — een belangrijk verschil

```sql
COUNT(*)         -- counts ALL rows (including those with NULLs)
COUNT(email)     -- counts only rows where email is NOT NULL
COUNT(DISTINCT country)  -- counts UNIQUE non-null values
```

**`COUNT(*)`** telt alle rijen, maar **`COUNT(kolom)`** telt alleen rijen waarin die kolom **niet NULL** is — een subtiel maar belangrijk onderscheid. `COUNT(DISTINCT col)` telt unieke waarden.

## Aggregaties met GROUP BY (samenvattingen per groep)

```sql
-- aggregate PER GROUP instead of the whole table
SELECT country, COUNT(*) AS users, AVG(age) AS avg_age
FROM users
GROUP BY country;          -- one result row per country
-- → for each country: how many users and their average age
```

Zonder `GROUP BY` vat een aggregatie het hele resultaat samen in één rij. Met `GROUP BY` levert het één samenvattingsrij op **per groep** — het typische, krachtige gebruik.

## Een veelvoorkomende val: aggregaties en niet-geaggregeerde kolommen

```sql
-- ❌ ERROR — can't mix an aggregate with a non-grouped column
SELECT name, COUNT(*) FROM users;        -- which name? ambiguous
-- ✅ either group by it, or only select aggregates
SELECT country, COUNT(*) FROM users GROUP BY country;
```

## Waarom het belangrijk is

Aggregatiefuncties zijn essentieel voor **gegevens samenvatten en analyseren** — het berekenen van totalen, gemiddelden, aantallen en extremen is een constant behoefte in rapportage, analyse, dashboards en applicatielogica, dus het begrijpen ervan is fundamentele SQL-kennis.

Het kennen van de belangrijkste functies (`COUNT`, `SUM`, `AVG`, `MIN`, `MAX`) en hoe zij sets rijen tot enkele waarden reduceren is noodzakelijk voor elke gegevenssamenvatting.

Een belangrijk, vaak verkeerd begrepen detail is het **onderscheid tussen `COUNT(*)` en `COUNT(kolom)`** (`COUNT(*)` telt alle rijen, `COUNT(kolom)` telt alleen waarden die niet NULL zijn — wat verschillende, verrassende resultaten kan geven), evenals `COUNT(DISTINCT)` voor unieke waarden.

Meest krachtig combineren aggregaties met **`GROUP BY`** om samenvattingen per groep te produceren (aantallen/gemiddelden per categorie) — de basis van analytische queries.

Het begrijpen van de **val** dat je aggregaties niet kunt mengen met niet-gegroepeerde kolommen (een veelvoorkomende fout) is ook belangrijk.

Omdat gegevens samenvatten een alomtegenwoordige databasetaak is (elk rapport, dashboard en analytische query gebruikt aggregaties), en omdat het begrijpen van de functies, de COUNT-subtiliteiten en vooral hun combinatie met GROUP BY fundamenteel is voor gegevensanalyse in SQL, is het beheersen van aggregatiefuncties kernkennis die frequent wordt toegepast en essentieel is voor het werken met gegevens — brugvormend tussen basale queries en de analytische, samenvattende kracht die SQL waardevol maakt voor rapportage en inzichten.