876 lines
24 KiB
Go
876 lines
24 KiB
Go
package dbclient
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
mysqldriver "github.com/go-sql-driver/mysql"
|
||
"gorm.io/driver/mysql"
|
||
"gorm.io/gorm"
|
||
"gorm.io/gorm/logger"
|
||
)
|
||
|
||
// MySQLClient MySQL 客户端
|
||
type MySQLClient struct {
|
||
db *gorm.DB
|
||
sqlDB *sql.DB
|
||
config *MySQLConfig
|
||
}
|
||
|
||
// MySQLConfig MySQL 配置
|
||
type MySQLConfig struct {
|
||
Host string
|
||
Port int
|
||
Username string
|
||
Password string
|
||
Database string
|
||
}
|
||
|
||
// NewMySQLClient 创建 MySQL 客户端
|
||
func NewMySQLClient(config *MySQLConfig) (*MySQLClient, error) {
|
||
// 构建 DSN
|
||
mysqlConfig := mysqldriver.Config{
|
||
User: config.Username,
|
||
Passwd: config.Password,
|
||
Net: "tcp",
|
||
Addr: fmt.Sprintf("%s:%d", config.Host, config.Port),
|
||
DBName: config.Database,
|
||
Params: map[string]string{
|
||
"charset": "utf8mb4",
|
||
"parseTime": "True",
|
||
"loc": "Local",
|
||
"multiStatements": "true", // 支持多条SQL语句执行
|
||
},
|
||
AllowNativePasswords: true,
|
||
Timeout: 5 * time.Second,
|
||
}
|
||
dsn := mysqlConfig.FormatDSN()
|
||
|
||
// GORM 配置
|
||
gormConfig := &gorm.Config{
|
||
Logger: logger.Default.LogMode(logger.Silent),
|
||
}
|
||
|
||
// 打开连接
|
||
db, err := gorm.Open(mysql.Open(dsn), gormConfig)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("连接 MySQL 失败: %v", err)
|
||
}
|
||
|
||
// 获取底层 sql.DB
|
||
sqlDB, err := db.DB()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取数据库实例失败: %v", err)
|
||
}
|
||
|
||
// 测试连接
|
||
if err := sqlDB.Ping(); err != nil {
|
||
return nil, fmt.Errorf("MySQL 连接测试失败: %v", err)
|
||
}
|
||
|
||
// 设置连接池参数
|
||
sqlDB.SetMaxOpenConns(10)
|
||
sqlDB.SetMaxIdleConns(2)
|
||
sqlDB.SetConnMaxLifetime(5 * time.Minute)
|
||
|
||
return &MySQLClient{
|
||
db: db,
|
||
sqlDB: sqlDB,
|
||
config: config,
|
||
}, nil
|
||
}
|
||
|
||
// TestConnection 测试连接
|
||
func TestMySQLConnection(host string, port int, username, password, database string) error {
|
||
config := &MySQLConfig{
|
||
Host: host,
|
||
Port: port,
|
||
Username: username,
|
||
Password: password,
|
||
Database: database,
|
||
}
|
||
client, err := NewMySQLClient(config)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer client.Close()
|
||
return nil
|
||
}
|
||
|
||
// Close 关闭连接
|
||
func (c *MySQLClient) Close() error {
|
||
if c.sqlDB != nil {
|
||
return c.sqlDB.Close()
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// QueryResult 查询结果，包含数据和列顺序
|
||
type QueryResult struct {
|
||
Data []map[string]interface{}
|
||
Columns []string
|
||
}
|
||
|
||
// ExecuteQuery 执行查询 SQL
|
||
// database 参数可选，如果提供且不为空则优先使用，否则使用配置中的数据库
|
||
// 注意：SQL 语句应该已经包含 LIMIT 和 OFFSET（由客户端添加）
|
||
func (c *MySQLClient) ExecuteQuery(ctx context.Context, sqlStr string, database string) (*QueryResult, error) {
|
||
// 确定要使用的数据库
|
||
dbName := database
|
||
if dbName == "" {
|
||
dbName = c.config.Database
|
||
}
|
||
|
||
// 使用 Session 创建独立的数据库会话，避免影响其他查询
|
||
db := c.db.Session(&gorm.Session{})
|
||
|
||
// 如果指定了数据库，先切换到该数据库
|
||
if dbName != "" {
|
||
if err := db.Exec(fmt.Sprintf("USE `%s`", dbName)).Error; err != nil {
|
||
return nil, fmt.Errorf("切换数据库失败: %v", err)
|
||
}
|
||
}
|
||
|
||
rows, err := db.Raw(sqlStr).Rows()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("执行查询失败: %v", err)
|
||
}
|
||
defer rows.Close()
|
||
|
||
// 检查 rows 错误
|
||
if err := rows.Err(); err != nil {
|
||
return nil, fmt.Errorf("查询结果错误: %v", err)
|
||
}
|
||
|
||
// 获取列名
|
||
columns, err := rows.Columns()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取列名失败: %v", err)
|
||
}
|
||
|
||
// 如果没有列，返回空数组
|
||
if len(columns) == 0 {
|
||
return &QueryResult{
|
||
Data: []map[string]interface{}{},
|
||
Columns: []string{},
|
||
}, nil
|
||
}
|
||
|
||
// 读取数据
|
||
var results []map[string]interface{}
|
||
for rows.Next() {
|
||
// 创建值数组和指针数组
|
||
values := make([]interface{}, len(columns))
|
||
valuePtrs := make([]interface{}, len(columns))
|
||
for i := range values {
|
||
valuePtrs[i] = &values[i]
|
||
}
|
||
|
||
// 扫描行数据
|
||
if err := rows.Scan(valuePtrs...); err != nil {
|
||
return nil, fmt.Errorf("扫描数据失败: %v", err)
|
||
}
|
||
|
||
// 构建结果 map，按照列顺序构建
|
||
row := make(map[string]interface{})
|
||
for i, col := range columns {
|
||
val := values[i]
|
||
// 处理 nil 值
|
||
if val == nil {
|
||
row[col] = nil
|
||
} else if b, ok := val.([]byte); ok {
|
||
// 处理 []byte 类型
|
||
row[col] = string(b)
|
||
} else {
|
||
row[col] = val
|
||
}
|
||
}
|
||
results = append(results, row)
|
||
}
|
||
|
||
// 检查迭代过程中的错误
|
||
if err := rows.Err(); err != nil {
|
||
return nil, fmt.Errorf("读取数据时发生错误: %v", err)
|
||
}
|
||
|
||
return &QueryResult{
|
||
Data: results,
|
||
Columns: columns,
|
||
}, nil
|
||
}
|
||
|
||
// ExecuteUpdate 执行更新 SQL（INSERT/UPDATE/DELETE）
|
||
// database 参数可选，如果提供且不为空则优先使用，否则使用配置中的数据库
|
||
func (c *MySQLClient) ExecuteUpdate(ctx context.Context, sqlStr string, database string) (int64, error) {
|
||
// 确定要使用的数据库
|
||
dbName := database
|
||
if dbName == "" {
|
||
dbName = c.config.Database
|
||
}
|
||
|
||
// 使用 Session 创建独立的数据库会话，避免影响其他查询
|
||
db := c.db.Session(&gorm.Session{})
|
||
|
||
// 如果指定了数据库，先切换到该数据库
|
||
if dbName != "" {
|
||
if err := db.Exec(fmt.Sprintf("USE `%s`", dbName)).Error; err != nil {
|
||
return 0, fmt.Errorf("切换数据库失败: %v", err)
|
||
}
|
||
}
|
||
|
||
result := db.Exec(sqlStr)
|
||
if result.Error != nil {
|
||
return 0, fmt.Errorf("执行更新失败: %v", result.Error)
|
||
}
|
||
return result.RowsAffected, nil
|
||
}
|
||
|
||
// ListDatabases 获取数据库列表
|
||
func (c *MySQLClient) ListDatabases(ctx context.Context) ([]string, error) {
|
||
var databases []string
|
||
err := c.db.Raw("SHOW DATABASES").Scan(&databases).Error
|
||
return databases, err
|
||
}
|
||
|
||
// ListTables 获取表列表
|
||
func (c *MySQLClient) ListTables(ctx context.Context, database string) ([]string, error) {
|
||
var tables []string
|
||
query := "SHOW TABLES"
|
||
if database != "" {
|
||
query = fmt.Sprintf("SHOW TABLES FROM `%s`", database)
|
||
}
|
||
err := c.db.Raw(query).Scan(&tables).Error
|
||
return tables, err
|
||
}
|
||
|
||
// GetTableStructure 获取表结构
|
||
func (c *MySQLClient) GetTableStructure(ctx context.Context, database, tableName string) ([]map[string]interface{}, error) {
|
||
// 使用 SHOW FULL COLUMNS 来获取包含 comment 的完整字段信息
|
||
query := fmt.Sprintf("SHOW FULL COLUMNS FROM `%s`", tableName)
|
||
if database != "" {
|
||
query = fmt.Sprintf("SHOW FULL COLUMNS FROM `%s`.`%s`", database, tableName)
|
||
}
|
||
|
||
rows, err := c.db.Raw(query).Rows()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取表结构失败: %v", err)
|
||
}
|
||
defer rows.Close()
|
||
|
||
columns, err := rows.Columns()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取列名失败: %v", err)
|
||
}
|
||
|
||
var results []map[string]interface{}
|
||
for rows.Next() {
|
||
values := make([]interface{}, len(columns))
|
||
valuePtrs := make([]interface{}, len(columns))
|
||
for i := range values {
|
||
valuePtrs[i] = &values[i]
|
||
}
|
||
|
||
if err := rows.Scan(valuePtrs...); err != nil {
|
||
return nil, fmt.Errorf("扫描数据失败: %v", err)
|
||
}
|
||
|
||
row := make(map[string]interface{})
|
||
for i, col := range columns {
|
||
val := values[i]
|
||
if b, ok := val.([]byte); ok {
|
||
row[col] = string(b)
|
||
} else if val == nil {
|
||
row[col] = nil
|
||
} else {
|
||
row[col] = val
|
||
}
|
||
}
|
||
|
||
// 确保 Comment 字段存在（SHOW FULL COLUMNS 返回的字段名是 Comment）
|
||
if _, ok := row["Comment"]; !ok {
|
||
row["Comment"] = ""
|
||
}
|
||
|
||
results = append(results, row)
|
||
}
|
||
|
||
return results, nil
|
||
}
|
||
|
||
// GetIndexes 获取索引列表
|
||
func (c *MySQLClient) GetIndexes(ctx context.Context, database, tableName string) ([]map[string]interface{}, error) {
|
||
query := "SHOW INDEX FROM "
|
||
if database != "" {
|
||
query += fmt.Sprintf("`%s`.", database)
|
||
}
|
||
query += fmt.Sprintf("`%s`", tableName)
|
||
|
||
rows, err := c.db.Raw(query).Rows()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取索引列表失败: %v", err)
|
||
}
|
||
defer rows.Close()
|
||
|
||
columns, err := rows.Columns()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取列名失败: %v", err)
|
||
}
|
||
|
||
var results []map[string]interface{}
|
||
for rows.Next() {
|
||
values := make([]interface{}, len(columns))
|
||
valuePtrs := make([]interface{}, len(columns))
|
||
for i := range values {
|
||
valuePtrs[i] = &values[i]
|
||
}
|
||
|
||
if err := rows.Scan(valuePtrs...); err != nil {
|
||
return nil, fmt.Errorf("扫描数据失败: %v", err)
|
||
}
|
||
|
||
row := make(map[string]interface{})
|
||
for i, col := range columns {
|
||
val := values[i]
|
||
if b, ok := val.([]byte); ok {
|
||
row[col] = string(b)
|
||
} else {
|
||
row[col] = val
|
||
}
|
||
}
|
||
results = append(results, row)
|
||
}
|
||
|
||
return results, nil
|
||
}
|
||
|
||
// PreviewTableStructure 预览表结构变更，只生成 SQL 语句不执行
|
||
func (c *MySQLClient) PreviewTableStructure(ctx context.Context, database, tableName string, structure map[string]interface{}) ([]string, error) {
|
||
// 获取当前表结构
|
||
currentColumns, err := c.GetTableStructure(ctx, database, tableName)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取当前表结构失败: %v", err)
|
||
}
|
||
|
||
currentIndexes, err := c.GetIndexes(ctx, database, tableName)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取当前索引失败: %v", err)
|
||
}
|
||
|
||
// 解析新的结构数据
|
||
var newColumns []map[string]interface{}
|
||
var newIndexes []map[string]interface{}
|
||
|
||
if cols, ok := structure["columns"].([]interface{}); ok {
|
||
for _, col := range cols {
|
||
if colMap, ok := col.(map[string]interface{}); ok {
|
||
newColumns = append(newColumns, colMap)
|
||
}
|
||
}
|
||
}
|
||
|
||
if idxs, ok := structure["indexes"].([]interface{}); ok {
|
||
for _, idx := range idxs {
|
||
if idxMap, ok := idx.(map[string]interface{}); ok {
|
||
newIndexes = append(newIndexes, idxMap)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 构建 ALTER TABLE 语句
|
||
var alterStatements []string
|
||
|
||
// 处理字段变更
|
||
alterStatements = append(alterStatements, c.buildColumnAlterStatements(tableName, currentColumns, newColumns)...)
|
||
|
||
// 处理索引变更
|
||
alterStatements = append(alterStatements, c.buildIndexAlterStatements(tableName, currentIndexes, newIndexes)...)
|
||
|
||
return alterStatements, nil
|
||
}
|
||
|
||
// UpdateTableStructure 更新表结构，返回生成的 SQL 语句列表
|
||
func (c *MySQLClient) UpdateTableStructure(ctx context.Context, database, tableName string, structure map[string]interface{}) ([]string, error) {
|
||
// 先预览生成 SQL 语句
|
||
alterStatements, err := c.PreviewTableStructure(ctx, database, tableName, structure)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 执行所有 ALTER TABLE 语句
|
||
if len(alterStatements) > 0 {
|
||
dbName := database
|
||
if dbName == "" {
|
||
dbName = c.config.Database
|
||
}
|
||
|
||
db := c.db.Session(&gorm.Session{})
|
||
if dbName != "" {
|
||
if err := db.Exec(fmt.Sprintf("USE `%s`", dbName)).Error; err != nil {
|
||
return alterStatements, fmt.Errorf("切换数据库失败: %v", err)
|
||
}
|
||
}
|
||
|
||
for _, stmt := range alterStatements {
|
||
if err := db.Exec(stmt).Error; err != nil {
|
||
return alterStatements, fmt.Errorf("执行 ALTER TABLE 失败: %v, SQL: %s", err, stmt)
|
||
}
|
||
}
|
||
}
|
||
|
||
return alterStatements, nil
|
||
}
|
||
|
||
// buildColumnAlterStatements 构建字段变更的 ALTER TABLE 语句
|
||
func (c *MySQLClient) buildColumnAlterStatements(tableName string, currentColumns, newColumns []map[string]interface{}) []string {
|
||
var statements []string
|
||
|
||
// 创建字段名映射和顺序映射
|
||
currentFieldMap := make(map[string]map[string]interface{})
|
||
currentFieldOrder := make([]string, 0, len(currentColumns))
|
||
for _, col := range currentColumns {
|
||
if field, ok := col["Field"].(string); ok {
|
||
currentFieldMap[field] = col
|
||
currentFieldOrder = append(currentFieldOrder, field)
|
||
}
|
||
}
|
||
|
||
newFieldMap := make(map[string]bool)
|
||
newFieldOrder := make([]string, 0, len(newColumns))
|
||
newColumnsMap := make(map[string]map[string]interface{})
|
||
for _, col := range newColumns {
|
||
if field, ok := col["Field"].(string); ok && field != "" {
|
||
newFieldMap[field] = true
|
||
newFieldOrder = append(newFieldOrder, field)
|
||
newColumnsMap[field] = col
|
||
}
|
||
}
|
||
|
||
// 检测字段重命名：优先使用位置匹配，如果位置相同但字段名不同，认为是重命名
|
||
renameMap := make(map[string]string) // oldName -> newName
|
||
processedNewFields := make(map[string]bool)
|
||
|
||
// 第一步：使用位置匹配检测重命名（最可靠）
|
||
for oldIndex, oldFieldName := range currentFieldOrder {
|
||
if newFieldMap[oldFieldName] {
|
||
continue // 字段名未改变，跳过
|
||
}
|
||
|
||
// 检查新字段列表中相同位置是否有字段
|
||
if oldIndex < len(newFieldOrder) {
|
||
newFieldName := newFieldOrder[oldIndex]
|
||
_, existsInCurrent := currentFieldMap[newFieldName]
|
||
if !existsInCurrent && !processedNewFields[newFieldName] {
|
||
// 新字段不在当前字段列表中，且位置相同，很可能是重命名
|
||
// 进一步验证：检查类型是否相同（类型相同更可能是重命名）
|
||
oldCol := currentFieldMap[oldFieldName]
|
||
newCol := newColumnsMap[newFieldName]
|
||
oldType := getStringValue(oldCol["Type"])
|
||
newType := getStringValue(newCol["Type"])
|
||
|
||
// 如果类型相同，认为是重命名
|
||
if oldType == newType {
|
||
renameMap[oldFieldName] = newFieldName
|
||
processedNewFields[newFieldName] = true
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 第二步：对于未匹配的字段，使用属性匹配（兼容旧逻辑）
|
||
for oldFieldName, oldCol := range currentFieldMap {
|
||
if newFieldMap[oldFieldName] {
|
||
continue // 字段名未改变，跳过
|
||
}
|
||
if renameMap[oldFieldName] != "" {
|
||
continue // 已经通过位置匹配识别为重命名
|
||
}
|
||
|
||
// 查找属性完全匹配的新字段
|
||
var matchedNewField string
|
||
for newFieldName, newCol := range newColumnsMap {
|
||
if processedNewFields[newFieldName] {
|
||
continue // 已经被匹配过了
|
||
}
|
||
_, existsInCurrent := currentFieldMap[newFieldName]
|
||
if !existsInCurrent {
|
||
// 这是一个新增字段，检查属性是否匹配
|
||
if c.isColumnPropertiesEqual(oldCol, newCol) {
|
||
if matchedNewField == "" {
|
||
matchedNewField = newFieldName
|
||
} else {
|
||
// 有多个匹配，无法确定，不认为是重命名
|
||
matchedNewField = ""
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果找到唯一匹配，认为是重命名
|
||
if matchedNewField != "" {
|
||
renameMap[oldFieldName] = matchedNewField
|
||
processedNewFields[matchedNewField] = true
|
||
}
|
||
}
|
||
|
||
// 处理字段重命名
|
||
for oldName, newName := range renameMap {
|
||
stmt := fmt.Sprintf("ALTER TABLE `%s` RENAME COLUMN `%s` TO `%s`", tableName, oldName, newName)
|
||
statements = append(statements, stmt)
|
||
}
|
||
|
||
// 处理字段添加、修改和位置调整（排除已重命名的字段）
|
||
for i, newCol := range newColumns {
|
||
field, _ := newCol["Field"].(string)
|
||
if field == "" {
|
||
continue
|
||
}
|
||
|
||
// 检查是否是重命名的字段
|
||
isRenamed := false
|
||
var oldName string
|
||
for old, new := range renameMap {
|
||
if new == field {
|
||
isRenamed = true
|
||
oldName = old
|
||
break
|
||
}
|
||
}
|
||
|
||
if isRenamed {
|
||
// 重命名的字段：如果属性有变化，需要 MODIFY COLUMN
|
||
oldCol := currentFieldMap[oldName]
|
||
needsModify := c.isColumnChanged(oldCol, newCol)
|
||
|
||
// 检查顺序变化：使用旧字段名在 currentOrder 中查找位置，与新位置比较
|
||
oldIndex := -1
|
||
for idx, name := range currentFieldOrder {
|
||
if name == oldName {
|
||
oldIndex = idx
|
||
break
|
||
}
|
||
}
|
||
needsReorder := (oldIndex != -1 && oldIndex != i)
|
||
|
||
if needsModify || needsReorder {
|
||
// 重命名后需要修改属性或位置
|
||
stmt := c.buildModifyColumnStatement(tableName, field, newCol, newFieldOrder, i)
|
||
if stmt != "" {
|
||
statements = append(statements, stmt)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
if currentCol, exists := currentFieldMap[field]; exists {
|
||
// 修改现有字段
|
||
needsModify := c.isColumnChanged(currentCol, newCol)
|
||
needsReorder := c.isColumnOrderChanged(currentFieldOrder, newFieldOrder, field, i)
|
||
|
||
if needsModify || needsReorder {
|
||
stmt := c.buildModifyColumnStatement(tableName, field, newCol, newFieldOrder, i)
|
||
if stmt != "" {
|
||
statements = append(statements, stmt)
|
||
}
|
||
}
|
||
} else {
|
||
// 添加新字段（排除重命名的字段）
|
||
stmt := c.buildAddColumnStatement(tableName, newCol, newFieldOrder, i)
|
||
if stmt != "" {
|
||
statements = append(statements, stmt)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 删除不存在的字段（排除已重命名的字段）
|
||
for field := range currentFieldMap {
|
||
if !newFieldMap[field] && renameMap[field] == "" {
|
||
stmt := fmt.Sprintf("ALTER TABLE `%s` DROP COLUMN `%s`", tableName, field)
|
||
statements = append(statements, stmt)
|
||
}
|
||
}
|
||
|
||
return statements
|
||
}
|
||
|
||
// buildIndexAlterStatements 构建索引变更的 ALTER TABLE 语句
|
||
func (c *MySQLClient) buildIndexAlterStatements(tableName string, currentIndexes, newIndexes []map[string]interface{}) []string {
|
||
var statements []string
|
||
|
||
// 创建索引名映射
|
||
currentIndexMap := make(map[string]map[string]interface{})
|
||
for _, idx := range currentIndexes {
|
||
if keyName, ok := idx["Key_name"].(string); ok && keyName != "PRIMARY" {
|
||
currentIndexMap[keyName] = idx
|
||
}
|
||
}
|
||
|
||
newIndexMap := make(map[string]bool)
|
||
for _, idx := range newIndexes {
|
||
if keyName, ok := idx["Key_name"].(string); ok && keyName != "" && keyName != "PRIMARY" {
|
||
newIndexMap[keyName] = true
|
||
}
|
||
}
|
||
|
||
// 处理索引变更
|
||
for _, newIdx := range newIndexes {
|
||
keyName, _ := newIdx["Key_name"].(string)
|
||
if keyName == "" || keyName == "PRIMARY" {
|
||
continue
|
||
}
|
||
|
||
if currentIdx, exists := currentIndexMap[keyName]; exists {
|
||
// 修改现有索引
|
||
if c.isIndexChanged(currentIdx, newIdx) {
|
||
dropStmt := fmt.Sprintf("ALTER TABLE `%s` DROP INDEX `%s`", tableName, keyName)
|
||
addStmt := c.buildAddIndexStatement(tableName, newIdx)
|
||
if addStmt != "" {
|
||
statements = append(statements, dropStmt)
|
||
statements = append(statements, addStmt)
|
||
}
|
||
}
|
||
} else {
|
||
// 添加新索引
|
||
stmt := c.buildAddIndexStatement(tableName, newIdx)
|
||
if stmt != "" {
|
||
statements = append(statements, stmt)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 删除不存在的索引
|
||
for keyName := range currentIndexMap {
|
||
if !newIndexMap[keyName] {
|
||
stmt := fmt.Sprintf("ALTER TABLE `%s` DROP INDEX `%s`", tableName, keyName)
|
||
statements = append(statements, stmt)
|
||
}
|
||
}
|
||
|
||
return statements
|
||
}
|
||
|
||
// isColumnChanged 检查字段是否发生变化（不包括字段名）
|
||
func (c *MySQLClient) isColumnChanged(oldCol, newCol map[string]interface{}) bool {
|
||
fields := []string{"Type", "Null", "Default", "Extra", "Comment"}
|
||
for _, field := range fields {
|
||
oldVal := getStringValue(oldCol[field])
|
||
newVal := getStringValue(newCol[field])
|
||
if oldVal != newVal {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// isColumnPropertiesEqual 检查字段属性是否完全相等（不包括字段名）
|
||
func (c *MySQLClient) isColumnPropertiesEqual(oldCol, newCol map[string]interface{}) bool {
|
||
fields := []string{"Type", "Null", "Default", "Extra", "Key", "Comment"}
|
||
for _, field := range fields {
|
||
oldVal := getStringValue(oldCol[field])
|
||
newVal := getStringValue(newCol[field])
|
||
if oldVal != newVal {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// isColumnOrderChanged 检查字段顺序是否发生变化
|
||
func (c *MySQLClient) isColumnOrderChanged(currentOrder, newOrder []string, fieldName string, newIndex int) bool {
|
||
// 查找字段在当前顺序中的位置
|
||
currentIndex := -1
|
||
for i, name := range currentOrder {
|
||
if name == fieldName {
|
||
currentIndex = i
|
||
break
|
||
}
|
||
}
|
||
|
||
// 如果字段不存在于当前顺序中（新字段），不需要检查顺序
|
||
if currentIndex == -1 {
|
||
return false
|
||
}
|
||
|
||
// 如果索引相同，检查前面的字段是否相同
|
||
if newIndex == currentIndex {
|
||
// 检查前面的字段集合是否相同
|
||
if newIndex > 0 {
|
||
currentPrevFields := make(map[string]bool)
|
||
for i := 0; i < currentIndex; i++ {
|
||
currentPrevFields[currentOrder[i]] = true
|
||
}
|
||
|
||
newPrevFields := make(map[string]bool)
|
||
for i := 0; i < newIndex; i++ {
|
||
newPrevFields[newOrder[i]] = true
|
||
}
|
||
|
||
// 如果前面的字段集合不同，说明顺序变了
|
||
if len(currentPrevFields) != len(newPrevFields) {
|
||
return true
|
||
}
|
||
for f := range currentPrevFields {
|
||
if !newPrevFields[f] {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// 索引不同，说明顺序变了
|
||
return true
|
||
}
|
||
|
||
// isIndexChanged 检查索引是否发生变化
|
||
func (c *MySQLClient) isIndexChanged(oldIdx, newIdx map[string]interface{}) bool {
|
||
oldCol := getStringValue(oldIdx["Column_name"])
|
||
newCol := getStringValue(newIdx["Column_name"])
|
||
if oldCol != newCol {
|
||
return true
|
||
}
|
||
|
||
oldUnique := getIntValue(oldIdx["Non_unique"])
|
||
newUnique := getIntValue(newIdx["Non_unique"])
|
||
return oldUnique != newUnique
|
||
}
|
||
|
||
// buildAddColumnStatement 构建添加字段的语句
|
||
func (c *MySQLClient) buildAddColumnStatement(tableName string, col map[string]interface{}, fieldOrder []string, index int) string {
|
||
field := getStringValue(col["Field"])
|
||
if field == "" {
|
||
return ""
|
||
}
|
||
|
||
colDef := c.buildColumnDefinition(col)
|
||
|
||
// 确定字段位置
|
||
position := c.buildColumnPosition(fieldOrder, index)
|
||
|
||
return fmt.Sprintf("ALTER TABLE `%s` ADD COLUMN %s%s", tableName, colDef, position)
|
||
}
|
||
|
||
// buildModifyColumnStatement 构建修改字段的语句
|
||
func (c *MySQLClient) buildModifyColumnStatement(tableName, field string, col map[string]interface{}, fieldOrder []string, index int) string {
|
||
colDef := c.buildColumnDefinition(col)
|
||
|
||
// 确定字段位置
|
||
position := c.buildColumnPosition(fieldOrder, index)
|
||
|
||
return fmt.Sprintf("ALTER TABLE `%s` MODIFY COLUMN %s%s", tableName, colDef, position)
|
||
}
|
||
|
||
// buildColumnPosition 构建字段位置子句（AFTER 或 FIRST）
|
||
func (c *MySQLClient) buildColumnPosition(fieldOrder []string, index int) string {
|
||
if index < 0 || index >= len(fieldOrder) {
|
||
return ""
|
||
}
|
||
|
||
if index == 0 {
|
||
// 第一个字段使用 FIRST
|
||
return " FIRST"
|
||
}
|
||
|
||
// 其他字段使用 AFTER 前一个字段
|
||
prevField := fieldOrder[index-1]
|
||
return fmt.Sprintf(" AFTER `%s`", prevField)
|
||
}
|
||
|
||
// buildColumnDefinition 构建字段定义
|
||
func (c *MySQLClient) buildColumnDefinition(col map[string]interface{}) string {
|
||
field := getStringValue(col["Field"])
|
||
colType := getStringValue(col["Type"])
|
||
null := getStringValue(col["Null"])
|
||
defaultVal := col["Default"]
|
||
extra := getStringValue(col["Extra"])
|
||
comment := getStringValue(col["Comment"])
|
||
|
||
def := fmt.Sprintf("`%s` %s", field, colType)
|
||
|
||
if null == "NO" {
|
||
def += " NOT NULL"
|
||
}
|
||
|
||
if defaultVal != nil {
|
||
if defaultStr, ok := defaultVal.(string); ok {
|
||
if defaultStr == "" {
|
||
// 空字符串表示默认值为空字符串
|
||
def += " DEFAULT ''"
|
||
} else if defaultStr != "NULL" {
|
||
// 转义单引号
|
||
escapedDefault := strings.ReplaceAll(defaultStr, "'", "''")
|
||
def += fmt.Sprintf(" DEFAULT '%s'", escapedDefault)
|
||
}
|
||
// 如果 defaultStr == "NULL"，不添加 DEFAULT 子句（允许 NULL）
|
||
} else {
|
||
// 非字符串类型的默认值
|
||
def += fmt.Sprintf(" DEFAULT %v", defaultVal)
|
||
}
|
||
}
|
||
|
||
if extra != "" {
|
||
def += " " + extra
|
||
}
|
||
|
||
if comment != "" {
|
||
// 转义单引号
|
||
escapedComment := strings.ReplaceAll(comment, "'", "''")
|
||
def += fmt.Sprintf(" COMMENT '%s'", escapedComment)
|
||
}
|
||
|
||
return def
|
||
}
|
||
|
||
// buildAddIndexStatement 构建添加索引的语句
|
||
func (c *MySQLClient) buildAddIndexStatement(tableName string, idx map[string]interface{}) string {
|
||
keyName := getStringValue(idx["Key_name"])
|
||
columnName := getStringValue(idx["Column_name"])
|
||
nonUnique := getIntValue(idx["Non_unique"])
|
||
|
||
if keyName == "" || columnName == "" {
|
||
return ""
|
||
}
|
||
|
||
indexType := "INDEX"
|
||
if nonUnique == 0 {
|
||
indexType = "UNIQUE INDEX"
|
||
}
|
||
|
||
return fmt.Sprintf("ALTER TABLE `%s` ADD %s `%s` (`%s`)", tableName, indexType, keyName, columnName)
|
||
}
|
||
|
||
// getStringValue 安全获取字符串值
|
||
func getStringValue(v interface{}) string {
|
||
if v == nil {
|
||
return ""
|
||
}
|
||
if s, ok := v.(string); ok {
|
||
return s
|
||
}
|
||
return fmt.Sprintf("%v", v)
|
||
}
|
||
|
||
// getIntValue 安全获取整数值
|
||
func getIntValue(v interface{}) int {
|
||
if v == nil {
|
||
return 0
|
||
}
|
||
switch val := v.(type) {
|
||
case int:
|
||
return val
|
||
case int64:
|
||
return int(val)
|
||
case float64:
|
||
return int(val)
|
||
case string:
|
||
var i int
|
||
fmt.Sscanf(val, "%d", &i)
|
||
return i
|
||
}
|
||
return 0
|
||
}
|