重构：移除数据库客户端模块 v0.4.0（-17,885行，专注文件管理）

- 删除全部 MySQL/Redis/MongoDB 客户端代码（dbclient/api/service/storage）
- 清理 4 个驱动依赖（mysql/redis/mongo/gorm-mysql），构建体积 -10MB
- 前端移除 db-cli 整个目录（40 文件）+ 7 个 API/工具文件
- 版本号升级至 v0.4.0，顶部 Tab 仅保留文件管理

internal/service/config_service.go

@@ -42,11 +42,10 @@ type TabConfig struct {
 var defaultTabConfig = TabConfig{
 	AvailableTabs: []TabDefinition{
 		{Key: "file-system", Title: "文件管理", Enabled: true},
-		{Key: "db-cli", Title: "数据库", Enabled: true},
 		{Key: "markdown-editor", Title: "Markdown", Enabled: true},
 		{Key: "version", Title: "版本历史", Enabled: true},
 	},
-	VisibleTabs: []string{"file-system", "db-cli", "markdown-editor", "version"},
+	VisibleTabs: []string{"file-system", "markdown-editor", "version"},
 	DefaultTab:  "file-system",
 }
 

internal/service/connection_service.go

@@ -1,268 +0,0 @@
-package service
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"u-desk/internal/crypto"
-	"u-desk/internal/dbclient"
-	"u-desk/internal/storage/models"
-	"u-desk/internal/storage/repository"
-
-	"gorm.io/gorm"
-)
-
-// ConnectionService 连接管理服务
-type ConnectionService struct {
-	repo repository.ConnectionRepository
-}
-
-// NewConnectionService 创建连接服务
-func NewConnectionService() (*ConnectionService, error) {
-	repo, err := repository.NewConnectionRepository()
-	if err != nil {
-		return nil, fmt.Errorf("创建连接仓库失败: %v", err)
-	}
-	return &ConnectionService{repo: repo}, nil
-}
-
-// SaveConnection 保存连接配置
-func (s *ConnectionService) SaveConnection(conn *models.DbConnection) error {
-	// 验证
-	if conn.Name == "" {
-		return fmt.Errorf("连接名称不能为空")
-	}
-	if conn.Type == "" {
-		return fmt.Errorf("数据库类型不能为空")
-	}
-	if conn.Host == "" {
-		return fmt.Errorf("主机地址不能为空")
-	}
-
-	// 检查名称是否重复
-	existing, err := s.repo.FindByName(conn.Name, conn.ID)
-	if err != nil {
-		return fmt.Errorf("检查连接名称失败: %v", err)
-	}
-	if existing != nil {
-		return fmt.Errorf("连接名称已存在")
-	}
-
-	// 处理密码
-	if conn.ID > 0 {
-		if conn.Password == "" {
-			// 更新模式：保留原密码
-			conn.Password, err = s.getPassword(conn.ID)
-			if err != nil {
-				return err
-			}
-		} else {
-			// 加密新密码
-			conn.Password, err = crypto.EncryptPassword(conn.Password)
-			if err != nil {
-				return fmt.Errorf("密码加密失败: %v", err)
-			}
-		}
-	} else {
-		// 新增模式：加密密码
-		conn.Password, err = crypto.EncryptPassword(conn.Password)
-		if err != nil {
-			return fmt.Errorf("密码加密失败: %v", err)
-		}
-	}
-
-	return s.repo.Save(conn)
-}
-
-// getPassword 获取原始密码
-func (s *ConnectionService) getPassword(id uint) (string, error) {
-	existing, err := s.repo.FindByID(id)
-	if err != nil {
-		return "", fmt.Errorf("获取原连接配置失败: %v", err)
-	}
-	return existing.Password, nil
-}
-
-// ListConnections 获取连接列表
-func (s *ConnectionService) ListConnections() ([]models.DbConnection, error) {
-	return s.repo.FindAll()
-}
-
-// GetConnection 获取连接详情
-func (s *ConnectionService) GetConnection(id uint) (*models.DbConnection, error) {
-	return s.repo.FindByID(id)
-}
-
-// DeleteConnection 删除连接配置（含关联数据和连接池清理）
-func (s *ConnectionService) DeleteConnection(id uint) error {
-	conn, err := s.repo.FindByID(id)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil // 连接不存在视为成功
-		}
-		return fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	// 关闭连接池中的连接
-	dbclient.GetPool().CloseConnection(id, conn.Type)
-
-	// 删除连接记录
-	return s.repo.Delete(id)
-}
-
-// TestConnection 测试连接（通过已保存的连接ID）
-func (s *ConnectionService) TestConnection(id uint) error {
-	conn, err := s.repo.FindByID(id)
-	if err != nil {
-		return fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	// 解密密码用于测试
-	password, err := crypto.DecryptPassword(conn.Password)
-	if err != nil {
-		return fmt.Errorf("密码解密失败: %v", err)
-	}
-
-	// 根据类型测试连接
-	switch conn.Type {
-	case "mysql":
-		return dbclient.TestMySQLConnection(conn.Host, conn.Port, conn.Username, password, conn.Database)
-	case "redis":
-		return dbclient.TestRedisConnection(conn.Host, conn.Port, password)
-	case "mongo":
-		// 解析 Options 获取 MongoDB 连接参数
-		authSource := ""
-		authMechanism := ""
-		if conn.Options != "" {
-			var opts map[string]interface{}
-			if err := json.Unmarshal([]byte(conn.Options), &opts); err == nil {
-				if as, ok := opts["authSource"].(string); ok && as != "" {
-					authSource = as
-				}
-				if am, ok := opts["authMechanism"].(string); ok && am != "" {
-					authMechanism = am
-				}
-			}
-		}
-		return dbclient.TestMongoConnectionWithOptions(conn.Host, conn.Port, conn.Username, password, conn.Database, authSource, authMechanism)
-	default:
-		return fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}
-
-// TestConnectionWithParams 测试连接（直接传入参数，不保存数据）
-func (s *ConnectionService) TestConnectionWithParams(connType, host string, port int, username, password, database, options string, existingId uint) error {
-	// 验证必填项
-	if connType == "" {
-		return fmt.Errorf("数据库类型不能为空")
-	}
-	if host == "" {
-		return fmt.Errorf("主机地址不能为空")
-	}
-
-	// 如果是编辑模式且密码为空，尝试获取已保存的密码
-	actualPassword := password
-	if existingId > 0 && password == "" {
-		conn, err := s.repo.FindByID(existingId)
-		if err != nil {
-			return fmt.Errorf("获取原连接配置失败: %v", err)
-		}
-		// 解密原密码
-		actualPassword, err = crypto.DecryptPassword(conn.Password)
-		if err != nil {
-			return fmt.Errorf("密码解密失败: %v", err)
-		}
-	}
-
-	// 根据类型测试连接
-	switch connType {
-	case "mysql":
-		return dbclient.TestMySQLConnection(host, port, username, actualPassword, database)
-	case "redis":
-		return dbclient.TestRedisConnection(host, port, actualPassword)
-	case "mongo":
-		// 解析 Options 获取 MongoDB 连接参数
-		authSource := ""
-		authMechanism := ""
-		if options != "" {
-			var opts map[string]interface{}
-			if err := json.Unmarshal([]byte(options), &opts); err == nil {
-				if as, ok := opts["authSource"].(string); ok && as != "" {
-					authSource = as
-				}
-				if am, ok := opts["authMechanism"].(string); ok && am != "" {
-					authMechanism = am
-				}
-			}
-		}
-		return dbclient.TestMongoConnectionWithOptions(host, port, username, actualPassword, database, authSource, authMechanism)
-	default:
-		return fmt.Errorf("不支持的数据库类型: %s", connType)
-	}
-}
-
-// LoadAllDatabases 加载全部数据库列表
-func (s *ConnectionService) LoadAllDatabases(dbType, host string, port int, username, password, database, options string, existingId uint) ([]string, error) {
-	// 如果是编辑模式且密码为空，尝试获取已保存的密码
-	actualPassword := password
-	if existingId > 0 && password == "" {
-		conn, err := s.repo.FindByID(existingId)
-		if err != nil {
-			return nil, fmt.Errorf("获取原连接配置失败: %v", err)
-		}
-		actualPassword, err = crypto.DecryptPassword(conn.Password)
-		if err != nil {
-			return nil, fmt.Errorf("密码解密失败: %v", err)
-		}
-	}
-
-	// 解析 MongoDB 选项
-	authSource := ""
-	authMechanism := ""
-	if options != "" {
-		var opts map[string]interface{}
-		if err := json.Unmarshal([]byte(options), &opts); err == nil {
-			authSource, _ = opts["authSource"].(string)
-			authMechanism, _ = opts["authMechanism"].(string)
-		}
-	}
-
-	switch dbType {
-	case "mysql":
-		return loadDatabasesForMySQL(host, port, username, actualPassword, database)
-	case "mongo":
-		return loadDatabasesForMongo(host, port, username, actualPassword, database, authSource, authMechanism)
-	case "redis":
-		return []string{}, nil
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", dbType)
-	}
-}
-
-func loadDatabasesForMySQL(host string, port int, username, password, defaultDatabase string) ([]string, error) {
-	config := &dbclient.MySQLConfig{
-		Host: host, Port: port, Username: username,
-		Password: password, Database: defaultDatabase,
-	}
-	client, err := dbclient.NewMySQLClient(config)
-	if err != nil {
-		return nil, err
-	}
-	defer client.Close()
-	return client.ListDatabases(context.Background())
-}
-
-func loadDatabasesForMongo(host string, port int, username, password, defaultDatabase, authSource, authMechanism string) ([]string, error) {
-	config := &dbclient.MongoConfig{
-		Host: host, Port: port, Username: username,
-		Password: password, Database: defaultDatabase,
-		AuthSource: authSource, AuthMechanism: authMechanism,
-	}
-	client, err := dbclient.NewMongoClient(config)
-	if err != nil {
-		return nil, err
-	}
-	defer client.Close()
-	return client.ListDatabases(context.Background())
-}

internal/service/sql_exec_service.go

@@ -1,475 +0,0 @@
-package service
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"u-desk/internal/common"
-	"u-desk/internal/dbclient"
-	"u-desk/internal/storage/models"
-	"u-desk/internal/storage/repository"
-)
-
-// SqlExecService SQL执行服务
-type SqlExecService struct {
-	connRepo repository.ConnectionRepository
-	pool     *dbclient.ConnectionPool
-}
-
-// NewSqlExecService 创建SQL执行服务
-func NewSqlExecService() (*SqlExecService, error) {
-	connRepo, err := repository.NewConnectionRepository()
-	if err != nil {
-		return nil, err
-	}
-	return &SqlExecService{
-		connRepo: connRepo,
-		pool:     dbclient.GetPool(),
-	}, nil
-}
-
-// SqlResult SQL执行结果
-type SqlResult struct {
-	Type          string      `json:"type"`          // query/update/command
-	Data          interface{} `json:"data"`          // 查询结果数据
-	Columns       []string    `json:"columns"`       // 列顺序（仅查询时有效）
-	RowsAffected  int         `json:"rowsAffected"`  // 影响行数
-	ExecutionTime int64       `json:"executionTime"` // 执行时间（毫秒）
-}
-
-// ExecuteSQL 执行SQL语句
-// 注意：SQL 语句应该已经包含分页信息（LIMIT 和 OFFSET），由客户端添加
-func (s *SqlExecService) ExecuteSQL(connectionID uint, sqlStr string, database string) (*SqlResult, error) {
-	conn, err := s.connRepo.FindByID(connectionID)
-	if err != nil {
-		return nil, fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	startTime := time.Now()
-	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutQuery)
-	defer cancel()
-
-	switch conn.Type {
-	case "mysql":
-		return s.executeMySQL(ctx, conn, sqlStr, database, startTime)
-	case "redis":
-		return s.executeRedis(ctx, conn, sqlStr, startTime)
-	case "mongo":
-		return s.executeMongo(ctx, conn, sqlStr, database, startTime)
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}
-
-// executeMySQL 执行MySQL SQL
-func (s *SqlExecService) executeMySQL(ctx context.Context, conn *models.DbConnection, sqlStr string, database string, startTime time.Time) (*SqlResult, error) {
-	pc := s.pool.GetMySQLClient(conn)
-	if pc.Client == nil {
-		return nil, fmt.Errorf("获取 MySQL 客户端失败")
-	}
-	defer pc.Release()
-
-	sqlStr = strings.TrimSpace(sqlStr)
-	sqlUpper := strings.ToUpper(sqlStr)
-
-	// 获取数据库参数
-	dbName := database
-	if dbName == "" {
-		dbName = conn.Database
-	}
-
-	result := &SqlResult{
-		ExecutionTime: time.Since(startTime).Milliseconds(),
-	}
-
-	// 判断是查询还是更新
-	if strings.HasPrefix(sqlUpper, "SELECT") || strings.HasPrefix(sqlUpper, "SHOW") ||
-		strings.HasPrefix(sqlUpper, "DESCRIBE") || strings.HasPrefix(sqlUpper, "DESC") ||
-		strings.HasPrefix(sqlUpper, "EXPLAIN") {
-		// 查询语句
-		queryResult, err := pc.Client.ExecuteQuery(ctx, sqlStr, dbName)
-		if err != nil {
-			return nil, err
-		}
-		result.Type = "query"
-		result.Data = queryResult.Data
-		result.Columns = queryResult.Columns
-		result.RowsAffected = len(queryResult.Data)
-	} else {
-		// 更新语句
-		rowsAffected, err := pc.Client.ExecuteUpdate(ctx, sqlStr, dbName)
-		if err != nil {
-			return nil, err
-		}
-		result.Type = "update"
-		result.RowsAffected = int(rowsAffected)
-		result.Data = nil
-	}
-
-	return result, nil
-}
-
-// executeRedis 执行Redis命令
-func (s *SqlExecService) executeRedis(ctx context.Context, conn *models.DbConnection, sqlStr string, startTime time.Time) (*SqlResult, error) {
-	client, err := s.pool.GetRedisClient(conn)
-	if err != nil {
-		return nil, fmt.Errorf("获取 Redis 客户端失败: %v", err)
-	}
-
-	// 解析Redis命令
-	parts := parseRedisCommand(sqlStr)
-	if len(parts) == 0 {
-		return nil, fmt.Errorf("Redis 命令不能为空")
-	}
-
-	cmd := strings.ToUpper(parts[0])
-	args := make([]interface{}, 0)
-	for i := 1; i < len(parts); i++ {
-		args = append(args, parts[i])
-	}
-
-	data, err := client.ExecuteCommand(ctx, cmd, args...)
-	if err != nil {
-		return nil, err
-	}
-
-	return &SqlResult{
-		Type:          "command",
-		Data:          data,
-		RowsAffected:  1,
-		ExecutionTime: time.Since(startTime).Milliseconds(),
-	}, nil
-}
-
-// executeMongo 执行MongoDB命令
-func (s *SqlExecService) executeMongo(ctx context.Context, conn *models.DbConnection, sqlStr string, database string, startTime time.Time) (*SqlResult, error) {
-	client, err := s.pool.GetMongoClient(conn)
-	if err != nil {
-		return nil, fmt.Errorf("获取 MongoDB 客户端失败: %v", err)
-	}
-
-	// 解析MongoDB命令（JSON格式）
-	var command map[string]interface{}
-	sqlStr = strings.TrimSpace(sqlStr)
-	if err := json.Unmarshal([]byte(sqlStr), &command); err != nil {
-		return nil, fmt.Errorf("MongoDB 命令必须是有效的 JSON 格式: %v", err)
-	}
-
-	// 确定数据库
-	dbName := conn.Database
-	if db, ok := command["database"].(string); ok && db != "" {
-		dbName = db
-	}
-	if database != "" {
-		dbName = database
-	}
-	if dbName == "" {
-		return nil, fmt.Errorf("需要指定数据库名称")
-	}
-
-	// 执行命令
-	data, err := client.ExecuteCommand(ctx, dbName, command)
-	if err != nil {
-		return nil, err
-	}
-
-	result := &SqlResult{
-		Type:          "command",
-		Data:          data,
-		ExecutionTime: time.Since(startTime).Milliseconds(),
-	}
-
-	// 根据操作类型确定影响行数
-	if op, ok := command["op"].(string); ok {
-		switch op {
-		case "find":
-			if results, ok := data.([]map[string]interface{}); ok {
-				result.RowsAffected = len(results)
-			}
-		case "count":
-			if count, ok := data.(int64); ok {
-				result.RowsAffected = int(count)
-			}
-		case "insertOne", "deleteOne":
-			result.RowsAffected = 1
-		case "insertMany":
-			if resultMap, ok := data.(map[string]interface{}); ok {
-				if count, ok := resultMap["insertedCount"].(int); ok {
-					result.RowsAffected = count
-				}
-			}
-		default:
-			result.RowsAffected = 0
-		}
-	}
-
-	return result, nil
-}
-
-// GetDatabases 获取数据库列表
-func (s *SqlExecService) GetDatabases(connectionID uint) ([]string, error) {
-	conn, err := s.connRepo.FindByID(connectionID)
-	if err != nil {
-		return nil, fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutFastQuery)
-	defer cancel()
-
-	switch conn.Type {
-	case "mysql":
-		pc := s.pool.GetMySQLClient(conn)
-		if pc.Client == nil {
-			return nil, fmt.Errorf("获取 MySQL 客户端失败")
-		}
-		defer pc.Release()
-		return pc.Client.ListDatabases(ctx)
-	case "redis":
-		databases := make([]string, 16)
-		for i := 0; i < 16; i++ {
-			databases[i] = fmt.Sprintf("%d", i)
-		}
-		return databases, nil
-	case "mongo":
-		client, err := s.pool.GetMongoClient(conn)
-		if err != nil {
-			return nil, fmt.Errorf("获取 MongoDB 客户端失败: %v", err)
-		}
-		return client.ListDatabases(ctx)
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}
-
-// GetTables 获取表列表（MySQL/MongoDB）或Key列表（Redis）
-func (s *SqlExecService) GetTables(connectionID uint, database string) ([]string, error) {
-	conn, err := s.connRepo.FindByID(connectionID)
-	if err != nil {
-		return nil, fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutFastQuery)
-	defer cancel()
-
-	switch conn.Type {
-	case "mysql":
-		pc := s.pool.GetMySQLClient(conn)
-		if pc.Client == nil {
-			return nil, fmt.Errorf("获取 MySQL 客户端失败")
-		}
-		defer pc.Release()
-		return pc.Client.ListTables(ctx, database)
-	case "redis":
-		client, err := s.pool.GetRedisClient(conn)
-		if err != nil {
-			return nil, fmt.Errorf("获取 Redis 客户端失败: %v", err)
-		}
-		return client.GetKeys(ctx, database)
-	case "mongo":
-		client, err := s.pool.GetMongoClient(conn)
-		if err != nil {
-			return nil, fmt.Errorf("获取 MongoDB 客户端失败: %v", err)
-		}
-		return client.ListCollections(ctx, database)
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}
-
-// parseRedisCommand 解析Redis命令
-func parseRedisCommand(cmd string) []string {
-	cmd = strings.TrimSpace(cmd)
-	if cmd == "" {
-		return []string{}
-	}
-
-	var parts []string
-	var current strings.Builder
-	inQuotes := false
-	quoteChar := byte(0)
-
-	for i := 0; i < len(cmd); i++ {
-		char := cmd[i]
-		if !inQuotes {
-			if char == '"' || char == '\'' {
-				inQuotes = true
-				quoteChar = char
-			} else if char == ' ' || char == '\t' {
-				if current.Len() > 0 {
-					parts = append(parts, current.String())
-					current.Reset()
-				}
-			} else {
-				current.WriteByte(char)
-			}
-		} else {
-			if char == quoteChar {
-				inQuotes = false
-				quoteChar = byte(0)
-			} else {
-				current.WriteByte(char)
-			}
-		}
-	}
-
-	if current.Len() > 0 {
-		parts = append(parts, current.String())
-	}
-	return parts
-}
-
-// GetTableStructure 获取表结构
-func (s *SqlExecService) GetTableStructure(connectionID uint, database, tableName string) (map[string]interface{}, error) {
-	conn, err := s.connRepo.FindByID(connectionID)
-	if err != nil {
-		return nil, fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutQuery)
-	defer cancel()
-
-	switch conn.Type {
-	case "mysql":
-		pc := s.pool.GetMySQLClient(conn)
-		if pc.Client == nil {
-			return nil, fmt.Errorf("获取 MySQL 客户端失败")
-		}
-		defer pc.Release()
-		structure, err := pc.Client.GetTableStructure(ctx, database, tableName)
-		if err != nil {
-			return nil, err
-		}
-		return map[string]interface{}{
-			"type":     "mysql",
-			"database": database,
-			"table":    tableName,
-			"columns":  structure,
-		}, nil
-
-	case "mongo":
-		client, err := s.pool.GetMongoClient(conn)
-		if err != nil {
-			return nil, fmt.Errorf("获取 MongoDB 客户端失败: %v", err)
-		}
-		structure, err := client.GetCollectionStructure(ctx, database, tableName)
-		if err != nil {
-			return nil, err
-		}
-		return map[string]interface{}{
-			"type":       "mongo",
-			"database":   database,
-			"collection": tableName,
-			"structure":  structure,
-		}, nil
-
-	case "redis":
-		client, err := s.pool.GetRedisClient(conn)
-		if err != nil {
-			return nil, fmt.Errorf("获取 Redis 客户端失败: %v", err)
-		}
-		info, err := client.GetKeyInfo(ctx, tableName)
-		if err != nil {
-			return nil, err
-		}
-		return map[string]interface{}{
-			"type": "redis",
-			"key":  tableName,
-			"info": info,
-		}, nil
-
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}
-
-// GetIndexes 获取索引列表
-func (s *SqlExecService) GetIndexes(connectionID uint, database, tableName string) ([]map[string]interface{}, error) {
-	conn, err := s.connRepo.FindByID(connectionID)
-	if err != nil {
-		return nil, fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutQuery)
-	defer cancel()
-
-	switch conn.Type {
-	case "mysql":
-		pc := s.pool.GetMySQLClient(conn)
-		if pc.Client == nil {
-			return nil, fmt.Errorf("获取 MySQL 客户端失败")
-		}
-		defer pc.Release()
-		return pc.Client.GetIndexes(ctx, database, tableName)
-
-	case "mongo", "redis":
-		return []map[string]interface{}{}, nil
-
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}
-
-// PreviewTableStructure 预览表结构变更
-func (s *SqlExecService) PreviewTableStructure(connectionID uint, database, tableName string, structure map[string]interface{}) ([]string, error) {
-	conn, err := s.connRepo.FindByID(connectionID)
-	if err != nil {
-		return nil, fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutLongOp)
-	defer cancel()
-
-	switch conn.Type {
-	case "mysql":
-		pc := s.pool.GetMySQLClient(conn)
-		if pc.Client == nil {
-			return nil, fmt.Errorf("获取 MySQL 客户端失败")
-		}
-		defer pc.Release()
-		return pc.Client.PreviewTableStructure(ctx, database, tableName, structure)
-
-	case "mongo":
-		client, err := s.pool.GetMongoClient(conn)
-		if err != nil {
-			return nil, fmt.Errorf("获取 MongoDB 客户端失败: %v", err)
-		}
-		return client.PreviewCollectionIndexes(ctx, database, tableName, structure)
-
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}
-
-// UpdateTableStructure 更新表结构
-func (s *SqlExecService) UpdateTableStructure(connectionID uint, database, tableName string, structure map[string]interface{}) ([]string, error) {
-	conn, err := s.connRepo.FindByID(connectionID)
-	if err != nil {
-		return nil, fmt.Errorf("获取连接配置失败: %v", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), common.TimeoutLongOp)
-	defer cancel()
-
-	switch conn.Type {
-	case "mysql":
-		pc := s.pool.GetMySQLClient(conn)
-		if pc.Client == nil {
-			return nil, fmt.Errorf("获取 MySQL 客户端失败")
-		}
-		defer pc.Release()
-		return pc.Client.UpdateTableStructure(ctx, database, tableName, structure)
-
-	case "mongo":
-		client, err := s.pool.GetMongoClient(conn)
-		if err != nil {
-			return nil, fmt.Errorf("获取 MongoDB 客户端失败: %v", err)
-		}
-		return client.UpdateCollectionIndexes(ctx, database, tableName, structure)
-
-	default:
-		return nil, fmt.Errorf("不支持的数据库类型: %s", conn.Type)
-	}
-}

internal/service/tab_service.go

@@ -1,31 +0,0 @@
-package service
-
-import (
-	"fmt"
-	"u-desk/internal/storage/models"
-	"u-desk/internal/storage/repository"
-)
-
-// TabService 标签页管理服务
-type TabService struct {
-	repo repository.TabRepository
-}
-
-// NewTabService 创建标签页服务
-func NewTabService() (*TabService, error) {
-	repo, err := repository.NewTabRepository()
-	if err != nil {
-		return nil, fmt.Errorf("创建标签页仓库失败: %v", err)
-	}
-	return &TabService{repo: repo}, nil
-}
-
-// SaveTabs 保存标签页列表
-func (s *TabService) SaveTabs(tabs []models.SqlTab) error {
-	return s.repo.SaveAll(tabs)
-}
-
-// ListTabs 获取标签页列表
-func (s *TabService) ListTabs() ([]models.SqlTab, error) {
-	return s.repo.FindAll()
-}

internal/service/version.go

@@ -15,7 +15,7 @@ import (
 // ==================== 常量定义 ====================
 
 // AppVersion 应用版本号（发布时直接修改此处）
-const AppVersion = "0.3.3"
+const AppVersion = "0.4.0"
 
 // 版本号缓存
 var (