自动建立表通过

drivers/postgres.go → drivers/postgresql.go

@@ -10,7 +10,7 @@ import (
 type PostgresDriver struct{}
 
 func (d *PostgresDriver) Name() string {
-	return "postgres"
+	return "postgresql"
 }
 
 func (d *PostgresDriver) BuildDSN(config DBConfig) string {

functions/query_csv.go

@@ -7,65 +7,78 @@ import (
 	"strings"
 
 	"git.x2erp.com/qdy/go-base/ctx"
+	"git.x2erp.com/qdy/go-base/logger"
 	"github.com/jmoiron/sqlx"
+	"go.uber.org/zap"
 )
 
 // QueryToCSV 无参数查询并返回 CSV 字节数据
 func QueryToCSV(db *sqlx.DB, sql string, writerHeader bool, reqCtx *ctx.RequestContext) ([]byte, error) {
+	logger.DebugC(reqCtx, "Executing QueryToCSV",
+		zap.String("sql", sql),
+		zap.Bool("writerHeader", writerHeader))
+
 	if sql == "" {
-		return nil, fmt.Errorf("SQL query cannot be empty")
+		return nil, logger.ErrorCf(reqCtx, "SQL query cannot be empty")
 	}
 
 	rows, err := db.Query(sql)
 	if err != nil {
-		return nil, fmt.Errorf("query execution failed: %v", err)
+		return nil, logger.ErrorCf(reqCtx, "query execution failed: %v", err)
 	}
 
-	return rowsToCSV(rows, writerHeader)
+	return rowsToCSV(rows, writerHeader, reqCtx)
 }
 
 // QueryParamsToCSV 位置参数查询并返回 CSV 字节数据
 func QueryPositionalToCSV(db *sqlx.DB, sql string, writerHeader bool, params []interface{}, reqCtx *ctx.RequestContext) ([]byte, error) {
+
+	logger.DebugC(reqCtx, "Executing QueryToCSV: sql=%s, writerHeader=%v", sql, writerHeader)
+
 	if sql == "" {
-		return nil, fmt.Errorf("SQL query cannot be empty")
+		return nil, logger.ErrorCf(reqCtx, "SQL query cannot be empty")
 	}
 
 	rows, err := db.Query(sql, params...)
 	if err != nil {
-		return nil, fmt.Errorf("query execution failed: %v", err)
+		return nil, logger.ErrorCf(reqCtx, "query execution failed: %v", err)
 	}
 
-	return rowsToCSV(rows, writerHeader)
+	return rowsToCSV(rows, writerHeader, reqCtx)
 }
 
 // QueryParamsNameToCSV 命名参数查询并返回 CSV 字节数据
 // params 可以是 map[string]interface{} 或结构体
 func QueryParamsNameToCSV(db *sqlx.DB, sql string, writerHeader bool, params map[string]interface{}, reqCtx *ctx.RequestContext) ([]byte, error) {
+
+	logger.DebugC(reqCtx, "Executing QueryToCSV",
+		zap.String("sql", sql),
+		zap.Bool("writerHeader", writerHeader))
 	if sql == "" {
-		return nil, fmt.Errorf("SQL query cannot be empty")
+		return nil, logger.ErrorCf(reqCtx, "SQL query cannot be empty")
 	}
 
 	query, args, err := sqlx.Named(sql, params)
 	if err != nil {
-		return nil, fmt.Errorf("failed to bind named parameters: %v", err)
+		return nil, logger.ErrorCf(reqCtx, "query execution failed: %v", err)
 	}
 
 	query = db.Rebind(query)
 	rows, err := db.Query(query, args...)
 	if err != nil {
-		return nil, fmt.Errorf("query execution failed: %v", err)
+		return nil, logger.ErrorCf(reqCtx, "query execution failed: %v", err)
 	}
 
-	return rowsToCSV(rows, writerHeader)
+	return rowsToCSV(rows, writerHeader, reqCtx)
 }
 
 // rowsToCSV 公共方法：将查询结果转换为 CSV 字节数据
-func rowsToCSV(rows *sql.Rows, writerHeader bool) ([]byte, error) {
+func rowsToCSV(rows *sql.Rows, writerHeader bool, reqCtx *ctx.RequestContext) ([]byte, error) {
 	defer rows.Close()
 
 	columns, err := rows.Columns()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get columns: %v", err)
+		return nil, logger.ErrorCf(reqCtx, "failed to get columns: %v", err)
 	}
 
 	var builder strings.Builder
@@ -74,7 +87,7 @@ func rowsToCSV(rows *sql.Rows, writerHeader bool) ([]byte, error) {
 	// 根据参数决定是否写入表头
 	if writerHeader {
 		if err := writer.Write(columns); err != nil {
-			return nil, fmt.Errorf("failed to write CSV header: %v", err)
+			return nil, logger.ErrorCf(reqCtx, "failed to write CSV header: %v", err)
 		}
 	}
 
@@ -86,7 +99,7 @@ func rowsToCSV(rows *sql.Rows, writerHeader bool) ([]byte, error) {
 		}
 
 		if err := rows.Scan(valuePtrs...); err != nil {
-			return nil, fmt.Errorf("failed to scan row: %v", err)
+			return nil, logger.ErrorCf(reqCtx, "failed to scan row: %v", err)
 		}
 
 		// 所有值转为字符串
@@ -100,17 +113,17 @@ func rowsToCSV(rows *sql.Rows, writerHeader bool) ([]byte, error) {
 		}
 
 		if err := writer.Write(row); err != nil {
-			return nil, fmt.Errorf("failed to write CSV row: %v", err)
+			return nil, logger.ErrorCf(reqCtx, "failed to write CSV row: %v", err)
 		}
 	}
 
 	writer.Flush()
 	if err := writer.Error(); err != nil {
-		return nil, fmt.Errorf("failed to flush CSV: %v", err)
+		return nil, logger.ErrorCf(reqCtx, "failed to flush CSV: %v", err)
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("row iteration error: %v", err)
+		return nil, logger.ErrorCf(reqCtx, "row iteration error: %v", err)
 	}
 
 	return []byte(builder.String()), nil

myhandle/query_handler_bytes.go

@@ -2,6 +2,7 @@ package myhandle
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 
 	"git.x2erp.com/qdy/go-base/ctx"
@@ -12,24 +13,32 @@ func QueryHandlerBytes[T any, F any](
 	w http.ResponseWriter,
 	r *http.Request,
 	factory F,
-	handlerFunc func(F, T, *ctx.RequestContext) []byte,
+	handlerFunc func(F, T, *ctx.RequestContext) ([]byte, error),
 ) {
 	// 解析请求参数
+
+	w.Header().Set("Content-Type", "text/csv")
+	w.Header().Set("Content-Disposition", "attachment; filename=query_result.csv")
 	var req T
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		// 返回 CSV 格式的错误信息
 		errorCSV := "error,Invalid request body\n"
-		w.Header().Set("Content-Type", "text/csv")
+		//		w.Header().Set("Content-Type", "text/csv")
 		w.WriteHeader(http.StatusBadRequest)
 		w.Write([]byte(errorCSV))
 		return
 	}
 
+	reqCtx := ctx.GetContext(r)
 	// 调用业务逻辑函数
-	csvData := handlerFunc(factory, req, ctx.GetContext(r))
-
+	csvData, err := handlerFunc(factory, req, reqCtx)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		w.Write([]byte(fmt.Sprintf("%v", err)))
+		return
+	}
 	// 直接返回 CSV 数据（包含错误信息时也会被正确处理）
-	w.Header().Set("Content-Type", "text/csv")
-	w.Header().Set("Content-Disposition", "attachment; filename=query_result.csv")
+	//w.Header().Set("Content-Type", "text/csv")
+	//w.Header().Set("Content-Disposition", "attachment; filename=query_result.csv")
 	w.Write(csvData)
 }

sqldef/generators/mysql.go

@@ -0,0 +1,148 @@
+// mysql.go 根据//table_defintion.go 定义的表结构，编写mysql建立表和索引的代码。
+package generators
+
+import (
+	"fmt"
+	"strings"
+)
+
+// MySQLGenerator MySQL SQL生成器
+type MySQLGenerator struct{}
+
+// NewMySQLGenerator 创建MySQL生成器实例
+func NewMySQLGenerator() *MySQLGenerator {
+	return &MySQLGenerator{}
+}
+
+func (mg *MySQLGenerator) DBType() string {
+	return "mysql"
+}
+
+func (mg *MySQLGenerator) TableExistsSQL(tableName string) string {
+	return fmt.Sprintf(
+		"SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = '%s'",
+		tableName,
+	)
+}
+
+func (mg *MySQLGenerator) DropTableSQL(tableName string) string {
+	return fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName)
+}
+
+func (mg *MySQLGenerator) GenerateCreateTable(table TableDDL) string {
+	if table.Schema == nil {
+		return ""
+	}
+
+	var sql strings.Builder
+
+	// 表头
+	sql.WriteString(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (\n", table.Name))
+
+	// 列定义
+	columns := table.Schema.Columns
+	for i, col := range columns {
+		sql.WriteString(fmt.Sprintf("  %s %s", col.Name, mg.getMySQLType(col)))
+
+		// 添加选项
+		for _, opt := range col.Options {
+			sql.WriteString(" " + opt)
+		}
+
+		// 添加默认值
+		if col.Default != "" {
+			// 检查是否是函数调用（如CURRENT_TIMESTAMP）
+			if strings.Contains(strings.ToUpper(col.Default), "CURRENT_TIMESTAMP") ||
+				strings.Contains(strings.ToUpper(col.Default), "NOW()") {
+				sql.WriteString(" DEFAULT " + col.Default)
+			} else {
+				sql.WriteString(fmt.Sprintf(" DEFAULT '%s'", col.Default))
+			}
+		}
+
+		// 添加注释
+		if col.Comment != "" {
+			sql.WriteString(fmt.Sprintf(" COMMENT '%s'", col.Comment))
+		}
+
+		if i < len(columns)-1 {
+			sql.WriteString(",")
+		}
+		sql.WriteString("\n")
+	}
+
+	// 添加索引（在MySQL中，索引可以在CREATE TABLE语句中定义）
+	for _, idx := range table.Schema.Indexes {
+		if idx.Unique {
+			sql.WriteString(fmt.Sprintf("  ,UNIQUE KEY %s (%s)\n",
+				idx.Name, strings.Join(idx.Columns, ", ")))
+		} else {
+			sql.WriteString(fmt.Sprintf("  ,KEY %s (%s)\n",
+				idx.Name, strings.Join(idx.Columns, ", ")))
+		}
+	}
+
+	sql.WriteString(")")
+
+	// 表选项
+	if table.Schema.Comment != "" {
+		sql.WriteString(fmt.Sprintf(" COMMENT='%s'", table.Schema.Comment))
+	}
+
+	sql.WriteString(" ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;")
+
+	return sql.String()
+}
+
+// getMySQLType 获取MySQL数据类型
+func (mg *MySQLGenerator) getMySQLType(col ColumnSchema) string {
+	switch col.Type {
+	case "DECIMAL":
+		if col.Precision > 0 && col.Scale > 0 {
+			return fmt.Sprintf("DECIMAL(%d,%d)", col.Precision, col.Scale)
+		}
+		return "DECIMAL"
+	case "VARCHAR":
+		if col.Length > 0 {
+			return fmt.Sprintf("VARCHAR(%d)", col.Length)
+		}
+		return "VARCHAR(255)"
+	case "CHAR":
+		if col.Length > 0 {
+			return fmt.Sprintf("CHAR(%d)", col.Length)
+		}
+		return "CHAR(1)"
+	case "INT":
+		return "INT"
+	case "BIGINT":
+		return "BIGINT"
+	case "TINYINT":
+		return "TINYINT"
+	case "BOOL":
+		return "TINYINT(1)"
+	case "DATETIME":
+		return "DATETIME"
+	case "TIMESTAMP":
+		return "TIMESTAMP"
+	case "DATE":
+		return "DATE"
+	case "TIME":
+		return "TIME"
+	case "TEXT":
+		return "TEXT"
+	case "JSON":
+		return "JSON"
+	case "BLOB":
+		return "BLOB"
+	case "FLOAT":
+		return "FLOAT"
+	case "DOUBLE":
+		return "DOUBLE"
+	default:
+		return col.Type
+	}
+}
+
+func init() {
+	RegisterGenerator(NewMySQLGenerator())
+}

sqldef/generators/postgresql.go

@@ -0,0 +1,236 @@
+// postgresql.go 根据//table_defintion.go 定义的表结构，编写PostgreSQL建立表和索引的代码。
+package generators
+
+import (
+	"fmt"
+	"strings"
+)
+
+// PostgreSQLGenerator PostgreSQL SQL生成器
+type PostgreSQLGenerator struct{}
+
+// NewPostgreSQLGenerator 创建PostgreSQL生成器实例
+func NewPostgreSQLGenerator() *PostgreSQLGenerator {
+	return &PostgreSQLGenerator{}
+}
+
+func (pg *PostgreSQLGenerator) DBType() string {
+	return "postgresql"
+}
+
+func (pg *PostgreSQLGenerator) TableExistsSQL(tableName string) string {
+	return fmt.Sprintf(
+		"SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_schema = 'public' AND table_name = '%s')",
+		strings.ToLower(tableName),
+	)
+}
+
+func (pg *PostgreSQLGenerator) DropTableSQL(tableName string) string {
+	return fmt.Sprintf("DROP TABLE IF EXISTS %s CASCADE", tableName)
+}
+
+func (pg *PostgreSQLGenerator) GenerateCreateTable(table TableDDL) string {
+	if table.Schema == nil {
+		return ""
+	}
+
+	var sql strings.Builder
+
+	// 表头
+	sql.WriteString(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (\n", table.Name))
+
+	// 列定义
+	columns := table.Schema.Columns
+	for i, col := range columns {
+		sql.WriteString(fmt.Sprintf("  %s %s", col.Name, pg.getPostgreSQLType(col)))
+
+		// 添加选项（转换MySQL选项到PostgreSQL）
+		for _, opt := range col.Options {
+			pgOpt := pg.convertOption(opt, col)
+			if pgOpt != "" {
+				sql.WriteString(" " + pgOpt)
+			}
+		}
+
+		// 添加默认值
+		if col.Default != "" {
+			pgDefault := pg.convertDefaultValue(col.Default, col.Type)
+			if pgDefault != "" {
+				sql.WriteString(" DEFAULT " + pgDefault)
+			}
+		}
+
+		// 列注释将在表创建后单独添加
+
+		if i < len(columns)-1 {
+			sql.WriteString(",")
+		}
+		sql.WriteString("\n")
+	}
+
+	// 添加主键约束（从列选项中提取）
+	primaryKeys := pg.extractPrimaryKeys(columns)
+	if len(primaryKeys) > 0 {
+		sql.WriteString(fmt.Sprintf("  ,PRIMARY KEY (%s)\n", strings.Join(primaryKeys, ", ")))
+	}
+
+	sql.WriteString(");\n")
+
+	// 添加表注释
+	if table.Schema.Comment != "" {
+		sql.WriteString(fmt.Sprintf("COMMENT ON TABLE %s IS '%s';\n",
+			table.Name, table.Schema.Comment))
+	}
+
+	// 添加列注释
+	for _, col := range columns {
+		if col.Comment != "" {
+			sql.WriteString(fmt.Sprintf("COMMENT ON COLUMN %s.%s IS '%s';\n",
+				table.Name, col.Name, col.Comment))
+		}
+	}
+
+	// 添加索引（PostgreSQL中索引在表外创建）
+	for _, idx := range table.Schema.Indexes {
+		if idx.Unique {
+			sql.WriteString(fmt.Sprintf("CREATE UNIQUE INDEX IF NOT EXISTS %s ON %s (%s);\n",
+				idx.Name, table.Name, strings.Join(idx.Columns, ", ")))
+		} else {
+			sql.WriteString(fmt.Sprintf("CREATE INDEX IF NOT EXISTS %s ON %s (%s);\n",
+				idx.Name, table.Name, strings.Join(idx.Columns, ", ")))
+		}
+	}
+
+	return sql.String()
+}
+
+// getPostgreSQLType 获取PostgreSQL数据类型
+func (pg *PostgreSQLGenerator) getPostgreSQLType(col ColumnSchema) string {
+	switch col.Type {
+	case "TINYINT":
+		if col.Length == 1 {
+			return "BOOLEAN"
+		}
+		return "SMALLINT"
+	case "BOOL":
+		return "BOOLEAN"
+	case "DATETIME":
+		return "TIMESTAMP"
+	case "TIMESTAMP":
+		return "TIMESTAMP"
+	case "JSON":
+		return "JSONB"
+	case "BLOB":
+		return "BYTEA"
+	case "INT":
+		return "INTEGER"
+	case "BIGINT":
+		return "BIGINT"
+	case "DECIMAL":
+		if col.Precision > 0 && col.Scale > 0 {
+			return fmt.Sprintf("DECIMAL(%d,%d)", col.Precision, col.Scale)
+		}
+		return "DECIMAL"
+	case "VARCHAR":
+		if col.Length > 0 {
+			return fmt.Sprintf("VARCHAR(%d)", col.Length)
+		}
+		return "VARCHAR"
+	case "CHAR":
+		if col.Length > 0 {
+			return fmt.Sprintf("CHAR(%d)", col.Length)
+		}
+		return "CHAR"
+	case "TEXT":
+		return "TEXT"
+	case "FLOAT":
+		return "REAL"
+	case "DOUBLE":
+		return "DOUBLE PRECISION"
+	case "DATE":
+		return "DATE"
+	case "TIME":
+		return "TIME"
+	default:
+		return col.Type
+	}
+}
+
+// convertOption 转换选项到PostgreSQL语法
+func (pg *PostgreSQLGenerator) convertOption(option string, col ColumnSchema) string {
+	option = strings.ToUpper(option)
+
+	switch option {
+	case "NOT NULL":
+		return "NOT NULL"
+	case "UNIQUE":
+		return "UNIQUE"
+	case "AUTO_INCREMENT":
+		// PostgreSQL使用SERIAL/BIGSERIAL/SMALLSERIAL
+		// 已在getPostgreSQLType中处理
+		return ""
+	case "PRIMARY KEY":
+		// 主键将在表级别定义
+		return ""
+	default:
+		return option
+	}
+}
+
+// convertDefaultValue 转换默认值
+func (pg *PostgreSQLGenerator) convertDefaultValue(value, colType string) string {
+	value = strings.TrimSpace(value)
+
+	// 移除引号（如果有）
+	if strings.HasPrefix(value, "'") && strings.HasSuffix(value, "'") {
+		value = value[1 : len(value)-1]
+	}
+
+	// 处理布尔值
+	if strings.EqualFold(colType, "BOOLEAN") || strings.EqualFold(colType, "BOOL") {
+		switch strings.ToUpper(value) {
+		case "1", "TRUE", "'TRUE'":
+			return "TRUE"
+		case "0", "FALSE", "'FALSE'":
+			return "FALSE"
+		}
+	}
+
+	// 处理时间戳
+	if strings.Contains(strings.ToUpper(value), "CURRENT_TIMESTAMP") {
+		return "CURRENT_TIMESTAMP"
+	}
+
+	// 处理数字
+	if _, ok := pg.isNumber(value); ok {
+		return value
+	}
+
+	// 其他情况加单引号
+	return "'" + value + "'"
+}
+
+// isNumber 检查字符串是否为数字
+func (pg *PostgreSQLGenerator) isNumber(s string) (float64, bool) {
+	var f float64
+	_, err := fmt.Sscanf(s, "%f", &f)
+	return f, err == nil
+}
+
+// extractPrimaryKeys 从列中提取主键
+func (pg *PostgreSQLGenerator) extractPrimaryKeys(columns []ColumnSchema) []string {
+	var primaryKeys []string
+	for _, col := range columns {
+		for _, opt := range col.Options {
+			if strings.ToUpper(opt) == "PRIMARY KEY" {
+				primaryKeys = append(primaryKeys, col.Name)
+				break
+			}
+		}
+	}
+	return primaryKeys
+}
+
+func init() {
+	RegisterGenerator(NewPostgreSQLGenerator())
+}

sqldef/generators/sql_generator.go

@@ -0,0 +1,137 @@
+// sql_generator.go 根据数据库类型，自动选择对应注册的建立表的sql编写器，进行编写。
+package generators
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+)
+
+// ColumnSchema 列结构定义
+type ColumnSchema struct {
+	Name      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
+	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
+}

sqldef/index_manager.go

@@ -0,0 +1,99 @@
+// index_manager.go
+package sqldef
+
+import (
+	"fmt"
+	"strings"
+)
+
+// IndexManager 索引管理器
+type IndexManager struct {
+	ddlExecutor DDLExecutor
+}
+
+// IndexDefinition 索引定义
+type IndexDefinition struct {
+	TableName string
+	IndexName string
+	Columns   []string
+	IsUnique  bool
+	IsPrimary bool
+}
+
+// NewIndexManager 创建索引管理器
+func NewIndexManager(executor DDLExecutor) *IndexManager {
+	return &IndexManager{
+		ddlExecutor: executor,
+	}
+}
+
+// CreateIndex 创建索引
+func (im *IndexManager) CreateIndex(idx *IndexDefinition) error {
+	var indexType string
+	if idx.IsPrimary {
+		indexType = "PRIMARY KEY"
+	} else if idx.IsUnique {
+		indexType = "UNIQUE INDEX"
+	} else {
+		indexType = "INDEX"
+	}
+
+	columns := strings.Join(idx.Columns, ", ")
+	sql := fmt.Sprintf("CREATE %s %s ON %s (%s)",
+		indexType, idx.IndexName, idx.TableName, columns)
+
+	return im.ddlExecutor.ExecuteDDL(sql)
+}
+
+// DropIndex 删除索引
+func (im *IndexManager) DropIndex(tableName, indexName string) error {
+	sql := fmt.Sprintf("DROP INDEX %s ON %s", indexName, tableName)
+	return im.ddlExecutor.ExecuteDDL(sql)
+}
+
+// TableManager 添加索引相关方法
+func (tm *TableManager) SetIndexManager(im *IndexManager) {
+	// 可以在这里关联索引管理器
+}
+
+// CreateIndexesFromDDL 从DDL语句中解析并创建索引
+func (tm *TableManager) CreateIndexesFromDDL() error {
+	// 获取所有表
+	tables := tm.GetRegisteredTables()
+
+	for _, tableName := range tables {
+		ddl, exists := tm.GetTableDDL(tableName)
+		if !exists {
+			continue
+		}
+
+		// 解析DDL中的索引信息
+		indexes := parseIndexesFromDDL(ddl)
+
+		// 创建索引
+		for _, index := range indexes {
+			if err := tm.ddlExecutor.ExecuteDDL(index); err != nil {
+				return fmt.Errorf("创建索引失败: %w", err)
+			}
+		}
+	}
+
+	return nil
+}
+
+// parseIndexesFromDDL 从DDL语句中解析索引
+func parseIndexesFromDDL(ddl string) []string {
+	var indexes []string
+	lines := strings.Split(ddl, "\n")
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if strings.Contains(line, "INDEX") || strings.Contains(line, "PRIMARY KEY") {
+			// 移除末尾的逗号
+			line = strings.TrimSuffix(line, ",")
+			indexes = append(indexes, line)
+		}
+	}
+
+	return indexes
+}

sqldef/table_create.go

@@ -0,0 +1,168 @@
+// 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
+}
+
+// CreateTables 创建所有不存在的表
+func (ts *TableSyncer) CreateTables() error {
+	return ts.CreateAllTables(false)
+}
+
+// RecreateTables 重建所有表
+func (ts *TableSyncer) RecreateTables() error {
+	return ts.CreateAllTables(true)
+}
+
+// 包级便捷函数
+
+// 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)
+}

sqldef/table_definition.go

@@ -0,0 +1,406 @@
+package sqldef
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	"git.x2erp.com/qdy/go-db/sqldef/generators"
+)
+
+// 数据类型常量
+const (
+	TypeVarchar   = "VARCHAR"
+	TypeChar      = "CHAR"
+	TypeText      = "TEXT"
+	TypeInt       = "INT"
+	TypeBigInt    = "BIGINT"
+	TypeTinyInt   = "TINYINT"
+	TypeDecimal   = "DECIMAL"
+	TypeFloat     = "FLOAT"
+	TypeDouble    = "DOUBLE"
+	TypeBool      = "BOOL"
+	TypeDateTime  = "DATETIME"
+	TypeTimestamp = "TIMESTAMP"
+	TypeDate      = "DATE"
+	TypeTime      = "TIME"
+	TypeBlob      = "BLOB"
+	TypeJson      = "JSON"
+)
+
+// Column 列定义
+type Column struct {
+	name         string
+	sqlType      string
+	comment      string
+	options      []string
+	defaultValue string // 新增：默认值
+}
+
+// ColumnBuilder 列构建器
+type ColumnBuilder struct {
+	table  *TableBuilder
+	column Column
+}
+
+// TableBuilder 表构建器
+type TableBuilder struct {
+	name    string
+	comment string
+	columns []Column
+	indexes []string
+}
+
+// Registry 注册表（懒加载）
+type Registry struct {
+	tables map[string]generators.TableDDL
+	mu     sync.RWMutex
+	once   sync.Once
+	regFns []func(*Registry)
+}
+
+var globalRegistry = &Registry{
+	tables: make(map[string]generators.TableDDL),
+}
+
+// AddRegistration 添加注册函数
+func AddRegistration(fn func(*Registry)) {
+	globalRegistry.regFns = append(globalRegistry.regFns, fn)
+}
+
+func (r *Registry) lazyInit() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	for _, fn := range r.regFns {
+		fn(r)
+	}
+}
+
+func (r *Registry) ensureInit() {
+	r.once.Do(r.lazyInit)
+}
+
+// RegisterTable 注册表
+func (r *Registry) RegisterTable(table generators.TableDDL) {
+	if table.Name != "" {
+		r.tables[table.Name] = table
+	}
+}
+
+// GetAll 获取所有表定义
+func GetAll() []generators.TableDDL {
+	globalRegistry.ensureInit()
+
+	globalRegistry.mu.RLock()
+	defer globalRegistry.mu.RUnlock()
+
+	result := make([]generators.TableDDL, 0, len(globalRegistry.tables))
+	for _, table := range globalRegistry.tables {
+		result = append(result, table)
+	}
+	return result
+}
+
+// Get 获取表定义
+func Get(tableName string) (generators.TableDDL, bool) {
+	globalRegistry.ensureInit()
+
+	globalRegistry.mu.RLock()
+	defer globalRegistry.mu.RUnlock()
+
+	table, exists := globalRegistry.tables[tableName]
+	return table, exists
+}
+
+// ================== TableBuilder 表构建器 ==================
+
+// NewTable 创建新表
+func NewTable(name string, comment ...string) *TableBuilder {
+	tb := &TableBuilder{name: name}
+	if len(comment) > 0 {
+		tb.comment = comment[0]
+	}
+	return tb
+}
+
+// ================== 列定义方法 ==================
+
+// 默认64位长度
+func (t *TableBuilder) ID(name string, length ...int) *ColumnBuilder {
+	size := 64
+	if len(length) > 0 {
+		size = length[0]
+	}
+	return t.column(name, TypeVarchar, size).PrimaryKey()
+}
+
+func (t *TableBuilder) String(name string, length int) *ColumnBuilder {
+	return t.column(name, TypeVarchar, length)
+}
+
+func (t *TableBuilder) Char(name string, length int) *ColumnBuilder {
+	return t.column(name, TypeChar, length)
+}
+
+func (t *TableBuilder) Text(name string) *ColumnBuilder {
+	return t.column(name, TypeText, 0)
+}
+
+func (t *TableBuilder) Int(name string) *ColumnBuilder {
+	return t.column(name, TypeInt, 0)
+}
+
+func (t *TableBuilder) TinyInt(name string) *ColumnBuilder {
+	return t.column(name, TypeTinyInt, 0)
+}
+
+func (t *TableBuilder) BigInt(name string) *ColumnBuilder {
+	return t.column(name, TypeBigInt, 0)
+}
+
+func (t *TableBuilder) Bool(name string) *ColumnBuilder {
+	return t.column(name, TypeBool, 0)
+}
+
+func (t *TableBuilder) JSON(name string) *ColumnBuilder {
+	return t.column(name, TypeJson, 0)
+}
+
+func (t *TableBuilder) Decimal(name string, precision, scale int) *ColumnBuilder {
+	col := &ColumnBuilder{
+		table: t,
+		column: Column{
+			name:    name,
+			sqlType: fmt.Sprintf("%s(%d,%d)", TypeDecimal, precision, scale),
+		},
+	}
+	return col
+}
+
+func (t *TableBuilder) Float(name string) *ColumnBuilder {
+	return t.column(name, TypeFloat, 0)
+}
+
+func (t *TableBuilder) Double(name string) *ColumnBuilder {
+	return t.column(name, TypeDouble, 0)
+}
+
+func (t *TableBuilder) DateTime(name string) *ColumnBuilder {
+	return t.column(name, TypeDateTime, 0)
+}
+
+func (t *TableBuilder) Timestamp(name string) *ColumnBuilder {
+	return t.column(name, TypeTimestamp, 0)
+}
+
+func (t *TableBuilder) Time(name string) *ColumnBuilder {
+	return t.column(name, TypeTime, 0)
+}
+
+func (t *TableBuilder) Date(name string) *ColumnBuilder {
+	return t.column(name, TypeDate, 0)
+}
+
+func (t *TableBuilder) Blob(name string) *ColumnBuilder {
+	return t.column(name, TypeBlob, 0)
+}
+
+// 私有辅助方法
+func (t *TableBuilder) column(name string, dataType string, length int) *ColumnBuilder {
+	sqlType := dataType
+	if length > 0 {
+		sqlType = fmt.Sprintf("%s(%d)", dataType, length)
+	}
+
+	col := &ColumnBuilder{
+		table: t,
+		column: Column{
+			name:    name,
+			sqlType: sqlType,
+		},
+	}
+	return col
+}
+
+// ================== 列构建器方法 ==================
+
+func (c *ColumnBuilder) NotNull() *ColumnBuilder {
+	c.column.options = append(c.column.options, "NOT NULL")
+	return c
+}
+
+func (c *ColumnBuilder) Default(value string) *ColumnBuilder {
+	c.column.defaultValue = value
+	return c
+}
+
+func (c *ColumnBuilder) PrimaryKey() *ColumnBuilder {
+	c.column.options = append(c.column.options, "PRIMARY KEY")
+	return c
+}
+
+func (c *ColumnBuilder) AutoIncrement() *ColumnBuilder {
+	c.column.options = append(c.column.options, "AUTO_INCREMENT")
+	return c
+}
+
+func (c *ColumnBuilder) Unique() *ColumnBuilder {
+	c.column.options = append(c.column.options, "UNIQUE")
+	return c
+}
+
+func (c *ColumnBuilder) Comment(comment string) *ColumnBuilder {
+	c.column.comment = comment
+	return c
+}
+
+// End 结束列定义，返回TableBuilder继续定义其他列
+func (c *ColumnBuilder) End() *TableBuilder {
+	c.table.columns = append(c.table.columns, c.column)
+	return c.table
+}
+
+// ================== 索引方法 ==================
+
+func (t *TableBuilder) AddIndex(name string, columns ...string) *TableBuilder {
+	idx := fmt.Sprintf("INDEX %s (%s)", name, strings.Join(columns, ", "))
+	t.indexes = append(t.indexes, idx)
+	return t
+}
+
+func (t *TableBuilder) AddUniqueIndex(name string, columns ...string) *TableBuilder {
+	idx := fmt.Sprintf("UNIQUE INDEX %s (%s)", name, strings.Join(columns, ", "))
+	t.indexes = append(t.indexes, idx)
+	return t
+}
+
+// Build 构建表定义，包含完整的Schema信息
+func (t *TableBuilder) Build() generators.TableDDL {
+	// 构建列Schema
+	columns := make([]generators.ColumnSchema, 0, len(t.columns))
+
+	for _, col := range t.columns {
+		// 解析列类型
+		colType, length, precision, scale := parseColumnType(col.sqlType)
+
+		// 提取默认值
+		var defaultValue string
+		var options []string
+		for _, opt := range col.options {
+			if strings.HasPrefix(opt, "DEFAULT ") {
+				defaultValue = strings.TrimPrefix(opt, "DEFAULT ")
+			} else {
+				options = append(options, opt)
+			}
+		}
+
+		columns = append(columns, generators.ColumnSchema{
+			Name:      col.name,
+			Type:      colType,
+			Length:    length,
+			Precision: precision,
+			Scale:     scale,
+			Comment:   col.comment,
+			Options:   options,
+			Default:   defaultValue,
+		})
+	}
+
+	// 构建索引Schema
+	indexes := make([]generators.IndexSchema, 0, len(t.indexes))
+
+	for _, idx := range t.indexes {
+		// 解析索引字符串，例如: "INDEX idx_name (col1, col2)" 或 "UNIQUE INDEX idx_name (col1, col2)"
+		indexName, isUnique, columns := parseIndex(idx)
+		if indexName != "" && len(columns) > 0 {
+			indexes = append(indexes, generators.IndexSchema{
+				Name:    indexName,
+				Columns: columns,
+				Unique:  isUnique,
+			})
+		}
+	}
+
+	return generators.TableDDL{
+		Name:    t.name,
+		Comment: t.comment,
+		Schema: &generators.TableSchema{
+			Name:    t.name,
+			Comment: t.comment,
+			Columns: columns,
+			Indexes: indexes,
+		},
+	}
+}
+
+// parseColumnType 解析列类型字符串
+func parseColumnType(sqlType string) (colType string, length, precision, scale int) {
+	sqlType = strings.ToUpper(strings.TrimSpace(sqlType))
+
+	// 处理带括号的类型，如 VARCHAR(255), DECIMAL(10,2)
+	if strings.Contains(sqlType, "(") {
+		openParen := strings.Index(sqlType, "(")
+		closeParen := strings.Index(sqlType, ")")
+
+		colType = sqlType[:openParen]
+		params := strings.TrimSpace(sqlType[openParen+1 : closeParen])
+
+		switch colType {
+		case "DECIMAL":
+			if strings.Contains(params, ",") {
+				parts := strings.Split(params, ",")
+				if len(parts) == 2 {
+					fmt.Sscanf(parts[0], "%d", &precision)
+					fmt.Sscanf(parts[1], "%d", &scale)
+				}
+			}
+		case "VARCHAR", "CHAR":
+			fmt.Sscanf(params, "%d", &length)
+		default:
+			fmt.Sscanf(params, "%d", &length)
+		}
+	} else {
+		colType = sqlType
+	}
+
+	return
+}
+
+// parseIndex 解析索引字符串
+func parseIndex(indexStr string) (name string, isUnique bool, columns []string) {
+	indexStr = strings.TrimSpace(indexStr)
+
+	// 检查是否是唯一索引
+	if strings.HasPrefix(indexStr, "UNIQUE INDEX") {
+		isUnique = true
+		indexStr = strings.TrimPrefix(indexStr, "UNIQUE INDEX ")
+	} else if strings.HasPrefix(indexStr, "INDEX") {
+		indexStr = strings.TrimPrefix(indexStr, "INDEX ")
+	} else {
+		return "", false, nil
+	}
+
+	// 分割索引名和列
+	parts := strings.Split(indexStr, " ")
+	if len(parts) < 2 {
+		return "", false, nil
+	}
+
+	name = parts[0]
+
+	// 提取列，如 (col1, col2)
+	colsPart := strings.Join(parts[1:], " ")
+	colsPart = strings.Trim(colsPart, "()")
+	columns = strings.Split(colsPart, ", ")
+
+	return
+}
+
+// Register 快捷方法：直接注册表
+func (t *TableBuilder) Register() {
+	table := t.Build()
+	AddRegistration(func(r *Registry) {
+		r.RegisterTable(table)
+	})
+}

sqldef/table_manager.go

@@ -0,0 +1,250 @@
+// table_manager.go
+package sqldef
+
+import (
+	"fmt"
+	"sync"
+
+	"git.x2erp.com/qdy/go-db/sqldef/generators"
+)
+
+// TableManager 表管理器
+type TableManager struct {
+	ddlExecutor DDLExecutor
+	initialized bool
+	mu          sync.RWMutex
+}
+
+// DDLExecutor DDL执行器接口
+type DDLExecutor interface {
+	ExecuteDDL(ddl string) error
+	TableExists(tableName string) (bool, error)
+}
+
+// TableManagerFactory 表管理器工厂
+type TableManagerFactory struct {
+	instance *TableManager
+	mu       sync.RWMutex
+}
+
+var factory = &TableManagerFactory{}
+
+// GetTableManager 获取或创建表管理器实例（懒加载）
+func GetTableManager() *TableManager {
+	return factory.GetInstance()
+}
+
+// GetTableManagerWithExecutor 使用指定的执行器获取表管理器
+func GetTableManagerWithExecutor(executor DDLExecutor) *TableManager {
+	return factory.GetInstanceWithExecutor(executor)
+}
+
+// GetInstance 获取单例实例（懒加载）
+func (f *TableManagerFactory) GetInstance() *TableManager {
+	f.mu.RLock()
+	if f.instance != nil && f.instance.initialized {
+		f.mu.RUnlock()
+		return f.instance
+	}
+	f.mu.RUnlock()
+
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	// 双重检查
+	if f.instance != nil && f.instance.initialized {
+		return f.instance
+	}
+
+	// 创建新实例（但未初始化执行器）
+	f.instance = &TableManager{}
+	return f.instance
+}
+
+// GetInstanceWithExecutor 使用执行器获取实例
+func (f *TableManagerFactory) GetInstanceWithExecutor(executor DDLExecutor) *TableManager {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	// 如果已存在实例且有执行器，则直接返回
+	if f.instance != nil && f.instance.initialized && f.instance.ddlExecutor != nil {
+		return f.instance
+	}
+
+	// 创建或更新实例
+	if f.instance == nil {
+		f.instance = &TableManager{
+			ddlExecutor: executor,
+			initialized: true,
+		}
+	} else {
+		f.instance.ddlExecutor = executor
+		f.instance.initialized = true
+	}
+
+	return f.instance
+}
+
+// SyncTables 同步所有注册的表结构（懒加载执行器）
+// recreate: true - 如果表存在则删除重建；false - 如果表不存在则创建
+func (tm *TableManager) SyncTables(recreate bool) error {
+	// 确保注册表已初始化
+	globalRegistry.ensureInit()
+
+	// 检查执行器是否初始化
+	if !tm.isExecutorInitialized() {
+		return fmt.Errorf("DDL执行器未初始化，请先调用SetExecutor方法")
+	}
+
+	// 获取所有注册的表定义
+	tables := GetAll()
+
+	// 按顺序处理所有表
+	for _, table := range tables {
+		err := tm.syncTable(table, recreate)
+		if err != nil {
+			return fmt.Errorf("同步表 %s 失败: %w", table.Name, err)
+		}
+	}
+
+	return nil
+}
+
+// SetExecutor 设置DDL执行器
+func (tm *TableManager) SetExecutor(executor DDLExecutor) {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+
+	tm.ddlExecutor = executor
+	tm.initialized = true
+}
+
+// isExecutorInitialized 检查执行器是否初始化
+func (tm *TableManager) isExecutorInitialized() bool {
+	tm.mu.RLock()
+	defer tm.mu.RUnlock()
+
+	return tm.initialized && tm.ddlExecutor != nil
+}
+
+// syncTable 同步单个表
+func (tm *TableManager) syncTable(table generators.TableDDL, recreate bool) error {
+	// 检查表是否存在
+	exists, err := tm.ddlExecutor.TableExists(table.Name)
+	if err != nil {
+		return fmt.Errorf("检查表 %s 是否存在失败: %w", table.Name, err)
+	}
+
+	if recreate {
+		// 如果存在就删除重建
+		if exists {
+			// 删除表
+			dropSQL := fmt.Sprintf("DROP TABLE IF EXISTS %s", table.Name)
+			if err := tm.ddlExecutor.ExecuteDDL(dropSQL); err != nil {
+				return fmt.Errorf("删除表 %s 失败: %w", table.Name, err)
+			}
+			fmt.Printf("表 %s 已删除\n", table.Name)
+
+			// 重新创建表
+			if err := tm.ddlExecutor.ExecuteDDL(table.SQL); err != nil {
+				return fmt.Errorf("创建表 %s 失败: %w", table.Name, err)
+			}
+			fmt.Printf("表 %s 已创建\n", table.Name)
+		} else {
+			// 不存在直接创建
+			if err := tm.ddlExecutor.ExecuteDDL(table.SQL); err != nil {
+				return fmt.Errorf("创建表 %s 失败: %w", table.Name, err)
+			}
+			fmt.Printf("表 %s 已创建\n", table.Name)
+		}
+	} else {
+		// 如果不存在就建立
+		if !exists {
+			if err := tm.ddlExecutor.ExecuteDDL(table.SQL); err != nil {
+				return fmt.Errorf("创建表 %s 失败: %w", table.Name, err)
+			}
+			fmt.Printf("表 %s 已创建\n", table.Name)
+		} else {
+			fmt.Printf("表 %s 已存在，跳过创建\n", table.Name)
+		}
+	}
+
+	return nil
+}
+
+// CreateTables 创建所有表（不存在则创建）
+func (tm *TableManager) CreateTables() error {
+	return tm.SyncTables(false)
+}
+
+// RecreateTables 重建所有表（存在则删除重建）
+func (tm *TableManager) RecreateTables() error {
+	return tm.SyncTables(true)
+}
+
+// CreateIndexes 创建索引
+func (tm *TableManager) CreateIndexes() error {
+	// 这里可以添加索引创建的逻辑
+	// 由于TableDDL中没有包含索引信息，所以暂时为空
+
+	// 暂时返回nil，表示索引创建成功（实际上是空的）
+	fmt.Println("创建索引方法（空实现）")
+	return nil
+}
+
+// CreateTablesAndIndexes 创建表及其索引（便捷方法）
+func (tm *TableManager) CreateTablesAndIndexes(recreateTables bool) error {
+	if err := tm.SyncTables(recreateTables); err != nil {
+		return err
+	}
+
+	return tm.CreateIndexes()
+}
+
+// GetRegisteredTables 获取所有注册的表名
+func (tm *TableManager) GetRegisteredTables() []string {
+	globalRegistry.ensureInit()
+
+	globalRegistry.mu.RLock()
+	defer globalRegistry.mu.RUnlock()
+
+	tables := make([]string, 0, len(globalRegistry.tables))
+	for name := range globalRegistry.tables {
+		tables = append(tables, name)
+	}
+	return tables
+}
+
+// GetTableDDL 获取指定表的DDL语句
+func (tm *TableManager) GetTableDDL(tableName string) (string, bool) {
+	table, exists := Get(tableName)
+	return table.SQL, exists
+}
+
+// PrintRegisteredTables 打印所有注册的表信息
+func (tm *TableManager) PrintRegisteredTables() {
+	tables := tm.GetRegisteredTables()
+	fmt.Printf("注册的表数量: %d\n", len(tables))
+	for i, name := range tables {
+		fmt.Printf("%d. %s\n", i+1, name)
+	}
+}
+
+// 包级便捷函数
+// CreateAllTables 创建所有表（便捷函数，自动获取单例）
+func CreateAllTables(executor DDLExecutor) error {
+	tm := GetTableManagerWithExecutor(executor)
+	return tm.CreateTables()
+}
+
+// RecreateAllTables 重建所有表（便捷函数，自动获取单例）
+func RecreateAllTables(executor DDLExecutor) error {
+	tm := GetTableManagerWithExecutor(executor)
+	return tm.RecreateTables()
+}
+
+// SyncAllTables 同步所有表（便捷函数，自动获取单例）
+func SyncAllTables(executor DDLExecutor, recreate bool) error {
+	tm := GetTableManagerWithExecutor(executor)
+	return tm.SyncTables(recreate)
+}