cli.go

package mysql

import (
	"context"
	"database/sql"
	"fmt"
	"io"
	"strconv"
	"strings"
	"time"

	_ "github.com/go-sql-driver/mysql"
)

// Terminal 终端接口，用于输入输出
type Terminal interface {
	io.Reader
	io.Writer
}

// Config MySQL 连接配置
type Config struct {
	Host              string
	Port              int
	Username          string
	Password          string
	Database          string
	Charset           string        // 字符集，默认 utf8mb4
	Collation         string        // 排序规则
	Timeout           time.Duration // 连接超时，默认 10s
	ReadTimeout       time.Duration // 读取超时，默认 30s
	WriteTimeout      time.Duration // 写入超时，默认 30s
	MaxOpenConns      int           // 最大连接数，默认 10
	MaxIdleConns      int           // 最大空闲连接数，默认 5
	ConnMaxLifetime   time.Duration // 连接最大生命周期，默认 1h
	ParseTime         bool          // 是否解析时间，默认 true
	Loc               string        // 时区，默认 Local
	AllowNativePasswd bool          // 允许原生密码，默认 true
	TLS               string        // TLS 配置：true/false/skip-verify/preferred
	CustomParams      string        // 自定义参数，如 "param1=value1&param2=value2"
}

// CLI MySQL 交互式命令行客户端
type CLI struct {
	term         Terminal
	config       *Config
	db           *sql.DB
	reader       *Reader
	serverInfo   ServerInfo
	verticalMode bool   // 是否垂直显示结果
	pagerMode    bool   // 是否启用分页
	maxRows      int    // 最大显示行数
	delimiter    string // SQL 分隔符
	inTransaction bool  // 是否在事务中
	database     string // 当前数据库
}

// ServerInfo MySQL 服务器信息
type ServerInfo struct {
	Version        string
	ProtocolVersion int
	ConnectionID   int
	Charset        string
	Uptime         int64
}

// NewCLI 创建新的 MySQL CLI 实例（兼容旧接口）
func NewCLI(term Terminal, host string, port int, username, password, database string) *CLI {
	config := &Config{
		Host:              host,
		Port:              port,
		Username:          username,
		Password:          password,
		Database:          database,
		Charset:           "utf8mb4",
		Timeout:           10 * time.Second,
		ReadTimeout:       30 * time.Second,
		WriteTimeout:      30 * time.Second,
		MaxOpenConns:      10,
		MaxIdleConns:      5,
		ConnMaxLifetime:   time.Hour,
		ParseTime:         true,
		Loc:               "Local",
		AllowNativePasswd: true,
	}
	return NewCLIWithConfig(term, config)
}

// NewCLIWithConfig 使用配置创建 MySQL CLI 实例
func NewCLIWithConfig(term Terminal, config *Config) *CLI {
	// 设置默认值
	if config.Charset == "" {
		config.Charset = "utf8mb4"
	}
	if config.Timeout == 0 {
		config.Timeout = 10 * time.Second
	}
	if config.ReadTimeout == 0 {
		config.ReadTimeout = 30 * time.Second
	}
	if config.WriteTimeout == 0 {
		config.WriteTimeout = 30 * time.Second
	}
	if config.MaxOpenConns == 0 {
		config.MaxOpenConns = 10
	}
	if config.MaxIdleConns == 0 {
		config.MaxIdleConns = 5
	}
	if config.ConnMaxLifetime == 0 {
		config.ConnMaxLifetime = time.Hour
	}
	if config.Loc == "" {
		config.Loc = "Local"
	}

	return &CLI{
		term:      term,
		config:    config,
		database:  config.Database,
		reader:    NewReader(term),
		maxRows:   1000,
		delimiter: ";",
	}
}

// Connect 连接到 MySQL 数据库
func (c *CLI) Connect() error {
	// 构建 DSN
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?timeout=%s&readTimeout=%s&writeTimeout=%s&parseTime=%t&loc=%s&charset=%s",
		c.config.Username,
		c.config.Password,
		c.config.Host,
		c.config.Port,
		c.config.Database,
		c.config.Timeout,
		c.config.ReadTimeout,
		c.config.WriteTimeout,
		c.config.ParseTime,
		c.config.Loc,
		c.config.Charset,
	)

	// 添加可选参数
	if c.config.Collation != "" {
		dsn += "&collation=" + c.config.Collation
	}
	if c.config.TLS != "" {
		dsn += "&tls=" + c.config.TLS
	}
	if c.config.AllowNativePasswd {
		dsn += "&allowNativePasswords=true"
	}
	if c.config.CustomParams != "" {
		dsn += "&" + c.config.CustomParams
	}

	var err error
	c.db, err = sql.Open("mysql", dsn)
	if err != nil {
		return err
	}

	// 设置连接池参数
	c.db.SetMaxOpenConns(c.config.MaxOpenConns)
	c.db.SetMaxIdleConns(c.config.MaxIdleConns)
	c.db.SetConnMaxLifetime(c.config.ConnMaxLifetime)

	if err := c.db.Ping(); err != nil {
		c.db.Close()
		return err
	}

	// 获取服务器信息
	c.fetchServerInfo()

	// 显示欢迎信息
	c.showWelcome()

	return nil
}

// fetchServerInfo 获取服务器信息
func (c *CLI) fetchServerInfo() {
	var version string
	c.db.QueryRow("SELECT VERSION()").Scan(&version)
	c.serverInfo.Version = version

	var connID int
	c.db.QueryRow("SELECT CONNECTION_ID()").Scan(&connID)
	c.serverInfo.ConnectionID = connID

	var charset string
	c.db.QueryRow("SELECT @@character_set_database").Scan(&charset)
	c.serverInfo.Charset = charset
}

// showWelcome 显示欢迎信息
func (c *CLI) showWelcome() {
	fmt.Fprintf(c.term, "Welcome to the MySQL monitor.  Commands end with ; or \\g.\n")
	fmt.Fprintf(c.term, "Your MySQL connection id is %d\n", c.serverInfo.ConnectionID)
	fmt.Fprintf(c.term, "Server version: %s\n", c.serverInfo.Version)
	fmt.Fprintf(c.term, "Connection: %s:%d via TCP/IP\n", c.config.Host, c.config.Port)
	fmt.Fprintf(c.term, "Charset: %s\n\n", c.config.Charset)
	fmt.Fprintf(c.term, "Type 'help;' or '\\h' for help. Type '\\c' to clear the current input statement.\n\n")
}

// Start 启动交互式命令行
func (c *CLI) Start() error {
	for {
		// 设置提示符
		prompt := c.getPrompt()
		c.reader.SetPrompt(prompt)
		
		// 支持多行 SQL（以分隔符结束）
		sqlStr := c.readMultiLine()
		if sqlStr == "" {
			continue
		}

		sqlStr = strings.TrimSpace(sqlStr)
		
		// 先检查是否是特殊命令（不需要分号）
		if c.handleSpecialCommand(sqlStr) {
			if strings.ToLower(sqlStr) == "exit" || strings.ToLower(sqlStr) == "quit" || 
			   sqlStr == "\\q" || sqlStr == "\\quit" {
				return nil
			}
			continue
		}

		// 执行 SQL
		c.executeSQL(sqlStr)
	}
}

// getPrompt 获取提示符
func (c *CLI) getPrompt() string {
	if c.inTransaction {
		if c.database != "" {
			return fmt.Sprintf("mysql [%s]*> ", c.database)
		}
		return "mysql *> "
	}
	if c.database != "" {
		return fmt.Sprintf("mysql [%s]> ", c.database)
	}
	return "mysql> "
}

// readMultiLine 读取多行 SQL（以分隔符结束）
func (c *CLI) readMultiLine() string {
	var lines []string
	lineNum := 0
	
	for {
		line, err := c.reader.ReadLine()
		if err != nil {
			if err == io.EOF {
				return ""
			}
			return ""
		}
		
		trimmed := strings.TrimSpace(line)
		
		// 空行继续等待输入
		if trimmed == "" && len(lines) == 0 {
			return ""
		}
		
		lines = append(lines, line)
		lineNum++
		
		// 第一行就检查是否是特殊命令（以反斜杠开头或常见命令），如果是则立即返回
		if lineNum == 1 {
			cmdLower := strings.ToLower(trimmed)
			// 反斜杠命令直接返回
			if strings.HasPrefix(trimmed, "\\") {
				break
			}
			// exit, quit, help 命令直接返回
			if cmdLower == "exit" || cmdLower == "quit" || cmdLower == "help" ||
			   cmdLower == "status" || cmdLower == "tables" || cmdLower == "databases" {
				break
			}
			// delimiter 命令直接返回
			if strings.HasPrefix(cmdLower, "delimiter ") {
				break
			}
		}
		
		// 检查是否以分隔符结束
		if strings.HasSuffix(trimmed, c.delimiter) {
			break
		}
		
		// 检查是否以 \g 或 \G 结束
		if strings.HasSuffix(trimmed, "\\g") || strings.HasSuffix(trimmed, "\\G") {
			break
		}
		
		// 设置多行提示符
		c.reader.SetPrompt("    -> ")
	}
	
	result := strings.Join(lines, "\n")
	return result
}

// executeSQL 执行 SQL 语句
func (c *CLI) executeSQL(sqlStr string) {
	startTime := time.Now()
	
	// 检查是否以 \G 结束（垂直显示）
	verticalMode := false
	if strings.HasSuffix(sqlStr, "\\G") {
		verticalMode = true
		sqlStr = strings.TrimSuffix(sqlStr, "\\G")
		sqlStr = strings.TrimSpace(sqlStr)
	} else if strings.HasSuffix(sqlStr, "\\g") {
		sqlStr = strings.TrimSuffix(sqlStr, "\\g")
		sqlStr = strings.TrimSpace(sqlStr)
	}
	
	// 移除末尾的分隔符
	sqlStr = strings.TrimSuffix(strings.TrimSpace(sqlStr), c.delimiter)
	sqlStr = strings.TrimSpace(sqlStr)
	
	if sqlStr == "" {
		return
	}
	
	// 检查是否是事务命令
	upperSQL := strings.ToUpper(sqlStr)
	if upperSQL == "BEGIN" || upperSQL == "START TRANSACTION" {
		c.inTransaction = true
		fmt.Fprintf(c.term, "Query OK, 0 rows affected (%.2f sec)\n\n", time.Since(startTime).Seconds())
		return
	}
	if upperSQL == "COMMIT" {
		c.inTransaction = false
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()
		_, err := c.db.ExecContext(ctx, "COMMIT")
		if err != nil {
			fmt.Fprintf(c.term, "ERROR: %v\n\n", err)
			return
		}
		fmt.Fprintf(c.term, "Query OK, 0 rows affected (%.2f sec)\n\n", time.Since(startTime).Seconds())
		return
	}
	if upperSQL == "ROLLBACK" {
		c.inTransaction = false
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()
		_, err := c.db.ExecContext(ctx, "ROLLBACK")
		if err != nil {
			fmt.Fprintf(c.term, "ERROR: %v\n\n", err)
			return
		}
		fmt.Fprintf(c.term, "Query OK, 0 rows affected (%.2f sec)\n\n", time.Since(startTime).Seconds())
		return
	}
	
	// 处理 USE database
	if strings.HasPrefix(upperSQL, "USE ") {
		c.handleUseDatabase(sqlStr)
		fmt.Fprintf(c.term, "Database changed (%.2f sec)\n\n", time.Since(startTime).Seconds())
		return
	}
	
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()
	
	if isQuery(sqlStr) {
		c.executeQuery(ctx, sqlStr, verticalMode, startTime)
	} else {
		c.executeCommand(ctx, sqlStr, startTime)
	}
}

// handleSpecialCommand 处理 MySQL 特殊命令
func (c *CLI) handleSpecialCommand(cmd string) bool {
	cmd = strings.TrimSpace(cmd)
	cmdLower := strings.ToLower(cmd)
	
	// Exit commands
	if cmd == "\\q" || cmd == "\\quit" || cmdLower == "exit" || cmdLower == "quit" {
		fmt.Fprintf(c.term, "Bye\n")
		return true
	}
	
	// Clear current command
	if cmd == "\\c" {
		fmt.Fprintf(c.term, "\n")
		return true
	}
	
	// Help
	if cmd == "\\h" || cmd == "\\?" || cmdLower == "help" || cmdLower == "help;" {
		c.showHelp()
		return true
	}
	
	// Status
	if cmd == "\\s" || cmdLower == "status" || cmdLower == "status;" {
		c.showStatus()
		return true
	}
	
	// Current database
	if cmd == "\\d" || cmd == "\\db" {
		c.showCurrentDatabase()
		return true
	}
	
	// Use database (shortcut)
	if strings.HasPrefix(cmd, "\\u ") || strings.HasPrefix(cmd, "\\use ") {
		dbName := strings.TrimSpace(cmd[strings.Index(cmd, " "):])
		c.handleUseDatabase("USE " + dbName)
		return true
	}
	
	// Change delimiter
	if strings.HasPrefix(cmdLower, "delimiter ") {
		newDelim := strings.TrimSpace(cmd[10:])
		if newDelim != "" {
			c.delimiter = newDelim
			fmt.Fprintf(c.term, "Delimiter changed to: %s\n\n", c.delimiter)
		}
		return true
	}
	
	// Toggle vertical mode
	if cmd == "\\G" {
		c.verticalMode = !c.verticalMode
		fmt.Fprintf(c.term, "Vertical mode: %v\n\n", c.verticalMode)
		return true
	}
	
	// Show tables
	if cmdLower == "tables" || cmdLower == "tables;" {
		c.executeSQL("SHOW TABLES")
		return true
	}
	
	// Show databases
	if cmdLower == "databases" || cmdLower == "databases;" {
		c.executeSQL("SHOW DATABASES")
		return true
	}
	
	return false
}

// handleUseDatabase 处理 USE database 命令
func (c *CLI) handleUseDatabase(sqlStr string) {
	parts := strings.Fields(sqlStr)
	if len(parts) < 2 {
		fmt.Fprintf(c.term, "ERROR: Database name required\n\n")
		return
	}
	
	dbName := strings.Trim(parts[1], ";`\"'")
	
	// 构建新的DSN（复用配置）
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?timeout=%s&readTimeout=%s&writeTimeout=%s&parseTime=%t&loc=%s&charset=%s",
		c.config.Username,
		c.config.Password,
		c.config.Host,
		c.config.Port,
		dbName,
		c.config.Timeout,
		c.config.ReadTimeout,
		c.config.WriteTimeout,
		c.config.ParseTime,
		c.config.Loc,
		c.config.Charset,
	)
	
	if c.config.CustomParams != "" {
		dsn += "&" + c.config.CustomParams
	}
	
	newDB, err := sql.Open("mysql", dsn)
	if err != nil {
		fmt.Fprintf(c.term, "ERROR: %v\n\n", err)
		return
	}
	
	if err := newDB.Ping(); err != nil {
		newDB.Close()
		fmt.Fprintf(c.term, "ERROR 1049 (42000): Unknown database '%s'\n\n", dbName)
		return
	}
	
	// 关闭旧连接，使用新连接
	if c.db != nil {
		c.db.Close()
	}
	c.db = newDB
	c.database = dbName
	c.config.Database = dbName
}

// showHelp 显示帮助信息
func (c *CLI) showHelp() {
	help := `
MySQL Client Commands:
----------------------
\\q, \\quit, exit, quit  Exit mysql
\\c                      Clear the current input statement
\\h, \\?, help           Display this help
\\s, status             Get status information from the server
\\d, \\db               Show current database
\\u, \\use <db>         Use another database
\\G                     Execute command and display results vertically

SQL Statements (end with ; or \\g):
-----------------------------------
USE <db>                Change database
SHOW DATABASES          List all databases
SHOW TABLES             List tables in current database
SHOW COLUMNS FROM <t>   Show columns of table
DESC <table>            Describe table structure
SELECT ...              Query data
INSERT ...              Insert data
UPDATE ...              Update data
DELETE ...              Delete data
CREATE ...              Create database/table
DROP ...                Drop database/table
ALTER ...               Alter table structure

Transaction Commands:
---------------------
BEGIN / START TRANSACTION   Start a transaction
COMMIT                      Commit current transaction
ROLLBACK                    Rollback current transaction

Special Features:
-----------------
- Multi-line SQL supported (end with ;)
- Use \\G at end to display results vertically
- DELIMITER command to change statement delimiter

`
	fmt.Fprintf(c.term, help)
}

// showStatus 显示服务器状态
func (c *CLI) showStatus() {
	fmt.Fprintf(c.term, "--------------\n")
	fmt.Fprintf(c.term, "mysql  Ver %s\n\n", c.serverInfo.Version)
	fmt.Fprintf(c.term, "Connection id:          %d\n", c.serverInfo.ConnectionID)
	fmt.Fprintf(c.term, "Current database:       %s\n", c.database)
	if c.database == "" {
		fmt.Fprintf(c.term, "Current database:       (none)\n")
	} else {
		fmt.Fprintf(c.term, "Current database:       %s\n", c.database)
	}
	fmt.Fprintf(c.term, "Current user:           %s@%s\n", c.config.Username, c.config.Host)
	fmt.Fprintf(c.term, "Connection:             %s via TCP/IP\n", c.config.Host)
	fmt.Fprintf(c.term, "Server characterset:    %s\n", c.serverInfo.Charset)
	fmt.Fprintf(c.term, "Db characterset:        %s\n", c.serverInfo.Charset)
	fmt.Fprintf(c.term, "TCP port:               %d\n", c.config.Port)
	
	// 获取 uptime
	var uptime int64
	c.db.QueryRow("SHOW STATUS LIKE 'Uptime'").Scan(nil, &uptime)
	fmt.Fprintf(c.term, "Uptime:                 %d sec\n", uptime)
	
	// 获取线程数
	var threads int
	c.db.QueryRow("SHOW STATUS LIKE 'Threads_connected'").Scan(nil, &threads)
	fmt.Fprintf(c.term, "Threads:                %d\n", threads)
	
	fmt.Fprintf(c.term, "--------------\n\n")
}

// showCurrentDatabase 显示当前数据库
func (c *CLI) showCurrentDatabase() {
	if c.database == "" {
		fmt.Fprintf(c.term, "No database selected\n\n")
	} else {
		fmt.Fprintf(c.term, "Current database: %s\n\n", c.database)
	}
}

// Close 关闭数据库连接
func (c *CLI) Close() error {
	if c.db != nil {
		return c.db.Close()
	}
	return nil
}

// executeQuery 执行查询语句
func (c *CLI) executeQuery(ctx context.Context, sqlStr string, verticalMode bool, startTime time.Time) {
	rows, err := c.db.QueryContext(ctx, sqlStr)
	if err != nil {
		c.printError(err)
		return
	}
	defer rows.Close()

	cols, _ := rows.Columns()
	colTypes, _ := rows.ColumnTypes()
	
	if verticalMode || c.verticalMode {
		c.displayVertical(rows, cols)
	} else {
		c.displayTable(rows, cols, colTypes, startTime)
	}
}

// displayTable 以表格形式显示结果
func (c *CLI) displayTable(rows *sql.Rows, cols []string, colTypes []*sql.ColumnType, startTime time.Time) {
	// 计算每列的最大宽度
	colWidths := make([]int, len(cols))
	for i, col := range cols {
		colWidths[i] = len(col)
		if colWidths[i] < 4 {
			colWidths[i] = 4 // 最小宽度
		}
		if colWidths[i] > 50 {
			colWidths[i] = 50 // 最大宽度
		}
	}
	
	// 收集所有行数据
	var allRows [][]string
	for rows.Next() {
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		rows.Scan(valPtrs...)
		
		rowStrs := make([]string, len(vals))
		for i, v := range vals {
			if v == nil {
				rowStrs[i] = "NULL"
			} else {
				switch val := v.(type) {
				case []byte:
					rowStrs[i] = string(val)
				case time.Time:
					rowStrs[i] = val.Format("2006-01-02 15:04:05")
				default:
					rowStrs[i] = fmt.Sprintf("%v", v)
				}
			}
			
			// 更新列宽
			if len(rowStrs[i]) > colWidths[i] {
				if len(rowStrs[i]) > 50 {
					colWidths[i] = 50
					rowStrs[i] = rowStrs[i][:47] + "..."
				} else {
					colWidths[i] = len(rowStrs[i])
				}
			}
		}
		allRows = append(allRows, rowStrs)
		
		// 限制最大行数
		if len(allRows) >= c.maxRows {
			break
		}
	}
	
	// 打印表头分隔线
	c.printSeparator(colWidths)
	
	// 打印表头
	fmt.Fprintf(c.term, "| ")
	for i, col := range cols {
		fmt.Fprintf(c.term, "%-*s | ", colWidths[i], col)
	}
	fmt.Fprintf(c.term, "\n")
	
	// 打印表头分隔线
	c.printSeparator(colWidths)
	
	// 打印数据行
	for _, row := range allRows {
		fmt.Fprintf(c.term, "| ")
		for i, val := range row {
			fmt.Fprintf(c.term, "%-*s | ", colWidths[i], val)
		}
		fmt.Fprintf(c.term, "\n")
	}
	
	// 打印底部分隔线
	c.printSeparator(colWidths)
	
	// 打印统计信息
	rowCount := len(allRows)
	elapsed := time.Since(startTime).Seconds()
	
	if rowCount == 0 {
		fmt.Fprintf(c.term, "Empty set (%.2f sec)\n\n", elapsed)
	} else if rowCount == 1 {
		fmt.Fprintf(c.term, "1 row in set (%.2f sec)\n\n", elapsed)
	} else {
		fmt.Fprintf(c.term, "%d rows in set (%.2f sec)\n\n", rowCount, elapsed)
	}
}

// printSeparator 打印表格分隔线
func (c *CLI) printSeparator(colWidths []int) {
	fmt.Fprintf(c.term, "+")
	for _, width := range colWidths {
		fmt.Fprintf(c.term, "%s+", strings.Repeat("-", width+2))
	}
	fmt.Fprintf(c.term, "\n")
}

// displayVertical 以垂直形式显示结果
func (c *CLI) displayVertical(rows *sql.Rows, cols []string) {
	rowNum := 0
	for rows.Next() {
		rowNum++
		vals := make([]interface{}, len(cols))
		valPtrs := make([]interface{}, len(cols))
		for i := range vals {
			valPtrs[i] = &vals[i]
		}
		rows.Scan(valPtrs...)
		
		fmt.Fprintf(c.term, "*************************** %d. row ***************************\n", rowNum)
		
		// 找出最长的列名
		maxColLen := 0
		for _, col := range cols {
			if len(col) > maxColLen {
				maxColLen = len(col)
			}
		}
		
		for i, col := range cols {
			var valStr string
			if vals[i] == nil {
				valStr = "NULL"
			} else {
				switch val := vals[i].(type) {
				case []byte:
					valStr = string(val)
				case time.Time:
					valStr = val.Format("2006-01-02 15:04:05")
				default:
					valStr = fmt.Sprintf("%v", val)
				}
			}
			fmt.Fprintf(c.term, "%*s: %s\n", maxColLen, col, valStr)
		}
		
		if rowNum >= c.maxRows {
			break
		}
	}
	
	if rowNum == 0 {
		fmt.Fprintf(c.term, "Empty set\n\n")
	} else if rowNum == 1 {
		fmt.Fprintf(c.term, "1 row in set\n\n")
	} else {
		fmt.Fprintf(c.term, "%d rows in set\n\n", rowNum)
	}
}

// executeCommand 执行非查询语句
func (c *CLI) executeCommand(ctx context.Context, sqlStr string, startTime time.Time) {
	result, err := c.db.ExecContext(ctx, sqlStr)
	if err != nil {
		c.printError(err)
		return
	}
	
	affected, _ := result.RowsAffected()
	lastInsertID, _ := result.LastInsertId()
	elapsed := time.Since(startTime).Seconds()
	
	if lastInsertID > 0 {
		fmt.Fprintf(c.term, "Query OK, %d row affected (%.2f sec)\n", affected, elapsed)
		fmt.Fprintf(c.term, "Last Insert ID: %d\n\n", lastInsertID)
	} else {
		if affected == 0 {
			fmt.Fprintf(c.term, "Query OK, 0 rows affected (%.2f sec)\n\n", elapsed)
		} else if affected == 1 {
			fmt.Fprintf(c.term, "Query OK, 1 row affected (%.2f sec)\n\n", elapsed)
		} else {
			fmt.Fprintf(c.term, "Query OK, %d rows affected (%.2f sec)\n\n", affected, elapsed)
		}
	}
}

// printError 打印错误信息
func (c *CLI) printError(err error) {
	errMsg := err.Error()
	
	// 尝试解析 MySQL 错误代码
	if strings.Contains(errMsg, "Error ") {
		fmt.Fprintf(c.term, "ERROR: %s\n\n", errMsg)
	} else {
		fmt.Fprintf(c.term, "ERROR: %s\n\n", errMsg)
	}
}

// isQuery 判断是否是查询语句
func isQuery(sqlStr string) bool {
	upper := strings.ToUpper(strings.TrimSpace(sqlStr))
	
	queryPrefixes := []string{
		"SELECT", "SHOW", "DESC", "DESCRIBE", "EXPLAIN",
		"WITH", "TABLE", "VALUES",
	}
	
	for _, prefix := range queryPrefixes {
		if strings.HasPrefix(upper, prefix) {
			return true
		}
	}
	
	return false
}

// ParseInt 安全地解析整数
func parseInt(s string) int {
	i, _ := strconv.Atoi(s)
	return i
}