# Agregiranje podataka: GROUP BY, HAVING i uobičajene agregatne funkcije ## Uvod Agregiranje podataka je temeljna operacija u upravljanju bazama podataka koja vam omogućava transformaciju neobrađenih podataka u smislene uvide. Bilo da analizirate trendove prodaje, izračunate demografiju kupaca ili sažete razine zaliha, agregatne funkcije i mehanizmi grupiranja su neizostavni alati. Ova lekcija detaljno istražuje MySQL mogućnosti agregiranja, pokrivajući `GROUP BY` klauzulu, `HAVING` filter i najčešće korištene agregatne funkcije (`COUNT`, `SUM`, `AVG`, `MIN`, `MAX` i više). Do kraja ove lekcije, moći ćete pisati sofisticirane upite koji izvlače djelotvorne uvide iz vaših podataka. --- ## Osnovni koncepti ### 1. **Agregatne funkcije: Građevni blokovi agregiranja podataka** Agregatne funkcije izvode izračune na skupovima vrijednosti i vraćaju jedan rezultat. One su temelj agregiranja podataka, omogućavajući vam da sumarižete podatke na moćne načine. MySQL pruža nekoliko ugrađenih agregatnih funkcija, svaka služi za određenu svrhu: #### **Uobičajene agregatne funkcije** | Funkcija | Opis | Primjer upotrebe | |----------|-------------|------------------| | **`COUNT()`** | Vraća broj redaka (ili ne-NULL vrijednosti) u grupi. | Brojanje broja narudžbi po kupcu. | | **`SUM()`** | Izračunava zbroj vrijednosti u grupi. | Zbrajanje ukupne prodaje za svaku kategoriju proizvoda. | | **`AVG()`** | Izračunava prosjek (aritmetički prosjek) vrijednosti u grupi. | Izračunavanje prosječne ocjene za svaki film. | | **`MIN()`** | Pronalazi najmanju vrijednost u grupi. | Identificiranje najnižeprije hranjene stavke u svakoj kategoriji. | | **`MAX()`** | Pronalazi najveću vrijednost u grupi. | Određivanje najviše prodaje po regiji. | | **`STDDEV()`** | Izračunava standardnu devijaciju vrijednosti u grupi. | Analiza varijabilnosti u cijenama proizvoda. | | **`VARIANCE()`** | Izračunava varijancu vrijednosti u grupi. | Mjerenje širenja dobi kupaca. | #### **Sintaksa i ponašanje** - Agregatne funkcije **ignoriraju NULL vrijednosti** prema zadanim postavkama. Na primjer, `COUNT(column_name)` neće brojati retke gdje je `column_name` `NULL`. - Za uključivanje `NULL` vrijednosti u izračune, koristite `COUNT(*)`, koji broji sve retke bez obzira na `NULL` vrijednosti. - Agregatne funkcije se obično koriste s `GROUP BY` za izvođenje izračuna na podskupovima podataka. --- ### 2. **Klauzula `GROUP BY`: Organiziranje podataka u grupe** `GROUP BY` klauzula se koristi za organiziranje identičnih podataka u grupe (ili podskupove) na temelju jedne ili više kolona. To omogućava agregatnim funkcijama da djeluju na svaku grupu neovisno, stvarajući sumarne rezultate. #### **Sintaksa** ```sql SELECT column1, aggregate_function(column2) FROM table_name GROUP BY column1; ``` #### **Ključna pravila i ponašanja** 1. **Grupiranje kolona**: - `GROUP BY` klauzula specificira jednu ili više kolona koje definiraju grupe. - Sve neagregirane kolone u `SELECT` klauzuli **mora pojaviti u `GROUP BY` klauzuli** ili biti dio agregatne funkcije. To je poznato kao **GROUP BY proširenje** u MySQL-u (iako nije ANSI SQL kompatibilan prema zadanim postavkama; možete omogućiti strogi način rada da se ovo pravilo poštuje). ```sql -- Valjan u MySQL-u (s GROUP BY proširenjem) SELECT department, employee_name, AVG(salary) FROM employees GROUP BY department; -- Strogi SQL (zahjevava sve neagregirane kolone u GROUP BY) -- Ovo bi zahtijevalo da `employee_name` bude u GROUP BY ili agregirano. ``` 2. **Više kolona u `GROUP BY`**: - Možete grupirati po više kolona kako biste stvorili hijerarhijska grupiranja. Na primjer, grupiranje po `department` i `job_title` će stvoriti grupe za svaku jedinstvenu kombinaciju ovih kolona. ```sql SELECT department, job_title, AVG(salary) FROM employees GROUP BY department, job_title; ``` 3. **Redoslijed operacija**: - `GROUP BY` se obrađuje **nakon** `WHERE` klauzule, ali **prije** `HAVING` klauzule i `ORDER BY`. Protok je: `WHERE` → `GROUP BY` → `HAVING` → `SELECT` → `ORDER BY`. 4. **Rukovanje `NULL` vrijednostima u `GROUP BY`**: - `NULL` vrijednosti se tretiraju kao posebna grupa. Na primjer, ako grupirate po koloni koja sadrži `NULL` vrijednosti, te će retke tvoriti svoju vlastitu grupu. ```sql SELECT status, COUNT(*) FROM orders GROUP BY status; -- Izlaz može uključiti grupu za `NULL` ako kolona `status` ima NULL vrijednosti. ``` 5. **Razmatranja performansi**: - Grupiranje po kolonama koje nisu indeksirane može dovesti do sporije izvršenja upita, posebno na velikim tablicama. Razmotrite dodavanje indeksa na često grupirane kolone. - Izbjegavajte grupiranje po kolonama s niskom kardinalnošću (npr. `gender` kolona s samo dvije vrijednosti) osim ako nije potrebno, jer to može rezultirati mnogim malim grupama i neefikasnostima. --- ### 3. **Klauzula `HAVING`: Filtriranje grupa** Dok `WHERE` klauzula filtrira retke **prije** grupiranja, `HAVING` klauzula filtrira **grupe** nakon što je agregacija izvršena. To je ključno jer `WHERE` ne može reference agregatne funkcije, dok `HAVING` može. #### **Sintaksa** ```sql SELECT column1, aggregate_function(column2) FROM table_name GROUP BY column1 HAVING condition; ``` #### **Ključne razlike između `WHERE` i `HAVING`** | Feature | `WHERE` Clause | `HAVING` Clause | |------------------|----------------|-----------------| | **Svrha** | Filtrira retke prije grupiranja. | Filtrira grupe nakon agregacije. | | **Agregatne funkcije** | Ne može koristiti agregatne funkcije. | Može koristiti agregatne funkcije. | | **Performansa** | Primijenjeno rano u izvršenju upita. | Primijenjeno nakon grupiranja i agregacije. | | **Rukovanje `NULL` vrijednostima** | Isključuje `NULL` vrijednosti osim ako se koristi `IS NULL`. | Tretiranje `NULL` kao nepoznatog u usporedbama (koristite `IS NULL` eksplicitno). | #### **Primjeri** 1. **Filtriranje grupa s `HAVING`**: Pretpostavimo da želite pronaći odjeli s prosječnom plaćom većom od 50.000. ```sql SELECT department, AVG(salary) AS avg_salary FROM employees GROUP BY department HAVING AVG(salary) > 50000; ``` 2. **Kombiniranje `WHERE` i `HAVING`**: - Koristite `WHERE` za filtriranje redaka (npr. samo uključiti aktivne zaposlene). - Koristite `HAVING` za filtriranje grupa (npr. samo uključiti odjele s više od 5 zaposlenih). ```sql SELECT department, COUNT(*) AS employee_count, AVG(salary) AS avg_salary FROM employees WHERE status = 'active' GROUP BY department HAVING COUNT(*) > 5; ``` 3. **Više uvjeta u `HAVING`**: Možete kombinirati uvjete koristeći `AND`, `OR` i `NOT`. ```sql SELECT product_category, SUM(revenue) AS total_revenue FROM sales GROUP BY product_category HAVING SUM(revenue) > 100000 AND product_category LIKE 'E%'; ``` --- ### 4. **Napredne tehnike agregatnih funkcija** Agregatne funkcije se mogu kombinirati s drugim MySQL značajkama za stvaranje moćnih upita. Ispod su neki napredni tehniki: #### **a. Filtriranje s `HAVING` i agregatnim funkcijama** Možete koristiti agregatne funkcije u `HAVING` za filtriranje grupa na temelju složenih uvjeta, kao što su: - Grupe gdje zbroj premašuje prag. - Grupe gdje je prosjek unutar određenog raspona. - Grupe s brojem redaka koji ispunjavaju određene kriterije. ```sql -- Pronađite proizvode s više od 10 narudžbi i prosječnom vrijednosti narudžbe > 50. SELECT product_id, COUNT(*) AS order_count, AVG(order_value) AS avg_order_value FROM orders GROUP BY product_id HAVING COUNT(*) > 10 AND AVG(order_value) > 50; ``` #### **b. Korištenje `GROUP BY` s izrazima** Možete grupirati po izrazima ili funkcijama, ne samo kolonama. Na primjer: - Grupiranje po prvom slovu imena. - Grupiranje po izračunanoj vrijednosti (npr. `YEAR(order_date)`). ```sql -- Grupirajte narudžbe po godini kada su postavljene. SELECT YEAR(order_date) AS order_year, COUNT(*) AS order_count FROM orders GROUP BY YEAR(order_date); -- Grupirajte kupce po prvom slovu prezimena. SELECT SUBSTRING(last_name, 1, 1) AS last_name_initial, COUNT(*) AS customer_count FROM customers GROUP BY SUBSTRING(last_name, 1, 1); ``` #### **c. Kombiniranje agregatnih funkcija** Možete koristiti više agregatnih funkcija u istom upitu za dublji uvid. Na primjer: - Izračunajte i zbroj i prosjek kolone. - Pronađite minimalnu i maksimalnu vrijednost u grupi. ```sql -- Izračunajte ukupnu i prosječnu plaću po odjelu, uz minimalnu i maksimalnu plaću. SELECT department, COUNT(*) AS employee_count, SUM(salary) AS total_salary, AVG(salary) AS avg_salary, MIN(salary) AS min_salary, MAX(salary) AS max_salary FROM employees GROUP BY department; ``` #### **d. Korištenje `GROUP BY` s `JOIN`** Agregatne funkcije mogu se kombinirati s `JOIN` za izvođenje izračuna preko povezanih tablica. Na primjer: - Izračunajte ukupnu prodaju po kategoriji proizvoda, spajajući `orders` i `products`. ```sql SELECT p.category, COUNT(o.order_id) AS order_count, SUM(o.quantity * o.unit_price) AS total_revenue FROM orders o JOIN products p ON o.product_id = p.product_id GROUP BY p.category; ``` #### **e. Sažimanje podataka s `WITH ROLLUP`** MySQL podržava `WITH ROLLUP` modifikator, koji dodaje "super-aggregate" redak u rezultat. To znači: -računa ukupnu vrijednost i prosjek za svaku kategoriju proizvoda, uključujući ukupan redak. ```sql SELECT category, SUM(revenue) AS total_revenue FROM sales GROUP BY category WITH ROLLUP; ``` **Primjer rezultata**: ``` category | total_revenue -----------|-------------- Electronics| 50000 Clothing | 30000 NULL | 80000 -- Super-aggregati (ukupan zbroj) ``` #### **f. Filtriranje grupa s `HAVING` i podupitima** Možete koristiti podupit u `HAVING` za filtriranje grupa na temelju dinamičkih uvjeta. Na primjer: - Pronađite odjele gdje je prosječna plaća viša od prosječne plaće u cijelošću organizacije. ```sql SELECT department, AVG(salary) AS avg_salary FROM employees GROUP BY department HAVING AVG(salary) > ( SELECT AVG(salary) FROM employees ); ``` --- ### 5. **Uobičajene pogreške i najbolje prakse** #### **Pogreške koje treba izbjegavati** 1. **Zaboravljanje uključiti neagregirane kolone u `GROUP BY`**: - MySQL dopušta neagregirane kolone u `SELECT` klauzuli bez uključivanja u `GROUP BY` (zbog GROUP BY proširenja), ali to može dovesti do nejasnih ili pogrešnih rezultata. Uvijek uključite sve neagregirane kolone u `GROUP BY` za jasnoću i ispravnost. ```sql **Pozovnadna znakovna slova dopustiti** **_hint: dodati još čeka kolaža** |nači kolona"filtere za upit" neder ```sql | Category | GROUP BY | HAVING |```

```sql Neaš மத தா ...collumns)

Aggregating Data: GROUP BY, HAVING, and Common Aggregate Functions (COUNT, SUM, AVG, etc.)