go-db/sqldef/generators/sql_generator.go

// sql_generator.go 根据数据库类型，自动选择对应注册的建立表的sql编写器，进行编写。
package generators

import (
	"fmt"
	"strings"
	"sync"
)

// ColumnSchema 列结构定义
type ColumnSchema struct {
	Name        string
	ChineseName string   // 新增：字段中文名称
	Aliases     []string // 新增：字段别名列表
	Type        string   // 基本类型：VARCHAR, INT, DECIMAL 等
	Length      int      // 长度
	Precision   int      // 精度（用于 DECIMAL）
	Scale       int      // 小数位数（用于 DECIMAL）
	Comment     string
	Options     []string // 选项：NOT NULL, PRIMARY KEY 等
	Default     string   // 默认值字符串
}

// IndexSchema 索引结构定义
type IndexSchema struct {
	Name    string
	Columns []string
	Unique  bool
}

// TableSchema 表结构定义
type TableSchema struct {
	Name        string
	ChineseName string   // 新增：表中文名称
	Aliases     []string // 新增：表别名列表
	Comment     string
	Columns     []ColumnSchema
	Indexes     []IndexSchema
}

// TableDDL 表定义
type TableDDL struct {
	Name    string
	SQL     string
	Comment string
	Schema  *TableSchema // 新增Schema字段

}

// SQLGenerator SQL生成器接口
type SQLGenerator interface {
	// 生成检查表是否存在的SQL
	TableExistsSQL(tableName string) string

	// 生成删除表的SQL
	DropTableSQL(tableName string) string

	// 生成创建表的SQL
	GenerateCreateTable(table TableDDL) string

	// 获取数据库类型
	DBType() string
}

// SQLGeneratorRegistry SQL生成器注册表
type SQLGeneratorRegistry struct {
	generators map[string]SQLGenerator
	mu         sync.RWMutex
}

var (
	globalGeneratorRegistry *SQLGeneratorRegistry
	generatorRegistryOnce   sync.Once
)

// GetSQLGeneratorRegistry 获取SQL生成器注册表单例
func GetSQLGeneratorRegistry() *SQLGeneratorRegistry {
	generatorRegistryOnce.Do(func() {
		globalGeneratorRegistry = &SQLGeneratorRegistry{
			generators: make(map[string]SQLGenerator),
		}
	})
	return globalGeneratorRegistry
}

// RegisterGenerator 注册SQL生成器
func (r *SQLGeneratorRegistry) RegisterGenerator(generator SQLGenerator) {
	r.mu.Lock()
	defer r.mu.Unlock()

	dbType := strings.ToLower(generator.DBType())
	r.generators[dbType] = generator
}

// GetGenerator 获取SQL生成器
func (r *SQLGeneratorRegistry) GetGenerator(dbType string) (SQLGenerator, error) {
	r.mu.RLock()
	defer r.mu.RUnlock()

	generator, exists := r.generators[strings.ToLower(dbType)]
	if !exists {
		return nil, fmt.Errorf("不支持的数据类型: %s，已注册的类型: %v", dbType, r.GetRegisteredTypes())
	}
	return generator, nil
}

// GetRegisteredTypes 获取已注册的数据库类型
func (r *SQLGeneratorRegistry) GetRegisteredTypes() []string {
	r.mu.RLock()
	defer r.mu.RUnlock()

	types := make([]string, 0, len(r.generators))
	for dbType := range r.generators {
		types = append(types, dbType)
	}
	return types
}

// 包级便捷函数

// RegisterGenerator 包级便捷函数：注册SQL生成器
func RegisterGenerator(generator SQLGenerator) {
	GetSQLGeneratorRegistry().RegisterGenerator(generator)
}

// GetGenerator 包级便捷函数：获取SQL生成器
func GetGenerator(dbType string) (SQLGenerator, error) {
	return GetSQLGeneratorRegistry().GetGenerator(dbType)
}

// GetAllGenerators 获取所有已注册的生成器
func GetAllGenerators() []SQLGenerator {
	registry := GetSQLGeneratorRegistry()
	registry.mu.RLock()
	defer registry.mu.RUnlock()

	generators := make([]SQLGenerator, 0, len(registry.generators))
	for _, generator := range registry.generators {
		generators = append(generators, generator)
	}
	return generators
}