როგორ მუშაობს GROUP BY და HAVING?

Question

Accepted Answer

**`GROUP BY`** დააჯამებს რიგებს, რომლებიც იზიარებენ ერთსა და იმავე მნიშვნელობას, ასე რომ აგრეგატული ფუნქციები გამოითვლება თითოეული ჯამისთვის. **`HAVING`** ფილტრავს ამ ჯამებს (როგორც `WHERE`, მაგრამ ჯამებისა და აგრეგატებისთვის). ერთად ისინი წარმოადგენენ მონაცემების შეჯამებისა და ანალიზის ძირითად საშუალებებს კატეგორიის მიხედვით.

## GROUP BY — აგრეგირება თითოეული ჯამისთვის

```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` ყველა რიგს თითოეული ქვეყნის ჯამში შეკუმშავს, და აგრეგატული ფუნქციები (`COUNT`, `AVG`) ითვლის მნიშვნელობას თითოეული ჯამისთვის. შეგიძლიათ დაჯამოთ რამდენიმე სვეტის მიხედვით:

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

## HAVING — ჯამების ფილტრირება

```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` ფილტრავს *დაჯამების შემდეგ*, აგრეგატული მნიშვნელობებზე — რაც `WHERE` ვერ აკეთებს (`WHERE` ფილტრავს ცალკეულ რიგებს დაჯამებამდე).

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

## შესრულების თანმიმდევრობა

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

## რატომ აქვს ეს მნიშვნელობა

`GROUP BY` და `HAVING` არის **ანალიტიკული SQL**-ის ძირი — მონაცემების შეჯამება და ანალიზი კატეგორიის მიხედვით არის ფундამენტური, მუდმივი საჭიროება (ჯამი რეგიონის მიხედვით, გაყიდვა პროდუქტის მიხედვით, საშუალოები ჯამის მიხედვით), ამიტომ მათი გაგება სერიოზულია. `GROUP BY` (რიგების დაჯამება ისე, რომ აგრეგატები გამოითვლებოდეს ჯამის მიხედვით) არის ამ შეჯამების შედეგების მოთხოვნის საფუძველი, და იმის გაგება, თუ როგორ შეკუმშავს იგი რიგებს ჯამებად აგრეგირებისთვის, აუცილებელია ნებისმიერი ანგარიშო ან ანალიტიკისთვის.

**`WHERE` vs `HAVING` განსხვავება** განსაკუთრებით მნიშვნელოვანია და ხშირად დაბნელებული: `WHERE` ფილტრავს ცალკეულ რიგებს *დაჯამებამდე* (და ვერ იყენებს აგრეგატებს), ხოლო `HAVING` ფილტრავს ჯამებს *დაჯამების შემდეგ* (აგრეგატული მნიშვნელობებზე) — არასწორი ერთის გამოყენება იწვევს შეცდომებს ან არასწორ შედეგებს, და იმის გაგება, თუ როდის გამოიყენება თითოეული (WHERE მწკრივის დონის ფილტრირებისთვის, HAVING აგრეგატული დონის ფილტრირებისთვის ჯამებში) არის ღირებული უნარი.

იმის ცოდნა, რომ შეფასება WHERE-ით დავიწყოთ, როდესაც შესაძლებელია (უფრო ეფექტური — რიგების შემცირება დაჯამებამდე), არის სასარგებლო ოპტიმიზაცია.

**შესრულების თანმიმდევრობასთან** კავშირი (WHERE დაჯამებამდე, HAVING შემდეგ) ხსნის, რატომ განსხვავდებიან მათი როლები.

მას შემდეგ, რაც დაჯამება და აგრეგატული ფილტრირება არის ფართოდ გავრცელებული ანგარიშო და მონაცემების ანალიზში, და რადგან WHERE-vs-HAVING განსხვავება არის მნიშვნელოვანი სისწორისთვის და ხშირად გაუგებარი, `GROUP BY` და `HAVING`-ის ათვისება — დაჯამება თითოეული კატეგორიის აგრეგატებისთვის და ორი დონის ფილტრირების მოდელი — არის ძირითადი, ხშირად გამოყენებული ცოდნა, რომელიც აუცილებელია ანალიტიკული SQL-ისთვის და ხშირი ინტერვიუს თემა.