Aggregate functions (COUNT, SUM, AVG, போன்றவை) என்றால் என்ன?

Question

Accepted Answer

**Aggregate functions**, rows-களின் ஒரு தொகுப்பிலிருந்து ஒரே ஒரு மதிப்பைக் கணக்கிடுகின்றன — `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`. data-வை சுருக்குவதற்கு (totals, averages, counts) அவை அவசியம், குறிப்பாக `GROUP BY` உடன் இணைந்து.

## முக்கிய aggregate functions

```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;
```

ஒவ்வொரு function-ம் பல rows-களை ஒரு மதிப்பாகக் குறைக்கிறது. `SUM`/`AVG` எண்களில் வேலை செய்கின்றன; `MIN`/`MAX` எண்கள், dates அல்லது text-இல்; `COUNT` எதிலும்.

## COUNT(*) vs COUNT(column) — ஒரு முக்கியமான வேறுபாடு

```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(*)`** அனைத்து rows-களையும் எண்ணுகிறது, ஆனால் **`COUNT(column)`** அந்த column **NULL அல்லாத** rows-களை மட்டுமே எண்ணுகிறது — ஒரு நுட்பமான ஆனால் முக்கியமான வேறுபாடு. `COUNT(DISTINCT col)` unique மதிப்புகளை எண்ணுகிறது.

## GROUP BY உடன் aggregates (per-group summaries)

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

`GROUP BY` இல்லாமல், ஒரு aggregate முழு முடிவையும் ஒரு row-ஆக சுருக்குகிறது. `GROUP BY` உடன், அது **ஒவ்வொரு group-க்கும்** ஒரு summary row-ஐ உருவாக்குகிறது — வழக்கமான, சக்திவாய்ந்த பயன்பாடு.

## ஒரு பொதுவான ஆபத்து: aggregates மற்றும் non-aggregated columns

```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;
```

## இது ஏன் முக்கியம்

Aggregate functions **data-வை சுருக்குவதற்கும் பகுப்பாய்வு செய்வதற்கும்** அவசியம் — totals, averages, counts மற்றும் extremes கணக்கிடுவது reporting, analytics, dashboards மற்றும் application logic-இல் ஒரு நிலையான தேவை, எனவே அவற்றைப் புரிந்துகொள்வது அடிப்படையான SQL அறிவு.

முக்கிய functions (`COUNT`, `SUM`, `AVG`, `MIN`, `MAX`) மற்றும் அவை rows-களின் தொகுப்புகளை ஒரே மதிப்புகளாக எப்படிக் குறைக்கின்றன என்பதை அறிந்திருப்பது எந்த data சுருக்கத்திற்கும் அவசியம்.

ஒரு முக்கியமான, அடிக்கடி தவறாகப் புரிந்துகொள்ளப்படும் விவரம் **`COUNT(*)` vs `COUNT(column)` வேறுபாடு** (COUNT(*) அனைத்து rows-களையும் எண்ணுகிறது, COUNT(column) NULL அல்லாத மதிப்புகளை மட்டுமே எண்ணுகிறது — இது வேறுபட்ட, ஆச்சரியமான முடிவுகளைத் தரலாம்), unique மதிப்புகளுக்கான `COUNT(DISTINCT)` உடன் சேர்ந்து.

மிக சக்திவாய்ந்த முறையில், aggregates **`GROUP BY`** உடன் இணைந்து per-group summaries-களை உருவாக்குகின்றன (ஒரு category-க்கு counts/averages) — analytical queries-களின் அடித்தளம்.

aggregates-களை non-grouped columns-களுடன் கலக்க முடியாது என்ற **ஆபத்தை** (ஒரு பொதுவான error) புரிந்துகொள்வதும் முக்கியம்.

data-வை சுருக்குவது ஒரு எங்கும் காணப்படும் database பணி என்பதாலும் (ஒவ்வொரு report, dashboard மற்றும் analytics query-ம் aggregates-களைப் பயன்படுத்துகிறது), functions, COUNT நுட்பங்கள், மற்றும் குறிப்பாக GROUP BY உடனான அவற்றின் கலவையைப் புரிந்துகொள்வது SQL-இல் data பகுப்பாய்வுக்கு அடிப்படையானது என்பதாலும், aggregate functions-களில் தேர்ச்சி பெறுதல் data-உடன் வேலை செய்வதற்கு அவசியமான, அடிக்கடி பயன்படுத்தப்படும் அறிவு — அடிப்படை query செய்தலையும் SQL-ஐ reporting மற்றும் insights-களுக்கு மதிப்புமிக்கதாக்கும் analytical, summarizing சக்தியையும் இணைக்கிறது.