GROUP BY மற்றும் HAVING எப்படி வேலை செய்கின்றன?

Question

Accepted Answer

**`GROUP BY`** ஒரு மதிப்பைப் பகிர்ந்துகொள்ளும் rows-களை group செய்கிறது, இதனால் 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-க்கு *பிறகு*, aggregate மதிப்புகளில் filter செய்கிறது — `WHERE`-ஆல் செய்ய முடியாதது (WHERE grouping-க்கு முன் தனிப்பட்ட rows-களை filter செய்கிறது).

## WHERE vs 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 வரிசை

```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` (aggregates ஒவ்வொரு group-க்கும் கணக்கிடுமாறு rows-களை group செய்தல்) இந்த summary queries-களின் அடித்தளம், மேலும் aggregation-க்காக அது rows-களை எப்படி groups-களாக சுருக்குகிறது என்பதைப் புரிந்துகொள்வது எந்த reporting அல்லது analytics-க்கும் அவசியம்.

**`WHERE` vs `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-vs-HAVING வேறுபாடு சரியான தன்மைக்கு முக்கியமாகவும் அடிக்கடி தவறாகப் புரிந்துகொள்ளப்படுவதாலும், `GROUP BY` மற்றும் `HAVING`-இல் தேர்ச்சி பெறுதல் — per-category aggregates-க்கு grouping மற்றும் இரண்டு-நிலை filtering model — analytical SQL-க்கு அவசியமான, அடிக்கடி பயன்படுத்தப்படும் அறிவு மற்றும் ஒரு பொதுவான interview தலைப்பு.