Cum să folosești funcții de agregare SQL — COUNT, SUM, AVG, GROUP BY, HAVING

In this tutorial, you'll learn about Cum să folosești funcții de agregare SQL. We cover key concepts, practical examples, and best practices.

Cum să folosești funcții de agregare SQL (COUNT, SUM, AVG, MAX, MIN) împreună cu GROUP BY și HAVING pentru a analiza și rezuma date din tabele relaționale.

Problema

Datele brute dintr-o tabelă nu oferă informații agregate — de exemplu, "câte comenzi sunt per client" sau "care este totalul vânzărilor pe lună". Fără funcții de agregare, dezvoltătorii extrag toate rândurile și le procesează în aplicație, ceea ce este ineficient.

The Wrong Way

Procesarea agregărilor în codul aplicației în loc de SQL:

# Python: extrage toate comenzile și calculează manual
rows = db.execute("SELECT customer_id, total FROM orders")
totals = {}
for row in rows:
    totals[row['customer_id']] = totals.get(row['customer_id'], 0) + row['total']

Problema: Transferi toate datele prin rețea și consumi CPU în aplicație pentru o operație pe care baza de date o face mult mai eficient.

The Right Way

Folosește funcțiile de agregare direct în SQL:

SELECT customer_id,
       COUNT(*) AS numar_comenzi,
       SUM(total) AS total_cheltuit,
       AVG(total) AS medie_comanda,
       MAX(total) AS comanda_maxima,
       MIN(total) AS comanda_minima
FROM orders
GROUP BY customer_id;

Output:

 customer_id | numar_comenzi | total_cheltuit | medie_comanda | comanda_maxima | comanda_minima
-------------+---------------+----------------+---------------+----------------+----------------
           1 |             5 |        4500.00 |        900.00 |        1500.00 |         200.00
           2 |             3 |        1200.00 |        400.00 |         600.00 |         150.00

Step-by-Step Fix

1. Folosește COUNT pentru numărare

-- Numără totalul comenzilor
SELECT COUNT(*) FROM orders;

-- Numără valorile non-NULL
SELECT COUNT(shipped_date) FROM orders;  -- exclude NULL-uri

-- Numără distinct
SELECT COUNT(DISTINCT customer_id) FROM orders;

2. Folosește SUM și AVG pentru valori numerice

SELECT SUM(total) AS venit_total,
       AVG(total) AS valoare_medie,
       ROUND(AVG(total), 2) AS medie_rotunjita
FROM orders
WHERE created_at >= '2024-01-01';

3. Adaugă GROUP BY pentru grupări

Grupează după una sau mai multe coloane:

SELECT department_id,
       COUNT(*) AS nr_angajati,
       AVG(salary) AS salariu_mediu
FROM employees
GROUP BY department_id;

4. Filtrează grupările cu HAVING

HAVING este ca WHERE, dar pentru grupuri (se aplică după GROUP BY):

SELECT department_id,
       COUNT(*) AS nr_angajati,
       AVG(salary) AS salariu_mediu
FROM employees
GROUP BY department_id
HAVING COUNT(*) > 5    -- doar departamentele cu peste 5 angajați
   AND AVG(salary) > 50000;

Prevention Tips

• Toate coloanele din SELECT care nu sunt agregate trebuie să fie în GROUP BY
• WHERE filtrează înainte de gruparea, HAVING după
• COUNT(*) numără toate rândurile; COUNT(col) numără doar cele non-NULL
• Folosește DISTINCT în interiorul funcțiilor de agregare când ai nevoie

Greșeli comune cu agregări

1. Coloane în SELECT fără GROUP BY sau agregare — eroare SQL în modul strict
2. WHERE pe coloane agregate — folosește HAVING în loc de WHERE
3. COUNT(col) în loc de COUNT(*) — coloanele NULL sunt excluse din numărare
4. GROUP BY pe coloane cu multe valori unice — rezultate cu multe grupuri mici
5. HAVING fără GROUP BY — posibil dar aproape întotdeauna greșit

Exercițiu practic

Scrie o interogare care afișează numărul de comenzi, valoarea totală și valoarea medie per lună pentru anul 2024, filtrând doar lunile cu peste 10 comenzi.

Soluție:

SELECT EXTRACT(MONTH FROM created_at) AS luna,
       COUNT(*) AS nr_comenzi,
       SUM(total) AS total_vanzari,
       AVG(total) AS medie_comanda
FROM orders
WHERE EXTRACT(YEAR FROM created_at) = 2024
GROUP BY EXTRACT(MONTH FROM created_at)
HAVING COUNT(*) > 10
ORDER BY luna;

FAQ

Construit de dezvoltătorii Doda Browser, DodaZIP și Durga Antivirus Pro. Uneltele DodaTech se integrează nativ cu bazele de date pentru productivitate și securitate sporite.