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'.
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; 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; chia_nguyen | chia_thuc | du | luy_thua | noi_chuoi
-------------+--------------------+----+----------+-----------
3 | 3.5000000000000000 | 1 | 1024 | abcd
(1 row)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ĩa | Ví dụ |
|---|---|---|
= <> != < <= > >= | So sánh (<> là chuẩn, != cũng chạy) | status <> 'cancelled' |
AND OR NOT | Logic | price > 1e6 AND is_active |
IN (...) | Thuộc tập giá trị | city IN ('Hà Nội','Đà Nẵng') |
BETWEEN a AND b | Trong đoạn đóng [a, b] | price BETWEEN 1e6 AND 5e6 |
LIKE / ILIKE | Khớ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 NULL | Kiểm tra NULL | city 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; 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%'; id | name
----+-------------------------
7 | Tai nghe không dây Echo
10 | Chuột không dây
(2 rows)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'; sai
-----
19
(1 row)SELECT count(*) AS dung
FROM customers
WHERE city IN ('Hà Nội', 'TP.HCM') AND created_at > '2024-03-01'; dung
------
16
(1 row)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'; 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'; 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; 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án | Sai ❌ | Đú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ả NULL | city <> 'Hà Nội' (loại cả NULL) | city IS DISTINCT FROM 'Hà Nội' |
| Thay NULL bằng mặc định | if/else ở code ứng dụng | COALESCE(city, 'Chưa rõ') |
| Tránh chia cho 0 | a / b | a / 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; 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.
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); ket_qua_mong_doi_khac_0
-------------------------
0
(1 row)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; 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; 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; 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)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; 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; 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; 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)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
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; 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.
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; 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.
Đế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'; 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.
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; 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; 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
-
PostgreSQL — Queries (SELECT)Chương Queries của tài liệu chính thứcDocs
-
Use The Index, Luke — Paging Through ResultsGiải thích keyset pagination (seek method)Bài viết
✅ 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