8-bo‘lim

Agregat funksiyalar va GROUP BY

COUNT, SUM, AVG, MIN, MAX funksiyalari, guruhlash, HAVING va WHERE farqi, ko'p ustunli guruhlash.

🕑 15 daqiqa o‘qish 📄 608 so‘z 👁 6 marta ko‘rilgan
Ushbu bo‘lim mundarijasi
  1. Agregat funksiyalar
  2. COUNT ning uch shakli
  3. GROUP BY
  4. GROUP_CONCAT
  5. Ko'p ustun bo'yicha guruhlash
  6. HAVING - guruhlarni filtrlash
  7. WITH ROLLUP - yakuniy qator
  8. Amaliy hisobotlar
  9. To'liq so'rov tuzilmasi
  10. Xulosa

Shu paytgacha alohida qatorlar bilan ishladik. Endi guruh bo'yicha xulosa chiqarishni o'rganamiz: "nechta", "jami", "o'rtacha".

Agregat funksiyalar #

FunksiyaVazifasi
COUNT()Qatorlar sonini sanaydi
SUM()Yig'indi
AVG()O'rtacha
MIN()Eng kichik
MAX()Eng katta
GROUP_CONCAT()Qiymatlarni matnga birlashtiradi
SQL
SELECT
    COUNT(*)              AS talabalar_soni,
    AVG(ortacha_baho)     AS ortacha,
    MIN(ortacha_baho)     AS eng_past,
    MAX(ortacha_baho)     AS eng_yuqori,
    SUM(ortacha_baho)     AS yigindi
FROM talabalar;
Natija
+----------------+----------+----------+------------+---------+
| talabalar_soni | ortacha  | eng_past | eng_yuqori | yigindi |
+----------------+----------+----------+------------+---------+
|              8 | 4.144000 |     3.20 |       4.90 |   33.15 |
+----------------+----------+----------+------------+---------+

Butun jadval bitta qatorga siqildi.

COUNT ning uch shakli #

SQL
SELECT
    COUNT(*)                AS barcha_qatorlar,
    COUNT(telefon)          AS telefoni_borlar,
    COUNT(DISTINCT shahar)  AS noyob_shaharlar
FROM talabalar;
Natija
+-----------------+-----------------+-----------------+
| barcha_qatorlar | telefoni_borlar | noyob_shaharlar |
+-----------------+-----------------+-----------------+
|               8 |               6 |               6 |
+-----------------+-----------------+-----------------+
COUNT(*) va COUNT(ustun) farqi
  • COUNT(*) - barcha qatorlarni sanaydi
  • COUNT(ustun) - shu ustunda NULL bo'lmagan qiymatlarni sanaydi

Yuqorida 8 ta talaba bor, lekin 2 tasining telefoni yo'q - shuning uchun COUNT(telefon) 6 ni qaytardi.

Agar shunchaki qatorlarni sanamoqchi bo'lsangiz, har doim COUNT(*) ishlating.

Agregat funksiyalar NULL ni e'tiborsiz qoldiradi
SQL
SELECT AVG(narx) FROM kitoblar;

Agar 10 ta kitobdan 3 tasida narx NULL bo'lsa, o'rtacha 7 ta kitob bo'yicha hisoblanadi, 10 ta emas. Bu odatda to'g'ri xatti-harakat, lekin bilib turish kerak.

NULL ni nol deb hisoblash uchun:

SQL
SELECT AVG(IFNULL(narx, 0)) FROM kitoblar;

GROUP BY #

Endi eng muhim qismi - guruh bo'yicha hisoblash.

SQL
SELECT
    shahar,
    COUNT(*)                     AS talabalar_soni,
    ROUND(AVG(ortacha_baho), 2)  AS ortacha_baho
FROM talabalar
GROUP BY shahar
ORDER BY talabalar_soni DESC;
Natija
+-----------+----------------+--------------+
| shahar    | talabalar_soni | ortacha_baho |
+-----------+----------------+--------------+
| Samarqand |              2 |         4.53 |
| Toshkent  |              2 |         3.50 |
| Andijon   |              1 |         3.50 |
| Buxoro    |              1 |         4.90 |
| Xiva      |              1 |         4.10 |
| Namangan  |              1 |         4.60 |
+-----------+----------------+--------------+
Asl qatorlar Husanboy | Namangan | 4.6 Sardor | Toshkent | 3.8 Malika | Buxoro | 4.9 Bekzod | Toshkent | 3.2 Nodira | Samarqand | 4.3 GROUP BY shahar Guruhlar Samarqand: Nodira(4.3), Kamola(4.75) → 2 ta, o'rtacha 4.45 Toshkent: Sardor(3.8), Bekzod(3.2) → 2 ta, o'rtacha 3.50 Buxoro: Malika(4.9) → 1 ta, o'rtacha 4.90 Har bir guruh natijada BITTA qatorga aylanadi
GROUP BY bir xil qiymatli qatorlarni guruhlab, har biriga agregat qo'llaydi
GROUP BY ning asosiy qoidasi

SELECT da faqat quyidagilar bo'lishi mumkin:

  1. GROUP BY da sanalgan ustunlar
  2. Agregat funksiyalar
SQL
-- XATO: ism qaysi biriniki? Guruhda 2 ta talaba bor
SELECT shahar, ism, COUNT(*)
FROM talabalar
GROUP BY shahar;

-- TO'G'RI
SELECT shahar, COUNT(*)
FROM talabalar
GROUP BY shahar;

-- TO'G'RI: ismlarni birlashtiramiz
SELECT shahar, GROUP_CONCAT(ism) AS talabalar, COUNT(*)
FROM talabalar
GROUP BY shahar;

Qat'iy rejimda (ONLY_FULL_GROUP_BY) MySQL bu xatoni to'g'ridan-to'g'ri beradi.

GROUP_CONCAT #

SQL
SELECT
    shahar,
    COUNT(*) AS soni,
    GROUP_CONCAT(ism ORDER BY ism SEPARATOR ', ') AS talabalar
FROM talabalar
GROUP BY shahar;
Natija
+-----------+------+------------------+
| shahar    | soni | talabalar        |
+-----------+------+------------------+
| Andijon   |    1 | Jasur            |
| Buxoro    |    1 | Malika           |
| Namangan  |    1 | Husanboy         |
| Samarqand |    2 | Kamola, Nodira   |
| Toshkent  |    2 | Bekzod, Sardor   |
| Xiva      |    1 | Aziza            |
+-----------+------+------------------+
GROUP_CONCAT uzunligi cheklangan

Standart chegara - 1024 belgi. Undan uzun natija jimgina kesiladi.

SQL
SET SESSION group_concat_max_len = 1000000;

Ko'p ustun bo'yicha guruhlash #

SQL
SELECT
    shahar,
    guruh_id,
    COUNT(*)                    AS soni,
    ROUND(AVG(ortacha_baho), 2) AS ortacha
FROM talabalar
GROUP BY shahar, guruh_id
ORDER BY shahar, guruh_id;

Endi har bir shahar + guruh kombinatsiyasi alohida qator bo'ladi.

HAVING - guruhlarni filtrlash #

SQL
-- 1 tadan ko'p talabasi bor shaharlar
SELECT shahar, COUNT(*) AS soni
FROM talabalar
GROUP BY shahar
HAVING COUNT(*) > 1;
Natija
+-----------+------+
| shahar    | soni |
+-----------+------+
| Samarqand |    2 |
| Toshkent  |    2 |
+-----------+------+
WHERE va HAVING farqi
WHEREHAVING
QachonGuruhlashdan oldinGuruhlashdan keyin
Nimani filtrlaydiQatorlarniGuruhlarni
Agregat ishlatishMumkin emasMumkin
TaxallusMumkin emasMumkin
SQL
SELECT shahar, AVG(ortacha_baho) AS ortacha
FROM talabalar
WHERE faolmi = TRUE            -- avval: faqat faol talabalar
GROUP BY shahar
HAVING ortacha > 4.0           -- keyin: faqat kuchli shaharlar
ORDER BY ortacha DESC;
Filtrni to'g'ri joyga qo'ying
SQL
-- SEKIN: hammasi guruhlanadi, keyin filtrlanadi
SELECT shahar, COUNT(*) FROM talabalar
GROUP BY shahar
HAVING shahar = 'Toshkent';

-- TEZ: avval filtrlanadi, keyin guruhlanadi
SELECT shahar, COUNT(*) FROM talabalar
WHERE shahar = 'Toshkent'
GROUP BY shahar;

Agar shart agregatga bog'liq bo'lmasa, uni WHERE ga qo'ying.

WITH ROLLUP - yakuniy qator #

SQL
SELECT
    shahar,
    COUNT(*)          AS soni,
    SUM(ortacha_baho) AS yigindi
FROM talabalar
GROUP BY shahar WITH ROLLUP;
Natija
+-----------+------+---------+
| shahar    | soni | yigindi |
+-----------+------+---------+
| Andijon   |    1 |    3.50 |
| Buxoro    |    1 |    4.90 |
| Namangan  |    1 |    4.60 |
| Samarqand |    2 |    9.05 |
| Toshkent  |    2 |    7.00 |
| Xiva      |    1 |    4.10 |
| NULL      |    8 |   33.15 |     <- JAMI
+-----------+------+---------+

Oxirgi qator - umumiy yakun. Hisobotlar uchun juda qulay.

SQL
-- NULL o'rniga "JAMI" yozish
SELECT
    IFNULL(shahar, 'JAMI') AS shahar,
    COUNT(*) AS soni
FROM talabalar
GROUP BY shahar WITH ROLLUP;

Amaliy hisobotlar #

SQL
-- Guruhlar bo'yicha statistika
SELECT
    g.nomi                          AS guruh,
    COUNT(t.id)                     AS talabalar,
    ROUND(AVG(t.ortacha_baho), 2)   AS ortacha,
    MAX(t.ortacha_baho)             AS eng_yuqori,
    MIN(t.ortacha_baho)             AS eng_past
FROM guruhlar g
LEFT JOIN talabalar t ON t.guruh_id = g.id
GROUP BY g.id, g.nomi
ORDER BY ortacha DESC;
SQL
-- Baho darajalari bo'yicha taqsimot
SELECT
    CASE
        WHEN ortacha_baho >= 4.5 THEN 'A''lo (4.5+)'
        WHEN ortacha_baho >= 3.5 THEN 'Yaxshi (3.5-4.5)'
        ELSE 'Qoniqarli (3.5 gacha)'
    END                             AS daraja,
    COUNT(*)                        AS soni,
    ROUND(COUNT(*) * 100.0 / (SELECT COUNT(*) FROM talabalar), 1) AS foiz
FROM talabalar
GROUP BY daraja
ORDER BY soni DESC;
Natija
+-----------------------+------+------+
| daraja                | soni | foiz |
+-----------------------+------+------+
| Yaxshi (3.5-4.5)      |    4 | 50.0 |
| A'lo (4.5+)           |    3 | 37.5 |
| Qoniqarli (3.5 gacha) |    1 | 12.5 |
+-----------------------+------+------+
SQL
-- Oylik savdo hisoboti
SELECT
    DATE_FORMAT(yaratilgan, '%Y-%m')  AS oy,
    COUNT(*)                          AS buyurtmalar,
    SUM(summa)                        AS jami_savdo,
    ROUND(AVG(summa))                 AS ortacha_chek,
    MAX(summa)                        AS eng_katta_chek
FROM buyurtmalar
WHERE yaratilgan >= '2026-01-01'
GROUP BY oy
ORDER BY oy;
SQL
-- Shartli sanash - juda foydali naqsh
SELECT
    shahar,
    COUNT(*)                                        AS jami,
    SUM(CASE WHEN ortacha_baho >= 4.5 THEN 1 ELSE 0 END) AS alochilar,
    SUM(CASE WHEN faolmi = FALSE THEN 1 ELSE 0 END)      AS nofaollar,
    SUM(telefon IS NOT NULL)                        AS telefoni_borlar
FROM talabalar
GROUP BY shahar;
SUM(CASE WHEN ...) naqshi

Bu bitta so'rovda bir nechta shartli hisob-kitob qilish imkonini beradi - har bir shart uchun alohida so'rov yozish shart emas.

MySQL da yanada qisqa yozish mumkin, chunki mantiqiy ifoda 1 yoki 0 qaytaradi:

SQL
SUM(ortacha_baho >= 4.5)     -- SUM(CASE WHEN ... THEN 1 ELSE 0 END) bilan bir xil

To'liq so'rov tuzilmasi #

SQL
SELECT   shahar, COUNT(*) AS soni, AVG(ortacha_baho) AS ortacha
FROM     talabalar                    -- 1. qaysi jadval
WHERE    faolmi = TRUE                -- 2. qaysi qatorlar
GROUP BY shahar                       -- 3. qanday guruhlash
HAVING   COUNT(*) >= 2                -- 4. qaysi guruhlar
ORDER BY ortacha DESC                 -- 5. qanday saralash
LIMIT    10;                          -- 6. nechta
Amaliy topshiriq

kutubxona bazasida hisobotlar yozing:

  1. Jami kitoblar soni, o'rtacha narx va eng qimmat kitob narxi.
  2. Janrlar bo'yicha: har bir janrda nechta kitob va o'rtacha narxi.
  3. Har bir muallifning nechta kitobi borligi (GROUP BY muallif_id).
  4. Faqat 3 tadan ko'p kitobi bor mualliflar (HAVING).
  5. O'n yilliklar bo'yicha taqsimot (FLOOR(yil / 10) * 10).
  6. GROUP_CONCAT bilan har bir janrdagi kitob nomlarini bitta qatorda chiqaring.
  7. WITH ROLLUP bilan yakuniy qator qo'shing.
  8. SUM(CASE WHEN ...) bilan har bir janrda nechta qimmat (100 000+) kitob borligini sanang.

Xulosa #

  • Agregat funksiyalar: COUNT, SUM, AVG, MIN, MAX, GROUP_CONCAT.
  • COUNT(*) barcha qatorlarni, COUNT(ustun) esa NULL bo'lmaganlarni sanaydi.
  • Agregat funksiyalar NULL ni e'tiborsiz qoldiradi.
  • GROUP BY bir xil qiymatli qatorlarni birlashtiradi; har bir guruh bitta qator bo'ladi.
  • SELECT da faqat guruhlangan ustunlar va agregatlar bo'lishi mumkin.
  • WHERE qatorlarni, HAVING guruhlarni filtrlaydi.
  • Shart agregatga bog'liq bo'lmasa - uni WHERE ga qo'ying (tezroq).
  • SUM(CASE WHEN ...) bir so'rovda bir nechta shartli hisobni beradi.

Keyingi bo'limda ma'lumotni o'zgartirish va o'chirishni o'rganamiz.

Xatolik topdingizmi?

Imlo xatosi, ishlamaydigan kod yoki noto‘g‘ri ma‘lumotni ko‘rsangiz - bizga xabar bering. Har bir xabar administrator tomonidan ko‘rib chiqiladi.