Jak działają GROUP BY i HAVING?

Question

Accepted Answer

**`GROUP BY`** grupuje wiersze, które mają wspólną wartość, dzięki czemu funkcje agregujące obliczają wyniki dla każdej grupy. **`HAVING`** filtruje te grupy (jak `WHERE`, ale dla grup/agregatów). Razem stanowią rdzeń podsumowania i analizy danych według kategorii.

## GROUP BY — agregacja na grupę

```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` scala wszystkie wiersze każdego kraju w jedną grupę, a funkcje agregujące (`COUNT`, `AVG`) obliczają wartość dla każdej grupy. Możesz grupować według wielu kolumn:

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

## HAVING — filtrowanie grup

```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` filtruje *po* grupowaniu, na podstawie wartości agregatów — coś, czego `WHERE` nie potrafi zrobić (WHERE filtruje pojedyncze wiersze przed grupowaniem).

## WHERE vs HAVING — kluczowa różnica

```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.)
```

## Kolejność wykonania

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

## Dlaczego to ważne

`GROUP BY` i `HAVING` to podstawa **analitycznego SQL** — podsumowanie i analiza danych według kategorii to fundamentalna, stała potrzeba (liczby na region, sprzedaż na produkt, średnie na grupę), więc zrozumienie ich jest niezbędne. `GROUP BY` (grupowanie wierszy, aby agregaty obliczały się dla każdej grupy) to fundament takich zapytań podsumowujących, a zrozumienie, jak scala wiersze w grupy do agregacji, jest konieczne dla każdego raportowania czy analityki.

Rozróżnienie **`WHERE` vs `HAVING`** jest szczególnie ważne i często mylone: `WHERE` filtruje poszczególne wiersze *przed* grupowaniem (i nie może używać agregatów), podczas gdy `HAVING` filtruje grupy *po* grupowaniu (na podstawie wartości agregatów) — użycie złego filtra powoduje błędy lub złe wyniki, a zrozumienie, kiedy każdy z nich zastosować (WHERE do filtrowania na poziomie wierszy, HAVING do filtrowania grup na poziomie agregatów) to umiejętność kluczowa.

Wiedza, aby jeśli to możliwe, najpierw filtrować WHERE (bardziej efektywnie — zmniejszając wiersze przed grupowaniem) to przydatna optymalizacja.

Połączenie z **kolejnością wykonania** (WHERE przed grupowaniem, HAVING po) wyjaśnia, dlaczego ich role różnią się.

Ponieważ grupowanie i filtrowanie agregatów są wszechobecne w raportowaniu i analizie danych, a rozróżnienie WHERE vs HAVING jest zarówno ważne dla poprawności, jak i powszechnie niezrozumiane, opanowanie `GROUP BY` i `HAVING` — grupowania dla agregatów na kategorię i dwupoziomowego modelu filtrowania — to podstawowa, często stosowana wiedza niezbędna dla analitycznego SQL i powszechny temat rozmów kwalifikacyjnych.