Mẫu prompt tối ưu hóa SQL

Nắm vững tối ưu hóa truy vấn SQL, chiến lược lập chỉ mục và phân tích EXPLAIN. Cải thiện đáng kể hiệu suất cơ sở dữ liệu và loại bỏ các truy vấn chậm.

Ví dụ sử dụng

"Phân tích dữ liệu bán hàng thương mại điện tử của tôi từ quý trước và xác định xu hướng, sản phẩm bán chạy nhất và các lĩnh vực cần cải thiện".

Prompt mẫu

Hãy dán prompt này vào bất kỳ trợ lý AI nào - Claude, ChatGPT, Gemini, Copilot, hoặc bất kỳ trợ lý nào khác.

You are a SQL optimization expert. Help me analyze and optimize database queries for maximum performance.

## Query Analysis with EXPLAIN

### PostgreSQL EXPLAIN
```sql
EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 123;

-- Key metrics to watch:
-- Seq Scan: Full table scan (often bad)
-- Index Scan: Using index (good)
-- Nested Loop: Can be slow for large datasets
-- Hash Join: Good for large joins
-- Sort: Check if index can help
```

### Reading Execution Plans
```
Seq Scan on orders  (cost=0.00..1500.00 rows=50 width=100)
       ↑                    ↑              ↑        ↑
  Scan type         Estimated cost    Est. rows   Row width

actual time=0.015..45.123 rows=47 loops=1
       ↑                    ↑       ↑
  Start time          End time   Actual rows
```

## Index Strategies

### Index Types
```sql
-- B-Tree (default, most common)
CREATE INDEX idx_customer ON orders(customer_id);

-- Composite index (order matters!)
CREATE INDEX idx_customer_date ON orders(customer_id, order_date);

-- Partial index (filtered)
CREATE INDEX idx_active_orders ON orders(status)
  WHERE status = 'pending';

-- Covering index (includes all needed columns)
CREATE INDEX idx_covering ON orders(customer_id)
  INCLUDE (total, created_at);

-- GIN index (for arrays, JSONB)
CREATE INDEX idx_tags ON products USING GIN(tags);
```

### When to Index
- WHERE clause columns
- JOIN columns
- ORDER BY columns
- High cardinality columns
- NOT: Frequently updated columns
- NOT: Low cardinality (boolean, status)

## Common Optimization Patterns

### Fix N+1 Queries
```sql
-- BAD: N+1 queries
SELECT * FROM orders WHERE customer_id = 1;
SELECT * FROM order_items WHERE order_id = 1;
SELECT * FROM order_items WHERE order_id = 2;
-- ... repeated N times

-- GOOD: Single JOIN
SELECT o.*, oi.*
FROM orders o
JOIN order_items oi ON o.id = oi.order_id
WHERE o.customer_id = 1;
```

### Cursor-Based Pagination
```sql
-- BAD: OFFSET is slow for large offsets
SELECT * FROM products ORDER BY id LIMIT 20 OFFSET 10000;

-- GOOD: Cursor pagination
SELECT * FROM products
WHERE id > 10000
ORDER BY id
LIMIT 20;
```

### Optimize Aggregations
```sql
-- Use window functions instead of subqueries
SELECT
  customer_id,
  order_total,
  SUM(order_total) OVER (PARTITION BY customer_id) as customer_total,
  AVG(order_total) OVER () as avg_total
FROM orders;
```

### Batch Operations
```sql
-- BAD: Individual inserts
INSERT INTO logs VALUES (1, 'msg1');
INSERT INTO logs VALUES (2, 'msg2');

-- GOOD: Batch insert
INSERT INTO logs VALUES
  (1, 'msg1'),
  (2, 'msg2'),
  (3, 'msg3');

-- GOOD: COPY for bulk data (PostgreSQL)
COPY logs FROM '/path/to/data.csv' WITH CSV;
```

### Use CTEs for Readability
```sql
WITH monthly_sales AS (
  SELECT
    DATE_TRUNC('month', order_date) as month,
    SUM(total) as revenue
  FROM orders
  GROUP BY 1
),
ranked AS (
  SELECT *,
    RANK() OVER (ORDER BY revenue DESC) as rank
  FROM monthly_sales
)
SELECT * FROM ranked WHERE rank <= 3;
```

## Materialized Views
```sql
-- Create materialized view for expensive queries
CREATE MATERIALIZED VIEW monthly_stats AS
SELECT
  DATE_TRUNC('month', created_at) as month,
  COUNT(*) as order_count,
  SUM(total) as revenue
FROM orders
GROUP BY 1;

-- Refresh when needed
REFRESH MATERIALIZED VIEW monthly_stats;
```

## Find Slow Queries

### PostgreSQL
```sql
-- Enable query logging
ALTER SYSTEM SET log_min_duration_statement = 1000; -- 1 second

-- Find slow queries
SELECT query, calls, mean_time, total_time
FROM pg_stat_statements
ORDER BY mean_time DESC
LIMIT 10;
```

## Best Practices

1. Always EXPLAIN ANALYZE before optimizing
2. Index foreign keys
3. Use appropriate data types
4. Avoid SELECT *
5. Use connection pooling
6. Monitor and log slow queries
7. Vacuum/analyze regularly (PostgreSQL)

Hướng dẫn sử dụng prompt

• Sao chép prompt ở trên
• Dán vào trợ lý AI của bạn (Claude, ChatGPT, v.v...)
• Điền thông tin của bạn bên dưới (tùy chọn) và sao chép để thêm vào prompt

• Gửi và bắt đầu trò chuyện với AI của bạn

Kết quả prompt mẫu được thực hiện bằng ChatGPT