SQL cơ bản: CRUD và JOIN cho dữ liệu đơn hàng

SQL cơ bản cho người làm backend: SELECT, INSERT, UPDATE, DELETE và JOIN trên PostgreSQL, qua dữ liệu đơn hàng quán cà phê, kèm lỗi UPDATE quên WHERE.

SQL là ngôn ngữ để hỏi và sửa dữ liệu trong cơ sở dữ liệu quan hệ như PostgreSQL. Bốn lệnh làm nên CRUD là SELECT (đọc), INSERT (thêm), UPDATE (sửa) và DELETE (xóa), còn JOIN nối các bảng lại, ví dụ nối đơn hàng với các món trong đơn.

Ở bài trước, mình dựng một API đơn hàng nhỏ cho quán cà phê Mộc (tình huống minh họa) và thấy một điểm yếu: đơn hàng nằm trong bộ nhớ, nên tắt server là mất. Muốn giữ dữ liệu lâu dài, bạn phải đưa nó vào cơ sở dữ liệu, và để nói chuyện với cơ sở dữ liệu bạn cần SQL. Bài này dạy phần SQL đủ dùng cho người làm backend, chạy trên dữ liệu đơn hàng của quán.

Cơ sở dữ liệu quan hệ là gì?

Cơ sở dữ liệu quan hệ lưu dữ liệu trong các bảng. Mỗi bảng giống một trang tính: mỗi cột là một thuộc tính (tên món, giá) và mỗi dòng là một bản ghi (một món cụ thể). Các bảng liên hệ với nhau qua giá trị chung, ví dụ bảng các dòng món trong đơn ghi lại mã đơn và mã món để chỉ về hai bảng kia.

Vì sao không lưu thẳng vào file như orders.json? Vì file không giúp bạn khi nhiều người cùng ghi một lúc, không chặn được dữ liệu sai (giá âm, đơn trỏ tới món đã xóa), và việc tìm "các đơn của khách Lan tuần này" nghĩa là đọc cả file rồi tự lọc. Cơ sở dữ liệu lo những việc đó. Mình dùng PostgreSQL, một trong những cơ sở dữ liệu mã nguồn mở phổ biến nhất, và là thứ mà các bài Spring Boot về sau sẽ nối vào.

Chạy SQL thế nào mà không phải cài gì?

Để làm theo ngay, mình dùng PGlite, một bản PostgreSQL chạy ngay trong Node.js, không cần cài database hay Docker. Bản mình dùng báo PostgreSQL 17.5. Các câu SQL trong bài là SQL chuẩn của PostgreSQL, nên bạn chạy y nguyên được trên PostgreSQL cài sẵn (bằng psql hay một công cụ như DBeaver). Mình chỉ chạy kết quả trong bài bằng PGlite, chưa chạy lại trên một server PostgreSQL riêng.

Có hai cách để làm theo. Cách thứ nhất, và là cách mình khuyên nếu bạn đã có PostgreSQL, là dùng psql hay DBeaver: chạy lần lượt các file SQL dưới đây (schema.sql, du-lieu-mau.sql, rồi từng file bài) và đối chiếu kết quả với bài. Cách thứ hai là dùng đúng thứ mình dùng: lấy thư mục demo từ repo, cài Node.js 22 trở lên rồi chạy:

Chạy bằng PGlite (trong thư mục demo của tập này)
npm install
node chay-sql.mjs bai-1-select.sql

Script chay-sql.mjs (khoảng 60 dòng) nạp bảng và dữ liệu mẫu, chạy file .sql bạn chỉ định rồi in kết quả theo kiểu psql. Nó chỉ là đồ nghề để chạy bài, nên mình không dán cả vào đây; bạn cần mở repo mới dùng được cách này. Mỗi lần chạy tạo một database mới, nên kết quả luôn giống nhau.

Bảng của quán Mộc trông như thế nào?

Quán có ba bảng: món (menu_items), đơn hàng (orders) và các dòng món trong từng đơn (order_lines). Mình tạo bảng bằng file schema.sql. Lúc này bạn chưa cần hiểu hết các từ như PRIMARY KEY hay REFERENCES: bài kế tiếp sẽ giải thích vì sao thiết kế như vậy.

schema.sql
CREATE TABLE menu_items (
    id    BIGSERIAL PRIMARY KEY,
    name  TEXT   NOT NULL,
    price BIGINT NOT NULL CHECK (price > 0)
);

CREATE TABLE orders (
    id            BIGSERIAL PRIMARY KEY,
    customer_name TEXT      NOT NULL,
    status        TEXT      NOT NULL DEFAULT 'NEW'
                  CHECK (status IN ('NEW', 'PAID', 'DONE', 'CANCELLED')),
    created_at    TIMESTAMP NOT NULL
);

CREATE TABLE order_lines (
    order_id     BIGINT NOT NULL REFERENCES orders (id),
    menu_item_id BIGINT NOT NULL REFERENCES menu_items (id),
    quantity     INT    NOT NULL CHECK (quantity > 0),
    PRIMARY KEY (order_id, menu_item_id)
);

Tiếp theo là dữ liệu mẫu: 5 món, 6 đơn, 8 dòng món. Đơn số 6 của khách Phúc chưa có dòng món nào, và mình cố tình để vậy vì nó sẽ cho thấy một khác biệt quan trọng ở phần JOIN.

du-lieu-mau.sql
INSERT INTO menu_items (name, price) VALUES
    ('Cà phê sữa', 35000),
    ('Bạc xỉu', 39000),
    ('Trà đào', 45000),
    ('Bánh mì que', 15000),
    ('Cà phê đen', 29000);

INSERT INTO orders (customer_name, status, created_at) VALUES
    ('Lan',  'DONE',      '2026-11-01 08:10:00'),
    ('Hùng', 'PAID',      '2026-11-01 09:30:00'),
    ('Mai',  'NEW',       '2026-11-02 07:45:00'),
    ('Nam',  'CANCELLED', '2026-11-02 10:05:00'),
    ('Lan',  'NEW',       '2026-11-03 08:20:00'),
    ('Phúc', 'NEW',       '2026-11-03 09:00:00');

INSERT INTO order_lines (order_id, menu_item_id, quantity) VALUES
    (1, 1, 2),
    (1, 4, 1),
    (2, 2, 1),
    (3, 3, 3),
    (3, 1, 1),
    (4, 2, 2),
    (5, 1, 1),
    (5, 5, 2);

Trong một lệnh INSERT có sẵn danh sách cột và các dòng giá trị. Các cột id mình không điền: PostgreSQL tự cấp số 1, 2, 3, ... nhờ kiểu BIGSERIAL. Dữ liệu trên có nghĩa là, ví dụ, đơn số 1 của Lan gồm 2 ly cà phê sữa (món 1) và 1 bánh mì que (món 4).

SELECT: đọc dữ liệu như thế nào?

SELECT là lệnh bạn dùng nhiều nhất. Bạn nói chọn cột nào (SELECT), từ bảng nào (FROM), lọc dòng nào (WHERE), sắp xếp ra sao (ORDER BY). Mình ghi sáu câu trong bai-1-select.sql:

bai-1-select.sql
-- Đọc toàn bộ bảng món
SELECT * FROM menu_items;

-- Chỉ một số cột, lọc theo điều kiện, sắp xếp giảm dần theo giá
SELECT name, price FROM menu_items WHERE price >= 35000 ORDER BY price DESC;

-- Lọc theo chữ: món có tên bắt đầu bằng "Cà phê"
SELECT name FROM menu_items WHERE name LIKE 'Cà phê%';

-- Hai món rẻ nhất
SELECT name, price FROM menu_items ORDER BY price LIMIT 2;

-- Đếm số đơn, rồi đếm theo từng trạng thái
SELECT count(*) AS so_don FROM orders;
SELECT status, count(*) AS so_don FROM orders GROUP BY status ORDER BY status;
Kết quả (chạy bằng node chay-sql.mjs bai-1-select.sql)
sql> SELECT * FROM menu_items;
 id |    name     | price
----+-------------+-------
  1 | Cà phê sữa  | 35000
  2 | Bạc xỉu     | 39000
  3 | Trà đào     | 45000
  4 | Bánh mì que | 15000
  5 | Cà phê đen  | 29000
(5 rows)

sql> SELECT name, price FROM menu_items WHERE price >= 35000 ORDER BY price DESC;
    name    | price
------------+-------
 Trà đào    | 45000
 Bạc xỉu    | 39000
 Cà phê sữa | 35000
(3 rows)

sql> SELECT name FROM menu_items WHERE name LIKE 'Cà phê%';
    name   
------------
 Cà phê sữa
 Cà phê đen
(2 rows)

sql> SELECT name, price FROM menu_items ORDER BY price LIMIT 2;
    name     | price
-------------+-------
 Bánh mì que | 15000
 Cà phê đen  | 29000
(2 rows)

sql> SELECT count(*) AS so_don FROM orders;
 so_don
--------
      6
(1 row)

sql> SELECT status, count(*) AS so_don FROM orders GROUP BY status ORDER BY status;
  status   | so_don
-----------+--------
 CANCELLED |      1
 DONE      |      1
 NEW       |      3
 PAID      |      1
(4 rows)

Dấu * nghĩa là "mọi cột". Câu thứ hai chỉ lấy hai cột và những món từ 35.000 đồng trở lên, xếp từ đắt đến rẻ (DESC là giảm dần). Câu thứ ba dùng LIKE với dấu % đại diện cho "bất kỳ chữ nào theo sau", nên tìm được cả hai món cà phê. LIMIT 2 chỉ lấy hai dòng đầu sau khi sắp xếp. Hai câu cuối đếm: count(*) đếm số dòng, và GROUP BY status gom các đơn theo trạng thái rồi đếm trong từng nhóm.

Trong quá trình làm việc, bạn sẽ viết rất nhiều câu SELECT kiểu này. Chữ nằm sau AS là tên bạn đặt cho cột kết quả (alias), giúp kết quả dễ đọc hơn.

INSERT, UPDATE, DELETE: ghi dữ liệu như thế nào?

Ba lệnh còn lại thay đổi dữ liệu. Trong PostgreSQL, bạn thêm mệnh đề RETURNING ở cuối để lấy lại ngay các dòng vừa bị tác động, tiện cho việc kiểm tra. Mình viết trong bai-2-ghi.sql đủ cả thao tác thành công lẫn các lần database từ chối:

bai-2-ghi.sql (nửa đầu)
-- Thêm món mới; RETURNING cho ta thấy dòng vừa thêm (kèm id do database cấp)
INSERT INTO menu_items (name, price) VALUES ('Sinh tố bơ', 52000) RETURNING id, name, price;

-- Sửa giá một món: nhớ WHERE
UPDATE menu_items SET price = 37000 WHERE name = 'Cà phê sữa' RETURNING id, name, price;

-- Xóa món vừa thêm
DELETE FROM menu_items WHERE name = 'Sinh tố bơ' RETURNING id, name;

-- Database tự chặn dữ liệu sai: giá âm
INSERT INTO menu_items (name, price) VALUES ('Món lỗi', -5);

-- Database chặn xóa món đang có trong đơn hàng
DELETE FROM menu_items WHERE name = 'Cà phê sữa';
Kết quả
sql> INSERT INTO menu_items (name, price) VALUES ('Sinh tố bơ', 52000) RETURNING id, name, price;
 id |    name    | price
----+------------+-------
  6 | Sinh tố bơ | 52000
(1 row)
INSERT 0 1

sql> UPDATE menu_items SET price = 37000 WHERE name = 'Cà phê sữa' RETURNING id, name, price;
 id |    name    | price
----+------------+-------
  1 | Cà phê sữa | 37000
(1 row)
UPDATE 1

sql> DELETE FROM menu_items WHERE name = 'Sinh tố bơ' RETURNING id, name;
 id |    name   
----+------------
  6 | Sinh tố bơ
(1 row)
DELETE 1

sql> INSERT INTO menu_items (name, price) VALUES ('Món lỗi', -5);
ERROR: new row for relation "menu_items" violates check constraint "menu_items_price_check"

sql> DELETE FROM menu_items WHERE name = 'Cà phê sữa';
ERROR: update or delete on table "menu_items" violates foreign key constraint "order_lines_menu_item_id_fkey" on table "order_lines"

Món mới nhận được id là 6 do database cấp, và dòng INSERT 0 1 cho biết một dòng đã được thêm (UPDATE 1, DELETE 1 tương tự). Hai câu lệnh cuối bị từ chối, và đây chính là lý do bạn nên để database giữ luật thay vì chỉ kiểm tra trong code Java.

Câu INSERT giá âm vi phạm ràng buộc CHECK (price > 0) đã khai báo trong schema.sql. Câu DELETE món "Cà phê sữa" bị chặn bởi ràng buộc khóa ngoại, vì món này đang nằm trong nhiều đơn hàng, và nếu xóa thì các dòng món sẽ trỏ vào một món không còn tồn tại.

Lỗi UPDATE quên WHERE nguy hiểm đến mức nào?

Đây là lỗi mà gần như ai làm SQL cũng gặp một lần. Câu UPDATE không có WHERE sẽ áp dụng lên mọi dòng của bảng. Mình thử trong một transaction (một khối lệnh có thể hủy bằng ROLLBACK), để chuyện không thành thảm họa thật:

bai-2-ghi.sql (nửa sau)
BEGIN;
UPDATE menu_items SET price = price + 1000;
SELECT name, price FROM menu_items ORDER BY id;
ROLLBACK;
SELECT name, price FROM menu_items ORDER BY id;
Kết quả
sql> BEGIN;
BEGIN

sql> UPDATE menu_items SET price = price + 1000;
UPDATE 5

sql> SELECT name, price FROM menu_items ORDER BY id;
    name     | price
-------------+-------
 Cà phê sữa  | 38000
 Bạc xỉu     | 40000
 Trà đào     | 46000
 Bánh mì que | 16000
 Cà phê đen  | 30000
(5 rows)

sql> ROLLBACK;
ROLLBACK

sql> SELECT name, price FROM menu_items ORDER BY id;
    name     | price
-------------+-------
 Cà phê sữa  | 37000
 Bạc xỉu     | 39000
 Trà đào     | 45000
 Bánh mì que | 15000
 Cà phê đen  | 29000
(5 rows)

Dòng UPDATE 5 là dấu hiệu cần để ý: bạn định sửa một món mà database báo đã sửa năm dòng, tức là cả bảng. Giá của cả năm món cùng tăng 1.000 đồng. Sau ROLLBACK, dữ liệu trở về như trước.

Ngoài đời thật, nếu bạn chạy câu đó mà không có transaction, giá của cả thực đơn đã đổi và bạn chỉ còn cách khôi phục từ bản sao lưu. Thói quen tốt: trước khi chạy UPDATE hay DELETE, hãy viết thử câu SELECT với đúng WHERE đó để xem nó chọn những dòng nào, và nhìn con số UPDATE n ở kết quả. Bài về transaction ở các phần sau sẽ nói kỹ hơn về BEGIN, COMMIT và ROLLBACK.

JOIN nối các bảng như thế nào?

Dữ liệu một đơn hàng nằm rải ở ba bảng: tên khách ở orders, tên món ở menu_items, số lượng ở order_lines. Để xem "ai mua gì, bao nhiêu", bạn nối chúng bằng JOIN, với mệnh đề ON nói hai bảng khớp nhau ở cột nào. Mình viết ba ví dụ trong bai-3-join.sql:

bai-3-join.sql (phần nối ba bảng)
SELECT o.id AS ma_don, o.customer_name AS khach, m.name AS mon, l.quantity AS so_luong
FROM orders o
JOIN order_lines l ON l.order_id = o.id
JOIN menu_items m ON m.id = l.menu_item_id
ORDER BY o.id, m.name;
Kết quả
 ma_don | khach |     mon     | so_luong
--------+-------+-------------+----------
      1 | Lan   | Bánh mì que |        1
      1 | Lan   | Cà phê sữa  |        2
      2 | Hùng  | Bạc xỉu     |        1
      3 | Mai   | Cà phê sữa  |        1
      3 | Mai   | Trà đào     |        3
      4 | Nam   | Bạc xỉu     |        2
      5 | Lan   | Cà phê sữa  |        1
      5 | Lan   | Cà phê đen  |        2
(8 rows)

Chữ o, l, m sau tên bảng là tên viết tắt (alias) cho đỡ phải gõ dài. Kết quả có tám dòng, đúng bằng số dòng trong order_lines: mỗi dòng món được gắn với tên khách và tên món tương ứng.

Hãy chú ý: không thấy khách Phúc (đơn 6) ở đây. Vì sao? Vì JOIN mặc định (còn gọi INNER JOIN) chỉ giữ những dòng khớp ở cả hai bên, mà đơn 6 chưa có dòng món nào. Mình kiểm tra riêng đơn này bằng hai câu, một với JOIN và một với LEFT JOIN:

bai-3-join.sql (INNER JOIN so với LEFT JOIN)
SELECT o.id, o.customer_name, l.menu_item_id
FROM orders o
JOIN order_lines l ON l.order_id = o.id
WHERE o.id = 6;

SELECT o.id, o.customer_name, l.menu_item_id
FROM orders o
LEFT JOIN order_lines l ON l.order_id = o.id
WHERE o.id = 6;
Kết quả
 id | customer_name | menu_item_id
----+---------------+--------------
(0 rows)

 id | customer_name | menu_item_id
----+---------------+--------------
  6 | Phúc          |
(1 row)

Với JOIN, đơn 6 biến mất khỏi kết quả (0 dòng). Với LEFT JOIN, mọi dòng của bảng bên trái (orders) được giữ lại, và chỗ bên phải không có gì thì để trống (giá trị NULL). Trong thực tế, đây là khác biệt mà người làm báo cáo hay quên: nếu bạn muốn liệt kê mọi đơn kể cả đơn chưa có món, hãy dùng LEFT JOIN, còn nếu chỉ cần những đơn có món thì JOIN là đủ.

Cuối cùng, tính tổng tiền từng đơn bằng cách nhân số lượng với giá rồi cộng lại theo đơn. Hàm SUM cộng các giá trị trong nhóm, GROUP BY gom theo từng đơn, và COALESCE(..., 0) đổi NULL thành 0 để đơn trống tính là 0 đồng chứ không để trống:

bai-3-join.sql (tổng tiền từng đơn)
SELECT o.id AS ma_don, o.customer_name AS khach, COALESCE(SUM(l.quantity * m.price), 0) AS tong_tien
FROM orders o
LEFT JOIN order_lines l ON l.order_id = o.id
LEFT JOIN menu_items m ON m.id = l.menu_item_id
GROUP BY o.id, o.customer_name
ORDER BY o.id;
Kết quả
 ma_don | khach | tong_tien
--------+-------+-----------
      1 | Lan   |     85000
      2 | Hùng  |     39000
      3 | Mai   |    170000
      4 | Nam   |     78000
      5 | Lan   |     93000
      6 | Phúc  |         0
(6 rows)

Bạn có thể tự kiểm lại bằng tay: đơn 3 của Mai có 3 ly trà đào (3 × 45.000) và 1 ly cà phê sữa (35.000), tổng 170.000 đồng, khớp với kết quả. Đơn 6 trả về 0 nhờ LEFT JOIN và COALESCE. Tài liệu đầy đủ về các lệnh này nằm trong phần SQL của hướng dẫn PostgreSQL.

Bước tiếp theo là gì?

Bạn đã đọc và ghi được dữ liệu, nối được các bảng, và thấy database tự chặn dữ liệu sai. Nhưng mình còn nợ bạn một câu hỏi: vì sao lại chia dữ liệu thành đúng ba bảng đó? Vì sao order_lines có khóa chính gồm hai cột, và vì sao tên khách nằm trong orders chứ không tách thành bảng riêng? Một bảng thiết kế sai sẽ làm mọi câu SQL sau này khó viết hơn và dễ sai hơn. Đó là việc của bài kế tiếp trong series Học Spring Boot: xây API đặt hàng từ con số 0.

Nếu bạn đang ôn phỏng vấn, thử trả lời câu INNER JOIN và LEFT JOIN khác nhau thế nào trước khi đọc đáp án.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.