SQL Queries với Claude — Hướng dẫn nhanh

Không phải ai cũng thành thạo SQL. Với Claude, bạn chỉ cần mô tả dữ liệu bạn muốn lấy bằng ngôn ngữ tự nhiên — Claude sẽ viết SQL cho bạn. Bài này hướng dẫn cách tích hợp Claude vào workflow làm việc với database.

Use case phổ biến nhất

• Data analyst cần query ad-hoc mà không muốn nhớ syntax phức tạp
• Developer muốn giải thích query của người khác để debug
• Product manager muốn tự query data mà không phụ thuộc engineer
• Chatbot "nói chuyện với database" bằng ngôn ngữ tự nhiên

Setup cơ bản

import anthropic

client = anthropic.Anthropic()

# Schema của database — đây là phần quan trọng nhất
SCHEMA = """
Database: E-commerce platform

Bảng users:
  - user_id (INT, PRIMARY KEY)
  - name (VARCHAR)
  - email (VARCHAR)
  - created_at (DATETIME)
  - country (VARCHAR)

Bảng orders:
  - order_id (INT, PRIMARY KEY)
  - user_id (INT, FOREIGN KEY -> users)
  - total_amount (DECIMAL)
  - status (VARCHAR: pending/completed/cancelled)
  - created_at (DATETIME)

Bảng order_items:
  - item_id (INT, PRIMARY KEY)
  - order_id (INT, FOREIGN KEY -> orders)
  - product_name (VARCHAR)
  - quantity (INT)
  - unit_price (DECIMAL)

Bảng products:
  - product_id (INT, PRIMARY KEY)
  - name (VARCHAR)
  - category (VARCHAR)
  - price (DECIMAL)
  - stock (INT)
"""

SQL_SYSTEM_PROMPT = f"""Bạn là chuyên gia SQL. Nhiệm vụ: chuyển yêu cầu tiếng Việt thành SQL query chính xác.

Schema database:
{SCHEMA}

Quy tắc:
1. Chỉ viết SQL hợp lệ cho MySQL/PostgreSQL
2. Luôn dùng alias rõ ràng (u for users, o for orders, v.v.)
3. Thêm comment ngắn giải thích logic phức tạp
4. Format SQL gọn gàng, dễ đọc
5. Trả về SQL trong tag  và giải thích trong tag """

Function chính: Text-to-SQL

def text_to_sql(question: str) -> dict:
    """Chuyển câu hỏi tự nhiên thành SQL query."""
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=800,
        system=SQL_SYSTEM_PROMPT,
        messages=[{"role": "user", "content": question}],
        temperature=0.0,
    )

    import re
    text = response.content[0].text

    sql_match = re.search(r"(.*?)", text, re.DOTALL)
    exp_match = re.search(r"(.*?)", text, re.DOTALL)

    sql = sql_match.group(1).strip() if sql_match else text
    explanation = exp_match.group(1).strip() if exp_match else ""

    return {"sql": sql, "explanation": explanation}

# Test các câu hỏi thực tế
questions = [
    "Lấy 10 user đăng ký gần đây nhất",
    "Doanh thu tổng của tháng 12/2024",
    "Top 5 sản phẩm bán chạy nhất theo số lượng",
    "Tỉ lệ đơn hàng bị cancel theo từng tháng trong năm 2024",
    "Users đã mua hàng hơn 3 lần và tổng chi tiêu trên 10 triệu VND",
]

for q in questions:
    result = text_to_sql(q)
    print(f"
Câu hỏi: {q}")
    print(f"SQL:
{result['sql']}")
    if result['explanation']:
        print(f"Giải thích: {result['explanation'][:100]}...")

Ví dụ kết quả thực tế

Với câu hỏi "Top 5 sản phẩm bán chạy nhất", Claude sẽ generate:

SELECT
    p.name AS product_name,
    p.category,
    SUM(oi.quantity) AS total_sold,
    SUM(oi.quantity * oi.unit_price) AS total_revenue
FROM order_items oi
JOIN orders o ON oi.order_id = o.order_id
JOIN products p ON oi.product_name = p.name
WHERE o.status = 'completed'  -- Chỉ tính đơn hoàn thành
GROUP BY p.product_id, p.name, p.category
ORDER BY total_sold DESC
LIMIT 5;

SQL Explainer — Giải thích query sẵn có

def explain_sql(sql_query: str) -> str:
    """Giải thích SQL query bằng tiếng Việt đơn giản."""
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"""Giải thích SQL query sau bằng tiếng Việt đơn giản,
dễ hiểu cho người không biết SQL:

{sql_query}

Giải thích:
1. Query này lấy dữ liệu gì?
2. Điều kiện lọc là gì?
3. Kết quả được sắp xếp/nhóm như thế nào?"""
        }],
        temperature=0.0,
    )
    return response.content[0].text

complex_query = """
SELECT
    u.country,
    COUNT(DISTINCT u.user_id) as total_users,
    COUNT(o.order_id) as total_orders,
    ROUND(AVG(o.total_amount), 2) as avg_order_value
FROM users u
LEFT JOIN orders o ON u.user_id = o.user_id
    AND o.status = 'completed'
    AND o.created_at >= DATE_SUB(NOW(), INTERVAL 90 DAY)
GROUP BY u.country
HAVING total_users > 10
ORDER BY avg_order_value DESC;
"""

print(explain_sql(complex_query))

SQL Debugger — Tìm lỗi trong query

def debug_sql(broken_query: str, error_message: str = None) -> dict:
    """Tìm và sửa lỗi trong SQL query."""
    context = f"
Lỗi database báo: {error_message}" if error_message else ""

    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=800,
        system=SQL_SYSTEM_PROMPT,
        messages=[{
            "role": "user",
            "content": f"""Query sau có lỗi, hãy tìm và sửa:{context}

{broken_query}

Trả về:
Mô tả vấn đề
SQL đã sửa
Những thay đổi đã thực hiện"""
        }],
        temperature=0.0,
    )

    import re
    text = response.content[0].text

    return {
        "issue": re.search(r"(.*?)", text, re.DOTALL).group(1).strip() if re.search(r"", text) else "",
        "fixed_sql": re.search(r"(.*?)", text, re.DOTALL).group(1).strip() if re.search(r"", text) else "",
        "changes": re.search(r"(.*?)", text, re.DOTALL).group(1).strip() if re.search(r"", text) else "",
    }

# Test với query có lỗi
broken = """
SELECT user_id, name, SUM(total_amount)
FROM users, orders
WHERE users.id = orders.user_id
GROUP BY name
HAVING SUM > 1000000
ORDER BY 3 DESC
"""

result = debug_sql(broken, "Column 'users.id' doesn't exist")
print(f"Vấn đề: {result['issue']}")
print(f"
SQL đã sửa:
{result['fixed_sql']}")
print(f"
Thay đổi: {result['changes']}")

Natural Language Interface cho ứng dụng

import sqlite3

def nl_query_database(question: str, db_path: str) -> dict:
    """
    Full pipeline: câu hỏi tự nhiên -> SQL -> thực thi -> kết quả.
    """
    # Bước 1: Generate SQL
    sql_result = text_to_sql(question)
    sql = sql_result["sql"]

    # Bước 2: Thực thi query
    try:
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()
        cursor.execute(sql)
        columns = [desc[0] for desc in cursor.description]
        rows = cursor.fetchall()
        conn.close()

        # Format kết quả
        data = [dict(zip(columns, row)) for row in rows]

        return {
            "question": question,
            "sql": sql,
            "success": True,
            "row_count": len(data),
            "data": data[:10],  # Giới hạn 10 rows để display
        }

    except Exception as e:
        return {
            "question": question,
            "sql": sql,
            "success": False,
            "error": str(e),
        }

# Usage
result = nl_query_database(
    "Có bao nhiêu user đăng ký trong tuần này?",
    "ecommerce.db"
)

if result["success"]:
    print(f"Kết quả: {result['row_count']} rows")
    for row in result["data"]:
        print(row)
else:
    print(f"Lỗi: {result['error']}")

Tips để get query tốt hơn

• Cung cấp schema đầy đủ: Càng chi tiết schema trong system prompt, query càng chính xác
• Chỉ định database type: MySQL, PostgreSQL, SQLite có syntax khác nhau — nói rõ để tránh nhầm lẫn
• Mô tả kết quả mong muốn: "Top 10", "theo tháng", "chỉ tính đơn completed" — càng cụ thể càng tốt
• Temperature = 0: Luôn dùng temperature=0.0 cho SQL generation — không cần creativity, cần chính xác
• Validate trước khi chạy: Với production database, luôn review SQL trước khi execute

Text-to-SQL là một trong những ứng dụng thực tế nhất của Claude trong môi trường doanh nghiệp. Kết hợp với JSON Mode để trả về kết quả có cấu trúc cho frontend hiển thị.