5-bo‘lim

SELECT asoslari

Ustun tanlash, taxalluslar, hisoblangan ustunlar, DISTINCT, LIMIT va so'rov bajarilish tartibi.

🕑 14 daqiqa o‘qish 📄 579 so‘z 👁 6 marta ko‘rilgan
Ushbu bo‘lim mundarijasi
  1. Eng oddiy so'rov
  2. Taxalluslar (AS)
  3. Hisoblangan ustunlar
  4. DISTINCT - takrorlarni olib tashlash
  5. LIMIT - natijani cheklash
  6. LIMIT ni har doim ishlatish odati
  7. So'rov bajarilish tartibi
  8. Jadvalsiz SELECT
  9. Amaliy misol
  10. Xulosa

SELECT - SQL dagi eng muhim buyruq. Ish vaqtingizning katta qismi shu bilan o'tadi.

Eng oddiy so'rov #

SQL
-- Barcha ustunlar
SELECT * FROM talabalar;

-- Aniq ustunlar
SELECT ism, familiya, shahar FROM talabalar;
Natija
+----------+----------+-----------+
| ism      | familiya | shahar    |
+----------+----------+-----------+
| Husanboy | Qodirov  | Namangan  |
| Sardor   | Aliyev   | Toshkent  |
| Aziza    | Tosheva  | Xiva      |
| Malika   | Yusupova | Buxoro    |
+----------+----------+-----------+
SELECT * ni ishlab chiqarishda ishlatmang

SELECT * o'rganish va tez tekshirish uchun qulay, lekin real kodda muammoli:

MuammoIzoh
Ortiqcha ma'lumotKerakmas ustunlar tarmoq orqali uzatiladi
Indeks ishlamaydi"Faqat indeksdan o'qish" optimizatsiyasi yo'qoladi
Kod sinishiUstun qo'shilsa yoki tartibi o'zgarsa
NoaniqlikQaysi ustunlar kerakligi ko'rinmaydi

Har doim kerakli ustunlarni sanang.

Taxalluslar (AS) #

SQL
SELECT
    ism        AS "Ism",
    familiya   AS "Familiya",
    ortacha_baho AS "O'rtacha baho"
FROM talabalar;

-- AS ni tushirib qoldirish mumkin
SELECT ism "Ism", familiya "Familiya" FROM talabalar;

-- Jadval uchun ham
SELECT t.ism, t.familiya
FROM talabalar AS t;
Natija
+----------+----------+---------------+
| Ism      | Familiya | O'rtacha baho |
+----------+----------+---------------+
| Husanboy | Qodirov  |          4.60 |
| Sardor   | Aliyev   |          3.80 |
+----------+----------+---------------+
Jadval taxalluslari

Uzun so'rovlarda jadval taxalluslari kodni ancha qisqartiradi:

SQL
SELECT t.ism, g.nomi
FROM talabalar AS t
JOIN guruhlar  AS g ON g.id = t.guruh_id;

Taxallus qisqa va ma'noli bo'lsin: t (talabalar), g (guruhlar). a, b, c kabi harflar keyinroq chalkashtiradi.

Hisoblangan ustunlar #

SQL
SELECT
    ism,
    familiya,
    CONCAT(ism, ' ', familiya)                  AS toliq_ism,
    ortacha_baho,
    ROUND(ortacha_baho * 20)                    AS foizda,
    YEAR(CURDATE()) - YEAR(tugilgan_sana)       AS yosh
FROM talabalar;
Natija
+----------+----------+------------------+--------------+--------+------+
| ism      | familiya | toliq_ism        | ortacha_baho | foizda | yosh |
+----------+----------+------------------+--------------+--------+------+
| Husanboy | Qodirov  | Husanboy Qodirov |         4.60 |     92 |   25 |
| Sardor   | Aliyev   | Sardor Aliyev    |         3.80 |     76 |   25 |
+----------+----------+------------------+--------------+--------+------+

Arifmetik amallar:

SQL
SELECT
    nomi,
    narx,
    soni,
    narx * soni                     AS jami,
    narx * 0.12                     AS qqs,
    narx * soni * 1.12              AS qqs_bilan,
    ROUND(narx * 0.9)               AS chegirmali
FROM mahsulotlar;

DISTINCT - takrorlarni olib tashlash #

SQL
-- Barcha shaharlar (takrorlar bilan)
SELECT shahar FROM talabalar;

-- Noyob shaharlar
SELECT DISTINCT shahar FROM talabalar;

-- Bir nechta ustun bo'yicha noyob juftliklar
SELECT DISTINCT shahar, guruh_id FROM talabalar;
Natija
+-----------+
| shahar    |
+-----------+
| Namangan  |
| Toshkent  |
| Xiva      |
| Buxoro    |
| Samarqand |
| Andijon   |
+-----------+
DISTINCT butun qatorga ta'sir qiladi
SQL
-- Bu "faqat shahar noyob" degani EMAS
SELECT DISTINCT shahar, ism FROM talabalar;

DISTINCT barcha tanlangan ustunlar kombinatsiyasini noyob qiladi. Ism har xil bo'lgani uchun natijada deyarli barcha qatorlar qoladi.

Bitta ustun bo'yicha guruhlash kerak bo'lsa - GROUP BY ishlating (8-bo'lim).

LIMIT - natijani cheklash #

SQL
-- Faqat 5 ta qator
SELECT ism, ortacha_baho FROM talabalar LIMIT 5;

-- 10-qatordan boshlab 5 ta (sahifalash uchun)
SELECT ism FROM talabalar LIMIT 5 OFFSET 10;

-- Qisqa yozuv: LIMIT offset, soni
SELECT ism FROM talabalar LIMIT 10, 5;
Sahifalash formulasi
SQL
-- N-sahifa, har sahifada 20 ta yozuv
LIMIT 20 OFFSET (N - 1) * 20
SahifaSo'rov
1LIMIT 20 OFFSET 0
2LIMIT 20 OFFSET 20
3LIMIT 20 OFFSET 40

Ushbu saytdagi admin panelidagi sahifalash ham aynan shunday ishlaydi.

Katta OFFSET sekin ishlaydi
SQL
SELECT * FROM talabalar LIMIT 20 OFFSET 500000;

Baza 500 020 ta qatorni o'qib, birinchi 500 000 tasini tashlab yuboradi.

Katta jadvallarda "kursor" usuli tezroq:

SQL
SELECT * FROM talabalar WHERE id > 500000 ORDER BY id LIMIT 20;

LIMIT ni har doim ishlatish odati #

SQL
-- Xavfli: 10 million qator qaytishi mumkin
SELECT * FROM loglar;

-- Xavfsiz
SELECT * FROM loglar LIMIT 100;
Konsolda ishlaganda

Notanish jadvalni tekshirayotganda har doim LIMIT qo'ying. Aks holda milliondan ortiq qator ekranga oqib, terminalni bloklaydi.

So'rov bajarilish tartibi #

Bu SQL ni tushunishning kaliti. So'rov yozilgan tartibda emas, boshqacha bajariladi:

Yozilish tartibi Bajarilish tartibi 1. SELECT 2. FROM 3. WHERE 4. GROUP BY 5. HAVING 6. ORDER BY 7. LIMIT 1. FROM 2. WHERE 3. GROUP BY 4. HAVING 5. SELECT 6. ORDER BY 7. LIMIT SELECT deyarli oxirida bajariladi - shundan ko'p qoidalar kelib chiqadi
SELECT beshinchi bo'lib bajariladi - WHERE dan keyin

Bundan ikkita muhim natija kelib chiqadi:

SQL
-- ISHLAMAYDI: WHERE bajarilganda taxallus hali yo'q
SELECT ortacha_baho * 20 AS foizda
FROM talabalar
WHERE foizda > 80;
Natija
ERROR 1054 (42S22): Unknown column 'foizda' in 'where clause'
SQL
-- ISHLAYDI: ORDER BY SELECT dan keyin bajariladi
SELECT ortacha_baho * 20 AS foizda
FROM talabalar
ORDER BY foizda DESC;

-- WHERE da to'liq ifodani takrorlash kerak
SELECT ortacha_baho * 20 AS foizda
FROM talabalar
WHERE ortacha_baho * 20 > 80;
Bu qoidani eslab qolish
Bo'limTaxallus ishlatish mumkinmi
WHEREYo'q
GROUP BYHa (MySQL da)
HAVINGHa
ORDER BYHa

Sabab oddiy: WHERE SELECT dan oldin ishlaydi, ORDER BY esa keyin.

Jadvalsiz SELECT #

Hisob-kitob va sinov uchun:

SQL
SELECT 2 + 3 AS yigindi;
SELECT NOW() AS hozir;
SELECT CURDATE() AS bugun;
SELECT UPPER('salom') AS katta_harf;
SELECT ROUND(3.14159, 2) AS yaxlitlangan;
SELECT CONCAT('Salom, ', 'Husanboy', '!') AS xabar;
Natija
+------------------+
| xabar            |
+------------------+
| Salom, Husanboy! |
+------------------+

Amaliy misol #

SQL
SELECT
    CONCAT(ism, ' ', familiya)              AS talaba,
    shahar,
    ortacha_baho,
    ROUND(ortacha_baho * 20)                AS ball_100,
    CASE
        WHEN ortacha_baho >= 4.5 THEN 'A''lo'
        WHEN ortacha_baho >= 3.5 THEN 'Yaxshi'
        WHEN ortacha_baho >= 3.0 THEN 'Qoniqarli'
        ELSE 'Qoniqarsiz'
    END                                      AS daraja,
    TIMESTAMPDIFF(YEAR, tugilgan_sana, CURDATE()) AS yosh
FROM talabalar
ORDER BY ortacha_baho DESC
LIMIT 5;
Natija
+------------------+-----------+--------------+----------+--------+------+
| talaba           | shahar    | ortacha_baho | ball_100 | daraja | yosh |
+------------------+-----------+--------------+----------+--------+------+
| Malika Yusupova  | Buxoro    |         4.90 |       98 | A'lo   |   21 |
| Kamola Ergasheva | Samarqand |         4.75 |       95 | A'lo   |   20 |
| Husanboy Qodirov | Namangan  |         4.60 |       92 | A'lo   |   25 |
| Nodira Sobirova  | Samarqand |         4.30 |       86 | Yaxshi |   24 |
| Aziza Tosheva    | Xiva      |         4.10 |       82 | Yaxshi |   22 |
+------------------+-----------+--------------+----------+--------+------+
CASE - SQL dagi shart operatori
SQL
CASE
    WHEN shart1 THEN natija1
    WHEN shart2 THEN natija2
    ELSE standart
END

U Python dagi if/elif/else ning analogi. Hisobotlarda juda ko'p ishlatiladi.

Amaliy topshiriq

kutubxona bazangizda:

  1. Barcha kitoblarning faqat nomi va yil ustunlarini chiqaring.
  2. Ustunlarga o'zbekcha taxallus bering.
  3. CONCAT bilan "Kitob nomi (yil)" ko'rinishidagi ustun hosil qiling.
  4. Kitob narxining 20% chegirmali qiymatini hisoblang.
  5. DISTINCT bilan noyob janrlar ro'yxatini chiqaring.
  6. LIMIT bilan faqat birinchi 3 ta kitobni oling.
  7. CASE bilan kitoblarni sahifalar soniga qarab "qisqa / o'rta / uzun" deb belgilang.
  8. WHERE da taxallus ishlatib ko'ring va chiqqan xatoni tushuntiring.

Xulosa #

  • SELECT ustunlar FROM jadval; - asosiy shakl.
  • SELECT * ni ishlab chiqarishda ishlatmang - kerakli ustunlarni sanang.
  • AS bilan ustun va jadvallarga taxallus beriladi.
  • Hisoblangan ustunlar (narx * soni) to'g'ridan-to'g'ri so'rovda yaratiladi.
  • DISTINCT barcha tanlangan ustunlar kombinatsiyasini noyob qiladi.
  • LIMIT ... OFFSET sahifalash uchun; katta OFFSET sekin ishlaydi.
  • SELECT beshinchi bo'lib bajariladi - shuning uchun WHERE da taxallus ishlamaydi, ORDER BY da esa ishlaydi.
  • CASE ... WHEN - SQL dagi shart operatori.

Keyingi bo'limda WHERE bilan ma'lumotni filtrlashni 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.