GROUP BY और HAVING कैसे काम करते हैं?

Question

Accepted Answer

**`GROUP BY`** एक मान साझा करने वाली rows को समूहित करता है, ताकि aggregate functions प्रति group गणना करें। **`HAVING`** उन groups को filter करता है (`WHERE` की तरह, लेकिन groups/aggregates के लिए)। साथ में ये category द्वारा data को सारांशित और विश्लेषित करने के मूल हैं।

## GROUP BY — प्रति group aggregate

```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` प्रत्येक country की सभी rows को एक group में समेट देता है, और aggregate functions (`COUNT`, `AVG`) प्रत्येक group के लिए एक मान की गणना करते हैं। आप कई columns द्वारा group कर सकते हैं:

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

## HAVING — groups को filter करें

```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` grouping के *बाद* filter करता है, aggregate मानों पर — कुछ ऐसा जो `WHERE` नहीं कर सकता (WHERE grouping से पहले व्यक्तिगत rows को filter करता है)।

## WHERE बनाम HAVING — एक मुख्य अंतर

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

## execution order

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

## यह क्यों महत्वपूर्ण है

`GROUP BY` और `HAVING` **analytical SQL** के मूल हैं — category द्वारा data को सारांशित और विश्लेषित करना एक मूलभूत, निरंतर आवश्यकता है (प्रति region counts, प्रति product sales, प्रति group averages), इसलिए इन्हें समझना आवश्यक है। `GROUP BY` (rows को समूहित करना ताकि aggregates प्रति group गणना करें) इन सारांश queries की नींव है, और यह कैसे aggregation के लिए rows को groups में समेटता है यह समझना किसी भी reporting या analytics के लिए आवश्यक है।

**`WHERE` बनाम `HAVING` अंतर** विशेष रूप से महत्वपूर्ण और आम तौर पर भ्रमित किया जाने वाला है: `WHERE` grouping से *पहले* व्यक्तिगत rows को filter करता है (और aggregates का उपयोग नहीं कर सकता), जबकि `HAVING` grouping के *बाद* groups को filter करता है (aggregate मानों पर) — गलत का उपयोग errors या गलत परिणाम पैदा करता है, और यह समझना कि प्रत्येक कब लागू होता है (row-level filtering के लिए WHERE, groups की aggregate-level filtering के लिए HAVING) एक मुख्य कौशल है।

जब संभव हो तब पहले WHERE से filter करना जानना (अधिक कुशल — grouping से पहले rows कम करना) एक उपयोगी optimization है।

**execution order** से संबंध (WHERE grouping से पहले, HAVING बाद में) यह समझाता है कि उनकी भूमिकाएँ क्यों भिन्न हैं।

चूँकि grouping और aggregate filtering reporting और data विश्लेषण में सर्वव्यापी हैं, और चूँकि WHERE-बनाम-HAVING अंतर शुद्धता के लिए महत्वपूर्ण और आम तौर पर गलत समझा जाने वाला दोनों है, इसलिए `GROUP BY` और `HAVING` में महारत हासिल करना — per-category aggregates के लिए grouping और दो-स्तरीय filtering मॉडल — analytical SQL के लिए आवश्यक मूलभूत, बार-बार उपयोग होने वाला ज्ञान है और एक आम interview विषय है।