# Chỉ một tên CTE là đủ qua mặt guard chỉ cho SELECT của agent text-to-SQL

> Chính README của SQLGlot nhận nó là transpiler chứ không phải validator, nên luật an toàn trên cây cú pháp, kể cả phân giải scope, bạn phải tự viết.

Bản gốc: https://fdetimes.net/vi/bach-khoa/thuc-hanh-sqlglot-chan-cau-sql-ghi-du-lieu-cho-agent-text-to-sql/

README của SQLGlot có ghi một câu thẳng thắn: SQLGlot là một transpiler, không phải một validator. Nghĩa là công cụ bạn định dùng làm cổng bảo vệ tự nhận nó không sinh ra để làm việc đó. Muốn nó thành cổng bảo vệ, bạn phải tự viết luật trên cây cú pháp.

Vì sao không dặn agent trong prompt là đủ? Bài viết của SurrealDB về agent bị jailbreak tóm lại rất gọn: system prompt chỉ là lời gợi ý, không phải hàng rào. Khi agent text-to-SQL được nối vào database của khách hàng, luật phải nằm ở lớp mà mô hình không với tới được.

Bài này dựng lớp đó trên laptop của bạn: một hàm Python nhận câu SQL, trả về câu đã duyệt hoặc ném lỗi. Kết quả là một guard chỉ cho phép đúng một câu SELECT, chỉ trên các bảng `orders` và `customers`, và không gọi hàm lạ. Bạn cần Python 3, `pip install sqlglot` và khoảng một giờ.

Mã trong bài là bản rút gọn để học. Hãy ghim phiên bản sqlglot trong file requirements và coi sáu câu kiểm thử ở cuối bài là thước đo: mỗi lần nâng phiên bản, chạy lại chúng trước khi deploy.

## Vì sao phải parse thay vì dùng regex?

SQLGlot là parser viết bằng Python thuần, không phụ thuộc thư viện nào khác, biến chuỗi SQL thành một AST mà code duyệt được. Hướng dẫn về text-to-SQL an toàn trên DEV Community khuyên làm đúng điều này: parse câu sinh ra thành AST để kiểm tra ngữ nghĩa, chẳng hạn bảo đảm trong đó chỉ có câu SELECT.

Regex chỉ nhìn thấy chữ. Cây cú pháp cho bạn biết cấu trúc thật: chữ `orders` đang là tên bảng, tên cột hay một chuỗi ký tự. Toàn bộ guard bên dưới dựa trên khác biệt đó.

## Bước 1: lỗi parse thì từ chối, không đoán

README ghi rằng khi parser phát hiện lỗi cú pháp, nó ném `ParseError`. Đó là nhánh đầu tiên của guard: không cố sửa, không thử lại, từ chối luôn. Bạn cũng muốn đúng một câu lệnh, để chặn kiểu `SELECT 1; DROP TABLE orders`.

```python
import sqlglot
from sqlglot import exp
from sqlglot.errors import ParseError

class Rejected(Exception):
    pass

def parse_single(sql: str) -> exp.Expression:
    try:
        statements = sqlglot.parse(sql, read="postgres")
    except ParseError as e:
        raise Rejected(f"parse error: {e}")
    statements = [s for s in statements if s is not None]
    if len(statements) != 1:
        raise Rejected("phải đúng một câu lệnh")
    return statements[0]
```

Kiểm tra: gọi `parse_single("SELECT 1; SELECT 2")` phải ra `Rejected`. Ở đây dùng `sqlglot.parse`, hàm trả về danh sách câu lệnh, thay cho `parse_one` trong README, vì guard cần đếm số câu.

## Bước 2: chỉ nhận một cây có gốc là SELECT

Vì parser dễ dãi, parse thành công chưa nói lên điều gì. Luật thứ hai kiểm tra chính cái cây: gốc phải là một SELECT, và khi duyệt toàn bộ cây bằng `walk` thì không được gặp nút ghi dữ liệu nào.

Tài liệu AST Primer của dự án giải thích `find` và `find_all` đều được xây trên `walk`, nên `walk` là công cụ cho mức kiểm soát chi tiết nhất.

```python
FORBIDDEN = (exp.Insert, exp.Update, exp.Delete,
             exp.Drop, exp.Create, exp.Command)

def require_select(tree: exp.Expression) -> None:
    if not isinstance(tree, exp.Select):
        raise Rejected(f"gốc là {type(tree).__name__}, không phải SELECT")
    for node in tree.walk():
        if isinstance(node, FORBIDDEN):
            raise Rejected(f"nút cấm: {type(node).__name__}")
```

Danh sách `FORBIDDEN` ở đây cố ý ngắn, vì luật gốc-phải-là-SELECT đã làm phần việc chính.

Luật gốc chặt như vậy có thể chặn luôn cả những câu đọc hợp lệ như `UNION`, tùy cách sqlglot dựng cây cho chúng; hãy thêm một câu `UNION` vào bộ test để biết chắc trên phiên bản bạn ghim.

Chặn thừa là chủ ý: mở rộng sau khi khách hàng cần, đừng mở trước.

## Bước 3: allowlist bảng, và cái bẫy CTE

README có sẵn ví dụ dùng `find_all(exp.Table)` để liệt kê mọi bảng trong một câu truy vấn, và đó là điểm xuất phát tự nhiên cho allowlist. Phiên bản đầu tiên ai cũng viết trông như sau.

```python
ALLOWED = {"orders", "customers"}

def naive_tables(tree):
    cte_names = {c.alias_or_name for c in tree.find_all(exp.CTE)}
    for t in tree.find_all(exp.Table):
        if t.name in cte_names:
            continue  # tưởng là CTE, bỏ qua
        if t.name not in ALLOWED:
            raise Rejected(f"bảng ngoài allowlist: {t.name}")
```

Vì sao phải có `cte_names`? AST Primer cảnh báo rằng nút `Table` không phải lúc nào cũng là bảng trong database của bạn, vì tên CTE cũng hiện ra dưới dạng `Table`. Không bỏ qua chúng thì mọi câu `WITH` hợp lệ đều bị chặn.

Nhưng cách bỏ qua theo tên mở ra một lỗ hổng. Một ví dụ dựng ra để thử: agent sinh `WITH salaries AS (SELECT * FROM salaries) SELECT * FROM salaries`. Trong thân CTE, `salaries` là bảng lương thật; hàm trên thấy tên trùng với một CTE nên cho qua cả ba lần.

**Điểm mấu chốt:** Một cái tên giống nhau chưa chắc là cùng một thứ; guard phải biết mỗi tên trỏ tới đâu.

## Bước 4: để module scope phân xử tên nào là bảng thật

AST Primer giới thiệu module scope, cách duyệt cây có hiểu ngữ nghĩa, biết mỗi tên trỏ tới đâu: `build_scope` xác định một cái tên là bảng vật lý, CTE hay subquery. Đó đúng là câu hỏi guard cần trả lời.

```python
from sqlglot.optimizer.scope import build_scope

def check_tables(tree: exp.Expression) -> None:
    root = build_scope(tree)
    if root is None:
        raise Rejected("không dựng được scope")
    for scope in root.traverse():
        for name, source in scope.sources.items():
            if isinstance(source, exp.Table) and source.name not in ALLOWED:
                raise Rejected(f"bảng ngoài allowlist: {source.name}")
```

Trong mỗi scope, nguồn là `exp.Table` thì đó là bảng thật, nguồn là một scope con thì đó là CTE hoặc subquery, và thân của nó sẽ được duyệt ở vòng lặp kế tiếp. Lưu ý nhánh `root is None`: không dựng được scope cũng là một kiểu không chắc chắn, nên cũng bị từ chối.

Chạy lại ví dụ `salaries`: thân CTE giờ phải bị từ chối, vì ở đó `salaries` là bảng vật lý chứ không phải tên CTE.

## Bước 5: đừng quên các hàm

Một câu SELECT vẫn có thể làm việc nguy hiểm qua lời gọi hàm. Theo hoop.dev, PostgreSQL mặc định cấp quyền execute trên function và procedure cho role public, nên role chỉ đọc vẫn gọi được hàm. Guard nên chặn những lời gọi hàm mà parser không nhận ra.

```python
def check_functions(tree: exp.Expression) -> None:
    for node in tree.find_all(exp.Anonymous):
        raise Rejected(f"hàm không có trong allowlist: {node.name}")

def guard(sql: str) -> str:
    tree = parse_single(sql)
    require_select(tree)
    check_tables(tree)
    check_functions(tree)
    return tree.sql(dialect="postgres")
```

Bản này đã được đơn giản hóa và dựa trên một giả định cần kiểm chứng: hàm mà sqlglot không nhận ra sẽ thành nút `exp.Anonymous`.

Câu test `pg_sleep` ở phần sau là để thử đúng giả định đó; nếu nó lọt qua, đoạn kiểm tra này không đủ. Ở môi trường thật, bạn nên đảo lại thành allowlist hàm, ví dụ chỉ cho `COUNT`, `SUM`, `DATE_TRUNC`, và để database tự thu hồi quyền execute.

## Sáu câu kiểm thử trước khi gọi là xong

Chạy `guard` trên sáu câu sau và ghi kết quả. `SELECT id, total FROM orders` phải qua. `DELETE FROM orders` phải bị chặn ở bước 2, `SELECT * FROM salaries` bị chặn ở bước 4. Câu CTE `salaries` phải bị chặn, `SELECT pg_sleep(10)` cũng vậy, và một chuỗi rác như `SELEC * FRM` phải dừng ở bước 1 hoặc bước 2.

Câu cuối dạy điều quan trọng nhất. Bạn không cần biết parser dễ dãi sẽ biến chuỗi rác thành gì, vì mọi nhánh không chắc chắn đều dẫn tới từ chối. Lỗi thường gặp nhất là viết ngược lại: chỉ chặn những gì đã liệt kê là xấu và cho qua phần còn lại.

Lưu sáu câu này thành test pytest ngay hôm nay. Câu nào cho kết quả khác kỳ vọng là chỗ code đang dựa vào một giả định sai về cách sqlglot dựng cây, và chúng là thứ cho bạn biết guard còn đúng hay không sau mỗi lần nâng phiên bản sqlglot đã ghim.

## Guard của bạn không phải hàng rào cuối cùng

SurrealDB đặt vấn đề rõ: nếu database từ chối chạy câu lệnh, chuyện agent bị dụ sinh ra nó thế nào không còn quan trọng. Hướng dẫn trên DEV Community cũng khuyên user database chỉ có quyền SELECT trên những bảng cụ thể, không nhạy cảm, và kết nối phải là read-only như lớp phòng thủ cuối.

Ngay cả lớp đó cũng có giới hạn. Tài liệu PostgreSQL về `SET TRANSACTION` mô tả read-only là một khái niệm ở mức cao, không ngăn được mọi thao tác ghi xuống đĩa. Vì thế nên xếp ba lớp lên nhau: guard AST, role chỉ có quyền tối thiểu, transaction read-only, và không coi lớp nào là lớp duy nhất.

## Ở site khách hàng, kỹ năng này trông thế nào

Trước khi nối agent text-to-SQL vào database của khách, hãy chuẩn bị sẵn câu trả lời cho câu hỏi: agent chạm được vào những bảng nào? File allowlist có trong code review, bộ test tấn công chạy trong CI và grant của role database là những thứ người khác kiểm chứng được, điều một đoạn system prompt không làm được.

Nếu bạn đang chuẩn bị chuyển sang vai trò FDE, hãy đưa guard này cùng bộ test lên GitHub và viết vào CV đúng điều nó làm: chặn câu không phải SELECT, phân giải CTE bằng scope, fail closed khi parse lỗi. Khi ứng tuyển vào vị trí đưa agent vào dữ liệu thật của khách, đây là một ví dụ đáng mang theo để kể trong phỏng vấn.

Ngày đầu ở chỗ khách hàng, đừng mở prompt trước. Hãy xin danh sách bảng agent thực sự cần, rồi viết allowlist và grant theo đúng danh sách đó.

**Thử ngay tuần này:**

- Cài sqlglot, ghim phiên bản trong requirements, chép hàm guard trong bài và chạy sáu câu kiểm thử, kể cả câu CTE tên 'salaries'
- Viết thêm 10 câu SQL tấn công vào guard của bạn và lưu thành test pytest
- Với agent đang chạy thật, kiểm tra role database của nó: có quyền gì ngoài SELECT, có gọi được hàm nào không

## Nguồn

- [SQLGlot README (tobymao/sqlglot)](https://github.com/tobymao/sqlglot/blob/main/README.md)

- [SQLGlot AST Primer](https://github.com/tobymao/sqlglot/blob/main/posts/ast_primer.md)

- [Even a jailbroken LLM can't exceed its database permissions (SurrealDB)](https://surrealdb.com/blog/even-a-jailbroken-llm-cant-exceed-its-database-permissions-heres-how)

- [Safe Text-to-SQL: giving an agent database access without dropping tables or leaking PII (DEV Community)](https://dev.to/kowshik_jallipalli_a7e0a5/safe-text-to-sql-giving-an-agent-database-access-without-dropping-tables-or-leaking-pii-i47)

- [LangChain SQL agent on PostgreSQL: limiting what it can execute (hoop.dev)](https://hoop.dev/blog/langchain-sql-agent-on-postgresql-limiting-what-it-can-execute)

- [SET TRANSACTION (PostgreSQL documentation)](https://www.postgresql.org/docs/current/sql-set-transaction.html)
