<think>我们正在开发一个Java程序，用于将
SQL Server数据库迁移到My
SQL，包括格式转换和
数据迁移。
根据之前的讨论，我们需要考虑以下几个方面：
1.
SQL语法转换（如分页、字符串连接、日期函数等）
2.
数据类型映射（如将
SQL Server的NVARCHAR(MAX)映射为My
SQL的LONGTEXT等）
3. 特殊字段处理（如
SQL Server的timestamp类型，在My
SQL中需要转换为合适的类型）
4.
数据迁移方式（全量迁移、增量迁移、性能优化等）
5. 连接配置（不同的JDBC连接字符串和驱动）
根据引用[1]和[3]，我们可以采用以下步骤：
步骤1：将
SQL Server的.mdf文件
导入到
SQL Server数据库中（这一步我们的Java程序可能不直接处理，但需要确保有可连接的
SQL Server数据库）
步骤2：通过Java程序读取
SQL Server的
数据，同时进行格式转换（
SQL语法转换和
数据类型映射）
步骤3：将转换后的
数据写入到My
SQL（可以先写入本地My
SQL，验证后再
导入生产环境）
设计思路：
1. 使用JDBC连接
SQL Server和My
SQL。
2. 读取
SQL Server的表结构（元
数据），并转换为My
SQL的表结构（DDL）。
3. 根据表结构在My
SQL中创建表。
4. 分批次读取
SQL Server的
数据，进行必要的
数据类型转换，然后写入My
SQL。
重点问题：
1. 表结构转换（包括
数据类型、主键、自增列、索引等）
2.
数据分批迁移（避免内存溢出）
3. 特殊类型处理（如timestamp、blob等）
程序结构：
1. 配置读取（两个
数据库的连接信息）
2. 获取
SQL Server的元
数据（表、列、主键、索引等）
3. 生成My
SQL的DDL
4. 在My
SQL中执行DDL创建表
5.
数据迁移（按表进行，每个表按批次读取和写入）
代码示例：
我们将按照以下步骤实现：
步骤1：配置
数据库连接
步骤2：获取
SQL Server的所有表名
步骤3：对于每个表，获取其列信息，并生成对应的My
SQL建表语句
步骤4：在My
SQL中执行建表语句
步骤5：迁移
数据（使用分页查询，分批读取和插入）
注意：由于
数据量可能很大（百万级），我们需要使用分页查询并控制事务大小。
具体实现如下：</think>### Java程序实现
SQL Server到My
SQL的
数据迁移与格式转换
我将设计一个完整的Java迁移程序，包含表结构转换、
数据迁移和格式适配三大模块，核心架构如下：
```mermaid
classDiagram
class
SQLServerToMy
SQLMigrator {
+migrateSchema() : void
+transferData() : void
+validateData() : void
}
class SchemaConverter {
+convertDDL(
sqlServerDDL: String) : String
+mapDataType(
sqlServerType: String) : String
}
class DataTransfer {
+batchTransfer(batchSize: int) : void
+handleSpecialTypes() : void
}
SQLServerToMy
SQLMigrator --> SchemaConverter
SQLServerToMy
SQLMigrator --> DataTransfer
```
#### 一、核心实现代码
```java
import java.
sql.*;
import java.util.*;
public class
SQLServerToMy
SQLMigrator {
//
数据库连接配置
private static final String
SQL_
SERVER_URL = "jdbc:
sqlserver://localhost:1433;databaseName=sourceDB";
private static final String MY
SQL_URL = "jdbc:my
sql://localhost:3306/targetDB?useUnicode=true&characterEncoding=utf8";
private static final String USER = "admin";
private static final String PASS = "password";
public static void main(String[] args) {
try (Connection
sqlConn = DriverManager.getConnection(
SQL_
SERVER_URL, USER, PASS);
Connection my
sqlConn = DriverManager.getConnection(MY
SQL_URL, USER, PASS)) {
// 1. 表结构迁移
migrateSchema(
sqlConn, my
sqlConn);
// 2.
数据迁移
transferData(
sqlConn, my
sqlConn, 5000); // 每批5000条
// 3.
数据校验
validateData(
sqlConn, my
sqlConn);
} catch (
SQLException e) {
e.printStackTrace();
}
}
// 表结构转换方法
private static void migrateSchema(Connection
sqlConn, Connection my
sqlConn) throws
SQLException {
DatabaseMetaData meta =
sqlConn.getMetaData();
try (ResultSet
tables = meta.get
Tables(null, null, "%", new String[]{"
TABLE"})) {
while (
tables.next()) {
String
tableName =
tables.getString("
TABLE_NAME");
String my
sqlDDL = convertDDL(
sqlConn,
tableName);
try (Statement stmt = my
sqlConn.createStatement()) {
stmt.execute("DROP
TABLE IF EXISTS " +
tableName);
stmt.execute(my
sqlDDL);
}
}
}
}
// DDL转换器
private static String convertDDL(Connection
sqlConn, String
tableName) throws
SQLException {
StringBuilder ddl = new StringBuilder("CREATE
TABLE " +
tableName + " (\n");
DatabaseMetaData meta =
sqlConn.getMetaData();
try (ResultSet columns = meta.getColumns(null, null,
tableName, null)) {
while (columns.next()) {
String colName = columns.getString("COLUMN_NAME");
String
sqlType = columns.getString("TYPE_NAME");
int size = columns.getInt("COLUMN_SIZE");
// 类型映射（核心转换逻辑）
String my
sqlType = mapDataType(
sqlType, size);
// 主键处理
String isPrimary = isPrimaryKey(meta,
tableName, colName) ? " PRIMARY KEY" : "";
// 自增列处理
String autoIncr = "auto_increment".equals(columns.getString("IS_AUTOINCREMENT"))
? " AUTO_INCREMENT" : "";
ddl.append(" ").append(colName).append(" ").append(my
sqlType)
.append(isPrimary).append(autoIncr).append(",\n");
}
}
ddl.deleteCharAt(ddl.lastIndexOf(",")).append("\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4");
return ddl.toString();
}
//
数据类型映射（核心转换规则）
private static String mapDataType(String
sqlType, int size) {
switch (
sqlType.toUpperCase()) {
case "NVARCHAR":
case "VARCHAR":
return size > 65535 ? "LONGTEXT" : "VARCHAR(" + size + ") CHARACTER SET utf8mb4";
case "DATETIME":
return "DATETIME";
case "INT":
return "INT";
case "BIT":
return "TINYINT(1)";
case "TIMESTAMP": //
SQL Server的timestamp特殊处理[^1]
return "BINARY(8) COMMENT '
SQL Server timestamp converted'";
case "FLOAT":
return "FLOAT";
case "TEXT":
return "LONGTEXT CHARACTER SET utf8mb4";
default:
return
sqlType + " /* UNMAPPED_TYPE */";
}
}
//
数据迁移方法（分批处理）
private static void transferData(Connection
sqlConn, Connection my
sqlConn, int batchSize)
throws
SQLException {
DatabaseMetaData meta =
sqlConn.getMetaData();
try (ResultSet
tables = meta.get
Tables(null, null, "%", new String[]{"
TABLE"})) {
while (
tables.next()) {
String
tableName =
tables.getString("
TABLE_NAME");
try (Statement countStmt =
sqlConn.createStatement();
ResultSet countRs = countStmt.executeQuery("SELECT COUNT(*) FROM " +
tableName)) {
countRs.next();
int total = countRs.getInt(1);
int offset = 0;
while (offset < total) {
String
sql = "SELECT * FROM " +
tableName + " ORDER BY 1 OFFSET "
+ offset + " ROWS FETCH NEXT " + batchSize + " ROWS ONLY";
try (PreparedStatement pstmt =
sqlConn.prepareStatement(
sql);
ResultSet rs = pstmt.executeQuery()) {
// 构建My
SQL插入语句
StringBuilder
insertSql = new StringBuilder("
INSERT INTO " +
tableName + " VALUES (");
for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) {
insertSql.append(i > 0 ? ",?" : "?");
}
insertSql.append(")");
// 批处理插入
try (PreparedStatement my
sqlStmt = my
sqlConn.prepareStatement(
insertSql.toString())) {
my
sqlConn.setAutoCommit(false);
int count = 0;
while (rs.next()) {
for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) {
// 特殊类型处理
if ("timestamp".equalsIgnoreCase(rs.getMetaData().getColumnTypeName(i))) {
byte[] bytes = rs.getBytes(i);
my
sqlStmt.setBytes(i, bytes);
} else {
my
sqlStmt.setObject(i, rs.getObject(i));
}
}
my
sqlStmt.addBatch();
if (++count % 1000 == 0) my
sqlStmt.executeBatch();
}
my
sqlStmt.executeBatch();
my
sqlConn.commit();
}
}
offset += batchSize;
}
}
}
}
}
}
```
#### 二、关键功能实现说明
1. **表结构转换**
- 自动识别
SQL Server数据类型并映射到My
SQL
- 特殊类型处理：
- `NVARCHAR(MAX)` → `LONGTEXT CHARACTER SET utf8mb4`
- `TIMESTAMP` → `BINARY(8)`（
SQL Server的timestamp是二进制版本戳[^1]）
- `BIT` → `TINYINT(1)`
- 字符集统一设置为`utf8mb4`避免中文乱码
2. **
数据迁移优化**
- 分批处理机制：通过`OFFSET FETCH`分页读取
- 批处理插入：每1000条执行一次batch操作
- 事务控制：每批
数据独立提交
- 特殊类型转换：
```java
// TIMESTAMP字段处理
if ("timestamp".equalsIgnoreCase(rs.getMetaData().getColumnTypeName(i))) {
byte[] bytes = rs.getBytes(i);
my
sqlStmt.setBytes(i, bytes);
}
```
3. **
数据校验模块**
```java
private static void validateData(Connection
sqlConn, Connection my
sqlConn) throws
SQLException {
try (Statement
sqlStmt =
sqlConn.createStatement();
Statement my
sqlStmt = my
sqlConn.createStatement()) {
ResultSet
tables =
sqlConn.getMetaData().get
Tables(null, null, "%", new String[]{"
TABLE"});
while (
tables.next()) {
String
table =
tables.getString("
TABLE_NAME");
ResultSet
sqlCount =
sqlStmt.executeQuery("SELECT COUNT(*) FROM " +
table);
ResultSet my
sqlCount = my
sqlStmt.executeQuery("SELECT COUNT(*) FROM " +
table);
sqlCount.next();
my
sqlCount.next();
if (
sqlCount.getInt(1) != my
sqlCount.getInt(1)) {
System.err.println("
数据不一致: " +
table);
}
}
}
}
```
#### 三、迁移执行流程
1. **准备阶段**
- 配置JDBC驱动：
```xml
<!--
SQL Server -->
<dependency>
<groupId>com.microsoft.
sqlserver</groupId>
<artifactId>ms
sql-jdbc</artifactId>
<version>11.2.0.jre18</version>
</dependency>
<!-- My
SQL -->
<dependency>
<groupId>my
sql</groupId>
<artifactId>my
sql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
```
2. **执行迁移**
```bash
java -jar migrator.jar \
--source jdbc:
sqlserver://db
server:1433 \
--target jdbc:my
sql://my
sqlserver:3306 \
--batch-size 10000
```
3. **验证结果**
- 记录计数比对
- 抽样
数据校验
- 使用`
UltraCompare`进行二进制校验[^2]
#### 四、百万级
数据迁移优化
1. **性能提升技巧**
```java
// 1. 禁用索引加速插入
stmt.execute("ALTER
TABLE " +
table + " DISABLE KEYS");
// 2. 使用LOAD DATA INFILE替代
INSERT
String loadData = "LOAD DATA LOCAL INFILE '/tmp/data.csv'
INTO
TABLE " +
table + " CHARACTER SET utf8mb4";
// 3. 调整JDBC参数
my
sqlUrl += "&rewriteBatchedStatements=true&use
ServerPrepStmts=false";
```
2. **断点续传实现**
```java
// 记录已迁移的表和位置
Properties progress = new Properties();
try (InputStream is = new FileInputStream("migration.progress")) {
progress.load(is);
}
// 从断点继续
if (progress.containsKey(
tableName)) {
offset = Integer.parseInt(progress.getProperty(
tableName));
}
```
> **重要提示**：对于800万+
数据的迁移[^1]：
> 1. 先在本地My
SQL测试迁移
> 2. 生产环境迁移前备份
数据
> 3. 使用`my
sqldump`导出本地
数据
> 4.
导入生产环境前停止写操作
本文介绍了一种使用UltraEdit软件将Excel数据批量导入SQLServer表的方法，包括数据复制、替换分隔符、调整语句格式并执行SQL语句的过程，特别注意特殊字符的数据处理限制。
扫一扫
2180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
