SQL từ cơ bản đến nâng cao
Trang chủ / Module 2
🔎 Module 2 / 16 · 4-5 giờ

SELECT, WHERE, ORDER BY và thế giới của NULL

Đọc và lọc dữ liệu thành thạo: toán tử, LIKE, IN, BETWEEN, sắp xếp, phân trang và đặc biệt là NULL với logic ba trị — nguồn gốc của rất nhiều bug 'âm thầm'.

SELECTWHERENULLLIMIT
📌 Vì sao module này quan trọng

Mọi truy vấn phức tạp sau này đều được dựng từ những viên gạch này. Điều nguy hiểm là các lỗi ở tầng này không báo lỗi: WHERE x = NULL chạy êm nhưng trả 0 dòng, NOT IN gặp một NULL làm cả kết quả rỗng, BETWEEN trên timestamp bỏ sót cả ngày cuối. Học kỹ ở đây giúp bạn không bao giờ báo cáo sai số liệu cho sếp.

🎯 Mục tiêu học tập

  • Viết WHERE với AND/OR/NOT, IN, BETWEEN, LIKE/ILIKE và hiểu độ ưu tiên toán tử
  • Hiểu logic ba trị (TRUE/FALSE/UNKNOWN) và xử lý NULL đúng với IS NULL, IS DISTINCT FROM, COALESCE
  • Sắp xếp đa cột, kiểm soát NULLS FIRST/LAST, phân trang đúng cách (và biết vì sao OFFSET lớn là xấu)
  • Dùng DISTINCT và DISTINCT ON để loại trùng / lấy dòng đầu mỗi nhóm

SELECT: chọn cột, biểu thức, alias

SELECT không chỉ chọn cột — nó tính biểu thức trên từng dòng. Alias (AS) đặt tên cho cột kết quả; nên luôn dùng AS tường minh để dễ đọc.

SELECT name,
       price,
       cost,
       price - cost              AS loi_nhuan_don_vi,
       round((price - cost) / price * 100, 1) AS bien_loi_nhuan_pct
FROM products
WHERE category_id = 4
ORDER BY bien_loi_nhuan_pct DESC;
Kết quả
          name          |    price    |    cost     | loi_nhuan_don_vi | bien_loi_nhuan_pct
------------------------+-------------+-------------+------------------+--------------------
 Điện thoại Aurora Lite |  6490000.00 |  4700000.00 |       1790000.00 |               27.6
 Điện thoại Aurora X1   | 12990000.00 |  9800000.00 |       3190000.00 |               24.6
 Điện thoại Nova Pro    | 18990000.00 | 14500000.00 |       4490000.00 |               23.6
(3 rows)
SELECT 7 / 2 AS chia_nguyen, 7 / 2.0 AS chia_thuc, 7 % 2 AS du, 2 ^ 10 AS luy_thua, 'ab' || 'cd' AS noi_chuoi;
Kết quả
 chia_nguyen |     chia_thuc      | du | luy_thua | noi_chuoi
-------------+--------------------+----+----------+-----------
           3 | 3.5000000000000000 |  1 |     1024 | abcd
(1 row)
❌ Lỗi thường gặp — Chia hai số nguyên

7 / 2 cho 3, không phải 3.5: với hai integer, PostgreSQL chia nguyên (cắt phần thập phân). Lỗi này làm sai tỉ lệ, phần trăm mà không báo gì. Hãy ép kiểu: 7 / 2.0, 7::numeric / 2 hoặc nhân 1.0 * trước.

WHERE: lọc dòng

Toán tửÝ nghĩaVí dụ
= <> != < <= > >=So sánh (<> là chuẩn, != cũng chạy)status <> 'cancelled'
AND OR NOTLogicprice > 1e6 AND is_active
IN (...)Thuộc tập giá trịcity IN ('Hà Nội','Đà Nẵng')
BETWEEN a AND bTrong đoạn đóng [a, b]price BETWEEN 1e6 AND 5e6
LIKE / ILIKEKhớp mẫu (% nhiều ký tự, _ một ký tự); ILIKE không phân biệt hoa/thường (chỉ PostgreSQL)name ILIKE '%laptop%'
IS NULL / IS NOT NULLKiểm tra NULLcity IS NULL
SELECT id, name, price
FROM products
WHERE is_active
  AND category_id IN (4, 5)
  AND price BETWEEN 10000000 AND 25000000
ORDER BY price;
Kết quả
 id |         name         |    price
----+----------------------+-------------
  6 | Laptop Student 15    | 11900000.00
  1 | Điện thoại Aurora X1 | 12990000.00
  3 | Điện thoại Nova Pro  | 18990000.00
  4 | Laptop Zenbook 14    | 22500000.00
(4 rows)
SELECT id, name FROM products WHERE name ILIKE '%không dây%';
Kết quả
 id |          name
----+-------------------------
  7 | Tai nghe không dây Echo
 10 | Chuột không dây
(2 rows)
❌ Lỗi thường gặp — Quên ngoặc khi trộn AND và OR

AND có độ ưu tiên cao hơn OR. Câu WHERE city = 'Hà Nội' OR city = 'TP.HCM' AND created_at > '2024-03-01' được hiểu là Hà Nội (mọi ngày) HOẶC (TP.HCM và sau 1/3) — thường không phải ý bạn. Luôn thêm ngoặc khi có cả AND lẫn OR, hoặc dùng IN.

-- Ý định: khách Hà Nội hoặc TP.HCM, tạo sau 2024-03-01
SELECT count(*) AS sai
FROM customers
WHERE city = 'Hà Nội' OR city = 'TP.HCM' AND created_at > '2024-03-01';
Kết quả
 sai
-----
  19
(1 row)
SELECT count(*) AS dung
FROM customers
WHERE city IN ('Hà Nội', 'TP.HCM') AND created_at > '2024-03-01';
Kết quả
 dung
------
   16
(1 row)
❌ Lỗi thường gặp — BETWEEN với timestamp bỏ sót cả ngày cuối

BETWEEN '2024-03-01' AND '2024-03-31' trên cột timestamptz hiểu là đến 2024-03-31 00:00:00 — mất toàn bộ đơn từ 00:00:01 ngày 31. Chuẩn chuyên gia: khoảng nửa mở >= đầu_kỳ AND < đầu_kỳ_sau. Cách này đúng với mọi độ chính xác thời gian và ghép nối được các kỳ liên tiếp không chồng lấn, không hở.

SELECT count(*) AS sai_bo_sot_ngay_cuoi
FROM orders WHERE ordered_at BETWEEN '2024-03-01' AND '2024-03-31';
Kết quả
 sai_bo_sot_ngay_cuoi
----------------------
                   36
(1 row)
SELECT count(*) AS dung
FROM orders WHERE ordered_at >= '2024-03-01' AND ordered_at < '2024-04-01';
Kết quả
 dung
------
   38
(1 row)

NULL — logic ba trị (phần dễ gây bug nhất)

NULL không phải 0, không phải chuỗi rỗng — nó nghĩa là "không biết/chưa có giá trị". Mọi phép so sánh với NULL cho kết quả UNKNOWN (không phải TRUE hay FALSE), và WHERE chỉ giữ dòng có điều kiện là TRUE — nên dòng UNKNOWN bị loại im lặng.

SELECT NULL = NULL    AS bang_null,
       NULL <> 1      AS khac_1,
       NULL IS NULL   AS is_null,
       1 + NULL       AS cong_null,
       'a' || NULL    AS noi_chuoi_null,
       true AND NULL  AS true_and_null,
       false AND NULL AS false_and_null,
       true OR NULL   AS true_or_null;
Kết quả
 bang_null | khac_1 | is_null | cong_null | noi_chuoi_null | true_and_null | false_and_null | true_or_null
-----------+--------+---------+-----------+----------------+---------------+----------------+--------------
 NULL      | NULL   | t       |      NULL | NULL           | NULL          | f              | t
(1 row)
Bài toánSai ❌Đúng ✅
Tìm dòng không có thành phốcity = NULL (luôn 0 dòng)city IS NULL
Khác 'Hà Nội' kể cả NULLcity <> 'Hà Nội' (loại cả NULL)city IS DISTINCT FROM 'Hà Nội'
Thay NULL bằng mặc địnhif/else ở code ứng dụngCOALESCE(city, 'Chưa rõ')
Tránh chia cho 0a / ba / NULLIF(b, 0)
SELECT
  count(*)                                          AS tong,
  count(*) FILTER (WHERE city = 'Hà Nội')           AS ha_noi,
  count(*) FILTER (WHERE city <> 'Hà Nội')          AS khac_ha_noi_bo_null,
  count(*) FILTER (WHERE city IS DISTINCT FROM 'Hà Nội') AS khac_ha_noi_dung,
  count(*) FILTER (WHERE city IS NULL)              AS null_city
FROM customers;
Kết quả
 tong | ha_noi | khac_ha_noi_bo_null | khac_ha_noi_dung | null_city
------+--------+---------------------+------------------+-----------
   60 |     12 |                  44 |               48 |         4
(1 row)

Kiểm tra: 12 (Hà Nội) + 44 (khác Hà Nội, không tính NULL) + 4 (NULL) = 60. Câu city <> 'Hà Nội' âm thầm làm rơi 4 khách chưa có thành phố; còn IS DISTINCT FROM trả đủ 48.

❌ Lỗi thường gặp — NOT IN gặp NULL — cả kết quả biến mất

x NOT IN (1, 2, NULL) bằng x <> 1 AND x <> 2 AND x <> NULL → luôn UNKNOWN/FALSE → trả 0 dòng. Đây là lỗi kinh điển khi subquery của NOT IN có thể trả về NULL. Dùng NOT EXISTS (module 6) — an toàn với NULL.

SELECT count(*) AS ket_qua_mong_doi_khac_0
FROM customers
WHERE id NOT IN (1, 2, NULL);
Kết quả
 ket_qua_mong_doi_khac_0
-------------------------
                       0
(1 row)
🧠 Cách chuyên gia — Cột có nên cho phép NULL?

Chuyên gia đặt NOT NULL làm mặc định khi thiết kế bảng và chỉ cho NULL khi nó có nghĩa nghiệp vụ rõ ràng ("chưa giao" → shipped_at NULL). Mỗi cột nullable là một chỗ ba trị ẩn nấp trong mọi truy vấn về sau. Đừng dùng giá trị "ma" như 0, '' hay '1900-01-01' thay cho NULL — chúng làm hỏng AVG, MIN, khoảng thời gian.

ORDER BY, LIMIT, OFFSET — và vì sao phân trang hay sai

Không có ORDER BY, thứ tự dòng trả về là không được đảm bảo (thường là thứ tự lưu trữ nhưng đổi sau UPDATE, VACUUM, hay khi planner đổi kế hoạch). Mọi LIMIT không kèm ORDER BY đều là bug tiềm ẩn.

SELECT id, full_name, city
FROM customers
ORDER BY city NULLS LAST, id DESC
LIMIT 6;
Kết quả
 id |   full_name   |  city
----+---------------+---------
 58 | Lê Thu Hà     | Cần Thơ
 53 | Vũ Đức Phúc   | Cần Thơ
 48 | Nguyễn Thu Hà | Cần Thơ
 43 | Phạm Đức Phúc | Cần Thơ
 38 | Đặng Thu Hà   | Cần Thơ
 33 | Trần Đức Phúc | Cần Thơ
(6 rows)

Mặc định PostgreSQL xếp NULL cuối khi ASC và đầu khi DESC — kiểm soát tường minh bằng NULLS FIRST/LAST. Có thể ORDER BY theo alias, biểu thức hay số thứ tự cột (ORDER BY 2 — tiện trong psql nhưng đừng dùng trong code).

Phân trang kiểu OFFSET dễ dùng nhưng có hai vấn đề: (1) OFFSET 100000 buộc DB đọc rồi bỏ 100.000 dòng → chậm dần theo số trang; (2) nếu có dòng được thêm/xoá giữa hai lần tải, người dùng thấy dòng bị lặp hoặc sót. Cách chuyên gia: keyset pagination — nhớ giá trị cuối trang trước:

-- Trang 1
SELECT id, ordered_at FROM orders ORDER BY ordered_at, id LIMIT 3;
Kết quả
 id  |       ordered_at
-----+------------------------
 371 | 2024-01-24 01:00:00+07
   1 | 2024-02-01 03:00:00+07
  63 | 2024-02-02 21:00:00+07
(3 rows)
-- Trang 2: truyền (ordered_at, id) của dòng cuối trang 1 (đơn 63) — so sánh theo cặp (row value)
SELECT id, ordered_at
FROM orders
WHERE (ordered_at, id) > ('2024-02-02 21:00:00+07', 63)
ORDER BY ordered_at, id
LIMIT 3;
Kết quả
 id  |       ordered_at
-----+------------------------
 170 | 2024-02-04 03:00:00+07
 224 | 2024-02-04 09:00:00+07
 355 | 2024-02-05 17:00:00+07
(3 rows)
❌ Lỗi thường gặp — ORDER BY không đủ để xác định thứ tự duy nhất

Sắp theo cột có giá trị trùng (ordered_at trùng, city trùng) rồi LIMIT/OFFSET → thứ tự giữa các dòng trùng không ổn định, trang 1 và trang 2 có thể lặp dòng. Luôn thêm cột duy nhất (thường là id) làm tiêu chí cuối — gọi là tie-breaker.

-- Chuẩn SQL: FETCH FIRST (PostgreSQL, Oracle, DB2); MySQL dùng LIMIT; SQL Server dùng TOP / OFFSET-FETCH
SELECT id, name FROM products ORDER BY price DESC FETCH FIRST 3 ROWS ONLY;
Kết quả
 id |         name
----+-----------------------
  5 | Laptop Zenbook 16 Pro
  4 | Laptop Zenbook 14
  3 | Điện thoại Nova Pro
(3 rows)

DISTINCT và DISTINCT ON

DISTINCT loại dòng trùng toàn bộ cột được chọn. DISTINCT ON (cột) là đặc sản PostgreSQL: giữ dòng đầu tiên của mỗi nhóm theo thứ tự ORDER BY — cách ngắn nhất để "lấy bản ghi mới nhất của mỗi khách".

SELECT DISTINCT city FROM customers ORDER BY city;
Kết quả
   city
-----------
 Cần Thơ
 Đà Nẵng
 Hà Nội
 Hải Phòng
 TP.HCM
 NULL
(6 rows)
-- Đơn gần nhất của mỗi khách (5 khách đầu)
SELECT DISTINCT ON (customer_id) customer_id, id AS order_id, ordered_at
FROM orders
ORDER BY customer_id, ordered_at DESC
LIMIT 5;
Kết quả
 customer_id | order_id |       ordered_at
-------------+----------+------------------------
           1 |      108 | 2024-06-11 13:00:00+07
           2 |      247 | 2024-05-29 21:00:00+07
           3 |      332 | 2024-05-17 21:00:00+07
           4 |       39 | 2024-06-18 21:00:00+07
           5 |       16 | 2024-06-27 09:00:00+07
(5 rows)
❌ Lỗi thường gặp — Dùng DISTINCT để 'chữa' kết quả bị nhân đôi

Khi JOIN ra nhiều dòng hơn mong đợi, nhiều người thêm DISTINCT cho "sạch". Đó là che triệu chứng: nguyên nhân thật là sai grain / JOIN sai khoá (module 5), và DISTINCT còn thêm bước sort/hash tốn kém. Hãy tìm vì sao có trùng trước, đừng khử trùng bằng DISTINCT theo phản xạ.

🏋️ Bài tập thực hành

Khách chưa có thành phốDễ

Liệt kê id, full_name các khách hàng chưa có thông tin thành phố, sắp theo id.

Xem lời giải & giải thích
SELECT id, full_name FROM customers WHERE city IS NULL ORDER BY id;
Kết quả
 id |   full_name
----+----------------
 13 | Vũ Đức Phúc
 26 | Lê Khánh Linh
 39 | Bùi Hải Nam
 52 | Hoàng Ngọc Lan
(4 rows)

Phải dùng IS NULL, không phải = NULL.

Sản phẩm đang bán, giá từ 1 triệu đến dưới 10 triệuDễ

Lấy sku, name, price của sản phẩm còn bán có giá từ 1.000.000 đến dưới 10.000.000, đắt nhất trước.

Xem lời giải & giải thích
SELECT sku, name, price
FROM products
WHERE is_active AND price >= 1000000 AND price < 10000000
ORDER BY price DESC;
Kết quả
  sku   |          name           |   price
--------+-------------------------+------------
 HM-004 | Robot hút bụi           | 7490000.00
 PH-002 | Điện thoại Aurora Lite  | 6490000.00
 HM-001 | Nồi chiên không dầu 5L  | 2290000.00
 AC-001 | Tai nghe không dây Echo | 1890000.00
 FA-005 | Giày da nam             | 1590000.00
 FA-004 | Giày chạy bộ Sprint     | 1290000.00
(6 rows)

Dùng khoảng nửa mở thay vì BETWEEN để loại trừ đúng 10.000.000. WHERE is_active đủ vì cột kiểu boolean.

Đơn hàng quý 2/2024Trung bình

Đếm số đơn có ordered_at trong quý 2 năm 2024 (1/4 đến hết 30/6), không tính đơn đã huỷ.

Xem lời giải & giải thích
SELECT count(*) AS don_q2
FROM orders
WHERE ordered_at >= '2024-04-01' AND ordered_at < '2024-07-01'
  AND status <> 'cancelled';
Kết quả
 don_q2
--------
    169
(1 row)

Khoảng nửa mở đảm bảo đơn lúc 23:59 ngày 30/6 vẫn được tính. status NOT NULL nên <> an toàn ở đây.

Phân trang keysetKhó

Lấy 5 sản phẩm đầu theo (price DESC, id); sau đó viết câu lấy 5 sản phẩm của trang kế tiếp dựa trên dòng cuối của trang 1 (không dùng OFFSET).

Xem lời giải & giải thích
SELECT id, name, price FROM products ORDER BY price DESC, id DESC LIMIT 5;
Kết quả
 id |         name          |    price
----+-----------------------+-------------
  5 | Laptop Zenbook 16 Pro | 34900000.00
  4 | Laptop Zenbook 14     | 22500000.00
  3 | Điện thoại Nova Pro   | 18990000.00
  1 | Điện thoại Aurora X1  | 12990000.00
  6 | Laptop Student 15     | 11900000.00
(5 rows)
-- dòng cuối trang 1: price = 11900000, id = 6
SELECT id, name, price
FROM products
WHERE (price, id) < (11900000, 6)      -- so sánh theo cặp, cùng chiều DESC với ORDER BY
ORDER BY price DESC, id DESC
LIMIT 5;
Kết quả
 id |          name           |   price
----+-------------------------+------------
 19 | Robot hút bụi           | 7490000.00
  2 | Điện thoại Aurora Lite  | 6490000.00
 16 | Nồi chiên không dầu 5L  | 2290000.00
  7 | Tai nghe không dây Echo | 1890000.00
 15 | Giày da nam             | 1590000.00
(5 rows)

Điều kiện row-value phải khớp chiều của ORDER BY: cả hai cột cùng DESC thì dùng <; cùng ASC thì dùng >. Nếu hai cột khác chiều, row-value không dùng được — phải viết tường minh price < x OR (price = x AND id > y). Đó là lý do nên chọn tie-breaker cùng chiều với cột chính.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Không còn viết '= NULL' hay 'NOT IN' với subquery có thể NULL
  • Luôn dùng khoảng nửa mở [đầu, cuối) cho lọc thời gian
  • Biết thêm tie-breaker (id) vào ORDER BY khi phân trang
  • Giải thích được vì sao OFFSET lớn chậm và keyset pagination hoạt động thế nào