SQLite 数据库性能测试（完整方案 + 可直接运行代码）
# SQLite 数据库性能测试（完整方案+可直接运行代码）
SQLite 是**嵌入式轻量数据库**，性能受**事务、索引、批量写入、查询复杂度、磁盘IO**影响极大。我给你一套**开箱即用、覆盖核心场景**的性能测试方案，包含：
- 写入性能（单条/批量）
- 查询性能（简单/范围/聚合）
- 索引影响
- 并发读写
- 优化建议
## 一、测试环境说明
- 语言：Python3（无需安装，自带 `sqlite3`）
- 工具：`timeit` / `time` 计时
- 测试表：用户表（id, name, age, email, create_time）
- 测试量级：1万 ~ 100万行（可自行调整）
## 二、完整性能测试代码（直接复制运行）
```python
import sqlite3
import time
import random
import string
# --------------------------
# 1. 初始化连接 + 建表
# --------------------------
conn = sqlite3.connect('sqlite_perf_test.db')
cursor = conn.cursor()
# 测试表（无索引）
cursor.execute('''
CREATE TABLE IF NOT EXISTS user (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
age INTEGER,
email TEXT UNIQUE,
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
# 带索引的表（用于对比索引性能）
cursor.execute('''
CREATE TABLE IF NOT EXISTS user_index (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
age INTEGER,
email TEXT UNIQUE,
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
cursor.execute('CREATE INDEX IF NOT EXISTS idx_age ON user_index(age)')
conn.commit()
# --------------------------
# 工具函数：生成随机数据
# --------------------------
def random_str(n=8):
return ''.join(random.choices(string.ascii_lowercase, k=n))
def generate_user():
name = random_str()
age = random.randint(10, 80)
email = f"{random_str(10)}@test.com"
return (name, age, email)
# --------------------------
# 2. 性能测试：单条插入（无事务）最慢
# --------------------------
def test_insert_single(count=10000):
print(f"\n===== 单条插入（无事务）{count} 条 =====")
start = time.time()
for _ in range(count):
cursor.execute("INSERT INTO user (name, age, email) VALUES (?, ?, ?)", generate_user())
conn.commit()
cost = time.time() - start
print(f"耗时：{cost:.2f}s 速度：{count/cost:.0f} 条/秒")
# --------------------------
# 3. 性能测试：批量插入（事务）最快
# --------------------------
def test_insert_batch(count=100000, batch=1000):
print(f"\n===== 批量插入 {count} 条（每批{batch}） =====")
start = time.time()
for i in range(0, count, batch):
users = [generate_user() for _ in range(min(batch, count - i))]
cursor.executemany("INSERT INTO user (name, age, email) VALUES (?, ?, ?)", users)
conn.commit()
cost = time.time() - start
print(f"耗时：{cost:.2f}s 速度：{count/cost:.0f} 条/秒")
# --------------------------
# 4. 性能测试：简单查询（主键）
# --------------------------
def test_query_pk(count=10000):
print(f"\n===== 主键查询 {count} 次 =====")
start = time.time()
for _ in range(count):
_id = random.randint(1, 100000)
cursor.execute("SELECT * FROM user WHERE id = ?", (_id,))
cursor.fetchone()
cost = time.time() - start
print(f"耗时：{cost:.2f}s QPS：{count/cost:.0f}")
# --------------------------
# 5. 性能测试：无索引范围查询 vs 有索引
# --------------------------
def test_query_range():
print("\n===== 范围查询（age=25）对比 =====")
# 无索引
start = time.time()
cursor.execute("SELECT * FROM user WHERE age = 25")
cursor.fetchall()
cost_no_idx = time.time() - start
# 有索引
start = time.time()
cursor.execute("SELECT * FROM user_index WHERE age = 25")
cursor.fetchall()
cost_idx = time.time() - start
print(f"无索引：{cost_no_idx:.4f}s")
print(f"有索引：{cost_idx:.4f}s")
print(f"索引加速：{cost_no_idx/cost_idx:.1f} 倍")
# --------------------------
# 6. 性能测试：聚合查询 COUNT/SUM
# --------------------------
def test_aggregate():
print("\n===== 聚合查询 COUNT(*) =====")
start = time.time()
cursor.execute("SELECT COUNT(*) FROM user")
cursor.fetchone()
cost = time.time() - start
print(f"耗时：{cost:.4f}s")
# --------------------------
# 7. 清空表（方便重复测试）
# --------------------------
def clear_table():
cursor.execute("DELETE FROM user")
cursor.execute("DELETE FROM user_index")
conn.commit()
print("\n表已清空")
# --------------------------
# 执行所有测试
# --------------------------
if __name__ == '__main__':
clear_table() # 清空数据
test_insert_single(10000) # 单条插入 1w
clear_table()
test_insert_batch(100000) # 批量插入 10w
test_query_pk(10000) # 主键查询
test_query_range() # 范围查询（索引对比）
test_aggregate() # 聚合查询
conn.close()
print("\n===== 测试完成 =====")
```
## 三、典型测试结果（参考）
| 测试场景 | 数据量 | 耗时 | 性能 |
|---------|--------|------|------|
| 单条插入（无事务） | 1万 | 8~15s | 1000 条/秒 |
| 批量插入（事务） | 10万 | 0.3~0.8s | **15万+ 条/秒** |
| 主键查询 | 1万次 | 0.1~0.3s | 5万+ QPS |
| 无索引范围查询 | 10万行 | 0.01~0.03s | - |
| 有索引范围查询 | 10万行 | 0.001~0.003s | **加速 10~20 倍** |
| COUNT(*) | 100万行 | 0.005s | 极快 |
## 四、SQLite 性能关键结论
### 1. **写入性能：事务决定一切**
- **无事务单条写入**：极慢（每次写入都刷磁盘）
- **批量事务写入**：提升 **50~200 倍**
- 最佳批量大小：**500~5000 条/批**
### 2. **查询性能：索引是核心**
- 主键/唯一索引查询：**毫秒级**
- 无索引全表扫描：数据量大后急剧变慢
- 范围查询、WHERE 条件字段**必须建索引**
### 3. **SQLite 不适合场景**
- 高并发写入（多线程/多进程频繁写入）
- 超大数据（>10GB）
- 分布式、主从同步
## 五、SQLite 性能优化配置（直接加在代码里）
```python
# 连接时加优化参数，性能提升 20%~50%
conn = sqlite3.connect('sqlite_perf_test.db', check_same_thread=False)
cursor = conn.cursor()
# 关键优化
cursor.execute("PRAGMA synchronous = NORMAL") # 降低磁盘刷写频率
cursor.execute("PRAGMA journal_mode = WAL") # 开启 WAL 模式（最重要）
cursor.execute("PRAGMA cache_size = -100000") # 100MB 缓存
cursor.execute("PRAGMA temp_store = MEMORY") # 临时表放内存
```
**WAL 模式**：读写可并发，性能提升巨大。
## 六、进阶：压测 100万+ 数据
把批量插入数量改成 `1000000` 即可测试海量数据性能：
```python
test_insert_batch(1000000, batch=2000)
```
- 100万行批量写入：**1~3 秒**
- 占用空间：~50MB（SQLite 极省空间）
---
### 总结
1. **批量+事务**是 SQLite 写入性能的关键
2. **WAL 模式 + 索引**是查询优化核心
3. 适合：单机、中小数据、读多写少、嵌入式场景
4. 不适合：高并发写入、海量分布式场景
扫一扫，关注我们