SQL từ cơ bản đến nâng cao
Trang chủ / Module 11
⚡ Module 11 / 16 · 8-9 giờ

Index, EXPLAIN và tối ưu truy vấn

Hiểu index hoạt động ra sao, đọc kế hoạch thực thi EXPLAIN (ANALYZE), thiết kế index đúng (composite, partial, covering), tránh các cách viết làm index vô dụng và quy trình tối ưu có đo đạc.

B-treeEXPLAIN ANALYZEComposite indexSargable
📌 Vì sao module này quan trọng

Truy vấn chạy 50ms với 10.000 dòng có thể chạy 50 giây với 10 triệu dòng. Khác biệt thường chỉ là một index đúng hoặc một cách viết không làm index vô dụng. Nhưng tối ưu mù quáng (thêm index tràn lan, đoán mò) làm ghi chậm đi mà đọc không nhanh lên. Chuyên gia luôn đi theo vòng: đo → đọc kế hoạch → giả thuyết → sửa → đo lại.

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

  • Giải thích Seq Scan vs Index Scan vs Index Only Scan vs Bitmap Scan và vì sao planner chọn từng loại
  • Đọc EXPLAIN (ANALYZE, BUFFERS): chi phí, số dòng ước lượng vs thực tế, thời gian, loại join
  • Thiết kế index: thứ tự cột composite, partial, covering (INCLUDE), expression index; biết cái giá khi ghi
  • Nhận diện các cách viết làm index vô dụng (hàm trên cột, ép kiểu, LIKE '%x', OR) và viết lại

Index là gì và vì sao nhanh

Không có index, để tìm khách số 4242 trong bảng 1 triệu dòng database phải đọc cả bảng (Seq Scan) — O(n). B-tree index là cây đã sắp xếp: tìm theo giá trị chỉ cần vài bước (O(log n)), như tra mục lục sách thay vì đọc từng trang. Index tự động có trên PRIMARY KEY và UNIQUE; mọi thứ khác bạn phải tự tạo.

Cái giá của index: (1) tốn dung lượng đĩa/RAM; (2) mỗi INSERT/UPDATE/DELETE phải cập nhật mọi index liên quan — ghi chậm đi; (3) planner có thêm lựa chọn để nhầm. Vì vậy index không phải "càng nhiều càng tốt": chỉ tạo cho truy vấn thật sự chạy nhiều và chậm.

Loại indexDùng cho
B-tree (mặc định)=, <, >, BETWEEN, ORDER BY, LIKE 'abc%' — 95% trường hợp
HashChỉ so sánh bằng (hiếm cần hơn B-tree)
GINMảng, JSONB (@>), full-text search, trigram LIKE '%x%'
GiST / SP-GiSTHình học, phạm vi (range), exclusion constraint, tìm lân cận
BRINBảng khổng lồ sắp xếp tự nhiên theo thời gian (log) — index cực nhỏ

Hãy xem tận mắt. Tạo bảng 1 triệu đơn (trong bài này nó được tạo rồi rollback), so sánh trước và sau khi có index:

CREATE TABLE big_orders AS
SELECT i AS id,
       (i::bigint * 7919) % 100000 + 1                                   AS customer_id,
       (ARRAY['pending','paid','shipped','delivered','cancelled'])[1 + (i + i / 100000) % 5] AS status,
       timestamptz '2023-01-01' + (i % 500000) * interval '1 minute' AS ordered_at,
       (i % 1000) * 1000                                         AS amount
FROM generate_series(1, 1000000) AS i;
ANALYZE big_orders;

EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM big_orders WHERE customer_id = 4242;

CREATE INDEX idx_big_orders_customer ON big_orders (customer_id);
ANALYZE big_orders;

EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM big_orders WHERE customer_id = 4242;
Kết quả
SELECT 1000000
ANALYZE
                                                       QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------
 Gather  (cost=1000.00..15041.33 rows=10 width=32) (actual time=8.616..56.012 rows=10 loops=1)
   Workers Planned: 2
   Workers Launched: 2
   Buffers: shared hit=2080 read=6752
   ->  Parallel Seq Scan on big_orders  (cost=0.00..14040.33 rows=4 width=32) (actual time=6.911..31.728 rows=3 loops=3)
         Filter: (customer_id = 4242)
         Rows Removed by Filter: 333330
         Buffers: shared hit=2080 read=6752
 Planning:
   Buffers: shared hit=25
 Planning Time: 0.175 ms
 Execution Time: 56.036 ms
(12 rows)

CREATE INDEX
ANALYZE
                                                            QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------
 Bitmap Heap Scan on big_orders  (cost=4.50..43.62 rows=10 width=32) (actual time=0.060..0.115 rows=10 loops=1)
   Recheck Cond: (customer_id = 4242)
   Heap Blocks: exact=10
   Buffers: shared hit=6 read=10
   ->  Bitmap Index Scan on idx_big_orders_customer  (cost=0.00..4.50 rows=10 width=0) (actual time=0.047..0.047 rows=10 loops=1)
         Index Cond: (customer_id = 4242)
         Buffers: shared hit=3 read=3
 Planning:
   Buffers: shared hit=18 read=1
 Planning Time: 0.128 ms
 Execution Time: 0.133 ms
(11 rows)
💡 Con số chỉ mang tính minh hoạ

Thời gian thực thi phụ thuộc máy bạn, nhưng tỉ lệ thì ổn định: quét tuần tự toàn bảng (hàng chục nghìn trang, hàng chục ms) so với index scan (vài trang, dưới 1ms) — chênh lệch hàng trăm đến hàng nghìn lần và tăng theo kích thước bảng.

Đọc EXPLAIN (ANALYZE)

EXPLAIN chỉ cho kế hoạch dự kiến; EXPLAIN ANALYZE chạy thật truy vấn và đo thực tế (cẩn thận với UPDATE/DELETE — nó thực sự thay đổi dữ liệu; hãy bọc trong BEGIN ... ROLLBACK). Thêm BUFFERS để xem số trang đọc.

Đọc kế hoạch từ trong ra ngoài, từ dưới lên trên (nút lá chạy trước). Những thứ cần nhìn:

  • cost=khởi_đầu..tổng — chi phí ước lượng (đơn vị tương đối, dùng để so sánh).
  • rows= (ước lượng) so với actual rows= (thực tế): lệch hàng chục lần ⇒ thống kê cũ/sai → ANALYZE; là nguồn gốc của kế hoạch tồi.
  • loops= — nút bị lặp bao nhiêu lần (nhân với actual time để ra tổng thời gian!).
  • Rows Removed by Filter — lọc sau khi đọc: số lớn nghĩa là đọc nhiều bỏ nhiều → cần index tốt hơn.
  • Buffers: shared hit/read — trang lấy từ cache / từ đĩa.
  • Sort Method: external merge Disk — sắp xếp tràn ra đĩa (thiếu work_mem hoặc cần index sắp xếp sẵn).
NútNghĩaTốt/xấu
Seq ScanĐọc cả bảngTốt cho bảng nhỏ hoặc lấy phần lớn bảng; xấu nếu lọc ra rất ít dòng trên bảng lớn
Index ScanTra index rồi lấy dòng từ bảngTốt khi chọn lọc cao
Index Only ScanMọi cột cần nằm trong index, khỏi đụng bảngRất nhanh (cần visibility map — VACUUM)
Bitmap Heap ScanGom vị trí từ index rồi đọc trang theo thứ tựTốt cho chọn lọc vừa phải / kết hợp nhiều index
Nested LoopVới mỗi dòng ngoài, tra dòng trongTốt khi một phía rất nhỏ + có index phía kia
Hash JoinBăm một bên, dò bên kiaTốt cho nối tập lớn không cần thứ tự
Merge JoinHai phía đã sắp xếp, duyệt song songTốt khi cả hai đã có thứ tự (index)
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF)
SELECT c.city, count(*) AS so_don, round(avg(p.amount)) AS gia_tri_tb
FROM payments p
JOIN orders o    ON o.id = p.order_id
JOIN customers c ON c.id = o.customer_id
WHERE p.paid_at >= '2024-04-01' AND p.paid_at < '2024-07-01'
GROUP BY c.city
ORDER BY so_don DESC;
Kết quả
                                                                                  QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Sort (actual rows=6 loops=1)
   Sort Key: (count(*)) DESC
   Sort Method: quicksort  Memory: 25kB
   ->  HashAggregate (actual rows=6 loops=1)
         Group Key: c.city
         Batches: 1  Memory Usage: 24kB
         ->  Hash Join (actual rows=151 loops=1)
               Hash Cond: (o.customer_id = c.id)
               ->  Hash Join (actual rows=151 loops=1)
                     Hash Cond: (o.id = p.order_id)
                     ->  Seq Scan on orders o (actual rows=400 loops=1)
                     ->  Hash (actual rows=151 loops=1)
                           Buckets: 1024  Batches: 1  Memory Usage: 15kB
                           ->  Seq Scan on payments p (actual rows=151 loops=1)
                                 Filter: ((paid_at >= '2024-04-01 00:00:00+07'::timestamp with time zone) AND (paid_at < '2024-07-01 00:00:00+07'::timestamp with time zone))
                                 Rows Removed by Filter: 169
               ->  Hash (actual rows=60 loops=1)
                     Buckets: 1024  Batches: 1  Memory Usage: 11kB
                     ->  Seq Scan on customers c (actual rows=60 loops=1)
 Planning Time: 6.854 ms
 Execution Time: 0.291 ms
(21 rows)
🧠 Cách chuyên gia — Quy trình tối ưu một truy vấn chậm
  1. Đo: tìm truy vấn thật sự chậm/tốn tổng thời gian nhất (pg_stat_statements, slow query log) — đừng tối ưu theo cảm giác.
  2. EXPLAIN (ANALYZE, BUFFERS) trên dữ liệu có kích cỡ thật (kế hoạch trên bảng 100 dòng nói dối về bảng 100 triệu dòng).
  3. Tìm nút tốn nhất; kiểm tra rows ước lượng vs thực tế; Rows Removed by Filter; Seq Scan trên bảng lớn.
  4. Giả thuyết → sửa (viết lại câu truy vấn / thêm index / ANALYZE) → đo lại → giữ nếu thật sự nhanh hơn.
  5. Kiểm tra tác động lên ghi và dung lượng; xoá index không dùng (pg_stat_user_indexes.idx_scan = 0).
❌ Lỗi thường gặp — Chỉ nhìn EXPLAIN không ANALYZE rồi kết luận

Chi phí ước lượng có thể sai hàng bậc độ lớn khi thống kê cũ. Đồng thời EXPLAIN ANALYZE trên máy dev nhỏ không phản ánh production (kích thước, cache, đồng thời). Dùng dữ liệu đại diện, chạy vài lần (lần đầu "nguội" cache).

Thiết kế index: composite, partial, covering, expression

Composite index — thứ tự cột quyết định tất cả

Index (a, b, c) được sắp theo a, rồi b trong cùng a, rồi c. Nó phục vụ tốt truy vấn lọc theo tiền tố trái (a; a,b; a,b,c) nhưng không giúp nếu chỉ lọc theo b hoặc c. Quy tắc xếp cột:

  1. Cột lọc bằng = đặt trước.
  2. Rồi tới cột lọc khoảng (>, BETWEEN) hoặc cột ORDER BY — một cột "khoảng" là chốt, các cột sau nó ít giá trị.
  3. Giữa các cột =, đặt cột có tính chọn lọc cao hơn/được dùng chung nhiều truy vấn hơn lên trước.
CREATE TABLE big_orders AS
SELECT i AS id, (i::bigint * 7919) % 100000 + 1 AS customer_id,
       (ARRAY['pending','paid','shipped','delivered','cancelled'])[1 + (i + i / 100000) % 5] AS status,
       timestamptz '2023-01-01' + (i % 500000) * interval '1 minute' AS ordered_at, (i % 1000) * 1000 AS amount
FROM generate_series(1, 1000000) AS i;
CREATE INDEX idx_status_time ON big_orders (status, ordered_at);
ANALYZE big_orders;

-- Dùng được cả hai cột: = rồi khoảng
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF)
SELECT count(*) FROM big_orders WHERE status = 'paid' AND ordered_at >= '2023-03-01' AND ordered_at < '2023-03-02';

-- Chỉ lọc cột SAU của index (bỏ cột đầu): không dùng hiệu quả được index này
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF)
SELECT count(*) FROM big_orders WHERE ordered_at >= '2023-03-01' AND ordered_at < '2023-03-02';
Kết quả
SELECT 1000000
CREATE INDEX
ANALYZE
                                                                                            QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Aggregate (actual rows=1 loops=1)
   ->  Bitmap Heap Scan on big_orders (actual rows=576 loops=1)
         Recheck Cond: ((status = 'paid'::text) AND (ordered_at >= '2023-03-01 00:00:00+07'::timestamp with time zone) AND (ordered_at < '2023-03-02 00:00:00+07'::timestamp with time zone))
         Heap Blocks: exact=26
         ->  Bitmap Index Scan on idx_status_time (actual rows=576 loops=1)
               Index Cond: ((status = 'paid'::text) AND (ordered_at >= '2023-03-01 00:00:00+07'::timestamp with time zone) AND (ordered_at < '2023-03-02 00:00:00+07'::timestamp with time zone))
 Planning Time: 0.169 ms
 Execution Time: 0.284 ms
(8 rows)

                                                                               QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Finalize Aggregate (actual rows=1 loops=1)
   ->  Gather (actual rows=3 loops=1)
         Workers Planned: 2
         Workers Launched: 2
         ->  Partial Aggregate (actual rows=1 loops=3)
               ->  Parallel Seq Scan on big_orders (actual rows=960 loops=3)
                     Filter: ((ordered_at >= '2023-03-01 00:00:00+07'::timestamp with time zone) AND (ordered_at < '2023-03-02 00:00:00+07'::timestamp with time zone))
                     Rows Removed by Filter: 332373
 Planning Time: 0.039 ms
 Execution Time: 56.036 ms
(10 rows)
💡 Về 'skip scan'

PostgreSQL 18 đã thêm khả năng skip scan cho B-tree trong một số trường hợp, nhưng không nên thiết kế dựa vào nó: vẫn nên đặt cột phục vụ nhiều truy vấn nhất ở tiền tố trái. Luôn kiểm chứng bằng EXPLAIN trên phiên bản bạn dùng.

Partial index, expression index, covering index

-- Partial index: chỉ index phần dữ liệu "nóng" => nhỏ và nhanh. Ở đây chỉ đơn đang chờ.
CREATE INDEX idx_don_cho ON orders (ordered_at) WHERE status = 'pending';

-- Ràng buộc nghiệp vụ bằng index: mỗi đơn chỉ có đúng 1 thanh toán
CREATE UNIQUE INDEX uq_payments_order ON payments (order_id);

-- Expression index: tra email không phân biệt hoa/thường (truy vấn PHẢI dùng đúng biểu thức)
CREATE UNIQUE INDEX uq_email_lower ON customers (lower(email));

-- Covering index: INCLUDE thêm cột để Index Only Scan, không cần đụng bảng
CREATE INDEX idx_orders_cus_cover ON orders (customer_id) INCLUDE (status, ordered_at);

SET LOCAL enable_seqscan = off;     -- chỉ để minh hoạ: bảng nhỏ nên planner vốn thích Seq Scan
EXPLAIN (COSTS OFF) SELECT id FROM customers WHERE lower(email) = 'user7@example.com';
Kết quả
CREATE INDEX
CREATE INDEX
CREATE INDEX
CREATE INDEX
SET
                        QUERY PLAN
----------------------------------------------------------
 Index Scan using uq_email_lower on customers
   Index Cond: (lower(email) = 'user7@example.com'::text)
(2 rows)
🧠 Cách chuyên gia — Quy tắc index chuyên gia
  • Index mọi khoá ngoại (PostgreSQL không tự tạo) — nhất là cột con dùng để JOIN và DELETE ở bảng cha.
  • Index cho các cột trong WHERE, JOIN, ORDER BY ... LIMIT của truy vấn thường xuyên; một composite index thay vài index đơn.
  • CREATE INDEX CONCURRENTLY trên production để không chặn ghi (không chạy được trong transaction).
  • Định kỳ xem index không dùng (idx_scan = 0), index trùng lặp/thừa tiền tố ((a) thừa nếu đã có (a,b)) và xoá.
  • Index phình theo thời gian (bloat): REINDEX CONCURRENTLY khi cần.

Các cách viết làm index 'vô dụng' (non-sargable)

Sargable = "Search ARGument able": điều kiện mà database dùng được index. Quy tắc: cột đứng một mình ở một vế, không bị bọc hàm/phép tính/ép kiểu.

Không dùng được index ❌Viết lại ✅
WHERE date_trunc('day', ordered_at) = '2024-03-01'WHERE ordered_at >= '2024-03-01' AND ordered_at < '2024-03-02'
WHERE extract(year FROM ordered_at) = 2024Khoảng nửa mở >= '2024-01-01' AND < '2025-01-01'
WHERE price * 1.1 > 1000000WHERE price > 1000000 / 1.1
WHERE lower(email) = 'a@x.com' (chỉ có index trên email)Tạo expression index (lower(email)) hoặc dùng citext
WHERE name LIKE '%laptop%'Trigram index (pg_trgm + GIN) hoặc full-text search
WHERE customer_id::text = '42' / so sánh khác kiểuTruyền đúng kiểu: customer_id = 42
WHERE a = 1 OR b = 2 (mỗi cột index riêng) — đôi khi chậmHai truy vấn UNION ALL, hoặc dựa vào BitmapOr (PG thường tự xử lý — kiểm tra bằng EXPLAIN)
WHERE COALESCE(city,'') = 'Hà Nội'WHERE city = 'Hà Nội'
CREATE TABLE big_orders AS
SELECT i AS id, (i::bigint * 7919) % 100000 + 1 AS customer_id, timestamptz '2023-01-01' + (i % 500000) * interval '1 minute' AS ordered_at
FROM generate_series(1, 1000000) AS i;
CREATE INDEX ON big_orders (ordered_at);
ANALYZE big_orders;

-- ❌ Bọc hàm quanh cột index: phải quét cả bảng
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF)
SELECT count(*) FROM big_orders WHERE ordered_at::date = '2023-03-01';

-- ✅ Khoảng nửa mở: dùng được index
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF)
SELECT count(*) FROM big_orders WHERE ordered_at >= '2023-03-01' AND ordered_at < '2023-03-02';
Kết quả
SELECT 1000000
CREATE INDEX
ANALYZE
                                 QUERY PLAN
-----------------------------------------------------------------------------
 Finalize Aggregate (actual rows=1 loops=1)
   ->  Gather (actual rows=3 loops=1)
         Workers Planned: 2
         Workers Launched: 2
         ->  Partial Aggregate (actual rows=1 loops=3)
               ->  Parallel Seq Scan on big_orders (actual rows=960 loops=3)
                     Filter: ((ordered_at)::date = '2023-03-01'::date)
                     Rows Removed by Filter: 332373
 Planning Time: 0.217 ms
 Execution Time: 63.374 ms
(10 rows)

                                                                              QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Aggregate (actual rows=1 loops=1)
   ->  Bitmap Heap Scan on big_orders (actual rows=2880 loops=1)
         Recheck Cond: ((ordered_at >= '2023-03-01 00:00:00+07'::timestamp with time zone) AND (ordered_at < '2023-03-02 00:00:00+07'::timestamp with time zone))
         Heap Blocks: exact=21
         ->  Bitmap Index Scan on big_orders_ordered_at_idx (actual rows=2880 loops=1)
               Index Cond: ((ordered_at >= '2023-03-01 00:00:00+07'::timestamp with time zone) AND (ordered_at < '2023-03-02 00:00:00+07'::timestamp with time zone))
 Planning Time: 0.076 ms
 Execution Time: 0.460 ms
(8 rows)
❌ Lỗi thường gặp — Thêm index 'cho chắc' rồi thấy vẫn không được dùng

Planner bỏ qua index khi: truy vấn không sargable (bảng trên); điều kiện kém chọn lọc (lấy >~10–20% bảng thì quét tuần tự rẻ hơn); bảng quá nhỏ; thống kê cũ; kiểu dữ liệu không khớp; hoặc thứ tự cột composite sai. Hãy đọc EXPLAIN để biết lý do thay vì ép bằng cờ cấu hình.

❌ Lỗi thường gặp — OFFSET lớn và count(*) trên bảng khổng lồ

OFFSET 1000000 đọc rồi vứt 1 triệu dòng → dùng keyset pagination (module 2). SELECT count(*) FROM bảng_tỷ_dòng luôn quét (MVCC không lưu sẵn số đếm chính xác) → dùng ước lượng (pg_class.reltuples), bảng đếm tổng hợp/cache, hoặc đếm gần đúng cho giao diện phân trang.

❌ Lỗi thường gặp — Tối ưu bằng cách thêm RAM/CPU trước khi xem truy vấn

Nhiều "sự cố hiệu năng" là một truy vấn thiếu index hoặc N+1 (module 14). Phần cứng chỉ trì hoãn vấn đề vài tuần. Luôn xem kế hoạch trước.

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

Chọn index cho truy vấnTrung bình

Truy vấn thường chạy: SELECT * FROM orders WHERE customer_id = ? AND status = 'delivered' ORDER BY ordered_at DESC LIMIT 10;. Thiết kế một index duy nhất phục vụ tốt nhất và giải thích thứ tự cột.

Xem lời giải & giải thích
CREATE INDEX idx_orders_cus_status_time ON orders (customer_id, status, ordered_at DESC);
SET LOCAL enable_seqscan = off;      -- bảng 400 dòng quá nhỏ để planner tự chọn index
SET LOCAL enable_bitmapscan = off;
EXPLAIN (COSTS OFF)
SELECT * FROM orders WHERE customer_id = 7 AND status = 'delivered' ORDER BY ordered_at DESC LIMIT 10;
Kết quả
CREATE INDEX
SET
SET
                                QUERY PLAN
--------------------------------------------------------------------------
 Limit
   ->  Index Scan using idx_orders_cus_status_time on orders
         Index Cond: ((customer_id = 7) AND (status = 'delivered'::text))
(3 rows)

Hai cột lọc bằng (customer_id, status) đứng trước, cột ordered_at (sắp xếp) đứng cuối với cùng chiều DESC → database đọc đúng 10 mục đầu của index đã sắp xếp, không cần bước Sort. (Bảng nhỏ nên planner có thể chọn Seq Scan — hãy thử trên bảng lớn hơn.)

Sửa truy vấn không sargableDễ

Viết lại SELECT count(*) FROM orders WHERE extract(month FROM ordered_at) = 3 AND extract(year FROM ordered_at) = 2024 để dùng được index trên ordered_at và chứng minh kết quả bằng nhau.

Xem lời giải & giải thích
SELECT
  (SELECT count(*) FROM orders WHERE extract(month FROM ordered_at) = 3 AND extract(year FROM ordered_at) = 2024) AS cach_cu,
  (SELECT count(*) FROM orders WHERE ordered_at >= '2024-03-01' AND ordered_at < '2024-04-01')                  AS cach_moi;
Kết quả
 cach_cu | cach_moi
---------+----------
      38 |       38
(1 row)

Hai cách cho cùng số, nhưng cách mới là khoảng thẳng trên cột nên index dùng được. Lưu ý múi giờ: extract trên timestamptz dùng múi giờ phiên — khoảng nửa mở với mốc rõ ràng cũng tránh nhập nhằng đó.

Tìm khoá ngoại thiếu indexKhó

Viết truy vấn liệt kê các khoá ngoại mà cột con chưa là cột đầu của bất kỳ index nào (gợi ý: pg_constraint kết pg_index).

Xem lời giải & giải thích
SELECT c.conrelid::regclass AS bang, a.attname AS cot_fk, c.conname
FROM pg_constraint c
JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = c.conkey[1]
WHERE c.contype = 'f' AND cardinality(c.conkey) = 1
  AND NOT EXISTS (
    SELECT 1 FROM pg_index i
    WHERE i.indrelid = c.conrelid AND i.indkey[0] = c.conkey[1])
ORDER BY 1, 2;
Kết quả
    bang     |   cot_fk    |           conname
-------------+-------------+-----------------------------
 customers   | referred_by | customers_referred_by_fkey
 categories  | parent_id   | categories_parent_id_fkey
 products    | category_id | products_category_id_fkey
 orders      | customer_id | orders_customer_id_fkey
 order_items | product_id  | order_items_product_id_fkey
 payments    | order_id    | payments_order_id_fkey
 employees   | manager_id  | employees_manager_id_fkey
 events      | customer_id | events_customer_id_fkey
(8 rows)

Đây là truy vấn 'kiểm tra sức khoẻ schema' nên chạy định kỳ. Cột như orders.customer_id, payments.order_id sẽ hiện ra — đó là các ứng viên tạo index (cân nhắc theo truy vấn thực tế).

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

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

  • Đọc được EXPLAIN (ANALYZE, BUFFERS): so rows ước lượng với thực tế, tìm nút tốn nhất
  • Thiết kế composite index đúng thứ tự (= trước, khoảng/ORDER BY sau) và index mọi khoá ngoại
  • Biết viết lại điều kiện thành sargable (không bọc hàm/ép kiểu quanh cột)
  • Tuân thủ vòng đo → sửa → đo lại và biết chi phí ghi của index