SQLite到MySQL数据迁移实战与优化指南

1. SQLite到MySQL数据迁移的核心挑战

我最近接手了一个从SQLite迁移到MySQL的项目，本以为是个简单的数据搬运工作，结果踩了不少坑。SQLite和MySQL虽然都是关系型数据库，但它们在数据类型、语法特性和存储引擎上的差异，让迁移过程变得异常复杂。

SQLite作为轻量级嵌入式数据库，最大的优势是零配置和单文件存储。我在移动应用和小型工具中经常使用它，开发效率极高。但当数据量增长到百万级，并发访问需求增加时，SQLite的性能瓶颈就显现出来了。这时就需要迁移到MySQL这样的服务端数据库。

关键差异点：SQLite采用动态类型系统，而MySQL使用严格的静态类型。这意味着SQLite中你可以把字符串存到整数列里，但MySQL会直接报错。

2. 迁移前的准备工作

2.1 环境配置检查

在开始迁移前，必须确保两端环境就绪。我的工作机上已经安装了DB Browser for SQLite（版本3.12.2）和MySQL Workbench（8.0.33）。建议使用官方工具，第三方工具可能在解析SQLite文件时出现兼容性问题。

对于MySQL端，需要特别注意字符集配置。我遇到过最头疼的问题就是迁移后中文变成乱码。现在我会在MySQL中统一使用utf8mb4字符集，它完整支持emoji和所有Unicode字符。

sql复制-- MySQL字符集配置示例
CREATE DATABASE target_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

2.2 数据结构分析

先用DB Browser打开SQLite文件，系统性地检查所有表结构。重点关注以下几点：

• 自增主键的定义方式（SQLite是AUTOINCREMENT，MySQL是AUTO_INCREMENT）
• 没有显式长度的TEXT类型（MySQL需要指定VARCHAR长度）
• 日期时间格式（SQLite灵活，MySQL严格）
• 没有主键的表（MySQL的InnoDB要求每表必须有主键）

我通常会导出SQLite的schema到一个.sql文件，然后用文本编辑器全局搜索这些关键词，提前发现潜在问题。

3. 数据迁移的四种实战方案

3.1 使用SQLite导出CSV再导入MySQL

这是最直观的方法，但隐藏的坑最多。步骤如下：

1. 在DB Browser中执行导出：

   sql复制.mode csv
   .output data.csv
   SELECT * FROM table;
   

2. 在MySQL中创建匹配的表结构后导入：

   sql复制LOAD DATA INFILE 'data.csv' INTO TABLE table
   FIELDS TERMINATED BY ',' ENCLOSED BY '"'
   LINES TERMINATED BY '\n';
   

致命陷阱：CSV无法区分NULL和空字符串。如果原数据中有NULL值，导入后会变成空字符串。我的解决方案是改用SELECT语句显式处理NULL值：

sql复制SELECT 
  id,
  CASE WHEN name IS NULL THEN '\N' ELSE name END as name
FROM table;

3.2 使用Python脚本桥接

对于复杂数据结构，我更喜欢用Python写迁移脚本。核心代码结构：

python复制import sqlite3
import pymysql
from tqdm import tqdm  # 进度条显示

# 连接两端数据库
sqlite_conn = sqlite3.connect('source.db')
mysql_conn = pymysql.connect(host='localhost', user='root',
                           password='123456', db='target_db')

# 分批次迁移数据
batch_size = 1000
tables = ['users', 'products', 'orders']  # 需要迁移的表

for table in tables:
    # 读取SQLite数据
    sqlite_cur = sqlite3_conn.cursor()
    sqlite_cur.execute(f"SELECT * FROM {table}")
    
    # 获取列名
    col_names = [desc[0] for desc in sqlite_cur.description]
    
    # 准备MySQL插入语句
    placeholders = ', '.join(['%s'] * len(col_names))
    insert_sql = f"INSERT INTO {table} ({', '.join(col_names)}) VALUES ({placeholders})"
    
    # 分批插入
    while True:
        rows = sqlite_cur.fetchmany(batch_size)
        if not rows:
            break
            
        mysql_cur = mysql_conn.cursor()
        try:
            mysql_cur.executemany(insert_sql, rows)
            mysql_conn.commit()
        except Exception as e:
            print(f"Error inserting into {table}: {e}")
            mysql_conn.rollback()

这个方法的优势是可以对数据进行灵活转换。比如SQLite的布尔值存储为0/1，而MySQL有专门的BOOLEAN类型，可以在Python层做类型转换。

3.3 使用专业迁移工具

对于大型数据库（超过10GB），我推荐使用专业工具如AWS Database Migration Service或Alibaba Cloud DTS。这些工具的优势在于：

1. 自动类型映射
2. 断点续传
3. 增量同步
4. 数据校验

但要注意这些服务通常需要付费，且对网络带宽要求较高。我曾经用阿里云DTS迁移一个50GB的SQLite数据库，整个过程耗时约6小时，期间需要保持网络稳定。

3.4 使用SQL中间文件转换

另一种可靠方案是将SQLite数据库导出为SQL文件，然后修改语法后导入MySQL：

bash复制# 导出SQLite数据
sqlite3 source.db .dump > dump.sql

# 转换常见语法差异
sed -i 's/AUTOINCREMENT/AUTO_INCREMENT/g' dump.sql
sed -i 's/DATETIME/TIMESTAMP/g' dump.sql
sed -i 's/BLOB/LONGBLOB/g' dump.sql

# 导入MySQL
mysql -u root -p target_db < dump.sql

这个方法的关键在于正确处理SQLite特有的语法。比如SQLite的INSERT语句可能包含rowid，而MySQL不需要这个字段。我通常会先用小样本测试，确认转换规则无误后再处理完整数据库。

4. 迁移后的验证与优化

4.1 数据一致性检查

迁移完成后，必须验证数据完整性。我常用的检查方法：

1. 记录数比对：

   sql复制-- SQLite
   SELECT COUNT(*) FROM table;
   
   -- MySQL
   SELECT COUNT(*) FROM table;
   

2. 抽样校验：

   python复制# 随机抽查100条记录比对
   import random
   sample_ids = random.sample(range(1, max_id), 100)
   for id in sample_ids:
       sqlite_data = sqlite_cur.execute(f"SELECT * FROM table WHERE id={id}").fetchone()
       mysql_data = mysql_cur.execute(f"SELECT * FROM table WHERE id={id}").fetchone()
       assert sqlite_data == mysql_data
   

3. 校验和比对（适用于大型表）：

   sql复制-- MySQL
   SELECT 
     COUNT(*) as cnt,
     SUM(CRC32(CONCAT_WS('|', col1, col2, col3))) as checksum
   FROM table;
   

4.2 性能优化调整

MySQL的配置优化是迁移后的重要工作。根据我的经验，这几个参数需要特别关注：

ini复制# my.cnf 配置示例
[mysqld]
innodb_buffer_pool_size = 4G  # 通常设为物理内存的70-80%
innodb_log_file_size = 256M
innodb_flush_log_at_trx_commit = 2  # 在可接受少量数据丢失风险时提高性能
max_connections = 200

对于特定的查询模式，还需要创建合适的索引。我常用Percona的pt-index-usage工具分析SQLite中的查询模式，然后在MySQL中建立对应索引。

5. 常见问题解决方案

5.1 中文乱码问题

症状：迁移后中文字符显示为"???"或乱码。

解决方案：

1. 确保MySQL连接字符串指定了字符集：

   python复制mysql_conn = pymysql.connect(..., charset='utf8mb4')
   

2. 检查表级别的字符集：

   sql复制ALTER TABLE table CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
   

3. 如果使用CSV中转，确保编辑器以UTF-8保存文件

5.2 自增ID冲突

症状：插入数据时出现主键冲突。

原因：SQLite和MySQL的自增机制不同，迁移时可能打乱ID序列。

解决方案：

sql复制-- 迁移完成后重置自增计数器
ALTER TABLE table AUTO_INCREMENT = (SELECT MAX(id)+1 FROM table);

5.3 日期时间转换

SQLite的日期函数与MySQL差异很大。比如SQLite的datetime('now')对应MySQL的NOW()。

我建议在应用层统一处理日期格式，或者在迁移时进行转换：

sql复制-- 在MySQL中创建表时使用标准格式
CREATE TABLE events (
    id INT PRIMARY KEY,
    event_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
);

-- 迁移时转换SQLite的日期字符串
INSERT INTO events (id, event_time)
SELECT id, STR_TO_DATE(sqlite_date, '%Y-%m-%d %H:%M:%S') FROM source_table;

6. 高级迁移技巧

6.1 处理BLOB类型数据

SQLite和MySQL的BLOB实现有细微差别。对于存储文件、图片的场景，我推荐以下方法：

1. 在Python中使用二进制模式读写：

   python复制# 读取SQLite BLOB
   sqlite_cur.execute("SELECT blob_data FROM table WHERE id=1")
   blob_data = sqlite_cur.fetchone()[0]
   
   # 写入MySQL
   mysql_cur.execute("INSERT INTO table (blob_data) VALUES (%s)", (blob_data,))
   

2. 对于超大BLOB（>10MB），考虑分块传输：

   python复制chunk_size = 1024*1024  # 1MB
   for i in range(0, len(blob_data), chunk_size):
       chunk = blob_data[i:i+chunk_size]
       # 分批写入
   

6.2 迁移数据库视图和触发器

SQLite和MySQL的视图语法相似，但触发器语法差异较大。迁移时需要重写：

sql复制-- SQLite触发器示例
CREATE TRIGGER update_timestamp
AFTER UPDATE ON orders
BEGIN
    UPDATE orders SET updated_at = datetime('now') WHERE id = NEW.id;
END;

-- MySQL等效写法
DELIMITER //
CREATE TRIGGER update_timestamp
AFTER UPDATE ON orders
FOR EACH ROW
BEGIN
    SET NEW.updated_at = NOW();
END//
DELIMITER ;

6.3 处理外键约束

如果SQLite数据库启用了外键（PRAGMA foreign_keys=ON），在迁移到MySQL时需要注意：

1. 暂时禁用外键检查加速导入：

   sql复制SET FOREIGN_KEY_CHECKS = 0;
   -- 执行导入操作
   SET FOREIGN_KEY_CHECKS = 1;
   

2. 确保导入顺序满足外键依赖，通常需要先导入主表再导入从表。

3. 在MySQL中验证外键约束：

   sql复制SELECT TABLE_NAME, COLUMN_NAME, CONSTRAINT_NAME, 
          REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
   FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
   WHERE REFERENCED_TABLE_SCHEMA = 'your_db';
   

7. 性能对比与调优建议

迁移完成后，我通常会进行性能基准测试。以下是一个典型测试案例的结果（100万条记录）：

基于这些数据，我给团队制定了以下MySQL使用规范：

1. 总是使用批量插入代替单条插入
2. 为常用查询模式创建合适的复合索引
3. 定期执行ANALYZE TABLE更新统计信息
4. 对大表考虑分区策略

8. 自动化迁移方案

对于需要频繁迁移的场景（如开发环境同步），我开发了一个自动化脚本，主要功能包括：

1. 自动检测SQLite和MySQL的表结构差异
2. 智能类型映射（如SQLite的INTEGER→MySQL的INT）
3. 数据校验报告生成
4. 增量同步能力

核心逻辑用Python实现，关键部分如下：

python复制def auto_migrate(sqlite_path, mysql_config):
    # 结构分析
    sqlite_schema = analyze_sqlite_schema(sqlite_path)
    mysql_schema = analyze_mysql_schema(mysql_config)
    
    # 差异对比
    diff = compare_schemas(sqlite_schema, mysql_schema)
    
    # 自动修正
    for table, changes in diff.items():
        if changes['action'] == 'create':
            generate_create_table(mysql_config, table, changes['schema'])
        elif changes['action'] == 'alter':
            generate_alter_table(mysql_config, table, changes['changes'])
    
    # 数据迁移
    migrate_data(sqlite_path, mysql_config, diff)
    
    # 生成报告
    generate_report(sqlite_path, mysql_config)

这个脚本已经帮我们团队节省了数百小时的手动迁移时间。关键在于正确处理各种边界情况，比如默认值处理、非空约束、唯一索引等。

9. 云环境下的特殊考量

当MySQL部署在云服务（如AWS RDS或阿里云RDS）时，迁移工作还需要考虑：

1. 网络带宽限制：大型数据库迁移可能需要申请临时带宽提升
2. 安全组规则：确保迁移客户端IP被允许访问数据库端口
3. 云服务商的特殊限制：如RDS通常不允许SUPER权限，影响某些SQL操作
4. 监控指标：关注迁移期间的CPU、IOPS使用情况，避免影响生产环境

我常用的云迁移命令示例：

bash复制# 使用mysqldump配合管道直接传输
sqlite3 source.db .dump | \
sed 's/SQLite/MYSQL/g' | \
mysql -h rds-host -u user -p target_db

10. 迁移后的应用适配

数据库迁移只是第一步，应用层通常需要相应调整：

1. 连接字符串配置变更

   python复制# SQLite连接
   conn = sqlite3.connect('file.db')
   
   # MySQL连接
   conn = pymysql.connect(host='localhost', user='user',
                        password='pass', database='db')
   

2. SQL方言适配：

   • LIMIT子句语法（SQLite: LIMIT offset, count；MySQL: LIMIT count OFFSET offset）
   • 字符串连接（SQLite: || ；MySQL: CONCAT()）
   • 获取最后插入ID（SQLite: last_insert_rowid()；MySQL: LAST_INSERT_ID()）

3. 事务行为差异：

   • SQLite默认启用自动提交，MySQL需要显式BEGIN/COMMIT
   • 隔离级别配置方式不同

4. 并发处理：

   • MySQL需要正确处理连接池
   • 注意锁等待超时设置

我在实际项目中总结了一个适配层代码模板，可以平滑处理这些差异：

python复制class DatabaseAdapter:
    def __init__(self, db_type):
        self.db_type = db_type
        
    def connect(self, **kwargs):
        if self.db_type == 'sqlite':
            return sqlite3.connect(kwargs['path'])
        elif self.db_type == 'mysql':
            return pymysql.connect(**kwargs)
    
    def last_insert_id(self, cursor):
        if self.db_type == 'sqlite':
            return cursor.lastrowid
        elif self.db_type == 'mysql':
            cursor.execute("SELECT LAST_INSERT_ID()")
            return cursor.fetchone()[0]
    
    def limit_clause(self, offset, count):
        if self.db_type == 'sqlite':
            return f"LIMIT {offset}, {count}"
        elif self.db_type == 'mysql':
            return f"LIMIT {count} OFFSET {offset}"

这个适配器模式让应用代码可以无缝切换底层数据库，大大降低了迁移风险。