go-db/sqldef/table_create.go

// table_create.go 执行建表代码
package sqldef

import (
	"fmt"
	"log"

	"git.x2erp.com/qdy/go-db/sqldef/generators"
	"github.com/jmoiron/sqlx"
)

// TableSyncer 表同步器
type TableSyncer struct {
	db        *sqlx.DB
	dbType    string
	generator generators.SQLGenerator
}

// NewTableSyncer 创建表同步器
func NewTableSyncer(db *sqlx.DB, dbType string) (*TableSyncer, error) {

	// 获取SQL生成器
	generator, err := generators.GetGenerator(dbType)
	if err != nil {
		return nil, fmt.Errorf("获取SQL生成器失败: %w", err)
	}

	return &TableSyncer{
		db:        db,
		dbType:    dbType,
		generator: generator,
	}, nil
}

// CreateAllTables 同步所有注册的表
// recreate: true - 表存在则删除重建；false - 表不存在则创建
func (ts *TableSyncer) createAllTables(recreate bool) error {
	// 确保注册表已初始化
	globalRegistry.ensureInit()

	// 测试数据库连接
	if err := ts.db.Ping(); err != nil {
		return fmt.Errorf("数据库连接失败: %w", err)
	}

	// 获取所有注册的表定义
	tables := GetAll()

	log.Printf("开始创建 %d 个表到 %s 数据库...\n", len(tables), ts.dbType)

	// 处理每个表
	for i, table := range tables {
		tableName := table.Name

		// 检查表是否存在
		exists, err := ts.tableExists(tableName)
		if err != nil {
			return fmt.Errorf("检查表 %s 是否存在失败: %w", tableName, err)
		}

		if recreate {
			// 如果存在则删除
			if exists {
				if err := ts.dropTable(tableName); err != nil {
					return fmt.Errorf("删除表 %s 失败: %w", tableName, err)
				}
				log.Printf("[%d/%d] 表 %s 已删除\n", i+1, len(tables), tableName)
			}

			// 创建表
			if err := ts.createTable(table); err != nil {
				return fmt.Errorf("创建表 %s 失败: %w", tableName, err)
			}
			// 修正：Go没有三元运算符，使用if-else
			var action string
			if exists {
				action = "重建"
			} else {
				action = "创建"
			}
			log.Printf("[%d/%d] 表 %s 已%s\n", i+1, len(tables), tableName, action)
		} else {
			// 只创建不存在的表
			if !exists {
				if err := ts.createTable(table); err != nil {
					return fmt.Errorf("创建表 %s 失败: %w", tableName, err)
				}
				log.Printf("[%d/%d] 表 %s 已创建\n", i+1, len(tables), tableName)
			} else {
				log.Printf("[%d/%d] 表 %s 已存在，跳过\n", i+1, len(tables), tableName)
			}
		}
	}

	log.Println("所有表创建完成！")
	return nil
}

// tableExists 检查表是否存在
func (ts *TableSyncer) tableExists(tableName string) (bool, error) {
	sql := ts.generator.TableExistsSQL(tableName)

	var exists bool
	if ts.dbType == "postgresql" {
		// PostgreSQL返回boolean
		err := ts.db.QueryRow(sql).Scan(&exists)
		return exists, err
	} else {
		// MySQL返回count
		var count int
		err := ts.db.QueryRow(sql).Scan(&count)
		return count > 0, err
	}
}

// dropTable 删除表
func (ts *TableSyncer) dropTable(tableName string) error {
	sql := ts.generator.DropTableSQL(tableName)
	_, err := ts.db.Exec(sql)
	return err
}

// createTable 创建表
func (ts *TableSyncer) createTable(table generators.TableDDL) error {
	// 使用生成器生成适合当前数据库的SQL
	sql := ts.generator.GenerateCreateTable(table)

	// 打印SQL用于调试
	log.Printf("执行SQL: %s", sql)

	_, err := ts.db.Exec(sql)
	if err != nil {
		// 记录详细的错误信息
		log.Printf("执行SQL失败: %v", err)
		return fmt.Errorf("执行SQL失败: %w", err)
	}
	return nil
}

// SyncTables 同步所有表
func syncTables(db *sqlx.DB, dbType string, recreate bool) error {
	syncer, err := NewTableSyncer(db, dbType)
	if err != nil {
		return err
	}
	return syncer.createAllTables(recreate)
}

// // CreateTables 创建所有不存在的表
// func CreateTables(db *sqlx.DB, dbType string) error {
// 	return syncTables(db, dbType, false)
// }

// // RecreateTables 重建所有表
// func RecreateTables(db *sqlx.DB, dbType string) error {
// 	return syncTables(db, dbType, true)
// }

// CreateTables 创建所有不存在的表
func (ts *TableSyncer) CreateTables() error {
	return ts.createAllTables(false)
}

// RecreateTables 重建所有表
func (ts *TableSyncer) RecreateTables() error {
	return ts.createAllTables(true)
}