🐛 fix(update-windows): 修复自动更新脚本变量转义导致TARGET语法错误

- 将 buildWindowsScript 改为模板占位符替换，避免 fmt.Sprintf 吞掉批处理百分号
- 修正 for %%I/%%F 语法，消除“此时不应有 TARGET~nxI”报错
- 保留原有更新重试与日志流程，不改变下载与安装主链路
- refs #112

.github/workflows/release.yml

@@ -19,23 +19,59 @@ jobs:
         include:
           - os: macos-latest
             platform: darwin/amd64
-            artifact_name: GoNavi-mac-amd64
-            asset_ext: .dmg
+            os_name: MacOS
+            arch_name: Amd64
+            build_name: gonavi-build-darwin-amd64
+            wails_tags: ""
+            artifact_suffix: ""
+            build_optional_agents: true
+            linux_webkit: ""
           - os: macos-latest
             platform: darwin/arm64
-            artifact_name: GoNavi-mac-arm64
-            asset_ext: .dmg
+            os_name: MacOS
+            arch_name: Arm64
+            build_name: gonavi-build-darwin-arm64
+            wails_tags: ""
+            artifact_suffix: ""
+            build_optional_agents: true
+            linux_webkit: ""
           - os: windows-latest
             platform: windows/amd64
-            artifact_name: GoNavi-windows-amd64
-            asset_ext: .exe
+            os_name: Windows
+            arch_name: Amd64
+            build_name: gonavi-build-windows-amd64
+            wails_tags: ""
+            artifact_suffix: ""
+            build_optional_agents: true
+            linux_webkit: ""
           - os: windows-latest
             platform: windows/arm64
-            artifact_name: GoNavi-windows-arm64
-            asset_ext: .exe
+            os_name: Windows
+            arch_name: Arm64
+            build_name: gonavi-build-windows-arm64
+            wails_tags: ""
+            artifact_suffix: ""
+            build_optional_agents: true
+            linux_webkit: ""
           - os: ubuntu-22.04
             platform: linux/amd64
-            artifact_name: GoNavi-linux-amd64
+            os_name: Linux
+            arch_name: Amd64
+            build_name: gonavi-build-linux-amd64
+            wails_tags: ""
+            artifact_suffix: ""
+            build_optional_agents: true
+            linux_webkit: "4.0"
+          # Debian 13 (trixie) 默认仓库已切到 WebKitGTK 4.1：单独提供 4.1 变体产物
+          - os: ubuntu-24.04
+            platform: linux/amd64
+            os_name: Linux
+            arch_name: Amd64
+            build_name: gonavi-build-linux-amd64-webkit41
+            wails_tags: "webkit2_41"
+            artifact_suffix: "-WebKit41"
+            build_optional_agents: false
+            linux_webkit: "4.1"
 
     steps:
       - name: Checkout code
@@ -57,7 +93,17 @@ jobs:
         if: contains(matrix.platform, 'linux')
         run: |
           sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libfuse2
+          sudo apt-get install -y libgtk-3-dev
+
+          # WebKitGTK 4.1 需要 libsoup3；4.0 使用 libsoup2（通常由 webkit2gtk dev 包拉起）
+          if [ "${{ matrix.linux_webkit }}" = "4.1" ]; then
+            sudo apt-get install -y libwebkit2gtk-4.1-dev libsoup-3.0-dev
+          else
+            sudo apt-get install -y libwebkit2gtk-4.0-dev
+          fi
+
+          # AppImage 运行/打包可能需要 FUSE2。不同发行版/版本包名不同，做兼容兜底。
+          sudo apt-get install -y libfuse2 || sudo apt-get install -y libfuse2t64 || true
 
           # Download linuxdeploy tools for AppImage packaging
           LINUXDEPLOY_URL="https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
@@ -88,13 +134,65 @@ jobs:
       - name: Build
         shell: bash
         run: |
-          wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.artifact_name }} -ldflags "-X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"
+          set -euo pipefail
+          TAG_ARGS=()
+          if [ -n "${{ matrix.wails_tags }}" ]; then
+            TAG_ARGS+=(-tags "${{ matrix.wails_tags }}")
+          fi
+          wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.build_name }} "${TAG_ARGS[@]}" -ldflags "-s -w -X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"
+
+      - name: Build Optional Driver Agents
+        if: ${{ matrix.build_optional_agents }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          TARGET_PLATFORM="${{ matrix.platform }}"
+          GOOS="${TARGET_PLATFORM%%/*}"
+          GOARCH="${TARGET_PLATFORM##*/}"
+          DRIVERS=(mariadb diros sphinx sqlserver sqlite duckdb dameng kingbase highgo vastbase mongodb tdengine)
+          OUTDIR="drivers/${{ matrix.os_name }}"
+          mkdir -p "$OUTDIR"
+
+          for DRIVER in "${DRIVERS[@]}"; do
+            TAG="gonavi_${DRIVER}_driver"
+            OUTPUT="${DRIVER}-driver-agent-${GOOS}-${GOARCH}"
+            if [ "$GOOS" = "windows" ]; then
+              OUTPUT="${OUTPUT}.exe"
+            fi
+            OUTPUT_PATH="${OUTDIR}/${OUTPUT}"
+            echo "🔧 构建 ${OUTPUT_PATH} (tag=${TAG})"
+            if [ "$DRIVER" = "duckdb" ]; then
+              set +e
+              CGO_ENABLED=1 GOOS="$GOOS" GOARCH="$GOARCH" go build \
+                -tags "${TAG}" \
+                -trimpath \
+                -ldflags "-s -w" \
+                -o "${OUTPUT_PATH}" \
+                ./cmd/optional-driver-agent
+              DUCKDB_RC=$?
+              set -e
+              if [ "${DUCKDB_RC}" -ne 0 ]; then
+                echo "⚠️ DuckDB 代理构建失败（平台 ${GOOS}/${GOARCH}），跳过该资产，不阻断发布"
+                rm -f "${OUTPUT_PATH}"
+                continue
+              fi
+            else
+              CGO_ENABLED=0 GOOS="$GOOS" GOARCH="$GOARCH" go build \
+                -tags "${TAG}" \
+                -trimpath \
+                -ldflags "-s -w" \
+                -o "${OUTPUT_PATH}" \
+                ./cmd/optional-driver-agent
+            fi
+          done
 
       # macOS Packaging
       - name: Package macOS DMG
         if: contains(matrix.platform, 'darwin')
         run: |
           brew install create-dmg
+          VERSION="${{ github.ref_name }}"
+          VERSION="${VERSION#v}"
           cd build/bin
           
           APP_PATH=$(find . -maxdepth 1 -name "*.app" | head -n 1)
@@ -107,7 +205,8 @@ jobs:
           echo "🔏 正在进行 Ad-hoc 签名..."
           codesign --force --options runtime --deep --sign - "$APP_NAME"
           
-          DMG_NAME="${{ matrix.artifact_name }}.dmg"
+          DMG_NAME="${{ matrix.build_name }}.dmg"
+          FINAL_NAME="GoNavi-$VERSION-${{ matrix.os_name }}-${{ matrix.arch_name }}${{ matrix.artifact_suffix }}.dmg"
           echo "📦 正在生成 DMG: $DMG_NAME..."
           
           create-dmg \
@@ -121,35 +220,48 @@ jobs:
             "$DMG_NAME" \
             "$APP_NAME"
             
-          mv "$DMG_NAME" ../../
+          mv "$DMG_NAME" "../../$FINAL_NAME"
 
       # Windows Packaging
-      - name: Prepare Windows Exe
+      - name: Package Windows Portable Zip
         if: contains(matrix.platform, 'windows')
-        shell: bash
+        shell: pwsh
         run: |
-          cd build/bin
-          TARGET="${{ matrix.artifact_name }}"
-          
-          if [ -f "$TARGET.exe" ]; then
-              FINAL_EXE="$TARGET.exe"
-          elif [ -f "$TARGET" ]; then
-              mv "$TARGET" "$TARGET.exe"
-              FINAL_EXE="$TARGET.exe"
-          else
-              echo "❌ 未找到构建产物 '$TARGET'!"
+          Set-Location build/bin
+          $version = "${{ github.ref_name }}"
+          if ($version.StartsWith("v")) {
+              $version = $version.Substring(1)
+          }
+          $target = "${{ matrix.build_name }}"
+          $finalExeName = "GoNavi-$version-${{ matrix.os_name }}-${{ matrix.arch_name }}${{ matrix.artifact_suffix }}.exe"
+          $finalZipName = "GoNavi-$version-${{ matrix.os_name }}-${{ matrix.arch_name }}${{ matrix.artifact_suffix }}.zip"
+
+          if (Test-Path "$target.exe") {
+              $finalExe = "$target.exe"
+          } elseif (Test-Path "$target") {
+              Rename-Item -Path "$target" -NewName "$target.exe"
+              $finalExe = "$target.exe"
+          } else {
+              Write-Error "❌ 未找到构建产物 '$target'!"
               exit 1
-          fi
-          
-          echo "📦 正在移动 $FINAL_EXE 到根目录..."
-          mv "$FINAL_EXE" "../../$FINAL_EXE"
+          }
+
+          Write-Host "📦 生成 Windows 可执行文件 $finalExeName..."
+          Copy-Item -LiteralPath $finalExe -Destination "..\\..\\$finalExeName" -Force
+
+          Write-Host "📦 生成 Windows 压缩包 $finalZipName..."
+          Compress-Archive -LiteralPath $finalExe -DestinationPath "..\\..\\$finalZipName" -Force
 
       # Linux Packaging (tar.gz and AppImage)
       - name: Package Linux
         if: contains(matrix.platform, 'linux')
         run: |
+          VERSION="${{ github.ref_name }}"
+          VERSION="${VERSION#v}"
           cd build/bin
-          TARGET="${{ matrix.artifact_name }}"
+          TARGET="${{ matrix.build_name }}"
+          TAR_NAME="GoNavi-$VERSION-${{ matrix.os_name }}-${{ matrix.arch_name }}${{ matrix.artifact_suffix }}.tar.gz"
+          APPIMAGE_NAME="GoNavi-$VERSION-${{ matrix.os_name }}-${{ matrix.arch_name }}${{ matrix.artifact_suffix }}.AppImage"
 
           if [ ! -f "$TARGET" ]; then
               echo "❌ 未找到构建产物 '$TARGET'!"
@@ -159,9 +271,9 @@ jobs:
           chmod +x "$TARGET"
 
           # 1. Create tar.gz
-          echo "📦 正在打包 $TARGET.tar.gz..."
-          tar -czvf "$TARGET.tar.gz" "$TARGET"
-          mv "$TARGET.tar.gz" ../../
+          echo "📦 正在打包 $TAR_NAME..."
+          tar -czvf "$TAR_NAME" "$TARGET"
+          mv "$TAR_NAME" ../../
 
           # 2. Create AppImage (skip for ARM64 or if tools unavailable)
           if [ -f /tmp/skip-appimage ]; then
@@ -211,13 +323,13 @@ jobs:
           }
 
           # Rename output
-          mv GoNavi*.AppImage "$TARGET.AppImage" 2>/dev/null || {
+          mv GoNavi*.AppImage "$APPIMAGE_NAME" 2>/dev/null || {
               echo "⚠️ AppImage 重命名失败"
               exit 0
           }
 
-          if [ -f "$TARGET.AppImage" ]; then
-              mv "$TARGET.AppImage" ../../
+          if [ -f "$APPIMAGE_NAME" ]; then
+              mv "$APPIMAGE_NAME" ../../
               echo "✅ AppImage 生成成功"
           fi
 
@@ -229,8 +341,10 @@ jobs:
           path: |
             GoNavi-*.dmg
             GoNavi-*.exe
+            GoNavi-*.zip
             GoNavi-*.tar.gz
             GoNavi-*.AppImage
+            drivers/**
           retention-days: 1
 
   # Phase 2: Collect all artifacts and Publish Release (Single Job)
@@ -249,10 +363,75 @@ jobs:
       - name: List Assets
         run: ls -R release-assets
 
+      - name: Package Driver Agents Bundle
+        shell: bash
+        run: |
+          set -euo pipefail
+          cd release-assets
+          if [ ! -d drivers ]; then
+            echo "⚠️ 未找到 drivers 目录，跳过驱动总包打包"
+            exit 0
+          fi
+          if [ -z "$(find drivers -type f 2>/dev/null | head -n 1)" ]; then
+            echo "⚠️ drivers 目录为空，跳过驱动总包打包"
+            rm -rf drivers
+            exit 0
+          fi
+
+          echo "📦 打包驱动总包：GoNavi-DriverAgents.zip"
+          python3 - <<'PY'
+          import json
+          import os
+          import zipfile
+          from pathlib import Path
+
+          out_name = "GoNavi-DriverAgents.zip"
+          index_name = "GoNavi-DriverAgents-Index.json"
+          base = Path("drivers")
+          out_path = Path(out_name)
+          index_path = Path(index_name)
+          if out_path.exists():
+              out_path.unlink()
+          if index_path.exists():
+              index_path.unlink()
+
+          size_index = {}
+          with zipfile.ZipFile(out_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+              for p in base.rglob("*"):
+                  if not p.is_file():
+                      continue
+                  arcname = p.relative_to(base).as_posix()
+                  zf.write(p, arcname)
+                  size_index[p.name] = p.stat().st_size
+
+          index_path.write_text(
+              json.dumps({"assets": size_index}, ensure_ascii=False, indent=2),
+              encoding="utf-8",
+          )
+
+          print(f"created {out_name} size={out_path.stat().st_size} bytes")
+          print(f"created {index_name} entries={len(size_index)}")
+          PY
+
+          # Release 只发布一个驱动总包，避免大量平铺资产污染 Release 页面
+          rm -rf drivers
+
       - name: Generate SHA256SUMS
+        shell: bash
         run: |
           cd release-assets
-          sha256sum * > SHA256SUMS
+          FILES=()
+          while IFS= read -r file; do
+            if [ -n "$file" ]; then
+              FILES+=("$file")
+            fi
+          done < <(find . -maxdepth 1 -type f ! -name SHA256SUMS -exec basename {} \; | sort)
+          if [ ${#FILES[@]} -eq 0 ]; then
+            echo "⚠️ 未找到可签名资产，生成空 SHA256SUMS"
+            : > SHA256SUMS
+          else
+            sha256sum "${FILES[@]}" > SHA256SUMS
+          fi
 
       - name: Create Release
         uses: softprops/action-gh-release@v2

README.md

@@ -37,6 +37,7 @@
 - **Oracle**：基础数据访问与编辑支持。
 - **Dameng（达梦）**：基础数据访问与编辑支持。
 - **Kingbase（人大金仓）**：基础数据访问与编辑支持。
+- **TDengine**：时序数据库连接、库表浏览与 SQL 查询支持。
 - **Redis**：Key/Value 浏览、命令执行、视图与编码切换。
 - **自定义驱动**：支持配置 Driver/DSN 接入更多数据源。
 - **SSH 隧道**：内置 SSH 隧道支持，安全连接内网数据库。
@@ -128,6 +129,7 @@ wails build -clean
 支持构建：
 *   macOS (AMD64 / ARM64)
 *   Windows (AMD64)
+*   Linux (AMD64，提供 WebKitGTK 4.0 与 4.1 变体产物)
 
 ---
 
@@ -145,6 +147,27 @@ wails build -clean
     ```
 4.  或者：在 Finder 中右键点击应用图标，按住 `Control` 键选择 **打开**，然后在弹出的窗口中再次点击 **打开**。
 
+### Linux 启动报错缺少 `libwebkit2gtk` / `libjavascriptcoregtk`
+
+GoNavi 的 Linux 二进制依赖系统 WebKitGTK 运行库。不同发行版默认版本不同：
+
+- Debian 13 / Ubuntu 24.04 及更新版本：通常为 WebKitGTK 4.1
+- Ubuntu 22.04 / Debian 12 等：通常为 WebKitGTK 4.0
+
+如果启动时报错（如 `libwebkit2gtk-4.0.so.37: cannot open shared object file`），请按系统安装对应依赖后重试：
+
+```bash
+# Debian 13 / Ubuntu 24.04+
+sudo apt-get update
+sudo apt-get install -y libgtk-3-0 libwebkit2gtk-4.1-0 libjavascriptcoregtk-4.1-0
+
+# Ubuntu 22.04 / Debian 12
+sudo apt-get update
+sudo apt-get install -y libgtk-3-0 libwebkit2gtk-4.0-37 libjavascriptcoregtk-4.0-18
+```
+
+如果你使用的是 Release 中带 `-WebKit41` 后缀的 Linux 产物，请优先在 Debian 13 / Ubuntu 24.04+ 上使用；普通 Linux 产物更适合 WebKitGTK 4.0 运行环境。
+
 ---
 
 ## 🤝 贡献指南

build-release.sh

@@ -12,7 +12,7 @@ if [ -z "$VERSION" ]; then
     VERSION="0.0.0"
 fi
 echo "ℹ️  检测到版本号: $VERSION"
-LDFLAGS="-X GoNavi-Wails/internal/app.AppVersion=$VERSION"
+LDFLAGS="-s -w -X GoNavi-Wails/internal/app.AppVersion=$VERSION"
 
 # 颜色配置
 GREEN='\033[0;32m'

build/darwin/Info.dev.plist

@@ -0,0 +1,68 @@
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+    <dict>
+        <key>CFBundlePackageType</key>
+        <string>APPL</string>
+        <key>CFBundleName</key>
+        <string>{{.Info.ProductName}}</string>
+        <key>CFBundleExecutable</key>
+        <string>{{.OutputFilename}}</string>
+        <key>CFBundleIdentifier</key>
+        <string>com.wails.{{.Name}}.dev</string>
+        <key>CFBundleVersion</key>
+        <string>{{.Info.ProductVersion}}</string>
+        <key>CFBundleGetInfoString</key>
+        <string>{{.Info.Comments}}</string>
+        <key>CFBundleShortVersionString</key>
+        <string>{{.Info.ProductVersion}}</string>
+        <key>CFBundleIconFile</key>
+        <string>iconfile</string>
+        <key>LSMinimumSystemVersion</key>
+        <string>10.13.0</string>
+        <key>NSHighResolutionCapable</key>
+        <string>true</string>
+        <key>NSHumanReadableCopyright</key>
+        <string>{{.Info.Copyright}}</string>
+        {{if .Info.FileAssociations}}
+        <key>CFBundleDocumentTypes</key>
+        <array>
+          {{range .Info.FileAssociations}}
+          <dict>
+            <key>CFBundleTypeExtensions</key>
+            <array>
+              <string>{{.Ext}}</string>
+            </array>
+            <key>CFBundleTypeName</key>
+            <string>{{.Name}}</string>
+            <key>CFBundleTypeRole</key>
+            <string>{{.Role}}</string>
+            <key>CFBundleTypeIconFile</key>
+            <string>{{.IconName}}</string>
+          </dict>
+          {{end}}
+        </array>
+        {{end}}
+        {{if .Info.Protocols}}
+        <key>CFBundleURLTypes</key>
+        <array>
+          {{range .Info.Protocols}}
+            <dict>
+                <key>CFBundleURLName</key>
+                <string>com.wails.{{.Scheme}}</string>
+                <key>CFBundleURLSchemes</key>
+                <array>
+                    <string>{{.Scheme}}</string>
+                </array>
+                <key>CFBundleTypeRole</key>
+                <string>{{.Role}}</string>
+            </dict>
+          {{end}}
+        </array>
+        {{end}}
+        <key>NSAppTransportSecurity</key>
+        <dict>
+            <key>NSAllowsLocalNetworking</key>
+            <true/>
+        </dict>
+    </dict>
+</plist>

build/darwin/Info.plist

@@ -0,0 +1,63 @@
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+    <dict>
+        <key>CFBundlePackageType</key>
+        <string>APPL</string>
+        <key>CFBundleName</key>
+        <string>{{.Info.ProductName}}</string>
+        <key>CFBundleExecutable</key>
+        <string>{{.OutputFilename}}</string>
+        <key>CFBundleIdentifier</key>
+        <string>com.wails.{{.Name}}</string>
+        <key>CFBundleVersion</key>
+        <string>{{.Info.ProductVersion}}</string>
+        <key>CFBundleGetInfoString</key>
+        <string>{{.Info.Comments}}</string>
+        <key>CFBundleShortVersionString</key>
+        <string>{{.Info.ProductVersion}}</string>
+        <key>CFBundleIconFile</key>
+        <string>iconfile</string>
+        <key>LSMinimumSystemVersion</key>
+        <string>10.13.0</string>
+        <key>NSHighResolutionCapable</key>
+        <string>true</string>
+        <key>NSHumanReadableCopyright</key>
+        <string>{{.Info.Copyright}}</string>
+        {{if .Info.FileAssociations}}
+        <key>CFBundleDocumentTypes</key>
+        <array>
+          {{range .Info.FileAssociations}}
+          <dict>
+            <key>CFBundleTypeExtensions</key>
+            <array>
+              <string>{{.Ext}}</string>
+            </array>
+            <key>CFBundleTypeName</key>
+            <string>{{.Name}}</string>
+            <key>CFBundleTypeRole</key>
+            <string>{{.Role}}</string>
+            <key>CFBundleTypeIconFile</key>
+            <string>{{.IconName}}</string>
+          </dict>
+          {{end}}
+        </array>
+        {{end}}
+        {{if .Info.Protocols}}
+        <key>CFBundleURLTypes</key>
+        <array>
+          {{range .Info.Protocols}}
+            <dict>
+                <key>CFBundleURLName</key>
+                <string>com.wails.{{.Scheme}}</string>
+                <key>CFBundleURLSchemes</key>
+                <array>
+                    <string>{{.Scheme}}</string>
+                </array>
+                <key>CFBundleTypeRole</key>
+                <string>{{.Role}}</string>
+            </dict>
+          {{end}}
+        </array>
+        {{end}}
+    </dict>
+</plist>

cmd/mysql-driver-agent/main.go

@@ -0,0 +1,227 @@
+//go:build gonavi_mysql_driver
+
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/db"
+)
+
+type mysqlAgentRequest struct {
+	ID        int64                        `json:"id"`
+	Method    string                       `json:"method"`
+	Config    *connection.ConnectionConfig `json:"config,omitempty"`
+	Query     string                       `json:"query,omitempty"`
+	DBName    string                       `json:"dbName,omitempty"`
+	TableName string                       `json:"tableName,omitempty"`
+	Changes   *connection.ChangeSet        `json:"changes,omitempty"`
+}
+
+type mysqlAgentResponse struct {
+	ID           int64       `json:"id"`
+	Success      bool        `json:"success"`
+	Error        string      `json:"error,omitempty"`
+	Data         interface{} `json:"data,omitempty"`
+	Fields       []string    `json:"fields,omitempty"`
+	RowsAffected int64       `json:"rowsAffected,omitempty"`
+}
+
+const (
+	mysqlAgentMethodConnect       = "connect"
+	mysqlAgentMethodClose         = "close"
+	mysqlAgentMethodPing          = "ping"
+	mysqlAgentMethodQuery         = "query"
+	mysqlAgentMethodExec          = "exec"
+	mysqlAgentMethodGetDatabases  = "getDatabases"
+	mysqlAgentMethodGetTables     = "getTables"
+	mysqlAgentMethodGetCreateStmt = "getCreateStatement"
+	mysqlAgentMethodGetColumns    = "getColumns"
+	mysqlAgentMethodGetAllColumns = "getAllColumns"
+	mysqlAgentMethodGetIndexes    = "getIndexes"
+	mysqlAgentMethodGetForeignKey = "getForeignKeys"
+	mysqlAgentMethodGetTriggers   = "getTriggers"
+	mysqlAgentMethodApplyChanges  = "applyChanges"
+)
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Buffer(make([]byte, 0, 16<<10), 8<<20)
+	writer := bufio.NewWriter(os.Stdout)
+	defer writer.Flush()
+
+	var inst *db.MySQLDB
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+
+		var req mysqlAgentRequest
+		if err := json.Unmarshal([]byte(line), &req); err != nil {
+			_ = writeResponse(writer, mysqlAgentResponse{
+				ID:      req.ID,
+				Success: false,
+				Error:   fmt.Sprintf("解析请求失败：%v", err),
+			})
+			continue
+		}
+
+		resp := handleRequest(&inst, req)
+		if err := writeResponse(writer, resp); err != nil {
+			fmt.Fprintf(os.Stderr, "写入响应失败：%v\n", err)
+			break
+		}
+	}
+
+	if inst != nil {
+		_ = inst.Close()
+	}
+
+	if err := scanner.Err(); err != nil {
+		fmt.Fprintf(os.Stderr, "读取请求失败：%v\n", err)
+	}
+}
+
+func handleRequest(inst **db.MySQLDB, req mysqlAgentRequest) mysqlAgentResponse {
+	resp := mysqlAgentResponse{
+		ID:      req.ID,
+		Success: true,
+	}
+
+	switch strings.TrimSpace(req.Method) {
+	case mysqlAgentMethodConnect:
+		if req.Config == nil {
+			return fail(resp, "连接配置为空")
+		}
+		if *inst != nil {
+			_ = (*inst).Close()
+		}
+		next := &db.MySQLDB{}
+		if err := next.Connect(*req.Config); err != nil {
+			return fail(resp, err.Error())
+		}
+		*inst = next
+		return resp
+	case mysqlAgentMethodClose:
+		if *inst != nil {
+			if err := (*inst).Close(); err != nil {
+				return fail(resp, err.Error())
+			}
+			*inst = nil
+		}
+		return resp
+	}
+
+	if *inst == nil {
+		return fail(resp, "connection not open")
+	}
+
+	switch strings.TrimSpace(req.Method) {
+	case mysqlAgentMethodPing:
+		if err := (*inst).Ping(); err != nil {
+			return fail(resp, err.Error())
+		}
+	case mysqlAgentMethodQuery:
+		data, fields, err := (*inst).Query(req.Query)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+		resp.Fields = fields
+	case mysqlAgentMethodExec:
+		affected, err := (*inst).Exec(req.Query)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.RowsAffected = affected
+	case mysqlAgentMethodGetDatabases:
+		data, err := (*inst).GetDatabases()
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodGetTables:
+		data, err := (*inst).GetTables(req.DBName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodGetCreateStmt:
+		data, err := (*inst).GetCreateStatement(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodGetColumns:
+		data, err := (*inst).GetColumns(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodGetAllColumns:
+		data, err := (*inst).GetAllColumns(req.DBName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodGetIndexes:
+		data, err := (*inst).GetIndexes(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodGetForeignKey:
+		data, err := (*inst).GetForeignKeys(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodGetTriggers:
+		data, err := (*inst).GetTriggers(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case mysqlAgentMethodApplyChanges:
+		if req.Changes == nil {
+			return fail(resp, "变更集为空")
+		}
+		applier, ok := interface{}(*inst).(interface {
+			ApplyChanges(tableName string, changes connection.ChangeSet) error
+		})
+		if !ok {
+			return fail(resp, "当前驱动不支持 ApplyChanges")
+		}
+		if err := applier.ApplyChanges(req.TableName, *req.Changes); err != nil {
+			return fail(resp, err.Error())
+		}
+	default:
+		return fail(resp, "不支持的方法")
+	}
+
+	return resp
+}
+
+func writeResponse(writer *bufio.Writer, resp mysqlAgentResponse) error {
+	payload, err := json.Marshal(resp)
+	if err != nil {
+		return err
+	}
+	payload = append(payload, '\n')
+	if _, err := writer.Write(payload); err != nil {
+		return err
+	}
+	return writer.Flush()
+}
+
+func fail(resp mysqlAgentResponse, errText string) mysqlAgentResponse {
+	resp.Success = false
+	resp.Error = strings.TrimSpace(errText)
+	return resp
+}

cmd/optional-driver-agent/main.go

@@ -0,0 +1,236 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/db"
+)
+
+type agentRequest struct {
+	ID        int64                        `json:"id"`
+	Method    string                       `json:"method"`
+	Config    *connection.ConnectionConfig `json:"config,omitempty"`
+	Query     string                       `json:"query,omitempty"`
+	DBName    string                       `json:"dbName,omitempty"`
+	TableName string                       `json:"tableName,omitempty"`
+	Changes   *connection.ChangeSet        `json:"changes,omitempty"`
+}
+
+type agentResponse struct {
+	ID           int64       `json:"id"`
+	Success      bool        `json:"success"`
+	Error        string      `json:"error,omitempty"`
+	Data         interface{} `json:"data,omitempty"`
+	Fields       []string    `json:"fields,omitempty"`
+	RowsAffected int64       `json:"rowsAffected,omitempty"`
+}
+
+const (
+	agentMethodConnect       = "connect"
+	agentMethodClose         = "close"
+	agentMethodPing          = "ping"
+	agentMethodQuery         = "query"
+	agentMethodExec          = "exec"
+	agentMethodGetDatabases  = "getDatabases"
+	agentMethodGetTables     = "getTables"
+	agentMethodGetCreateStmt = "getCreateStatement"
+	agentMethodGetColumns    = "getColumns"
+	agentMethodGetAllColumns = "getAllColumns"
+	agentMethodGetIndexes    = "getIndexes"
+	agentMethodGetForeignKey = "getForeignKeys"
+	agentMethodGetTriggers   = "getTriggers"
+	agentMethodApplyChanges  = "applyChanges"
+)
+
+var (
+	agentDriverType      string
+	agentDatabaseFactory func() db.Database
+)
+
+func main() {
+	if agentDatabaseFactory == nil || strings.TrimSpace(agentDriverType) == "" {
+		fmt.Fprintf(os.Stderr, "未配置驱动代理 provider，请使用 gonavi_<driver>_driver 标签构建\n")
+		os.Exit(2)
+	}
+
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Buffer(make([]byte, 0, 16<<10), 8<<20)
+	writer := bufio.NewWriter(os.Stdout)
+	defer writer.Flush()
+
+	var inst db.Database
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+
+		var req agentRequest
+		if err := json.Unmarshal([]byte(line), &req); err != nil {
+			_ = writeResponse(writer, agentResponse{
+				ID:      req.ID,
+				Success: false,
+				Error:   fmt.Sprintf("解析请求失败：%v", err),
+			})
+			continue
+		}
+
+		resp := handleRequest(&inst, req)
+		if err := writeResponse(writer, resp); err != nil {
+			fmt.Fprintf(os.Stderr, "写入响应失败：%v\n", err)
+			break
+		}
+	}
+
+	if inst != nil {
+		_ = inst.Close()
+	}
+
+	if err := scanner.Err(); err != nil {
+		fmt.Fprintf(os.Stderr, "读取请求失败：%v\n", err)
+	}
+}
+
+func handleRequest(inst *db.Database, req agentRequest) agentResponse {
+	resp := agentResponse{ID: req.ID, Success: true}
+	method := strings.TrimSpace(req.Method)
+
+	switch method {
+	case agentMethodConnect:
+		if req.Config == nil {
+			return fail(resp, "连接配置为空")
+		}
+		if *inst != nil {
+			_ = (*inst).Close()
+		}
+		next := agentDatabaseFactory()
+		if next == nil {
+			return fail(resp, "驱动代理初始化失败")
+		}
+		if err := next.Connect(*req.Config); err != nil {
+			return fail(resp, err.Error())
+		}
+		*inst = next
+		return resp
+	case agentMethodClose:
+		if *inst != nil {
+			if err := (*inst).Close(); err != nil {
+				return fail(resp, err.Error())
+			}
+			*inst = nil
+		}
+		return resp
+	}
+
+	if *inst == nil {
+		return fail(resp, "connection not open")
+	}
+
+	switch method {
+	case agentMethodPing:
+		if err := (*inst).Ping(); err != nil {
+			return fail(resp, err.Error())
+		}
+	case agentMethodQuery:
+		data, fields, err := (*inst).Query(req.Query)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+		resp.Fields = fields
+	case agentMethodExec:
+		affected, err := (*inst).Exec(req.Query)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.RowsAffected = affected
+	case agentMethodGetDatabases:
+		data, err := (*inst).GetDatabases()
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodGetTables:
+		data, err := (*inst).GetTables(req.DBName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodGetCreateStmt:
+		data, err := (*inst).GetCreateStatement(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodGetColumns:
+		data, err := (*inst).GetColumns(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodGetAllColumns:
+		data, err := (*inst).GetAllColumns(req.DBName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodGetIndexes:
+		data, err := (*inst).GetIndexes(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodGetForeignKey:
+		data, err := (*inst).GetForeignKeys(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodGetTriggers:
+		data, err := (*inst).GetTriggers(req.DBName, req.TableName)
+		if err != nil {
+			return fail(resp, err.Error())
+		}
+		resp.Data = data
+	case agentMethodApplyChanges:
+		if req.Changes == nil {
+			return fail(resp, "变更集为空")
+		}
+		applier, ok := (*inst).(interface {
+			ApplyChanges(tableName string, changes connection.ChangeSet) error
+		})
+		if !ok {
+			return fail(resp, "当前驱动不支持 ApplyChanges")
+		}
+		if err := applier.ApplyChanges(req.TableName, *req.Changes); err != nil {
+			return fail(resp, err.Error())
+		}
+	default:
+		return fail(resp, "不支持的方法")
+	}
+
+	return resp
+}
+
+func writeResponse(writer *bufio.Writer, resp agentResponse) error {
+	payload, err := json.Marshal(resp)
+	if err != nil {
+		return err
+	}
+	payload = append(payload, '\n')
+	if _, err := writer.Write(payload); err != nil {
+		return err
+	}
+	return writer.Flush()
+}
+
+func fail(resp agentResponse, errText string) agentResponse {
+	resp.Success = false
+	resp.Error = strings.TrimSpace(errText)
+	return resp
+}

cmd/optional-driver-agent/provider_dameng.go

@@ -0,0 +1,12 @@
+//go:build gonavi_dameng_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "dameng"
+	agentDatabaseFactory = func() db.Database {
+		return &db.DamengDB{}
+	}
+}

cmd/optional-driver-agent/provider_diros.go

@@ -0,0 +1,12 @@
+//go:build gonavi_diros_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "diros"
+	agentDatabaseFactory = func() db.Database {
+		return &db.DirosDB{}
+	}
+}

cmd/optional-driver-agent/provider_duckdb.go

@@ -0,0 +1,12 @@
+//go:build gonavi_duckdb_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "duckdb"
+	agentDatabaseFactory = func() db.Database {
+		return &db.DuckDB{}
+	}
+}

cmd/optional-driver-agent/provider_highgo.go

@@ -0,0 +1,12 @@
+//go:build gonavi_highgo_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "highgo"
+	agentDatabaseFactory = func() db.Database {
+		return &db.HighGoDB{}
+	}
+}

cmd/optional-driver-agent/provider_kingbase.go

@@ -0,0 +1,12 @@
+//go:build gonavi_kingbase_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "kingbase"
+	agentDatabaseFactory = func() db.Database {
+		return &db.KingbaseDB{}
+	}
+}

cmd/optional-driver-agent/provider_mariadb.go

@@ -0,0 +1,12 @@
+//go:build gonavi_mariadb_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "mariadb"
+	agentDatabaseFactory = func() db.Database {
+		return &db.MariaDB{}
+	}
+}

cmd/optional-driver-agent/provider_mongodb.go

@@ -0,0 +1,12 @@
+//go:build gonavi_mongodb_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "mongodb"
+	agentDatabaseFactory = func() db.Database {
+		return &db.MongoDB{}
+	}
+}

cmd/optional-driver-agent/provider_mysql.go

@@ -0,0 +1,12 @@
+//go:build gonavi_mysql_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "mysql"
+	agentDatabaseFactory = func() db.Database {
+		return &db.MySQLDB{}
+	}
+}

cmd/optional-driver-agent/provider_sphinx.go

@@ -0,0 +1,12 @@
+//go:build gonavi_sphinx_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "sphinx"
+	agentDatabaseFactory = func() db.Database {
+		return &db.SphinxDB{}
+	}
+}

cmd/optional-driver-agent/provider_sqlite.go

@@ -0,0 +1,12 @@
+//go:build gonavi_sqlite_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "sqlite"
+	agentDatabaseFactory = func() db.Database {
+		return &db.SQLiteDB{}
+	}
+}

cmd/optional-driver-agent/provider_sqlserver.go

@@ -0,0 +1,12 @@
+//go:build gonavi_sqlserver_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "sqlserver"
+	agentDatabaseFactory = func() db.Database {
+		return &db.SqlServerDB{}
+	}
+}

cmd/optional-driver-agent/provider_tdengine.go

@@ -0,0 +1,12 @@
+//go:build gonavi_tdengine_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "tdengine"
+	agentDatabaseFactory = func() db.Database {
+		return &db.TDengineDB{}
+	}
+}

cmd/optional-driver-agent/provider_vastbase.go

@@ -0,0 +1,12 @@
+//go:build gonavi_vastbase_driver
+
+package main
+
+import "GoNavi-Wails/internal/db"
+
+func init() {
+	agentDriverType = "vastbase"
+	agentDatabaseFactory = func() db.Database {
+		return &db.VastbaseDB{}
+	}
+}

docs/driver-manifest.json

@@ -0,0 +1,83 @@
+{
+  "engine": "go",
+  "drivers": {
+    "mariadb": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/mariadb"
+    },
+    "diros": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/diros"
+    },
+    "sphinx": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/sphinx"
+    },
+    "sqlserver": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/sqlserver"
+    },
+    "sqlite": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/sqlite"
+    },
+    "duckdb": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/duckdb"
+    },
+    "dameng": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/dameng"
+    },
+    "kingbase": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/kingbase"
+    },
+    "highgo": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/highgo"
+    },
+    "vastbase": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/vastbase"
+    },
+    "mongodb": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/mongodb"
+    },
+    "tdengine": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/tdengine"
+    },
+    "postgres": {
+      "engine": "go",
+      "version": "go-embedded",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/postgres"
+    }
+  }
+}

frontend/.gitignore

@@ -0,0 +1 @@
+.ace-tool/

frontend/package.json.md5

@@ -1 +1 @@
-d0f9366af59a6367ad3c7e2d4185ead4
+5b8157374dae5f9340e31b2d0bd2c00e

frontend/src/App.css

@@ -6,6 +6,10 @@ html, body, #root {
   background-color: transparent !important; /* CRITICAL: Allow Wails window transparency */
 }
 
+body, #root {
+  border-radius: 14px; /* Slightly rounded app window corners */
+}
+
 /* 侧边栏 Tree 样式优化 */
 .ant-tree .ant-tree-treenode {
   width: 100%;
@@ -59,8 +63,28 @@ body {
 }
 
 body[data-theme='dark'] {
-    /* Improve contrast on transparent backgrounds */
-    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.8);
+    /* 移除全局 text-shadow：对每个文本元素增加 GPU compositing 成本，
+       在透明窗口环境下会显著加剧 GPU 负载 */
+}
+
+/* 连接配置弹窗：滚动仅在弹窗 body 内部，不使用外层 wrap 滚动条 */
+.connection-modal-wrap {
+    overflow: hidden !important;
+}
+
+.connection-modal-wrap .ant-modal-content {
+    max-height: calc(100vh - 72px);
+    display: flex;
+    flex-direction: column;
+}
+
+.connection-modal-wrap .ant-modal-body {
+    flex: 1 1 auto;
+    min-height: 0;
+}
+
+.connection-modal-wrap .ant-modal-footer {
+    flex-shrink: 0;
 }
 
 /* Custom Title Bar Close Button Hover */

frontend/src/App.tsx

@@ -1,14 +1,18 @@
 import React, { useState, useEffect } from 'react';
-import { Layout, Button, ConfigProvider, theme, Dropdown, MenuProps, message, Modal, Spin, Slider, Popover } from 'antd';
+import { Layout, Button, ConfigProvider, theme, Dropdown, MenuProps, message, Modal, Spin, Slider, Progress } from 'antd';
 import zhCN from 'antd/locale/zh_CN';
 import { PlusOutlined, BulbOutlined, BulbFilled, ConsoleSqlOutlined, UploadOutlined, DownloadOutlined, CloudDownloadOutlined, BugOutlined, ToolOutlined, InfoCircleOutlined, GithubOutlined, SkinOutlined, CheckOutlined, MinusOutlined, BorderOutlined, CloseOutlined, SettingOutlined } from '@ant-design/icons';
+import { Environment, EventsOn } from '../wailsjs/runtime/runtime';
 import Sidebar from './components/Sidebar';
 import TabManager from './components/TabManager';
 import ConnectionModal from './components/ConnectionModal';
 import DataSyncModal from './components/DataSyncModal';
+import DriverManagerModal from './components/DriverManagerModal';
 import LogPanel from './components/LogPanel';
 import { useStore } from './store';
 import { SavedConnection } from './types';
+import { blurToFilter, normalizeBlurForPlatform, normalizeOpacityForPlatform, isWindowsPlatform } from './utils/appearance';
+import { SetWindowTranslucency } from '../wailsjs/go/app/App';
 import './App.css';
 
 const { Sider, Content } = Layout;
@@ -16,23 +20,52 @@ const { Sider, Content } = Layout;
 function App() {
   const [isModalOpen, setIsModalOpen] = useState(false);
   const [isSyncModalOpen, setIsSyncModalOpen] = useState(false);
+  const [isDriverModalOpen, setIsDriverModalOpen] = useState(false);
   const [editingConnection, setEditingConnection] = useState<SavedConnection | null>(null);
   const themeMode = useStore(state => state.theme);
   const setTheme = useStore(state => state.setTheme);
   const appearance = useStore(state => state.appearance);
   const setAppearance = useStore(state => state.setAppearance);
   const darkMode = themeMode === 'dark';
+  const effectiveOpacity = normalizeOpacityForPlatform(appearance.opacity);
+  const effectiveBlur = normalizeBlurForPlatform(appearance.blur);
+  const blurFilter = blurToFilter(effectiveBlur);
+  const windowCornerRadius = 14;
+  const [isLinuxRuntime, setIsLinuxRuntime] = useState(false);
+
+  // 同步 macOS 窗口透明度：opacity=1.0 且 blur=0 时关闭 NSVisualEffectView，
+  // 避免 GPU 持续计算窗口背后的模糊合成
+  useEffect(() => {
+    SetWindowTranslucency(appearance.opacity, appearance.blur).catch(() => {});
+  }, [appearance.opacity, appearance.blur]);
+
+  useEffect(() => {
+      let cancelled = false;
+      Environment()
+          .then((env) => {
+              if (cancelled) return;
+              setIsLinuxRuntime((env?.platform || '').toLowerCase() === 'linux');
+          })
+          .catch(() => {
+              if (cancelled) return;
+              const platform = typeof navigator !== 'undefined' ? navigator.platform : '';
+              setIsLinuxRuntime(/linux/i.test(platform));
+          });
+      return () => {
+          cancelled = true;
+      };
+  }, []);
 
   // Background Helper
   const getBg = (darkHex: string, lightHex: string) => {
-      if (!darkMode) return `rgba(255, 255, 255, ${appearance.opacity ?? 0.95})`; // Light mode usually white
+      if (!darkMode) return `rgba(255, 255, 255, ${effectiveOpacity})`; // Light mode usually white
       
       // Parse hex to rgb
       const hex = darkHex.replace('#', '');
       const r = parseInt(hex.substring(0, 2), 16);
       const g = parseInt(hex.substring(2, 4), 16);
       const b = parseInt(hex.substring(4, 6), 16);
-      return `rgba(${r}, ${g}, ${b}, ${appearance.opacity ?? 0.95})`;
+      return `rgba(${r}, ${g}, ${b}, ${effectiveOpacity})`;
   };
   // Specific colors
   const bgMain = getBg('#141414', '#ffffff');
@@ -47,6 +80,7 @@ function App() {
   const updateCheckInFlightRef = React.useRef(false);
   const updateDownloadInFlightRef = React.useRef(false);
   const updateDownloadedVersionRef = React.useRef<string | null>(null);
+  const updateDownloadMetaRef = React.useRef<UpdateDownloadResultData | null>(null);
   const updateDeferredVersionRef = React.useRef<string | null>(null);
   const updateNotifiedVersionRef = React.useRef<string | null>(null);
   const updateMutedVersionRef = React.useRef<string | null>(null);
@@ -55,6 +89,23 @@ function App() {
   const [aboutInfo, setAboutInfo] = useState<{ version: string; author: string; buildTime?: string; repoUrl?: string; issueUrl?: string; releaseUrl?: string } | null>(null);
   const [aboutUpdateStatus, setAboutUpdateStatus] = useState<string>('');
   const [lastUpdateInfo, setLastUpdateInfo] = useState<UpdateInfo | null>(null);
+  const [updateDownloadProgress, setUpdateDownloadProgress] = useState<{
+      open: boolean;
+      version: string;
+      status: 'idle' | 'start' | 'downloading' | 'done' | 'error';
+      percent: number;
+      downloaded: number;
+      total: number;
+      message: string;
+  }>({
+      open: false,
+      version: '',
+      status: 'idle',
+      percent: 0,
+      downloaded: 0,
+      total: 0,
+      message: ''
+  });
 
   type UpdateInfo = {
       hasUpdate: boolean;
@@ -66,12 +117,55 @@ function App() {
       assetUrl?: string;
       assetSize?: number;
       sha256?: string;
+      downloaded?: boolean;
+      downloadPath?: string;
   };
 
-  const promptRestartForUpdate = (info: UpdateInfo) => {
+  type UpdateDownloadProgressEvent = {
+      status?: 'start' | 'downloading' | 'done' | 'error';
+      percent?: number;
+      downloaded?: number;
+      total?: number;
+      message?: string;
+  };
+
+  type UpdateDownloadResultData = {
+      info?: UpdateInfo;
+      downloadPath?: string;
+      installLogPath?: string;
+      installTarget?: string;
+      platform?: string;
+      autoRelaunch?: boolean;
+  };
+
+  const formatBytes = (bytes?: number) => {
+      if (!bytes || bytes <= 0) return '0 B';
+      const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+      let value = bytes;
+      let idx = 0;
+      while (value >= 1024 && idx < units.length - 1) {
+          value /= 1024;
+          idx++;
+      }
+      return `${value.toFixed(idx === 0 ? 0 : 1)} ${units[idx]}`;
+  };
+
+  const promptRestartForUpdate = (info: UpdateInfo, resultData?: UpdateDownloadResultData) => {
+      const downloadPathHint = resultData?.downloadPath
+          ? `更新包路径：${resultData.downloadPath}`
+          : '';
+      const installLogHint = resultData?.installLogPath
+          ? `安装日志：${resultData.installLogPath}`
+          : '';
       Modal.confirm({
           title: '更新已下载',
-          content: `版本 ${info.latestVersion} 已下载完成，是否现在重启完成更新？`,
+          content: (
+              <div style={{ display: 'flex', flexDirection: 'column', gap: 6, userSelect: 'text' }}>
+                  <div>{`版本 ${info.latestVersion} 已下载完成，是否现在重启完成更新？`}</div>
+                  {downloadPathHint ? <div style={{ fontSize: 12, color: '#8c8c8c' }}>{downloadPathHint}</div> : null}
+                  {installLogHint ? <div style={{ fontSize: 12, color: '#8c8c8c' }}>{installLogHint}</div> : null}
+              </div>
+          ),
           okText: '立即重启',
           cancelText: '稍后',
           onOk: async () => {
@@ -91,25 +185,49 @@ function App() {
       if (updateDownloadInFlightRef.current) return;
       if (updateDownloadedVersionRef.current === info.latestVersion) {
           if (!silent) {
-              message.info(`更新包已就绪（${info.latestVersion}）`);
+              const cachedDownloadPath = updateDownloadMetaRef.current?.downloadPath;
+              message.info(cachedDownloadPath ? `更新包已就绪（${info.latestVersion}），路径：${cachedDownloadPath}` : `更新包已就绪（${info.latestVersion}）`);
           }
           if (!silent || updateDeferredVersionRef.current !== info.latestVersion) {
-              promptRestartForUpdate(info);
+              promptRestartForUpdate(info, updateDownloadMetaRef.current || undefined);
           }
           return;
       }
       updateDownloadInFlightRef.current = true;
+      updateDownloadMetaRef.current = null;
       const key = 'update-download';
+      setUpdateDownloadProgress({
+          open: true,
+          version: info.latestVersion,
+          status: 'start',
+          percent: 0,
+          downloaded: 0,
+          total: info.assetSize || 0,
+          message: ''
+      });
       message.loading({ content: `正在下载更新 ${info.latestVersion}...`, key, duration: 0 });
       const res = await (window as any).go.app.App.DownloadUpdate();
       updateDownloadInFlightRef.current = false;
       if (res?.success) {
+          const resultData = (res?.data || {}) as UpdateDownloadResultData;
+          updateDownloadMetaRef.current = resultData;
           updateDownloadedVersionRef.current = info.latestVersion;
-          message.success({ content: '更新下载完成', key, duration: 2 });
+          setUpdateDownloadProgress(prev => ({ ...prev, status: 'done', percent: 100, open: false }));
+          if (resultData?.downloadPath) {
+              message.success({ content: `更新下载完成，更新包路径：${resultData.downloadPath}`, key, duration: 5 });
+          } else {
+              message.success({ content: '更新下载完成', key, duration: 2 });
+          }
+          setAboutUpdateStatus(`发现新版本 ${info.latestVersion}（已下载，待重启安装）`);
           if (!silent || updateDeferredVersionRef.current !== info.latestVersion) {
-              promptRestartForUpdate(info);
+              promptRestartForUpdate(info, resultData);
           }
       } else {
+          setUpdateDownloadProgress(prev => ({
+              ...prev,
+              status: 'error',
+              message: res?.message || '未知错误'
+          }));
           message.error({ content: '更新下载失败: ' + (res?.message || '未知错误'), key, duration: 4 });
       }
   }, []);
@@ -133,12 +251,30 @@ function App() {
       if (!info) return;
       setLastUpdateInfo(info);
       if (info.hasUpdate) {
+          const localDownloaded = updateDownloadedVersionRef.current === info.latestVersion;
+          const hasDownloaded = Boolean(info.downloaded) || localDownloaded;
+          if (hasDownloaded) {
+              const downloadPath = info.downloadPath || updateDownloadMetaRef.current?.downloadPath || '';
+              updateDownloadedVersionRef.current = info.latestVersion;
+              updateDownloadMetaRef.current = {
+                  ...(updateDownloadMetaRef.current || {}),
+                  info,
+                  downloadPath: downloadPath || undefined,
+              };
+          } else {
+              if (updateDownloadedVersionRef.current !== info.latestVersion) {
+                  updateDownloadMetaRef.current = null;
+              }
+          }
+          const statusText = hasDownloaded
+              ? `发现新版本 ${info.latestVersion}（已下载，待重启安装）`
+              : `发现新版本 ${info.latestVersion}（未下载）`;
           if (!silent) {
               message.info(`发现新版本 ${info.latestVersion}`);
-              setAboutUpdateStatus(`发现新版本 ${info.latestVersion}（未下载）`);
+              setAboutUpdateStatus(statusText);
           }
           if (silent && isAboutOpen) {
-              setAboutUpdateStatus(`发现新版本 ${info.latestVersion}（未下载）`);
+              setAboutUpdateStatus(statusText);
           }
           if (silent && !isAboutOpen && updateMutedVersionRef.current !== info.latestVersion && updateNotifiedVersionRef.current !== info.latestVersion) {
               updateNotifiedVersionRef.current = info.latestVersion;
@@ -244,6 +380,12 @@ function App() {
           label: '数据同步',
           icon: <UploadOutlined rotate={90} />,
           onClick: () => setIsSyncModalOpen(true)
+      },
+      {
+          key: 'drivers',
+          label: '驱动管理',
+          icon: <SettingOutlined />,
+          onClick: () => setIsDriverModalOpen(true)
       }
   ];
 
@@ -272,8 +414,13 @@ function App() {
   const [isAppearanceModalOpen, setIsAppearanceModalOpen] = useState(false);
 
 
-  // Log Panel
-  const [logPanelHeight, setLogPanelHeight] = useState(200);
+  // Log Panel: 最小高度按“工具栏 + 1 条日志行（微增）”限制
+  const LOG_PANEL_TOOLBAR_HEIGHT = 32;
+  const LOG_PANEL_SINGLE_ROW_HEIGHT = 39;
+  const LOG_PANEL_MIN_VISIBLE_ROWS = 1;
+  const LOG_PANEL_MIN_HEIGHT = LOG_PANEL_TOOLBAR_HEIGHT + (LOG_PANEL_SINGLE_ROW_HEIGHT * LOG_PANEL_MIN_VISIBLE_ROWS);
+  const LOG_PANEL_MAX_HEIGHT = 800;
+  const [logPanelHeight, setLogPanelHeight] = useState(Math.max(200, LOG_PANEL_MIN_HEIGHT));
   const [isLogPanelOpen, setIsLogPanelOpen] = useState(false);
   const logResizeRef = React.useRef<{ startY: number, startHeight: number } | null>(null);
   const logGhostRef = React.useRef<HTMLDivElement>(null);
@@ -302,7 +449,10 @@ function App() {
   const handleLogResizeUp = (e: MouseEvent) => {
       if (logResizeRef.current) {
           const delta = logResizeRef.current.startY - e.clientY; 
-          const newHeight = Math.max(100, Math.min(800, logResizeRef.current.startHeight + delta));
+          const newHeight = Math.max(
+              LOG_PANEL_MIN_HEIGHT,
+              Math.min(LOG_PANEL_MAX_HEIGHT, logResizeRef.current.startHeight + delta)
+          );
           setLogPanelHeight(newHeight);
       }
       
@@ -324,6 +474,20 @@ function App() {
       setIsModalOpen(false);
       setEditingConnection(null);
   };
+
+  const handleOpenDriverManagerFromConnection = () => {
+      setIsModalOpen(false);
+      setEditingConnection(null);
+      setIsDriverModalOpen(true);
+  };
+
+  const handleTitleBarDoubleClick = (e: React.MouseEvent<HTMLDivElement>) => {
+      const target = e.target as HTMLElement | null;
+      if (target?.closest('[data-no-titlebar-toggle="true"]')) {
+          return;
+      }
+      (window as any).runtime.WindowToggleMaximise();
+  };
   
   // Sidebar Resizing
   const [sidebarWidth, setSidebarWidth] = useState(300);
@@ -386,13 +550,9 @@ function App() {
   };
 
   useEffect(() => {
-    if (darkMode) {
-        document.body.style.backgroundColor = '#141414';
-        document.body.style.color = '#ffffff';
-    } else {
-        document.body.style.backgroundColor = '#ffffff';
-        document.body.style.color = '#000000';
-    }
+    document.body.style.backgroundColor = 'transparent';
+    document.body.style.color = darkMode ? '#ffffff' : '#000000';
+    document.body.setAttribute('data-theme', darkMode ? 'dark' : 'light');
   }, [darkMode]);
 
   useEffect(() => {
@@ -421,6 +581,46 @@ function App() {
       };
   }, [checkForUpdates]);
 
+  useEffect(() => {
+      const offDownloadProgress = EventsOn('update:download-progress', (event: UpdateDownloadProgressEvent) => {
+          if (!event) return;
+          const status = event.status || 'downloading';
+          const nextStatus: 'idle' | 'start' | 'downloading' | 'done' | 'error' =
+              status === 'start' || status === 'downloading' || status === 'done' || status === 'error'
+                  ? status
+                  : 'downloading';
+          const downloaded = typeof event.downloaded === 'number' ? event.downloaded : 0;
+          const total = typeof event.total === 'number' ? event.total : 0;
+          const percentRaw = typeof event.percent === 'number'
+              ? event.percent
+              : (total > 0 ? (downloaded / total) * 100 : 0);
+          const percent = Math.max(0, Math.min(100, percentRaw));
+          setUpdateDownloadProgress(prev => ({
+              open: nextStatus === 'start' || nextStatus === 'downloading' || nextStatus === 'error',
+              version: prev.version,
+              status: nextStatus,
+              percent,
+              downloaded,
+              total,
+              message: String(event.message || '')
+          }));
+      });
+      return () => {
+          offDownloadProgress();
+      };
+  }, []);
+
+  const linuxResizeHandleStyleBase = {
+      position: 'fixed',
+      zIndex: 12000,
+      background: 'transparent',
+      WebkitAppRegion: 'drag',
+      '--wails-draggable': 'drag',
+      userSelect: 'none'
+  } as any;
+
+  const showLinuxResizeHandles = isLinuxRuntime;
+
   return (
     <ConfigProvider
         locale={zhCN}
@@ -429,14 +629,14 @@ function App() {
             token: {
                 colorBgLayout: 'transparent',
                 colorBgContainer: darkMode 
-                    ? `rgba(29, 29, 29, ${appearance.opacity ?? 0.95})` 
-                    : `rgba(255, 255, 255, ${appearance.opacity ?? 0.95})`,
+                    ? `rgba(29, 29, 29, ${effectiveOpacity})` 
+                    : `rgba(255, 255, 255, ${effectiveOpacity})`,
                 colorBgElevated: darkMode 
                     ? '#1f1f1f' 
                     : '#ffffff',
                 colorFillAlter: darkMode
-                    ? `rgba(38, 38, 38, ${appearance.opacity ?? 0.95})`
-                    : `rgba(250, 250, 250, ${appearance.opacity ?? 0.95})`,
+                    ? `rgba(38, 38, 38, ${effectiveOpacity})`
+                    : `rgba(250, 250, 250, ${effectiveOpacity})`,
             },
             components: {
                 Layout: {
@@ -464,10 +664,14 @@ function App() {
             display: 'flex', 
             flexDirection: 'column',
             background: 'transparent',
-            backdropFilter: `blur(${appearance.blur ?? 0}px)` 
+            borderRadius: showLinuxResizeHandles ? 0 : windowCornerRadius,
+            clipPath: showLinuxResizeHandles ? 'none' : `inset(0 round ${windowCornerRadius}px)`,
+            backdropFilter: blurFilter,
+            WebkitBackdropFilter: blurFilter,
         }}>
           {/* Custom Title Bar */}
           <div
+            onDoubleClick={handleTitleBarDoubleClick}
             style={{
                 height: 32,
                 flexShrink: 0,
@@ -475,7 +679,6 @@ function App() {
                 alignItems: 'center',
                 justifyContent: 'space-between',
                 background: bgMain,
-                backdropFilter: `blur(${appearance.blur ?? 0}px)`,
                 borderBottom: 'none',
                 userSelect: 'none',
                 WebkitAppRegion: 'drag', // Wails drag region
@@ -487,7 +690,11 @@ function App() {
                   {/* Logo can be added here if available */}
                   GoNavi
               </div>
-              <div style={{ display: 'flex', height: '100%', WebkitAppRegion: 'no-drag', '--wails-draggable': 'no-drag' } as any}>
+              <div
+                data-no-titlebar-toggle="true"
+                onDoubleClick={(e) => e.stopPropagation()}
+                style={{ display: 'flex', height: '100%', WebkitAppRegion: 'no-drag', '--wails-draggable': 'no-drag' } as any}
+              >
                   <Button 
                     type="text" 
                     icon={<MinusOutlined />} 
@@ -522,7 +729,6 @@ function App() {
                 padding: '0 8px',
                 borderBottom: 'none',
                 background: bgMain,
-                backdropFilter: `blur(${appearance.blur ?? 0}px)`
             }}
           >
             <Dropdown menu={{ items: toolsMenu }} placement="bottomLeft">
@@ -533,11 +739,11 @@ function App() {
             </Dropdown>
             <Button type="text" icon={<InfoCircleOutlined />} title="关于" onClick={() => setIsAboutOpen(true)}>关于</Button>
           </div>
-          <Layout style={{ flex: 1, minHeight: 0 }}>
+          <Layout style={{ flex: 1, minHeight: 0, minWidth: 0 }}>
           <Sider 
             width={sidebarWidth} 
             style={{ 
-                borderRight: 'none', 
+                borderRight: '1px solid rgba(128,128,128,0.2)',
                 position: 'relative',
                 background: bgMain
             }}
@@ -584,8 +790,8 @@ function App() {
                 title="拖动调整宽度"
             />
           </Sider>
-           <Content style={{ background: 'transparent', overflow: 'hidden', display: 'flex', flexDirection: 'column' }}>
-             <div style={{ flex: 1, minHeight: 0, overflow: 'hidden', display: 'flex', flexDirection: 'column', background: bgContent, backdropFilter: `blur(${appearance.blur ?? 0}px)` }}>
+           <Content style={{ background: 'transparent', overflow: 'hidden', display: 'flex', flexDirection: 'column', minWidth: 0 }}>
+             <div style={{ flex: 1, minHeight: 0, minWidth: 0, overflow: 'hidden', display: 'flex', flexDirection: 'column', background: bgContent }}>
                  <TabManager />
              </div>
              {isLogPanelOpen && (
@@ -601,11 +807,16 @@ function App() {
             open={isModalOpen} 
             onClose={handleCloseModal} 
             initialValues={editingConnection}
+            onOpenDriverManager={handleOpenDriverManagerFromConnection}
           />
           <DataSyncModal
             open={isSyncModalOpen}
             onClose={() => setIsSyncModalOpen(false)}
           />
+          <DriverManagerModal
+            open={isDriverModalOpen}
+            onClose={() => setIsDriverModalOpen(false)}
+          />
           <Modal
             title="关于 GoNavi"
             open={isAboutOpen}
@@ -673,31 +884,104 @@ function App() {
                             min={0.1} 
                             max={1.0} 
                             step={0.05} 
-                            value={appearance.opacity ?? 0.95} 
+                            value={appearance.opacity ?? 1.0} 
                             onChange={(v) => setAppearance({ opacity: v })} 
                             style={{ flex: 1 }}
                           />
-                          <span style={{ width: 40 }}>{Math.round((appearance.opacity ?? 0.95) * 100)}%</span>
+                          <span style={{ width: 40 }}>{Math.round((appearance.opacity ?? 1.0) * 100)}%</span>
                       </div>
                   </div>
                   <div>
                       <div style={{ marginBottom: 8, fontWeight: 500 }}>高斯模糊 (Blur)</div>
-                      <div style={{ display: 'flex', alignItems: 'center', gap: 16 }}>
-                          <Slider 
-                            min={0} 
-                            max={20} 
-                            value={appearance.blur ?? 0} 
-                            onChange={(v) => setAppearance({ blur: v })} 
-                            style={{ flex: 1 }}
-                          />
-                          <span style={{ width: 40 }}>{appearance.blur}px</span>
-                      </div>
-                      <div style={{ fontSize: 12, color: '#888', marginTop: 4 }}>
-                          * 仅控制应用内覆盖层的模糊效果
-                      </div>
+                      {isWindowsPlatform() ? (
+                          <div style={{ fontSize: 12, color: '#888' }}>
+                              Windows 使用系统 Acrylic 效果，模糊程度由系统控制
+                          </div>
+                      ) : (
+                          <>
+                              <div style={{ display: 'flex', alignItems: 'center', gap: 16 }}>
+                                  <Slider
+                                    min={0}
+                                    max={20}
+                                    value={appearance.blur ?? 0}
+                                    onChange={(v) => setAppearance({ blur: v })}
+                                    style={{ flex: 1 }}
+                                  />
+                                  <span style={{ width: 40 }}>{appearance.blur}px</span>
+                              </div>
+                              <div style={{ fontSize: 12, color: '#888', marginTop: 4 }}>
+                                  * 仅控制应用内覆盖层的模糊效果
+                              </div>
+                          </>
+                      )}
                   </div>
               </div>
           </Modal>
+
+          <Modal
+              title={updateDownloadProgress.version ? `下载更新 ${updateDownloadProgress.version}` : '下载更新'}
+              open={updateDownloadProgress.open}
+              closable={updateDownloadProgress.status === 'error'}
+              maskClosable={false}
+              keyboard={updateDownloadProgress.status === 'error'}
+              onCancel={() => {
+                  if (updateDownloadProgress.status === 'error') {
+                      setUpdateDownloadProgress({
+                          open: false,
+                          version: '',
+                          status: 'idle',
+                          percent: 0,
+                          downloaded: 0,
+                          total: 0,
+                          message: ''
+                      });
+                  }
+              }}
+              footer={updateDownloadProgress.status === 'error' ? [
+                  <Button
+                      key="close"
+                      onClick={() => setUpdateDownloadProgress({
+                          open: false,
+                          version: '',
+                          status: 'idle',
+                          percent: 0,
+                          downloaded: 0,
+                          total: 0,
+                          message: ''
+                      })}
+                  >
+                      关闭
+                  </Button>
+              ] : null}
+          >
+              <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
+                  <Progress
+                      percent={Math.round(updateDownloadProgress.percent)}
+                      status={updateDownloadProgress.status === 'error' ? 'exception' : (updateDownloadProgress.status === 'done' ? 'success' : 'active')}
+                  />
+                  <div style={{ fontSize: 12, color: '#8c8c8c' }}>
+                      {`${formatBytes(updateDownloadProgress.downloaded)} / ${formatBytes(updateDownloadProgress.total)}`}
+                  </div>
+                  {updateDownloadProgress.message ? (
+                      <div style={{ fontSize: 12, color: '#ff4d4f' }}>{updateDownloadProgress.message}</div>
+                  ) : null}
+              </div>
+          </Modal>
+
+          {showLinuxResizeHandles && (
+              <>
+                  {/* Linux Mint 下 frameless 仅局部可缩放：补四边四角命中层 */}
+                  <div style={{ ...linuxResizeHandleStyleBase, top: 0, left: 14, right: 14, height: 6, cursor: 'ns-resize' }} />
+                  <div style={{ ...linuxResizeHandleStyleBase, bottom: 0, left: 14, right: 14, height: 6, cursor: 'ns-resize' }} />
+                  <div style={{ ...linuxResizeHandleStyleBase, top: 14, bottom: 14, left: 0, width: 6, cursor: 'ew-resize' }} />
+                  <div style={{ ...linuxResizeHandleStyleBase, top: 14, bottom: 14, right: 0, width: 6, cursor: 'ew-resize' }} />
+
+                  <div style={{ ...linuxResizeHandleStyleBase, top: 0, left: 0, width: 14, height: 14, cursor: 'nwse-resize' }} />
+                  <div style={{ ...linuxResizeHandleStyleBase, top: 0, right: 0, width: 14, height: 14, cursor: 'nesw-resize' }} />
+                  <div style={{ ...linuxResizeHandleStyleBase, bottom: 0, left: 0, width: 14, height: 14, cursor: 'nesw-resize' }} />
+                  <div style={{ ...linuxResizeHandleStyleBase, bottom: 0, right: 0, width: 14, height: 14, cursor: 'nwse-resize' }} />
+              </>
+          )}
           
           {/* Ghost Resize Line for Sidebar */}
           <div 

frontend/src/components/DataViewer.tsx

@@ -4,7 +4,7 @@ import { TabData, ColumnDefinition } from '../types';
 import { useStore } from '../store';
 import { DBQuery, DBGetColumns } from '../../wailsjs/go/app/App';
 import DataGrid, { GONAVI_ROW_KEY } from './DataGrid';
-import { buildWhereSQL, quoteIdentPart, quoteQualifiedIdent } from '../utils/sql';
+import { buildOrderBySQL, buildWhereSQL, quoteQualifiedIdent, withSortBufferTuningSQL, type FilterCondition } from '../utils/sql';
 
 const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
   const [data, setData] = useState<any[]>([]);
@@ -29,7 +29,9 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
   const [sortInfo, setSortInfo] = useState<{ columnKey: string, order: string } | null>(null);
   
   const [showFilter, setShowFilter] = useState(false);
-  const [filterConditions, setFilterConditions] = useState<any[]>([]);
+  const [filterConditions, setFilterConditions] = useState<FilterCondition[]>([]);
+  const currentConnType = (connections.find(c => c.id === tab.connectionId)?.config?.type || '').toLowerCase();
+  const forceReadOnly = currentConnType === 'tdengine';
 
   useEffect(() => {
     setPkColumns([]);
@@ -58,6 +60,8 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
     };
 
     const dbType = config.type || '';
+    const dbTypeLower = String(dbType || '').trim().toLowerCase();
+    const isMySQLFamily = dbTypeLower === 'mysql' || dbTypeLower === 'mariadb' || dbTypeLower === 'diros';
 
     const dbName = tab.dbName || '';
     const tableName = tab.tableName || '';
@@ -67,31 +71,51 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
     const countSql = `SELECT COUNT(*) as total FROM ${quoteQualifiedIdent(dbType, tableName)} ${whereSQL}`;
     
     let sql = `SELECT * FROM ${quoteQualifiedIdent(dbType, tableName)} ${whereSQL}`;
-    if (sortInfo && sortInfo.order) {
-        sql += ` ORDER BY ${quoteIdentPart(dbType, sortInfo.columnKey)} ${sortInfo.order === 'ascend' ? 'ASC' : 'DESC'}`;
-    }
+    sql += buildOrderBySQL(dbType, sortInfo, pkColumns);
     const offset = (page - 1) * size;
     // 大表性能：打开表不阻塞在 COUNT(*)，先通过多取 1 条判断是否还有下一页；总数在后台统计并异步回填。
     sql += ` LIMIT ${size + 1} OFFSET ${offset}`;
 
-    const startTime = Date.now();
+    const requestStartTime = Date.now();
+    let executedSql = sql;
     try {
-        const pData = DBQuery(config as any, dbName, sql);
+        const executeDataQuery = async (querySql: string, attemptLabel: string) => {
+            const startTime = Date.now();
+            const result = await DBQuery(config as any, dbName, querySql);
+            addSqlLog({
+                id: `log-${Date.now()}-data`,
+                timestamp: Date.now(),
+                sql: querySql,
+                status: result.success ? 'success' : 'error',
+                duration: Date.now() - startTime,
+                message: result.success ? '' : `${attemptLabel}: ${result.message}`,
+                affectedRows: Array.isArray(result.data) ? result.data.length : undefined,
+                dbName
+            });
+            return result;
+        };
 
-        const resData = await pData;
-        const duration = Date.now() - startTime;
-        
-        // Log Execution
-        addSqlLog({
-            id: `log-${Date.now()}-data`,
-            timestamp: Date.now(),
-            sql: sql,
-            status: resData.success ? 'success' : 'error',
-            duration: duration,
-            message: resData.success ? '' : resData.message,
-            affectedRows: Array.isArray(resData.data) ? resData.data.length : undefined,
-            dbName
-        });
+        const hasSort = !!sortInfo?.columnKey && (sortInfo?.order === 'ascend' || sortInfo?.order === 'descend');
+        const isSortMemoryErr = (msg: string) => /error\s*1038|out of sort memory/i.test(String(msg || ''));
+        let resData = await executeDataQuery(sql, '主查询');
+
+        if (!resData.success && isMySQLFamily && hasSort && isSortMemoryErr(resData.message)) {
+            const retrySql32MB = withSortBufferTuningSQL(dbType, sql, 32 * 1024 * 1024);
+            if (retrySql32MB !== sql) {
+                executedSql = retrySql32MB;
+                resData = await executeDataQuery(retrySql32MB, '重试(32MB sort_buffer)');
+            }
+            if (!resData.success && isSortMemoryErr(resData.message)) {
+                const retrySql128MB = withSortBufferTuningSQL(dbType, sql, 128 * 1024 * 1024);
+                if (retrySql128MB !== executedSql) {
+                    executedSql = retrySql128MB;
+                    resData = await executeDataQuery(retrySql128MB, '重试(128MB sort_buffer)');
+                }
+            }
+            if (resData.success) {
+                message.warning('已自动提升排序缓冲并重试成功。');
+            }
+        }
         
         if (pkColumns.length === 0) {
             const pkKey = `${tab.connectionId}|${dbName}|${tableName}`;
@@ -187,7 +211,7 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
                 }
             }
         } else {
-            message.error(resData.message);
+            message.error(String(resData.message || '查询失败'));
         }
     } catch (e: any) {
         if (fetchSeqRef.current !== seq) return;
@@ -195,37 +219,41 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
         addSqlLog({
             id: `log-${Date.now()}-error`,
             timestamp: Date.now(),
-            sql: sql,
+            sql: executedSql,
             status: 'error',
-            duration: Date.now() - startTime,
+            duration: Date.now() - requestStartTime,
             message: e.message,
             dbName
         });
     }
     if (fetchSeqRef.current === seq) setLoading(false);
-  }, [connections, tab, sortInfo, filterConditions, pkColumns.length]); 
-  // Depend on pkColumns.length to avoid loop? No, pkColumns is updated inside.
-  // Actually, 'pkColumns' state shouldn't trigger re-fetch.
-  // The 'if (pkColumns.length === 0)' check is inside.
-  // So adding pkColumns to dependency is safer but might trigger double fetch if not careful?
-  // Only if pkColumns changes. It changes once from [] to [...].
-  // So it's fine.
+  }, [connections, tab, sortInfo, filterConditions, pkColumns]); 
+  // 依赖 pkColumns：在无手动排序时可回退到主键稳定排序。
+  // 主键信息只会在首次加载后更新一次，避免循环查询。
 
   // Handlers memoized
   const handleReload = useCallback(() => {
     fetchData(pagination.current, pagination.pageSize);
   }, [fetchData, pagination.current, pagination.pageSize]);
-  const handleSort = useCallback((field: string, order: string) => setSortInfo({ columnKey: field, order }), []);
+  const handleSort = useCallback((field: string, order: string) => {
+    const normalizedOrder = order === 'ascend' || order === 'descend' ? order : '';
+    const normalizedField = String(field || '').trim();
+    if (!normalizedField || !normalizedOrder) {
+      setSortInfo(null);
+      return;
+    }
+    setSortInfo({ columnKey: normalizedField, order: normalizedOrder });
+  }, []);
   const handlePageChange = useCallback((page: number, size: number) => fetchData(page, size), [fetchData]);
   const handleToggleFilter = useCallback(() => setShowFilter(prev => !prev), []);
-  const handleApplyFilter = useCallback((conditions: any[]) => setFilterConditions(conditions), []);
+  const handleApplyFilter = useCallback((conditions: FilterCondition[]) => setFilterConditions(conditions), []);
 
   useEffect(() => {
     fetchData(1, pagination.pageSize); 
   }, [tab, sortInfo, filterConditions]); // Initial load and re-load on sort/filter
 
   return (
-    <div style={{ flex: '1 1 auto', minHeight: 0, height: '100%', width: '100%', overflow: 'hidden', display: 'flex', flexDirection: 'column' }}>
+    <div style={{ flex: '1 1 auto', minHeight: 0, minWidth: 0, height: '100%', width: '100%', overflow: 'hidden', display: 'flex', flexDirection: 'column' }}>
       <DataGrid
           data={data}
           columnNames={columnNames}
@@ -241,6 +269,8 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
           showFilter={showFilter}
           onToggleFilter={handleToggleFilter}
           onApplyFilter={handleApplyFilter}
+          readOnly={forceReadOnly}
+          sortInfoExternal={sortInfo}
       />
     </div>
   );

frontend/src/components/DefinitionViewer.tsx

@@ -0,0 +1,471 @@
+import React, { useState, useEffect } from 'react';
+import Editor from '@monaco-editor/react';
+import { Spin, Alert } from 'antd';
+import { TabData } from '../types';
+import { useStore } from '../store';
+import { DBQuery } from '../../wailsjs/go/app/App';
+
+interface DefinitionViewerProps {
+    tab: TabData;
+}
+
+const DefinitionViewer: React.FC<DefinitionViewerProps> = ({ tab }) => {
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<string | null>(null);
+    const [definition, setDefinition] = useState<string>('');
+
+    const connections = useStore(state => state.connections);
+    const theme = useStore(state => state.theme);
+    const darkMode = theme === 'dark';
+
+    const escapeSQLLiteral = (raw: string): string => String(raw || '').replace(/'/g, "''");
+
+    const getMetadataDialect = (conn: any): string => {
+        const type = String(conn?.config?.type || '').trim().toLowerCase();
+        if (type === 'custom') {
+            const driver = String(conn?.config?.driver || '').trim().toLowerCase();
+            if (driver === 'diros' || driver === 'doris') return 'mysql';
+            return driver;
+        }
+        if (type === 'mariadb' || type === 'diros' || type === 'sphinx') return 'mysql';
+        if (type === 'dameng') return 'dm';
+        return type;
+    };
+
+    const isSphinxConnection = (conn: any): boolean => {
+        const type = String(conn?.config?.type || '').trim().toLowerCase();
+        if (type === 'sphinx') return true;
+        if (type !== 'custom') return false;
+        const driver = String(conn?.config?.driver || '').trim().toLowerCase();
+        return driver === 'sphinx' || driver === 'sphinxql';
+    };
+
+    const parseSchemaAndName = (fullName: string): { schema: string; name: string } => {
+        const raw = String(fullName || '').trim();
+        const idx = raw.lastIndexOf('.');
+        if (idx > 0 && idx < raw.length - 1) {
+            return { schema: raw.substring(0, idx), name: raw.substring(idx + 1) };
+        }
+        return { schema: '', name: raw };
+    };
+
+    const getCaseInsensitiveRawValue = (row: Record<string, any>, candidateKeys: string[]): any => {
+        const keyMap = new Map<string, any>();
+        Object.keys(row || {}).forEach((key) => keyMap.set(key.toLowerCase(), row[key]));
+        for (const key of candidateKeys) {
+            const value = keyMap.get(key.toLowerCase());
+            if (value !== undefined && value !== null) {
+                return value;
+            }
+        }
+        return undefined;
+    };
+
+    const parseDuckDBParameterNames = (raw: any): string[] => {
+        if (Array.isArray(raw)) {
+            return raw
+                .map((item) => String(item ?? '').trim())
+                .filter((item) => item !== '' && item.toLowerCase() !== '<nil>');
+        }
+        const text = String(raw ?? '').trim();
+        if (!text) return [];
+        const normalized = text.startsWith('[') && text.endsWith(']')
+            ? text.slice(1, -1)
+            : text;
+        return normalized
+            .split(',')
+            .map((part) => part.trim())
+            .filter((part) => part !== '' && part.toLowerCase() !== '<nil>');
+    };
+
+    const buildDuckDBMacroDDL = (
+        schemaName: string,
+        functionName: string,
+        parametersRaw: any,
+        macroDefinitionRaw: any
+    ): string => {
+        const schema = String(schemaName || '').trim();
+        const name = String(functionName || '').trim();
+        const macroDefinition = String(macroDefinitionRaw || '').trim();
+        if (!name || !macroDefinition) return '';
+
+        const parameters = parseDuckDBParameterNames(parametersRaw).join(', ');
+        const qualifiedName = schema ? `${schema}.${name}` : name;
+        const isTableMacro = !macroDefinition.startsWith('(');
+        if (isTableMacro) {
+            return `CREATE OR REPLACE MACRO ${qualifiedName}(${parameters}) AS TABLE ${macroDefinition};`;
+        }
+        return `CREATE OR REPLACE MACRO ${qualifiedName}(${parameters}) AS ${macroDefinition};`;
+    };
+
+    const buildShowViewQueries = (dialect: string, viewName: string, dbName: string): string[] => {
+        const { schema, name } = parseSchemaAndName(viewName);
+        const safeName = escapeSQLLiteral(name);
+        const safeDbName = escapeSQLLiteral(dbName);
+
+        switch (dialect) {
+            case 'mysql':
+                return [
+                    `SHOW CREATE VIEW \`${name.replace(/`/g, '``')}\``,
+                    safeDbName
+                        ? `SELECT VIEW_DEFINITION AS view_definition FROM information_schema.views WHERE table_schema = '${safeDbName}' AND table_name = '${safeName}' LIMIT 1`
+                        : '',
+                    `SHOW CREATE TABLE \`${name.replace(/`/g, '``')}\``,
+                ].filter(Boolean);
+            case 'postgres':
+            case 'kingbase':
+            case 'highgo':
+            case 'vastbase': {
+                const schemaRef = schema || 'public';
+                return [`SELECT pg_get_viewdef('${escapeSQLLiteral(schemaRef)}.${safeName}'::regclass, true) AS view_definition`];
+            }
+            case 'sqlserver':
+                return [`SELECT OBJECT_DEFINITION(OBJECT_ID('${escapeSQLLiteral(viewName)}')) AS view_definition`];
+            case 'oracle':
+            case 'dm':
+                if (schema) {
+                    return [`SELECT TEXT AS view_definition FROM ALL_VIEWS WHERE OWNER = '${escapeSQLLiteral(schema).toUpperCase()}' AND VIEW_NAME = '${safeName.toUpperCase()}'`];
+                }
+                if (safeDbName) {
+                    return [`SELECT TEXT AS view_definition FROM ALL_VIEWS WHERE OWNER = '${safeDbName.toUpperCase()}' AND VIEW_NAME = '${safeName.toUpperCase()}'`];
+                }
+                return [`SELECT TEXT AS view_definition FROM USER_VIEWS WHERE VIEW_NAME = '${safeName.toUpperCase()}'`];
+            case 'sqlite':
+                return [`SELECT sql AS view_definition FROM sqlite_master WHERE type='view' AND name='${safeName}'`];
+            case 'duckdb': {
+                const schemaRef = schema || 'main';
+                return [`SELECT view_definition FROM information_schema.views WHERE table_schema = '${escapeSQLLiteral(schemaRef)}' AND table_name = '${safeName}' LIMIT 1`];
+            }
+            default:
+                return [`-- 暂不支持该数据库类型的视图定义查看`];
+        }
+    };
+
+    const buildShowRoutineQueries = (dialect: string, routineName: string, routineType: string, dbName: string): string[] => {
+        const { schema, name } = parseSchemaAndName(routineName);
+        const safeName = escapeSQLLiteral(name);
+        const safeDbName = escapeSQLLiteral(dbName);
+        const upperType = (routineType || 'FUNCTION').toUpperCase();
+
+        switch (dialect) {
+            case 'mysql':
+                return [
+                    `SHOW CREATE ${upperType} \`${name.replace(/`/g, '``')}\``,
+                    safeDbName
+                        ? `SELECT ROUTINE_DEFINITION AS routine_definition, ROUTINE_TYPE AS routine_type FROM information_schema.routines WHERE routine_schema = '${safeDbName}' AND routine_name = '${safeName}' LIMIT 1`
+                        : '',
+                    upperType === 'PROCEDURE'
+                        ? `SHOW PROCEDURE STATUS LIKE '${safeName}'`
+                        : `SHOW FUNCTION STATUS LIKE '${safeName}'`,
+                ].filter(Boolean);
+            case 'postgres':
+            case 'kingbase':
+            case 'highgo':
+            case 'vastbase': {
+                const schemaRef = schema || 'public';
+                return [`SELECT pg_get_functiondef(p.oid) AS routine_definition FROM pg_proc p JOIN pg_namespace n ON p.pronamespace = n.oid WHERE n.nspname = '${escapeSQLLiteral(schemaRef)}' AND p.proname = '${safeName}' LIMIT 1`];
+            }
+            case 'sqlserver':
+                return [`SELECT OBJECT_DEFINITION(OBJECT_ID('${escapeSQLLiteral(routineName)}')) AS routine_definition`];
+            case 'oracle':
+            case 'dm': {
+                const owner = schema ? escapeSQLLiteral(schema).toUpperCase() : (safeDbName ? safeDbName.toUpperCase() : '');
+                if (owner) {
+                    return [`SELECT TEXT FROM ALL_SOURCE WHERE OWNER = '${owner}' AND NAME = '${safeName.toUpperCase()}' AND TYPE = '${upperType}' ORDER BY LINE`];
+                }
+                return [`SELECT TEXT FROM USER_SOURCE WHERE NAME = '${safeName.toUpperCase()}' AND TYPE = '${upperType}' ORDER BY LINE`];
+            }
+            case 'duckdb': {
+                const schemaRef = schema || 'main';
+                const safeSchema = escapeSQLLiteral(schemaRef);
+                return [
+                    `SELECT schema_name, function_name, parameters, macro_definition FROM duckdb_functions() WHERE internal = false AND lower(function_type) = 'macro' AND schema_name = '${safeSchema}' AND function_name = '${safeName}' LIMIT 1`,
+                    `SELECT schema_name, function_name, parameters, macro_definition FROM duckdb_functions() WHERE internal = false AND lower(function_type) = 'macro' AND function_name = '${safeName}' ORDER BY CASE WHEN schema_name = '${safeSchema}' THEN 0 ELSE 1 END, schema_name LIMIT 1`,
+                ];
+            }
+            case 'sqlite':
+                return [`-- SQLite 不支持函数/存储过程定义管理`];
+            default:
+                return [`-- 暂不支持该数据库类型的函数/存储过程定义查看`];
+        }
+    };
+
+    const runQueryCandidates = async (
+        config: Record<string, any>,
+        dbName: string,
+        queries: string[]
+    ): Promise<{ success: boolean; data: any[]; message?: string }> => {
+        let lastMessage = '';
+        let hasSuccessfulQuery = false;
+        for (const query of queries) {
+            const sql = String(query || '').trim();
+            if (!sql) continue;
+            try {
+                const result = await DBQuery(config as any, dbName, sql);
+                if (!result.success || !Array.isArray(result.data)) {
+                    lastMessage = result.message || lastMessage;
+                    continue;
+                }
+                hasSuccessfulQuery = true;
+                if (result.data.length > 0) {
+                    return { success: true, data: result.data };
+                }
+            } catch (error: any) {
+                lastMessage = error?.message || String(error);
+            }
+        }
+        if (hasSuccessfulQuery) {
+            return { success: true, data: [] };
+        }
+        return { success: false, data: [], message: lastMessage };
+    };
+
+    const getVersionHint = async (config: Record<string, any>, dbName: string): Promise<string> => {
+        const candidates = [
+            `SELECT VERSION() AS version`,
+            `SHOW VARIABLES LIKE 'version'`,
+        ];
+        for (const query of candidates) {
+            try {
+                const result = await DBQuery(config as any, dbName, query);
+                if (!result.success || !Array.isArray(result.data) || result.data.length === 0) {
+                    continue;
+                }
+                const row = result.data[0] as Record<string, any>;
+                const version =
+                    row.version
+                    || row.VERSION
+                    || row.Value
+                    || row.value
+                    || Object.values(row)[1]
+                    || Object.values(row)[0];
+                const text = String(version || '').trim();
+                if (text) return text;
+            } catch {
+                // ignore
+            }
+        }
+        return '';
+    };
+
+    const extractViewDefinition = (dialect: string, data: any[]): string => {
+        if (!data || data.length === 0) return '-- 未找到视图定义';
+        const row = data[0];
+
+        switch (dialect) {
+            case 'mysql': {
+                const keys = Object.keys(row);
+                const textDefinition = row.view_definition || row.VIEW_DEFINITION;
+                if (textDefinition) return String(textDefinition);
+                const sqlKey = keys.find(k => k.toLowerCase().includes('create view') || k.toLowerCase() === 'create view');
+                if (sqlKey) return row[sqlKey];
+                const tableSqlKey = keys.find(k => k.toLowerCase().includes('create table'));
+                if (tableSqlKey) return row[tableSqlKey];
+                for (const key of keys) {
+                    const val = String(row[key] || '');
+                    if (val.toUpperCase().includes('CREATE') && (val.toUpperCase().includes('VIEW') || val.toUpperCase().includes('TABLE'))) {
+                        return val;
+                    }
+                }
+                return JSON.stringify(row, null, 2);
+            }
+            case 'oracle':
+            case 'dm':
+                return row.view_definition || row.VIEW_DEFINITION || row.text || row.TEXT || Object.values(row)[0] || '';
+            default:
+                return row.view_definition || row.VIEW_DEFINITION || row.sql || row.SQL || Object.values(row)[0] || '';
+        }
+    };
+
+    const extractRoutineDefinition = (dialect: string, data: any[]): string => {
+        if (!data || data.length === 0) return '-- 未找到函数/存储过程定义';
+
+        switch (dialect) {
+            case 'mysql': {
+                const row = data[0];
+                const keys = Object.keys(row);
+                if (row.routine_definition || row.ROUTINE_DEFINITION) {
+                    return String(row.routine_definition || row.ROUTINE_DEFINITION);
+                }
+                const sqlKey = keys.find(k => k.toLowerCase().includes('create function') || k.toLowerCase().includes('create procedure'));
+                if (sqlKey) return row[sqlKey];
+                for (const key of keys) {
+                    const val = String(row[key] || '');
+                    if (val.toUpperCase().includes('CREATE') && (val.toUpperCase().includes('FUNCTION') || val.toUpperCase().includes('PROCEDURE'))) {
+                        return val;
+                    }
+                }
+                const routineName = String(row.Name || row.name || '').trim();
+                if (routineName) {
+                    const routineType = String(row.Type || row.type || row.ROUTINE_TYPE || row.routine_type || 'FUNCTION').trim().toUpperCase();
+                    return `-- 当前数据源未返回可执行定义文本，已返回元数据\n-- 名称: ${routineName}\n-- 类型: ${routineType}\n${JSON.stringify(row, null, 2)}`;
+                }
+                return JSON.stringify(row, null, 2);
+            }
+            case 'oracle':
+            case 'dm': {
+                // Oracle/DM ALL_SOURCE returns multiple rows, one per line
+                return data.map(row => row.text || row.TEXT || Object.values(row)[0] || '').join('');
+            }
+            case 'duckdb': {
+                const row = data[0] as Record<string, any>;
+                const ddl = buildDuckDBMacroDDL(
+                    String(getCaseInsensitiveRawValue(row, ['schema_name']) || '').trim(),
+                    String(getCaseInsensitiveRawValue(row, ['function_name', 'routine_name', 'name']) || '').trim(),
+                    getCaseInsensitiveRawValue(row, ['parameters']),
+                    getCaseInsensitiveRawValue(row, ['macro_definition'])
+                );
+                if (ddl) return ddl;
+                const fallback = getCaseInsensitiveRawValue(row, ['macro_definition', 'routine_definition', 'definition']);
+                if (fallback !== undefined && fallback !== null && String(fallback).trim() !== '') {
+                    return String(fallback);
+                }
+                return JSON.stringify(row, null, 2);
+            }
+            default: {
+                const row = data[0];
+                return row.routine_definition || row.ROUTINE_DEFINITION || Object.values(row)[0] || '';
+            }
+        }
+    };
+
+    useEffect(() => {
+        const loadDefinition = async () => {
+            setLoading(true);
+            setError(null);
+
+            const conn = connections.find(c => c.id === tab.connectionId);
+            if (!conn) {
+                setError('未找到数据库连接');
+                setLoading(false);
+                return;
+            }
+
+            const dbName = tab.dbName || '';
+            const dialect = getMetadataDialect(conn);
+            const sphinxLike = isSphinxConnection(conn) && dialect === 'mysql';
+
+            let queries: string[];
+            let extractFn: (dialect: string, data: any[]) => string;
+            let objectLabel: string;
+
+            if (tab.type === 'view-def') {
+                const viewName = tab.viewName || '';
+                if (!viewName) {
+                    setError('视图名称为空');
+                    setLoading(false);
+                    return;
+                }
+                queries = buildShowViewQueries(dialect, viewName, dbName);
+                extractFn = extractViewDefinition;
+                objectLabel = '视图';
+            } else {
+                const routineName = tab.routineName || '';
+                const routineType = tab.routineType || 'FUNCTION';
+                if (!routineName) {
+                    setError('函数/存储过程名称为空');
+                    setLoading(false);
+                    return;
+                }
+                queries = buildShowRoutineQueries(dialect, routineName, routineType, dbName);
+                extractFn = extractRoutineDefinition;
+                objectLabel = '函数/存储过程';
+            }
+
+            if (!queries.length || String(queries[0] || '').startsWith('--')) {
+                setDefinition(String(queries[0] || '-- 暂不支持该对象定义查看'));
+                setLoading(false);
+                return;
+            }
+
+            try {
+                const config = {
+                    ...conn.config,
+                    port: Number(conn.config.port),
+                    password: conn.config.password || '',
+                    database: conn.config.database || '',
+                    useSSH: conn.config.useSSH || false,
+                    ssh: conn.config.ssh || { host: '', port: 22, user: '', password: '', keyPath: '' }
+                };
+
+                const result = await runQueryCandidates(config, dbName, queries);
+
+                if (result.success && Array.isArray(result.data) && result.data.length > 0) {
+                    const def = extractFn(dialect, result.data);
+                    setDefinition(def);
+                    return;
+                }
+
+                if (result.success) {
+                    if (sphinxLike) {
+                        const version = await getVersionHint(config, dbName);
+                        const versionText = version ? `（版本: ${version}）` : '';
+                        setDefinition(`-- 当前 Sphinx 实例${versionText}未返回${objectLabel}定义。\n-- 已执行多套兼容查询，可能是版本能力限制或对象类型不支持。`);
+                        return;
+                    }
+                    setDefinition(`-- 未找到${objectLabel}定义`);
+                } else if (sphinxLike) {
+                    const version = await getVersionHint(config, dbName);
+                    const versionText = version ? `（版本: ${version}）` : '';
+                    setDefinition(`-- 当前 Sphinx 实例${versionText}不支持${objectLabel}定义查询。\n-- 已自动尝试兼容语句，返回失败信息: ${result.message || 'unknown error'}`);
+                } else {
+                    setError(result.message || '查询定义失败');
+                }
+            } catch (e: any) {
+                setError('查询定义失败: ' + (e?.message || String(e)));
+            } finally {
+                setLoading(false);
+            }
+        };
+
+        loadDefinition();
+    }, [tab.connectionId, tab.dbName, tab.viewName, tab.routineName, tab.routineType, tab.type, connections]);
+
+    const objectLabel = tab.type === 'view-def' ? '视图' : '函数/存储过程';
+    const objectName = tab.type === 'view-def' ? tab.viewName : tab.routineName;
+
+    if (loading) {
+        return (
+            <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100%' }}>
+                <Spin tip={`加载${objectLabel}定义...`} />
+            </div>
+        );
+    }
+
+    if (error) {
+        return (
+            <div style={{ padding: 16 }}>
+                <Alert type="error" message="加载失败" description={error} showIcon />
+            </div>
+        );
+    }
+
+    return (
+        <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
+            <div style={{ padding: '8px 16px', borderBottom: darkMode ? '1px solid #303030' : '1px solid #f0f0f0' }}>
+                <strong>{objectLabel}: </strong>{objectName}
+                {tab.dbName && <span style={{ marginLeft: 16, color: '#888' }}>数据库: {tab.dbName}</span>}
+                {tab.routineType && <span style={{ marginLeft: 16, color: '#888' }}>类型: {tab.routineType}</span>}
+            </div>
+            <div style={{ flex: 1, minHeight: 0 }}>
+                <Editor
+                    height="100%"
+                    language="sql"
+                    theme={darkMode ? 'transparent-dark' : 'transparent-light'}
+                    value={definition}
+                    options={{
+                        readOnly: true,
+                        minimap: { enabled: false },
+                        fontSize: 14,
+                        lineNumbers: 'on',
+                        scrollBeyondLastLine: false,
+                        wordWrap: 'on',
+                        automaticLayout: true,
+                    }}
+                />
+            </div>
+        </div>
+    );
+};
+
+export default DefinitionViewer;

frontend/src/components/DriverManagerModal.tsx

@@ -0,0 +1,299 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { Button, Modal, Progress, Space, Table, Tag, Typography, message } from 'antd';
+import { DeleteOutlined, DownloadOutlined, ReloadOutlined } from '@ant-design/icons';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
+import {
+  DownloadDriverPackage,
+  GetDriverStatusList,
+  RemoveDriverPackage,
+} from '../../wailsjs/go/app/App';
+
+const { Text } = Typography;
+
+type DriverStatusRow = {
+  type: string;
+  name: string;
+  builtIn: boolean;
+  packageSizeText?: string;
+  runtimeAvailable: boolean;
+  packageInstalled: boolean;
+  connectable: boolean;
+  defaultDownloadUrl?: string;
+  message?: string;
+};
+
+type DriverProgressEvent = {
+  driverType?: string;
+  status?: 'start' | 'downloading' | 'done' | 'error';
+  message?: string;
+  percent?: number;
+};
+
+type ProgressState = {
+  status: 'start' | 'downloading' | 'done' | 'error';
+  message: string;
+  percent: number;
+};
+
+const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({ open, onClose }) => {
+  const [loading, setLoading] = useState(false);
+  const [downloadDir, setDownloadDir] = useState('');
+  const [rows, setRows] = useState<DriverStatusRow[]>([]);
+  const [actionDriver, setActionDriver] = useState('');
+  const [progressMap, setProgressMap] = useState<Record<string, ProgressState>>({});
+
+  const refreshStatus = useCallback(async (toastOnError = true) => {
+    setLoading(true);
+    try {
+      const res = await GetDriverStatusList(downloadDir, '');
+      if (!res?.success) {
+        if (toastOnError) {
+          message.error(res?.message || '拉取驱动状态失败');
+        }
+        return;
+      }
+
+      const data = (res?.data || {}) as any;
+      const resolvedDir = String(data.downloadDir || '').trim();
+      const drivers = Array.isArray(data.drivers) ? data.drivers : [];
+
+      if (resolvedDir) {
+        setDownloadDir(resolvedDir);
+      }
+
+      const nextRows: DriverStatusRow[] = drivers.map((item: any) => ({
+        type: String(item.type || '').trim(),
+        name: String(item.name || item.type || '').trim(),
+        builtIn: !!item.builtIn,
+        packageSizeText: String(item.packageSizeText || '').trim() || undefined,
+        runtimeAvailable: !!item.runtimeAvailable,
+        packageInstalled: !!item.packageInstalled,
+        connectable: !!item.connectable,
+        defaultDownloadUrl: String(item.defaultDownloadUrl || '').trim() || undefined,
+        message: String(item.message || '').trim() || undefined,
+      }));
+      setRows(nextRows);
+    } catch (err: any) {
+      if (toastOnError) {
+        message.error(`拉取驱动状态失败：${err?.message || String(err)}`);
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [downloadDir]);
+
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    refreshStatus(false);
+  }, [open, refreshStatus]);
+
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    const off = EventsOn('driver:download-progress', (event: DriverProgressEvent) => {
+      if (!event) {
+        return;
+      }
+      const driverType = String(event.driverType || '').trim().toLowerCase();
+      const status = event.status;
+      if (!driverType || !status) {
+        return;
+      }
+      const messageText = String(event.message || '').trim();
+      const percent = Math.max(0, Math.min(100, Number(event.percent || 0)));
+      setProgressMap((prev) => ({
+        ...prev,
+        [driverType]: {
+          status,
+          message: messageText,
+          percent,
+        },
+      }));
+    });
+    return () => {
+      off();
+    };
+  }, [open]);
+
+  const installDriver = useCallback(async (row: DriverStatusRow) => {
+    setActionDriver(row.type);
+    setProgressMap((prev) => ({
+      ...prev,
+      [row.type]: {
+        status: 'start',
+        message: '开始安装',
+        percent: 0,
+      },
+    }));
+    try {
+      const result = await DownloadDriverPackage(row.type, '', downloadDir);
+      if (!result?.success) {
+        message.error(result?.message || `安装 ${row.name} 失败`);
+        return;
+      }
+      message.success(`${row.name} 已安装启用`);
+      refreshStatus(false);
+    } finally {
+      setActionDriver('');
+    }
+  }, [downloadDir, refreshStatus]);
+
+  const removeDriver = useCallback(async (row: DriverStatusRow) => {
+    setActionDriver(row.type);
+    try {
+      const result = await RemoveDriverPackage(row.type, downloadDir);
+      if (!result?.success) {
+        message.error(result?.message || `移除 ${row.name} 失败`);
+        return;
+      }
+      message.success(`${row.name} 已移除`);
+      setProgressMap((prev) => {
+        const next = { ...prev };
+        delete next[row.type];
+        return next;
+      });
+      refreshStatus(false);
+    } finally {
+      setActionDriver('');
+    }
+  }, [downloadDir, refreshStatus]);
+
+  const columns = useMemo(() => {
+    return [
+      {
+        title: '数据源',
+        dataIndex: 'name',
+        key: 'name',
+        width: 150,
+      },
+      {
+        title: '安装包大小',
+        dataIndex: 'packageSizeText',
+        key: 'packageSizeText',
+        width: 120,
+        render: (_: string | undefined, row: DriverStatusRow) => row.packageSizeText || '-',
+      },
+      {
+        title: '状态',
+        key: 'status',
+        width: 140,
+        render: (_: string, row: DriverStatusRow) => {
+          if (row.builtIn) {
+            return <Tag color="success">内置可用</Tag>;
+          }
+          const progress = progressMap[row.type];
+          if (progress && (progress.status === 'start' || progress.status === 'downloading')) {
+            return <Tag color="processing">安装中 {Math.round(progress.percent)}%</Tag>;
+          }
+          if (row.connectable) {
+            return <Tag color="success">已启用</Tag>;
+          }
+          if (row.packageInstalled) {
+            return <Tag color="warning">已安装</Tag>;
+          }
+          return <Tag color="default">未启用</Tag>;
+        },
+      },
+      {
+        title: '安装进度',
+        key: 'progress',
+        width: 170,
+        render: (_: string, row: DriverStatusRow) => {
+          if (row.builtIn) {
+            return <Text type="secondary">-</Text>;
+          }
+
+          const progress = progressMap[row.type];
+          let percent = 0;
+          let status: 'normal' | 'exception' | 'active' | 'success' = 'normal';
+
+          if (progress?.status === 'error') {
+            percent = Math.max(0, Math.min(100, Math.round(progress.percent || 0)));
+            status = 'exception';
+          } else if (progress && (progress.status === 'start' || progress.status === 'downloading')) {
+            percent = Math.max(1, Math.min(99, Math.round(progress.percent || 0)));
+            status = 'active';
+          } else if (row.connectable || row.packageInstalled) {
+            percent = 100;
+            status = 'success';
+          }
+
+          return <Progress percent={percent} status={status} size="small" />;
+        },
+      },
+      {
+        title: '操作',
+        key: 'actions',
+        width: 190,
+        render: (_: string, row: DriverStatusRow) => {
+          if (row.builtIn) {
+            return <Text type="secondary">-</Text>;
+          }
+          const isSlimBuildUnavailable = (row.message || '').includes('精简构建');
+          const loadingAction = actionDriver === row.type;
+          if (isSlimBuildUnavailable && !row.packageInstalled) {
+            return <Text type="secondary">需 Full 版</Text>;
+          }
+          if (row.connectable) {
+            return (
+              <Button
+                danger
+                icon={<DeleteOutlined />}
+                loading={loadingAction}
+                onClick={() => removeDriver(row)}
+              >
+                移除
+              </Button>
+            );
+          }
+          return (
+            <Button
+              type="primary"
+              icon={<DownloadOutlined />}
+              loading={loadingAction}
+              onClick={() => installDriver(row)}
+            >
+              安装启用
+            </Button>
+          );
+        },
+      },
+    ];
+  }, [actionDriver, installDriver, progressMap, removeDriver]);
+
+  return (
+    <Modal
+      title="驱动管理"
+      open={open}
+      onCancel={onClose}
+      width={980}
+      destroyOnClose
+      footer={[
+        <Button key="refresh" icon={<ReloadOutlined />} onClick={() => refreshStatus(true)} loading={loading}>
+          刷新
+        </Button>,
+        <Button key="close" type="primary" onClick={onClose}>
+          关闭
+        </Button>,
+      ]}
+    >
+      <Space direction="vertical" size={12} style={{ width: '100%' }}>
+        <Text type="secondary">除 MySQL / Redis / Oracle / PostgreSQL 外，其他数据源需先安装启用后再连接。</Text>
+
+        <Table
+          rowKey="type"
+          loading={loading}
+          columns={columns as any}
+          dataSource={rows}
+          pagination={false}
+          size="middle"
+        />
+      </Space>
+    </Modal>
+  );
+};
+
+export default DriverManagerModal;

frontend/src/components/ImportPreviewModal.tsx

@@ -0,0 +1,250 @@
+import React, { useState, useEffect } from 'react';
+import { Modal, Table, Alert, Progress, Button, Space } from 'antd';
+import { CheckCircleOutlined, CloseCircleOutlined } from '@ant-design/icons';
+import { PreviewImportFile, ImportDataWithProgress } from '../../wailsjs/go/app/App';
+import { EventsOn, EventsOff } from '../../wailsjs/runtime/runtime';
+import { useStore } from '../store';
+
+interface ImportPreviewModalProps {
+    visible: boolean;
+    filePath: string;
+    connectionId: string;
+    dbName: string;
+    tableName: string;
+    onClose: () => void;
+    onSuccess: () => void;
+}
+
+interface PreviewData {
+    columns: string[];
+    totalRows: number;
+    previewRows: any[];
+}
+
+interface ImportProgress {
+    current: number;
+    total: number;
+    success: number;
+    errors: number;
+}
+
+const ImportPreviewModal: React.FC<ImportPreviewModalProps> = ({
+    visible,
+    filePath,
+    connectionId,
+    dbName,
+    tableName,
+    onClose,
+    onSuccess
+}) => {
+    const connections = useStore(state => state.connections);
+    const [loading, setLoading] = useState(true);
+    const [previewData, setPreviewData] = useState<PreviewData | null>(null);
+    const [error, setError] = useState<string | null>(null);
+    const [importing, setImporting] = useState(false);
+    const [progress, setProgress] = useState<ImportProgress | null>(null);
+    const [importResult, setImportResult] = useState<any>(null);
+
+    useEffect(() => {
+        if (visible && filePath) {
+            loadPreview();
+        }
+    }, [visible, filePath]);
+
+    useEffect(() => {
+        if (importing) {
+            const unsubscribe = EventsOn('import:progress', (data: ImportProgress) => {
+                setProgress(data);
+            });
+            return () => {
+                EventsOff('import:progress');
+            };
+        }
+    }, [importing]);
+
+    const loadPreview = async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const res = await PreviewImportFile(filePath);
+            if (res.success && res.data) {
+                setPreviewData({
+                    columns: res.data.columns || [],
+                    totalRows: res.data.totalRows || 0,
+                    previewRows: res.data.previewRows || []
+                });
+            } else {
+                setError(res.message || '预览失败');
+            }
+        } catch (e: any) {
+            setError('预览失败: ' + e.message);
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    const handleImport = async () => {
+        if (!previewData) return;
+
+        setImporting(true);
+        setProgress({ current: 0, total: previewData.totalRows, success: 0, errors: 0 });
+        setImportResult(null);
+
+        try {
+            const conn = connections.find(c => c.id === connectionId);
+            if (!conn) {
+                setError('连接配置未找到');
+                setImporting(false);
+                return;
+            }
+
+            const config = {
+                ...conn.config,
+                port: Number(conn.config.port),
+                password: conn.config.password || '',
+                database: conn.config.database || '',
+                useSSH: conn.config.useSSH || false,
+                ssh: conn.config.ssh || { host: '', port: 22, user: '', password: '', keyPath: '' }
+            };
+
+            const res = await ImportDataWithProgress(config as any, dbName, tableName, filePath);
+
+            if (res.success && res.data) {
+                setImportResult(res.data);
+                if (res.data.failed === 0) {
+                    onSuccess();
+                }
+            } else {
+                setError(res.message || '导入失败');
+            }
+        } catch (e: any) {
+            setError('导入失败: ' + e.message);
+        } finally {
+            setImporting(false);
+        }
+    };
+
+    const columns = previewData?.columns.map(col => ({
+        title: col,
+        dataIndex: col,
+        key: col,
+        ellipsis: true,
+        width: 150
+    })) || [];
+
+    const progressPercent = progress ? Math.round((progress.current / progress.total) * 100) : 0;
+
+    return (
+        <Modal
+            title="导入数据预览"
+            open={visible}
+            onCancel={onClose}
+            width={900}
+            footer={
+                importResult ? (
+                    <Space>
+                        <Button onClick={onClose}>关闭</Button>
+                    </Space>
+                ) : importing ? null : (
+                    <Space>
+                        <Button onClick={onClose}>取消</Button>
+                        <Button
+                            type="primary"
+                            onClick={handleImport}
+                            disabled={!previewData || loading}
+                        >
+                            开始导入
+                        </Button>
+                    </Space>
+                )
+            }
+        >
+            {error && <Alert type="error" message={error} style={{ marginBottom: 16 }} showIcon />}
+
+            {loading && <div style={{ textAlign: 'center', padding: 40 }}>加载预览数据...</div>}
+
+            {!loading && previewData && !importing && !importResult && (
+                <>
+                    <Alert
+                        type="info"
+                        message={`共 ${previewData.totalRows} 行数据，${previewData.columns.length} 个字段`}
+                        description='以下是前 5 行预览数据，确认无误后点击“开始导入”'
+                        style={{ marginBottom: 16 }}
+                        showIcon
+                    />
+                    <div style={{ marginBottom: 8, fontWeight: 600 }}>字段列表：</div>
+                    <div style={{ marginBottom: 16, padding: 8, background: '#f5f5f5', borderRadius: 4 }}>
+                        {previewData.columns.join(', ')}
+                    </div>
+                    <div style={{ marginBottom: 8, fontWeight: 600 }}>数据预览（前 5 行）：</div>
+                    <Table
+                        dataSource={previewData.previewRows}
+                        columns={columns}
+                        pagination={false}
+                        scroll={{ x: 'max-content' }}
+                        size="small"
+                        bordered
+                    />
+                </>
+            )}
+
+            {importing && progress && (
+                <div style={{ padding: '40px 20px' }}>
+                    <div style={{ marginBottom: 16, fontSize: 16, fontWeight: 600, textAlign: 'center' }}>
+                        正在导入数据...
+                    </div>
+                    <Progress percent={progressPercent} status="active" />
+                    <div style={{ marginTop: 16, textAlign: 'center', color: '#666' }}>
+                        已处理 {progress.current} / {progress.total} 行
+                        <span style={{ marginLeft: 16, color: '#52c41a' }}>
+                            <CheckCircleOutlined /> 成功 {progress.success}
+                        </span>
+                        {progress.errors > 0 && (
+                            <span style={{ marginLeft: 16, color: '#ff4d4f' }}>
+                                <CloseCircleOutlined /> 失败 {progress.errors}
+                            </span>
+                        )}
+                    </div>
+                </div>
+            )}
+
+            {importResult && (
+                <div style={{ padding: 20 }}>
+                    <Alert
+                        type={importResult.failed === 0 ? 'success' : 'warning'}
+                        message="导入完成"
+                        description={
+                            <div>
+                                <div>成功导入 {importResult.success} 行</div>
+                                {importResult.failed > 0 && <div>失败 {importResult.failed} 行</div>}
+                            </div>
+                        }
+                        showIcon
+                        style={{ marginBottom: 16 }}
+                    />
+                    {importResult.errorLogs && importResult.errorLogs.length > 0 && (
+                        <>
+                            <div style={{ marginBottom: 8, fontWeight: 600, color: '#ff4d4f' }}>错误日志：</div>
+                            <div style={{
+                                maxHeight: 300,
+                                overflow: 'auto',
+                                background: '#fff1f0',
+                                border: '1px solid #ffccc7',
+                                borderRadius: 4,
+                                padding: 12,
+                                fontSize: 12,
+                                fontFamily: 'monospace'
+                            }}>
+                                {importResult.errorLogs.map((log: string, idx: number) => (
+                                    <div key={idx} style={{ marginBottom: 4 }}>{log}</div>
+                                ))}
+                            </div>
+                        </>
+                    )}
+                </div>
+            )}
+        </Modal>
+    );
+};
+
+export default ImportPreviewModal;

frontend/src/components/LogPanel.tsx

@@ -2,6 +2,7 @@ import React, { useRef, useEffect } from 'react';
 import { Table, Tag, Button, Tooltip } from 'antd';
 import { ClearOutlined, CloseOutlined, CaretRightOutlined, BugOutlined } from '@ant-design/icons';
 import { useStore } from '../store';
+import { normalizeOpacityForPlatform } from '../utils/appearance';
 
 interface LogPanelProps {
     height: number;
@@ -15,18 +16,21 @@ const LogPanel: React.FC<LogPanelProps> = ({ height, onClose, onResizeStart }) =
     const theme = useStore(state => state.theme);
     const appearance = useStore(state => state.appearance);
     const darkMode = theme === 'dark';
+    const opacity = normalizeOpacityForPlatform(appearance.opacity);
 
     // Background Helper
     const getBg = (darkHex: string) => {
-        if (!darkMode) return `rgba(255, 255, 255, ${appearance.opacity ?? 0.95})`;
+        if (!darkMode) return `rgba(255, 255, 255, ${opacity})`;
         const hex = darkHex.replace('#', '');
         const r = parseInt(hex.substring(0, 2), 16);
         const g = parseInt(hex.substring(2, 4), 16);
         const b = parseInt(hex.substring(4, 6), 16);
-        return `rgba(${r}, ${g}, ${b}, ${appearance.opacity ?? 0.95})`;
+        return `rgba(${r}, ${g}, ${b}, ${opacity})`;
     };
     const bgMain = getBg('#1f1f1f');
     const bgToolbar = getBg('#2a2a2a');
+    const logScrollbarThumb = darkMode ? 'rgba(255, 255, 255, 0.34)' : 'rgba(0, 0, 0, 0.26)';
+    const logScrollbarThumbHover = darkMode ? 'rgba(255, 255, 255, 0.5)' : 'rgba(0, 0, 0, 0.36)';
 
     const columns = [
         {
@@ -69,7 +73,6 @@ const LogPanel: React.FC<LogPanelProps> = ({ height, onClose, onResizeStart }) =
             height, 
             borderTop: 'none', 
             background: bgMain,
-            backdropFilter: `blur(${appearance.blur ?? 0}px)`,
             display: 'flex',
             flexDirection: 'column',
             position: 'relative',
@@ -112,8 +115,9 @@ const LogPanel: React.FC<LogPanelProps> = ({ height, onClose, onResizeStart }) =
             </div>
 
             {/* List */}
-            <div style={{ flex: 1, overflow: 'auto' }}>
+            <div className="log-panel-scroll" style={{ flex: 1, overflow: 'auto' }}>
                 <Table 
+                    className="log-panel-table"
                     dataSource={sqlLogs} 
                     columns={columns} 
                     size="small" 
@@ -123,6 +127,35 @@ const LogPanel: React.FC<LogPanelProps> = ({ height, onClose, onResizeStart }) =
                     // scroll={{ y: height - 32 }} // Let flex handle it
                 />
             </div>
+            <style>{`
+                .log-panel-scroll {
+                    scrollbar-width: thin;
+                    scrollbar-color: ${logScrollbarThumb} transparent;
+                }
+                .log-panel-scroll::-webkit-scrollbar {
+                    width: 10px;
+                    height: 10px;
+                }
+                .log-panel-scroll::-webkit-scrollbar-track,
+                .log-panel-scroll::-webkit-scrollbar-corner {
+                    background: transparent;
+                }
+                .log-panel-scroll::-webkit-scrollbar-thumb {
+                    background: ${logScrollbarThumb};
+                    border-radius: 8px;
+                    border: 2px solid transparent;
+                    background-clip: padding-box;
+                }
+                .log-panel-scroll::-webkit-scrollbar-thumb:hover {
+                    background: ${logScrollbarThumbHover};
+                    background-clip: padding-box;
+                }
+                .log-panel-table .ant-table,
+                .log-panel-table .ant-table-container,
+                .log-panel-table .ant-table-tbody > tr > td {
+                    background: transparent !important;
+                }
+            `}</style>
         </div>
     );
 };

frontend/src/components/QueryEditor.tsx

@@ -196,6 +196,9 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
       editorRef.current = editor;
       monacoRef.current = monaco;
 
+      // 应用透明主题（主题已在 main.tsx 全局注册）
+      monaco.editor.setTheme(darkMode ? 'transparent-dark' : 'transparent-light');
+
       monaco.languages.registerCompletionItemProvider('sql', {
           triggerCharacters: ['.'],
           provideCompletionItems: async (model: any, position: any) => {
@@ -919,7 +922,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
 
   const applyAutoLimit = (sql: string, dbType: string, maxRows: number): { sql: string; applied: boolean; maxRows: number } => {
       const normalizedType = (dbType || 'mysql').toLowerCase();
-      const supportsLimit = normalizedType === 'mysql' || normalizedType === 'postgres' || normalizedType === 'kingbase' || normalizedType === 'sqlite' || normalizedType === '';
+      const supportsLimit = normalizedType === 'mysql' || normalizedType === 'mariadb' || normalizedType === 'diros' || normalizedType === 'sphinx' || normalizedType === 'postgres' || normalizedType === 'kingbase' || normalizedType === 'sqlite' || normalizedType === 'duckdb' || normalizedType === 'tdengine' || normalizedType === '';
       if (!supportsLimit) return { sql, applied: false, maxRows };
       if (!Number.isFinite(maxRows) || maxRows <= 0) return { sql, applied: false, maxRows };
 
@@ -997,6 +1000,8 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
         const nextResultSets: ResultSet[] = [];
         const maxRows = Number(queryOptions?.maxRows) || 0;
         const dbType = String((config as any).type || 'mysql');
+        const normalizedDbType = dbType.toLowerCase();
+        const forceReadOnlyResult = normalizedDbType === 'tdengine';
         const wantsLimitProbe = Number.isFinite(maxRows) && maxRows > 0;
         const probeLimit = wantsLimitProbe ? (maxRows + 1) : 0;
         let anyTruncated = false;
@@ -1053,7 +1058,9 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
                 const tableMatch = rawStatement.match(/^\s*SELECT\s+\*\s+FROM\s+[`"]?(\w+)[`"]?\s*(?:WHERE.*)?(?:ORDER BY.*)?(?:LIMIT.*)?$/i);
                 if (tableMatch) {
                     simpleTableName = tableMatch[1];
-                    pendingPk.push({ resultKey: `result-${idx + 1}`, tableName: simpleTableName });
+                    if (!forceReadOnlyResult) {
+                        pendingPk.push({ resultKey: `result-${idx + 1}`, tableName: simpleTableName });
+                    }
                 }
 
                 nextResultSets.push({
@@ -1207,7 +1214,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
           transition: none !important;
         }
       `}</style>
-      <div style={{ padding: '8px', borderBottom: '1px solid #eee', display: 'flex', gap: '8px', flexShrink: 0, alignItems: 'center' }}>
+      <div style={{ padding: '8px', display: 'flex', gap: '8px', flexShrink: 0, alignItems: 'center' }}>
         <Select 
             style={{ width: 150 }} 
             placeholder="选择连接"
@@ -1261,11 +1268,11 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
         </Button.Group>
       </div>
       
-      <div style={{ height: editorHeight, minHeight: '100px', borderBottom: '1px solid #eee' }}>
+      <div style={{ height: editorHeight, minHeight: '100px' }}>
         <Editor 
           height="100%" 
           defaultLanguage="sql" 
-          theme={darkMode ? "vs-dark" : "light"}
+          theme={darkMode ? "transparent-dark" : "transparent-light"}
           value={query} 
           onChange={(val) => setQuery(val || '')}
           onMount={handleEditorDidMount}
@@ -1283,7 +1290,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
         style={{ 
             height: '5px', 
             cursor: 'row-resize', 
-            background: darkMode ? '#333' : '#f0f0f0',
+            background: darkMode ? 'rgba(255,255,255,0.08)' : 'rgba(0,0,0,0.04)',
             flexShrink: 0,
             zIndex: 10 
         }} 

frontend/src/components/RedisViewer.tsx

@@ -1,13 +1,20 @@
-import React, { useState, useEffect, useCallback, useRef } from 'react';
-import { Table, Input, Button, Space, Tag, message, Modal, Form, InputNumber, Popconfirm, Tooltip, Radio } from 'antd';
-import { ReloadOutlined, DeleteOutlined, PlusOutlined, EditOutlined, SearchOutlined, ClockCircleOutlined, CopyOutlined } from '@ant-design/icons';
+import React, { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { Table, Input, Button, Space, Tag, Tree, Spin, message, Modal, Form, InputNumber, Popconfirm, Tooltip, Radio } from 'antd';
+import { ReloadOutlined, DeleteOutlined, PlusOutlined, EditOutlined, SearchOutlined, ClockCircleOutlined, CopyOutlined, FolderOpenOutlined, KeyOutlined } from '@ant-design/icons';
 import { useStore } from '../store';
-import { RedisKeyInfo, RedisValue } from '../types';
+import { RedisKeyInfo, RedisValue, StreamEntry } from '../types';
 import Editor from '@monaco-editor/react';
-import type { ColumnType } from 'antd/es/table';
+import type { DataNode } from 'antd/es/tree';
 
 const { Search } = Input;
 
+const KEY_GROUP_DELIMITER = ':';
+const EMPTY_SEGMENT_LABEL = '(empty)';
+const REDIS_TREE_KEY_TYPE_WIDTH = 92;
+const REDIS_TREE_KEY_TYPE_WIDTH_NARROW = 84;
+const REDIS_TREE_KEY_TTL_WIDTH = 92;
+const REDIS_TREE_HIDE_TTL_THRESHOLD = 460;
+
 interface RedisViewerProps {
     connectionId: string;
     redisDB: number;
@@ -222,86 +229,186 @@ const ResizableDivider: React.FC<{
 };
 
 // 可拖拽列头组件 - 纯 DOM 操作实现
-const ResizableTitle: React.FC<any> = (props) => {
-    const { onResize, width, children, ...restProps } = props;
-    const thRef = useRef<HTMLTableCellElement>(null);
+type RedisKeyTreeLeaf = {
+    keyInfo: RedisKeyInfo;
+    label: string;
+};
 
-    // 如果没有 onResize 或 width，说明这列不需要拖拽（如复选框列）
-    if (!onResize || !width) {
-        return <th {...restProps}>{children}</th>;
-    }
+type RedisKeyTreeGroup = {
+    name: string;
+    path: string;
+    children: Map<string, RedisKeyTreeGroup>;
+    leaves: RedisKeyTreeLeaf[];
+};
 
-    const handleMouseDown = (e: React.MouseEvent) => {
-        e.stopPropagation();
-        e.preventDefault();
+type RedisKeyTreeResult = {
+    treeData: DataNode[];
+    rawKeyByNodeKey: Map<string, string>;
+    leafNodeKeyByRawKey: Map<string, string>;
+    groupKeys: string[];
+};
 
-        const startX = e.clientX;
-        const startWidth = width;
-        const th = thRef.current;
-        if (!th) return;
+const normalizeKeySegment = (segment: string): string => {
+    return segment === '' ? EMPTY_SEGMENT_LABEL : segment;
+};
 
-        // 找到对应的 colgroup col 元素来同步更新列宽
-        const table = th.closest('table');
-        const thIndex = Array.from(th.parentElement?.children || []).indexOf(th);
-        const col = table?.querySelector(`colgroup col:nth-child(${thIndex + 1})`) as HTMLElement | null;
+const createTreeGroup = (name: string, path: string): RedisKeyTreeGroup => {
+    return { name, path, children: new Map(), leaves: [] };
+};
 
-        // 创建遮罩层防止文本选择
-        const overlay = document.createElement('div');
-        overlay.style.cssText = 'position:fixed;top:0;left:0;right:0;bottom:0;cursor:col-resize;z-index:9999;';
-        document.body.appendChild(overlay);
+const countGroupLeafNodes = (group: RedisKeyTreeGroup): number => {
+    let count = group.leaves.length;
+    group.children.forEach((child) => {
+        count += countGroupLeafNodes(child);
+    });
+    return count;
+};
 
-        let currentWidth = startWidth;
+const buildRedisKeyTree = (
+    keys: RedisKeyInfo[],
+    formatTTL: (ttl: number) => string,
+    getTypeColor: (type: string) => string,
+    showTTL: boolean
+): RedisKeyTreeResult => {
+    const root = createTreeGroup('__root__', '__root__');
 
-        const handleMouseMove = (moveEvent: MouseEvent) => {
-            moveEvent.preventDefault();
-            const delta = moveEvent.clientX - startX;
-            currentWidth = Math.max(50, startWidth + delta);
-            // 直接操作 DOM
-            th.style.width = `${currentWidth}px`;
-            if (col) {
-                col.style.width = `${currentWidth}px`;
+    keys.forEach((keyInfo) => {
+        const segments = keyInfo.key.split(KEY_GROUP_DELIMITER);
+        if (segments.length <= 1) {
+            root.leaves.push({ keyInfo, label: keyInfo.key });
+            return;
+        }
+
+        const groupSegments = segments.slice(0, -1);
+        const leafLabel = normalizeKeySegment(segments[segments.length - 1]);
+        let current = root;
+        const pathParts: string[] = [];
+
+        groupSegments.forEach((segment) => {
+            const normalized = normalizeKeySegment(segment);
+            pathParts.push(normalized);
+            const groupPath = pathParts.join(KEY_GROUP_DELIMITER);
+            let child = current.children.get(normalized);
+            if (!child) {
+                child = createTreeGroup(normalized, groupPath);
+                current.children.set(normalized, child);
             }
-        };
+            current = child;
+        });
 
-        const handleMouseUp = () => {
-            document.removeEventListener('mousemove', handleMouseMove);
-            document.removeEventListener('mouseup', handleMouseUp);
-            document.body.removeChild(overlay);
-            // 拖拽结束时更新 React state
-            onResize(null, { size: { width: currentWidth } });
-        };
+        current.leaves.push({ keyInfo, label: leafLabel });
+    });
 
-        document.addEventListener('mousemove', handleMouseMove);
-        document.addEventListener('mouseup', handleMouseUp);
+    const rawKeyByNodeKey = new Map<string, string>();
+    const leafNodeKeyByRawKey = new Map<string, string>();
+    const groupKeys: string[] = [];
+
+    const toTreeNodes = (group: RedisKeyTreeGroup): DataNode[] => {
+        const childGroups = Array.from(group.children.values()).sort((a, b) => a.name.localeCompare(b.name));
+        const childLeaves = [...group.leaves].sort((a, b) => a.keyInfo.key.localeCompare(b.keyInfo.key));
+
+        const groupNodes: DataNode[] = childGroups.map((child) => {
+            const groupNodeKey = `group:${child.path}`;
+            groupKeys.push(groupNodeKey);
+            return {
+                key: groupNodeKey,
+                title: (
+                    <Space size={6}>
+                        <FolderOpenOutlined style={{ color: '#8c8c8c' }} />
+                        <span>{child.name}</span>
+                        <span style={{ fontSize: 12, color: '#999' }}>({countGroupLeafNodes(child)})</span>
+                    </Space>
+                ),
+                selectable: false,
+                disableCheckbox: true,
+                children: toTreeNodes(child),
+            };
+        });
+
+        const leafNodes: DataNode[] = childLeaves.map((leaf) => {
+            const nodeKey = `key:${leaf.keyInfo.key}`;
+            rawKeyByNodeKey.set(nodeKey, leaf.keyInfo.key);
+            leafNodeKeyByRawKey.set(leaf.keyInfo.key, nodeKey);
+            return {
+                key: nodeKey,
+                isLeaf: true,
+                title: (
+                    <div
+                        style={{
+                            display: 'flex',
+                            alignItems: 'center',
+                            gap: 8,
+                            minWidth: 0,
+                            width: '100%',
+                            overflow: 'hidden',
+                        }}
+                    >
+                        <div
+                            style={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                gap: 6,
+                                minWidth: 0,
+                                flex: 1,
+                                overflow: 'hidden',
+                            }}
+                        >
+                            <KeyOutlined style={{ color: '#1677ff', flexShrink: 0 }} />
+                            <Tooltip title={leaf.keyInfo.key}>
+                                <span
+                                    style={{
+                                        minWidth: 0,
+                                        overflow: 'hidden',
+                                        textOverflow: 'ellipsis',
+                                        whiteSpace: 'nowrap',
+                                        display: 'block',
+                                    }}
+                                >
+                                    {leaf.label}
+                                </span>
+                            </Tooltip>
+                        </div>
+                        <Tag
+                            color={getTypeColor(leaf.keyInfo.type)}
+                            style={{
+                                marginInlineEnd: 0,
+                                width: showTTL ? REDIS_TREE_KEY_TYPE_WIDTH : REDIS_TREE_KEY_TYPE_WIDTH_NARROW,
+                                textAlign: 'center',
+                                flexShrink: 0
+                            }}
+                        >
+                            {leaf.keyInfo.type}
+                        </Tag>
+                        {showTTL && (
+                            <span
+                                style={{
+                                    width: REDIS_TREE_KEY_TTL_WIDTH,
+                                    fontSize: 12,
+                                    color: '#999',
+                                    textAlign: 'left',
+                                    whiteSpace: 'nowrap',
+                                    flexShrink: 0,
+                                    overflow: 'hidden',
+                                    textOverflow: 'ellipsis',
+                                }}
+                            >
+                                {formatTTL(leaf.keyInfo.ttl)}
+                            </span>
+                        )}
+                    </div>
+                ),
+            };
+        });
+
+        return [...groupNodes, ...leafNodes];
     };
 
-    return (
-        <th
-            ref={thRef}
-            {...restProps}
-            style={{
-                ...restProps.style,
-                position: 'relative'
-            }}
-        >
-            {children}
-            <div
-                style={{
-                    position: 'absolute',
-                    right: 0,
-                    top: 0,
-                    bottom: 0,
-                    width: 10,
-                    cursor: 'col-resize',
-                    zIndex: 1,
-                    background: 'transparent'
-                }}
-                onMouseDown={handleMouseDown}
-                onMouseOver={(e) => { e.currentTarget.style.background = 'rgba(0,0,0,0.06)'; }}
-                onMouseOut={(e) => { e.currentTarget.style.background = 'transparent'; }}
-            />
-        </th>
-    );
+    return {
+        treeData: toTreeNodes(root),
+        rawKeyByNodeKey,
+        leafNodeKeyByRawKey,
+        groupKeys,
+    };
 };
 
 const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
@@ -317,7 +424,6 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
     const [keyValue, setKeyValue] = useState<RedisValue | null>(null);
     const [valueLoading, setValueLoading] = useState(false);
     const [editModalOpen, setEditModalOpen] = useState(false);
-    const [editForm] = Form.useForm();
     const [newKeyModalOpen, setNewKeyModalOpen] = useState(false);
     const [newKeyForm] = Form.useForm();
     const [ttlModalOpen, setTtlModalOpen] = useState(false);
@@ -341,15 +447,8 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
     // 面板宽度状态和 ref - 默认占据 50% 宽度
     const [leftPanelWidth, setLeftPanelWidth] = useState<number | string>('50%');
     const leftPanelRef = useRef<HTMLDivElement>(null);
-
-    // 列宽状态 - 复选框列约 32px，总宽度需要接近面板宽度
-    // Key 列自适应剩余空间，其他列固定宽度
-    const [columnWidths, setColumnWidths] = useState({
-        key: 220,    // Key 名称，需要较宽
-        type: 65,    // 类型标签
-        ttl: 80,     // TTL 显示
-        action: 50   // 操作按钮
-    });
+    const [showTreeKeyTTL, setShowTreeKeyTTL] = useState(true);
+    const [expandedGroupKeys, setExpandedGroupKeys] = useState<string[]>([]);
 
     const getConfig = useCallback(() => {
         if (!connection) return null;
@@ -373,7 +472,12 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
             if (res.success) {
                 const result = res.data;
                 if (append) {
-                    setKeys(prev => [...prev, ...result.keys]);
+                    setKeys(prev => {
+                        const keyMap = new Map<string, RedisKeyInfo>();
+                        prev.forEach(item => keyMap.set(item.key, item));
+                        result.keys.forEach((item: RedisKeyInfo) => keyMap.set(item.key, item));
+                        return Array.from(keyMap.values());
+                    });
                 } else {
                     setKeys(result.keys);
                 }
@@ -451,6 +555,11 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
         }
     };
 
+    const handleDeleteCurrentKey = async () => {
+        if (!selectedKey) return;
+        await handleDeleteKeys([selectedKey]);
+    };
+
     const handleSetTTL = async () => {
         const config = getConfig();
         if (!config || !selectedKey) return;
@@ -516,6 +625,7 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
             case 'list': return 'orange';
             case 'set': return 'purple';
             case 'zset': return 'magenta';
+            case 'stream': return 'cyan';
             default: return 'default';
         }
     };
@@ -529,65 +639,81 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
         return `${Math.floor(ttl / 86400)}天${Math.floor((ttl % 86400) / 3600)}时`;
     };
 
-    // 处理列宽调整 - react-resizable 的 onResize 回调格式
-    const handleColumnResize = (key: string) => (_e: any, { size }: { size: { width: number } }) => {
-        setColumnWidths(prev => ({ ...prev, [key]: size.width }));
+    useEffect(() => {
+        const target = leftPanelRef.current;
+        if (!target) return;
+
+        const updateTTLVisibility = (width: number) => {
+            const nextShowTTL = width > REDIS_TREE_HIDE_TTL_THRESHOLD;
+            setShowTreeKeyTTL((prev) => (prev === nextShowTTL ? prev : nextShowTTL));
+        };
+
+        updateTTLVisibility(Math.round(target.getBoundingClientRect().width));
+
+        if (typeof ResizeObserver !== 'undefined') {
+            const observer = new ResizeObserver((entries) => {
+                const width = Math.round(entries[0]?.contentRect.width || target.getBoundingClientRect().width);
+                updateTTLVisibility(width);
+            });
+            observer.observe(target);
+            return () => observer.disconnect();
+        }
+
+        const handleWindowResize = () => {
+            updateTTLVisibility(Math.round(target.getBoundingClientRect().width));
+        };
+        window.addEventListener('resize', handleWindowResize);
+        return () => window.removeEventListener('resize', handleWindowResize);
+    }, []);
+
+    const keyTree = useMemo(() => {
+        return buildRedisKeyTree(keys, formatTTL, getTypeColor, showTreeKeyTTL);
+    }, [keys, showTreeKeyTTL]);
+
+    const selectedTreeNodeKeys = useMemo(() => {
+        if (!selectedKey) {
+            return [] as string[];
+        }
+        const nodeKey = keyTree.leafNodeKeyByRawKey.get(selectedKey);
+        return nodeKey ? [nodeKey] : [];
+    }, [selectedKey, keyTree]);
+
+    const checkedTreeNodeKeys = useMemo(() => {
+        return selectedKeys
+            .map(rawKey => keyTree.leafNodeKeyByRawKey.get(rawKey))
+            .filter((nodeKey): nodeKey is string => Boolean(nodeKey));
+    }, [selectedKeys, keyTree]);
+
+    useEffect(() => {
+        const existingKeySet = new Set(keys.map(item => item.key));
+        setSelectedKeys(prev => prev.filter(rawKey => existingKeySet.has(rawKey)));
+    }, [keys]);
+
+    useEffect(() => {
+        setExpandedGroupKeys((prev) => {
+            const validKeys = prev.filter(nodeKey => keyTree.groupKeys.includes(nodeKey));
+            return validKeys;
+        });
+    }, [keyTree]);
+
+    const handleTreeSelect = (nodeKeys: React.Key[]) => {
+        if (nodeKeys.length === 0) {
+            return;
+        }
+        const rawKey = keyTree.rawKeyByNodeKey.get(String(nodeKeys[0]));
+        if (!rawKey) {
+            return;
+        }
+        loadKeyValue(rawKey);
     };
 
-    const columns: ColumnType<RedisKeyInfo>[] = [
-        {
-            title: 'Key',
-            dataIndex: 'key',
-            key: 'key',
-            width: columnWidths.key,
-            ellipsis: true,
-            onHeaderCell: (column: any) => ({
-                width: column.width,
-                onResize: handleColumnResize('key')
-            }),
-            render: (text: string) => (
-                <Tooltip title={text}>
-                    <span style={{ cursor: 'pointer' }} onClick={() => loadKeyValue(text)}>{text}</span>
-                </Tooltip>
-            )
-        },
-        {
-            title: '类型',
-            dataIndex: 'type',
-            key: 'type',
-            width: columnWidths.type,
-            onHeaderCell: (column: any) => ({
-                width: column.width,
-                onResize: handleColumnResize('type')
-            }),
-            render: (type: string) => <Tag color={getTypeColor(type)}>{type}</Tag>
-        },
-        {
-            title: 'TTL',
-            dataIndex: 'ttl',
-            key: 'ttl',
-            width: columnWidths.ttl,
-            onHeaderCell: (column: any) => ({
-                width: column.width,
-                onResize: handleColumnResize('ttl')
-            }),
-            render: (ttl: number) => formatTTL(ttl)
-        },
-        {
-            title: '操作',
-            key: 'action',
-            width: columnWidths.action,
-            onHeaderCell: (column: any) => ({
-                width: column.width,
-                onResize: handleColumnResize('action')
-            }),
-            render: (_: any, record: RedisKeyInfo) => (
-                <Popconfirm title="确定删除此 Key？" onConfirm={() => handleDeleteKeys([record.key])}>
-                    <Button type="text" danger size="small" icon={<DeleteOutlined />} />
-                </Popconfirm>
-            )
-        }
-    ];
+    const handleTreeCheck = (checked: React.Key[] | { checked: React.Key[]; halfChecked: React.Key[] }) => {
+        const checkedNodeKeys = Array.isArray(checked) ? checked : checked.checked;
+        const rawKeys = checkedNodeKeys
+            .map(nodeKey => keyTree.rawKeyByNodeKey.get(String(nodeKey)))
+            .filter((rawKey): rawKey is string => Boolean(rawKey));
+        setSelectedKeys(rawKeys);
+    };
 
     const renderValueEditor = () => {
         if (!keyValue || !selectedKey) {
@@ -1343,6 +1469,212 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
             );
         };
 
+        const renderStreamValue = () => {
+            const processValue = (value: string) => {
+                if (viewMode === 'hex') {
+                    return { displayValue: toHexDisplay(value), isBinary: true, isJson: false, encoding: 'HEX' };
+                } else if (viewMode === 'text') {
+                    return { displayValue: value, isBinary: false, isJson: false, encoding: 'Text' };
+                } else if (viewMode === 'utf8') {
+                    try {
+                        const bytes = new Uint8Array(value.length);
+                        for (let i = 0; i < value.length; i++) {
+                            bytes[i] = value.charCodeAt(i) & 0xFF;
+                        }
+                        const decoded = new TextDecoder('utf-8', { fatal: false }).decode(bytes);
+                        return { displayValue: decoded, isBinary: false, isJson: false, encoding: 'UTF-8' };
+                    } catch (e) {
+                        return { displayValue: value, isBinary: false, isJson: false, encoding: 'UTF-8 (失败)' };
+                    }
+                } else {
+                    return formatStringValue(value);
+                }
+            };
+
+            const data = (keyValue.value as StreamEntry[]).map((item, index) => {
+                const rawFieldsText = JSON.stringify(item.fields ?? {}, null, 2);
+                const { displayValue, isBinary, isJson, encoding } = processValue(rawFieldsText);
+                return {
+                    index,
+                    id: item.id,
+                    rawFieldsText,
+                    displayFields: displayValue,
+                    isBinary,
+                    isJson,
+                    encoding,
+                };
+            });
+
+            const handleAddStreamEntry = async (fieldsText: string, id: string) => {
+                const config = getConfig();
+                if (!config) return;
+
+                let parsed: unknown;
+                try {
+                    parsed = JSON.parse(fieldsText);
+                } catch (e) {
+                    message.error('字段 JSON 格式不正确');
+                    return;
+                }
+
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                    message.error('字段必须是 JSON 对象');
+                    return;
+                }
+
+                const fieldMap: Record<string, string> = {};
+                Object.entries(parsed as Record<string, unknown>).forEach(([field, value]) => {
+                    fieldMap[field] = value == null ? '' : String(value);
+                });
+
+                if (Object.keys(fieldMap).length === 0) {
+                    message.error('至少提供一个字段');
+                    return;
+                }
+
+                try {
+                    const res = await (window as any).go.app.App.RedisStreamAdd(config, selectedKey, fieldMap, id || '*');
+                    if (res.success) {
+                        const newID = res.data?.id ? ` (${res.data.id})` : '';
+                        message.success(`添加成功${newID}`);
+                        loadKeyValue(selectedKey);
+                    } else {
+                        message.error('添加失败: ' + res.message);
+                    }
+                } catch (e: any) {
+                    message.error('添加失败: ' + (e?.message || String(e)));
+                }
+            };
+
+            const handleDeleteStreamEntry = async (id: string) => {
+                const config = getConfig();
+                if (!config) return;
+
+                try {
+                    const res = await (window as any).go.app.App.RedisStreamDelete(config, selectedKey, [id]);
+                    if (res.success) {
+                        const deleted = Number(res.data?.deleted ?? 0);
+                        if (deleted > 0) {
+                            message.success('删除成功');
+                        } else {
+                            message.warning('未删除任何消息，可能已不存在');
+                        }
+                        loadKeyValue(selectedKey);
+                    } else {
+                        message.error('删除失败: ' + res.message);
+                    }
+                } catch (e: any) {
+                    message.error('删除失败: ' + (e?.message || String(e)));
+                }
+            };
+
+            return (
+                <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
+                    <div style={{ marginBottom: 8, display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+                        <Button size="small" icon={<PlusOutlined />} onClick={() => {
+                            Modal.confirm({
+                                title: '添加 Stream 消息',
+                                width: 680,
+                                content: (
+                                    <div>
+                                        <div style={{ marginBottom: 8 }}>
+                                            <label>ID（可选，默认 *）：</label>
+                                            <Input id="new-stream-id" placeholder="例如: * 或 1723110000000-0" />
+                                        </div>
+                                        <div>
+                                            <label>字段 JSON：</label>
+                                            <Input.TextArea id="new-stream-fields" rows={8} defaultValue={'{\n  "field": "value"\n}'} />
+                                        </div>
+                                    </div>
+                                ),
+                                onOk: async () => {
+                                    const id = (document.getElementById('new-stream-id') as HTMLInputElement)?.value?.trim() || '*';
+                                    const fieldsText = (document.getElementById('new-stream-fields') as HTMLTextAreaElement)?.value || '{}';
+                                    await handleAddStreamEntry(fieldsText, id);
+                                }
+                            });
+                        }}>添加消息</Button>
+                        <Radio.Group size="small" value={viewMode} onChange={(e) => setViewMode(e.target.value)}>
+                            <Radio.Button value="auto">自动</Radio.Button>
+                            <Radio.Button value="text">原始文本</Radio.Button>
+                            <Radio.Button value="utf8">UTF-8</Radio.Button>
+                            <Radio.Button value="hex">十六进制</Radio.Button>
+                        </Radio.Group>
+                    </div>
+                    <Table
+                        dataSource={data}
+                        columns={[
+                            {
+                                title: 'ID',
+                                dataIndex: 'id',
+                                key: 'id',
+                                width: 240,
+                                ellipsis: true,
+                            },
+                            {
+                                title: '字段',
+                                dataIndex: 'displayFields',
+                                key: 'fields',
+                                ellipsis: true,
+                                render: (text: string, record: any) => {
+                                    const tooltipContent = record.encoding && record.encoding !== 'UTF-8'
+                                        ? `[${record.encoding}]\n${text}`
+                                        : text;
+
+                                    return (
+                                        <Tooltip title={<pre style={{ maxHeight: 300, overflow: 'auto', margin: 0, fontSize: 12 }}>{tooltipContent}</pre>} styles={{ root: { maxWidth: 720 } }}>
+                                            <span style={{
+                                                color: record.isBinary ? '#d46b08' : (record.isJson ? '#1890ff' : undefined),
+                                                fontFamily: record.isBinary ? 'monospace' : undefined,
+                                                fontSize: record.isBinary ? 11 : undefined
+                                            }}>
+                                                {text}
+                                            </span>
+                                        </Tooltip>
+                                    );
+                                }
+                            },
+                            {
+                                title: '操作',
+                                key: 'action',
+                                width: 140,
+                                render: (_: any, record: any) => (
+                                    <Space size="small">
+                                        <Tooltip title="复制 ID">
+                                            <Button type="text" size="small" icon={<CopyOutlined />} onClick={() => {
+                                                navigator.clipboard.writeText(record.id).then(() => {
+                                                    message.success('已复制');
+                                                }).catch(() => {
+                                                    message.error('复制失败');
+                                                });
+                                            }} />
+                                        </Tooltip>
+                                        <Tooltip title="复制字段 JSON">
+                                            <Button type="text" size="small" icon={<CopyOutlined />} onClick={() => {
+                                                navigator.clipboard.writeText(record.rawFieldsText).then(() => {
+                                                    message.success('已复制');
+                                                }).catch(() => {
+                                                    message.error('复制失败');
+                                                });
+                                            }} />
+                                        </Tooltip>
+                                        <Popconfirm title="确定删除此消息？" onConfirm={() => handleDeleteStreamEntry(record.id)}>
+                                            <Button type="text" size="small" danger icon={<DeleteOutlined />} />
+                                        </Popconfirm>
+                                    </Space>
+                                )
+                            }
+                        ]}
+                        rowKey="id"
+                        size="small"
+                        pagination={{ pageSize: 50 }}
+                        scroll={{ y: 'calc(100vh - 350px)' }}
+                        style={{ flex: 1 }}
+                    />
+                </div>
+            );
+        };
+
         return (
             <div style={{ padding: 12, height: '100%', display: 'flex', flexDirection: 'column' }}>
                 <div style={{ marginBottom: 12, display: 'flex', justifyContent: 'space-between', alignItems: 'center', flexShrink: 0 }}>
@@ -1375,6 +1707,9 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
                             setTtlModalOpen(true);
                         }}>设置 TTL</Button>
                         <Button size="small" onClick={() => loadKeyValue(selectedKey)} icon={<ReloadOutlined />}>刷新</Button>
+                        <Popconfirm title={`确定删除 Key "${selectedKey}"？`} onConfirm={handleDeleteCurrentKey}>
+                            <Button size="small" danger icon={<DeleteOutlined />}>删除 Key</Button>
+                        </Popconfirm>
                     </Space>
                 </div>
                 <div style={{ flex: 1, minHeight: 0, overflow: 'hidden' }}>
@@ -1383,6 +1718,7 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
                     {keyValue.type === 'list' && renderListValue()}
                     {keyValue.type === 'set' && renderSetValue()}
                     {keyValue.type === 'zset' && renderZSetValue()}
+                    {keyValue.type === 'stream' && renderStreamValue()}
                 </div>
             </div>
         );
@@ -1410,36 +1746,35 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
                             <Button size="small" icon={<ReloadOutlined />} onClick={handleRefresh}>刷新</Button>
                             <Button size="small" icon={<PlusOutlined />} onClick={() => setNewKeyModalOpen(true)}>新建</Button>
                         </Space>
-                        {selectedKeys.length > 0 && (
-                            <Popconfirm title={`确定删除选中的 ${selectedKeys.length} 个 Key？`} onConfirm={() => handleDeleteKeys(selectedKeys)}>
-                                <Button size="small" danger icon={<DeleteOutlined />}>删除选中</Button>
-                            </Popconfirm>
-                        )}
+                        <Popconfirm
+                            title={`确定删除选中的 ${selectedKeys.length} 个 Key？`}
+                            onConfirm={() => handleDeleteKeys(selectedKeys)}
+                            disabled={selectedKeys.length === 0}
+                        >
+                            <Button size="small" danger icon={<DeleteOutlined />} disabled={selectedKeys.length === 0}>
+                                删除选中({selectedKeys.length})
+                            </Button>
+                        </Popconfirm>
                     </div>
                 </div>
                 <div style={{ flex: 1, overflow: 'auto' }}>
-                    <Table
-                        dataSource={keys}
-                        columns={columns}
-                        rowKey="key"
-                        size="small"
-                        loading={loading}
-                        pagination={false}
-                        components={{
-                            header: {
-                                cell: ResizableTitle
-                            }
-                        }}
-                        rowSelection={{
-                            selectedRowKeys: selectedKeys,
-                            onChange: (keys) => setSelectedKeys(keys as string[])
-                        }}
-                        onRow={(record) => ({
-                            onClick: () => loadKeyValue(record.key),
-                            style: { cursor: 'pointer', background: selectedKey === record.key ? '#e6f7ff' : undefined }
-                        })}
-                        style={{ width: '100%' }}
-                    />
+                    <Spin spinning={loading} size="small">
+                        <Tree
+                            blockNode
+                            showIcon={false}
+                            checkable
+                            checkStrictly
+                            selectable
+                            treeData={keyTree.treeData}
+                            selectedKeys={selectedTreeNodeKeys}
+                            checkedKeys={checkedTreeNodeKeys}
+                            expandedKeys={expandedGroupKeys}
+                            onExpand={(nextExpandedKeys) => setExpandedGroupKeys(nextExpandedKeys as string[])}
+                            onSelect={(nodeKeys) => handleTreeSelect(nodeKeys)}
+                            onCheck={(checked) => handleTreeCheck(checked)}
+                            style={{ padding: '8px 6px' }}
+                        />
+                    </Spin>
                     {hasMore && (
                         <div style={{ padding: 8, textAlign: 'center' }}>
                             <Button onClick={handleLoadMore} loading={loading}>加载更多</Button>

frontend/src/components/TabManager.tsx

@@ -7,9 +7,31 @@ import QueryEditor from './QueryEditor';
 import TableDesigner from './TableDesigner';
 import RedisViewer from './RedisViewer';
 import RedisCommandEditor from './RedisCommandEditor';
+import TriggerViewer from './TriggerViewer';
+import DefinitionViewer from './DefinitionViewer';
+import type { TabData } from '../types';
+
+const detectConnectionEnvLabel = (connectionName: string): string | null => {
+  const tokens = connectionName.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  if (tokens.includes('prod') || tokens.includes('production')) return 'PROD';
+  if (tokens.includes('uat')) return 'UAT';
+  if (tokens.includes('dev') || tokens.includes('development')) return 'DEV';
+  if (tokens.includes('sit')) return 'SIT';
+  if (tokens.includes('stg') || tokens.includes('stage') || tokens.includes('staging') || tokens.includes('pre')) return 'STG';
+  if (tokens.includes('test') || tokens.includes('qa')) return 'TEST';
+  return null;
+};
+
+const buildTabDisplayTitle = (tab: TabData, connectionName: string | undefined): string => {
+  if (tab.type !== 'table' && tab.type !== 'design') return tab.title;
+  if (!connectionName) return tab.title;
+  const prefix = detectConnectionEnvLabel(connectionName) || connectionName;
+  return `[${prefix}] ${tab.title}`;
+};
 
 const TabManager: React.FC = () => {
   const tabs = useStore(state => state.tabs);
+  const connections = useStore(state => state.connections);
   const activeTabId = useStore(state => state.activeTabId);
   const setActiveTab = useStore(state => state.setActiveTab);
   const closeTab = useStore(state => state.closeTab);
@@ -29,6 +51,8 @@ const TabManager: React.FC = () => {
   };
 
   const items = useMemo(() => tabs.map((tab, index) => {
+    const connectionName = connections.find((conn) => conn.id === tab.connectionId)?.name;
+    const displayTitle = buildTabDisplayTitle(tab, connectionName);
     let content;
     if (tab.type === 'query') {
       content = <QueryEditor tab={tab} />;
@@ -40,6 +64,10 @@ const TabManager: React.FC = () => {
       content = <RedisViewer connectionId={tab.connectionId} redisDB={tab.redisDB ?? 0} />;
     } else if (tab.type === 'redis-command') {
       content = <RedisCommandEditor connectionId={tab.connectionId} redisDB={tab.redisDB ?? 0} />;
+    } else if (tab.type === 'trigger') {
+      content = <TriggerViewer tab={tab} />;
+    } else if (tab.type === 'view-def' || tab.type === 'routine-def') {
+      content = <DefinitionViewer tab={tab} />;
     }
 
     const menuItems: MenuProps['items'] = [
@@ -73,13 +101,13 @@ const TabManager: React.FC = () => {
     return {
       label: (
         <Dropdown menu={{ items: menuItems }} trigger={['contextMenu']}>
-          <span onContextMenu={(e) => e.preventDefault()}>{tab.title}</span>
+          <span onContextMenu={(e) => e.preventDefault()}>{displayTitle}</span>
         </Dropdown>
       ),
       key: tab.id,
       children: content,
     };
-  }), [tabs, closeOtherTabs, closeTabsToLeft, closeTabsToRight, closeAllTabs]);
+  }), [tabs, connections, closeOtherTabs, closeTabsToLeft, closeTabsToRight, closeAllTabs]);
 
   return (
     <>
@@ -88,6 +116,7 @@ const TabManager: React.FC = () => {
               height: 100%;
               flex: 1 1 auto;
               min-height: 0;
+              min-width: 0;
               display: flex;
               flex-direction: column;
               overflow: hidden;
@@ -98,6 +127,7 @@ const TabManager: React.FC = () => {
             .main-tabs .ant-tabs-content-holder {
               flex: 1 1 auto;
               min-height: 0;
+              min-width: 0;
               overflow: hidden;
               display: flex;
               flex-direction: column;
@@ -105,12 +135,14 @@ const TabManager: React.FC = () => {
             .main-tabs .ant-tabs-content {
               flex: 1 1 auto;
               min-height: 0;
+              min-width: 0;
               display: flex;
               flex-direction: column;
             }
             .main-tabs .ant-tabs-tabpane {
               flex: 1 1 auto;
               min-height: 0;
+              min-width: 0;
               display: flex;
               flex-direction: column;
               overflow: hidden;
@@ -118,6 +150,7 @@ const TabManager: React.FC = () => {
             .main-tabs .ant-tabs-tabpane > div {
               flex: 1 1 auto;
               min-height: 0;
+              min-width: 0;
             }
             .main-tabs .ant-tabs-tabpane-hidden {
               display: none !important;

frontend/src/components/TriggerViewer.tsx

@@ -0,0 +1,340 @@
+import React, { useState, useEffect } from 'react';
+import Editor, { loader } from '@monaco-editor/react';
+import { Spin, Alert } from 'antd';
+import { TabData } from '../types';
+import { useStore } from '../store';
+import { DBQuery } from '../../wailsjs/go/app/App';
+
+interface TriggerViewerProps {
+    tab: TabData;
+}
+
+const TriggerViewer: React.FC<TriggerViewerProps> = ({ tab }) => {
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<string | null>(null);
+    const [triggerDefinition, setTriggerDefinition] = useState<string>('');
+
+    const connections = useStore(state => state.connections);
+    const theme = useStore(state => state.theme);
+    const darkMode = theme === 'dark';
+
+    // 初始化透明 Monaco Editor 主题
+    useEffect(() => {
+        loader.init().then(monaco => {
+            monaco.editor.defineTheme('transparent-dark', {
+                base: 'vs-dark',
+                inherit: true,
+                rules: [],
+                colors: {
+                    'editor.background': '#00000000',
+                    'editor.lineHighlightBackground': '#ffffff10',
+                    'editorGutter.background': '#00000000',
+                }
+            });
+            monaco.editor.defineTheme('transparent-light', {
+                base: 'vs',
+                inherit: true,
+                rules: [],
+                colors: {
+                    'editor.background': '#00000000',
+                    'editor.lineHighlightBackground': '#00000010',
+                    'editorGutter.background': '#00000000',
+                }
+            });
+        });
+    }, []);
+
+    const escapeSQLLiteral = (raw: string): string => String(raw || '').replace(/'/g, "''");
+    const quoteSqlServerIdentifier = (raw: string): string => `[${String(raw || '').replace(/]/g, ']]')}]`;
+
+    const getMetadataDialect = (conn: any): string => {
+        const type = String(conn?.config?.type || '').trim().toLowerCase();
+        if (type === 'custom') {
+            const driver = String(conn?.config?.driver || '').trim().toLowerCase();
+            if (driver === 'diros' || driver === 'doris') return 'mysql';
+            return driver;
+        }
+        if (type === 'mariadb' || type === 'diros' || type === 'sphinx') return 'mysql';
+        if (type === 'dameng') return 'dm';
+        return type;
+    };
+
+    const isSphinxConnection = (conn: any): boolean => {
+        const type = String(conn?.config?.type || '').trim().toLowerCase();
+        if (type === 'sphinx') return true;
+        if (type !== 'custom') return false;
+        const driver = String(conn?.config?.driver || '').trim().toLowerCase();
+        return driver === 'sphinx' || driver === 'sphinxql';
+    };
+
+    const buildShowTriggerQueries = (dialect: string, triggerName: string, dbName: string): string[] => {
+        const safeTriggerName = escapeSQLLiteral(triggerName);
+        const safeDbName = escapeSQLLiteral(dbName);
+        switch (dialect) {
+            case 'mysql':
+                return [
+                    `SHOW CREATE TRIGGER \`${triggerName.replace(/`/g, '``')}\``,
+                    safeDbName
+                        ? `SELECT ACTION_STATEMENT AS trigger_definition FROM information_schema.triggers WHERE trigger_schema = '${safeDbName}' AND trigger_name = '${safeTriggerName}' LIMIT 1`
+                        : '',
+                    safeDbName
+                        ? `SHOW TRIGGERS FROM \`${dbName.replace(/`/g, '``')}\` LIKE '${safeTriggerName}'`
+                        : `SHOW TRIGGERS LIKE '${safeTriggerName}'`,
+                ].filter(Boolean);
+            case 'postgres':
+            case 'kingbase':
+            case 'highgo':
+            case 'vastbase':
+                return [`SELECT pg_get_triggerdef(t.oid, true) AS trigger_definition
+FROM pg_trigger t
+JOIN pg_class c ON t.tgrelid = c.oid
+WHERE t.tgname = '${safeTriggerName}'
+  AND NOT t.tgisinternal
+LIMIT 1`];
+            case 'sqlserver': {
+                return [`SELECT OBJECT_DEFINITION(OBJECT_ID('${safeTriggerName.replace(/'/g, "''")}')) AS trigger_definition`];
+            }
+            case 'oracle':
+            case 'dm':
+                if (!safeDbName) {
+                    return [`SELECT TRIGGER_BODY FROM USER_TRIGGERS WHERE TRIGGER_NAME = '${safeTriggerName.toUpperCase()}'`];
+                }
+                return [`SELECT TRIGGER_BODY FROM ALL_TRIGGERS WHERE OWNER = '${safeDbName.toUpperCase()}' AND TRIGGER_NAME = '${safeTriggerName.toUpperCase()}'`];
+            case 'sqlite':
+                return [`SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = '${safeTriggerName}'`];
+            case 'duckdb':
+                return [`-- DuckDB 不支持触发器`];
+            case 'tdengine':
+                return [`-- TDengine 不支持触发器`];
+            case 'mongodb':
+                return [`-- MongoDB 不支持触发器`];
+            default:
+                return [`-- 暂不支持该数据库类型的触发器定义查看`];
+        }
+    };
+
+    const runQueryCandidates = async (
+        config: Record<string, any>,
+        dbName: string,
+        queries: string[]
+    ): Promise<{ success: boolean; data: any[]; message?: string }> => {
+        let lastMessage = '';
+        let hasSuccessfulQuery = false;
+        for (const query of queries) {
+            const sql = String(query || '').trim();
+            if (!sql) continue;
+            try {
+                const result = await DBQuery(config as any, dbName, sql);
+                if (!result.success || !Array.isArray(result.data)) {
+                    lastMessage = result.message || lastMessage;
+                    continue;
+                }
+                hasSuccessfulQuery = true;
+                if (result.data.length > 0) {
+                    return { success: true, data: result.data };
+                }
+            } catch (error: any) {
+                lastMessage = error?.message || String(error);
+            }
+        }
+        if (hasSuccessfulQuery) {
+            return { success: true, data: [] };
+        }
+        return { success: false, data: [], message: lastMessage };
+    };
+
+    const getVersionHint = async (config: Record<string, any>, dbName: string): Promise<string> => {
+        const candidates = [
+            `SELECT VERSION() AS version`,
+            `SHOW VARIABLES LIKE 'version'`,
+        ];
+        for (const query of candidates) {
+            try {
+                const result = await DBQuery(config as any, dbName, query);
+                if (!result.success || !Array.isArray(result.data) || result.data.length === 0) {
+                    continue;
+                }
+                const row = result.data[0] as Record<string, any>;
+                const version =
+                    row.version
+                    || row.VERSION
+                    || row.Value
+                    || row.value
+                    || Object.values(row)[1]
+                    || Object.values(row)[0];
+                const text = String(version || '').trim();
+                if (text) return text;
+            } catch {
+                // ignore
+            }
+        }
+        return '';
+    };
+
+    const extractTriggerDefinition = (dialect: string, data: any[]): string => {
+        if (!data || data.length === 0) {
+            return '-- 未找到触发器定义';
+        }
+
+        const row = data[0];
+
+        switch (dialect) {
+            case 'mysql': {
+                // MySQL SHOW CREATE TRIGGER returns: Trigger, sql_mode, SQL Original Statement, ...
+                const keys = Object.keys(row);
+                if (row.trigger_definition || row.TRIGGER_DEFINITION) {
+                    return String(row.trigger_definition || row.TRIGGER_DEFINITION);
+                }
+                if (row.ACTION_STATEMENT || row.action_statement) {
+                    return String(row.ACTION_STATEMENT || row.action_statement);
+                }
+                const sqlKey = keys.find(k => k.toLowerCase().includes('statement') || k.toLowerCase() === 'sql original statement');
+                if (sqlKey) return row[sqlKey];
+                // Fallback: try to find any key containing CREATE TRIGGER
+                for (const key of keys) {
+                    const val = String(row[key] || '');
+                    if (val.toUpperCase().includes('CREATE TRIGGER')) {
+                        return val;
+                    }
+                }
+                return JSON.stringify(row, null, 2);
+            }
+            case 'postgres':
+            case 'kingbase':
+            case 'highgo':
+            case 'vastbase': {
+                return row.trigger_definition || row.TRIGGER_DEFINITION || Object.values(row)[0] || '';
+            }
+            case 'sqlserver': {
+                return row.trigger_definition || row.TRIGGER_DEFINITION || Object.values(row)[0] || '';
+            }
+            case 'oracle':
+            case 'dm': {
+                return row.trigger_body || row.TRIGGER_BODY || Object.values(row)[0] || '';
+            }
+            case 'sqlite': {
+                return row.sql || row.SQL || Object.values(row)[0] || '';
+            }
+            default:
+                return JSON.stringify(row, null, 2);
+        }
+    };
+
+    useEffect(() => {
+        const loadTriggerDefinition = async () => {
+            setLoading(true);
+            setError(null);
+
+            const conn = connections.find(c => c.id === tab.connectionId);
+            if (!conn) {
+                setError('未找到数据库连接');
+                setLoading(false);
+                return;
+            }
+
+            const triggerName = tab.triggerName || '';
+            const dbName = tab.dbName || '';
+
+            if (!triggerName) {
+                setError('触发器名称为空');
+                setLoading(false);
+                return;
+            }
+
+            const dialect = getMetadataDialect(conn);
+            const queries = buildShowTriggerQueries(dialect, triggerName, dbName);
+            const sphinxLike = isSphinxConnection(conn) && dialect === 'mysql';
+
+            if (!queries.length || String(queries[0] || '').startsWith('--')) {
+                setTriggerDefinition(String(queries[0] || '-- 暂不支持该数据库类型的触发器定义查看'));
+                setLoading(false);
+                return;
+            }
+
+            try {
+                const config = {
+                    ...conn.config,
+                    port: Number(conn.config.port),
+                    password: conn.config.password || '',
+                    database: conn.config.database || '',
+                    useSSH: conn.config.useSSH || false,
+                    ssh: conn.config.ssh || { host: '', port: 22, user: '', password: '', keyPath: '' }
+                };
+
+                const result = await runQueryCandidates(config, dbName, queries);
+
+                if (result.success && Array.isArray(result.data) && result.data.length > 0) {
+                    const definition = extractTriggerDefinition(dialect, result.data);
+                    setTriggerDefinition(definition);
+                    return;
+                }
+
+                if (result.success) {
+                    if (sphinxLike) {
+                        const version = await getVersionHint(config, dbName);
+                        const versionText = version ? `（版本: ${version}）` : '';
+                        setTriggerDefinition(`-- 当前 Sphinx 实例${versionText}未返回触发器定义。\n-- 已执行多套兼容查询，可能是版本能力限制或对象类型不支持。`);
+                        return;
+                    }
+                    setTriggerDefinition('-- 未找到触发器定义');
+                } else if (sphinxLike) {
+                    const version = await getVersionHint(config, dbName);
+                    const versionText = version ? `（版本: ${version}）` : '';
+                    setTriggerDefinition(`-- 当前 Sphinx 实例${versionText}不支持触发器定义查询。\n-- 已自动尝试兼容语句，返回失败信息: ${result.message || 'unknown error'}`);
+                } else {
+                    setError(result.message || '查询触发器定义失败');
+                }
+            } catch (e: any) {
+                setError('查询触发器定义失败: ' + (e?.message || String(e)));
+            } finally {
+                setLoading(false);
+            }
+        };
+
+        loadTriggerDefinition();
+    }, [tab.connectionId, tab.dbName, tab.triggerName, connections]);
+
+    if (loading) {
+        return (
+            <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100%' }}>
+                <Spin tip="加载触发器定义..." />
+            </div>
+        );
+    }
+
+    if (error) {
+        return (
+            <div style={{ padding: 16 }}>
+                <Alert type="error" message="加载失败" description={error} showIcon />
+            </div>
+        );
+    }
+
+    return (
+        <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
+            <div style={{ padding: '8px 16px', borderBottom: darkMode ? '1px solid #303030' : '1px solid #f0f0f0' }}>
+                <strong>触发器: </strong>{tab.triggerName}
+                {tab.dbName && <span style={{ marginLeft: 16, color: '#888' }}>数据库: {tab.dbName}</span>}
+            </div>
+            <div style={{ flex: 1, minHeight: 0 }}>
+                <Editor
+                    height="100%"
+                    language="sql"
+                    theme={darkMode ? 'transparent-dark' : 'transparent-light'}
+                    value={triggerDefinition}
+                    options={{
+                        readOnly: true,
+                        minimap: { enabled: false },
+                        fontSize: 14,
+                        lineNumbers: 'on',
+                        scrollBeyondLastLine: false,
+                        wordWrap: 'on',
+                        automaticLayout: true,
+                    }}
+                />
+            </div>
+        </div>
+    );
+};
+
+export default TriggerViewer;

frontend/src/main.tsx

@@ -3,6 +3,36 @@ import ReactDOM from 'react-dom/client'
 import App from './App'
 // import './index.css' // Optional global styles
 
+// 全局配置 Monaco Editor 使用本地打包的文件，避免从 CDN (jsdelivr) 加载。
+// Windows WebView2 环境下访问外部 CDN 可能失败，导致编辑器一直显示 Loading。
+import { loader } from '@monaco-editor/react'
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js'
+import EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker.js?worker'
+import JsonWorker from 'monaco-editor/esm/vs/language/json/json.worker.js?worker'
+import 'monaco-editor/esm/vs/basic-languages/sql/sql.contribution.js'
+import 'monaco-editor/esm/vs/language/json/monaco.contribution.js'
+
+(self as any).MonacoEnvironment = {
+  getWorker(_: unknown, label: string) {
+    if (label === 'json') {
+      return new JsonWorker()
+    }
+    return new EditorWorker()
+  },
+}
+
+loader.config({ monaco })
+
+// 全局注册透明主题，避免每个 Editor 组件 beforeMount 中重复定义
+monaco.editor.defineTheme('transparent-dark', {
+  base: 'vs-dark', inherit: true, rules: [],
+  colors: { 'editor.background': '#00000000', 'editor.lineHighlightBackground': '#ffffff10', 'editorGutter.background': '#00000000' }
+})
+monaco.editor.defineTheme('transparent-light', {
+  base: 'vs', inherit: true, rules: [],
+  colors: { 'editor.background': '#00000000', 'editor.lineHighlightBackground': '#00000010', 'editorGutter.background': '#00000000' }
+})
+
 ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>
     <App />

frontend/src/store.ts

@@ -1,6 +1,245 @@
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { SavedConnection, TabData, SavedQuery } from './types';
+import { ConnectionConfig, SavedConnection, TabData, SavedQuery } from './types';
+
+const DEFAULT_APPEARANCE = { opacity: 1.0, blur: 0 };
+const LEGACY_DEFAULT_OPACITY = 0.95;
+const OPACITY_EPSILON = 1e-6;
+const MAX_URI_LENGTH = 4096;
+const MAX_HOST_ENTRY_LENGTH = 512;
+const MAX_HOST_ENTRIES = 64;
+const DEFAULT_TIMEOUT_SECONDS = 30;
+const MAX_TIMEOUT_SECONDS = 3600;
+const DEFAULT_CONNECTION_TYPE = 'mysql';
+const SUPPORTED_CONNECTION_TYPES = new Set([
+  'mysql',
+  'mariadb',
+  'diros',
+  'sphinx',
+  'postgres',
+  'redis',
+  'tdengine',
+  'oracle',
+  'dameng',
+  'kingbase',
+  'sqlserver',
+  'mongodb',
+  'highgo',
+  'vastbase',
+  'sqlite',
+  'duckdb',
+  'custom',
+]);
+
+const getDefaultPortByType = (type: string): number => {
+  switch (type) {
+    case 'mysql':
+    case 'mariadb':
+      return 3306;
+    case 'diros':
+      return 9030;
+    case 'duckdb':
+      return 0;
+    case 'sphinx':
+      return 9306;
+    case 'postgres':
+    case 'vastbase':
+      return 5432;
+    case 'redis':
+      return 6379;
+    case 'tdengine':
+      return 6041;
+    case 'oracle':
+      return 1521;
+    case 'dameng':
+      return 5236;
+    case 'kingbase':
+      return 54321;
+    case 'sqlserver':
+      return 1433;
+    case 'mongodb':
+      return 27017;
+    case 'highgo':
+      return 5866;
+    default:
+      return 3306;
+  }
+};
+
+const toTrimmedString = (value: unknown, fallback = ''): string => {
+  if (typeof value === 'string') {
+    return value.trim();
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value).trim();
+  }
+  return fallback;
+};
+
+const normalizePort = (value: unknown, fallbackPort: number): number => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallbackPort;
+  const port = Math.trunc(parsed);
+  if (port <= 0 || port > 65535) return fallbackPort;
+  return port;
+};
+
+const normalizeIntegerInRange = (value: unknown, fallbackValue: number, min: number, max: number): number => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallbackValue;
+  const normalized = Math.trunc(parsed);
+  if (normalized < min || normalized > max) return fallbackValue;
+  return normalized;
+};
+
+const isValidHostEntry = (entry: string): boolean => {
+  if (!entry) return false;
+  if (entry.length > MAX_HOST_ENTRY_LENGTH) return false;
+  if (/[()\\/\s]/.test(entry)) return false;
+  return true;
+};
+
+const sanitizeStringArray = (value: unknown, maxLength = 256): string[] => {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set<string>();
+  const result: string[] = [];
+  value.forEach((entry) => {
+    const normalized = toTrimmedString(entry);
+    if (!normalized || normalized.length > maxLength) return;
+    if (seen.has(normalized)) return;
+    seen.add(normalized);
+    result.push(normalized);
+  });
+  return result;
+};
+
+const sanitizeNumberArray = (value: unknown, min: number, max: number): number[] => {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set<number>();
+  const result: number[] = [];
+  value.forEach((entry) => {
+    const parsed = Number(entry);
+    if (!Number.isFinite(parsed)) return;
+    const num = Math.trunc(parsed);
+    if (num < min || num > max) return;
+    if (seen.has(num)) return;
+    seen.add(num);
+    result.push(num);
+  });
+  return result;
+};
+
+const sanitizeAddressList = (value: unknown): string[] => {
+  const all = sanitizeStringArray(value, MAX_HOST_ENTRY_LENGTH)
+    .filter((entry) => isValidHostEntry(entry));
+  return all.slice(0, MAX_HOST_ENTRIES);
+};
+
+const normalizeConnectionType = (value: unknown): string => {
+  const type = toTrimmedString(value).toLowerCase();
+  return SUPPORTED_CONNECTION_TYPES.has(type) ? type : DEFAULT_CONNECTION_TYPE;
+};
+
+const sanitizeConnectionConfig = (value: unknown): ConnectionConfig => {
+  const raw = (value && typeof value === 'object') ? value as Record<string, unknown> : {};
+  const type = normalizeConnectionType(raw.type);
+  const defaultPort = getDefaultPortByType(type);
+  const savePassword = typeof raw.savePassword === 'boolean' ? raw.savePassword : true;
+  const mongoSrv = !!raw.mongoSrv;
+
+  const sshRaw = (raw.ssh && typeof raw.ssh === 'object') ? raw.ssh as Record<string, unknown> : {};
+  const ssh = {
+    host: toTrimmedString(sshRaw.host),
+    port: normalizePort(sshRaw.port, 22),
+    user: toTrimmedString(sshRaw.user),
+    password: toTrimmedString(sshRaw.password),
+    keyPath: toTrimmedString(sshRaw.keyPath),
+  };
+
+  const safeConfig: ConnectionConfig & Record<string, unknown> = {
+    ...raw,
+    type,
+    host: toTrimmedString(raw.host, 'localhost') || 'localhost',
+    port: normalizePort(raw.port, defaultPort),
+    user: toTrimmedString(raw.user),
+    password: savePassword ? toTrimmedString(raw.password) : '',
+    savePassword,
+    database: toTrimmedString(raw.database),
+    useSSH: !!raw.useSSH,
+    ssh,
+    uri: toTrimmedString(raw.uri).slice(0, MAX_URI_LENGTH),
+    hosts: sanitizeAddressList(raw.hosts),
+    topology: raw.topology === 'replica' ? 'replica' : 'single',
+    mysqlReplicaUser: toTrimmedString(raw.mysqlReplicaUser),
+    mysqlReplicaPassword: savePassword ? toTrimmedString(raw.mysqlReplicaPassword) : '',
+    replicaSet: toTrimmedString(raw.replicaSet),
+    authSource: toTrimmedString(raw.authSource),
+    readPreference: toTrimmedString(raw.readPreference),
+    mongoSrv,
+    mongoAuthMechanism: toTrimmedString(raw.mongoAuthMechanism),
+    mongoReplicaUser: toTrimmedString(raw.mongoReplicaUser),
+    mongoReplicaPassword: savePassword ? toTrimmedString(raw.mongoReplicaPassword) : '',
+    timeout: normalizeIntegerInRange(raw.timeout, DEFAULT_TIMEOUT_SECONDS, 1, MAX_TIMEOUT_SECONDS),
+  };
+
+  if (type === 'redis') {
+    safeConfig.redisDB = normalizeIntegerInRange(raw.redisDB, 0, 0, 15);
+  }
+
+  if (type === 'custom') {
+    safeConfig.driver = toTrimmedString(raw.driver);
+    safeConfig.dsn = toTrimmedString(raw.dsn).slice(0, MAX_URI_LENGTH);
+  }
+
+  return safeConfig;
+};
+
+const sanitizeSavedConnection = (value: unknown, index: number): SavedConnection | null => {
+  if (!value || typeof value !== 'object') return null;
+  const raw = value as Record<string, unknown>;
+  const config = sanitizeConnectionConfig(raw.config);
+  const id = toTrimmedString(raw.id, `conn-${index + 1}`) || `conn-${index + 1}`;
+  const fallbackName = config.host ? `${config.type}-${config.host}` : `连接-${index + 1}`;
+  const name = toTrimmedString(raw.name, fallbackName) || fallbackName;
+  const includeDatabases = sanitizeStringArray(raw.includeDatabases, 256);
+  const includeRedisDatabases = sanitizeNumberArray(raw.includeRedisDatabases, 0, 15);
+
+  return {
+    id,
+    name,
+    config,
+    includeDatabases: includeDatabases.length > 0 ? includeDatabases : undefined,
+    includeRedisDatabases: includeRedisDatabases.length > 0 ? includeRedisDatabases : undefined,
+  };
+};
+
+const sanitizeConnections = (value: unknown): SavedConnection[] => {
+  if (!Array.isArray(value)) return [];
+  const result: SavedConnection[] = [];
+  const idSet = new Set<string>();
+
+  value.forEach((entry, index) => {
+    const conn = sanitizeSavedConnection(entry, index);
+    if (!conn) return;
+    let nextId = conn.id;
+    if (idSet.has(nextId)) {
+      nextId = `${nextId}-${index + 1}`;
+    }
+    idSet.add(nextId);
+    result.push({ ...conn, id: nextId });
+  });
+
+  return result;
+};
+
+const isLegacyDefaultAppearance = (appearance: Partial<{ opacity: number; blur: number }> | undefined): boolean => {
+  if (!appearance) {
+    return true;
+  }
+  const opacity = typeof appearance.opacity === 'number' ? appearance.opacity : LEGACY_DEFAULT_OPACITY;
+  const blur = typeof appearance.blur === 'number' ? appearance.blur : 0;
+  return Math.abs(opacity - LEGACY_DEFAULT_OPACITY) < OPACITY_EPSILON && blur === 0;
+};
 
 export interface SqlLog {
   id: string;
@@ -13,6 +252,12 @@ export interface SqlLog {
   affectedRows?: number;
 }
 
+export interface QueryOptions {
+  maxRows: number;
+  showColumnComment: boolean;
+  showColumnType: boolean;
+}
+
 interface AppState {
   connections: SavedConnection[];
   tabs: TabData[];
@@ -22,18 +267,22 @@ interface AppState {
   theme: 'light' | 'dark';
   appearance: { opacity: number; blur: number };
   sqlFormatOptions: { keywordCase: 'upper' | 'lower' };
-  queryOptions: { maxRows: number };
+  queryOptions: QueryOptions;
   sqlLogs: SqlLog[];
-  
+  tableAccessCount: Record<string, number>;
+  tableSortPreference: Record<string, 'name' | 'frequency'>;
+
   addConnection: (conn: SavedConnection) => void;
   updateConnection: (conn: SavedConnection) => void;
   removeConnection: (id: string) => void;
-  
+
   addTab: (tab: TabData) => void;
   closeTab: (id: string) => void;
   closeOtherTabs: (id: string) => void;
   closeTabsToLeft: (id: string) => void;
   closeTabsToRight: (id: string) => void;
+  closeTabsByConnection: (connectionId: string) => void;
+  closeTabsByDatabase: (connectionId: string, dbName: string) => void;
   closeAllTabs: () => void;
   setActiveTab: (id: string) => void;
   setActiveContext: (context: { connectionId: string; dbName: string } | null) => void;
@@ -44,12 +293,93 @@ interface AppState {
   setTheme: (theme: 'light' | 'dark') => void;
   setAppearance: (appearance: Partial<{ opacity: number; blur: number }>) => void;
   setSqlFormatOptions: (options: { keywordCase: 'upper' | 'lower' }) => void;
-  setQueryOptions: (options: Partial<{ maxRows: number }>) => void;
-  
+  setQueryOptions: (options: Partial<QueryOptions>) => void;
+
   addSqlLog: (log: SqlLog) => void;
   clearSqlLogs: () => void;
+
+  recordTableAccess: (connectionId: string, dbName: string, tableName: string) => void;
+  setTableSortPreference: (connectionId: string, dbName: string, sortBy: 'name' | 'frequency') => void;
 }
 
+const sanitizeSavedQueries = (value: unknown): SavedQuery[] => {
+  if (!Array.isArray(value)) return [];
+  const result: SavedQuery[] = [];
+  value.forEach((entry, index) => {
+    if (!entry || typeof entry !== 'object') return;
+    const raw = entry as Record<string, unknown>;
+    const id = toTrimmedString(raw.id, `query-${index + 1}`) || `query-${index + 1}`;
+    const sql = toTrimmedString(raw.sql);
+    const connectionId = toTrimmedString(raw.connectionId);
+    const dbName = toTrimmedString(raw.dbName);
+    if (!sql || !connectionId || !dbName) return;
+    result.push({
+      id,
+      name: toTrimmedString(raw.name, `查询-${index + 1}`) || `查询-${index + 1}`,
+      sql,
+      connectionId,
+      dbName,
+      createdAt: Number.isFinite(Number(raw.createdAt)) ? Number(raw.createdAt) : Date.now(),
+    });
+  });
+  return result;
+};
+
+const sanitizeTheme = (value: unknown): 'light' | 'dark' => (value === 'dark' ? 'dark' : 'light');
+
+const sanitizeSqlFormatOptions = (value: unknown): { keywordCase: 'upper' | 'lower' } => {
+  const raw = (value && typeof value === 'object') ? value as Record<string, unknown> : {};
+  return { keywordCase: raw.keywordCase === 'lower' ? 'lower' : 'upper' };
+};
+
+const sanitizeQueryOptions = (value: unknown): QueryOptions => {
+  const raw = (value && typeof value === 'object') ? value as Record<string, unknown> : {};
+  const maxRows = Number(raw.maxRows);
+  const showColumnComment = typeof raw.showColumnComment === 'boolean' ? raw.showColumnComment : true;
+  const showColumnType = typeof raw.showColumnType === 'boolean' ? raw.showColumnType : true;
+  if (!Number.isFinite(maxRows) || maxRows <= 0) {
+    return { maxRows: 5000, showColumnComment, showColumnType };
+  }
+  return { maxRows: Math.min(50000, Math.trunc(maxRows)), showColumnComment, showColumnType };
+};
+
+const sanitizeTableAccessCount = (value: unknown): Record<string, number> => {
+  const raw = (value && typeof value === 'object') ? value as Record<string, unknown> : {};
+  const result: Record<string, number> = {};
+  Object.entries(raw).forEach(([key, count]) => {
+    const parsed = Number(count);
+    if (!Number.isFinite(parsed) || parsed < 0) return;
+    result[key] = Math.trunc(parsed);
+  });
+  return result;
+};
+
+const sanitizeTableSortPreference = (value: unknown): Record<string, 'name' | 'frequency'> => {
+  const raw = (value && typeof value === 'object') ? value as Record<string, unknown> : {};
+  const result: Record<string, 'name' | 'frequency'> = {};
+  Object.entries(raw).forEach(([key, preference]) => {
+    result[key] = preference === 'frequency' ? 'frequency' : 'name';
+  });
+  return result;
+};
+
+const sanitizeAppearance = (
+  appearance: Partial<{ opacity: number; blur: number }> | undefined,
+  version: number
+): { opacity: number; blur: number } => {
+  if (!appearance || typeof appearance !== 'object') {
+    return { ...DEFAULT_APPEARANCE };
+  }
+  const nextAppearance = {
+    opacity: typeof appearance.opacity === 'number' ? appearance.opacity : DEFAULT_APPEARANCE.opacity,
+    blur: typeof appearance.blur === 'number' ? appearance.blur : DEFAULT_APPEARANCE.blur,
+  };
+  if (version < 2 && isLegacyDefaultAppearance(appearance)) {
+    return { ...DEFAULT_APPEARANCE };
+  }
+  return nextAppearance;
+};
+
 export const useStore = create<AppState>()(
   persist(
     (set) => ({
@@ -59,14 +389,16 @@ export const useStore = create<AppState>()(
       activeContext: null,
       savedQueries: [],
       theme: 'light',
-      appearance: { opacity: 0.95, blur: 0 },
+      appearance: { ...DEFAULT_APPEARANCE },
       sqlFormatOptions: { keywordCase: 'upper' },
-      queryOptions: { maxRows: 5000 },
+      queryOptions: { maxRows: 5000, showColumnComment: true, showColumnType: true },
       sqlLogs: [],
+      tableAccessCount: {},
+      tableSortPreference: {},
 
       addConnection: (conn) => set((state) => ({ connections: [...state.connections, conn] })),
-      updateConnection: (conn) => set((state) => ({ 
-          connections: state.connections.map(c => c.id === conn.id ? conn : c) 
+      updateConnection: (conn) => set((state) => ({
+          connections: state.connections.map(c => c.id === conn.id ? conn : c)
       })),
       removeConnection: (id) => set((state) => ({ connections: state.connections.filter(c => c.id !== id) })),
 
@@ -112,6 +444,45 @@ export const useStore = create<AppState>()(
         return { tabs: newTabs, activeTabId: activeStillExists ? state.activeTabId : id };
       }),
 
+      closeTabsByConnection: (connectionId) => set((state) => {
+        const targetConnectionId = String(connectionId || '').trim();
+        if (!targetConnectionId) return state;
+        const newTabs = state.tabs.filter(t => String(t.connectionId || '').trim() !== targetConnectionId);
+        const activeStillExists = state.activeTabId ? newTabs.some(t => t.id === state.activeTabId) : false;
+        const nextActiveTabId = activeStillExists
+          ? state.activeTabId
+          : (newTabs.length > 0 ? newTabs[newTabs.length - 1].id : null);
+        const nextActiveContext = state.activeContext?.connectionId === targetConnectionId ? null : state.activeContext;
+        return {
+          tabs: newTabs,
+          activeTabId: nextActiveTabId,
+          activeContext: nextActiveContext,
+        };
+      }),
+
+      closeTabsByDatabase: (connectionId, dbName) => set((state) => {
+        const targetConnectionId = String(connectionId || '').trim();
+        const targetDbName = String(dbName || '').trim();
+        if (!targetConnectionId || !targetDbName) return state;
+        const newTabs = state.tabs.filter((tab) => {
+          const sameConnection = String(tab.connectionId || '').trim() === targetConnectionId;
+          const sameDb = String(tab.dbName || '').trim() === targetDbName;
+          return !(sameConnection && sameDb);
+        });
+        const activeStillExists = state.activeTabId ? newTabs.some(t => t.id === state.activeTabId) : false;
+        const nextActiveTabId = activeStillExists
+          ? state.activeTabId
+          : (newTabs.length > 0 ? newTabs[newTabs.length - 1].id : null);
+        const sameActiveContext = state.activeContext
+          && state.activeContext.connectionId === targetConnectionId
+          && state.activeContext.dbName === targetDbName;
+        return {
+          tabs: newTabs,
+          activeTabId: nextActiveTabId,
+          activeContext: sameActiveContext ? null : state.activeContext,
+        };
+      }),
+
       closeAllTabs: () => set(() => ({ tabs: [], activeTabId: null })),
       
       setActiveTab: (id) => set({ activeTabId: id }),
@@ -132,13 +503,77 @@ export const useStore = create<AppState>()(
       setAppearance: (appearance) => set((state) => ({ appearance: { ...state.appearance, ...appearance } })),
       setSqlFormatOptions: (options) => set({ sqlFormatOptions: options }),
       setQueryOptions: (options) => set((state) => ({ queryOptions: { ...state.queryOptions, ...options } })),
-      
+
       addSqlLog: (log) => set((state) => ({ sqlLogs: [log, ...state.sqlLogs].slice(0, 1000) })), // Keep last 1000 logs
       clearSqlLogs: () => set({ sqlLogs: [] }),
+
+      recordTableAccess: (connectionId, dbName, tableName) => set((state) => {
+        const key = `${connectionId}-${dbName}-${tableName}`;
+        const currentCount = state.tableAccessCount[key] || 0;
+        return {
+          tableAccessCount: {
+            ...state.tableAccessCount,
+            [key]: currentCount + 1
+          }
+        };
+      }),
+
+      setTableSortPreference: (connectionId, dbName, sortBy) => set((state) => {
+        const key = `${connectionId}-${dbName}`;
+        return {
+          tableSortPreference: {
+            ...state.tableSortPreference,
+            [key]: sortBy
+          }
+        };
+      }),
     }),
     {
       name: 'lite-db-storage', // name of the item in the storage (must be unique)
-      partialize: (state) => ({ connections: state.connections, savedQueries: state.savedQueries, theme: state.theme, appearance: state.appearance, sqlFormatOptions: state.sqlFormatOptions, queryOptions: state.queryOptions }), // Don't persist logs
+      version: 3,
+      migrate: (persistedState: unknown, version: number) => {
+        if (!persistedState || typeof persistedState !== 'object') {
+          return persistedState as AppState;
+        }
+        const state = persistedState as Partial<AppState>;
+        const nextState: Partial<AppState> = { ...state };
+        nextState.connections = sanitizeConnections(state.connections);
+        nextState.savedQueries = sanitizeSavedQueries(state.savedQueries);
+        nextState.theme = sanitizeTheme(state.theme);
+        nextState.appearance = sanitizeAppearance(state.appearance, version);
+        nextState.sqlFormatOptions = sanitizeSqlFormatOptions(state.sqlFormatOptions);
+        nextState.queryOptions = sanitizeQueryOptions(state.queryOptions);
+        nextState.tableAccessCount = sanitizeTableAccessCount(state.tableAccessCount);
+        nextState.tableSortPreference = sanitizeTableSortPreference(state.tableSortPreference);
+        return nextState as AppState;
+      },
+      merge: (persistedState, currentState) => {
+        const state = (persistedState && typeof persistedState === 'object')
+          ? persistedState as Partial<AppState>
+          : {};
+        return {
+          ...currentState,
+          ...state,
+          connections: sanitizeConnections(state.connections),
+          savedQueries: sanitizeSavedQueries(state.savedQueries),
+          theme: sanitizeTheme(state.theme),
+          appearance: sanitizeAppearance(state.appearance, 3),
+          sqlFormatOptions: sanitizeSqlFormatOptions(state.sqlFormatOptions),
+          queryOptions: sanitizeQueryOptions(state.queryOptions),
+          tableAccessCount: sanitizeTableAccessCount(state.tableAccessCount),
+          tableSortPreference: sanitizeTableSortPreference(state.tableSortPreference),
+        };
+      },
+      partialize: (state) => ({
+        connections: state.connections,
+        savedQueries: state.savedQueries,
+        theme: state.theme,
+        appearance: state.appearance,
+        sqlFormatOptions: state.sqlFormatOptions,
+        queryOptions: state.queryOptions,
+        tableAccessCount: state.tableAccessCount,
+        tableSortPreference: state.tableSortPreference
+      }), // Don't persist logs
     }
   )
 );

frontend/src/types.ts

@@ -12,10 +12,35 @@ export interface ConnectionConfig {
   port: number;
   user: string;
   password?: string;
+  savePassword?: boolean;
   database?: string;
   useSSH?: boolean;
   ssh?: SSHConfig;
+  driver?: string;
+  dsn?: string;
+  timeout?: number;
   redisDB?: number; // Redis database index (0-15)
+  uri?: string; // Connection URI for copy/paste
+  hosts?: string[]; // Multi-host addresses: host:port
+  topology?: 'single' | 'replica';
+  mysqlReplicaUser?: string;
+  mysqlReplicaPassword?: string;
+  replicaSet?: string;
+  authSource?: string;
+  readPreference?: string;
+  mongoSrv?: boolean;
+  mongoAuthMechanism?: string;
+  mongoReplicaUser?: string;
+  mongoReplicaPassword?: string;
+}
+
+export interface MongoMemberInfo {
+  host: string;
+  role: string;
+  state: string;
+  stateCode?: number;
+  healthy: boolean;
+  isSelf?: boolean;
 }
 
 export interface SavedConnection {
@@ -62,7 +87,7 @@ export interface TriggerDefinition {
 export interface TabData {
   id: string;
   title: string;
-  type: 'query' | 'table' | 'design' | 'redis-keys' | 'redis-command';
+  type: 'query' | 'table' | 'design' | 'redis-keys' | 'redis-command' | 'trigger' | 'view-def' | 'routine-def';
   connectionId: string;
   dbName?: string;
   tableName?: string;
@@ -70,6 +95,10 @@ export interface TabData {
   initialTab?: string;
   readOnly?: boolean;
   redisDB?: number; // Redis database index for redis tabs
+  triggerName?: string; // Trigger name for trigger tabs
+  viewName?: string; // View name for view definition tabs
+  routineName?: string; // Routine name for function/procedure definition tabs
+  routineType?: string; // 'FUNCTION' or 'PROCEDURE'
 }
 
 export interface DatabaseNode {
@@ -102,7 +131,7 @@ export interface RedisScanResult {
 }
 
 export interface RedisValue {
-  type: 'string' | 'hash' | 'list' | 'set' | 'zset';
+  type: 'string' | 'hash' | 'list' | 'set' | 'zset' | 'stream';
   ttl: number;
   value: any;
   length: number;
@@ -117,3 +146,8 @@ export interface ZSetMember {
   member: string;
   score: number;
 }
+
+export interface StreamEntry {
+  id: string;
+  fields: Record<string, string>;
+}

frontend/src/utils/appearance.ts

@@ -0,0 +1,66 @@
+const DEFAULT_OPACITY = 1.0;
+const MIN_OPACITY = 0.1;
+const MAX_OPACITY = 1.0;
+
+// 平台透明度映射因子：值越大，滑块变化越平滑（1.0 = 线性映射）
+const MAC_OPACITY_FACTOR = 0.60;
+const MAC_BLUR_FACTOR = 1.00;
+const WINDOWS_OPACITY_FACTOR = 0.70;
+const WINDOWS_BLUR_FACTOR = 1.00;
+
+const clamp = (value: number, min: number, max: number) => Math.min(max, Math.max(min, value));
+
+export const isMacLikePlatform = (): boolean => {
+  if (typeof navigator === 'undefined') {
+    return false;
+  }
+  const platform = navigator.platform || '';
+  const ua = navigator.userAgent || '';
+  return /(Mac|iPhone|iPad|iPod)/i.test(`${platform} ${ua}`);
+};
+
+export const isWindowsPlatform = (): boolean => {
+  if (typeof navigator === 'undefined') {
+    return false;
+  }
+  const platform = navigator.platform || '';
+  const ua = navigator.userAgent || '';
+  return /(Win|Windows)/i.test(`${platform} ${ua}`);
+};
+
+const getPlatformFactors = () => {
+  if (isMacLikePlatform()) {
+    return { opacity: MAC_OPACITY_FACTOR, blur: MAC_BLUR_FACTOR };
+  }
+  if (isWindowsPlatform()) {
+    return { opacity: WINDOWS_OPACITY_FACTOR, blur: WINDOWS_BLUR_FACTOR };
+  }
+  return undefined;
+};
+
+export const normalizeOpacityForPlatform = (opacity: number | undefined): number => {
+  const raw = clamp(opacity ?? DEFAULT_OPACITY, MIN_OPACITY, MAX_OPACITY);
+  // 用户显式拉到 100%% 时，必须保持完全不透明，不能再被平台映射压低。
+  if (raw >= MAX_OPACITY - 1e-6) {
+    return MAX_OPACITY;
+  }
+  const factors = getPlatformFactors();
+  if (!factors) {
+    return raw;
+  }
+
+  return clamp(MIN_OPACITY + (raw - MIN_OPACITY) * factors.opacity, MIN_OPACITY, MAX_OPACITY);
+};
+
+export const normalizeBlurForPlatform = (blur: number | undefined): number => {
+  const raw = Math.max(0, blur ?? 0);
+  const factors = getPlatformFactors();
+  if (!factors) {
+    return raw;
+  }
+  return Math.round(raw * factors.blur);
+};
+
+export const blurToFilter = (blur: number): string | undefined => {
+  return blur > 0 ? `blur(${blur}px)` : undefined;
+};

frontend/src/utils/sql.ts

@@ -1,5 +1,6 @@
 export type FilterCondition = {
   id?: number;
+  enabled?: boolean;
   column?: string;
   op?: string;
   value?: string;
@@ -23,6 +24,8 @@ const needsQuote = (ident: string): boolean => {
   if (!ident) return false;
   // 如果包含特殊字符（非字母、数字、下划线）则需要引号
   if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(ident)) return true;
+  // PostgreSQL 会将未加引号的标识符折叠为小写，含大写字母时必须加引号
+  if (/[A-Z]/.test(ident)) return true;
   // 常见 SQL 保留字列表（简化版）
   const reserved = ['select', 'from', 'where', 'table', 'index', 'user', 'order', 'group', 'by', 'limit', 'offset', 'and', 'or', 'not', 'null', 'true', 'false', 'key', 'primary', 'foreign', 'references', 'default', 'constraint', 'create', 'drop', 'alter', 'insert', 'update', 'delete', 'set', 'values', 'into', 'join', 'left', 'right', 'inner', 'outer', 'on', 'as', 'is', 'in', 'like', 'between', 'case', 'when', 'then', 'else', 'end', 'having', 'distinct', 'all', 'any', 'exists', 'union', 'except', 'intersect'];
   return reserved.includes(ident.toLowerCase());
@@ -33,7 +36,7 @@ export const quoteIdentPart = (dbType: string, ident: string) => {
   if (!raw) return raw;
   const dbTypeLower = (dbType || '').toLowerCase();
 
-  if (dbTypeLower === 'mysql') {
+  if (dbTypeLower === 'mysql' || dbTypeLower === 'mariadb' || dbTypeLower === 'diros' || dbTypeLower === 'sphinx' || dbTypeLower === 'tdengine') {
     return `\`${raw.replace(/`/g, '``')}\``;
   }
 
@@ -60,6 +63,76 @@ export const quoteQualifiedIdent = (dbType: string, ident: string) => {
 
 export const escapeLiteral = (val: string) => (val || '').replace(/'/g, "''");
 
+type SortInfo = {
+  columnKey?: string;
+  order?: string;
+} | null | undefined;
+
+// 为排序查询按库类型注入 sort_buffer 提升参数（仅影响当前语句）。
+// MySQL: 使用 Optimizer Hint `SET_VAR`。
+// MariaDB: 使用 `SET STATEMENT ... FOR` 包装当前查询。
+export const withSortBufferTuningSQL = (
+  dbType: string,
+  sql: string,
+  sortBufferBytes: number,
+) => {
+  const rawSql = String(sql || '');
+  const trimmed = rawSql.trim();
+  if (!trimmed) return rawSql;
+  if (!/^select\b/i.test(trimmed)) return rawSql;
+
+  const normalizedType = String(dbType || '').trim().toLowerCase();
+  const bytes = Math.max(256 * 1024, Math.floor(Number(sortBufferBytes) || 0));
+  if (normalizedType === 'mysql') {
+    return rawSql.replace(
+      /^\s*select\b/i,
+      (matched) => `${matched} /*+ SET_VAR(sort_buffer_size=${bytes}) */`,
+    );
+  }
+  if (normalizedType === 'mariadb') {
+    return `SET STATEMENT sort_buffer_size=${bytes} FOR ${rawSql}`;
+  }
+  return rawSql;
+};
+
+export const buildOrderBySQL = (
+  dbType: string,
+  sortInfo: SortInfo,
+  fallbackColumns: string[] = [],
+) => {
+  const dbTypeLower = String(dbType || '').trim().toLowerCase();
+  const sortColumn = normalizeIdentPart(String(sortInfo?.columnKey || ''));
+  const sortOrder = String(sortInfo?.order || '');
+  const direction = sortOrder === 'ascend' ? 'ASC' : sortOrder === 'descend' ? 'DESC' : '';
+  if (sortColumn && direction) {
+    return ` ORDER BY ${quoteIdentPart(dbType, sortColumn)} ${direction}`;
+  }
+
+  // MySQL/MariaDB 大表在无显式排序需求时强制 ORDER BY（即使按主键）可能触发 filesort，
+  // 导致 `Error 1038 (HY001): Out of sort memory`。
+  // 因此仅在用户主动点击排序时下发 ORDER BY，默认分页查询不加兜底排序。
+  if (dbTypeLower === 'mysql' || dbTypeLower === 'mariadb' || dbTypeLower === 'diros') {
+    return '';
+  }
+
+  const seen = new Set<string>();
+  const stableColumns = (fallbackColumns || [])
+    .map((col) => normalizeIdentPart(String(col || '')))
+    .filter((col) => {
+      if (!col) return false;
+      const key = col.toLowerCase();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  if (stableColumns.length > 0) {
+    const parts = stableColumns.map((col) => `${quoteIdentPart(dbType, col)} ASC`);
+    return ` ORDER BY ${parts.join(', ')}`;
+  }
+
+  return '';
+};
+
 export const parseListValues = (val: string) => {
   const raw = (val || '').trim();
   if (!raw) return [];
@@ -73,6 +146,8 @@ export const buildWhereSQL = (dbType: string, conditions: FilterCondition[]) =>
   const whereParts: string[] = [];
 
   (conditions || []).forEach((cond) => {
+    if (cond?.enabled === false) return;
+
     const op = (cond?.op || '').trim();
     const column = (cond?.column || '').trim();
     const value = (cond?.value ?? '').toString();
@@ -195,4 +270,3 @@ export const buildWhereSQL = (dbType: string, conditions: FilterCondition[]) =>
 
   return whereParts.length > 0 ? `WHERE ${whereParts.join(' AND ')}` : '';
 };
-

frontend/src/vite-env.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="vite/client" />
+

frontend/vite.config.ts

@@ -1,6 +1,54 @@
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 
+const normalizeModuleId = (id: string): string => id.replace(/\\/g, '/')
+
+const sanitizeChunkToken = (raw: string): string =>
+  String(raw || '')
+    .trim()
+    .replace(/[^a-zA-Z0-9_-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '') || 'misc'
+
+const firstSegmentAfter = (id: string, marker: string): string => {
+  const idx = id.indexOf(marker)
+  if (idx < 0) return ''
+  const rest = id.substring(idx + marker.length)
+  const [segment] = rest.split('/')
+  return sanitizeChunkToken(segment)
+}
+
+const resolveMonacoChunk = (id: string, prefix: string): string | undefined => {
+  if (!id.includes('/node_modules/monaco-editor/')) return undefined
+
+  if (id.includes('/esm/vs/language/typescript/')) {
+    if (id.includes('typescriptServices')) return `${prefix}-ts-services`
+    return `${prefix}-typescript`
+  }
+  if (id.includes('/esm/vs/language/json/')) return `${prefix}-json`
+  if (id.includes('/esm/vs/language/css/')) return `${prefix}-css`
+  if (id.includes('/esm/vs/language/html/')) return `${prefix}-html`
+
+  if (id.includes('/esm/vs/editor/contrib/')) {
+    return `${prefix}-editor-contrib-${firstSegmentAfter(id, '/esm/vs/editor/contrib/')}`
+  }
+  if (id.includes('/esm/vs/editor/browser/')) {
+    return `${prefix}-editor-browser-${firstSegmentAfter(id, '/esm/vs/editor/browser/')}`
+  }
+  if (id.includes('/esm/vs/editor/common/')) {
+    return `${prefix}-editor-common-${firstSegmentAfter(id, '/esm/vs/editor/common/')}`
+  }
+  if (id.includes('/esm/vs/editor/')) return `${prefix}-editor`
+
+  if (id.includes('/esm/vs/base/browser/')) return `${prefix}-base-browser`
+  if (id.includes('/esm/vs/base/common/')) return `${prefix}-base-common`
+  if (id.includes('/esm/vs/base/')) return `${prefix}-base`
+
+  if (id.includes('/esm/vs/platform/')) return `${prefix}-platform`
+
+  return `${prefix}-misc`
+}
+
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [react()],
@@ -11,5 +59,61 @@ export default defineConfig({
   build: {
     outDir: 'dist', // Standard Wails output directory
     emptyOutDir: true,
-  }
-})
+    rollupOptions: {
+      output: {
+        manualChunks(id) {
+          const moduleId = normalizeModuleId(id)
+          if (!moduleId.includes('node_modules')) return undefined
+
+          const monacoChunk = resolveMonacoChunk(moduleId, 'vendor-monaco')
+          if (monacoChunk) {
+            return monacoChunk
+          }
+          if (moduleId.includes('/node_modules/@monaco-editor/react/')) return 'vendor-monaco-react'
+
+          if (moduleId.includes('/node_modules/antd/es/')) {
+            return `vendor-antd-${firstSegmentAfter(moduleId, '/node_modules/antd/es/')}`
+          }
+          if (moduleId.includes('/node_modules/antd/')) return 'vendor-antd'
+          if (moduleId.includes('/node_modules/@ant-design/icons/')) return 'vendor-antd-icons'
+          if (moduleId.includes('/node_modules/@ant-design/cssinjs/')) return 'vendor-antd-css'
+          if (moduleId.includes('/node_modules/rc-')) return 'vendor-antd-rc'
+
+          if (moduleId.includes('/node_modules/@dnd-kit/')) return 'vendor-dnd-kit'
+          if (moduleId.includes('/node_modules/sql-formatter/')) return 'vendor-sql-formatter'
+
+          if (
+            moduleId.includes('/node_modules/react/')
+            || moduleId.includes('/node_modules/react-dom/')
+            || moduleId.includes('/node_modules/scheduler/')
+          ) {
+            return 'vendor-react'
+          }
+
+          if (
+            moduleId.includes('/node_modules/zustand/')
+            || moduleId.includes('/node_modules/uuid/')
+            || moduleId.includes('/node_modules/clsx/')
+            || moduleId.includes('/node_modules/react-resizable/')
+          ) {
+            return 'vendor-utils'
+          }
+
+          return 'vendor-misc'
+        },
+      },
+    },
+  },
+  worker: {
+    format: 'es',
+    rollupOptions: {
+      output: {
+        manualChunks(id) {
+          const moduleId = normalizeModuleId(id)
+          if (!moduleId.includes('node_modules')) return undefined
+          return resolveMonacoChunk(moduleId, 'worker-monaco')
+        },
+      },
+    },
+  },
+})

frontend/wailsjs/go/app/App.d.ts

@@ -8,6 +8,8 @@ export function ApplyChanges(arg1:connection.ConnectionConfig,arg2:string,arg3:s
 
 export function CheckForUpdates():Promise<connection.QueryResult>;
 
+export function ConfigureDriverRuntimeDirectory(arg1:string):Promise<connection.QueryResult>;
+
 export function CreateDatabase(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
 
 export function DBConnect(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
@@ -36,8 +38,18 @@ export function DataSyncAnalyze(arg1:sync.SyncConfig):Promise<connection.QueryRe
 
 export function DataSyncPreview(arg1:sync.SyncConfig,arg2:string,arg3:number):Promise<connection.QueryResult>;
 
+export function DownloadDriverPackage(arg1:string,arg2:string,arg3:string):Promise<connection.QueryResult>;
+
 export function DownloadUpdate():Promise<connection.QueryResult>;
 
+export function DropDatabase(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
+
+export function DropFunction(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string):Promise<connection.QueryResult>;
+
+export function DropTable(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;
+
+export function DropView(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;
+
 export function ExportData(arg1:Array<Record<string, any>>,arg2:Array<string>,arg3:string,arg4:string):Promise<connection.QueryResult>;
 
 export function ExportDatabaseSQL(arg1:connection.ConnectionConfig,arg2:string,arg3:boolean):Promise<connection.QueryResult>;
@@ -46,16 +58,26 @@ export function ExportQuery(arg1:connection.ConnectionConfig,arg2:string,arg3:st
 
 export function ExportTable(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string):Promise<connection.QueryResult>;
 
+export function ExportTablesDataSQL(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
+
 export function ExportTablesSQL(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>,arg4:boolean):Promise<connection.QueryResult>;
 
 export function GetAppInfo():Promise<connection.QueryResult>;
 
+export function GetDriverStatusList(arg1:string,arg2:string):Promise<connection.QueryResult>;
+
 export function ImportConfigFile():Promise<connection.QueryResult>;
 
 export function ImportData(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;
 
+export function ImportDataWithProgress(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string):Promise<connection.QueryResult>;
+
+export function InstallLocalDriverPackage(arg1:string,arg2:string,arg3:string):Promise<connection.QueryResult>;
+
 export function InstallUpdateAndRestart():Promise<connection.QueryResult>;
 
+export function MongoDiscoverMembers(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
+
 export function MySQLConnect(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
 
 export function MySQLGetDatabases(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
@@ -68,6 +90,8 @@ export function MySQLShowCreateTable(arg1:connection.ConnectionConfig,arg2:strin
 
 export function OpenSQLFile():Promise<connection.QueryResult>;
 
+export function PreviewImportFile(arg1:string):Promise<connection.QueryResult>;
+
 export function RedisConnect(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
 
 export function RedisDeleteHashField(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
@@ -104,10 +128,36 @@ export function RedisSetString(arg1:connection.ConnectionConfig,arg2:string,arg3
 
 export function RedisSetTTL(arg1:connection.ConnectionConfig,arg2:string,arg3:number):Promise<connection.QueryResult>;
 
+export function RedisStreamAdd(arg1:connection.ConnectionConfig,arg2:string,arg3:Record<string, string>,arg4:string):Promise<connection.QueryResult>;
+
+export function RedisStreamDelete(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
+
 export function RedisTestConnection(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
 
 export function RedisZSetAdd(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<redis.ZSetMember>):Promise<connection.QueryResult>;
 
 export function RedisZSetRemove(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
 
+export function RemoveDriverPackage(arg1:string,arg2:string):Promise<connection.QueryResult>;
+
+export function RenameDatabase(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;
+
+export function RenameTable(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string):Promise<connection.QueryResult>;
+
+export function RenameView(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string):Promise<connection.QueryResult>;
+
+export function ResolveDriverDownloadDirectory(arg1:string):Promise<connection.QueryResult>;
+
+export function ResolveDriverPackageDownloadURL(arg1:string,arg2:string):Promise<connection.QueryResult>;
+
+export function ResolveDriverRepositoryURL(arg1:string):Promise<connection.QueryResult>;
+
+export function SelectDriverDownloadDirectory(arg1:string):Promise<connection.QueryResult>;
+
+export function SelectDriverPackageFile(arg1:string):Promise<connection.QueryResult>;
+
+export function SelectSSHKeyFile(arg1:string):Promise<connection.QueryResult>;
+
+export function SetWindowTranslucency(arg1:number,arg2:number):Promise<void>;
+
 export function TestConnection(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;

frontend/wailsjs/go/app/App.js

@@ -10,6 +10,10 @@ export function CheckForUpdates() {
   return window['go']['app']['App']['CheckForUpdates']();
 }
 
+export function ConfigureDriverRuntimeDirectory(arg1) {
+  return window['go']['app']['App']['ConfigureDriverRuntimeDirectory'](arg1);
+}
+
 export function CreateDatabase(arg1, arg2) {
   return window['go']['app']['App']['CreateDatabase'](arg1, arg2);
 }
@@ -66,10 +70,30 @@ export function DataSyncPreview(arg1, arg2, arg3) {
   return window['go']['app']['App']['DataSyncPreview'](arg1, arg2, arg3);
 }
 
+export function DownloadDriverPackage(arg1, arg2, arg3) {
+  return window['go']['app']['App']['DownloadDriverPackage'](arg1, arg2, arg3);
+}
+
 export function DownloadUpdate() {
   return window['go']['app']['App']['DownloadUpdate']();
 }
 
+export function DropDatabase(arg1, arg2) {
+  return window['go']['app']['App']['DropDatabase'](arg1, arg2);
+}
+
+export function DropFunction(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['DropFunction'](arg1, arg2, arg3, arg4);
+}
+
+export function DropTable(arg1, arg2, arg3) {
+  return window['go']['app']['App']['DropTable'](arg1, arg2, arg3);
+}
+
+export function DropView(arg1, arg2, arg3) {
+  return window['go']['app']['App']['DropView'](arg1, arg2, arg3);
+}
+
 export function ExportData(arg1, arg2, arg3, arg4) {
   return window['go']['app']['App']['ExportData'](arg1, arg2, arg3, arg4);
 }
@@ -86,6 +110,10 @@ export function ExportTable(arg1, arg2, arg3, arg4) {
   return window['go']['app']['App']['ExportTable'](arg1, arg2, arg3, arg4);
 }
 
+export function ExportTablesDataSQL(arg1, arg2, arg3) {
+  return window['go']['app']['App']['ExportTablesDataSQL'](arg1, arg2, arg3);
+}
+
 export function ExportTablesSQL(arg1, arg2, arg3, arg4) {
   return window['go']['app']['App']['ExportTablesSQL'](arg1, arg2, arg3, arg4);
 }
@@ -94,6 +122,10 @@ export function GetAppInfo() {
   return window['go']['app']['App']['GetAppInfo']();
 }
 
+export function GetDriverStatusList(arg1, arg2) {
+  return window['go']['app']['App']['GetDriverStatusList'](arg1, arg2);
+}
+
 export function ImportConfigFile() {
   return window['go']['app']['App']['ImportConfigFile']();
 }
@@ -102,10 +134,22 @@ export function ImportData(arg1, arg2, arg3) {
   return window['go']['app']['App']['ImportData'](arg1, arg2, arg3);
 }
 
+export function ImportDataWithProgress(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['ImportDataWithProgress'](arg1, arg2, arg3, arg4);
+}
+
+export function InstallLocalDriverPackage(arg1, arg2, arg3) {
+  return window['go']['app']['App']['InstallLocalDriverPackage'](arg1, arg2, arg3);
+}
+
 export function InstallUpdateAndRestart() {
   return window['go']['app']['App']['InstallUpdateAndRestart']();
 }
 
+export function MongoDiscoverMembers(arg1) {
+  return window['go']['app']['App']['MongoDiscoverMembers'](arg1);
+}
+
 export function MySQLConnect(arg1) {
   return window['go']['app']['App']['MySQLConnect'](arg1);
 }
@@ -130,6 +174,10 @@ export function OpenSQLFile() {
   return window['go']['app']['App']['OpenSQLFile']();
 }
 
+export function PreviewImportFile(arg1) {
+  return window['go']['app']['App']['PreviewImportFile'](arg1);
+}
+
 export function RedisConnect(arg1) {
   return window['go']['app']['App']['RedisConnect'](arg1);
 }
@@ -202,6 +250,14 @@ export function RedisSetTTL(arg1, arg2, arg3) {
   return window['go']['app']['App']['RedisSetTTL'](arg1, arg2, arg3);
 }
 
+export function RedisStreamAdd(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['RedisStreamAdd'](arg1, arg2, arg3, arg4);
+}
+
+export function RedisStreamDelete(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RedisStreamDelete'](arg1, arg2, arg3);
+}
+
 export function RedisTestConnection(arg1) {
   return window['go']['app']['App']['RedisTestConnection'](arg1);
 }
@@ -214,6 +270,50 @@ export function RedisZSetRemove(arg1, arg2, arg3) {
   return window['go']['app']['App']['RedisZSetRemove'](arg1, arg2, arg3);
 }
 
+export function RemoveDriverPackage(arg1, arg2) {
+  return window['go']['app']['App']['RemoveDriverPackage'](arg1, arg2);
+}
+
+export function RenameDatabase(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RenameDatabase'](arg1, arg2, arg3);
+}
+
+export function RenameTable(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['RenameTable'](arg1, arg2, arg3, arg4);
+}
+
+export function RenameView(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['RenameView'](arg1, arg2, arg3, arg4);
+}
+
+export function ResolveDriverDownloadDirectory(arg1) {
+  return window['go']['app']['App']['ResolveDriverDownloadDirectory'](arg1);
+}
+
+export function ResolveDriverPackageDownloadURL(arg1, arg2) {
+  return window['go']['app']['App']['ResolveDriverPackageDownloadURL'](arg1, arg2);
+}
+
+export function ResolveDriverRepositoryURL(arg1) {
+  return window['go']['app']['App']['ResolveDriverRepositoryURL'](arg1);
+}
+
+export function SelectDriverDownloadDirectory(arg1) {
+  return window['go']['app']['App']['SelectDriverDownloadDirectory'](arg1);
+}
+
+export function SelectDriverPackageFile(arg1) {
+  return window['go']['app']['App']['SelectDriverPackageFile'](arg1);
+}
+
+export function SelectSSHKeyFile(arg1) {
+  return window['go']['app']['App']['SelectSSHKeyFile'](arg1);
+}
+
+export function SetWindowTranslucency(arg1, arg2) {
+  return window['go']['app']['App']['SetWindowTranslucency'](arg1, arg2);
+}
+
 export function TestConnection(arg1) {
   return window['go']['app']['App']['TestConnection'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -74,6 +74,7 @@ export namespace connection {
 	    port: number;
 	    user: string;
 	    password: string;
+	    savePassword?: boolean;
 	    database: string;
 	    useSSH: boolean;
 	    ssh: SSHConfig;
@@ -81,6 +82,18 @@ export namespace connection {
 	    dsn?: string;
 	    timeout?: number;
 	    redisDB?: number;
+	    uri?: string;
+	    hosts?: string[];
+	    topology?: string;
+	    mysqlReplicaUser?: string;
+	    mysqlReplicaPassword?: string;
+	    replicaSet?: string;
+	    authSource?: string;
+	    readPreference?: string;
+	    mongoSrv?: boolean;
+	    mongoAuthMechanism?: string;
+	    mongoReplicaUser?: string;
+	    mongoReplicaPassword?: string;
 	
 	    static createFrom(source: any = {}) {
 	        return new ConnectionConfig(source);
@@ -93,6 +106,7 @@ export namespace connection {
 	        this.port = source["port"];
 	        this.user = source["user"];
 	        this.password = source["password"];
+	        this.savePassword = source["savePassword"];
 	        this.database = source["database"];
 	        this.useSSH = source["useSSH"];
 	        this.ssh = this.convertValues(source["ssh"], SSHConfig);
@@ -100,6 +114,18 @@ export namespace connection {
 	        this.dsn = source["dsn"];
 	        this.timeout = source["timeout"];
 	        this.redisDB = source["redisDB"];
+	        this.uri = source["uri"];
+	        this.hosts = source["hosts"];
+	        this.topology = source["topology"];
+	        this.mysqlReplicaUser = source["mysqlReplicaUser"];
+	        this.mysqlReplicaPassword = source["mysqlReplicaPassword"];
+	        this.replicaSet = source["replicaSet"];
+	        this.authSource = source["authSource"];
+	        this.readPreference = source["readPreference"];
+	        this.mongoSrv = source["mongoSrv"];
+	        this.mongoAuthMechanism = source["mongoAuthMechanism"];
+	        this.mongoReplicaUser = source["mongoReplicaUser"];
+	        this.mongoReplicaPassword = source["mongoReplicaPassword"];
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {

go.mod

@@ -5,27 +5,50 @@ go 1.24.3
 require (
 	gitea.com/kingbase/gokb v0.0.0-20201021123113-29bd62a876c3
 	gitee.com/chunanyong/dm v1.8.22
+	github.com/duckdb/duckdb-go/v2 v2.5.5
 	github.com/go-sql-driver/mysql v1.9.3
+	github.com/highgo/pq-sm3 v0.0.0
 	github.com/lib/pq v1.11.1
+	github.com/microsoft/go-mssqldb v1.9.6
 	github.com/redis/go-redis/v9 v9.17.3
 	github.com/sijms/go-ora/v2 v2.9.0
+	github.com/taosdata/driver-go/v3 v3.7.8
 	github.com/wailsapp/wails/v2 v2.11.0
+	github.com/xuri/excelize/v2 v2.10.0
+	go.mongodb.org/mongo-driver/v2 v2.5.0
 	golang.org/x/crypto v0.47.0
+	golang.org/x/text v0.33.0
 	modernc.org/sqlite v1.44.3
 )
 
 require (
 	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/apache/arrow-go/v18 v18.5.1 // indirect
 	github.com/bep/debounce v1.2.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/duckdb/duckdb-go-bindings v0.3.3 // indirect
+	github.com/duckdb/duckdb-go-bindings/lib/darwin-amd64 v0.3.3 // indirect
+	github.com/duckdb/duckdb-go-bindings/lib/darwin-arm64 v0.3.3 // indirect
+	github.com/duckdb/duckdb-go-bindings/lib/linux-amd64 v0.3.3 // indirect
+	github.com/duckdb/duckdb-go-bindings/lib/linux-arm64 v0.3.3 // indirect
+	github.com/duckdb/duckdb-go-bindings/lib/windows-amd64 v0.3.3 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
+	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
+	github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
+	github.com/golang-sql/sqlexp v0.1.0 // indirect
+	github.com/golang/snappy v1.0.0 // indirect
+	github.com/google/flatbuffers v25.12.19+incompatible // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/hashicorp/go-version v1.7.0 // indirect
 	github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.18.3 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/labstack/echo/v4 v4.13.3 // indirect
 	github.com/labstack/gommon v0.4.2 // indirect
 	github.com/leaanthony/go-ansi-parser v1.6.1 // indirect
@@ -34,22 +57,42 @@ require (
 	github.com/leaanthony/u v1.1.1 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
+	github.com/pierrec/lz4/v4 v4.1.25 // indirect
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/richardlehane/mscfb v1.0.4 // indirect
+	github.com/richardlehane/msoleps v1.0.4 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/samber/lo v1.49.1 // indirect
+	github.com/shopspring/decimal v1.4.0 // indirect
+	github.com/tiendc/go-deepcopy v1.7.1 // indirect
 	github.com/tkrajina/go-reflector v0.5.8 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	github.com/wailsapp/go-webview2 v1.0.22 // indirect
 	github.com/wailsapp/mimetype v1.4.1 // indirect
-	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect
-	golang.org/x/net v0.48.0 // indirect
+	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
+	github.com/xdg-go/scram v1.2.0 // indirect
+	github.com/xdg-go/stringprep v1.0.4 // indirect
+	github.com/xuri/efp v0.0.1 // indirect
+	github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/exp v0.0.0-20260112195511-716be5621a96 // indirect
+	golang.org/x/mod v0.32.0 // indirect
+	golang.org/x/net v0.49.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/sys v0.40.0 // indirect
-	golang.org/x/text v0.33.0 // indirect
+	golang.org/x/telemetry v0.0.0-20260116145544-c6413dc483f5 // indirect
+	golang.org/x/tools v0.41.0 // indirect
+	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
 	modernc.org/libc v1.67.6 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
 )
+
+replace github.com/highgo/pq-sm3 => ./third_party/highgo-pq

go.sum

@@ -4,6 +4,24 @@ gitea.com/kingbase/gokb v0.0.0-20201021123113-29bd62a876c3 h1:QjslQNaH5Nuap5i4ni
 gitea.com/kingbase/gokb v0.0.0-20201021123113-29bd62a876c3/go.mod h1:7lH5A1jzCXD9Nl16DzaBUOfDAT8NPrDmZwKu1p5wf94=
 gitee.com/chunanyong/dm v1.8.22 h1:H7fsrnUIvEA0jlDWew7vwELry1ff+tLMIu2Fk2cIBSg=
 gitee.com/chunanyong/dm v1.8.22/go.mod h1:EPRJnuPFgbyOFgJ0TRYCTGzhq+ZT4wdyaj/GW/LLcNg=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0 h1:Gt0j3wceWMwPmiazCa8MzMA0MfhmPIz0Qp0FJ6qcM0U=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0/go.mod h1:Ot/6aikWnKWi4l9QB7qVSwa8iMphQNqkWALMoNT3rzM=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.10.1 h1:B+blDbyVIG3WaikNxPnhPiJ1MThR03b3vKGtER95TP4=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.10.1/go.mod h1:JdM5psgjfBf5fo2uWOZhflPWyDBZ/O/CNAH9CtsuZE4=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 h1:FPKJS1T+clwv+OLGt13a8UjqeRuh0O4SJ3lUriThc+4=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1/go.mod h1:j2chePtV91HrC22tGoRX3sGY42uF13WzmmV80/OdVAA=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.3.1 h1:Wgf5rZba3YZqeTNJPtvqZoBu1sBN/L4sry+u2U3Y75w=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.3.1/go.mod h1:xxCBG/f/4Vbmh2XQJBsOmNdxWUY5j/s27jujKPbQf14=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.1.1 h1:bFWuoEKg+gImo7pvkiQEFAc8ocibADgXeiLAxWhWmkI=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.1.1/go.mod h1:Vih/3yc6yac2JzU4hzpaDupBJP0Flaia9rXXrU8xyww=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 h1:oygO0locgZJe7PpYPXT5A29ZkwJaPqcva7BVeemZOZs=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI=
+github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
+github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
+github.com/apache/arrow-go/v18 v18.5.1 h1:yaQ6zxMGgf9YCYw4/oaeOU3AULySDlAYDOcnr4LdHdI=
+github.com/apache/arrow-go/v18 v18.5.1/go.mod h1:OCCJsmdq8AsRm8FkBSSmYTwL/s4zHW9CqxeBxEytkNE=
+github.com/apache/thrift v0.22.0 h1:r7mTJdj51TMDe6RtcmNdQxgn9XcyfGDOzegMDRg47uc=
+github.com/apache/thrift v0.22.0/go.mod h1:1e7J/O1Ae6ZQMTYdy9xa3w9k+XHWPfRvdPyJeynQ+/g=
 github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
 github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
@@ -12,31 +30,75 @@ github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/duckdb/duckdb-go-bindings v0.3.3 h1:lXogtCY8hiGLQvTfK55HcgvaA3K2MrwKeZGqhIin35U=
+github.com/duckdb/duckdb-go-bindings v0.3.3/go.mod h1:zS7OpBP8zwVlP38OljRZOnqWYlNd4KLcVfMoA1JFzpk=
+github.com/duckdb/duckdb-go-bindings/lib/darwin-amd64 v0.3.3 h1:ue8BtIOSt+2Bt2fEfTAvBcQLxzBFhgfCcyzPtqQWTRA=
+github.com/duckdb/duckdb-go-bindings/lib/darwin-amd64 v0.3.3/go.mod h1:EnAvZh1kNJHp5yF+M1ZHNEvapnmt6anq1xXHVrAGqMo=
+github.com/duckdb/duckdb-go-bindings/lib/darwin-arm64 v0.3.3 h1:2TrSeTgtwi3WIvub9ba0mny+AClSNo1w0Ghszc2B8lQ=
+github.com/duckdb/duckdb-go-bindings/lib/darwin-arm64 v0.3.3/go.mod h1:IGLSeEcFhNeZF16aVjQCULD7TsFZKG5G7SyKJAXKp5c=
+github.com/duckdb/duckdb-go-bindings/lib/linux-amd64 v0.3.3 h1:GN0cexhfE7uLb7qgDmsYG324wKF15nW+O7v5+NGalS4=
+github.com/duckdb/duckdb-go-bindings/lib/linux-amd64 v0.3.3/go.mod h1:KAIynZ0GHCS7X5fRyuFnQMg/SZBPK/bS9OCOVojClxw=
+github.com/duckdb/duckdb-go-bindings/lib/linux-arm64 v0.3.3 h1:bIJV+ct6yvMXjy+N3bfILFd0fkTK50AUhUTerkY40/8=
+github.com/duckdb/duckdb-go-bindings/lib/linux-arm64 v0.3.3/go.mod h1:81SGOYoEUs8qaAfSk1wRfM5oobrIJ5KI7AzYhK6/bvQ=
+github.com/duckdb/duckdb-go-bindings/lib/windows-amd64 v0.3.3 h1:SK2sunA/MPb2T3113iFzHv6DWeu+qrsw0DizTFrvM+Q=
+github.com/duckdb/duckdb-go-bindings/lib/windows-amd64 v0.3.3/go.mod h1:K25pJL26ARblGDeuAkrdblFvUen92+CwksLtPEHRqqQ=
+github.com/duckdb/duckdb-go/v2 v2.5.5 h1:TlK8ipnzoKW2aNrjGqRkFWLCDpJDxR/VwH8ezEcvVhw=
+github.com/duckdb/duckdb-go/v2 v2.5.5/go.mod h1:6uIbC3gz36NCEygECzboygOo/Z9TeVwox/puG+ohWV0=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo=
 github.com/go-sql-driver/mysql v1.9.3/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
+github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro=
+github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
+github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
 github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
+github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA=
+github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
+github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
+github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
-github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
+github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/flatbuffers v25.12.19+incompatible h1:haMV2JRRJCe1998HeW/p0X9UaMTK6SDo0ffLn2+DbLs=
+github.com/google/flatbuffers v25.12.19+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
+github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/asmfmt v1.3.2 h1:4Ri7ox3EwapiOjCki+hw14RyKk201CN4rzyCJRFLpK4=
+github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE=
+github.com/klauspost/compress v1.18.3 h1:9PJRvfbmTabkOX8moIpXPbMMbYN60bWImDDU7L+/6zw=
+github.com/klauspost/compress v1.18.3/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
+github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
+github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY=
 github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g=
 github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
@@ -61,27 +123,61 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/microsoft/go-mssqldb v1.9.6 h1:1MNQg5UiSsokiPz3++K2KPx4moKrwIqly1wv+RyCKTw=
+github.com/microsoft/go-mssqldb v1.9.6/go.mod h1:yYMPDufyoF2vVuVCUGtZARr06DKFIhMrluTcgWlXpr4=
+github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8 h1:AMFGa4R4MiIpspGNG7Z948v4n35fFGB3RR3G/ry4FWs=
+github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY=
+github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3 h1:+n/aFZefKZp7spd8DFdX7uMikMLXX4oubIzJF4kv/wI=
+github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3/go.mod h1:RagcQ7I8IeTMnF8JTXieKnO4Z6JCsikNEzj0DwauVzE=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/pierrec/lz4/v4 v4.1.25 h1:kocOqRffaIbU5djlIBr7Wh+cx82C0vtFb0fOurZHqD0=
+github.com/pierrec/lz4/v4 v4.1.25/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/redis/go-redis/v9 v9.17.3 h1:fN29NdNrE17KttK5Ndf20buqfDZwGNgoUr9qjl1DQx4=
 github.com/redis/go-redis/v9 v9.17.3/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/richardlehane/mscfb v1.0.4 h1:WULscsljNPConisD5hR0+OyZjwK46Pfyr6mPu5ZawpM=
+github.com/richardlehane/mscfb v1.0.4/go.mod h1:YzVpcZg9czvAuhk9T+a3avCpcFPMUWm7gK3DypaEsUk=
+github.com/richardlehane/msoleps v1.0.1/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
+github.com/richardlehane/msoleps v1.0.4 h1:WuESlvhX3gH2IHcd8UqyCuFY5yiq/GR/yqaSM/9/g00=
+github.com/richardlehane/msoleps v1.0.4/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew=
 github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o=
+github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
+github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
 github.com/sijms/go-ora/v2 v2.9.0 h1:+iQbUeTeCOFMb5BsOMgUhV8KWyrv9yjKpcK4x7+MFrg=
 github.com/sijms/go-ora/v2 v2.9.0/go.mod h1:QgFInVi3ZWyqAiJwzBQA+nbKYKH77tdp1PYoCqhR2dU=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/taosdata/driver-go/v3 v3.7.8 h1:N2H6HLLZH2ve2ipcoFgG9BJS+yW0XksqNYwEdSmHaJk=
+github.com/taosdata/driver-go/v3 v3.7.8/go.mod h1:gSxBEPOueMg0rTmMO1Ug6aeD7AwGdDGvUtLrsDTTpYc=
+github.com/tiendc/go-deepcopy v1.7.1 h1:LnubftI6nYaaMOcaz0LphzwraqN8jiWTwm416sitff4=
+github.com/tiendc/go-deepcopy v1.7.1/go.mod h1:4bKjNC2r7boYOkD2IOuZpYjmlDdzjbpTRyCx+goBCJQ=
 github.com/tkrajina/go-reflector v0.5.8 h1:yPADHrwmUbMq4RGEyaOUpz2H90sRsETNVpjzo3DLVQQ=
 github.com/tkrajina/go-reflector v0.5.8/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
@@ -94,35 +190,86 @@ github.com/wailsapp/mimetype v1.4.1 h1:pQN9ycO7uo4vsUUuPeHEYoUkLVkaRntMnHJxVwYhw
 github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o=
 github.com/wailsapp/wails/v2 v2.11.0 h1:seLacV8pqupq32IjS4Y7V8ucab0WZwtK6VvUVxSBtqQ=
 github.com/wailsapp/wails/v2 v2.11.0/go.mod h1:jrf0ZaM6+GBc1wRmXsM8cIvzlg0karYin3erahI4+0k=
+github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
+github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
+github.com/xdg-go/scram v1.2.0 h1:bYKF2AEwG5rqd1BumT4gAnvwU/M9nBp2pTSxeZw7Wvs=
+github.com/xdg-go/scram v1.2.0/go.mod h1:3dlrS0iBaWKYVt2ZfA4cj48umJZ+cAEbR6/SjLA88I8=
+github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
+github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
+github.com/xuri/efp v0.0.1 h1:fws5Rv3myXyYni8uwj2qKjVaRP30PdjeYe2Y6FDsCL8=
+github.com/xuri/efp v0.0.1/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI=
+github.com/xuri/excelize/v2 v2.10.0 h1:8aKsP7JD39iKLc6dH5Tw3dgV3sPRh8uRVXu/fMstfW4=
+github.com/xuri/excelize/v2 v2.10.0/go.mod h1:SC5TzhQkaOsTWpANfm+7bJCldzcnU/jrhqkTi/iBHBU=
+github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 h1:+C0TIdyyYmzadGaL/HBLbf3WdLgC29pgyhTjAT/0nuE=
+github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
+go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
 golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
-golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY=
-golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70=
-golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
-golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
+golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
+golang.org/x/exp v0.0.0-20260112195511-716be5621a96/go.mod h1:nzimsREAkjBCIEFtHiYkrJyT+2uy9YZJB7H1k68CXZU=
+golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ=
+golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
-golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
 golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/telemetry v0.0.0-20260116145544-c6413dc483f5 h1:i0p03B68+xC1kD2QUO8JzDTPXCzhN56OLJ+IhHY8U3A=
+golang.org/x/telemetry v0.0.0-20260116145544-c6413dc483f5/go.mod h1:b7fPSJ0pKZ3ccUh8gnTONJxhn3c/PS6tyzQvyqw4iA8=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.39.0 h1:RclSuaJf32jOqZz74CkPA9qFuVTX7vhLlpfj/IGWlqY=
 golang.org/x/term v0.39.0/go.mod h1:yxzUCTP/U+FzoxfdKmLaA0RV1WgE0VY7hXBwKtY/4ww=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
 golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
-golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da h1:noIWHXmPHxILtqtCOPIhSt0ABwskkZKjD3bXGnZGpNY=
+golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=

internal/app/app.go

@@ -26,9 +26,9 @@ type cachedDatabase struct {
 
 // App struct
 type App struct {
-	ctx     context.Context
-	dbCache map[string]cachedDatabase // Cache for DB connections
-	mu      sync.RWMutex              // Mutex for cache access
+	ctx         context.Context
+	dbCache     map[string]cachedDatabase // Cache for DB connections
+	mu          sync.RWMutex              // Mutex for cache access
 	updateMu    sync.Mutex
 	updateState updateState
 }
@@ -45,9 +45,17 @@ func NewApp() *App {
 func (a *App) Startup(ctx context.Context) {
 	a.ctx = ctx
 	logger.Init()
+	applyMacWindowTranslucencyFix()
 	logger.Infof("应用启动完成")
 }
 
+// SetWindowTranslucency 动态调整 macOS 窗口透明度。
+// 前端在加载用户外观设置后、以及用户修改外观时调用此方法。
+// opacity=1.0 且 blur=0 时窗口标记为 opaque，GPU 不再持续计算窗口背后的模糊合成。
+func (a *App) SetWindowTranslucency(opacity float64, blur float64) {
+	setMacWindowTranslucency(opacity, blur)
+}
+
 // Shutdown is called when the app terminates
 func (a *App) Shutdown(ctx context.Context) {
 	logger.Infof("应用开始关闭，准备释放资源")
@@ -102,10 +110,11 @@ type withLogHint struct {
 }
 
 func (e withLogHint) Error() string {
+	message := normalizeErrorMessage(e.err)
 	if strings.TrimSpace(e.logPath) == "" {
-		return e.err.Error()
+		return message
 	}
-	return fmt.Sprintf("%s（详细日志：%s）", e.err.Error(), e.logPath)
+	return fmt.Sprintf("%s（详细日志：%s）", message, e.logPath)
 }
 
 func (e withLogHint) Unwrap() error {
@@ -124,8 +133,44 @@ func formatConnSummary(config connection.ConnectionConfig) string {
 	}
 
 	var b strings.Builder
-	b.WriteString(fmt.Sprintf("类型=%s 地址=%s:%d 数据库=%s 用户=%s 超时=%ds",
-		config.Type, config.Host, config.Port, dbName, config.User, timeoutSeconds))
+	normalizedType := strings.ToLower(strings.TrimSpace(config.Type))
+	if normalizedType == "sqlite" || normalizedType == "duckdb" {
+		path := strings.TrimSpace(config.Host)
+		if path == "" {
+			path = "(未配置)"
+		}
+		b.WriteString(fmt.Sprintf("类型=%s 路径=%s 超时=%ds", config.Type, path, timeoutSeconds))
+	} else {
+		b.WriteString(fmt.Sprintf("类型=%s 地址=%s:%d 数据库=%s 用户=%s 超时=%ds",
+			config.Type, config.Host, config.Port, dbName, config.User, timeoutSeconds))
+	}
+
+	if len(config.Hosts) > 0 {
+		b.WriteString(fmt.Sprintf(" 节点数=%d", len(config.Hosts)))
+	}
+	if strings.TrimSpace(config.Topology) != "" {
+		b.WriteString(fmt.Sprintf(" 拓扑=%s", strings.TrimSpace(config.Topology)))
+	}
+	if strings.TrimSpace(config.URI) != "" {
+		b.WriteString(fmt.Sprintf(" URI=已配置(长度=%d)", len(config.URI)))
+	}
+	if strings.TrimSpace(config.MySQLReplicaUser) != "" {
+		b.WriteString(" MySQL从库凭据=已配置")
+	}
+	if strings.EqualFold(strings.TrimSpace(config.Type), "mongodb") {
+		if strings.TrimSpace(config.MongoReplicaUser) != "" {
+			b.WriteString(" Mongo从库凭据=已配置")
+		}
+		if strings.TrimSpace(config.ReplicaSet) != "" {
+			b.WriteString(fmt.Sprintf(" 副本集=%s", strings.TrimSpace(config.ReplicaSet)))
+		}
+		if strings.TrimSpace(config.ReadPreference) != "" {
+			b.WriteString(fmt.Sprintf(" 读偏好=%s", strings.TrimSpace(config.ReadPreference)))
+		}
+		if strings.TrimSpace(config.AuthSource) != "" {
+			b.WriteString(fmt.Sprintf(" 认证库=%s", strings.TrimSpace(config.AuthSource)))
+		}
+	}
 
 	if config.UseSSH {
 		b.WriteString(fmt.Sprintf(" SSH=%s:%d 用户=%s", config.SSH.Host, config.SSH.Port, config.SSH.User))
@@ -162,6 +207,20 @@ func (a *App) getDatabaseWithPing(config connection.ConnectionConfig, forcePing
 		shortKey = shortKey[:12]
 	}
 
+	if supported, reason := db.DriverRuntimeSupportStatus(config.Type); !supported {
+		if strings.TrimSpace(reason) == "" {
+			reason = fmt.Sprintf("%s 驱动未启用，请先在驱动管理中安装启用", strings.TrimSpace(config.Type))
+		}
+		// Best-effort cleanup: if cached instance exists for this exact config, close it.
+		a.mu.Lock()
+		if cur, exists := a.dbCache[key]; exists && cur.inst != nil {
+			_ = cur.inst.Close()
+			delete(a.dbCache, key)
+		}
+		a.mu.Unlock()
+		return nil, withLogHint{err: fmt.Errorf("%s", reason), logPath: logger.Path()}
+	}
+
 	a.mu.RLock()
 	entry, ok := a.dbCache[key]
 	a.mu.RUnlock()

internal/app/db_context.go

@@ -14,8 +14,8 @@ func normalizeRunConfig(config connection.ConnectionConfig, dbName string) conne
 	}
 
 	switch strings.ToLower(strings.TrimSpace(config.Type)) {
-	case "mysql", "postgres", "kingbase":
-		// 这些类型的 dbName 表示“数据库”，需要写入连接配置以选择目标库。
+	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "highgo", "vastbase", "sqlserver", "mongodb", "tdengine":
+		// 这些类型的 dbName 表示"数据库"，需要写入连接配置以选择目标库。
 		runConfig.Database = name
 	case "dameng":
 		// 达梦使用 schema 参数，沿用现有行为：dbName 表示 schema。
@@ -45,12 +45,14 @@ func normalizeSchemaAndTable(config connection.ConnectionConfig, dbName string,
 	}
 
 	switch strings.ToLower(strings.TrimSpace(config.Type)) {
-	case "postgres", "kingbase":
-		// PG/金仓：dbName 在 UI 里是“数据库”，schema 需从 tableName 或使用默认 public。
+	case "postgres", "kingbase", "highgo", "vastbase":
+		// PG/金仓/瀚高/海量：dbName 在 UI 里是"数据库"，schema 需从 tableName 或使用默认 public。
 		return "public", rawTable
+	case "sqlserver":
+		// SQL Server：dbName 表示数据库，schema 默认 dbo
+		return "dbo", rawTable
 	default:
 		// MySQL：dbName 表示数据库；Oracle/达梦：dbName 表示 schema/owner。
 		return rawDB, rawTable
 	}
 }
-

internal/app/error_text.go

@@ -0,0 +1,100 @@
+package app
+
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/transform"
+)
+
+func normalizeErrorMessage(err error) string {
+	if err == nil {
+		return ""
+	}
+	return normalizeMixedEncodingText(err.Error())
+}
+
+func normalizeMixedEncodingText(text string) string {
+	if text == "" {
+		return text
+	}
+
+	raw := []byte(text)
+	output := make([]byte, 0, len(raw)+16)
+	suspect := make([]byte, 0, 16)
+
+	flushSuspect := func() {
+		if len(suspect) == 0 {
+			return
+		}
+
+		fallback := strings.ToValidUTF8(string(suspect), "<22>")
+		decoded, _, err := transform.Bytes(simplifiedchinese.GB18030.NewDecoder(), suspect)
+		if err == nil && utf8.Valid(decoded) {
+			candidate := string(decoded)
+			if scoreDecodedText(candidate) > scoreDecodedText(fallback) {
+				output = append(output, []byte(candidate)...)
+			} else {
+				output = append(output, []byte(fallback)...)
+			}
+		} else {
+			output = append(output, []byte(fallback)...)
+		}
+
+		suspect = suspect[:0]
+	}
+
+	for len(raw) > 0 {
+		r, size := utf8.DecodeRune(raw)
+		if r == utf8.RuneError && size == 1 {
+			suspect = append(suspect, raw[0])
+			raw = raw[1:]
+			continue
+		}
+
+		if isLikelyMojibakeRune(r) {
+			suspect = append(suspect, raw[:size]...)
+		} else {
+			flushSuspect()
+			output = append(output, raw[:size]...)
+		}
+		raw = raw[size:]
+	}
+
+	flushSuspect()
+	return string(output)
+}
+
+func isLikelyMojibakeRune(r rune) bool {
+	if r == utf8.RuneError {
+		return true
+	}
+	if r >= 0x00C0 && r <= 0x02FF {
+		return true
+	}
+	if unicode.In(r, unicode.Hebrew, unicode.Arabic, unicode.Cyrillic, unicode.Greek) {
+		return true
+	}
+	return false
+}
+
+func scoreDecodedText(text string) int {
+	score := 0
+	for _, r := range text {
+		switch {
+		case r == '<27>':
+			score -= 6
+		case unicode.Is(unicode.Han, r):
+			score += 4
+		case isLikelyMojibakeRune(r):
+			score -= 3
+		case unicode.IsPrint(r):
+			score += 1
+		default:
+			score -= 2
+		}
+	}
+	return score
+}

internal/app/error_text_test.go

@@ -0,0 +1,25 @@
+package app
+
+import "testing"
+
+func TestNormalizeMixedEncodingText_GBKErrorMessage(t *testing.T) {
+	raw := []byte("pq: ")
+	raw = append(raw, 0xD3, 0xC3, 0xBB, 0xA7) // 用户
+	raw = append(raw, []byte(` "root" Password `)...)
+	raw = append(raw, 0xC8, 0xCF, 0xD6, 0xA4, 0xCA, 0xA7, 0xB0, 0xDC) // 认证失败
+	raw = append(raw, []byte(" (28P01)")...)
+
+	got := normalizeMixedEncodingText(string(raw))
+	want := `pq: 用户 "root" Password 认证失败 (28P01)`
+	if got != want {
+		t.Fatalf("normalizeMixedEncodingText() mismatch\nwant: %q\ngot:  %q", want, got)
+	}
+}
+
+func TestNormalizeMixedEncodingText_KeepUTF8(t *testing.T) {
+	input := `连接建立后验证失败：pq: password authentication failed for user "root"`
+	got := normalizeMixedEncodingText(input)
+	if got != input {
+		t.Fatalf("expected unchanged utf8 text, got: %q", got)
+	}
+}

internal/app/methods_db.go

@@ -20,7 +20,7 @@ func (a *App) DBConnect(config connection.ConnectionConfig) connection.QueryResu
 		logger.Error(err, "DBConnect 连接失败：%s", formatConnSummary(config))
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
-	
+
 	logger.Infof("DBConnect 连接成功：%s", formatConnSummary(config))
 	return connection.QueryResult{Success: true, Message: "连接成功"}
 }
@@ -31,14 +31,49 @@ func (a *App) TestConnection(config connection.ConnectionConfig) connection.Quer
 		logger.Error(err, "TestConnection 连接测试失败：%s", formatConnSummary(config))
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
-	
+
 	logger.Infof("TestConnection 连接测试成功：%s", formatConnSummary(config))
 	return connection.QueryResult{Success: true, Message: "连接成功"}
 }
 
+func (a *App) MongoDiscoverMembers(config connection.ConnectionConfig) connection.QueryResult {
+	config.Type = "mongodb"
+
+	dbInst, err := a.getDatabaseForcePing(config)
+	if err != nil {
+		logger.Error(err, "MongoDiscoverMembers 获取连接失败：%s", formatConnSummary(config))
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	discoverable, ok := dbInst.(interface {
+		DiscoverMembers() (string, []connection.MongoMemberInfo, error)
+	})
+	if !ok {
+		return connection.QueryResult{Success: false, Message: "当前 MongoDB 驱动不支持成员发现"}
+	}
+
+	replicaSet, members, err := discoverable.DiscoverMembers()
+	if err != nil {
+		logger.Error(err, "MongoDiscoverMembers 执行失败：%s", formatConnSummary(config))
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	data := map[string]interface{}{
+		"replicaSet": replicaSet,
+		"members":    members,
+	}
+
+	logger.Infof("MongoDiscoverMembers 成功：%s 成员数=%d 副本集=%s", formatConnSummary(config), len(members), replicaSet)
+	return connection.QueryResult{
+		Success: true,
+		Message: fmt.Sprintf("发现 %d 个成员", len(members)),
+		Data:    data,
+	}
+}
+
 func (a *App) CreateDatabase(config connection.ConnectionConfig, dbName string) connection.QueryResult {
 	runConfig := config
-	runConfig.Database = "" 
+	runConfig.Database = ""
 
 	dbInst, err := a.getDatabase(runConfig)
 	if err != nil {
@@ -47,9 +82,16 @@ func (a *App) CreateDatabase(config connection.ConnectionConfig, dbName string)
 
 	escapedDbName := strings.ReplaceAll(dbName, "`", "``")
 	query := fmt.Sprintf("CREATE DATABASE `%s` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci", escapedDbName)
-	if runConfig.Type == "postgres" {
+	dbType := strings.ToLower(strings.TrimSpace(runConfig.Type))
+	if dbType == "postgres" || dbType == "kingbase" || dbType == "highgo" || dbType == "vastbase" {
 		escapedDbName = strings.ReplaceAll(dbName, `"`, `""`)
 		query = fmt.Sprintf("CREATE DATABASE \"%s\"", escapedDbName)
+	} else if dbType == "tdengine" {
+		query = fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s", quoteIdentByType(dbType, dbName))
+	} else if dbType == "mariadb" || dbType == "diros" {
+		// MariaDB uses same syntax as MySQL
+	} else if dbType == "sphinx" {
+		return connection.QueryResult{Success: false, Message: "Sphinx 暂不支持创建数据库"}
 	}
 
 	_, err = dbInst.Exec(query)
@@ -60,6 +102,234 @@ func (a *App) CreateDatabase(config connection.ConnectionConfig, dbName string)
 	return connection.QueryResult{Success: true, Message: "Database created successfully"}
 }
 
+func resolveDDLDBType(config connection.ConnectionConfig) string {
+	dbType := strings.ToLower(strings.TrimSpace(config.Type))
+	if dbType != "custom" {
+		return dbType
+	}
+
+	driver := strings.ToLower(strings.TrimSpace(config.Driver))
+	switch driver {
+	case "postgresql":
+		return "postgres"
+	case "dm":
+		return "dameng"
+	case "sqlite3":
+		return "sqlite"
+	case "sphinxql":
+		return "sphinx"
+	case "diros", "doris":
+		return "diros"
+	default:
+		return driver
+	}
+}
+
+func normalizeSchemaAndTableByType(dbType string, dbName string, tableName string) (string, string) {
+	rawTable := strings.TrimSpace(tableName)
+	rawDB := strings.TrimSpace(dbName)
+	if rawTable == "" {
+		return rawDB, rawTable
+	}
+
+	if parts := strings.SplitN(rawTable, ".", 2); len(parts) == 2 {
+		schema := strings.TrimSpace(parts[0])
+		table := strings.TrimSpace(parts[1])
+		if schema != "" && table != "" {
+			return schema, table
+		}
+	}
+
+	switch dbType {
+	case "postgres", "kingbase", "highgo", "vastbase":
+		return "public", rawTable
+	default:
+		return rawDB, rawTable
+	}
+}
+
+func quoteTableIdentByType(dbType string, schema string, table string) string {
+	s := strings.TrimSpace(schema)
+	t := strings.TrimSpace(table)
+	if s == "" {
+		return quoteIdentByType(dbType, t)
+	}
+	return fmt.Sprintf("%s.%s", quoteIdentByType(dbType, s), quoteIdentByType(dbType, t))
+}
+
+func buildRunConfigForDDL(config connection.ConnectionConfig, dbType string, dbName string) connection.ConnectionConfig {
+	runConfig := normalizeRunConfig(config, dbName)
+	if strings.EqualFold(strings.TrimSpace(config.Type), "custom") {
+		// custom 连接的 dbName 语义依赖 driver，尽量在常见驱动上对齐内置类型行为。
+		switch dbType {
+		case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "vastbase", "dameng":
+			if strings.TrimSpace(dbName) != "" {
+				runConfig.Database = strings.TrimSpace(dbName)
+			}
+		}
+	}
+	return runConfig
+}
+
+func (a *App) RenameDatabase(config connection.ConnectionConfig, oldName string, newName string) connection.QueryResult {
+	oldName = strings.TrimSpace(oldName)
+	newName = strings.TrimSpace(newName)
+	if oldName == "" || newName == "" {
+		return connection.QueryResult{Success: false, Message: "数据库名称不能为空"}
+	}
+	if strings.EqualFold(oldName, newName) {
+		return connection.QueryResult{Success: false, Message: "新旧数据库名称不能相同"}
+	}
+
+	dbType := resolveDDLDBType(config)
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx":
+		return connection.QueryResult{Success: false, Message: "MySQL/MariaDB/Diros/Sphinx 不支持直接重命名数据库，请新建库后迁移数据"}
+	case "postgres", "kingbase", "highgo", "vastbase":
+		if strings.EqualFold(strings.TrimSpace(config.Database), oldName) {
+			return connection.QueryResult{Success: false, Message: "当前连接正在使用目标数据库，请先连接到其他数据库后再重命名"}
+		}
+		runConfig := config
+		if strings.TrimSpace(runConfig.Database) == "" {
+			runConfig.Database = "postgres"
+		}
+		dbInst, err := a.getDatabase(runConfig)
+		if err != nil {
+			return connection.QueryResult{Success: false, Message: err.Error()}
+		}
+		sql := fmt.Sprintf("ALTER DATABASE %s RENAME TO %s", quoteIdentByType(dbType, oldName), quoteIdentByType(dbType, newName))
+		if _, err := dbInst.Exec(sql); err != nil {
+			return connection.QueryResult{Success: false, Message: err.Error()}
+		}
+		return connection.QueryResult{Success: true, Message: "数据库重命名成功"}
+	default:
+		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持重命名数据库", dbType)}
+	}
+}
+
+func (a *App) DropDatabase(config connection.ConnectionConfig, dbName string) connection.QueryResult {
+	dbName = strings.TrimSpace(dbName)
+	if dbName == "" {
+		return connection.QueryResult{Success: false, Message: "数据库名称不能为空"}
+	}
+
+	dbType := resolveDDLDBType(config)
+	var (
+		runConfig connection.ConnectionConfig
+		sql       string
+	)
+	switch dbType {
+	case "mysql", "mariadb", "diros", "tdengine":
+		runConfig = config
+		runConfig.Database = ""
+		sql = fmt.Sprintf("DROP DATABASE %s", quoteIdentByType(dbType, dbName))
+	case "postgres", "kingbase", "highgo", "vastbase":
+		if strings.EqualFold(strings.TrimSpace(config.Database), dbName) {
+			return connection.QueryResult{Success: false, Message: "当前连接正在使用目标数据库，请先连接到其他数据库后再删除"}
+		}
+		runConfig = config
+		if strings.TrimSpace(runConfig.Database) == "" {
+			runConfig.Database = "postgres"
+		}
+		sql = fmt.Sprintf("DROP DATABASE %s", quoteIdentByType(dbType, dbName))
+	default:
+		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持删除数据库", dbType)}
+	}
+
+	dbInst, err := a.getDatabase(runConfig)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	if _, err := dbInst.Exec(sql); err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	return connection.QueryResult{Success: true, Message: "数据库删除成功"}
+}
+
+func (a *App) RenameTable(config connection.ConnectionConfig, dbName string, oldTableName string, newTableName string) connection.QueryResult {
+	oldTableName = strings.TrimSpace(oldTableName)
+	newTableName = strings.TrimSpace(newTableName)
+	if oldTableName == "" || newTableName == "" {
+		return connection.QueryResult{Success: false, Message: "表名不能为空"}
+	}
+	if strings.EqualFold(oldTableName, newTableName) {
+		return connection.QueryResult{Success: false, Message: "新旧表名不能相同"}
+	}
+	if strings.Contains(newTableName, ".") {
+		return connection.QueryResult{Success: false, Message: "新表名不能包含 schema 或数据库前缀"}
+	}
+
+	dbType := resolveDDLDBType(config)
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "sqlite", "duckdb", "oracle", "dameng", "highgo", "vastbase", "sqlserver":
+	default:
+		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持重命名表", dbType)}
+	}
+
+	schemaName, pureOldTableName := normalizeSchemaAndTableByType(dbType, dbName, oldTableName)
+	if pureOldTableName == "" {
+		return connection.QueryResult{Success: false, Message: "旧表名不能为空"}
+	}
+	oldQualifiedTable := quoteTableIdentByType(dbType, schemaName, pureOldTableName)
+	newTableQuoted := quoteIdentByType(dbType, newTableName)
+
+	var sql string
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx":
+		newQualifiedTable := quoteTableIdentByType(dbType, schemaName, newTableName)
+		sql = fmt.Sprintf("RENAME TABLE %s TO %s", oldQualifiedTable, newQualifiedTable)
+	case "sqlserver":
+		// SQL Server 使用 sp_rename，参数为 'schema.oldname', 'newname'
+		oldFullName := schemaName + "." + pureOldTableName
+		escapedOld := strings.ReplaceAll(oldFullName, "'", "''")
+		escapedNew := strings.ReplaceAll(newTableName, "'", "''")
+		sql = fmt.Sprintf("EXEC sp_rename '%s', '%s'", escapedOld, escapedNew)
+	default:
+		sql = fmt.Sprintf("ALTER TABLE %s RENAME TO %s", oldQualifiedTable, newTableQuoted)
+	}
+
+	runConfig := buildRunConfigForDDL(config, dbType, dbName)
+	dbInst, err := a.getDatabase(runConfig)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	if _, err := dbInst.Exec(sql); err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	return connection.QueryResult{Success: true, Message: "表重命名成功"}
+}
+
+func (a *App) DropTable(config connection.ConnectionConfig, dbName string, tableName string) connection.QueryResult {
+	tableName = strings.TrimSpace(tableName)
+	if tableName == "" {
+		return connection.QueryResult{Success: false, Message: "表名不能为空"}
+	}
+
+	dbType := resolveDDLDBType(config)
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "sqlite", "duckdb", "oracle", "dameng", "highgo", "vastbase", "sqlserver", "tdengine":
+	default:
+		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持删除表", dbType)}
+	}
+
+	schemaName, pureTableName := normalizeSchemaAndTableByType(dbType, dbName, tableName)
+	if pureTableName == "" {
+		return connection.QueryResult{Success: false, Message: "表名不能为空"}
+	}
+	qualifiedTable := quoteTableIdentByType(dbType, schemaName, pureTableName)
+	sql := fmt.Sprintf("DROP TABLE %s", qualifiedTable)
+
+	runConfig := buildRunConfigForDDL(config, dbType, dbName)
+	dbInst, err := a.getDatabase(runConfig)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	if _, err := dbInst.Exec(sql); err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	return connection.QueryResult{Success: true, Message: "表删除成功"}
+}
+
 func (a *App) MySQLConnect(config connection.ConnectionConfig) connection.QueryResult {
 	config.Type = "mysql"
 	return a.DBConnect(config)
@@ -103,7 +373,12 @@ func (a *App) DBQuery(config connection.ConnectionConfig, dbName string, query s
 	defer cancel()
 
 	lowerQuery := strings.TrimSpace(strings.ToLower(query))
-	if strings.HasPrefix(lowerQuery, "select") || strings.HasPrefix(lowerQuery, "show") || strings.HasPrefix(lowerQuery, "describe") || strings.HasPrefix(lowerQuery, "explain") {
+	isReadQuery := strings.HasPrefix(lowerQuery, "select") || strings.HasPrefix(lowerQuery, "show") || strings.HasPrefix(lowerQuery, "describe") || strings.HasPrefix(lowerQuery, "explain")
+	// MongoDB JSON 命令中的 find/count/aggregate 也属于读查询
+	if !isReadQuery && strings.ToLower(strings.TrimSpace(runConfig.Type)) == "mongodb" && strings.HasPrefix(strings.TrimSpace(query), "{") {
+		isReadQuery = true
+	}
+	if isReadQuery {
 		var data []map[string]interface{}
 		var columns []string
 		if q, ok := dbInst.(interface {
@@ -156,12 +431,12 @@ func (a *App) DBGetDatabases(config connection.ConnectionConfig) connection.Quer
 		logger.Error(err, "DBGetDatabases 获取数据库列表失败：%s", formatConnSummary(config))
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
-	
+
 	var resData []map[string]string
 	for _, name := range dbs {
 		resData = append(resData, map[string]string{"Database": name})
 	}
-	
+
 	return connection.QueryResult{Success: true, Data: resData}
 }
 
@@ -190,6 +465,7 @@ func (a *App) DBGetTables(config connection.ConnectionConfig, dbName string) con
 
 func (a *App) DBShowCreateTable(config connection.ConnectionConfig, dbName string, tableName string) connection.QueryResult {
 	runConfig := normalizeRunConfig(config, dbName)
+	dbType := resolveDDLDBType(config)
 
 	dbInst, err := a.getDatabase(runConfig)
 	if err != nil {
@@ -203,10 +479,120 @@ func (a *App) DBShowCreateTable(config connection.ConnectionConfig, dbName strin
 		logger.Error(err, "DBShowCreateTable 获取建表语句失败：%s 表=%s", formatConnSummary(runConfig), tableName)
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
+	if shouldFallbackCreateStatement(dbType, sqlStr) {
+		columns, colErr := dbInst.GetColumns(schemaName, pureTableName)
+		if colErr != nil {
+			logger.Error(colErr, "DBShowCreateTable 兜底加载字段失败：%s 表=%s", formatConnSummary(runConfig), tableName)
+			return connection.QueryResult{Success: false, Message: colErr.Error()}
+		}
+		fallbackDDL, buildErr := buildFallbackCreateStatement(dbType, schemaName, pureTableName, columns)
+		if buildErr != nil {
+			logger.Error(buildErr, "DBShowCreateTable 兜底生成 DDL 失败：%s 表=%s", formatConnSummary(runConfig), tableName)
+			return connection.QueryResult{Success: false, Message: buildErr.Error()}
+		}
+		sqlStr = fallbackDDL
+	}
 
 	return connection.QueryResult{Success: true, Data: sqlStr}
 }
 
+func shouldFallbackCreateStatement(dbType string, ddl string) bool {
+	switch dbType {
+	case "postgres", "kingbase", "highgo", "vastbase":
+	default:
+		return false
+	}
+
+	trimmed := strings.TrimSpace(ddl)
+	if trimmed == "" {
+		return true
+	}
+	if hasCreateTableHead(trimmed) {
+		return false
+	}
+
+	lower := strings.ToLower(trimmed)
+	if strings.Contains(lower, "not fully supported") ||
+		strings.Contains(lower, "not directly supported") ||
+		strings.Contains(lower, "not supported") {
+		return true
+	}
+	return true
+}
+
+func hasCreateTableHead(sqlText string) bool {
+	lines := strings.Split(sqlText, "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		if strings.HasPrefix(line, "--") || strings.HasPrefix(line, "/*") || strings.HasPrefix(line, "*") {
+			continue
+		}
+		return strings.HasPrefix(strings.ToLower(line), "create table")
+	}
+	return false
+}
+
+func buildFallbackCreateStatement(dbType string, schemaName string, tableName string, columns []connection.ColumnDefinition) (string, error) {
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return "", fmt.Errorf("表名不能为空")
+	}
+	if len(columns) == 0 {
+		return "", fmt.Errorf("未获取到字段定义，无法生成建表语句")
+	}
+
+	qualifiedTable := quoteTableIdentByType(dbType, schemaName, table)
+	columnLines := make([]string, 0, len(columns)+1)
+	primaryKeys := make([]string, 0, 2)
+
+	for _, col := range columns {
+		colNameRaw := strings.TrimSpace(col.Name)
+		if colNameRaw == "" {
+			continue
+		}
+		colType := strings.TrimSpace(col.Type)
+		if colType == "" {
+			colType = "text"
+		}
+
+		colName := quoteIdentByType(dbType, colNameRaw)
+		defParts := []string{fmt.Sprintf("%s %s", colName, colType)}
+
+		if strings.EqualFold(strings.TrimSpace(col.Nullable), "NO") {
+			defParts = append(defParts, "NOT NULL")
+		}
+		if col.Default != nil {
+			defVal := strings.TrimSpace(*col.Default)
+			if defVal != "" {
+				defParts = append(defParts, "DEFAULT "+defVal)
+			}
+		}
+
+		columnLines = append(columnLines, "  "+strings.Join(defParts, " "))
+		if strings.EqualFold(strings.TrimSpace(col.Key), "PRI") {
+			primaryKeys = append(primaryKeys, colName)
+		}
+	}
+
+	if len(columnLines) == 0 {
+		return "", fmt.Errorf("字段定义为空，无法生成建表语句")
+	}
+	if len(primaryKeys) > 0 {
+		columnLines = append(columnLines, "  PRIMARY KEY ("+strings.Join(primaryKeys, ", ")+")")
+	}
+
+	ddl := strings.Builder{}
+	ddl.WriteString("CREATE TABLE ")
+	ddl.WriteString(qualifiedTable)
+	ddl.WriteString(" (\n")
+	ddl.WriteString(strings.Join(columnLines, ",\n"))
+	ddl.WriteString("\n);")
+	return ddl.String(), nil
+}
+
 func (a *App) DBGetColumns(config connection.ConnectionConfig, dbName string, tableName string) connection.QueryResult {
 	runConfig := normalizeRunConfig(config, dbName)
 
@@ -275,6 +661,128 @@ func (a *App) DBGetTriggers(config connection.ConnectionConfig, dbName string, t
 	return connection.QueryResult{Success: true, Data: triggers}
 }
 
+func (a *App) DropView(config connection.ConnectionConfig, dbName string, viewName string) connection.QueryResult {
+	viewName = strings.TrimSpace(viewName)
+	if viewName == "" {
+		return connection.QueryResult{Success: false, Message: "视图名称不能为空"}
+	}
+
+	dbType := resolveDDLDBType(config)
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "sqlite", "duckdb", "oracle", "dameng", "highgo", "vastbase", "sqlserver":
+	default:
+		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持删除视图", dbType)}
+	}
+
+	schemaName, pureViewName := normalizeSchemaAndTableByType(dbType, dbName, viewName)
+	if pureViewName == "" {
+		return connection.QueryResult{Success: false, Message: "视图名称不能为空"}
+	}
+	qualifiedView := quoteTableIdentByType(dbType, schemaName, pureViewName)
+	sql := fmt.Sprintf("DROP VIEW %s", qualifiedView)
+
+	runConfig := buildRunConfigForDDL(config, dbType, dbName)
+	dbInst, err := a.getDatabase(runConfig)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	if _, err := dbInst.Exec(sql); err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	return connection.QueryResult{Success: true, Message: "视图删除成功"}
+}
+
+func (a *App) DropFunction(config connection.ConnectionConfig, dbName string, routineName string, routineType string) connection.QueryResult {
+	routineName = strings.TrimSpace(routineName)
+	routineType = strings.TrimSpace(strings.ToUpper(routineType))
+	if routineName == "" {
+		return connection.QueryResult{Success: false, Message: "函数/存储过程名称不能为空"}
+	}
+	if routineType != "FUNCTION" && routineType != "PROCEDURE" {
+		routineType = "FUNCTION"
+	}
+
+	dbType := resolveDDLDBType(config)
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "oracle", "dameng", "highgo", "vastbase", "sqlserver", "duckdb":
+	default:
+		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持删除函数/存储过程", dbType)}
+	}
+	if dbType == "duckdb" && routineType == "PROCEDURE" {
+		return connection.QueryResult{Success: false, Message: "DuckDB 暂不支持存储过程"}
+	}
+
+	schemaName, pureName := normalizeSchemaAndTableByType(dbType, dbName, routineName)
+	if pureName == "" {
+		return connection.QueryResult{Success: false, Message: "函数/存储过程名称不能为空"}
+	}
+	qualifiedName := quoteTableIdentByType(dbType, schemaName, pureName)
+	sql := fmt.Sprintf("DROP %s %s", routineType, qualifiedName)
+
+	runConfig := buildRunConfigForDDL(config, dbType, dbName)
+	dbInst, err := a.getDatabase(runConfig)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	if _, err := dbInst.Exec(sql); err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	label := "函数"
+	if routineType == "PROCEDURE" {
+		label = "存储过程"
+	}
+	return connection.QueryResult{Success: true, Message: fmt.Sprintf("%s删除成功", label)}
+}
+
+func (a *App) RenameView(config connection.ConnectionConfig, dbName string, oldName string, newName string) connection.QueryResult {
+	oldName = strings.TrimSpace(oldName)
+	newName = strings.TrimSpace(newName)
+	if oldName == "" || newName == "" {
+		return connection.QueryResult{Success: false, Message: "视图名称不能为空"}
+	}
+	if strings.EqualFold(oldName, newName) {
+		return connection.QueryResult{Success: false, Message: "新旧视图名称不能相同"}
+	}
+	if strings.Contains(newName, ".") {
+		return connection.QueryResult{Success: false, Message: "新视图名不能包含 schema 或数据库前缀"}
+	}
+
+	dbType := resolveDDLDBType(config)
+	schemaName, pureOldName := normalizeSchemaAndTableByType(dbType, dbName, oldName)
+	if pureOldName == "" {
+		return connection.QueryResult{Success: false, Message: "旧视图名不能为空"}
+	}
+	oldQualified := quoteTableIdentByType(dbType, schemaName, pureOldName)
+	newQuoted := quoteIdentByType(dbType, newName)
+
+	var sql string
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx":
+		newQualified := quoteTableIdentByType(dbType, schemaName, newName)
+		sql = fmt.Sprintf("RENAME TABLE %s TO %s", oldQualified, newQualified)
+	case "postgres", "kingbase", "highgo", "vastbase":
+		sql = fmt.Sprintf("ALTER VIEW %s RENAME TO %s", oldQualified, newQuoted)
+	case "sqlserver":
+		oldFullName := schemaName + "." + pureOldName
+		escapedOld := strings.ReplaceAll(oldFullName, "'", "''")
+		escapedNew := strings.ReplaceAll(newName, "'", "''")
+		sql = fmt.Sprintf("EXEC sp_rename '%s', '%s'", escapedOld, escapedNew)
+	default:
+		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持重命名视图", dbType)}
+	}
+
+	runConfig := buildRunConfigForDDL(config, dbType, dbName)
+	dbInst, err := a.getDatabase(runConfig)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	if _, err := dbInst.Exec(sql); err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	return connection.QueryResult{Success: true, Message: "视图重命名成功"}
+}
+
 func (a *App) DBGetAllColumns(config connection.ConnectionConfig, dbName string) connection.QueryResult {
 	runConfig := normalizeRunConfig(config, dbName)
 

internal/app/methods_redis.go

@@ -450,6 +450,40 @@ func (a *App) RedisZSetRemove(config connection.ConnectionConfig, key string, me
 	return connection.QueryResult{Success: true, Message: "删除成功"}
 }
 
+// RedisStreamAdd adds an entry to a stream
+func (a *App) RedisStreamAdd(config connection.ConnectionConfig, key string, fields map[string]string, id string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	newID, err := client.StreamAdd(key, fields, id)
+	if err != nil {
+		logger.Error(err, "RedisStreamAdd 添加失败：key=%s id=%s", key, id)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "添加成功", Data: map[string]string{"id": newID}}
+}
+
+// RedisStreamDelete deletes stream entries by IDs
+func (a *App) RedisStreamDelete(config connection.ConnectionConfig, key string, ids []string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	deleted, err := client.StreamDelete(key, ids...)
+	if err != nil {
+		logger.Error(err, "RedisStreamDelete 删除失败：key=%s ids=%v", key, ids)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "删除成功", Data: map[string]int64{"deleted": deleted}}
+}
+
 // RedisFlushDB flushes the current database
 func (a *App) RedisFlushDB(config connection.ConnectionConfig) connection.QueryResult {
 	config.Type = "redis"

internal/app/methods_update.go

@@ -7,11 +7,13 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
 	stdRuntime "runtime"
+	"strconv"
 	"strings"
 	"time"
 
@@ -22,15 +24,16 @@ import (
 )
 
 const (
-	updateRepo          = "Syngnat/GoNavi"
-	updateAPIURL        = "https://api.github.com/repos/" + updateRepo + "/releases/latest"
-	updateChecksumAsset = "SHA256SUMS"
+	updateRepo                  = "Syngnat/GoNavi"
+	updateAPIURL                = "https://api.github.com/repos/" + updateRepo + "/releases/latest"
+	updateChecksumAsset         = "SHA256SUMS"
+	updateDownloadProgressEvent = "update:download-progress"
 )
 
 type updateState struct {
-	lastCheck  *UpdateInfo
+	lastCheck   *UpdateInfo
 	downloading bool
-	staged     *stagedUpdate
+	staged      *stagedUpdate
 }
 
 type UpdateInfo struct {
@@ -43,30 +46,50 @@ type UpdateInfo struct {
 	AssetURL        string `json:"assetUrl"`
 	AssetSize       int64  `json:"assetSize"`
 	SHA256          string `json:"sha256"`
+	Downloaded      bool   `json:"downloaded"`
+	DownloadPath    string `json:"downloadPath,omitempty"`
 }
 
 type AppInfo struct {
-	Version   string `json:"version"`
-	Author    string `json:"author"`
-	RepoURL   string `json:"repoUrl,omitempty"`
-	IssueURL  string `json:"issueUrl,omitempty"`
+	Version    string `json:"version"`
+	Author     string `json:"author"`
+	RepoURL    string `json:"repoUrl,omitempty"`
+	IssueURL   string `json:"issueUrl,omitempty"`
 	ReleaseURL string `json:"releaseUrl,omitempty"`
-	BuildTime string `json:"buildTime,omitempty"`
+	BuildTime  string `json:"buildTime,omitempty"`
+}
+
+type updateDownloadResult struct {
+	Info           UpdateInfo `json:"info"`
+	DownloadPath   string     `json:"downloadPath,omitempty"`
+	InstallLogPath string     `json:"installLogPath,omitempty"`
+	InstallTarget  string     `json:"installTarget,omitempty"`
+	Platform       string     `json:"platform"`
+	AutoRelaunch   bool       `json:"autoRelaunch"`
+}
+
+type updateDownloadProgressPayload struct {
+	Status     string  `json:"status"`
+	Percent    float64 `json:"percent"`
+	Downloaded int64   `json:"downloaded"`
+	Total      int64   `json:"total"`
+	Message    string  `json:"message,omitempty"`
 }
 
 type stagedUpdate struct {
-	Version   string
-	AssetName string
-	FilePath  string
-	StagedDir string
+	Version        string
+	AssetName      string
+	FilePath       string
+	StagedDir      string
+	InstallLogPath string
 }
 
 type githubRelease struct {
-	TagName    string         `json:"tag_name"`
-	Name       string         `json:"name"`
-	HTMLURL    string         `json:"html_url"`
-	Prerelease bool           `json:"prerelease"`
-	Assets     []githubAsset  `json:"assets"`
+	TagName    string        `json:"tag_name"`
+	Name       string        `json:"name"`
+	HTMLURL    string        `json:"html_url"`
+	Prerelease bool          `json:"prerelease"`
+	Assets     []githubAsset `json:"assets"`
 }
 
 type githubAsset struct {
@@ -82,8 +105,27 @@ func (a *App) CheckForUpdates() connection.QueryResult {
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
 
+	var currentStaged *stagedUpdate
+	a.updateMu.Lock()
+	currentStaged = a.updateState.staged
+	a.updateMu.Unlock()
+
+	if info.HasUpdate {
+		reusable := resolveReusableStagedUpdate(info, currentStaged)
+		if reusable != nil {
+			info.Downloaded = true
+			info.DownloadPath = reusable.FilePath
+			currentStaged = reusable
+		} else if currentStaged != nil && currentStaged.Version != info.LatestVersion {
+			currentStaged = nil
+		}
+	} else {
+		currentStaged = nil
+	}
+
 	a.updateMu.Lock()
 	a.updateState.lastCheck = &info
+	a.updateState.staged = currentStaged
 	a.updateMu.Unlock()
 
 	msg := "已是最新版本"
@@ -95,12 +137,12 @@ func (a *App) CheckForUpdates() connection.QueryResult {
 
 func (a *App) GetAppInfo() connection.QueryResult {
 	info := AppInfo{
-		Version:   getCurrentVersion(),
-		Author:    getCurrentAuthor(),
-		RepoURL:   "https://github.com/" + updateRepo,
-		IssueURL:  "https://github.com/" + updateRepo + "/issues",
+		Version:    getCurrentVersion(),
+		Author:     getCurrentAuthor(),
+		RepoURL:    "https://github.com/" + updateRepo,
+		IssueURL:   "https://github.com/" + updateRepo + "/issues",
 		ReleaseURL: "https://github.com/" + updateRepo + "/releases",
-		BuildTime: strings.TrimSpace(AppBuildTime),
+		BuildTime:  strings.TrimSpace(AppBuildTime),
 	}
 	return connection.QueryResult{Success: true, Message: "OK", Data: info}
 }
@@ -124,13 +166,17 @@ func (a *App) DownloadUpdate() connection.QueryResult {
 		a.updateMu.Unlock()
 		return connection.QueryResult{Success: false, Message: "未找到可用的更新包"}
 	}
-	if a.updateState.staged != nil && a.updateState.staged.Version == info.LatestVersion {
+	staged := resolveReusableStagedUpdate(*info, a.updateState.staged)
+	if staged != nil {
+		a.updateState.staged = staged
 		a.updateMu.Unlock()
-		return connection.QueryResult{Success: true, Message: "更新包已下载完成", Data: info}
+		return connection.QueryResult{Success: true, Message: "更新包已下载完成", Data: buildUpdateDownloadResult(*info, staged)}
 	}
+	a.updateState.staged = nil
 	a.updateState.downloading = true
 	a.updateMu.Unlock()
 
+	a.emitUpdateDownloadProgress("start", 0, info.AssetSize, "")
 	result := a.downloadAndStageUpdate(*info)
 
 	a.updateMu.Lock()
@@ -143,6 +189,9 @@ func (a *App) DownloadUpdate() connection.QueryResult {
 func (a *App) InstallUpdateAndRestart() connection.QueryResult {
 	a.updateMu.Lock()
 	staged := a.updateState.staged
+	if staged != nil && strings.TrimSpace(staged.InstallLogPath) == "" {
+		staged.InstallLogPath = buildUpdateInstallLogPath(filepath.Dir(staged.FilePath))
+	}
 	a.updateMu.Unlock()
 	if staged == nil {
 		return connection.QueryResult{Success: false, Message: "未找到已下载的更新包"}
@@ -150,49 +199,118 @@ func (a *App) InstallUpdateAndRestart() connection.QueryResult {
 
 	if err := launchUpdateScript(staged); err != nil {
 		logger.Error(err, "启动更新脚本失败")
-		return connection.QueryResult{Success: false, Message: err.Error()}
+		msg := err.Error()
+		if staged.InstallLogPath != "" {
+			msg = fmt.Sprintf("%s（更新日志：%s）", msg, staged.InstallLogPath)
+		}
+		return connection.QueryResult{
+			Success: false,
+			Message: msg,
+			Data: map[string]any{
+				"logPath": staged.InstallLogPath,
+			},
+		}
 	}
 
 	go func() {
 		time.Sleep(300 * time.Millisecond)
 		wailsRuntime.Quit(a.ctx)
+		// 兜底退出，避免某些平台/窗口状态下 Quit 未真正结束进程，导致更新脚本一直等待。
+		time.Sleep(2 * time.Second)
+		os.Exit(0)
 	}()
 
-	return connection.QueryResult{Success: true, Message: "更新已开始安装"}
+	msg := "更新已开始安装"
+	if staged.InstallLogPath != "" {
+		msg = fmt.Sprintf("更新已开始安装，日志路径：%s", staged.InstallLogPath)
+	}
+	return connection.QueryResult{
+		Success: true,
+		Message: msg,
+		Data: map[string]any{
+			"logPath": staged.InstallLogPath,
+		},
+	}
 }
 
 func (a *App) downloadAndStageUpdate(info UpdateInfo) connection.QueryResult {
-	stagedDir, err := os.MkdirTemp("", "gonavi-update-")
-	if err != nil {
-		return connection.QueryResult{Success: false, Message: "创建临时目录失败"}
+	workspaceDir := strings.TrimSpace(resolveUpdateWorkspaceDir(info.LatestVersion))
+	if workspaceDir == "" {
+		a.emitUpdateDownloadProgress("error", 0, info.AssetSize, "无法确定当前应用目录")
+		return connection.QueryResult{Success: false, Message: "无法确定当前应用目录，无法下载更新"}
+	}
+	if err := os.MkdirAll(workspaceDir, 0o755); err != nil {
+		errMsg := fmt.Sprintf("无法访问应用目录：%s", workspaceDir)
+		a.emitUpdateDownloadProgress("error", 0, info.AssetSize, errMsg)
+		return connection.QueryResult{Success: false, Message: errMsg}
 	}
 
-	assetPath := filepath.Join(stagedDir, info.AssetName)
-	actualHash, err := downloadFileWithHash(info.AssetURL, assetPath)
+	// 使用版本号命名的工作目录，便于识别和调试
+	stagedDir := filepath.Join(workspaceDir, fmt.Sprintf(".gonavi-update-%s-%s", stdRuntime.GOOS, info.LatestVersion))
+	// 清理可能残留的旧目录（上次下载失败后未清理）
+	// Windows 上文件可能被杀毒软件/索引服务占用，需要重试
+	for retry := 0; retry < 5; retry++ {
+		err := os.RemoveAll(stagedDir)
+		if err == nil {
+			break
+		}
+		if retry < 4 {
+			time.Sleep(time.Duration(retry+1) * 500 * time.Millisecond)
+		} else {
+			// 最后一次仍然失败，换一个带时间戳的目录名避免冲突
+			stagedDir = filepath.Join(workspaceDir, fmt.Sprintf(".gonavi-update-%s-%s-%d", stdRuntime.GOOS, info.LatestVersion, time.Now().UnixNano()))
+		}
+	}
+	if err := os.MkdirAll(stagedDir, 0o755); err != nil {
+		errMsg := fmt.Sprintf("无法在应用目录创建更新工作目录：%s", stagedDir)
+		a.emitUpdateDownloadProgress("error", 0, info.AssetSize, errMsg)
+		return connection.QueryResult{Success: false, Message: errMsg}
+	}
+
+	// macOS 下载包放在桌面版本目录根级；其他平台继续放在 staging 目录。
+	assetPath := resolveUpdateAssetPath(workspaceDir, stagedDir, info.AssetName)
+	actualHash, err := downloadFileWithHash(info.AssetURL, assetPath, func(downloaded, total int64) {
+		reportTotal := total
+		if reportTotal <= 0 {
+			reportTotal = info.AssetSize
+		}
+		a.emitUpdateDownloadProgress("downloading", downloaded, reportTotal, "")
+	})
 	if err != nil {
+		_ = os.Remove(assetPath)
 		_ = os.RemoveAll(stagedDir)
+		a.emitUpdateDownloadProgress("error", 0, info.AssetSize, err.Error())
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
 
 	if info.SHA256 == "" {
+		_ = os.Remove(assetPath)
 		_ = os.RemoveAll(stagedDir)
+		a.emitUpdateDownloadProgress("error", 0, info.AssetSize, "缺少更新包校验值（SHA256SUMS）")
 		return connection.QueryResult{Success: false, Message: "缺少更新包校验值（SHA256SUMS）"}
 	}
 	if !strings.EqualFold(info.SHA256, actualHash) {
+		_ = os.Remove(assetPath)
 		_ = os.RemoveAll(stagedDir)
+		a.emitUpdateDownloadProgress("error", 0, info.AssetSize, "更新包校验失败，请重试")
 		return connection.QueryResult{Success: false, Message: "更新包校验失败，请重试"}
 	}
 
-	a.updateMu.Lock()
-	a.updateState.staged = &stagedUpdate{
-		Version:   info.LatestVersion,
-		AssetName: info.AssetName,
-		FilePath:  assetPath,
-		StagedDir: stagedDir,
+	staged := &stagedUpdate{
+		Version:        info.LatestVersion,
+		AssetName:      info.AssetName,
+		FilePath:       assetPath,
+		StagedDir:      stagedDir,
+		InstallLogPath: buildUpdateInstallLogPath(workspaceDir),
 	}
+	info.Downloaded = true
+	info.DownloadPath = assetPath
+	a.updateMu.Lock()
+	a.updateState.staged = staged
 	a.updateMu.Unlock()
 
-	return connection.QueryResult{Success: true, Message: "更新包下载完成", Data: info}
+	a.emitUpdateDownloadProgress("done", info.AssetSize, info.AssetSize, "")
+	return connection.QueryResult{Success: true, Message: "更新包下载完成", Data: buildUpdateDownloadResult(info, staged)}
 }
 
 func fetchLatestUpdateInfo() (UpdateInfo, error) {
@@ -207,7 +325,11 @@ func fetchLatestUpdateInfo() (UpdateInfo, error) {
 		return UpdateInfo{}, errors.New("无法解析最新版本号")
 	}
 
-	assetName, err := expectedAssetName(stdRuntime.GOOS, stdRuntime.GOARCH)
+	assetVersion := strings.TrimSpace(release.TagName)
+	if assetVersion == "" {
+		assetVersion = latestVersion
+	}
+	assetName, err := expectedAssetName(stdRuntime.GOOS, stdRuntime.GOARCH, assetVersion)
 	if err != nil {
 		return UpdateInfo{}, err
 	}
@@ -277,25 +399,32 @@ func fetchLatestRelease() (*githubRelease, error) {
 	return &release, nil
 }
 
-func expectedAssetName(goos, goarch string) (string, error) {
+func expectedAssetName(goos, goarch, version string) (string, error) {
+	version = strings.TrimSpace(version)
+	version = strings.TrimPrefix(version, "v")
+	version = strings.TrimPrefix(version, "V")
+	if version == "" {
+		return "", errors.New("无法解析发布版本号")
+	}
+
 	switch goos {
 	case "windows":
 		if goarch == "amd64" {
-			return "GoNavi-windows-amd64.exe", nil
+			return fmt.Sprintf("GoNavi-%s-Windows-Amd64.exe", version), nil
 		}
 		if goarch == "arm64" {
-			return "GoNavi-windows-arm64.exe", nil
+			return fmt.Sprintf("GoNavi-%s-Windows-Arm64.exe", version), nil
 		}
 	case "darwin":
 		if goarch == "amd64" {
-			return "GoNavi-mac-amd64.dmg", nil
+			return fmt.Sprintf("GoNavi-%s-MacOS-Amd64.dmg", version), nil
 		}
 		if goarch == "arm64" {
-			return "GoNavi-mac-arm64.dmg", nil
+			return fmt.Sprintf("GoNavi-%s-MacOS-Arm64.dmg", version), nil
 		}
 	case "linux":
 		if goarch == "amd64" {
-			return "GoNavi-linux-amd64.tar.gz", nil
+			return fmt.Sprintf("GoNavi-%s-Linux-Amd64.tar.gz", version), nil
 		}
 	}
 	return "", fmt.Errorf("当前平台暂不支持在线更新：%s/%s", goos, goarch)
@@ -367,7 +496,32 @@ func parseSHA256Sums(content string) map[string]string {
 	return result
 }
 
-func downloadFileWithHash(url, filePath string) (string, error) {
+type downloadProgressWriter struct {
+	total      int64
+	written    int64
+	lastEmit   time.Time
+	emitEvery  time.Duration
+	onProgress func(downloaded, total int64)
+}
+
+func (w *downloadProgressWriter) Write(p []byte) (int, error) {
+	n := len(p)
+	if n == 0 {
+		return 0, nil
+	}
+	w.written += int64(n)
+	if w.onProgress == nil {
+		return n, nil
+	}
+	now := time.Now()
+	if w.lastEmit.IsZero() || now.Sub(w.lastEmit) >= w.emitEvery || (w.total > 0 && w.written >= w.total) {
+		w.lastEmit = now
+		w.onProgress(w.written, w.total)
+	}
+	return n, nil
+}
+
+func downloadFileWithHash(url, filePath string, onProgress func(downloaded, total int64)) (string, error) {
 	client := &http.Client{Timeout: 10 * time.Minute}
 	req, err := http.NewRequest(http.MethodGet, url, nil)
 	if err != nil {
@@ -385,21 +539,253 @@ func downloadFileWithHash(url, filePath string) (string, error) {
 		return "", fmt.Errorf("下载更新包失败：HTTP %d", resp.StatusCode)
 	}
 
-	out, err := os.Create(filePath)
-	if err != nil {
-		return "", err
+	// Windows 上旧文件可能被杀毒软件/索引服务占用，先尝试删除并重试
+	_ = os.Remove(filePath)
+	var out *os.File
+	for retry := 0; retry < 5; retry++ {
+		out, err = os.Create(filePath)
+		if err == nil {
+			break
+		}
+		if retry < 4 {
+			time.Sleep(time.Duration(retry+1) * 500 * time.Millisecond)
+		}
+	}
+	if err != nil {
+		return "", fmt.Errorf("更新下载失败，文件被占用：%w", err)
 	}
-	defer out.Close()
 
 	hasher := sha256.New()
-	writer := io.MultiWriter(out, hasher)
-	if _, err := io.Copy(writer, resp.Body); err != nil {
+	total := resp.ContentLength
+	progressWriter := &downloadProgressWriter{
+		total:      total,
+		emitEvery:  120 * time.Millisecond,
+		onProgress: onProgress,
+	}
+	writers := []io.Writer{out, hasher, progressWriter}
+	if onProgress != nil {
+		onProgress(0, total)
+	}
+	if _, err := io.Copy(io.MultiWriter(writers...), resp.Body); err != nil {
+		out.Close()
+		return "", err
+	}
+	if onProgress != nil {
+		onProgress(progressWriter.written, total)
+	}
+
+	// 显式 Sync + Close，确保数据落盘且文件句柄释放
+	if err := out.Sync(); err != nil {
+		out.Close()
+		return "", err
+	}
+	if err := out.Close(); err != nil {
 		return "", err
 	}
 
 	return hex.EncodeToString(hasher.Sum(nil)), nil
 }
 
+func buildUpdateDownloadResult(info UpdateInfo, staged *stagedUpdate) updateDownloadResult {
+	result := updateDownloadResult{
+		Info:          info,
+		Platform:      stdRuntime.GOOS,
+		InstallTarget: resolveUpdateInstallTarget(),
+		AutoRelaunch:  true,
+	}
+	if staged != nil {
+		result.DownloadPath = staged.FilePath
+		result.InstallLogPath = staged.InstallLogPath
+	}
+	return result
+}
+
+func buildUpdateInstallLogPath(baseDir string) string {
+	platform := stdRuntime.GOOS
+	if platform == "darwin" {
+		platform = "macos"
+	}
+	logDir := strings.TrimSpace(baseDir)
+	if logDir == "" {
+		logDir = os.TempDir()
+	}
+	return filepath.Join(logDir, fmt.Sprintf("gonavi-update-%s-%d.log", platform, time.Now().UnixNano()))
+}
+
+func sanitizeVersionForPath(version string) string {
+	trimmed := strings.TrimSpace(version)
+	if trimmed == "" {
+		return "latest"
+	}
+
+	var builder strings.Builder
+	lastDash := false
+	for _, r := range trimmed {
+		isAllowed := (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '.' || r == '_' || r == '-'
+		if isAllowed {
+			builder.WriteRune(r)
+			lastDash = false
+			continue
+		}
+		if !lastDash {
+			builder.WriteRune('-')
+			lastDash = true
+		}
+	}
+
+	result := strings.Trim(builder.String(), "-")
+	if result == "" {
+		return "latest"
+	}
+	return result
+}
+
+func resolveLegacyUpdateWorkspaceDir() string {
+	return filepath.Join(os.TempDir(), "gonavi-updates")
+}
+
+func resolveUpdateWorkspaceDir(version string) string {
+	// 默认使用系统临时目录作为更新工作区，避免目录权限与锁冲突。
+	// macOS 用户要求更新包默认保存在桌面：Desktop/GoNavi-<version>/。
+	if stdRuntime.GOOS == "darwin" {
+		homeDir, err := os.UserHomeDir()
+		if err == nil && strings.TrimSpace(homeDir) != "" {
+			desktopDir := filepath.Join(homeDir, "Desktop")
+			if st, statErr := os.Stat(desktopDir); statErr == nil && st.IsDir() {
+				return filepath.Join(desktopDir, fmt.Sprintf("GoNavi-%s", sanitizeVersionForPath(version)))
+			}
+		}
+	}
+	return resolveLegacyUpdateWorkspaceDir()
+}
+
+func resolveUpdateAssetPath(workspaceDir string, stagedDir string, assetName string) string {
+	name := strings.TrimSpace(assetName)
+	if stdRuntime.GOOS == "darwin" {
+		return filepath.Join(workspaceDir, name)
+	}
+	return filepath.Join(stagedDir, name)
+}
+
+func isExistingDownloadedAsset(filePath string, expectedSize int64) bool {
+	path := strings.TrimSpace(filePath)
+	if path == "" {
+		return false
+	}
+	stat, err := os.Stat(path)
+	if err != nil || stat.IsDir() {
+		return false
+	}
+	if expectedSize > 0 && stat.Size() != expectedSize {
+		return false
+	}
+	return true
+}
+
+func resolveReusableStagedUpdate(info UpdateInfo, current *stagedUpdate) *stagedUpdate {
+	version := strings.TrimSpace(info.LatestVersion)
+	assetName := strings.TrimSpace(info.AssetName)
+	if version == "" || assetName == "" {
+		return nil
+	}
+
+	if current != nil && strings.TrimSpace(current.Version) == version {
+		currentPath := strings.TrimSpace(current.FilePath)
+		if isExistingDownloadedAsset(currentPath, info.AssetSize) {
+			if strings.TrimSpace(current.InstallLogPath) == "" {
+				current.InstallLogPath = buildUpdateInstallLogPath(filepath.Dir(currentPath))
+			}
+			return current
+		}
+	}
+
+	type pathCandidate struct {
+		workspaceDir string
+		stagedDir    string
+		assetPath    string
+	}
+	stagedDirName := fmt.Sprintf(".gonavi-update-%s-%s", stdRuntime.GOOS, version)
+	workspaceCandidates := []string{
+		resolveUpdateWorkspaceDir(version),
+		resolveLegacyUpdateWorkspaceDir(),
+	}
+	seenWorkspace := make(map[string]struct{}, len(workspaceCandidates))
+	candidates := make([]pathCandidate, 0, 4)
+	for _, workspaceDir := range workspaceCandidates {
+		workspaceDir = strings.TrimSpace(workspaceDir)
+		if workspaceDir == "" {
+			continue
+		}
+		if _, exists := seenWorkspace[workspaceDir]; exists {
+			continue
+		}
+		seenWorkspace[workspaceDir] = struct{}{}
+
+		stagedDir := filepath.Join(workspaceDir, stagedDirName)
+		assetPath := resolveUpdateAssetPath(workspaceDir, stagedDir, assetName)
+		candidates = append(candidates, pathCandidate{
+			workspaceDir: workspaceDir,
+			stagedDir:    stagedDir,
+			assetPath:    assetPath,
+		})
+		legacyAssetPath := filepath.Join(stagedDir, assetName)
+		if legacyAssetPath != assetPath {
+			candidates = append(candidates, pathCandidate{
+				workspaceDir: workspaceDir,
+				stagedDir:    stagedDir,
+				assetPath:    legacyAssetPath,
+			})
+		}
+	}
+
+	for _, candidate := range candidates {
+		if !isExistingDownloadedAsset(candidate.assetPath, info.AssetSize) {
+			continue
+		}
+		return &stagedUpdate{
+			Version:        version,
+			AssetName:      assetName,
+			FilePath:       candidate.assetPath,
+			StagedDir:      candidate.stagedDir,
+			InstallLogPath: buildUpdateInstallLogPath(candidate.workspaceDir),
+		}
+	}
+
+	return nil
+}
+
+func resolveUpdateInstallTarget() string {
+	exePath, err := os.Executable()
+	if err != nil {
+		return ""
+	}
+	exePath, _ = filepath.EvalSymlinks(exePath)
+	if stdRuntime.GOOS == "darwin" {
+		return resolveMacUpdateTarget(exePath)
+	}
+	return exePath
+}
+
+func (a *App) emitUpdateDownloadProgress(status string, downloaded, total int64, message string) {
+	if a.ctx == nil {
+		return
+	}
+	payload := updateDownloadProgressPayload{
+		Status:     status,
+		Percent:    0,
+		Downloaded: downloaded,
+		Total:      total,
+		Message:    strings.TrimSpace(message),
+	}
+	if total > 0 {
+		payload.Percent = math.Min(100, (float64(downloaded)/float64(total))*100)
+	}
+	if status == "done" && payload.Percent < 100 {
+		payload.Percent = 100
+	}
+	wailsRuntime.EventsEmit(a.ctx, updateDownloadProgressEvent, payload)
+}
+
 func launchUpdateScript(staged *stagedUpdate) error {
 	exePath, err := os.Executable()
 	if err != nil {
@@ -422,32 +808,41 @@ func launchUpdateScript(staged *stagedUpdate) error {
 
 func launchWindowsUpdate(staged *stagedUpdate, targetExe string, pid int) error {
 	scriptPath := filepath.Join(staged.StagedDir, "update.cmd")
-	content := buildWindowsScript(staged.FilePath, targetExe, staged.StagedDir, pid)
+	logPath := strings.TrimSpace(staged.InstallLogPath)
+	if logPath == "" {
+		logPath = buildUpdateInstallLogPath(filepath.Dir(staged.FilePath))
+		staged.InstallLogPath = logPath
+	}
+	content := buildWindowsScript(staged.FilePath, targetExe, staged.StagedDir, logPath, pid)
 	if err := os.WriteFile(scriptPath, []byte(content), 0o644); err != nil {
 		return err
 	}
 
+	logger.Infof("启动 Windows 更新脚本：target=%s script=%s log=%s", targetExe, scriptPath, logPath)
 	cmd := exec.Command("cmd", "/C", "start", "", scriptPath)
 	return cmd.Start()
 }
 
 func launchMacUpdate(staged *stagedUpdate, targetExe string, pid int) error {
-	targetApp := detectMacAppPath(targetExe)
-	if targetApp == "" {
-		targetApp = "/Applications/GoNavi.app"
-	}
+	targetApp := resolveMacUpdateTarget(targetExe)
 	mountDir := filepath.Join(staged.StagedDir, "mnt")
 	if err := os.MkdirAll(mountDir, 0o755); err != nil {
 		return err
 	}
+	logPath := strings.TrimSpace(staged.InstallLogPath)
+	if logPath == "" {
+		logPath = buildUpdateInstallLogPath(filepath.Dir(staged.FilePath))
+		staged.InstallLogPath = logPath
+	}
 
 	scriptPath := filepath.Join(staged.StagedDir, "update.sh")
-	content := buildMacScript(staged.FilePath, targetApp, staged.StagedDir, mountDir, pid)
+	content := buildMacScript(staged.FilePath, targetApp, staged.StagedDir, mountDir, logPath, pid)
 	if err := os.WriteFile(scriptPath, []byte(content), 0o755); err != nil {
 		return err
 	}
 
-	cmd := exec.Command("/bin/sh", scriptPath)
+	cmd := exec.Command("/bin/bash", scriptPath)
+	logger.Infof("启动 macOS 更新脚本：target=%s script=%s log=%s", targetApp, scriptPath, logPath)
 	return cmd.Start()
 }
 
@@ -462,49 +857,209 @@ func launchLinuxUpdate(staged *stagedUpdate, targetExe string, pid int) error {
 	return cmd.Start()
 }
 
-func buildWindowsScript(source, target, stagedDir string, pid int) string {
-	return fmt.Sprintf(`@echo off
-setlocal
-set "SOURCE=%s"
-set "TARGET=%s"
-set "STAGED=%s"
-set PID=%d
+func buildWindowsScript(source, target, stagedDir, logPath string, pid int) string {
+	script := `@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+set "SOURCE=__GONAVI_UPDATE_SOURCE__"
+set "TARGET=__GONAVI_UPDATE_TARGET__"
+set "STAGED=__GONAVI_UPDATE_STAGED__"
+set "LOG_FILE=__GONAVI_UPDATE_LOG__"
+set PID=__GONAVI_UPDATE_PID__
+
+call :log updater started
+if not exist "%SOURCE%" (
+  call :log source file not found: %SOURCE%
+  exit /b 1
+)
+
+for %%I in ("%TARGET%") do set "TARGET_NAME=%%~nxI"
+for %%I in ("%SOURCE%") do set "SOURCE_EXT=%%~xI"
+set "SOURCE_EXE="
+
+if /I "%SOURCE_EXT%"==".zip" (
+  set "EXTRACT_DIR=%STAGED%\_extract"
+  if exist "%EXTRACT_DIR%" (
+    rmdir /S /Q "%EXTRACT_DIR%" >> "%LOG_FILE%" 2>&1
+  )
+  mkdir "%EXTRACT_DIR%" >> "%LOG_FILE%" 2>&1
+  powershell -NoProfile -ExecutionPolicy Bypass -Command "$src=$env:SOURCE; $dst=$env:EXTRACT_DIR; Expand-Archive -LiteralPath $src -DestinationPath $dst -Force" >> "%LOG_FILE%" 2>&1
+  if %ERRORLEVEL% NEQ 0 (
+    call :log expand zip failed: %SOURCE%
+    exit /b 1
+  )
+  if exist "%EXTRACT_DIR%\%TARGET_NAME%" (
+    set "SOURCE_EXE=%EXTRACT_DIR%\%TARGET_NAME%"
+  ) else (
+    for /R "%EXTRACT_DIR%" %%F in (*.exe) do (
+      if not defined SOURCE_EXE (
+        set "SOURCE_EXE=%%~fF"
+      )
+    )
+  )
+  if not defined SOURCE_EXE (
+    call :log no executable found in portable zip: %SOURCE%
+    exit /b 1
+  )
+) else (
+  set "SOURCE_EXE=%SOURCE%"
+)
+
 :waitloop
-tasklist /FI "PID eq %%PID%%" | find "%%PID%%" >nul
-if %%ERRORLEVEL%%==0 (
+tasklist /FI "PID eq %PID%" | find "%PID%" >nul
+if %ERRORLEVEL%==0 (
   timeout /t 1 /nobreak >nul
   goto waitloop
 )
-move /Y "%%SOURCE%%" "%%TARGET%%" >nul
-start "" "%%TARGET%%"
-rmdir /S /Q "%%STAGED%%"
+call :log host process exited
+
+set /a RETRY=0
+:move_retry
+move /Y "%SOURCE_EXE%" "%TARGET%" >> "%LOG_FILE%" 2>&1
+if %ERRORLEVEL%==0 goto move_done
+
+copy /Y "%SOURCE_EXE%" "%TARGET%" >> "%LOG_FILE%" 2>&1
+if %ERRORLEVEL%==0 goto move_done
+
+set /a RETRY+=1
+if !RETRY! LSS 20 (
+  timeout /t 1 /nobreak >nul
+  goto move_retry
+)
+
+call :log replace failed after retries (portable mode, no elevation): check directory write permission or file lock
+exit /b 1
+
+:move_done
+start "" "%TARGET%" >> "%LOG_FILE%" 2>&1
+if %ERRORLEVEL% NEQ 0 (
+  call :log cmd start failed, trying powershell Start-Process
+  powershell -NoProfile -ExecutionPolicy Bypass -Command "Start-Process -FilePath '%TARGET%'" >> "%LOG_FILE%" 2>&1
+  if %ERRORLEVEL% NEQ 0 (
+    call :log relaunch failed
+    exit /b 1
+  )
+)
+rmdir /S /Q "%STAGED%" >> "%LOG_FILE%" 2>&1
+call :log update finished
 exit /b 0
-`, source, target, stagedDir, pid)
+
+:log
+echo [%date% %time%] %*>>"%LOG_FILE%"
+exit /b 0
+`
+	return strings.NewReplacer(
+		"__GONAVI_UPDATE_SOURCE__", source,
+		"__GONAVI_UPDATE_TARGET__", target,
+		"__GONAVI_UPDATE_STAGED__", stagedDir,
+		"__GONAVI_UPDATE_LOG__", logPath,
+		"__GONAVI_UPDATE_PID__", strconv.Itoa(pid),
+	).Replace(script)
 }
 
-func buildMacScript(dmgPath, targetApp, stagedDir, mountDir string, pid int) string {
+func buildMacScript(dmgPath, targetApp, stagedDir, mountDir, logPath string, pid int) string {
 	return fmt.Sprintf(`#!/bin/bash
-set -e
+set -euo pipefail
 PID=%d
 DMG="%s"
 TARGET_APP="%s"
 STAGED="%s"
 MOUNT_DIR="%s"
+LOG_FILE="%s"
+TMP_APP="${TARGET_APP}.new"
+BACKUP_APP="${TARGET_APP}.backup"
+APP_BIN_NAME=$(basename "$TARGET_APP" .app)
+APP_BIN_REL="Contents/MacOS/$APP_BIN_NAME"
+
+log() {
+  echo "[$(date '+%%Y-%%m-%%d %%H:%%M:%%S')] $*" >> "$LOG_FILE"
+}
+
+run_admin_replace() {
+  /usr/bin/osascript <<'APPLESCRIPT' "$APP_SRC" "$TARGET_APP" "$TMP_APP" "$BACKUP_APP" "$APP_BIN_REL" "$LOG_FILE"
+on run argv
+  set srcPath to item 1 of argv
+  set dstPath to item 2 of argv
+  set tmpPath to item 3 of argv
+  set bakPath to item 4 of argv
+  set binRel to item 5 of argv
+  set logPath to item 6 of argv
+  set cmd to "set -eu; " & ¬
+    "rm -rf " & quoted form of tmpPath & " " & quoted form of bakPath & "; " & ¬
+    "/usr/bin/ditto " & quoted form of srcPath & " " & quoted form of tmpPath & "; " & ¬
+    "if [ ! -x " & quoted form of (tmpPath & "/" & binRel) & " ]; then echo 'tmp app binary missing' >> " & quoted form of logPath & "; exit 1; fi; " & ¬
+    "xattr -rd com.apple.quarantine " & quoted form of tmpPath & " >> " & quoted form of logPath & " 2>&1 || true; " & ¬
+    "if [ -d " & quoted form of dstPath & " ]; then mv " & quoted form of dstPath & " " & quoted form of bakPath & "; fi; " & ¬
+    "mv " & quoted form of tmpPath & " " & quoted form of dstPath & "; " & ¬
+    "rm -rf " & quoted form of bakPath & "; " & ¬
+    "xattr -rd com.apple.quarantine " & quoted form of dstPath & " >> " & quoted form of logPath & " 2>&1 || true"
+  do shell script cmd with administrator privileges
+end run
+APPLESCRIPT
+}
+
+replace_app_direct() {
+  rm -rf "$TMP_APP" "$BACKUP_APP" >>"$LOG_FILE" 2>&1 || true
+  /usr/bin/ditto "$APP_SRC" "$TMP_APP" >>"$LOG_FILE" 2>&1
+  if [ ! -x "$TMP_APP/$APP_BIN_REL" ]; then
+    log "tmp app binary missing: $TMP_APP/$APP_BIN_REL"
+    return 1
+  fi
+  xattr -rd com.apple.quarantine "$TMP_APP" >>"$LOG_FILE" 2>&1 || true
+  if [ -d "$TARGET_APP" ]; then
+    mv "$TARGET_APP" "$BACKUP_APP" >>"$LOG_FILE" 2>&1
+  fi
+  if ! mv "$TMP_APP" "$TARGET_APP" >>"$LOG_FILE" 2>&1; then
+    log "move new app failed, trying rollback"
+    rm -rf "$TARGET_APP" >>"$LOG_FILE" 2>&1 || true
+    if [ -d "$BACKUP_APP" ]; then
+      mv "$BACKUP_APP" "$TARGET_APP" >>"$LOG_FILE" 2>&1 || true
+    fi
+    return 1
+  fi
+  rm -rf "$BACKUP_APP" >>"$LOG_FILE" 2>&1 || true
+  xattr -rd com.apple.quarantine "$TARGET_APP" >>"$LOG_FILE" 2>&1 || true
+  return 0
+}
+
+relaunch_app() {
+  if /usr/bin/open -n "$TARGET_APP" >>"$LOG_FILE" 2>&1; then
+    return 0
+  fi
+  log "open -n failed, trying binary launch"
+  "$TARGET_APP/$APP_BIN_REL" >>"$LOG_FILE" 2>&1 &
+  return 0
+}
+
+log "updater started"
 while kill -0 $PID 2>/dev/null; do
   sleep 1
 done
-hdiutil attach "$DMG" -nobrowse -quiet -mountpoint "$MOUNT_DIR"
-APP_SRC=$(ls "$MOUNT_DIR"/*.app 2>/dev/null | head -n 1)
+log "host process exited"
+hdiutil attach "$DMG" -nobrowse -quiet -mountpoint "$MOUNT_DIR" >>"$LOG_FILE" 2>&1
+APP_SRC=$(ls "$MOUNT_DIR"/*.app 2>/dev/null | head -n 1 || true)
 if [ -z "$APP_SRC" ]; then
-  hdiutil detach "$MOUNT_DIR" -quiet || true
+  log "no .app found inside dmg"
+  hdiutil detach "$MOUNT_DIR" -quiet >>"$LOG_FILE" 2>&1 || true
   exit 1
 fi
-rm -rf "$TARGET_APP"
-cp -R "$APP_SRC" "$TARGET_APP"
-hdiutil detach "$MOUNT_DIR" -quiet
-rm -rf "$MOUNT_DIR" "$DMG" "$STAGED"
-open "$TARGET_APP"
-`, pid, dmgPath, targetApp, stagedDir, mountDir)
+
+log "install target: $TARGET_APP"
+if ! replace_app_direct; then
+  log "direct replace failed, trying admin replace"
+  run_admin_replace >>"$LOG_FILE" 2>&1
+fi
+
+if [ ! -x "$TARGET_APP/$APP_BIN_REL" ]; then
+  log "target app binary missing after replace: $TARGET_APP/$APP_BIN_REL"
+  hdiutil detach "$MOUNT_DIR" -quiet >>"$LOG_FILE" 2>&1 || true
+  exit 1
+fi
+
+hdiutil detach "$MOUNT_DIR" -quiet >>"$LOG_FILE" 2>&1 || true
+rm -rf "$MOUNT_DIR" "$DMG" "$STAGED" >>"$LOG_FILE" 2>&1 || true
+relaunch_app
+log "relaunch requested"
+	`, pid, dmgPath, targetApp, stagedDir, mountDir, logPath)
 }
 
 func buildLinuxScript(tarPath, targetExe, stagedDir string, pid int) string {
@@ -537,12 +1092,31 @@ func detectMacAppPath(exePath string) string {
 	parts := strings.Split(exePath, string(filepath.Separator))
 	for i := len(parts) - 1; i >= 0; i-- {
 		if strings.HasSuffix(parts[i], ".app") {
-			return filepath.Join(parts[:i+1]...)
+			appPath := filepath.Join(parts[:i+1]...)
+			// 确保返回绝对路径
+			if !filepath.IsAbs(appPath) {
+				appPath = string(filepath.Separator) + appPath
+			}
+			return appPath
 		}
 	}
 	return ""
 }
 
+func resolveMacUpdateTarget(exePath string) string {
+	targetApp := detectMacAppPath(exePath)
+	if targetApp == "" {
+		return "/Applications/GoNavi.app"
+	}
+	targetApp = filepath.Clean(targetApp)
+	// Gatekeeper App Translocation 路径不可用于稳定覆盖更新，统一回退到 /Applications。
+	if strings.Contains(targetApp, string(filepath.Separator)+"AppTranslocation"+string(filepath.Separator)) {
+		logger.Warnf("检测到 AppTranslocation 运行路径，更新目标回退至 /Applications/GoNavi.app：%s", targetApp)
+		return "/Applications/GoNavi.app"
+	}
+	return targetApp
+}
+
 func normalizeVersion(version string) string {
 	version = strings.TrimSpace(version)
 	version = strings.TrimPrefix(version, "v")

internal/app/methods_update_windows_script_test.go

@@ -0,0 +1,40 @@
+package app
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestBuildWindowsScriptKeepsBatchForSyntax(t *testing.T) {
+	script := buildWindowsScript(
+		`C:\tmp\GoNavi-v0.4.0-windows-amd64.zip`,
+		`C:\Program Files\GoNavi\GoNavi.exe`,
+		`C:\Program Files\GoNavi\.gonavi-update-windows-v0.4.0`,
+		`C:\Program Files\GoNavi\logs\update-install.log`,
+		13579,
+	)
+
+	mustContain := []string{
+		`for %%I in ("%TARGET%") do set "TARGET_NAME=%%~nxI"`,
+		`for %%I in ("%SOURCE%") do set "SOURCE_EXT=%%~xI"`,
+		`for /R "%EXTRACT_DIR%" %%F in (*.exe) do (`,
+		`set "SOURCE_EXE=%%~fF"`,
+	}
+	for _, want := range mustContain {
+		if !strings.Contains(script, want) {
+			t.Fatalf("windows update script missing required token: %s\nscript:\n%s", want, script)
+		}
+	}
+
+	mustNotContain := []string{
+		`for %I in ("%TARGET%") do set "TARGET_NAME=%~nxI"`,
+		`for %I in ("%SOURCE%") do set "SOURCE_EXT=%~xI"`,
+		`for /R "%EXTRACT_DIR%" %F in (*.exe) do (`,
+		`set "SOURCE_EXE=%~fF"`,
+	}
+	for _, bad := range mustNotContain {
+		if strings.Contains(script, bad) {
+			t.Fatalf("windows update script contains invalid batch syntax: %s\nscript:\n%s", bad, script)
+		}
+	}
+}

internal/app/sql_sanitize.go

@@ -7,7 +7,7 @@ import (
 
 func sanitizeSQLForPgLike(dbType string, query string) string {
 	switch strings.ToLower(strings.TrimSpace(dbType)) {
-	case "postgres", "kingbase":
+	case "postgres", "kingbase", "highgo", "vastbase":
 		// 有些情况下会出现多层重复引用（例如 """"schema"""" 或 ""schema"""），单次修复不一定收敛。
 		// 这里做有限次数的迭代，直到输出不再变化。
 		out := query

internal/app/window_translucency_darwin.go

@@ -0,0 +1,121 @@
+//go:build darwin
+
+package app
+
+/*
+#cgo CFLAGS: -x objective-c -fblocks
+#cgo LDFLAGS: -framework Cocoa
+#import <Cocoa/Cocoa.h>
+#import <dispatch/dispatch.h>
+
+static void gonaviTuneWindowTranslucency(NSWindow *window) {
+	if (window == nil) {
+		return;
+	}
+	CGFloat cornerRadius = 14.0;
+
+	[window setOpaque:NO];
+	[window setBackgroundColor:[NSColor clearColor]];
+	[window setHasShadow:YES];
+	[window setMovableByWindowBackground:YES];
+
+	NSView *contentView = [window contentView];
+	if (contentView == nil) {
+		return;
+	}
+
+	[contentView setWantsLayer:YES];
+	[[contentView layer] setBackgroundColor:[[NSColor clearColor] CGColor]];
+	[[contentView layer] setCornerRadius:cornerRadius];
+	[[contentView layer] setMasksToBounds:YES];
+
+	NSVisualEffectView *effectView = nil;
+	for (NSView *subview in [contentView subviews]) {
+		if ([subview isKindOfClass:[NSVisualEffectView class]]) {
+			effectView = (NSVisualEffectView *)subview;
+			break;
+		}
+	}
+
+	if (effectView == nil) {
+		effectView = [[NSVisualEffectView alloc] initWithFrame:[contentView bounds]];
+		[effectView setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
+		[contentView addSubview:effectView positioned:NSWindowBelow relativeTo:nil];
+		[effectView release];
+	}
+
+	if (@available(macOS 10.14, *)) {
+		[effectView setMaterial:NSVisualEffectMaterialHUDWindow];
+	}
+	[effectView setBlendingMode:NSVisualEffectBlendingModeBehindWindow];
+	[effectView setState:NSVisualEffectStateActive];
+	// 默认 alpha=0（不可见），由前端根据用户外观设置动态启用
+	[effectView setAlphaValue:0.0];
+	[effectView setWantsLayer:YES];
+	[[effectView layer] setCornerRadius:cornerRadius];
+	[[effectView layer] setMasksToBounds:YES];
+}
+
+static void gonaviApplyWindowTranslucencyFix() {
+	// 启动时应用窗口透明度修复，减少重试次数以降低启动期 GPU 负载
+	for (int i = 0; i < 8; i++) {
+		dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(i * 250 * NSEC_PER_MSEC)), dispatch_get_main_queue(), ^{
+			for (NSWindow *window in [NSApp windows]) {
+				gonaviTuneWindowTranslucency(window);
+			}
+		});
+	}
+}
+
+// 动态设置 NSVisualEffectView 的透明度和窗口不透明标志。
+// alpha <= 0 时窗口标记为 opaque，GPU 不再持续计算窗口背后的模糊效果。
+static void gonaviSetEffectViewAlpha(double alpha) {
+	dispatch_async(dispatch_get_main_queue(), ^{
+		for (NSWindow *window in [NSApp windows]) {
+			NSView *contentView = [window contentView];
+			if (contentView == nil) {
+				continue;
+			}
+
+			for (NSView *subview in [contentView subviews]) {
+				if ([subview isKindOfClass:[NSVisualEffectView class]]) {
+					NSVisualEffectView *effectView = (NSVisualEffectView *)subview;
+					[effectView setAlphaValue:alpha];
+					break;
+				}
+			}
+
+			if (alpha <= 0.01) {
+				[window setOpaque:YES];
+			} else {
+				[window setOpaque:NO];
+				[window setBackgroundColor:[NSColor clearColor]];
+			}
+		}
+	});
+}
+*/
+import "C"
+
+func applyMacWindowTranslucencyFix() {
+	C.gonaviApplyWindowTranslucencyFix()
+}
+
+// setMacWindowTranslucency 根据用户外观设置动态调整 macOS 窗口透明度。
+// opacity=1.0 且 blur=0 时关闭 NSVisualEffectView（alpha=0），窗口标记为 opaque，
+// GPU 不再持续计算窗口背后的模糊合成，显著降低 CPU/GPU 温度。
+func setMacWindowTranslucency(opacity float64, blur float64) {
+	if opacity >= 0.999 && blur <= 0 {
+		C.gonaviSetEffectViewAlpha(C.double(0.0))
+	} else {
+		// 半透明模式：NSVisualEffectView alpha 根据透明度动态映射
+		alpha := (1.0 - opacity) * 1.2
+		if alpha < 0.3 {
+			alpha = 0.3
+		}
+		if alpha > 0.85 {
+			alpha = 0.85
+		}
+		C.gonaviSetEffectViewAlpha(C.double(alpha))
+	}
+}

internal/app/window_translucency_stub.go

@@ -0,0 +1,7 @@
+//go:build !darwin
+
+package app
+
+func applyMacWindowTranslucencyFix() {}
+
+func setMacWindowTranslucency(opacity float64, blur float64) {}

internal/connection/types.go

@@ -11,18 +11,31 @@ type SSHConfig struct {
 
 // ConnectionConfig holds database connection details including SSH
 type ConnectionConfig struct {
-	Type     string    `json:"type"`
-	Host     string    `json:"host"`
-	Port     int       `json:"port"`
-	User     string    `json:"user"`
-	Password string    `json:"password"`
-	Database string    `json:"database"`
-	UseSSH   bool      `json:"useSSH"`
-	SSH      SSHConfig `json:"ssh"`
-	Driver   string    `json:"driver,omitempty"`  // For custom connection
-	DSN      string    `json:"dsn,omitempty"`     // For custom connection
-	Timeout  int       `json:"timeout,omitempty"` // Connection timeout in seconds (default: 30)
-	RedisDB  int       `json:"redisDB,omitempty"` // Redis database index (0-15)
+	Type                 string    `json:"type"`
+	Host                 string    `json:"host"`
+	Port                 int       `json:"port"`
+	User                 string    `json:"user"`
+	Password             string    `json:"password"`
+	SavePassword         bool      `json:"savePassword,omitempty"` // Persist password in saved connection
+	Database             string    `json:"database"`
+	UseSSH               bool      `json:"useSSH"`
+	SSH                  SSHConfig `json:"ssh"`
+	Driver               string    `json:"driver,omitempty"`               // For custom connection
+	DSN                  string    `json:"dsn,omitempty"`                  // For custom connection
+	Timeout              int       `json:"timeout,omitempty"`              // Connection timeout in seconds (default: 30)
+	RedisDB              int       `json:"redisDB,omitempty"`              // Redis database index (0-15)
+	URI                  string    `json:"uri,omitempty"`                  // Connection URI for copy/paste
+	Hosts                []string  `json:"hosts,omitempty"`                // Multi-host addresses: host:port
+	Topology             string    `json:"topology,omitempty"`             // single | replica
+	MySQLReplicaUser     string    `json:"mysqlReplicaUser,omitempty"`     // MySQL replica auth user
+	MySQLReplicaPassword string    `json:"mysqlReplicaPassword,omitempty"` // MySQL replica auth password
+	ReplicaSet           string    `json:"replicaSet,omitempty"`           // MongoDB replica set name
+	AuthSource           string    `json:"authSource,omitempty"`           // MongoDB authSource
+	ReadPreference       string    `json:"readPreference,omitempty"`       // MongoDB readPreference
+	MongoSRV             bool      `json:"mongoSrv,omitempty"`             // MongoDB use mongodb+srv URI scheme
+	MongoAuthMechanism   string    `json:"mongoAuthMechanism,omitempty"`   // MongoDB authMechanism
+	MongoReplicaUser     string    `json:"mongoReplicaUser,omitempty"`     // MongoDB replica auth user
+	MongoReplicaPassword string    `json:"mongoReplicaPassword,omitempty"` // MongoDB replica auth password
 }
 
 // QueryResult is the standard response format for Wails methods
@@ -89,3 +102,12 @@ type ChangeSet struct {
 	Updates []UpdateRow              `json:"updates"`
 	Deletes []map[string]interface{} `json:"deletes"`
 }
+
+type MongoMemberInfo struct {
+	Host      string `json:"host"`
+	Role      string `json:"role"`
+	State     string `json:"state"`
+	StateCode int    `json:"stateCode,omitempty"`
+	Healthy   bool   `json:"healthy"`
+	IsSelf    bool   `json:"isSelf,omitempty"`
+}

internal/db/agent_process_stub.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package db
+
+import "os/exec"
+
+func configureAgentProcess(cmd *exec.Cmd) {
+	_ = cmd
+}

internal/db/agent_process_windows.go

@@ -0,0 +1,20 @@
+//go:build windows
+
+package db
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+const windowsCreateNoWindow = 0x08000000
+
+func configureAgentProcess(cmd *exec.Cmd) {
+	if cmd == nil {
+		return
+	}
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    true,
+		CreationFlags: windowsCreateNoWindow,
+	}
+}

internal/db/dameng_impl.go

@@ -1,3 +1,5 @@
+//go:build gonavi_full_drivers || gonavi_dameng_driver
+
 package db
 
 import (

internal/db/database.go

@@ -3,6 +3,7 @@ package db
 import (
 	"GoNavi-Wails/internal/connection"
 	"fmt"
+	"strings"
 )
 
 type Database interface {
@@ -25,28 +26,61 @@ type BatchApplier interface {
 	ApplyChanges(tableName string, changes connection.ChangeSet) error
 }
 
-// Factory
-func NewDatabase(dbType string) (Database, error) {
-	switch dbType {
-	case "mysql":
-		return &MySQLDB{}, nil
-	case "postgres":
-		return &PostgresDB{}, nil
-	case "sqlite":
-		return &SQLiteDB{}, nil
-	case "oracle":
-		return &OracleDB{}, nil
-	case "dameng":
-		return &DamengDB{}, nil
-	case "kingbase":
-		return &KingbaseDB{}, nil
-	case "custom":
-		return &CustomDB{}, nil
-	default:
-		// Default to MySQL for backward compatibility if empty
-		if dbType == "" {
-			return &MySQLDB{}, nil
+type databaseFactory func() Database
+
+var databaseFactories = map[string]databaseFactory{
+	"mysql": func() Database {
+		return &MySQLDB{}
+	},
+	"postgres": func() Database {
+		return &PostgresDB{}
+	},
+	"oracle": func() Database {
+		return &OracleDB{}
+	},
+	"custom": func() Database {
+		return &CustomDB{}
+	},
+}
+
+func init() {
+	registerOptionalDatabaseFactories()
+}
+
+func registerDatabaseFactory(factory databaseFactory, dbTypes ...string) {
+	if factory == nil || len(dbTypes) == 0 {
+		return
+	}
+	for _, dbType := range dbTypes {
+		normalized := normalizeDatabaseType(dbType)
+		if normalized == "" {
+			continue
 		}
-		return nil, fmt.Errorf("unsupported database type: %s", dbType)
+		databaseFactories[normalized] = factory
 	}
 }
+
+func normalizeDatabaseType(dbType string) string {
+	normalized := strings.ToLower(strings.TrimSpace(dbType))
+	switch normalized {
+	case "doris":
+		return "diros"
+	case "postgresql":
+		return "postgres"
+	default:
+		return normalized
+	}
+}
+
+// Factory
+func NewDatabase(dbType string) (Database, error) {
+	normalized := normalizeDatabaseType(dbType)
+	if normalized == "" {
+		normalized = "mysql"
+	}
+	factory, ok := databaseFactories[normalized]
+	if !ok {
+		return nil, fmt.Errorf("unsupported database type: %s", dbType)
+	}
+	return factory(), nil
+}

internal/db/database_optional_factories_full.go

@@ -0,0 +1,18 @@
+//go:build gonavi_full_drivers
+
+package db
+
+func registerOptionalDatabaseFactories() {
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("mariadb"), "mariadb")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("diros"), "diros", "doris")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("sphinx"), "sphinx")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("sqlserver"), "sqlserver")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("sqlite"), "sqlite")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("duckdb"), "duckdb")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("dameng"), "dameng")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("kingbase"), "kingbase")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("highgo"), "highgo")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("vastbase"), "vastbase")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("mongodb"), "mongodb")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("tdengine"), "tdengine")
+}

internal/db/database_optional_factories_lite.go

@@ -0,0 +1,18 @@
+//go:build !gonavi_full_drivers
+
+package db
+
+func registerOptionalDatabaseFactories() {
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("mariadb"), "mariadb")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("diros"), "diros", "doris")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("sphinx"), "sphinx")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("sqlserver"), "sqlserver")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("sqlite"), "sqlite")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("duckdb"), "duckdb")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("dameng"), "dameng")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("kingbase"), "kingbase")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("highgo"), "highgo")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("vastbase"), "vastbase")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("mongodb"), "mongodb")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("tdengine"), "tdengine")
+}

internal/db/diros_impl.go

@@ -0,0 +1,220 @@
+//go:build gonavi_full_drivers || gonavi_diros_driver
+
+package db
+
+import (
+	"database/sql"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/ssh"
+	"GoNavi-Wails/internal/utils"
+
+	mysqlDriver "github.com/go-sql-driver/mysql"
+)
+
+const (
+	dirosDriverName  = "diros"
+	defaultDirosPort = 9030
+)
+
+// DirosDB 使用独立 driver 名称（diros）接入，底层协议兼容 MySQL。
+type DirosDB struct {
+	MySQLDB
+}
+
+func init() {
+	for _, name := range sql.Drivers() {
+		if name == dirosDriverName {
+			return
+		}
+	}
+	sql.Register(dirosDriverName, &mysqlDriver.MySQLDriver{})
+}
+
+func applyDirosURI(config connection.ConnectionConfig) connection.ConnectionConfig {
+	uriText := strings.TrimSpace(config.URI)
+	if uriText == "" {
+		return config
+	}
+
+	lowerURI := strings.ToLower(uriText)
+	if !strings.HasPrefix(lowerURI, "diros://") &&
+		!strings.HasPrefix(lowerURI, "doris://") &&
+		!strings.HasPrefix(lowerURI, "mysql://") {
+		return config
+	}
+
+	parsed, err := url.Parse(uriText)
+	if err != nil {
+		return config
+	}
+
+	if parsed.User != nil {
+		if config.User == "" {
+			config.User = parsed.User.Username()
+		}
+		if pass, ok := parsed.User.Password(); ok && config.Password == "" {
+			config.Password = pass
+		}
+	}
+
+	if dbName := strings.TrimPrefix(parsed.Path, "/"); dbName != "" && config.Database == "" {
+		config.Database = dbName
+	}
+
+	defaultPort := config.Port
+	if defaultPort <= 0 {
+		defaultPort = defaultDirosPort
+	}
+
+	hostsFromURI := make([]string, 0, 4)
+	hostText := strings.TrimSpace(parsed.Host)
+	if hostText != "" {
+		for _, entry := range strings.Split(hostText, ",") {
+			host, port, ok := parseHostPortWithDefault(entry, defaultPort)
+			if !ok {
+				continue
+			}
+			hostsFromURI = append(hostsFromURI, normalizeMySQLAddress(host, port))
+		}
+	}
+
+	if len(config.Hosts) == 0 && len(hostsFromURI) > 0 {
+		config.Hosts = hostsFromURI
+	}
+	if strings.TrimSpace(config.Host) == "" && len(hostsFromURI) > 0 {
+		host, port, ok := parseHostPortWithDefault(hostsFromURI[0], defaultPort)
+		if ok {
+			config.Host = host
+			config.Port = port
+		}
+	}
+
+	if config.Topology == "" {
+		topology := strings.TrimSpace(parsed.Query().Get("topology"))
+		if topology != "" {
+			config.Topology = strings.ToLower(topology)
+		}
+	}
+
+	return config
+}
+
+func collectDirosAddresses(config connection.ConnectionConfig) []string {
+	defaultPort := config.Port
+	if defaultPort <= 0 {
+		defaultPort = defaultDirosPort
+	}
+
+	candidates := make([]string, 0, len(config.Hosts)+1)
+	if len(config.Hosts) > 0 {
+		candidates = append(candidates, config.Hosts...)
+	} else {
+		candidates = append(candidates, normalizeMySQLAddress(config.Host, defaultPort))
+	}
+
+	result := make([]string, 0, len(candidates))
+	seen := make(map[string]struct{}, len(candidates))
+	for _, entry := range candidates {
+		host, port, ok := parseHostPortWithDefault(entry, defaultPort)
+		if !ok {
+			continue
+		}
+		normalized := normalizeMySQLAddress(host, port)
+		if _, exists := seen[normalized]; exists {
+			continue
+		}
+		seen[normalized] = struct{}{}
+		result = append(result, normalized)
+	}
+
+	return result
+}
+
+func (d *DirosDB) getDSN(config connection.ConnectionConfig) string {
+	database := config.Database
+	protocol := "tcp"
+	address := normalizeMySQLAddress(config.Host, config.Port)
+
+	if config.UseSSH {
+		netName, err := ssh.RegisterSSHNetwork(config.SSH)
+		if err == nil {
+			protocol = netName
+			address = normalizeMySQLAddress(config.Host, config.Port)
+		} else {
+			logger.Warnf("注册 Diros SSH 网络失败，将尝试直连：地址=%s:%d 用户=%s，原因：%v", config.Host, config.Port, config.User, err)
+		}
+	}
+
+	timeout := getConnectTimeoutSeconds(config)
+
+	return fmt.Sprintf("%s:%s@%s(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=%ds",
+		config.User, config.Password, protocol, address, database, timeout)
+}
+
+func resolveDirosCredential(config connection.ConnectionConfig, addressIndex int) (string, string) {
+	primaryUser := strings.TrimSpace(config.User)
+	primaryPassword := config.Password
+	replicaUser := strings.TrimSpace(config.MySQLReplicaUser)
+	replicaPassword := config.MySQLReplicaPassword
+
+	if addressIndex > 0 && replicaUser != "" {
+		return replicaUser, replicaPassword
+	}
+
+	if primaryUser == "" && replicaUser != "" {
+		return replicaUser, replicaPassword
+	}
+
+	return config.User, primaryPassword
+}
+
+func (d *DirosDB) Connect(config connection.ConnectionConfig) error {
+	runConfig := applyDirosURI(config)
+	addresses := collectDirosAddresses(runConfig)
+	if len(addresses) == 0 {
+		return fmt.Errorf("连接建立后验证失败：未找到可用的 Diros 地址")
+	}
+
+	var errorDetails []string
+	for index, address := range addresses {
+		candidateConfig := runConfig
+		host, port, ok := parseHostPortWithDefault(address, defaultDirosPort)
+		if !ok {
+			continue
+		}
+		candidateConfig.Host = host
+		candidateConfig.Port = port
+		candidateConfig.User, candidateConfig.Password = resolveDirosCredential(runConfig, index)
+
+		dsn := d.getDSN(candidateConfig)
+		db, err := sql.Open(dirosDriverName, dsn)
+		if err != nil {
+			errorDetails = append(errorDetails, fmt.Sprintf("%s 打开失败: %v", address, err))
+			continue
+		}
+
+		timeout := getConnectTimeout(candidateConfig)
+		ctx, cancel := utils.ContextWithTimeout(timeout)
+		pingErr := db.PingContext(ctx)
+		cancel()
+		if pingErr != nil {
+			_ = db.Close()
+			errorDetails = append(errorDetails, fmt.Sprintf("%s 验证失败: %v", address, pingErr))
+			continue
+		}
+
+		d.conn = db
+		d.pingTimeout = timeout
+		return nil
+	}
+
+	if len(errorDetails) == 0 {
+		return fmt.Errorf("连接建立后验证失败：未找到可用的 Diros 地址")
+	}
+	return fmt.Errorf("连接建立后验证失败：%s", strings.Join(errorDetails, "；"))
+}

internal/db/driver_support.go

@@ -0,0 +1,222 @@
+package db
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+var coreBuiltinDrivers = map[string]struct{}{
+	"mysql":    {},
+	"redis":    {},
+	"oracle":   {},
+	"postgres": {},
+}
+
+// optionalGoDrivers 表示需要用户“安装启用”后才能使用的纯 Go 驱动。
+// 注意：这是一种运行时门控（installed.json 标记），并不减少主二进制体积。
+var optionalGoDrivers = map[string]struct{}{
+	"mariadb":   {},
+	"diros":     {},
+	"sphinx":    {},
+	"sqlserver": {},
+	"sqlite":    {},
+	"duckdb":    {},
+	"dameng":    {},
+	"kingbase":  {},
+	"highgo":    {},
+	"vastbase":  {},
+	"mongodb":   {},
+	"tdengine":  {},
+}
+
+var (
+	externalDriverDirMu sync.RWMutex
+	externalDriverDir   string
+)
+
+func normalizeRuntimeDriverType(driverType string) string {
+	normalized := strings.ToLower(strings.TrimSpace(driverType))
+	switch normalized {
+	case "doris":
+		return "diros"
+	case "postgresql":
+		return "postgres"
+	default:
+		return normalized
+	}
+}
+
+func driverDisplayName(driverType string) string {
+	switch normalizeRuntimeDriverType(driverType) {
+	case "mysql":
+		return "MySQL"
+	case "oracle":
+		return "Oracle"
+	case "redis":
+		return "Redis"
+	case "mariadb":
+		return "MariaDB"
+	case "diros":
+		return "Diros"
+	case "sphinx":
+		return "Sphinx"
+	case "postgres":
+		return "PostgreSQL"
+	case "sqlserver":
+		return "SQL Server"
+	case "sqlite":
+		return "SQLite"
+	case "duckdb":
+		return "DuckDB"
+	case "dameng":
+		return "Dameng"
+	case "kingbase":
+		return "Kingbase"
+	case "highgo":
+		return "HighGo"
+	case "vastbase":
+		return "Vastbase"
+	case "mongodb":
+		return "MongoDB"
+	case "tdengine":
+		return "TDengine"
+	default:
+		return strings.ToUpper(strings.TrimSpace(driverType))
+	}
+}
+
+func IsOptionalGoDriver(driverType string) bool {
+	_, ok := optionalGoDrivers[normalizeRuntimeDriverType(driverType)]
+	return ok
+}
+
+func IsOptionalGoDriverBuildIncluded(driverType string) bool {
+	return optionalGoDriverBuildIncluded(normalizeRuntimeDriverType(driverType))
+}
+
+func IsBuiltinDriver(driverType string) bool {
+	_, ok := coreBuiltinDrivers[normalizeRuntimeDriverType(driverType)]
+	return ok
+}
+
+func defaultExternalDriverDownloadDirectory() string {
+	if home, err := os.UserHomeDir(); err == nil && strings.TrimSpace(home) != "" {
+		return filepath.Join(home, ".gonavi", "drivers")
+	}
+	if wd, err := os.Getwd(); err == nil && strings.TrimSpace(wd) != "" {
+		return filepath.Join(wd, ".gonavi-drivers")
+	}
+	return ".gonavi-drivers"
+}
+
+func resolveExternalDriverRoot(downloadDir string) (string, error) {
+	root := strings.TrimSpace(downloadDir)
+	if root == "" {
+		root = currentExternalDriverDownloadDirectory()
+	}
+	if root == "" {
+		root = defaultExternalDriverDownloadDirectory()
+	}
+	if !filepath.IsAbs(root) {
+		abs, err := filepath.Abs(root)
+		if err != nil {
+			return "", err
+		}
+		root = abs
+	}
+	if err := os.MkdirAll(root, 0o755); err != nil {
+		return "", fmt.Errorf("创建驱动目录失败：%w", err)
+	}
+	return root, nil
+}
+
+func currentExternalDriverDownloadDirectory() string {
+	externalDriverDirMu.RLock()
+	current := strings.TrimSpace(externalDriverDir)
+	externalDriverDirMu.RUnlock()
+	if current != "" {
+		return current
+	}
+	return defaultExternalDriverDownloadDirectory()
+}
+
+func SetExternalDriverDownloadDirectory(downloadDir string) {
+	root, err := resolveExternalDriverRoot(downloadDir)
+	if err != nil {
+		root = defaultExternalDriverDownloadDirectory()
+	}
+	externalDriverDirMu.Lock()
+	externalDriverDir = root
+	externalDriverDirMu.Unlock()
+}
+
+func ResolveExternalDriverRoot(downloadDir string) (string, error) {
+	return resolveExternalDriverRoot(downloadDir)
+}
+
+func ResolveOptionalGoDriverMarkerPath(downloadDir string, driverType string) (string, error) {
+	normalized := normalizeRuntimeDriverType(driverType)
+	if !IsOptionalGoDriver(normalized) {
+		return "", fmt.Errorf("%s 不是可选 Go 驱动", driverDisplayName(normalized))
+	}
+	root, err := resolveExternalDriverRoot(downloadDir)
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(root, normalized, "installed.json"), nil
+}
+
+func optionalGoDriverInstalled(driverType string) bool {
+	markerPath, err := ResolveOptionalGoDriverMarkerPath("", driverType)
+	if err != nil {
+		return false
+	}
+	info, statErr := os.Stat(markerPath)
+	return statErr == nil && !info.IsDir()
+}
+
+func optionalGoDriverRuntimeReady(driverType string) (bool, string) {
+	normalized := normalizeRuntimeDriverType(driverType)
+	if !IsOptionalGoDriver(normalized) {
+		return true, ""
+	}
+	executablePath, err := ResolveOptionalDriverAgentExecutablePath("", normalized)
+	if err != nil {
+		return false, fmt.Sprintf("%s 驱动代理路径解析失败，请在驱动管理中重新安装启用", driverDisplayName(normalized))
+	}
+	info, statErr := os.Stat(executablePath)
+	if statErr != nil || info.IsDir() {
+		return false, fmt.Sprintf("%s 驱动代理缺失，请在驱动管理中重新安装启用", driverDisplayName(normalized))
+	}
+	return true, ""
+}
+
+// DriverRuntimeSupportStatus 返回当前构建下驱动是否可用（可直接用于连接）。
+func DriverRuntimeSupportStatus(driverType string) (bool, string) {
+	normalized := normalizeRuntimeDriverType(driverType)
+	if normalized == "" {
+		return false, "未识别的数据源类型"
+	}
+	if normalized == "custom" {
+		return true, ""
+	}
+	if IsBuiltinDriver(normalized) {
+		return true, ""
+	}
+	if IsOptionalGoDriver(normalized) {
+		if !IsOptionalGoDriverBuildIncluded(normalized) {
+			return false, fmt.Sprintf("%s 当前发行包为精简构建，未内置该驱动；如需使用请安装 Full 版", driverDisplayName(normalized))
+		}
+		if optionalGoDriverInstalled(normalized) {
+			if ready, reason := optionalGoDriverRuntimeReady(normalized); !ready {
+				return false, reason
+			}
+			return true, ""
+		}
+		return false, fmt.Sprintf("%s 纯 Go 驱动未启用，请先在驱动管理中点击“安装启用”", driverDisplayName(normalized))
+	}
+	return true, ""
+}

internal/db/driver_support_test.go

@@ -0,0 +1,89 @@
+package db
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestPostgresRuntimeSupportRequiresInstallMarker(t *testing.T) {
+	tmpDir := t.TempDir()
+	SetExternalDriverDownloadDirectory(tmpDir)
+
+	supported, _ := DriverRuntimeSupportStatus("postgres")
+	if !supported {
+		t.Fatalf("postgres 属于免安装内置驱动，应可用")
+	}
+	supported, reason := DriverRuntimeSupportStatus("postgres")
+	if !supported {
+		t.Fatalf("postgres 应可用，reason=%s", reason)
+	}
+}
+
+func TestBuiltinLikeDriversRemainAvailable(t *testing.T) {
+	tmpDir := t.TempDir()
+	SetExternalDriverDownloadDirectory(tmpDir)
+
+	supported, reason := DriverRuntimeSupportStatus("redis")
+	if !supported {
+		t.Fatalf("redis 应始终可用，reason=%s", reason)
+	}
+}
+
+func TestManagedDriverRequiresInstallMarker(t *testing.T) {
+	tmpDir := t.TempDir()
+	SetExternalDriverDownloadDirectory(tmpDir)
+
+	supported, _ := DriverRuntimeSupportStatus("mariadb")
+	if supported {
+		t.Fatalf("mariadb 未安装时不应可用")
+	}
+
+	if !IsOptionalGoDriverBuildIncluded("mariadb") {
+		supported, reason := DriverRuntimeSupportStatus("mariadb")
+		if supported {
+			t.Fatalf("精简构建下 mariadb 不应可用")
+		}
+		if reason == "" {
+			t.Fatalf("精简构建下 mariadb 应返回不可用原因")
+		}
+		return
+	}
+
+	markerPath, err := ResolveOptionalGoDriverMarkerPath(tmpDir, "mariadb")
+	if err != nil {
+		t.Fatalf("解析 marker 路径失败: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(markerPath), 0o755); err != nil {
+		t.Fatalf("创建 marker 目录失败: %v", err)
+	}
+	if err := os.WriteFile(markerPath, []byte("{}"), 0o644); err != nil {
+		t.Fatalf("写入 marker 失败: %v", err)
+	}
+	executablePath, err := ResolveOptionalDriverAgentExecutablePath(tmpDir, "mariadb")
+	if err != nil {
+		t.Fatalf("解析 mariadb 代理路径失败: %v", err)
+	}
+	if err := os.WriteFile(executablePath, []byte("placeholder"), 0o755); err != nil {
+		t.Fatalf("写入 mariadb 代理占位文件失败: %v", err)
+	}
+	if runtime.GOOS == "windows" {
+		_ = os.Chmod(executablePath, 0o644)
+	}
+
+	supported, reason := DriverRuntimeSupportStatus("mariadb")
+	if !supported {
+		t.Fatalf("mariadb 安装后应可用，reason=%s", reason)
+	}
+}
+
+func TestMySQLBuiltinRuntimeSupportAvailable(t *testing.T) {
+	tmpDir := t.TempDir()
+	SetExternalDriverDownloadDirectory(tmpDir)
+
+	supported, reason := DriverRuntimeSupportStatus("mysql")
+	if !supported {
+		t.Fatalf("mysql 属于免安装内置驱动，应可用，reason=%s", reason)
+	}
+}

internal/db/dsn_test.go

@@ -1,3 +1,5 @@
+//go:build gonavi_full_drivers
+
 package db
 
 import (
@@ -95,3 +97,20 @@ func TestKingbaseDSN_QuotesPasswordWithSpaces(t *testing.T) {
 		t.Fatalf("dsn 未对包含空格的密码进行引号包裹：%s", dsn)
 	}
 }
+
+func TestTDengineDSN_UsesWebSocketFormat(t *testing.T) {
+	td := &TDengineDB{}
+	cfg := connection.ConnectionConfig{
+		Type:     "tdengine",
+		Host:     "127.0.0.1",
+		Port:     6041,
+		User:     "root",
+		Password: "taosdata",
+		Database: "power",
+	}
+
+	dsn := td.getDSN(cfg)
+	if !strings.HasPrefix(dsn, "root:taosdata@ws(127.0.0.1:6041)/power") {
+		t.Fatalf("tdengine dsn 格式不正确：%s", dsn)
+	}
+}

internal/db/duckdb_driver_import.go

@@ -0,0 +1,5 @@
+//go:build (gonavi_full_drivers || gonavi_duckdb_driver) && cgo && (duckdb_use_lib || duckdb_use_static_lib || (darwin && (amd64 || arm64)) || (linux && (amd64 || arm64)) || (windows && amd64))
+
+package db
+
+import _ "github.com/duckdb/duckdb-go/v2"

internal/db/duckdb_impl.go

@@ -0,0 +1,466 @@
+//go:build gonavi_full_drivers || gonavi_duckdb_driver
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/utils"
+)
+
+type DuckDB struct {
+	conn        *sql.DB
+	pingTimeout time.Duration
+}
+
+func (d *DuckDB) Connect(config connection.ConnectionConfig) error {
+	if supported, reason := duckDBBuildSupportStatus(); !supported {
+		return fmt.Errorf("DuckDB 驱动不可用：%s", reason)
+	}
+
+	dsn := strings.TrimSpace(config.Host)
+	if dsn == "" {
+		dsn = strings.TrimSpace(config.Database)
+	}
+	if dsn == "" {
+		dsn = ":memory:"
+	}
+
+	db, err := sql.Open("duckdb", dsn)
+	if err != nil {
+		return fmt.Errorf("打开数据库连接失败：%w", err)
+	}
+	d.conn = db
+	d.pingTimeout = getConnectTimeout(config)
+
+	if err := d.Ping(); err != nil {
+		_ = db.Close()
+		d.conn = nil
+		return fmt.Errorf("连接建立后验证失败：%w", err)
+	}
+	return nil
+}
+
+func (d *DuckDB) Close() error {
+	if d.conn != nil {
+		return d.conn.Close()
+	}
+	return nil
+}
+
+func (d *DuckDB) Ping() error {
+	if d.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+	timeout := d.pingTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := utils.ContextWithTimeout(timeout)
+	defer cancel()
+	return d.conn.PingContext(ctx)
+}
+
+func (d *DuckDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if d.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+	rows, err := d.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (d *DuckDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	if d.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+	rows, err := d.conn.Query(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (d *DuckDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if d.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := d.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (d *DuckDB) Exec(query string) (int64, error) {
+	if d.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := d.conn.Exec(query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (d *DuckDB) GetDatabases() ([]string, error) {
+	data, _, err := d.Query("PRAGMA database_list")
+	if err != nil {
+		return []string{"main"}, nil
+	}
+
+	seen := map[string]struct{}{}
+	var names []string
+	for _, row := range data {
+		name := strings.TrimSpace(duckDBRowString(row, "name", "database_name", "database"))
+		if name == "" {
+			continue
+		}
+		if _, exists := seen[name]; exists {
+			continue
+		}
+		seen[name] = struct{}{}
+		names = append(names, name)
+	}
+	if len(names) == 0 {
+		return []string{"main"}, nil
+	}
+	return names, nil
+}
+
+func (d *DuckDB) GetTables(dbName string) ([]string, error) {
+	query := `
+SELECT table_schema, table_name
+FROM information_schema.tables
+WHERE table_type = 'BASE TABLE'
+  AND table_schema NOT IN ('information_schema', 'pg_catalog')
+ORDER BY table_schema, table_name`
+
+	data, _, err := d.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	seen := map[string]struct{}{}
+	var tables []string
+	for _, row := range data {
+		schema := strings.TrimSpace(duckDBRowString(row, "table_schema"))
+		name := strings.TrimSpace(duckDBRowString(row, "table_name"))
+		if name == "" {
+			continue
+		}
+		qualified := name
+		if schema != "" && !strings.EqualFold(schema, "main") {
+			qualified = schema + "." + name
+		}
+		if _, exists := seen[qualified]; exists {
+			continue
+		}
+		seen[qualified] = struct{}{}
+		tables = append(tables, qualified)
+	}
+	return tables, nil
+}
+
+func (d *DuckDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	schema, pureTable := normalizeDuckDBSchemaAndTable(dbName, tableName)
+	if pureTable == "" {
+		return "", fmt.Errorf("table name required")
+	}
+
+	escapedTable := escapeDuckDBLiteral(pureTable)
+	escapedSchema := escapeDuckDBLiteral(schema)
+
+	queryCandidates := []string{
+		fmt.Sprintf("SELECT sql FROM duckdb_tables() WHERE table_name = '%s' AND schema_name = '%s' LIMIT 1", escapedTable, escapedSchema),
+		fmt.Sprintf("SELECT sql FROM duckdb_tables() WHERE table_name = '%s' LIMIT 1", escapedTable),
+		fmt.Sprintf("SHOW CREATE TABLE %s", quoteDuckDBQualifiedTable(schema, pureTable)),
+	}
+
+	for _, query := range queryCandidates {
+		data, _, err := d.Query(query)
+		if err != nil || len(data) == 0 {
+			continue
+		}
+
+		createSQL := strings.TrimSpace(duckDBRowString(data[0], "sql", "create_table", "Create Table", "create_statement"))
+		if createSQL != "" {
+			return createSQL, nil
+		}
+		for _, value := range data[0] {
+			text := strings.TrimSpace(fmt.Sprintf("%v", value))
+			if text != "" && text != "<nil>" {
+				return text, nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("create statement not found")
+}
+
+func (d *DuckDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	schema, pureTable := normalizeDuckDBSchemaAndTable(dbName, tableName)
+	if pureTable == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	query := fmt.Sprintf(`
+SELECT column_name, data_type, is_nullable, column_default
+FROM information_schema.columns
+WHERE table_name = '%s' AND table_schema = '%s'
+ORDER BY ordinal_position`, escapeDuckDBLiteral(pureTable), escapeDuckDBLiteral(schema))
+
+	data, _, err := d.Query(query)
+	if err != nil {
+		return nil, err
+	}
+	if len(data) == 0 && schema != "main" {
+		fallbackQuery := fmt.Sprintf(`
+SELECT column_name, data_type, is_nullable, column_default
+FROM information_schema.columns
+WHERE table_name = '%s'
+ORDER BY ordinal_position`, escapeDuckDBLiteral(pureTable))
+		data, _, err = d.Query(fallbackQuery)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var columns []connection.ColumnDefinition
+	for _, row := range data {
+		column := connection.ColumnDefinition{
+			Name:     duckDBRowString(row, "column_name"),
+			Type:     duckDBRowString(row, "data_type"),
+			Nullable: strings.ToUpper(strings.TrimSpace(duckDBRowString(row, "is_nullable"))),
+			Key:      "",
+			Extra:    "",
+			Comment:  "",
+		}
+		if column.Nullable == "" {
+			column.Nullable = "YES"
+		}
+		if defaultVal := strings.TrimSpace(duckDBRowString(row, "column_default")); defaultVal != "" && defaultVal != "<nil>" {
+			def := defaultVal
+			column.Default = &def
+		}
+		columns = append(columns, column)
+	}
+	return columns, nil
+}
+
+func (d *DuckDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	query := `
+SELECT table_schema, table_name, column_name, data_type
+FROM information_schema.columns
+WHERE table_schema NOT IN ('information_schema', 'pg_catalog')
+ORDER BY table_schema, table_name, ordinal_position`
+
+	data, _, err := d.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	columns := make([]connection.ColumnDefinitionWithTable, 0, len(data))
+	for _, row := range data {
+		schema := strings.TrimSpace(duckDBRowString(row, "table_schema"))
+		tableName := strings.TrimSpace(duckDBRowString(row, "table_name"))
+		if tableName == "" {
+			continue
+		}
+		if schema != "" && !strings.EqualFold(schema, "main") {
+			tableName = schema + "." + tableName
+		}
+
+		columns = append(columns, connection.ColumnDefinitionWithTable{
+			TableName: tableName,
+			Name:      duckDBRowString(row, "column_name"),
+			Type:      duckDBRowString(row, "data_type"),
+		})
+	}
+	return columns, nil
+}
+
+func (d *DuckDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	return []connection.IndexDefinition{}, nil
+}
+
+func (d *DuckDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	return []connection.ForeignKeyDefinition{}, nil
+}
+
+func (d *DuckDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	return []connection.TriggerDefinition{}, nil
+}
+
+func (d *DuckDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
+	if d.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+
+	tx, err := d.conn.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	quoteIdent := func(name string) string {
+		n := strings.TrimSpace(name)
+		n = strings.Trim(n, "\"")
+		n = strings.ReplaceAll(n, "\"", "\"\"")
+		if n == "" {
+			return "\"\""
+		}
+		return `"` + n + `"`
+	}
+
+	schema := ""
+	table := strings.TrimSpace(tableName)
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	qualifiedTable := quoteIdent(table)
+	if schema != "" {
+		qualifiedTable = fmt.Sprintf("%s.%s", quoteIdent(schema), quoteIdent(table))
+	}
+
+	for _, pk := range changes.Deletes {
+		var wheres []string
+		var args []interface{}
+		for k, v := range pk {
+			wheres = append(wheres, fmt.Sprintf("%s = ?", quoteIdent(k)))
+			args = append(args, v)
+		}
+		if len(wheres) == 0 {
+			continue
+		}
+		query := fmt.Sprintf("DELETE FROM %s WHERE %s", qualifiedTable, strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("delete error: %v", err)
+		}
+	}
+
+	for _, update := range changes.Updates {
+		var sets []string
+		var args []interface{}
+		for k, v := range update.Values {
+			sets = append(sets, fmt.Sprintf("%s = ?", quoteIdent(k)))
+			args = append(args, v)
+		}
+		if len(sets) == 0 {
+			continue
+		}
+
+		var wheres []string
+		for k, v := range update.Keys {
+			wheres = append(wheres, fmt.Sprintf("%s = ?", quoteIdent(k)))
+			args = append(args, v)
+		}
+		if len(wheres) == 0 {
+			return fmt.Errorf("update requires keys")
+		}
+
+		query := fmt.Sprintf("UPDATE %s SET %s WHERE %s", qualifiedTable, strings.Join(sets, ", "), strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("update error: %v", err)
+		}
+	}
+
+	for _, row := range changes.Inserts {
+		var cols []string
+		var placeholders []string
+		var args []interface{}
+
+		for k, v := range row {
+			cols = append(cols, quoteIdent(k))
+			placeholders = append(placeholders, "?")
+			args = append(args, v)
+		}
+		if len(cols) == 0 {
+			continue
+		}
+
+		query := fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s)", qualifiedTable, strings.Join(cols, ", "), strings.Join(placeholders, ", "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("insert error: %v", err)
+		}
+	}
+
+	return tx.Commit()
+}
+
+func normalizeDuckDBSchemaAndTable(dbName string, tableName string) (string, string) {
+	schema := strings.TrimSpace(dbName)
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		if schema == "" {
+			schema = "main"
+		}
+		return schema, table
+	}
+
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		left := strings.TrimSpace(parts[0])
+		right := strings.TrimSpace(parts[1])
+		if left != "" && right != "" {
+			return normalizeDuckDBIdentifier(left), normalizeDuckDBIdentifier(right)
+		}
+	}
+
+	if schema == "" {
+		schema = "main"
+	}
+	return normalizeDuckDBIdentifier(schema), normalizeDuckDBIdentifier(table)
+}
+
+func normalizeDuckDBIdentifier(raw string) string {
+	text := strings.TrimSpace(raw)
+	if len(text) >= 2 {
+		first := text[0]
+		last := text[len(text)-1]
+		if (first == '"' && last == '"') || (first == '`' && last == '`') {
+			text = strings.TrimSpace(text[1 : len(text)-1])
+		}
+	}
+	return text
+}
+
+func quoteDuckDBIdentifier(raw string) string {
+	text := normalizeDuckDBIdentifier(raw)
+	return `"` + strings.ReplaceAll(text, `"`, `""`) + `"`
+}
+
+func quoteDuckDBQualifiedTable(schema string, table string) string {
+	s := strings.TrimSpace(schema)
+	t := strings.TrimSpace(table)
+	if s == "" {
+		return quoteDuckDBIdentifier(t)
+	}
+	return quoteDuckDBIdentifier(s) + "." + quoteDuckDBIdentifier(t)
+}
+
+func duckDBRowString(row map[string]interface{}, keys ...string) string {
+	for _, key := range keys {
+		for rowKey, value := range row {
+			if !strings.EqualFold(rowKey, key) || value == nil {
+				continue
+			}
+			return fmt.Sprintf("%v", value)
+		}
+	}
+	return ""
+}
+
+func escapeDuckDBLiteral(raw string) string {
+	return strings.ReplaceAll(raw, "'", "''")
+}

internal/db/duckdb_platform_supported.go

@@ -0,0 +1,7 @@
+//go:build (gonavi_full_drivers || gonavi_duckdb_driver) && cgo && (duckdb_use_lib || duckdb_use_static_lib || (darwin && (amd64 || arm64)) || (linux && (amd64 || arm64)) || (windows && amd64))
+
+package db
+
+func duckDBBuildSupportStatus() (bool, string) {
+	return true, ""
+}

internal/db/duckdb_platform_unsupported.go

@@ -0,0 +1,12 @@
+//go:build (gonavi_full_drivers || gonavi_duckdb_driver) && !(cgo && (duckdb_use_lib || duckdb_use_static_lib || (darwin && (amd64 || arm64)) || (linux && (amd64 || arm64)) || (windows && amd64)))
+
+package db
+
+import (
+	"fmt"
+	"runtime"
+)
+
+func duckDBBuildSupportStatus() (bool, string) {
+	return false, fmt.Sprintf("当前构建不包含 DuckDB 驱动（平台=%s/%s）。需要启用 CGO，并使用受支持平台（darwin/linux amd64|arm64、windows/amd64）或通过 -tags duckdb_use_lib / duckdb_use_static_lib 提供自定义库", runtime.GOOS, runtime.GOARCH)
+}

internal/db/highgo_impl.go

@@ -0,0 +1,630 @@
+//go:build gonavi_full_drivers || gonavi_highgo_driver
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/ssh"
+	"GoNavi-Wails/internal/utils"
+
+	_ "github.com/highgo/pq-sm3" // HighGo uses dedicated SM3-capable driver
+)
+
+// HighGoDB implements Database interface for HighGo (瀚高) database
+// HighGo is a PostgreSQL-compatible database, so we reuse PostgreSQL driver
+type HighGoDB struct {
+	conn        *sql.DB
+	pingTimeout time.Duration
+	forwarder   *ssh.LocalForwarder
+}
+
+func (h *HighGoDB) getDSN(config connection.ConnectionConfig) string {
+	// postgres://user:password@host:port/dbname?sslmode=disable
+	dbname := config.Database
+	if dbname == "" {
+		dbname = "highgo" // HighGo default database
+	}
+
+	u := &url.URL{
+		Scheme: "postgres",
+		Host:   net.JoinHostPort(config.Host, strconv.Itoa(config.Port)),
+		Path:   "/" + dbname,
+	}
+	u.User = url.UserPassword(config.User, config.Password)
+	q := url.Values{}
+	q.Set("sslmode", "disable")
+	q.Set("connect_timeout", strconv.Itoa(getConnectTimeoutSeconds(config)))
+	u.RawQuery = q.Encode()
+
+	return u.String()
+}
+
+func (h *HighGoDB) Connect(config connection.ConnectionConfig) error {
+	var dsn string
+
+	if config.UseSSH {
+		logger.Infof("HighGo 使用 SSH 连接：地址=%s:%d 用户=%s", config.Host, config.Port, config.User)
+
+		forwarder, err := ssh.GetOrCreateLocalForwarder(config.SSH, config.Host, config.Port)
+		if err != nil {
+			return fmt.Errorf("创建 SSH 隧道失败：%w", err)
+		}
+		h.forwarder = forwarder
+
+		host, portStr, err := net.SplitHostPort(forwarder.LocalAddr)
+		if err != nil {
+			return fmt.Errorf("解析本地转发地址失败：%w", err)
+		}
+
+		port, err := strconv.Atoi(portStr)
+		if err != nil {
+			return fmt.Errorf("解析本地端口失败：%w", err)
+		}
+
+		localConfig := config
+		localConfig.Host = host
+		localConfig.Port = port
+		localConfig.UseSSH = false
+
+		dsn = h.getDSN(localConfig)
+		logger.Infof("HighGo 通过本地端口转发连接：%s -> %s:%d", forwarder.LocalAddr, config.Host, config.Port)
+	} else {
+		dsn = h.getDSN(config)
+	}
+
+	db, err := sql.Open("highgo", dsn)
+	if err != nil {
+		return fmt.Errorf("打开数据库连接失败：%w", err)
+	}
+	h.conn = db
+	h.pingTimeout = getConnectTimeout(config)
+
+	if err := h.Ping(); err != nil {
+		return fmt.Errorf("连接建立后验证失败：%w", err)
+	}
+	return nil
+}
+
+func (h *HighGoDB) Close() error {
+	if h.forwarder != nil {
+		if err := h.forwarder.Close(); err != nil {
+			logger.Warnf("关闭 HighGo SSH 端口转发失败：%v", err)
+		}
+		h.forwarder = nil
+	}
+
+	if h.conn != nil {
+		return h.conn.Close()
+	}
+	return nil
+}
+
+func (h *HighGoDB) Ping() error {
+	if h.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+	timeout := h.pingTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := utils.ContextWithTimeout(timeout)
+	defer cancel()
+	return h.conn.PingContext(ctx)
+}
+
+func (h *HighGoDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if h.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := h.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
+func (h *HighGoDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	if h.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := h.conn.Query(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (h *HighGoDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if h.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := h.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (h *HighGoDB) Exec(query string) (int64, error) {
+	if h.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := h.conn.Exec(query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (h *HighGoDB) GetDatabases() ([]string, error) {
+	data, _, err := h.Query("SELECT datname FROM pg_database WHERE datistemplate = false")
+	if err != nil {
+		return nil, err
+	}
+	var dbs []string
+	for _, row := range data {
+		if val, ok := row["datname"]; ok {
+			dbs = append(dbs, fmt.Sprintf("%v", val))
+		}
+	}
+	return dbs, nil
+}
+
+func (h *HighGoDB) GetTables(dbName string) ([]string, error) {
+	query := "SELECT schemaname, tablename FROM pg_catalog.pg_tables WHERE schemaname != 'information_schema' AND schemaname NOT LIKE 'pg_%' ORDER BY schemaname, tablename"
+	data, _, err := h.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var tables []string
+	for _, row := range data {
+		schema, okSchema := row["schemaname"]
+		name, okName := row["tablename"]
+		if okSchema && okName {
+			tables = append(tables, fmt.Sprintf("%v.%v", schema, name))
+			continue
+		}
+		if okName {
+			tables = append(tables, fmt.Sprintf("%v", name))
+		}
+	}
+	return tables, nil
+}
+
+func (h *HighGoDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	return fmt.Sprintf("-- SHOW CREATE TABLE not fully supported for HighGo in this version.\n-- Table: %s", tableName), nil
+}
+
+func (h *HighGoDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT
+	a.attname AS column_name,
+	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
+	col_description(a.attrelid, a.attnum) AS comment,
+	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
+FROM pg_class c
+JOIN pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_attribute a ON a.attrelid = c.oid
+LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
+LEFT JOIN (
+	SELECT i.indrelid, a3.attname
+	FROM pg_index i
+	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
+	WHERE i.indisprimary
+) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
+WHERE c.relkind IN ('r', 'p')
+  AND n.nspname = '%s'
+  AND c.relname = '%s'
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+ORDER BY a.attnum`, esc(schema), esc(table))
+
+	data, _, err := h.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var columns []connection.ColumnDefinition
+	for _, row := range data {
+		col := connection.ColumnDefinition{
+			Name:     fmt.Sprintf("%v", row["column_name"]),
+			Type:     fmt.Sprintf("%v", row["data_type"]),
+			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
+			Key:      fmt.Sprintf("%v", row["column_key"]),
+			Extra:    "",
+			Comment:  "",
+		}
+
+		if v, ok := row["comment"]; ok && v != nil {
+			col.Comment = fmt.Sprintf("%v", v)
+		}
+
+		if v, ok := row["column_default"]; ok && v != nil {
+			def := fmt.Sprintf("%v", v)
+			col.Default = &def
+			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
+				col.Extra = "auto_increment"
+			}
+		}
+
+		columns = append(columns, col)
+	}
+	return columns, nil
+}
+
+func (h *HighGoDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT
+	i.relname AS index_name,
+	a.attname AS column_name,
+	ix.indisunique AS is_unique,
+	x.ordinality AS seq_in_index,
+	am.amname AS index_type
+FROM pg_class t
+JOIN pg_namespace n ON n.oid = t.relnamespace
+JOIN pg_index ix ON t.oid = ix.indrelid
+JOIN pg_class i ON i.oid = ix.indexrelid
+JOIN pg_am am ON i.relam = am.oid
+JOIN unnest(ix.indkey) WITH ORDINALITY AS x(attnum, ordinality) ON TRUE
+JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = x.attnum
+WHERE t.relkind IN ('r', 'p')
+  AND t.relname = '%s'
+  AND n.nspname = '%s'
+ORDER BY i.relname, x.ordinality`, esc(table), esc(schema))
+
+	data, _, err := h.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	parseBool := func(v interface{}) bool {
+		switch val := v.(type) {
+		case bool:
+			return val
+		case string:
+			s := strings.ToLower(strings.TrimSpace(val))
+			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
+		default:
+			s := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", v)))
+			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
+		}
+	}
+
+	parseInt := func(v interface{}) int {
+		switch val := v.(type) {
+		case int:
+			return val
+		case int64:
+			return int(val)
+		case float64:
+			return int(val)
+		case string:
+			var n int
+			_, _ = fmt.Sscanf(strings.TrimSpace(val), "%d", &n)
+			return n
+		default:
+			var n int
+			_, _ = fmt.Sscanf(strings.TrimSpace(fmt.Sprintf("%v", v)), "%d", &n)
+			return n
+		}
+	}
+
+	var indexes []connection.IndexDefinition
+	for _, row := range data {
+		isUnique := false
+		if v, ok := row["is_unique"]; ok && v != nil {
+			isUnique = parseBool(v)
+		}
+
+		nonUnique := 1
+		if isUnique {
+			nonUnique = 0
+		}
+
+		seq := 0
+		if v, ok := row["seq_in_index"]; ok && v != nil {
+			seq = parseInt(v)
+		}
+
+		indexType := ""
+		if v, ok := row["index_type"]; ok && v != nil {
+			indexType = strings.ToUpper(fmt.Sprintf("%v", v))
+		}
+		if indexType == "" {
+			indexType = "BTREE"
+		}
+
+		idx := connection.IndexDefinition{
+			Name:       fmt.Sprintf("%v", row["index_name"]),
+			ColumnName: fmt.Sprintf("%v", row["column_name"]),
+			NonUnique:  nonUnique,
+			SeqInIndex: seq,
+			IndexType:  indexType,
+		}
+		indexes = append(indexes, idx)
+	}
+	return indexes, nil
+}
+
+func (h *HighGoDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT
+	tc.constraint_name AS constraint_name,
+	kcu.column_name AS column_name,
+	ccu.table_schema AS foreign_table_schema,
+	ccu.table_name AS foreign_table_name,
+	ccu.column_name AS foreign_column_name
+FROM information_schema.table_constraints AS tc
+JOIN information_schema.key_column_usage AS kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage AS ccu
+  ON ccu.constraint_name = tc.constraint_name
+  AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND tc.table_name = '%s'
+  AND tc.table_schema = '%s'
+ORDER BY tc.constraint_name, kcu.ordinal_position`, esc(table), esc(schema))
+
+	data, _, err := h.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var fks []connection.ForeignKeyDefinition
+	for _, row := range data {
+		refSchema := ""
+		if v, ok := row["foreign_table_schema"]; ok && v != nil {
+			refSchema = fmt.Sprintf("%v", v)
+		}
+		refTable := fmt.Sprintf("%v", row["foreign_table_name"])
+		refTableName := refTable
+		if strings.TrimSpace(refSchema) != "" {
+			refTableName = fmt.Sprintf("%s.%s", refSchema, refTable)
+		}
+
+		fk := connection.ForeignKeyDefinition{
+			Name:           fmt.Sprintf("%v", row["constraint_name"]),
+			ColumnName:     fmt.Sprintf("%v", row["column_name"]),
+			RefTableName:   refTableName,
+			RefColumnName:  fmt.Sprintf("%v", row["foreign_column_name"]),
+			ConstraintName: fmt.Sprintf("%v", row["constraint_name"]),
+		}
+		fks = append(fks, fk)
+	}
+	return fks, nil
+}
+
+func (h *HighGoDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT trigger_name, action_timing, event_manipulation, action_statement
+FROM information_schema.triggers
+WHERE event_object_table = '%s'
+  AND event_object_schema = '%s'
+ORDER BY trigger_name, event_manipulation`, esc(table), esc(schema))
+
+	data, _, err := h.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var triggers []connection.TriggerDefinition
+	for _, row := range data {
+		trig := connection.TriggerDefinition{
+			Name:      fmt.Sprintf("%v", row["trigger_name"]),
+			Timing:    fmt.Sprintf("%v", row["action_timing"]),
+			Event:     fmt.Sprintf("%v", row["event_manipulation"]),
+			Statement: fmt.Sprintf("%v", row["action_statement"]),
+		}
+		triggers = append(triggers, trig)
+	}
+	return triggers, nil
+}
+
+func (h *HighGoDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	query := `
+SELECT table_schema, table_name, column_name, data_type
+FROM information_schema.columns
+WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+  AND table_schema NOT LIKE 'pg_%'
+ORDER BY table_schema, table_name, ordinal_position`
+
+	data, _, err := h.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var cols []connection.ColumnDefinitionWithTable
+	for _, row := range data {
+		schema := fmt.Sprintf("%v", row["table_schema"])
+		table := fmt.Sprintf("%v", row["table_name"])
+		tableName := table
+		if strings.TrimSpace(schema) != "" {
+			tableName = fmt.Sprintf("%s.%s", schema, table)
+		}
+
+		col := connection.ColumnDefinitionWithTable{
+			TableName: tableName,
+			Name:      fmt.Sprintf("%v", row["column_name"]),
+			Type:      fmt.Sprintf("%v", row["data_type"]),
+		}
+		cols = append(cols, col)
+	}
+	return cols, nil
+}
+
+func (h *HighGoDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
+	if h.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+
+	tx, err := h.conn.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	quoteIdent := func(name string) string {
+		n := strings.TrimSpace(name)
+		n = strings.Trim(n, "\"")
+		n = strings.ReplaceAll(n, "\"", "\"\"")
+		if n == "" {
+			return "\"\""
+		}
+		return `"` + n + `"`
+	}
+
+	schema := ""
+	table := strings.TrimSpace(tableName)
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	qualifiedTable := ""
+	if schema != "" {
+		qualifiedTable = fmt.Sprintf("%s.%s", quoteIdent(schema), quoteIdent(table))
+	} else {
+		qualifiedTable = quoteIdent(table)
+	}
+
+	// 1. Deletes
+	for _, pk := range changes.Deletes {
+		var wheres []string
+		var args []interface{}
+		idx := 0
+		for k, v := range pk {
+			idx++
+			wheres = append(wheres, fmt.Sprintf("%s = $%d", quoteIdent(k), idx))
+			args = append(args, v)
+		}
+		if len(wheres) == 0 {
+			continue
+		}
+		query := fmt.Sprintf("DELETE FROM %s WHERE %s", qualifiedTable, strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("delete error: %v", err)
+		}
+	}
+
+	// 2. Updates
+	for _, update := range changes.Updates {
+		var sets []string
+		var args []interface{}
+		idx := 0
+
+		for k, v := range update.Values {
+			idx++
+			sets = append(sets, fmt.Sprintf("%s = $%d", quoteIdent(k), idx))
+			args = append(args, v)
+		}
+
+		if len(sets) == 0 {
+			continue
+		}
+
+		var wheres []string
+		for k, v := range update.Keys {
+			idx++
+			wheres = append(wheres, fmt.Sprintf("%s = $%d", quoteIdent(k), idx))
+			args = append(args, v)
+		}
+
+		if len(wheres) == 0 {
+			return fmt.Errorf("update requires keys")
+		}
+
+		query := fmt.Sprintf("UPDATE %s SET %s WHERE %s", qualifiedTable, strings.Join(sets, ", "), strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("update error: %v", err)
+		}
+	}
+
+	// 3. Inserts
+	for _, row := range changes.Inserts {
+		var cols []string
+		var placeholders []string
+		var args []interface{}
+		idx := 0
+
+		for k, v := range row {
+			idx++
+			cols = append(cols, quoteIdent(k))
+			placeholders = append(placeholders, fmt.Sprintf("$%d", idx))
+			args = append(args, v)
+		}
+
+		if len(cols) == 0 {
+			continue
+		}
+
+		query := fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s)", qualifiedTable, strings.Join(cols, ", "), strings.Join(placeholders, ", "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("insert error: %v", err)
+		}
+	}
+
+	return tx.Commit()
+}

internal/db/kingbase_impl.go

@@ -1,3 +1,5 @@
+//go:build gonavi_full_drivers || gonavi_kingbase_driver
+
 package db
 
 import (

internal/db/mariadb_impl.go

@@ -0,0 +1,411 @@
+//go:build gonavi_full_drivers || gonavi_mariadb_driver
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/ssh"
+	"GoNavi-Wails/internal/utils"
+
+	_ "github.com/go-sql-driver/mysql"
+)
+
+// MariaDB implements Database interface for MariaDB
+// MariaDB is MySQL-compatible, so we reuse the MySQL driver
+type MariaDB struct {
+	conn        *sql.DB
+	pingTimeout time.Duration
+}
+
+func (m *MariaDB) getDSN(config connection.ConnectionConfig) string {
+	database := config.Database
+	protocol := "tcp"
+	address := fmt.Sprintf("%s:%d", config.Host, config.Port)
+
+	if config.UseSSH {
+		netName, err := ssh.RegisterSSHNetwork(config.SSH)
+		if err == nil {
+			protocol = netName
+			address = fmt.Sprintf("%s:%d", config.Host, config.Port)
+		} else {
+			logger.Warnf("注册 SSH 网络失败，将尝试直连：地址=%s:%d 用户=%s，原因：%v", config.Host, config.Port, config.User, err)
+		}
+	}
+
+	timeout := getConnectTimeoutSeconds(config)
+
+	return fmt.Sprintf("%s:%s@%s(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=%ds",
+		config.User, config.Password, protocol, address, database, timeout)
+}
+
+func (m *MariaDB) Connect(config connection.ConnectionConfig) error {
+	dsn := m.getDSN(config)
+	db, err := sql.Open("mysql", dsn)
+	if err != nil {
+		return fmt.Errorf("打开数据库连接失败：%w", err)
+	}
+	m.conn = db
+	m.pingTimeout = getConnectTimeout(config)
+
+	if err := m.Ping(); err != nil {
+		return fmt.Errorf("连接建立后验证失败：%w", err)
+	}
+	return nil
+}
+
+func (m *MariaDB) Close() error {
+	if m.conn != nil {
+		return m.conn.Close()
+	}
+	return nil
+}
+
+func (m *MariaDB) Ping() error {
+	if m.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+	timeout := m.pingTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := utils.ContextWithTimeout(timeout)
+	defer cancel()
+	return m.conn.PingContext(ctx)
+}
+
+func (m *MariaDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if m.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := m.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
+func (m *MariaDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	if m.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := m.conn.Query(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (m *MariaDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if m.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := m.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (m *MariaDB) Exec(query string) (int64, error) {
+	if m.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := m.conn.Exec(query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (m *MariaDB) GetDatabases() ([]string, error) {
+	data, _, err := m.Query("SHOW DATABASES")
+	if err != nil {
+		return nil, err
+	}
+	var dbs []string
+	for _, row := range data {
+		if val, ok := row["Database"]; ok {
+			dbs = append(dbs, fmt.Sprintf("%v", val))
+		} else if val, ok := row["database"]; ok {
+			dbs = append(dbs, fmt.Sprintf("%v", val))
+		}
+	}
+	return dbs, nil
+}
+
+func (m *MariaDB) GetTables(dbName string) ([]string, error) {
+	query := "SHOW TABLES"
+	if dbName != "" {
+		query = fmt.Sprintf("SHOW TABLES FROM `%s`", dbName)
+	}
+
+	data, _, err := m.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var tables []string
+	for _, row := range data {
+		for _, v := range row {
+			tables = append(tables, fmt.Sprintf("%v", v))
+			break
+		}
+	}
+	return tables, nil
+}
+
+func (m *MariaDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	query := fmt.Sprintf("SHOW CREATE TABLE `%s`.`%s`", dbName, tableName)
+	if dbName == "" {
+		query = fmt.Sprintf("SHOW CREATE TABLE `%s`", tableName)
+	}
+
+	data, _, err := m.Query(query)
+	if err != nil {
+		return "", err
+	}
+
+	if len(data) > 0 {
+		if val, ok := data[0]["Create Table"]; ok {
+			return fmt.Sprintf("%v", val), nil
+		}
+	}
+	return "", fmt.Errorf("create statement not found")
+}
+
+func (m *MariaDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	query := fmt.Sprintf("SHOW FULL COLUMNS FROM `%s`.`%s`", dbName, tableName)
+	if dbName == "" {
+		query = fmt.Sprintf("SHOW FULL COLUMNS FROM `%s`", tableName)
+	}
+
+	data, _, err := m.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var columns []connection.ColumnDefinition
+	for _, row := range data {
+		col := connection.ColumnDefinition{
+			Name:     fmt.Sprintf("%v", row["Field"]),
+			Type:     fmt.Sprintf("%v", row["Type"]),
+			Nullable: fmt.Sprintf("%v", row["Null"]),
+			Key:      fmt.Sprintf("%v", row["Key"]),
+			Extra:    fmt.Sprintf("%v", row["Extra"]),
+			Comment:  fmt.Sprintf("%v", row["Comment"]),
+		}
+
+		if row["Default"] != nil {
+			d := fmt.Sprintf("%v", row["Default"])
+			col.Default = &d
+		}
+
+		columns = append(columns, col)
+	}
+	return columns, nil
+}
+
+func (m *MariaDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	query := fmt.Sprintf("SHOW INDEX FROM `%s`.`%s`", dbName, tableName)
+	if dbName == "" {
+		query = fmt.Sprintf("SHOW INDEX FROM `%s`", tableName)
+	}
+
+	data, _, err := m.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var indexes []connection.IndexDefinition
+	for _, row := range data {
+		nonUnique := 0
+		if val, ok := row["Non_unique"]; ok {
+			if f, ok := val.(float64); ok {
+				nonUnique = int(f)
+			} else if i, ok := val.(int64); ok {
+				nonUnique = int(i)
+			}
+		}
+
+		seq := 0
+		if val, ok := row["Seq_in_index"]; ok {
+			if f, ok := val.(float64); ok {
+				seq = int(f)
+			} else if i, ok := val.(int64); ok {
+				seq = int(i)
+			}
+		}
+
+		idx := connection.IndexDefinition{
+			Name:       fmt.Sprintf("%v", row["Key_name"]),
+			ColumnName: fmt.Sprintf("%v", row["Column_name"]),
+			NonUnique:  nonUnique,
+			SeqInIndex: seq,
+			IndexType:  fmt.Sprintf("%v", row["Index_type"]),
+		}
+		indexes = append(indexes, idx)
+	}
+	return indexes, nil
+}
+
+func (m *MariaDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	query := fmt.Sprintf(`SELECT CONSTRAINT_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+              FROM information_schema.KEY_COLUMN_USAGE
+              WHERE TABLE_SCHEMA = '%s' AND TABLE_NAME = '%s' AND REFERENCED_TABLE_NAME IS NOT NULL`, dbName, tableName)
+
+	data, _, err := m.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var fks []connection.ForeignKeyDefinition
+	for _, row := range data {
+		fk := connection.ForeignKeyDefinition{
+			Name:           fmt.Sprintf("%v", row["CONSTRAINT_NAME"]),
+			ColumnName:     fmt.Sprintf("%v", row["COLUMN_NAME"]),
+			RefTableName:   fmt.Sprintf("%v", row["REFERENCED_TABLE_NAME"]),
+			RefColumnName:  fmt.Sprintf("%v", row["REFERENCED_COLUMN_NAME"]),
+			ConstraintName: fmt.Sprintf("%v", row["CONSTRAINT_NAME"]),
+		}
+		fks = append(fks, fk)
+	}
+	return fks, nil
+}
+
+func (m *MariaDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	query := fmt.Sprintf("SHOW TRIGGERS FROM `%s` WHERE `Table` = '%s'", dbName, tableName)
+	data, _, err := m.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var triggers []connection.TriggerDefinition
+	for _, row := range data {
+		trig := connection.TriggerDefinition{
+			Name:      fmt.Sprintf("%v", row["Trigger"]),
+			Timing:    fmt.Sprintf("%v", row["Timing"]),
+			Event:     fmt.Sprintf("%v", row["Event"]),
+			Statement: fmt.Sprintf("%v", row["Statement"]),
+		}
+		triggers = append(triggers, trig)
+	}
+	return triggers, nil
+}
+
+func (m *MariaDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
+	if m.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+
+	tx, err := m.conn.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	// 1. Deletes
+	for _, pk := range changes.Deletes {
+		var wheres []string
+		var args []interface{}
+		for k, v := range pk {
+			wheres = append(wheres, fmt.Sprintf("`%s` = ?", k))
+			args = append(args, normalizeMySQLDateTimeValue(v))
+		}
+		if len(wheres) == 0 {
+			continue
+		}
+		query := fmt.Sprintf("DELETE FROM `%s` WHERE %s", tableName, strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("delete error: %v", err)
+		}
+	}
+
+	// 2. Updates
+	for _, update := range changes.Updates {
+		var sets []string
+		var args []interface{}
+
+		for k, v := range update.Values {
+			sets = append(sets, fmt.Sprintf("`%s` = ?", k))
+			args = append(args, normalizeMySQLDateTimeValue(v))
+		}
+
+		if len(sets) == 0 {
+			continue
+		}
+
+		var wheres []string
+		for k, v := range update.Keys {
+			wheres = append(wheres, fmt.Sprintf("`%s` = ?", k))
+			args = append(args, normalizeMySQLDateTimeValue(v))
+		}
+
+		if len(wheres) == 0 {
+			return fmt.Errorf("update requires keys")
+		}
+
+		query := fmt.Sprintf("UPDATE `%s` SET %s WHERE %s", tableName, strings.Join(sets, ", "), strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("update error: %v", err)
+		}
+	}
+
+	// 3. Inserts
+	for _, row := range changes.Inserts {
+		var cols []string
+		var placeholders []string
+		var args []interface{}
+
+		for k, v := range row {
+			cols = append(cols, fmt.Sprintf("`%s`", k))
+			placeholders = append(placeholders, "?")
+			args = append(args, normalizeMySQLDateTimeValue(v))
+		}
+
+		if len(cols) == 0 {
+			continue
+		}
+
+		query := fmt.Sprintf("INSERT INTO `%s` (%s) VALUES (%s)", tableName, strings.Join(cols, ", "), strings.Join(placeholders, ", "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("insert error: %v", err)
+		}
+	}
+
+	return tx.Commit()
+}
+
+func (m *MariaDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	query := fmt.Sprintf("SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = '%s'", dbName)
+	if dbName == "" {
+		return nil, fmt.Errorf("database name required for GetAllColumns")
+	}
+
+	data, _, err := m.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var cols []connection.ColumnDefinitionWithTable
+	for _, row := range data {
+		col := connection.ColumnDefinitionWithTable{
+			TableName: fmt.Sprintf("%v", row["TABLE_NAME"]),
+			Name:      fmt.Sprintf("%v", row["COLUMN_NAME"]),
+			Type:      fmt.Sprintf("%v", row["COLUMN_TYPE"]),
+		}
+		cols = append(cols, col)
+	}
+	return cols, nil
+}

internal/db/mysql_agent_impl.go

@@ -0,0 +1,435 @@
+package db
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+const (
+	mysqlAgentMethodConnect          = "connect"
+	mysqlAgentMethodClose            = "close"
+	mysqlAgentMethodPing             = "ping"
+	mysqlAgentMethodQuery            = "query"
+	mysqlAgentMethodExec             = "exec"
+	mysqlAgentMethodGetDatabases     = "getDatabases"
+	mysqlAgentMethodGetTables        = "getTables"
+	mysqlAgentMethodGetCreateStmt    = "getCreateStatement"
+	mysqlAgentMethodGetColumns       = "getColumns"
+	mysqlAgentMethodGetAllColumns    = "getAllColumns"
+	mysqlAgentMethodGetIndexes       = "getIndexes"
+	mysqlAgentMethodGetForeignKeys   = "getForeignKeys"
+	mysqlAgentMethodGetTriggers      = "getTriggers"
+	mysqlAgentMethodApplyChanges     = "applyChanges"
+	mysqlAgentDefaultScannerMaxBytes = 8 << 20
+)
+
+type mysqlAgentRequest struct {
+	ID        int64                        `json:"id"`
+	Method    string                       `json:"method"`
+	Config    *connection.ConnectionConfig `json:"config,omitempty"`
+	Query     string                       `json:"query,omitempty"`
+	DBName    string                       `json:"dbName,omitempty"`
+	TableName string                       `json:"tableName,omitempty"`
+	Changes   *connection.ChangeSet        `json:"changes,omitempty"`
+}
+
+type mysqlAgentResponse struct {
+	ID           int64           `json:"id"`
+	Success      bool            `json:"success"`
+	Error        string          `json:"error,omitempty"`
+	Data         json.RawMessage `json:"data,omitempty"`
+	Fields       []string        `json:"fields,omitempty"`
+	RowsAffected int64           `json:"rowsAffected,omitempty"`
+}
+
+type mysqlAgentClient struct {
+	cmd      *exec.Cmd
+	stdin    io.WriteCloser
+	reader   *bufio.Reader
+	nextID   int64
+	mu       sync.Mutex
+	stderrMu sync.Mutex
+	stderr   strings.Builder
+}
+
+func newMySQLAgentClient(executablePath string) (*mysqlAgentClient, error) {
+	pathText := strings.TrimSpace(executablePath)
+	if pathText == "" {
+		return nil, fmt.Errorf("MySQL 驱动代理路径为空")
+	}
+	info, err := os.Stat(pathText)
+	if err != nil {
+		return nil, fmt.Errorf("MySQL 驱动代理不存在：%s", pathText)
+	}
+	if info.IsDir() {
+		return nil, fmt.Errorf("MySQL 驱动代理路径是目录：%s", pathText)
+	}
+
+	cmd := exec.Command(pathText)
+	configureAgentProcess(cmd)
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, fmt.Errorf("创建 MySQL 驱动代理 stdin 失败：%w", err)
+	}
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("创建 MySQL 驱动代理 stdout 失败：%w", err)
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, fmt.Errorf("创建 MySQL 驱动代理 stderr 失败：%w", err)
+	}
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("启动 MySQL 驱动代理失败：%w", err)
+	}
+
+	client := &mysqlAgentClient{
+		cmd:    cmd,
+		stdin:  stdin,
+		reader: bufio.NewReader(stdout),
+	}
+	go client.captureStderr(stderr)
+	return client, nil
+}
+
+func (c *mysqlAgentClient) captureStderr(stderr io.Reader) {
+	scanner := bufio.NewScanner(stderr)
+	buffer := make([]byte, 0, 8<<10)
+	scanner.Buffer(buffer, mysqlAgentDefaultScannerMaxBytes)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+		c.stderrMu.Lock()
+		if c.stderr.Len() > 0 {
+			c.stderr.WriteString(" | ")
+		}
+		c.stderr.WriteString(line)
+		c.stderrMu.Unlock()
+	}
+}
+
+func (c *mysqlAgentClient) stderrText() string {
+	c.stderrMu.Lock()
+	defer c.stderrMu.Unlock()
+	return strings.TrimSpace(c.stderr.String())
+}
+
+func (c *mysqlAgentClient) call(req mysqlAgentRequest, out interface{}, fields *[]string, rowsAffected *int64) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.nextID++
+	req.ID = c.nextID
+
+	payload, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+	payload = append(payload, '\n')
+	if _, err := c.stdin.Write(payload); err != nil {
+		stderrText := c.stderrText()
+		if stderrText == "" {
+			return fmt.Errorf("调用 MySQL 驱动代理失败：%w", err)
+		}
+		return fmt.Errorf("调用 MySQL 驱动代理失败：%w（stderr: %s）", err, stderrText)
+	}
+
+	line, err := c.reader.ReadBytes('\n')
+	if err != nil {
+		stderrText := c.stderrText()
+		if stderrText == "" {
+			return fmt.Errorf("读取 MySQL 驱动代理响应失败：%w", err)
+		}
+		return fmt.Errorf("读取 MySQL 驱动代理响应失败：%w（stderr: %s）", err, stderrText)
+	}
+
+	var resp mysqlAgentResponse
+	if err := json.Unmarshal(line, &resp); err != nil {
+		return fmt.Errorf("解析 MySQL 驱动代理响应失败：%w", err)
+	}
+	if !resp.Success {
+		errText := strings.TrimSpace(resp.Error)
+		if errText == "" {
+			errText = "MySQL 驱动代理返回失败"
+		}
+		return errors.New(errText)
+	}
+
+	if fields != nil {
+		*fields = resp.Fields
+	}
+	if rowsAffected != nil {
+		*rowsAffected = resp.RowsAffected
+	}
+	if out != nil && len(resp.Data) > 0 {
+		if err := json.Unmarshal(resp.Data, out); err != nil {
+			return fmt.Errorf("解析 MySQL 驱动代理数据失败：%w", err)
+		}
+	}
+	return nil
+}
+
+func (c *mysqlAgentClient) close() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	var closeErr error
+	if c.stdin != nil {
+		_ = c.stdin.Close()
+	}
+	if c.cmd != nil && c.cmd.Process != nil {
+		if err := c.cmd.Process.Kill(); err != nil {
+			closeErr = err
+		}
+	}
+	if c.cmd != nil {
+		_ = c.cmd.Wait()
+	}
+	return closeErr
+}
+
+type MySQLAgentDB struct {
+	client *mysqlAgentClient
+}
+
+func (m *MySQLAgentDB) Connect(config connection.ConnectionConfig) error {
+	if m.client != nil {
+		_ = m.client.close()
+		m.client = nil
+	}
+
+	executablePath, err := ResolveMySQLAgentExecutablePath("")
+	if err != nil {
+		return err
+	}
+	client, err := newMySQLAgentClient(executablePath)
+	if err != nil {
+		return err
+	}
+	if err := client.call(mysqlAgentRequest{
+		Method: mysqlAgentMethodConnect,
+		Config: &config,
+	}, nil, nil, nil); err != nil {
+		_ = client.close()
+		return err
+	}
+	m.client = client
+	return nil
+}
+
+func (m *MySQLAgentDB) Close() error {
+	if m.client == nil {
+		return nil
+	}
+	_ = m.client.call(mysqlAgentRequest{Method: mysqlAgentMethodClose}, nil, nil, nil)
+	err := m.client.close()
+	m.client = nil
+	return err
+}
+
+func (m *MySQLAgentDB) Ping() error {
+	client, err := m.requireClient()
+	if err != nil {
+		return err
+	}
+	return client.call(mysqlAgentRequest{Method: mysqlAgentMethodPing}, nil, nil, nil)
+}
+
+func (m *MySQLAgentDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, nil, err
+	}
+	return m.Query(query)
+}
+
+func (m *MySQLAgentDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, nil, err
+	}
+	var data []map[string]interface{}
+	var fields []string
+	if err := client.call(mysqlAgentRequest{
+		Method: mysqlAgentMethodQuery,
+		Query:  query,
+	}, &data, &fields, nil); err != nil {
+		return nil, nil, err
+	}
+	return data, fields, nil
+}
+
+func (m *MySQLAgentDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if err := ctx.Err(); err != nil {
+		return 0, err
+	}
+	return m.Exec(query)
+}
+
+func (m *MySQLAgentDB) Exec(query string) (int64, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return 0, err
+	}
+	var affected int64
+	if err := client.call(mysqlAgentRequest{
+		Method: mysqlAgentMethodExec,
+		Query:  query,
+	}, nil, nil, &affected); err != nil {
+		return 0, err
+	}
+	return affected, nil
+}
+
+func (m *MySQLAgentDB) GetDatabases() ([]string, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var dbs []string
+	if err := client.call(mysqlAgentRequest{
+		Method: mysqlAgentMethodGetDatabases,
+	}, &dbs, nil, nil); err != nil {
+		return nil, err
+	}
+	return dbs, nil
+}
+
+func (m *MySQLAgentDB) GetTables(dbName string) ([]string, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var tables []string
+	if err := client.call(mysqlAgentRequest{
+		Method: mysqlAgentMethodGetTables,
+		DBName: dbName,
+	}, &tables, nil, nil); err != nil {
+		return nil, err
+	}
+	return tables, nil
+}
+
+func (m *MySQLAgentDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return "", err
+	}
+	var sqlText string
+	if err := client.call(mysqlAgentRequest{
+		Method:    mysqlAgentMethodGetCreateStmt,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &sqlText, nil, nil); err != nil {
+		return "", err
+	}
+	return sqlText, nil
+}
+
+func (m *MySQLAgentDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var columns []connection.ColumnDefinition
+	if err := client.call(mysqlAgentRequest{
+		Method:    mysqlAgentMethodGetColumns,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &columns, nil, nil); err != nil {
+		return nil, err
+	}
+	return columns, nil
+}
+
+func (m *MySQLAgentDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var columns []connection.ColumnDefinitionWithTable
+	if err := client.call(mysqlAgentRequest{
+		Method: mysqlAgentMethodGetAllColumns,
+		DBName: dbName,
+	}, &columns, nil, nil); err != nil {
+		return nil, err
+	}
+	return columns, nil
+}
+
+func (m *MySQLAgentDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var indexes []connection.IndexDefinition
+	if err := client.call(mysqlAgentRequest{
+		Method:    mysqlAgentMethodGetIndexes,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &indexes, nil, nil); err != nil {
+		return nil, err
+	}
+	return indexes, nil
+}
+
+func (m *MySQLAgentDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var keys []connection.ForeignKeyDefinition
+	if err := client.call(mysqlAgentRequest{
+		Method:    mysqlAgentMethodGetForeignKeys,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &keys, nil, nil); err != nil {
+		return nil, err
+	}
+	return keys, nil
+}
+
+func (m *MySQLAgentDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	client, err := m.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var triggers []connection.TriggerDefinition
+	if err := client.call(mysqlAgentRequest{
+		Method:    mysqlAgentMethodGetTriggers,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &triggers, nil, nil); err != nil {
+		return nil, err
+	}
+	return triggers, nil
+}
+
+func (m *MySQLAgentDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
+	client, err := m.requireClient()
+	if err != nil {
+		return err
+	}
+	return client.call(mysqlAgentRequest{
+		Method:    mysqlAgentMethodApplyChanges,
+		TableName: tableName,
+		Changes:   &changes,
+	}, nil, nil, nil)
+}
+
+func (m *MySQLAgentDB) requireClient() (*mysqlAgentClient, error) {
+	if m.client == nil {
+		return nil, fmt.Errorf("connection not open")
+	}
+	return m.client, nil
+}

internal/db/mysql_agent_path.go

@@ -0,0 +1,40 @@
+package db
+
+import (
+	"fmt"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+func mysqlAgentExecutableName() string {
+	return optionalDriverAgentExecutableName("mysql")
+}
+
+func optionalDriverAgentExecutableName(driverType string) string {
+	normalized := normalizeRuntimeDriverType(driverType)
+	if normalized == "" {
+		normalized = "unknown"
+	}
+	name := fmt.Sprintf("%s-driver-agent", normalized)
+	if runtime.GOOS == "windows" {
+		return name + ".exe"
+	}
+	return name
+}
+
+func ResolveOptionalDriverAgentExecutablePath(downloadDir string, driverType string) (string, error) {
+	normalized := normalizeRuntimeDriverType(driverType)
+	if strings.TrimSpace(normalized) == "" {
+		return "", fmt.Errorf("驱动类型为空")
+	}
+	root, err := resolveExternalDriverRoot(downloadDir)
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(root, normalized, optionalDriverAgentExecutableName(normalized)), nil
+}
+
+func ResolveMySQLAgentExecutablePath(downloadDir string) (string, error) {
+	return ResolveOptionalDriverAgentExecutablePath(downloadDir, "mysql")
+}

internal/db/mysql_impl.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+	"net/url"
+	"strconv"
 	"strings"
 	"time"
 
@@ -20,16 +22,162 @@ type MySQLDB struct {
 	pingTimeout time.Duration
 }
 
+const defaultMySQLPort = 3306
+
+func parseHostPortWithDefault(raw string, defaultPort int) (string, int, bool) {
+	text := strings.TrimSpace(raw)
+	if text == "" {
+		return "", 0, false
+	}
+
+	if strings.HasPrefix(text, "[") {
+		end := strings.Index(text, "]")
+		if end < 0 {
+			return text, defaultPort, true
+		}
+		host := text[1:end]
+		portText := strings.TrimSpace(text[end+1:])
+		if strings.HasPrefix(portText, ":") {
+			if p, err := strconv.Atoi(strings.TrimSpace(strings.TrimPrefix(portText, ":"))); err == nil && p > 0 {
+				return host, p, true
+			}
+		}
+		return host, defaultPort, true
+	}
+
+	lastColon := strings.LastIndex(text, ":")
+	if lastColon > 0 && strings.Count(text, ":") == 1 {
+		host := strings.TrimSpace(text[:lastColon])
+		portText := strings.TrimSpace(text[lastColon+1:])
+		if host != "" {
+			if p, err := strconv.Atoi(portText); err == nil && p > 0 {
+				return host, p, true
+			}
+			return host, defaultPort, true
+		}
+	}
+
+	return text, defaultPort, true
+}
+
+func normalizeMySQLAddress(host string, port int) string {
+	h := strings.TrimSpace(host)
+	if h == "" {
+		h = "localhost"
+	}
+	p := port
+	if p <= 0 {
+		p = defaultMySQLPort
+	}
+	return fmt.Sprintf("%s:%d", h, p)
+}
+
+func applyMySQLURI(config connection.ConnectionConfig) connection.ConnectionConfig {
+	uriText := strings.TrimSpace(config.URI)
+	if uriText == "" {
+		return config
+	}
+	lowerURI := strings.ToLower(uriText)
+	if !strings.HasPrefix(lowerURI, "mysql://") {
+		return config
+	}
+
+	parsed, err := url.Parse(uriText)
+	if err != nil {
+		return config
+	}
+
+	if parsed.User != nil {
+		if config.User == "" {
+			config.User = parsed.User.Username()
+		}
+		if pass, ok := parsed.User.Password(); ok && config.Password == "" {
+			config.Password = pass
+		}
+	}
+
+	if dbName := strings.TrimPrefix(parsed.Path, "/"); dbName != "" && config.Database == "" {
+		config.Database = dbName
+	}
+
+	defaultPort := config.Port
+	if defaultPort <= 0 {
+		defaultPort = defaultMySQLPort
+	}
+
+	hostsFromURI := make([]string, 0, 4)
+	hostText := strings.TrimSpace(parsed.Host)
+	if hostText != "" {
+		for _, entry := range strings.Split(hostText, ",") {
+			host, port, ok := parseHostPortWithDefault(entry, defaultPort)
+			if !ok {
+				continue
+			}
+			hostsFromURI = append(hostsFromURI, normalizeMySQLAddress(host, port))
+		}
+	}
+
+	if len(config.Hosts) == 0 && len(hostsFromURI) > 0 {
+		config.Hosts = hostsFromURI
+	}
+	if strings.TrimSpace(config.Host) == "" && len(hostsFromURI) > 0 {
+		host, port, ok := parseHostPortWithDefault(hostsFromURI[0], defaultPort)
+		if ok {
+			config.Host = host
+			config.Port = port
+		}
+	}
+
+	if config.Topology == "" {
+		topology := strings.TrimSpace(parsed.Query().Get("topology"))
+		if topology != "" {
+			config.Topology = strings.ToLower(topology)
+		}
+	}
+
+	return config
+}
+
+func collectMySQLAddresses(config connection.ConnectionConfig) []string {
+	defaultPort := config.Port
+	if defaultPort <= 0 {
+		defaultPort = defaultMySQLPort
+	}
+
+	candidates := make([]string, 0, len(config.Hosts)+1)
+	if len(config.Hosts) > 0 {
+		candidates = append(candidates, config.Hosts...)
+	} else {
+		candidates = append(candidates, normalizeMySQLAddress(config.Host, defaultPort))
+	}
+
+	result := make([]string, 0, len(candidates))
+	seen := make(map[string]struct{}, len(candidates))
+	for _, entry := range candidates {
+		host, port, ok := parseHostPortWithDefault(entry, defaultPort)
+		if !ok {
+			continue
+		}
+		normalized := normalizeMySQLAddress(host, port)
+		if _, exists := seen[normalized]; exists {
+			continue
+		}
+		seen[normalized] = struct{}{}
+		result = append(result, normalized)
+	}
+	return result
+}
+
 func (m *MySQLDB) getDSN(config connection.ConnectionConfig) string {
 	database := config.Database
 	protocol := "tcp"
-	address := fmt.Sprintf("%s:%d", config.Host, config.Port)
+	address := normalizeMySQLAddress(config.Host, config.Port)
 
 	if config.UseSSH {
 		netName, err := ssh.RegisterSSHNetwork(config.SSH)
 		if err == nil {
 			protocol = netName
-			address = fmt.Sprintf("%s:%d", config.Host, config.Port)
+			address = normalizeMySQLAddress(config.Host, config.Port)
 		} else {
 			logger.Warnf("注册 SSH 网络失败，将尝试直连：地址=%s:%d 用户=%s，原因：%v", config.Host, config.Port, config.User, err)
 		}
@@ -41,20 +189,67 @@ func (m *MySQLDB) getDSN(config connection.ConnectionConfig) string {
 		config.User, config.Password, protocol, address, database, timeout)
 }
 
-func (m *MySQLDB) Connect(config connection.ConnectionConfig) error {
-	dsn := m.getDSN(config)
-	db, err := sql.Open("mysql", dsn)
-	if err != nil {
-		return fmt.Errorf("打开数据库连接失败：%w", err)
-	}
-	m.conn = db
-	m.pingTimeout = getConnectTimeout(config)
+func resolveMySQLCredential(config connection.ConnectionConfig, addressIndex int) (string, string) {
+	primaryUser := strings.TrimSpace(config.User)
+	primaryPassword := config.Password
+	replicaUser := strings.TrimSpace(config.MySQLReplicaUser)
+	replicaPassword := config.MySQLReplicaPassword
 
-	// Force verification
-	if err := m.Ping(); err != nil {
-		return fmt.Errorf("连接建立后验证失败：%w", err)
+	if addressIndex > 0 && replicaUser != "" {
+		return replicaUser, replicaPassword
 	}
-	return nil
+
+	if primaryUser == "" && replicaUser != "" {
+		return replicaUser, replicaPassword
+	}
+
+	return config.User, primaryPassword
+}
+
+func (m *MySQLDB) Connect(config connection.ConnectionConfig) error {
+	runConfig := applyMySQLURI(config)
+	addresses := collectMySQLAddresses(runConfig)
+	if len(addresses) == 0 {
+		return fmt.Errorf("连接建立后验证失败：未找到可用的 MySQL 地址")
+	}
+
+	var errorDetails []string
+	for index, address := range addresses {
+		candidateConfig := runConfig
+		host, port, ok := parseHostPortWithDefault(address, defaultMySQLPort)
+		if !ok {
+			continue
+		}
+		candidateConfig.Host = host
+		candidateConfig.Port = port
+		candidateConfig.User, candidateConfig.Password = resolveMySQLCredential(runConfig, index)
+
+		dsn := m.getDSN(candidateConfig)
+		db, err := sql.Open("mysql", dsn)
+		if err != nil {
+			errorDetails = append(errorDetails, fmt.Sprintf("%s 打开失败: %v", address, err))
+			continue
+		}
+
+		timeout := getConnectTimeout(candidateConfig)
+		ctx, cancel := utils.ContextWithTimeout(timeout)
+		pingErr := db.PingContext(ctx)
+		cancel()
+		if pingErr != nil {
+			_ = db.Close()
+			errorDetails = append(errorDetails, fmt.Sprintf("%s 验证失败: %v", address, pingErr))
+			continue
+		}
+
+		m.conn = db
+		m.pingTimeout = timeout
+		return nil
+	}
+
+	if len(errorDetails) == 0 {
+		return fmt.Errorf("连接建立后验证失败：未找到可用的 MySQL 地址")
+	}
+	return fmt.Errorf("连接建立后验证失败：%s", strings.Join(errorDetails, "；"))
 }
 
 func (m *MySQLDB) Close() error {
@@ -306,6 +501,8 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		return fmt.Errorf("connection not open")
 	}
 
+	columnTypeMap := m.loadColumnTypeMap(tableName)
+
 	tx, err := m.conn.Begin()
 	if err != nil {
 		return err
@@ -318,7 +515,7 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		var args []interface{}
 		for k, v := range pk {
 			wheres = append(wheres, fmt.Sprintf("`%s` = ?", k))
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizeMySQLValueForWrite(k, v, columnTypeMap))
 		}
 		if len(wheres) == 0 {
 			continue
@@ -340,7 +537,7 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 
 		for k, v := range update.Values {
 			sets = append(sets, fmt.Sprintf("`%s` = ?", k))
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizeMySQLValueForWrite(k, v, columnTypeMap))
 		}
 
 		if len(sets) == 0 {
@@ -350,7 +547,7 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		var wheres []string
 		for k, v := range update.Keys {
 			wheres = append(wheres, fmt.Sprintf("`%s` = ?", k))
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizeMySQLValueForWrite(k, v, columnTypeMap))
 		}
 
 		if len(wheres) == 0 {
@@ -374,12 +571,24 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		var args []interface{}
 
 		for k, v := range row {
+			normalizedValue, omit := normalizeMySQLValueForInsert(k, v, columnTypeMap)
+			if omit {
+				continue
+			}
 			cols = append(cols, fmt.Sprintf("`%s`", k))
 			placeholders = append(placeholders, "?")
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizedValue)
 		}
 
 		if len(cols) == 0 {
+			query := fmt.Sprintf("INSERT INTO `%s` () VALUES ()", tableName)
+			res, err := tx.Exec(query)
+			if err != nil {
+				return fmt.Errorf("insert error: %v", err)
+			}
+			if affected, err := res.RowsAffected(); err == nil && affected == 0 {
+				return fmt.Errorf("插入未生效：未影响任何行")
+			}
 			continue
 		}
 
@@ -434,6 +643,69 @@ func normalizeMySQLDateTimeValue(value interface{}) interface{} {
 	return value
 }
 
+func (m *MySQLDB) loadColumnTypeMap(tableName string) map[string]string {
+	result := map[string]string{}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return result
+	}
+
+	columns, err := m.GetColumns("", table)
+	if err != nil {
+		logger.Warnf("加载列元数据失败（不影响提交）：表=%s err=%v", table, err)
+		return result
+	}
+
+	for _, col := range columns {
+		name := strings.ToLower(strings.TrimSpace(col.Name))
+		if name == "" {
+			continue
+		}
+		result[name] = strings.TrimSpace(col.Type)
+	}
+	return result
+}
+
+func normalizeMySQLValueForInsert(columnName string, value interface{}, columnTypeMap map[string]string) (interface{}, bool) {
+	columnType := strings.ToLower(strings.TrimSpace(columnTypeMap[strings.ToLower(strings.TrimSpace(columnName))]))
+	if !isMySQLTemporalColumnType(columnType) {
+		return value, false
+	}
+	text, ok := value.(string)
+	if ok && strings.TrimSpace(text) == "" {
+		// INSERT 空时间字段不写入，交给 DB 默认值处理（如 CURRENT_TIMESTAMP）。
+		return nil, true
+	}
+	return normalizeMySQLDateTimeValue(value), false
+}
+
+func normalizeMySQLValueForWrite(columnName string, value interface{}, columnTypeMap map[string]string) interface{} {
+	columnType := strings.ToLower(strings.TrimSpace(columnTypeMap[strings.ToLower(strings.TrimSpace(columnName))]))
+	if !isMySQLTemporalColumnType(columnType) {
+		return value
+	}
+	text, ok := value.(string)
+	if ok && strings.TrimSpace(text) == "" {
+		return nil
+	}
+	return normalizeMySQLDateTimeValue(value)
+}
+
+func isMySQLTemporalColumnType(columnType string) bool {
+	raw := strings.ToLower(strings.TrimSpace(columnType))
+	if raw == "" {
+		return false
+	}
+	if strings.Contains(raw, "datetime") || strings.Contains(raw, "timestamp") {
+		return true
+	}
+	base := raw
+	if idx := strings.IndexAny(base, "( "); idx >= 0 {
+		base = base[:idx]
+	}
+	return base == "date" || base == "time" || base == "year"
+}
+
 func hasTimezoneOffset(text string) bool {
 	pos := strings.LastIndexAny(text, "+-")
 	if pos < 0 || pos < 10 || pos+1 >= len(text) {

internal/db/optional_driver_agent_impl.go

@@ -0,0 +1,445 @@
+package db
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+const (
+	optionalAgentMethodConnect          = "connect"
+	optionalAgentMethodClose            = "close"
+	optionalAgentMethodPing             = "ping"
+	optionalAgentMethodQuery            = "query"
+	optionalAgentMethodExec             = "exec"
+	optionalAgentMethodGetDatabases     = "getDatabases"
+	optionalAgentMethodGetTables        = "getTables"
+	optionalAgentMethodGetCreateStmt    = "getCreateStatement"
+	optionalAgentMethodGetColumns       = "getColumns"
+	optionalAgentMethodGetAllColumns    = "getAllColumns"
+	optionalAgentMethodGetIndexes       = "getIndexes"
+	optionalAgentMethodGetForeignKeys   = "getForeignKeys"
+	optionalAgentMethodGetTriggers      = "getTriggers"
+	optionalAgentMethodApplyChanges     = "applyChanges"
+	optionalAgentDefaultScannerMaxBytes = 8 << 20
+)
+
+type optionalAgentRequest struct {
+	ID        int64                        `json:"id"`
+	Method    string                       `json:"method"`
+	Config    *connection.ConnectionConfig `json:"config,omitempty"`
+	Query     string                       `json:"query,omitempty"`
+	DBName    string                       `json:"dbName,omitempty"`
+	TableName string                       `json:"tableName,omitempty"`
+	Changes   *connection.ChangeSet        `json:"changes,omitempty"`
+}
+
+type optionalAgentResponse struct {
+	ID           int64           `json:"id"`
+	Success      bool            `json:"success"`
+	Error        string          `json:"error,omitempty"`
+	Data         json.RawMessage `json:"data,omitempty"`
+	Fields       []string        `json:"fields,omitempty"`
+	RowsAffected int64           `json:"rowsAffected,omitempty"`
+}
+
+type optionalDriverAgentClient struct {
+	cmd      *exec.Cmd
+	stdin    io.WriteCloser
+	reader   *bufio.Reader
+	nextID   int64
+	mu       sync.Mutex
+	stderrMu sync.Mutex
+	stderr   strings.Builder
+	driver   string
+}
+
+func newOptionalDriverAgentClient(driverType string, executablePath string) (*optionalDriverAgentClient, error) {
+	pathText := strings.TrimSpace(executablePath)
+	if pathText == "" {
+		return nil, fmt.Errorf("%s 驱动代理路径为空", driverDisplayName(driverType))
+	}
+	info, err := os.Stat(pathText)
+	if err != nil {
+		return nil, fmt.Errorf("%s 驱动代理不存在：%s", driverDisplayName(driverType), pathText)
+	}
+	if info.IsDir() {
+		return nil, fmt.Errorf("%s 驱动代理路径是目录：%s", driverDisplayName(driverType), pathText)
+	}
+
+	cmd := exec.Command(pathText)
+	configureAgentProcess(cmd)
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, fmt.Errorf("创建 %s 驱动代理 stdin 失败：%w", driverDisplayName(driverType), err)
+	}
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("创建 %s 驱动代理 stdout 失败：%w", driverDisplayName(driverType), err)
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, fmt.Errorf("创建 %s 驱动代理 stderr 失败：%w", driverDisplayName(driverType), err)
+	}
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("启动 %s 驱动代理失败：%w", driverDisplayName(driverType), err)
+	}
+
+	client := &optionalDriverAgentClient{
+		cmd:    cmd,
+		stdin:  stdin,
+		reader: bufio.NewReader(stdout),
+		driver: normalizeRuntimeDriverType(driverType),
+	}
+	go client.captureStderr(stderr)
+	return client, nil
+}
+
+func (c *optionalDriverAgentClient) captureStderr(stderr io.Reader) {
+	scanner := bufio.NewScanner(stderr)
+	buffer := make([]byte, 0, 8<<10)
+	scanner.Buffer(buffer, optionalAgentDefaultScannerMaxBytes)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+		c.stderrMu.Lock()
+		if c.stderr.Len() > 0 {
+			c.stderr.WriteString(" | ")
+		}
+		c.stderr.WriteString(line)
+		c.stderrMu.Unlock()
+	}
+}
+
+func (c *optionalDriverAgentClient) stderrText() string {
+	c.stderrMu.Lock()
+	defer c.stderrMu.Unlock()
+	return strings.TrimSpace(c.stderr.String())
+}
+
+func (c *optionalDriverAgentClient) call(req optionalAgentRequest, out interface{}, fields *[]string, rowsAffected *int64) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.nextID++
+	req.ID = c.nextID
+
+	payload, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+	payload = append(payload, '\n')
+	if _, err := c.stdin.Write(payload); err != nil {
+		stderrText := c.stderrText()
+		if stderrText == "" {
+			return fmt.Errorf("调用 %s 驱动代理失败：%w", driverDisplayName(c.driver), err)
+		}
+		return fmt.Errorf("调用 %s 驱动代理失败：%w（stderr: %s）", driverDisplayName(c.driver), err, stderrText)
+	}
+
+	line, err := c.reader.ReadBytes('\n')
+	if err != nil {
+		stderrText := c.stderrText()
+		if stderrText == "" {
+			return fmt.Errorf("读取 %s 驱动代理响应失败：%w", driverDisplayName(c.driver), err)
+		}
+		return fmt.Errorf("读取 %s 驱动代理响应失败：%w（stderr: %s）", driverDisplayName(c.driver), err, stderrText)
+	}
+
+	var resp optionalAgentResponse
+	if err := json.Unmarshal(line, &resp); err != nil {
+		return fmt.Errorf("解析 %s 驱动代理响应失败：%w", driverDisplayName(c.driver), err)
+	}
+	if !resp.Success {
+		errText := strings.TrimSpace(resp.Error)
+		if errText == "" {
+			errText = fmt.Sprintf("%s 驱动代理返回失败", driverDisplayName(c.driver))
+		}
+		return errors.New(errText)
+	}
+
+	if fields != nil {
+		*fields = resp.Fields
+	}
+	if rowsAffected != nil {
+		*rowsAffected = resp.RowsAffected
+	}
+	if out != nil && len(resp.Data) > 0 {
+		if err := json.Unmarshal(resp.Data, out); err != nil {
+			return fmt.Errorf("解析 %s 驱动代理数据失败：%w", driverDisplayName(c.driver), err)
+		}
+	}
+	return nil
+}
+
+func (c *optionalDriverAgentClient) close() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	var closeErr error
+	if c.stdin != nil {
+		_ = c.stdin.Close()
+	}
+	if c.cmd != nil && c.cmd.Process != nil {
+		if err := c.cmd.Process.Kill(); err != nil {
+			closeErr = err
+		}
+	}
+	if c.cmd != nil {
+		_ = c.cmd.Wait()
+	}
+	return closeErr
+}
+
+type OptionalDriverAgentDB struct {
+	driverType string
+	client     *optionalDriverAgentClient
+}
+
+func newOptionalDriverAgentDatabase(driverType string) databaseFactory {
+	normalized := normalizeRuntimeDriverType(driverType)
+	return func() Database {
+		return &OptionalDriverAgentDB{driverType: normalized}
+	}
+}
+
+func (d *OptionalDriverAgentDB) Connect(config connection.ConnectionConfig) error {
+	if d.client != nil {
+		_ = d.client.close()
+		d.client = nil
+	}
+
+	executablePath, err := ResolveOptionalDriverAgentExecutablePath("", d.driverType)
+	if err != nil {
+		return err
+	}
+	client, err := newOptionalDriverAgentClient(d.driverType, executablePath)
+	if err != nil {
+		return err
+	}
+	if err := client.call(optionalAgentRequest{
+		Method: optionalAgentMethodConnect,
+		Config: &config,
+	}, nil, nil, nil); err != nil {
+		_ = client.close()
+		return err
+	}
+	d.client = client
+	return nil
+}
+
+func (d *OptionalDriverAgentDB) Close() error {
+	if d.client == nil {
+		return nil
+	}
+	_ = d.client.call(optionalAgentRequest{Method: optionalAgentMethodClose}, nil, nil, nil)
+	err := d.client.close()
+	d.client = nil
+	return err
+}
+
+func (d *OptionalDriverAgentDB) Ping() error {
+	client, err := d.requireClient()
+	if err != nil {
+		return err
+	}
+	return client.call(optionalAgentRequest{Method: optionalAgentMethodPing}, nil, nil, nil)
+}
+
+func (d *OptionalDriverAgentDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, nil, err
+	}
+	return d.Query(query)
+}
+
+func (d *OptionalDriverAgentDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, nil, err
+	}
+	var data []map[string]interface{}
+	var fields []string
+	if err := client.call(optionalAgentRequest{
+		Method: optionalAgentMethodQuery,
+		Query:  query,
+	}, &data, &fields, nil); err != nil {
+		return nil, nil, err
+	}
+	return data, fields, nil
+}
+
+func (d *OptionalDriverAgentDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if err := ctx.Err(); err != nil {
+		return 0, err
+	}
+	return d.Exec(query)
+}
+
+func (d *OptionalDriverAgentDB) Exec(query string) (int64, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return 0, err
+	}
+	var affected int64
+	if err := client.call(optionalAgentRequest{
+		Method: optionalAgentMethodExec,
+		Query:  query,
+	}, nil, nil, &affected); err != nil {
+		return 0, err
+	}
+	return affected, nil
+}
+
+func (d *OptionalDriverAgentDB) GetDatabases() ([]string, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var dbs []string
+	if err := client.call(optionalAgentRequest{
+		Method: optionalAgentMethodGetDatabases,
+	}, &dbs, nil, nil); err != nil {
+		return nil, err
+	}
+	return dbs, nil
+}
+
+func (d *OptionalDriverAgentDB) GetTables(dbName string) ([]string, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var tables []string
+	if err := client.call(optionalAgentRequest{
+		Method: optionalAgentMethodGetTables,
+		DBName: dbName,
+	}, &tables, nil, nil); err != nil {
+		return nil, err
+	}
+	return tables, nil
+}
+
+func (d *OptionalDriverAgentDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return "", err
+	}
+	var sqlText string
+	if err := client.call(optionalAgentRequest{
+		Method:    optionalAgentMethodGetCreateStmt,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &sqlText, nil, nil); err != nil {
+		return "", err
+	}
+	return sqlText, nil
+}
+
+func (d *OptionalDriverAgentDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var columns []connection.ColumnDefinition
+	if err := client.call(optionalAgentRequest{
+		Method:    optionalAgentMethodGetColumns,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &columns, nil, nil); err != nil {
+		return nil, err
+	}
+	return columns, nil
+}
+
+func (d *OptionalDriverAgentDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var columns []connection.ColumnDefinitionWithTable
+	if err := client.call(optionalAgentRequest{
+		Method: optionalAgentMethodGetAllColumns,
+		DBName: dbName,
+	}, &columns, nil, nil); err != nil {
+		return nil, err
+	}
+	return columns, nil
+}
+
+func (d *OptionalDriverAgentDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var indexes []connection.IndexDefinition
+	if err := client.call(optionalAgentRequest{
+		Method:    optionalAgentMethodGetIndexes,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &indexes, nil, nil); err != nil {
+		return nil, err
+	}
+	return indexes, nil
+}
+
+func (d *OptionalDriverAgentDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var keys []connection.ForeignKeyDefinition
+	if err := client.call(optionalAgentRequest{
+		Method:    optionalAgentMethodGetForeignKeys,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &keys, nil, nil); err != nil {
+		return nil, err
+	}
+	return keys, nil
+}
+
+func (d *OptionalDriverAgentDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	client, err := d.requireClient()
+	if err != nil {
+		return nil, err
+	}
+	var triggers []connection.TriggerDefinition
+	if err := client.call(optionalAgentRequest{
+		Method:    optionalAgentMethodGetTriggers,
+		DBName:    dbName,
+		TableName: tableName,
+	}, &triggers, nil, nil); err != nil {
+		return nil, err
+	}
+	return triggers, nil
+}
+
+func (d *OptionalDriverAgentDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
+	client, err := d.requireClient()
+	if err != nil {
+		return err
+	}
+	return client.call(optionalAgentRequest{
+		Method:    optionalAgentMethodApplyChanges,
+		TableName: tableName,
+		Changes:   &changes,
+	}, nil, nil, nil)
+}
+
+func (d *OptionalDriverAgentDB) requireClient() (*optionalDriverAgentClient, error) {
+	if d.client == nil {
+		return nil, fmt.Errorf("connection not open")
+	}
+	return d.client, nil
+}

internal/db/optional_driver_build_full.go

@@ -0,0 +1,9 @@
+//go:build gonavi_full_drivers
+
+package db
+
+func optionalGoDriverBuildIncluded(driverType string) bool {
+	_, ok := optionalGoDrivers[normalizeRuntimeDriverType(driverType)]
+	return ok
+}
+

internal/db/optional_driver_build_lite.go

@@ -0,0 +1,8 @@
+//go:build !gonavi_full_drivers
+
+package db
+
+func optionalGoDriverBuildIncluded(driverType string) bool {
+	_, ok := optionalGoDrivers[normalizeRuntimeDriverType(driverType)]
+	return ok
+}

internal/db/postgres_impl.go

@@ -18,14 +18,12 @@ import (
 	_ "github.com/lib/pq"
 )
 
-
 type PostgresDB struct {
 	conn        *sql.DB
 	pingTimeout time.Duration
 	forwarder   *ssh.LocalForwarder // Store SSH tunnel forwarder
 }
 
-
 func (p *PostgresDB) getDSN(config connection.ConnectionConfig) string {
 	// postgres://user:password@host:port/dbname?sslmode=disable
 	dbname := config.Database
@@ -48,6 +46,13 @@ func (p *PostgresDB) getDSN(config connection.ConnectionConfig) string {
 }
 
 func (p *PostgresDB) Connect(config connection.ConnectionConfig) error {
+	if supported, reason := DriverRuntimeSupportStatus("postgres"); !supported {
+		if strings.TrimSpace(reason) == "" {
+			reason = "PostgreSQL 纯 Go 驱动未启用，请先在驱动管理中安装启用"
+		}
+		return fmt.Errorf("%s", reason)
+	}
+
 	var dsn string
 	var err error
 
@@ -98,7 +103,6 @@ func (p *PostgresDB) Connect(config connection.ConnectionConfig) error {
 	return nil
 }
 
-
 func (p *PostgresDB) Close() error {
 	// Close SSH forwarder first if exists
 	if p.forwarder != nil {

internal/db/sphinx_impl.go

@@ -0,0 +1,199 @@
+//go:build gonavi_full_drivers || gonavi_sphinx_driver
+
+package db
+
+import (
+	"fmt"
+	"strings"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+)
+
+const sphinxDefaultDatabaseName = "default"
+
+// SphinxDB 复用 MySQL 协议实现，并在数据库列表不可用时提供兜底。
+type SphinxDB struct {
+	MySQLDB
+	fallbackDatabase string
+}
+
+func isSphinxUnsupportedFeatureError(err error) bool {
+	if err == nil {
+		return false
+	}
+	text := strings.ToLower(strings.TrimSpace(err.Error()))
+	if text == "" {
+		return false
+	}
+	keywords := []string{
+		"not supported",
+		"unsupported",
+		"syntax error",
+		"unknown table",
+		"unknown column",
+		"doesn't exist",
+	}
+	for _, keyword := range keywords {
+		if strings.Contains(text, keyword) {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *SphinxDB) Connect(config connection.ConnectionConfig) error {
+	runConfig := applyMySQLURI(config)
+	s.fallbackDatabase = strings.TrimSpace(runConfig.Database)
+	return s.MySQLDB.Connect(config)
+}
+
+func (s *SphinxDB) resolveDatabaseName(dbName string) string {
+	name := strings.TrimSpace(dbName)
+	if name == "" {
+		return s.fallbackDatabase
+	}
+	if strings.EqualFold(name, sphinxDefaultDatabaseName) && s.fallbackDatabase == "" {
+		return ""
+	}
+	return name
+}
+
+func (s *SphinxDB) GetDatabases() ([]string, error) {
+	dbs, err := s.MySQLDB.GetDatabases()
+	if err == nil && len(dbs) > 0 {
+		return dbs, nil
+	}
+	if s.fallbackDatabase != "" {
+		return []string{s.fallbackDatabase}, nil
+	}
+	return []string{sphinxDefaultDatabaseName}, nil
+}
+
+func (s *SphinxDB) GetTables(dbName string) ([]string, error) {
+	tables, err := s.MySQLDB.GetTables(s.resolveDatabaseName(dbName))
+	if err == nil {
+		return tables, nil
+	}
+	if !isSphinxUnsupportedFeatureError(err) {
+		return nil, err
+	}
+
+	// Sphinx/Manticore 常见返回列名为 `Index`，并且不支持 `SHOW TABLES FROM <db>` 语法。
+	data, fields, fallbackErr := s.MySQLDB.Query("SHOW TABLES")
+	if fallbackErr != nil {
+		return nil, fallbackErr
+	}
+
+	fallbackTables := make([]string, 0, len(data))
+	for _, row := range data {
+		if val, ok := row["Index"]; ok {
+			fallbackTables = append(fallbackTables, fmt.Sprintf("%v", val))
+			continue
+		}
+		if val, ok := row["index"]; ok {
+			fallbackTables = append(fallbackTables, fmt.Sprintf("%v", val))
+			continue
+		}
+		for _, field := range fields {
+			if val, ok := row[field]; ok {
+				fallbackTables = append(fallbackTables, fmt.Sprintf("%v", val))
+				break
+			}
+		}
+	}
+
+	return fallbackTables, nil
+}
+
+func (s *SphinxDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	return s.MySQLDB.GetCreateStatement(s.resolveDatabaseName(dbName), tableName)
+}
+
+func (s *SphinxDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	// Sphinx 使用 DESCRIBE 语法获取索引结构
+	query := fmt.Sprintf("DESCRIBE %s", tableName)
+	data, _, err := s.MySQLDB.Query(query)
+	if err != nil {
+		// 如果 DESCRIBE 失败，尝试使用 MySQL 的方式作为降级
+		return s.MySQLDB.GetColumns(s.resolveDatabaseName(dbName), tableName)
+	}
+
+	var columns []connection.ColumnDefinition
+	for _, row := range data {
+		// Sphinx DESCRIBE 返回的字段：Field, Type, Properties
+		fieldName := ""
+		if val, ok := row["Field"]; ok {
+			fieldName = fmt.Sprintf("%v", val)
+		} else if val, ok := row["field"]; ok {
+			fieldName = fmt.Sprintf("%v", val)
+		}
+
+		fieldType := ""
+		if val, ok := row["Type"]; ok {
+			fieldType = fmt.Sprintf("%v", val)
+		} else if val, ok := row["type"]; ok {
+			fieldType = fmt.Sprintf("%v", val)
+		}
+
+		properties := ""
+		if val, ok := row["Properties"]; ok {
+			properties = fmt.Sprintf("%v", val)
+		} else if val, ok := row["properties"]; ok {
+			properties = fmt.Sprintf("%v", val)
+		}
+
+		if fieldName == "" {
+			continue
+		}
+
+		col := connection.ColumnDefinition{
+			Name:     fieldName,
+			Type:     fieldType,
+			Nullable: "YES", // Sphinx 默认字段可为空
+			Key:      "",    // Sphinx 没有主键概念
+			Default:  nil,   // Sphinx DESCRIBE 不返回默认值
+			Extra:    properties,
+			Comment:  "",
+		}
+
+		// 根据 properties 判断是否为索引字段
+		if strings.Contains(strings.ToLower(properties), "indexed") {
+			col.Key = "MUL"
+		}
+
+		columns = append(columns, col)
+	}
+
+	// 如果没有获取到任何列，尝试使用 MySQL 方式
+	if len(columns) == 0 {
+		logger.Warnf("Sphinx DESCRIBE 未返回任何列，尝试使用 MySQL 方式获取：表=%s", tableName)
+		return s.MySQLDB.GetColumns(s.resolveDatabaseName(dbName), tableName)
+	}
+
+	return columns, nil
+}
+
+func (s *SphinxDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	return s.MySQLDB.GetAllColumns(s.resolveDatabaseName(dbName))
+}
+
+func (s *SphinxDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	return s.MySQLDB.GetIndexes(s.resolveDatabaseName(dbName), tableName)
+}
+
+func (s *SphinxDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	fks, err := s.MySQLDB.GetForeignKeys(s.resolveDatabaseName(dbName), tableName)
+	if err != nil && isSphinxUnsupportedFeatureError(err) {
+		return []connection.ForeignKeyDefinition{}, nil
+	}
+	return fks, err
+}
+
+func (s *SphinxDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	triggers, err := s.MySQLDB.GetTriggers(s.resolveDatabaseName(dbName), tableName)
+	if err != nil && isSphinxUnsupportedFeatureError(err) {
+		return []connection.TriggerDefinition{}, nil
+	}
+	return triggers, err
+}

internal/db/sqlite_impl.go

@@ -1,9 +1,14 @@
+//go:build gonavi_full_drivers || gonavi_sqlite_driver
+
 package db
 
 import (
 	"context"
 	"database/sql"
 	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
 	"strings"
 	"time"
 
@@ -19,7 +24,14 @@ type SQLiteDB struct {
 }
 
 func (s *SQLiteDB) Connect(config connection.ConnectionConfig) error {
-	dsn := config.Host
+	dsn, err := resolveSQLiteDSN(config)
+	if err != nil {
+		return err
+	}
+	if err := ensureSQLiteParentDir(dsn); err != nil {
+		return err
+	}
+
 	db, err := sql.Open("sqlite", dsn)
 	if err != nil {
 		return fmt.Errorf("打开数据库连接失败：%w", err)
@@ -29,11 +41,140 @@ func (s *SQLiteDB) Connect(config connection.ConnectionConfig) error {
 
 	// Force verification
 	if err := s.Ping(); err != nil {
+		_ = db.Close()
+		s.conn = nil
 		return fmt.Errorf("连接建立后验证失败：%w", err)
 	}
 	return nil
 }
 
+func resolveSQLiteDSN(config connection.ConnectionConfig) (string, error) {
+	dsn := strings.TrimSpace(config.Host)
+	if dsn == "" {
+		dsn = strings.TrimSpace(config.Database)
+	}
+	dsn = normalizeSQLitePath(dsn)
+	if dsn == "" {
+		return "", fmt.Errorf("SQLite 需要本地数据库文件路径（例如 /path/to/demo.sqlite）")
+	}
+	if strings.EqualFold(dsn, ":memory:") {
+		return dsn, nil
+	}
+	if looksLikeHostPort(dsn) {
+		return "", fmt.Errorf("SQLite 需要本地数据库文件路径，当前输入看起来是主机地址：%s", dsn)
+	}
+	return dsn, nil
+}
+
+func normalizeSQLitePath(raw string) string {
+	text := strings.TrimSpace(raw)
+	if strings.HasPrefix(text, "/") && len(text) > 3 && isWindowsDrivePath(text[1:]) {
+		text = text[1:]
+	}
+	if isWindowsDrivePath(text) {
+		text = trimLegacyPortSuffix(text)
+	}
+	return text
+}
+
+func isWindowsDrivePath(path string) bool {
+	if len(path) < 3 {
+		return false
+	}
+	drive := path[0]
+	if !((drive >= 'a' && drive <= 'z') || (drive >= 'A' && drive <= 'Z')) {
+		return false
+	}
+	if path[1] != ':' {
+		return false
+	}
+	sep := path[2]
+	return sep == '\\' || sep == '/'
+}
+
+func trimLegacyPortSuffix(path string) string {
+	normalized := path
+	for {
+		idx := strings.LastIndex(normalized, ":")
+		if idx <= 1 || idx+1 >= len(normalized) {
+			return normalized
+		}
+		suffix := normalized[idx+1:]
+		validDigits := true
+		for _, ch := range suffix {
+			if ch < '0' || ch > '9' {
+				validDigits = false
+				break
+			}
+		}
+		if !validDigits {
+			return normalized
+		}
+		normalized = normalized[:idx]
+	}
+}
+
+func looksLikeHostPort(raw string) bool {
+	text := strings.TrimSpace(raw)
+	if text == "" {
+		return false
+	}
+	if strings.ContainsAny(text, `/\`) {
+		return false
+	}
+	if strings.HasPrefix(strings.ToLower(text), "file:") {
+		return false
+	}
+	if strings.HasPrefix(text, "[") {
+		closing := strings.LastIndex(text, "]")
+		if closing <= 0 || closing+1 >= len(text) {
+			return false
+		}
+		portText := strings.TrimSpace(strings.TrimPrefix(text[closing+1:], ":"))
+		return isValidPortText(portText)
+	}
+	if strings.Count(text, ":") != 1 {
+		return false
+	}
+	split := strings.LastIndex(text, ":")
+	if split <= 0 || split+1 >= len(text) {
+		return false
+	}
+	return isValidPortText(strings.TrimSpace(text[split+1:]))
+}
+
+func isValidPortText(text string) bool {
+	port, err := strconv.Atoi(text)
+	return err == nil && port > 0 && port <= 65535
+}
+
+func ensureSQLiteParentDir(dsn string) error {
+	text := strings.TrimSpace(dsn)
+	if text == "" || strings.EqualFold(text, ":memory:") {
+		return nil
+	}
+	// file: URI 由驱动处理，避免在这里误判路径格式。
+	if strings.HasPrefix(strings.ToLower(text), "file:") {
+		return nil
+	}
+	path := text
+	if idx := strings.Index(path, "?"); idx >= 0 {
+		path = path[:idx]
+	}
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return nil
+	}
+	dir := filepath.Dir(path)
+	if dir == "." || dir == "" {
+		return nil
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return fmt.Errorf("创建 SQLite 数据文件目录失败：%w", err)
+	}
+	return nil
+}
+
 func (s *SQLiteDB) Close() error {
 	if s.conn != nil {
 		return s.conn.Close()

internal/db/sqlite_impl_test.go

@@ -0,0 +1,79 @@
+//go:build gonavi_full_drivers || gonavi_sqlite_driver
+
+package db
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+func TestResolveSQLiteDSNRejectsHostPort(t *testing.T) {
+	_, err := resolveSQLiteDSN(connection.ConnectionConfig{Type: "sqlite", Host: "localhost:3306"})
+	if err == nil {
+		t.Fatalf("期望拦截 host:port 输入")
+	}
+	if !strings.Contains(err.Error(), "本地数据库文件路径") {
+		t.Fatalf("错误提示不符合预期: %v", err)
+	}
+}
+
+func TestResolveSQLiteDSNFallbackDatabase(t *testing.T) {
+	dsn, err := resolveSQLiteDSN(connection.ConnectionConfig{Type: "sqlite", Database: "/tmp/demo.sqlite"})
+	if err != nil {
+		t.Fatalf("解析 DSN 失败: %v", err)
+	}
+	if dsn != "/tmp/demo.sqlite" {
+		t.Fatalf("期望使用 database 作为 DSN，实际=%s", dsn)
+	}
+}
+
+func TestResolveSQLiteDSNNormalizesWindowsLegacyPath(t *testing.T) {
+	dsn, err := resolveSQLiteDSN(connection.ConnectionConfig{Type: "sqlite", Host: `F:\py\py\history.db:3306:3306`})
+	if err != nil {
+		t.Fatalf("解析 DSN 失败: %v", err)
+	}
+	if dsn != `F:\py\py\history.db` {
+		t.Fatalf("期望清理历史端口污染，实际=%s", dsn)
+	}
+}
+
+func TestResolveSQLiteDSNNormalizesWindowsPathWithLeadingSlash(t *testing.T) {
+	dsn, err := resolveSQLiteDSN(connection.ConnectionConfig{Type: "sqlite", Host: `/F:\py\py\history.db:3306`})
+	if err != nil {
+		t.Fatalf("解析 DSN 失败: %v", err)
+	}
+	if dsn != `F:\py\py\history.db` {
+		t.Fatalf("期望清理前导斜杠与端口污染，实际=%s", dsn)
+	}
+}
+
+func TestEnsureSQLiteParentDirCreatesNestedDir(t *testing.T) {
+	base := t.TempDir()
+	target := filepath.Join(base, "nested", "child", "demo.sqlite")
+	if err := ensureSQLiteParentDir(target); err != nil {
+		t.Fatalf("创建目录失败: %v", err)
+	}
+	info, err := os.Stat(filepath.Dir(target))
+	if err != nil {
+		t.Fatalf("目录不存在: %v", err)
+	}
+	if !info.IsDir() {
+		t.Fatalf("目标不是目录: %s", filepath.Dir(target))
+	}
+}
+
+func TestLooksLikeHostPort(t *testing.T) {
+	if !looksLikeHostPort("localhost:3306") {
+		t.Fatalf("localhost:3306 应识别为 host:port")
+	}
+	if looksLikeHostPort("/tmp/demo.sqlite") {
+		t.Fatalf("/tmp/demo.sqlite 不应识别为 host:port")
+	}
+	if looksLikeHostPort(`C:\sqlite\demo.db`) {
+		t.Fatalf("Windows 路径不应识别为 host:port")
+	}
+}

internal/db/sqlserver_impl.go

@@ -0,0 +1,637 @@
+//go:build gonavi_full_drivers || gonavi_sqlserver_driver
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/ssh"
+	"GoNavi-Wails/internal/utils"
+
+	_ "github.com/microsoft/go-mssqldb"
+)
+
+type SqlServerDB struct {
+	conn        *sql.DB
+	pingTimeout time.Duration
+	forwarder   *ssh.LocalForwarder
+}
+
+// quoteBracket escapes ] in identifiers for safe use in SQL Server [bracket] notation
+func quoteBracket(name string) string {
+	return strings.ReplaceAll(name, "]", "]]")
+}
+
+func (s *SqlServerDB) getDSN(config connection.ConnectionConfig) string {
+	// sqlserver://user:password@host:port?database=dbname
+	dbname := config.Database
+	if dbname == "" {
+		dbname = "master"
+	}
+
+	u := &url.URL{
+		Scheme: "sqlserver",
+		Host:   net.JoinHostPort(config.Host, strconv.Itoa(config.Port)),
+	}
+	u.User = url.UserPassword(config.User, config.Password)
+
+	q := url.Values{}
+	q.Set("database", dbname)
+	q.Set("connection timeout", strconv.Itoa(getConnectTimeoutSeconds(config)))
+	q.Set("encrypt", "disable")
+	q.Set("TrustServerCertificate", "true")
+	u.RawQuery = q.Encode()
+
+	return u.String()
+}
+
+func (s *SqlServerDB) Connect(config connection.ConnectionConfig) error {
+	var dsn string
+
+	if config.UseSSH {
+		logger.Infof("SQL Server 使用 SSH 连接：地址=%s:%d 用户=%s", config.Host, config.Port, config.User)
+
+		forwarder, err := ssh.GetOrCreateLocalForwarder(config.SSH, config.Host, config.Port)
+		if err != nil {
+			return fmt.Errorf("创建 SSH 隧道失败：%w", err)
+		}
+		s.forwarder = forwarder
+
+		host, portStr, err := net.SplitHostPort(forwarder.LocalAddr)
+		if err != nil {
+			return fmt.Errorf("解析本地转发地址失败：%w", err)
+		}
+
+		port, err := strconv.Atoi(portStr)
+		if err != nil {
+			return fmt.Errorf("解析本地端口失败：%w", err)
+		}
+
+		localConfig := config
+		localConfig.Host = host
+		localConfig.Port = port
+		localConfig.UseSSH = false
+
+		dsn = s.getDSN(localConfig)
+		logger.Infof("SQL Server 通过本地端口转发连接：%s -> %s:%d", forwarder.LocalAddr, config.Host, config.Port)
+	} else {
+		dsn = s.getDSN(config)
+	}
+
+	db, err := sql.Open("sqlserver", dsn)
+	if err != nil {
+		return fmt.Errorf("打开数据库连接失败：%w", err)
+	}
+	s.conn = db
+	s.pingTimeout = getConnectTimeout(config)
+
+	if err := s.Ping(); err != nil {
+		return fmt.Errorf("连接建立后验证失败：%w", err)
+	}
+	return nil
+}
+
+func (s *SqlServerDB) Close() error {
+	if s.forwarder != nil {
+		if err := s.forwarder.Close(); err != nil {
+			logger.Warnf("关闭 SQL Server SSH 端口转发失败：%v", err)
+		}
+		s.forwarder = nil
+	}
+
+	if s.conn != nil {
+		return s.conn.Close()
+	}
+	return nil
+}
+
+func (s *SqlServerDB) Ping() error {
+	if s.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+	timeout := s.pingTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := utils.ContextWithTimeout(timeout)
+	defer cancel()
+	return s.conn.PingContext(ctx)
+}
+
+func (s *SqlServerDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if s.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := s.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
+func (s *SqlServerDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	if s.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := s.conn.Query(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (s *SqlServerDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if s.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := s.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (s *SqlServerDB) Exec(query string) (int64, error) {
+	if s.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := s.conn.Exec(query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (s *SqlServerDB) GetDatabases() ([]string, error) {
+	query := "SELECT name FROM sys.databases WHERE state_desc = 'ONLINE' ORDER BY name"
+	data, _, err := s.Query(query)
+	if err != nil {
+		return nil, err
+	}
+	var dbs []string
+	for _, row := range data {
+		if val, ok := row["name"]; ok {
+			dbs = append(dbs, fmt.Sprintf("%v", val))
+		}
+	}
+	return dbs, nil
+}
+
+func (s *SqlServerDB) GetTables(dbName string) ([]string, error) {
+	// SQL Server uses schema.table format, default schema is dbo
+	safeDB := quoteBracket(dbName)
+	query := fmt.Sprintf(`
+SELECT s.name AS schema_name, t.name AS table_name
+FROM [%s].sys.tables t
+JOIN [%s].sys.schemas s ON t.schema_id = s.schema_id
+WHERE t.type = 'U'
+ORDER BY s.name, t.name`, safeDB, safeDB)
+
+	data, _, err := s.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var tables []string
+	for _, row := range data {
+		schema, okSchema := row["schema_name"]
+		name, okName := row["table_name"]
+		if okSchema && okName {
+			tables = append(tables, fmt.Sprintf("%v.%v", schema, name))
+			continue
+		}
+		if okName {
+			tables = append(tables, fmt.Sprintf("%v", name))
+		}
+	}
+	return tables, nil
+}
+
+func (s *SqlServerDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	return fmt.Sprintf("-- SHOW CREATE TABLE not supported for SQL Server in this version.\n-- Table: %s.%s", dbName, tableName), nil
+}
+
+func (s *SqlServerDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	schema := "dbo"
+	table := strings.TrimSpace(tableName)
+
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+	safeDB := quoteBracket(dbName)
+
+	query := fmt.Sprintf(`
+SELECT
+    c.name AS column_name,
+    t.name + CASE
+        WHEN t.name IN ('varchar', 'nvarchar', 'char', 'nchar') THEN '(' + CASE WHEN c.max_length = -1 THEN 'MAX' ELSE CAST(CASE WHEN t.name IN ('nvarchar', 'nchar') THEN c.max_length / 2 ELSE c.max_length END AS VARCHAR) END + ')'
+        WHEN t.name IN ('decimal', 'numeric') THEN '(' + CAST(c.precision AS VARCHAR) + ',' + CAST(c.scale AS VARCHAR) + ')'
+        ELSE ''
+    END AS data_type,
+    CASE WHEN c.is_nullable = 1 THEN 'YES' ELSE 'NO' END AS is_nullable,
+    dc.definition AS column_default,
+    ep.value AS comment,
+    CASE WHEN pk.column_id IS NOT NULL THEN 'PRI' ELSE '' END AS column_key,
+    CASE WHEN c.is_identity = 1 THEN 'auto_increment' ELSE '' END AS extra
+FROM [%s].sys.columns c
+JOIN [%s].sys.types t ON c.user_type_id = t.user_type_id
+JOIN [%s].sys.tables tb ON c.object_id = tb.object_id
+JOIN [%s].sys.schemas s ON tb.schema_id = s.schema_id
+LEFT JOIN [%s].sys.default_constraints dc ON c.default_object_id = dc.object_id
+LEFT JOIN [%s].sys.extended_properties ep ON ep.major_id = c.object_id AND ep.minor_id = c.column_id AND ep.name = 'MS_Description'
+LEFT JOIN (
+    SELECT ic.object_id, ic.column_id
+    FROM [%s].sys.index_columns ic
+    JOIN [%s].sys.indexes i ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+    WHERE i.is_primary_key = 1
+) pk ON pk.object_id = c.object_id AND pk.column_id = c.column_id
+WHERE s.name = '%s' AND tb.name = '%s'
+ORDER BY c.column_id`,
+		safeDB, safeDB, safeDB, safeDB, safeDB, safeDB, safeDB, safeDB,
+		esc(schema), esc(table))
+
+	data, _, err := s.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var columns []connection.ColumnDefinition
+	for _, row := range data {
+		col := connection.ColumnDefinition{
+			Name:     fmt.Sprintf("%v", row["column_name"]),
+			Type:     fmt.Sprintf("%v", row["data_type"]),
+			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
+			Key:      fmt.Sprintf("%v", row["column_key"]),
+			Extra:    fmt.Sprintf("%v", row["extra"]),
+			Comment:  "",
+		}
+
+		if v, ok := row["comment"]; ok && v != nil {
+			col.Comment = fmt.Sprintf("%v", v)
+		}
+
+		if v, ok := row["column_default"]; ok && v != nil {
+			def := fmt.Sprintf("%v", v)
+			col.Default = &def
+		}
+
+		columns = append(columns, col)
+	}
+	return columns, nil
+}
+
+func (s *SqlServerDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	safeDB := quoteBracket(dbName)
+	query := fmt.Sprintf(`
+SELECT s.name AS schema_name, t.name AS table_name, c.name AS column_name, tp.name AS data_type
+FROM [%s].sys.columns c
+JOIN [%s].sys.tables t ON c.object_id = t.object_id
+JOIN [%s].sys.schemas s ON t.schema_id = s.schema_id
+JOIN [%s].sys.types tp ON c.user_type_id = tp.user_type_id
+WHERE t.type = 'U'
+ORDER BY s.name, t.name, c.column_id`, safeDB, safeDB, safeDB, safeDB)
+
+	data, _, err := s.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var cols []connection.ColumnDefinitionWithTable
+	for _, row := range data {
+		schema := fmt.Sprintf("%v", row["schema_name"])
+		table := fmt.Sprintf("%v", row["table_name"])
+		tableName := fmt.Sprintf("%s.%s", schema, table)
+
+		col := connection.ColumnDefinitionWithTable{
+			TableName: tableName,
+			Name:      fmt.Sprintf("%v", row["column_name"]),
+			Type:      fmt.Sprintf("%v", row["data_type"]),
+		}
+		cols = append(cols, col)
+	}
+	return cols, nil
+}
+
+func (s *SqlServerDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	schema := "dbo"
+	table := strings.TrimSpace(tableName)
+
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+	safeDB := quoteBracket(dbName)
+
+	query := fmt.Sprintf(`
+SELECT
+    i.name AS index_name,
+    c.name AS column_name,
+    i.is_unique,
+    ic.key_ordinal AS seq_in_index,
+    i.type_desc AS index_type
+FROM [%s].sys.indexes i
+JOIN [%s].sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+JOIN [%s].sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+JOIN [%s].sys.tables t ON i.object_id = t.object_id
+JOIN [%s].sys.schemas s ON t.schema_id = s.schema_id
+WHERE s.name = '%s' AND t.name = '%s' AND i.name IS NOT NULL
+ORDER BY i.name, ic.key_ordinal`,
+		safeDB, safeDB, safeDB, safeDB, safeDB, esc(schema), esc(table))
+
+	data, _, err := s.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var indexes []connection.IndexDefinition
+	for _, row := range data {
+		isUnique := false
+		if v, ok := row["is_unique"]; ok && v != nil {
+			switch val := v.(type) {
+			case bool:
+				isUnique = val
+			case int64:
+				isUnique = val == 1
+			}
+		}
+
+		nonUnique := 1
+		if isUnique {
+			nonUnique = 0
+		}
+
+		seq := 0
+		if v, ok := row["seq_in_index"]; ok && v != nil {
+			switch val := v.(type) {
+			case int:
+				seq = val
+			case int64:
+				seq = int(val)
+			}
+		}
+
+		indexType := "NONCLUSTERED"
+		if v, ok := row["index_type"]; ok && v != nil {
+			indexType = strings.ToUpper(fmt.Sprintf("%v", v))
+		}
+
+		idx := connection.IndexDefinition{
+			Name:       fmt.Sprintf("%v", row["index_name"]),
+			ColumnName: fmt.Sprintf("%v", row["column_name"]),
+			NonUnique:  nonUnique,
+			SeqInIndex: seq,
+			IndexType:  indexType,
+		}
+		indexes = append(indexes, idx)
+	}
+	return indexes, nil
+}
+
+func (s *SqlServerDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	schema := "dbo"
+	table := strings.TrimSpace(tableName)
+
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+	safeDB := quoteBracket(dbName)
+
+	query := fmt.Sprintf(`
+SELECT
+    fk.name AS constraint_name,
+    c.name AS column_name,
+    rs.name AS foreign_schema,
+    rt.name AS foreign_table,
+    rc.name AS foreign_column
+FROM [%s].sys.foreign_keys fk
+JOIN [%s].sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
+JOIN [%s].sys.columns c ON fkc.parent_object_id = c.object_id AND fkc.parent_column_id = c.column_id
+JOIN [%s].sys.tables t ON fk.parent_object_id = t.object_id
+JOIN [%s].sys.schemas s ON t.schema_id = s.schema_id
+JOIN [%s].sys.tables rt ON fk.referenced_object_id = rt.object_id
+JOIN [%s].sys.schemas rs ON rt.schema_id = rs.schema_id
+JOIN [%s].sys.columns rc ON fkc.referenced_object_id = rc.object_id AND fkc.referenced_column_id = rc.column_id
+WHERE s.name = '%s' AND t.name = '%s'
+ORDER BY fk.name`,
+		safeDB, safeDB, safeDB, safeDB, safeDB, safeDB, safeDB, safeDB, esc(schema), esc(table))
+
+	data, _, err := s.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var fks []connection.ForeignKeyDefinition
+	for _, row := range data {
+		refSchema := fmt.Sprintf("%v", row["foreign_schema"])
+		refTable := fmt.Sprintf("%v", row["foreign_table"])
+		refTableName := fmt.Sprintf("%s.%s", refSchema, refTable)
+
+		fk := connection.ForeignKeyDefinition{
+			Name:           fmt.Sprintf("%v", row["constraint_name"]),
+			ColumnName:     fmt.Sprintf("%v", row["column_name"]),
+			RefTableName:   refTableName,
+			RefColumnName:  fmt.Sprintf("%v", row["foreign_column"]),
+			ConstraintName: fmt.Sprintf("%v", row["constraint_name"]),
+		}
+		fks = append(fks, fk)
+	}
+	return fks, nil
+}
+
+func (s *SqlServerDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	schema := "dbo"
+	table := strings.TrimSpace(tableName)
+
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+	safeDB := quoteBracket(dbName)
+
+	query := fmt.Sprintf(`
+SELECT
+    tr.name AS trigger_name,
+    CASE WHEN tr.is_instead_of_trigger = 1 THEN 'INSTEAD OF' ELSE 'AFTER' END AS timing,
+    STUFF((
+        SELECT ', ' + te.type_desc
+        FROM [%s].sys.trigger_events te
+        WHERE te.object_id = tr.object_id
+        FOR XML PATH('')
+    ), 1, 2, '') AS event,
+    OBJECT_DEFINITION(tr.object_id) AS statement
+FROM [%s].sys.triggers tr
+JOIN [%s].sys.tables t ON tr.parent_id = t.object_id
+JOIN [%s].sys.schemas s ON t.schema_id = s.schema_id
+WHERE s.name = '%s' AND t.name = '%s'
+ORDER BY tr.name`,
+		safeDB, safeDB, safeDB, safeDB, esc(schema), esc(table))
+
+	data, _, err := s.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var triggers []connection.TriggerDefinition
+	for _, row := range data {
+		trig := connection.TriggerDefinition{
+			Name:      fmt.Sprintf("%v", row["trigger_name"]),
+			Timing:    fmt.Sprintf("%v", row["timing"]),
+			Event:     fmt.Sprintf("%v", row["event"]),
+			Statement: "",
+		}
+		if v, ok := row["statement"]; ok && v != nil {
+			trig.Statement = fmt.Sprintf("%v", v)
+		}
+		triggers = append(triggers, trig)
+	}
+	return triggers, nil
+}
+
+func (s *SqlServerDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
+	if s.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+
+	tx, err := s.conn.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	quoteIdent := func(name string) string {
+		n := strings.TrimSpace(name)
+		n = strings.Trim(n, "[]")
+		n = strings.ReplaceAll(n, "]", "]]")
+		if n == "" {
+			return "[]"
+		}
+		return "[" + n + "]"
+	}
+
+	schema := "dbo"
+	table := strings.TrimSpace(tableName)
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	qualifiedTable := fmt.Sprintf("%s.%s", quoteIdent(schema), quoteIdent(table))
+
+	// 1. Deletes
+	for _, pk := range changes.Deletes {
+		var wheres []string
+		var args []interface{}
+		idx := 0
+		for k, v := range pk {
+			idx++
+			wheres = append(wheres, fmt.Sprintf("%s = @p%d", quoteIdent(k), idx))
+			args = append(args, sql.Named(fmt.Sprintf("p%d", idx), v))
+		}
+		if len(wheres) == 0 {
+			continue
+		}
+		query := fmt.Sprintf("DELETE FROM %s WHERE %s", qualifiedTable, strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("delete error: %v", err)
+		}
+	}
+
+	// 2. Updates
+	for _, update := range changes.Updates {
+		var sets []string
+		var args []interface{}
+		idx := 0
+
+		for k, v := range update.Values {
+			idx++
+			sets = append(sets, fmt.Sprintf("%s = @p%d", quoteIdent(k), idx))
+			args = append(args, sql.Named(fmt.Sprintf("p%d", idx), v))
+		}
+
+		if len(sets) == 0 {
+			continue
+		}
+
+		var wheres []string
+		for k, v := range update.Keys {
+			idx++
+			wheres = append(wheres, fmt.Sprintf("%s = @p%d", quoteIdent(k), idx))
+			args = append(args, sql.Named(fmt.Sprintf("p%d", idx), v))
+		}
+
+		if len(wheres) == 0 {
+			return fmt.Errorf("update requires keys")
+		}
+
+		query := fmt.Sprintf("UPDATE %s SET %s WHERE %s", qualifiedTable, strings.Join(sets, ", "), strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("update error: %v", err)
+		}
+	}
+
+	// 3. Inserts
+	for _, row := range changes.Inserts {
+		var cols []string
+		var placeholders []string
+		var args []interface{}
+		idx := 0
+
+		for k, v := range row {
+			idx++
+			cols = append(cols, quoteIdent(k))
+			placeholders = append(placeholders, fmt.Sprintf("@p%d", idx))
+			args = append(args, sql.Named(fmt.Sprintf("p%d", idx), v))
+		}
+
+		if len(cols) == 0 {
+			continue
+		}
+
+		query := fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s)", qualifiedTable, strings.Join(cols, ", "), strings.Join(placeholders, ", "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("insert error: %v", err)
+		}
+	}
+
+	return tx.Commit()
+}

internal/db/tdengine_impl.go

@@ -0,0 +1,400 @@
+//go:build gonavi_full_drivers || gonavi_tdengine_driver
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/ssh"
+	"GoNavi-Wails/internal/utils"
+
+	_ "github.com/taosdata/driver-go/v3/taosWS"
+)
+
+// TDengineDB implements Database interface for TDengine.
+// Uses taosWS driver via WebSocket (通常通过 taosAdapter 提供服务)。
+type TDengineDB struct {
+	conn        *sql.DB
+	pingTimeout time.Duration
+	forwarder   *ssh.LocalForwarder
+}
+
+func (t *TDengineDB) getDSN(config connection.ConnectionConfig) string {
+	user := strings.TrimSpace(config.User)
+	if user == "" {
+		user = "root"
+	}
+
+	pass := config.Password
+	dbName := strings.TrimSpace(config.Database)
+	path := "/"
+	if dbName != "" {
+		path = "/" + dbName
+	}
+
+	return fmt.Sprintf("%s:%s@ws(%s)%s", user, pass, net.JoinHostPort(config.Host, strconv.Itoa(config.Port)), path)
+}
+
+func (t *TDengineDB) Connect(config connection.ConnectionConfig) error {
+	var dsn string
+
+	if config.UseSSH {
+		logger.Infof("TDengine 使用 SSH 连接：地址=%s:%d 用户=%s", config.Host, config.Port, config.User)
+
+		forwarder, err := ssh.GetOrCreateLocalForwarder(config.SSH, config.Host, config.Port)
+		if err != nil {
+			return fmt.Errorf("创建 SSH 隧道失败：%w", err)
+		}
+		t.forwarder = forwarder
+
+		host, portStr, err := net.SplitHostPort(forwarder.LocalAddr)
+		if err != nil {
+			return fmt.Errorf("解析本地转发地址失败：%w", err)
+		}
+		port, err := strconv.Atoi(portStr)
+		if err != nil {
+			return fmt.Errorf("解析本地端口失败：%w", err)
+		}
+
+		localConfig := config
+		localConfig.Host = host
+		localConfig.Port = port
+		localConfig.UseSSH = false
+		dsn = t.getDSN(localConfig)
+		logger.Infof("TDengine 通过本地端口转发连接：%s -> %s:%d", forwarder.LocalAddr, config.Host, config.Port)
+	} else {
+		dsn = t.getDSN(config)
+	}
+
+	db, err := sql.Open("taosWS", dsn)
+	if err != nil {
+		return fmt.Errorf("打开数据库连接失败：%w", err)
+	}
+	t.conn = db
+	t.pingTimeout = getConnectTimeout(config)
+
+	if err := t.Ping(); err != nil {
+		return fmt.Errorf("连接建立后验证失败：%w", err)
+	}
+	return nil
+}
+
+func (t *TDengineDB) Close() error {
+	if t.forwarder != nil {
+		if err := t.forwarder.Close(); err != nil {
+			logger.Warnf("关闭 TDengine SSH 端口转发失败：%v", err)
+		}
+		t.forwarder = nil
+	}
+
+	if t.conn != nil {
+		return t.conn.Close()
+	}
+	return nil
+}
+
+func (t *TDengineDB) Ping() error {
+	if t.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+	timeout := t.pingTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := utils.ContextWithTimeout(timeout)
+	defer cancel()
+	return t.conn.PingContext(ctx)
+}
+
+func (t *TDengineDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if t.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := t.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
+func (t *TDengineDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	if t.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := t.conn.Query(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
+func (t *TDengineDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if t.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := t.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (t *TDengineDB) Exec(query string) (int64, error) {
+	if t.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := t.conn.Exec(query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (t *TDengineDB) GetDatabases() ([]string, error) {
+	data, _, err := t.Query("SHOW DATABASES")
+	if err != nil {
+		return nil, err
+	}
+
+	var dbs []string
+	for _, row := range data {
+		if val, ok := getValueFromRow(row, "name", "database", "Database", "db_name"); ok {
+			dbs = append(dbs, fmt.Sprintf("%v", val))
+			continue
+		}
+		for _, val := range row {
+			dbs = append(dbs, fmt.Sprintf("%v", val))
+			break
+		}
+	}
+	return dbs, nil
+}
+
+func (t *TDengineDB) GetTables(dbName string) ([]string, error) {
+	queries := make([]string, 0, 2)
+	if strings.TrimSpace(dbName) != "" {
+		queries = append(queries, fmt.Sprintf("SHOW TABLES FROM `%s`", escapeBacktickIdent(dbName)))
+	}
+	queries = append(queries, "SHOW TABLES")
+
+	var lastErr error
+	for _, query := range queries {
+		data, _, err := t.Query(query)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		var tables []string
+		for _, row := range data {
+			if val, ok := getValueFromRow(row, "table_name", "tablename", "name", "Table", "table"); ok {
+				tables = append(tables, fmt.Sprintf("%v", val))
+				continue
+			}
+			for _, val := range row {
+				tables = append(tables, fmt.Sprintf("%v", val))
+				break
+			}
+		}
+		return tables, nil
+	}
+
+	if lastErr != nil {
+		return nil, lastErr
+	}
+	return []string{}, nil
+}
+
+func (t *TDengineDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	qualified := quoteTDengineTable(dbName, tableName)
+	queries := []string{
+		fmt.Sprintf("SHOW CREATE TABLE %s", qualified),
+		fmt.Sprintf("SHOW CREATE STABLE %s", qualified),
+	}
+
+	var lastErr error
+	for _, query := range queries {
+		data, _, err := t.Query(query)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		if len(data) == 0 {
+			continue
+		}
+
+		row := data[0]
+		if val, ok := getValueFromRow(row, "Create Table", "create table", "Create Stable", "create stable", "SQL", "sql"); ok {
+			return fmt.Sprintf("%v", val), nil
+		}
+
+		longest := ""
+		for _, val := range row {
+			text := fmt.Sprintf("%v", val)
+			if strings.Contains(strings.ToUpper(text), "CREATE ") && len(text) > len(longest) {
+				longest = text
+			}
+		}
+		if longest != "" {
+			return longest, nil
+		}
+	}
+
+	if lastErr != nil {
+		return "", lastErr
+	}
+	return "", fmt.Errorf("create statement not found")
+}
+
+func (t *TDengineDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	query := fmt.Sprintf("DESCRIBE %s", quoteTDengineTable(dbName, tableName))
+	data, _, err := t.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	columns := make([]connection.ColumnDefinition, 0, len(data))
+	for _, row := range data {
+		name, _ := getValueFromRow(row, "Field", "field", "col_name", "column_name", "name")
+		colType, _ := getValueFromRow(row, "Type", "type", "data_type")
+		note, _ := getValueFromRow(row, "Note", "note", "Extra", "extra")
+		nullable, okNull := getValueFromRow(row, "Null", "null", "nullable")
+		comment, _ := getValueFromRow(row, "Comment", "comment")
+		defaultVal, hasDefault := getValueFromRow(row, "Default", "default")
+
+		col := connection.ColumnDefinition{
+			Name:     fmt.Sprintf("%v", name),
+			Type:     fmt.Sprintf("%v", colType),
+			Nullable: "YES",
+			Key:      "",
+			Extra:    fmt.Sprintf("%v", note),
+			Comment:  fmt.Sprintf("%v", comment),
+		}
+
+		if okNull {
+			col.Nullable = strings.ToUpper(fmt.Sprintf("%v", nullable))
+		}
+
+		noteUpper := strings.ToUpper(fmt.Sprintf("%v", note))
+		if strings.Contains(noteUpper, "TAG") {
+			col.Key = "TAG"
+		}
+
+		if hasDefault && defaultVal != nil {
+			def := fmt.Sprintf("%v", defaultVal)
+			if def != "<nil>" {
+				col.Default = &def
+			}
+		}
+
+		columns = append(columns, col)
+	}
+	return columns, nil
+}
+
+func (t *TDengineDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	if strings.TrimSpace(dbName) == "" {
+		return nil, fmt.Errorf("database name required for GetAllColumns")
+	}
+
+	tables, err := t.GetTables(dbName)
+	if err != nil {
+		return nil, err
+	}
+
+	cols := make([]connection.ColumnDefinitionWithTable, 0)
+	for _, table := range tables {
+		tableCols, err := t.GetColumns(dbName, table)
+		if err != nil {
+			continue
+		}
+		for _, col := range tableCols {
+			cols = append(cols, connection.ColumnDefinitionWithTable{
+				TableName: table,
+				Name:      col.Name,
+				Type:      col.Type,
+			})
+		}
+	}
+
+	return cols, nil
+}
+
+func (t *TDengineDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	return []connection.IndexDefinition{}, nil
+}
+
+func (t *TDengineDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	return []connection.ForeignKeyDefinition{}, nil
+}
+
+func (t *TDengineDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	return []connection.TriggerDefinition{}, nil
+}
+
+func getValueFromRow(row map[string]interface{}, keys ...string) (interface{}, bool) {
+	if len(row) == 0 {
+		return nil, false
+	}
+
+	for _, key := range keys {
+		if val, ok := row[key]; ok {
+			return val, true
+		}
+	}
+
+	for existingKey, val := range row {
+		for _, key := range keys {
+			if strings.EqualFold(existingKey, key) {
+				return val, true
+			}
+		}
+	}
+
+	return nil, false
+}
+
+func escapeBacktickIdent(ident string) string {
+	return strings.ReplaceAll(strings.TrimSpace(ident), "`", "``")
+}
+
+func quoteTDengineTable(dbName, tableName string) string {
+	t := escapeBacktickIdent(tableName)
+	if t == "" {
+		return "``"
+	}
+	if strings.Contains(t, ".") {
+		parts := strings.Split(t, ".")
+		quoted := make([]string, 0, len(parts))
+		for _, part := range parts {
+			part = strings.TrimSpace(part)
+			if part == "" {
+				continue
+			}
+			quoted = append(quoted, fmt.Sprintf("`%s`", escapeBacktickIdent(part)))
+		}
+		if len(quoted) > 0 {
+			return strings.Join(quoted, ".")
+		}
+	}
+
+	db := escapeBacktickIdent(dbName)
+	if db == "" {
+		return fmt.Sprintf("`%s`", t)
+	}
+	return fmt.Sprintf("`%s`.`%s`", db, t)
+}

internal/db/vastbase_impl.go

@@ -0,0 +1,629 @@
+//go:build gonavi_full_drivers || gonavi_vastbase_driver
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/ssh"
+	"GoNavi-Wails/internal/utils"
+
+	_ "github.com/lib/pq" // Vastbase is PostgreSQL compatible
+)
+
+// VastbaseDB implements Database interface for Vastbase (海量) database
+// Vastbase is a PostgreSQL-compatible database, so we reuse PostgreSQL driver
+type VastbaseDB struct {
+	conn        *sql.DB
+	pingTimeout time.Duration
+	forwarder   *ssh.LocalForwarder
+}
+
+func (v *VastbaseDB) getDSN(config connection.ConnectionConfig) string {
+	dbname := config.Database
+	if dbname == "" {
+		dbname = "vastbase" // Vastbase default database
+	}
+
+	u := &url.URL{
+		Scheme: "postgres",
+		Host:   net.JoinHostPort(config.Host, strconv.Itoa(config.Port)),
+		Path:   "/" + dbname,
+	}
+	u.User = url.UserPassword(config.User, config.Password)
+	q := url.Values{}
+	q.Set("sslmode", "disable")
+	q.Set("connect_timeout", strconv.Itoa(getConnectTimeoutSeconds(config)))
+	u.RawQuery = q.Encode()
+
+	return u.String()
+}
+
+func (v *VastbaseDB) Connect(config connection.ConnectionConfig) error {
+	var dsn string
+
+	if config.UseSSH {
+		logger.Infof("Vastbase 使用 SSH 连接：地址=%s:%d 用户=%s", config.Host, config.Port, config.User)
+
+		forwarder, err := ssh.GetOrCreateLocalForwarder(config.SSH, config.Host, config.Port)
+		if err != nil {
+			return fmt.Errorf("创建 SSH 隧道失败：%w", err)
+		}
+		v.forwarder = forwarder
+
+		host, portStr, err := net.SplitHostPort(forwarder.LocalAddr)
+		if err != nil {
+			return fmt.Errorf("解析本地转发地址失败：%w", err)
+		}
+
+		port, err := strconv.Atoi(portStr)
+		if err != nil {
+			return fmt.Errorf("解析本地端口失败：%w", err)
+		}
+
+		localConfig := config
+		localConfig.Host = host
+		localConfig.Port = port
+		localConfig.UseSSH = false
+
+		dsn = v.getDSN(localConfig)
+		logger.Infof("Vastbase 通过本地端口转发连接：%s -> %s:%d", forwarder.LocalAddr, config.Host, config.Port)
+	} else {
+		dsn = v.getDSN(config)
+	}
+
+	db, err := sql.Open("postgres", dsn)
+	if err != nil {
+		return fmt.Errorf("打开数据库连接失败：%w", err)
+	}
+	v.conn = db
+	v.pingTimeout = getConnectTimeout(config)
+
+	if err := v.Ping(); err != nil {
+		return fmt.Errorf("连接建立后验证失败：%w", err)
+	}
+	return nil
+}
+
+func (v *VastbaseDB) Close() error {
+	if v.forwarder != nil {
+		if err := v.forwarder.Close(); err != nil {
+			logger.Warnf("关闭 Vastbase SSH 端口转发失败：%v", err)
+		}
+		v.forwarder = nil
+	}
+
+	if v.conn != nil {
+		return v.conn.Close()
+	}
+	return nil
+}
+
+func (v *VastbaseDB) Ping() error {
+	if v.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+	timeout := v.pingTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := utils.ContextWithTimeout(timeout)
+	defer cancel()
+	return v.conn.PingContext(ctx)
+}
+
+func (v *VastbaseDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if v.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := v.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
+func (v *VastbaseDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	if v.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := v.conn.Query(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (v *VastbaseDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if v.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := v.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (v *VastbaseDB) Exec(query string) (int64, error) {
+	if v.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := v.conn.Exec(query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (v *VastbaseDB) GetDatabases() ([]string, error) {
+	data, _, err := v.Query("SELECT datname FROM pg_database WHERE datistemplate = false")
+	if err != nil {
+		return nil, err
+	}
+	var dbs []string
+	for _, row := range data {
+		if val, ok := row["datname"]; ok {
+			dbs = append(dbs, fmt.Sprintf("%v", val))
+		}
+	}
+	return dbs, nil
+}
+
+func (v *VastbaseDB) GetTables(dbName string) ([]string, error) {
+	query := "SELECT schemaname, tablename FROM pg_catalog.pg_tables WHERE schemaname != 'information_schema' AND schemaname NOT LIKE 'pg_%' ORDER BY schemaname, tablename"
+	data, _, err := v.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var tables []string
+	for _, row := range data {
+		schema, okSchema := row["schemaname"]
+		name, okName := row["tablename"]
+		if okSchema && okName {
+			tables = append(tables, fmt.Sprintf("%v.%v", schema, name))
+			continue
+		}
+		if okName {
+			tables = append(tables, fmt.Sprintf("%v", name))
+		}
+	}
+	return tables, nil
+}
+
+func (v *VastbaseDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	return fmt.Sprintf("-- SHOW CREATE TABLE not fully supported for Vastbase in this version.\n-- Table: %s", tableName), nil
+}
+
+func (v *VastbaseDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT
+	a.attname AS column_name,
+	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
+	col_description(a.attrelid, a.attnum) AS comment,
+	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
+FROM pg_class c
+JOIN pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_attribute a ON a.attrelid = c.oid
+LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
+LEFT JOIN (
+	SELECT i.indrelid, a3.attname
+	FROM pg_index i
+	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
+	WHERE i.indisprimary
+) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
+WHERE c.relkind IN ('r', 'p')
+  AND n.nspname = '%s'
+  AND c.relname = '%s'
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+ORDER BY a.attnum`, esc(schema), esc(table))
+
+	data, _, err := v.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var columns []connection.ColumnDefinition
+	for _, row := range data {
+		col := connection.ColumnDefinition{
+			Name:     fmt.Sprintf("%v", row["column_name"]),
+			Type:     fmt.Sprintf("%v", row["data_type"]),
+			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
+			Key:      fmt.Sprintf("%v", row["column_key"]),
+			Extra:    "",
+			Comment:  "",
+		}
+
+		if val, ok := row["comment"]; ok && val != nil {
+			col.Comment = fmt.Sprintf("%v", val)
+		}
+
+		if val, ok := row["column_default"]; ok && val != nil {
+			def := fmt.Sprintf("%v", val)
+			col.Default = &def
+			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
+				col.Extra = "auto_increment"
+			}
+		}
+
+		columns = append(columns, col)
+	}
+	return columns, nil
+}
+
+func (v *VastbaseDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT
+	i.relname AS index_name,
+	a.attname AS column_name,
+	ix.indisunique AS is_unique,
+	x.ordinality AS seq_in_index,
+	am.amname AS index_type
+FROM pg_class t
+JOIN pg_namespace n ON n.oid = t.relnamespace
+JOIN pg_index ix ON t.oid = ix.indrelid
+JOIN pg_class i ON i.oid = ix.indexrelid
+JOIN pg_am am ON i.relam = am.oid
+JOIN unnest(ix.indkey) WITH ORDINALITY AS x(attnum, ordinality) ON TRUE
+JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = x.attnum
+WHERE t.relkind IN ('r', 'p')
+  AND t.relname = '%s'
+  AND n.nspname = '%s'
+ORDER BY i.relname, x.ordinality`, esc(table), esc(schema))
+
+	data, _, err := v.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	parseBool := func(val interface{}) bool {
+		switch v := val.(type) {
+		case bool:
+			return v
+		case string:
+			s := strings.ToLower(strings.TrimSpace(v))
+			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
+		default:
+			s := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", val)))
+			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
+		}
+	}
+
+	parseInt := func(val interface{}) int {
+		switch v := val.(type) {
+		case int:
+			return v
+		case int64:
+			return int(v)
+		case float64:
+			return int(v)
+		case string:
+			var n int
+			_, _ = fmt.Sscanf(strings.TrimSpace(v), "%d", &n)
+			return n
+		default:
+			var n int
+			_, _ = fmt.Sscanf(strings.TrimSpace(fmt.Sprintf("%v", val)), "%d", &n)
+			return n
+		}
+	}
+
+	var indexes []connection.IndexDefinition
+	for _, row := range data {
+		isUnique := false
+		if val, ok := row["is_unique"]; ok && val != nil {
+			isUnique = parseBool(val)
+		}
+
+		nonUnique := 1
+		if isUnique {
+			nonUnique = 0
+		}
+
+		seq := 0
+		if val, ok := row["seq_in_index"]; ok && val != nil {
+			seq = parseInt(val)
+		}
+
+		indexType := ""
+		if val, ok := row["index_type"]; ok && val != nil {
+			indexType = strings.ToUpper(fmt.Sprintf("%v", val))
+		}
+		if indexType == "" {
+			indexType = "BTREE"
+		}
+
+		idx := connection.IndexDefinition{
+			Name:       fmt.Sprintf("%v", row["index_name"]),
+			ColumnName: fmt.Sprintf("%v", row["column_name"]),
+			NonUnique:  nonUnique,
+			SeqInIndex: seq,
+			IndexType:  indexType,
+		}
+		indexes = append(indexes, idx)
+	}
+	return indexes, nil
+}
+
+func (v *VastbaseDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT
+	tc.constraint_name AS constraint_name,
+	kcu.column_name AS column_name,
+	ccu.table_schema AS foreign_table_schema,
+	ccu.table_name AS foreign_table_name,
+	ccu.column_name AS foreign_column_name
+FROM information_schema.table_constraints AS tc
+JOIN information_schema.key_column_usage AS kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage AS ccu
+  ON ccu.constraint_name = tc.constraint_name
+  AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND tc.table_name = '%s'
+  AND tc.table_schema = '%s'
+ORDER BY tc.constraint_name, kcu.ordinal_position`, esc(table), esc(schema))
+
+	data, _, err := v.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var fks []connection.ForeignKeyDefinition
+	for _, row := range data {
+		refSchema := ""
+		if val, ok := row["foreign_table_schema"]; ok && val != nil {
+			refSchema = fmt.Sprintf("%v", val)
+		}
+		refTable := fmt.Sprintf("%v", row["foreign_table_name"])
+		refTableName := refTable
+		if strings.TrimSpace(refSchema) != "" {
+			refTableName = fmt.Sprintf("%s.%s", refSchema, refTable)
+		}
+
+		fk := connection.ForeignKeyDefinition{
+			Name:           fmt.Sprintf("%v", row["constraint_name"]),
+			ColumnName:     fmt.Sprintf("%v", row["column_name"]),
+			RefTableName:   refTableName,
+			RefColumnName:  fmt.Sprintf("%v", row["foreign_column_name"]),
+			ConstraintName: fmt.Sprintf("%v", row["constraint_name"]),
+		}
+		fks = append(fks, fk)
+	}
+	return fks, nil
+}
+
+func (v *VastbaseDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	schema := strings.TrimSpace(dbName)
+	if schema == "" {
+		schema = "public"
+	}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return nil, fmt.Errorf("table name required")
+	}
+
+	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
+
+	query := fmt.Sprintf(`
+SELECT trigger_name, action_timing, event_manipulation, action_statement
+FROM information_schema.triggers
+WHERE event_object_table = '%s'
+  AND event_object_schema = '%s'
+ORDER BY trigger_name, event_manipulation`, esc(table), esc(schema))
+
+	data, _, err := v.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var triggers []connection.TriggerDefinition
+	for _, row := range data {
+		trig := connection.TriggerDefinition{
+			Name:      fmt.Sprintf("%v", row["trigger_name"]),
+			Timing:    fmt.Sprintf("%v", row["action_timing"]),
+			Event:     fmt.Sprintf("%v", row["event_manipulation"]),
+			Statement: fmt.Sprintf("%v", row["action_statement"]),
+		}
+		triggers = append(triggers, trig)
+	}
+	return triggers, nil
+}
+
+func (v *VastbaseDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	query := `
+SELECT table_schema, table_name, column_name, data_type
+FROM information_schema.columns
+WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+  AND table_schema NOT LIKE 'pg_%'
+ORDER BY table_schema, table_name, ordinal_position`
+
+	data, _, err := v.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var cols []connection.ColumnDefinitionWithTable
+	for _, row := range data {
+		schema := fmt.Sprintf("%v", row["table_schema"])
+		table := fmt.Sprintf("%v", row["table_name"])
+		tableName := table
+		if strings.TrimSpace(schema) != "" {
+			tableName = fmt.Sprintf("%s.%s", schema, table)
+		}
+
+		col := connection.ColumnDefinitionWithTable{
+			TableName: tableName,
+			Name:      fmt.Sprintf("%v", row["column_name"]),
+			Type:      fmt.Sprintf("%v", row["data_type"]),
+		}
+		cols = append(cols, col)
+	}
+	return cols, nil
+}
+
+func (v *VastbaseDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
+	if v.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+
+	tx, err := v.conn.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	quoteIdent := func(name string) string {
+		n := strings.TrimSpace(name)
+		n = strings.Trim(n, "\"")
+		n = strings.ReplaceAll(n, "\"", "\"\"")
+		if n == "" {
+			return "\"\""
+		}
+		return `"` + n + `"`
+	}
+
+	schema := ""
+	table := strings.TrimSpace(tableName)
+	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
+		schema = strings.TrimSpace(parts[0])
+		table = strings.TrimSpace(parts[1])
+	}
+
+	qualifiedTable := ""
+	if schema != "" {
+		qualifiedTable = fmt.Sprintf("%s.%s", quoteIdent(schema), quoteIdent(table))
+	} else {
+		qualifiedTable = quoteIdent(table)
+	}
+
+	// 1. Deletes
+	for _, pk := range changes.Deletes {
+		var wheres []string
+		var args []interface{}
+		idx := 0
+		for k, val := range pk {
+			idx++
+			wheres = append(wheres, fmt.Sprintf("%s = $%d", quoteIdent(k), idx))
+			args = append(args, val)
+		}
+		if len(wheres) == 0 {
+			continue
+		}
+		query := fmt.Sprintf("DELETE FROM %s WHERE %s", qualifiedTable, strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("delete error: %v", err)
+		}
+	}
+
+	// 2. Updates
+	for _, update := range changes.Updates {
+		var sets []string
+		var args []interface{}
+		idx := 0
+
+		for k, val := range update.Values {
+			idx++
+			sets = append(sets, fmt.Sprintf("%s = $%d", quoteIdent(k), idx))
+			args = append(args, val)
+		}
+
+		if len(sets) == 0 {
+			continue
+		}
+
+		var wheres []string
+		for k, val := range update.Keys {
+			idx++
+			wheres = append(wheres, fmt.Sprintf("%s = $%d", quoteIdent(k), idx))
+			args = append(args, val)
+		}
+
+		if len(wheres) == 0 {
+			return fmt.Errorf("update requires keys")
+		}
+
+		query := fmt.Sprintf("UPDATE %s SET %s WHERE %s", qualifiedTable, strings.Join(sets, ", "), strings.Join(wheres, " AND "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("update error: %v", err)
+		}
+	}
+
+	// 3. Inserts
+	for _, row := range changes.Inserts {
+		var cols []string
+		var placeholders []string
+		var args []interface{}
+		idx := 0
+
+		for k, val := range row {
+			idx++
+			cols = append(cols, quoteIdent(k))
+			placeholders = append(placeholders, fmt.Sprintf("$%d", idx))
+			args = append(args, val)
+		}
+
+		if len(cols) == 0 {
+			continue
+		}
+
+		query := fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s)", qualifiedTable, strings.Join(cols, ", "), strings.Join(placeholders, ", "))
+		if _, err := tx.Exec(query, args...); err != nil {
+			return fmt.Errorf("insert error: %v", err)
+		}
+	}
+
+	return tx.Commit()
+}

internal/redis/redis.go

@@ -4,7 +4,7 @@ import "GoNavi-Wails/internal/connection"
 
 // RedisValue represents a Redis value with its type and metadata
 type RedisValue struct {
-	Type   string      `json:"type"`   // string, hash, list, set, zset
+	Type   string      `json:"type"`   // string, hash, list, set, zset, stream
 	TTL    int64       `json:"ttl"`    // TTL in seconds, -1 means no expiry, -2 means key doesn't exist
 	Value  interface{} `json:"value"`  // The actual value
 	Length int64       `json:"length"` // Length/size of the value
@@ -72,6 +72,11 @@ type RedisClient interface {
 	ZSetAdd(key string, members ...ZSetMember) error
 	ZSetRemove(key string, members ...string) error
 
+	// Stream operations
+	GetStream(key, start, stop string, count int64) ([]StreamEntry, error)
+	StreamAdd(key string, fields map[string]string, id string) (string, error)
+	StreamDelete(key string, ids ...string) (int64, error)
+
 	// Command execution
 	ExecuteCommand(args []string) (interface{}, error)
 
@@ -88,3 +93,9 @@ type ZSetMember struct {
 	Member string  `json:"member"`
 	Score  float64 `json:"score"`
 }
+
+// StreamEntry represents a single stream message
+type StreamEntry struct {
+	ID     string            `json:"id"`
+	Fields map[string]string `json:"fields"`
+}

internal/redis/redis_impl.go

@@ -334,6 +334,26 @@ func (r *RedisClientImpl) GetValue(key string) (*RedisValue, error) {
 		result.Value = members
 		result.Length = length
 
+	case "stream":
+		length, err := r.client.XLen(ctx, key).Result()
+		if err != nil {
+			return nil, err
+		}
+		result.Length = length
+		if length == 0 {
+			result.Value = []StreamEntry{}
+			break
+		}
+		limit := int64(1000)
+		if length < limit {
+			limit = length
+		}
+		val, err := r.client.XRangeN(ctx, key, "-", "+", limit).Result()
+		if err != nil {
+			return nil, err
+		}
+		result.Value = toStreamEntries(val)
+
 	default:
 		return nil, fmt.Errorf("不支持的 Redis 数据类型: %s", keyType)
 	}
@@ -523,6 +543,91 @@ func (r *RedisClientImpl) ZSetRemove(key string, members ...string) error {
 	return r.client.ZRem(ctx, key, args...).Err()
 }
 
+// GetStream gets stream entries in a range
+func (r *RedisClientImpl) GetStream(key, start, stop string, count int64) ([]StreamEntry, error) {
+	if r.client == nil {
+		return nil, fmt.Errorf("Redis 客户端未连接")
+	}
+	if start == "" {
+		start = "-"
+	}
+	if stop == "" {
+		stop = "+"
+	}
+	if count <= 0 {
+		count = 1000
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	val, err := r.client.XRangeN(ctx, key, start, stop, count).Result()
+	if err != nil {
+		return nil, err
+	}
+	return toStreamEntries(val), nil
+}
+
+// StreamAdd adds an entry to a stream
+func (r *RedisClientImpl) StreamAdd(key string, fields map[string]string, id string) (string, error) {
+	if r.client == nil {
+		return "", fmt.Errorf("Redis 客户端未连接")
+	}
+	if len(fields) == 0 {
+		return "", fmt.Errorf("Stream 字段不能为空")
+	}
+	if id == "" {
+		id = "*"
+	}
+
+	values := make(map[string]interface{}, len(fields))
+	for field, value := range fields {
+		values[field] = value
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	newID, err := r.client.XAdd(ctx, &redis.XAddArgs{
+		Stream: key,
+		ID:     id,
+		Values: values,
+	}).Result()
+	if err != nil {
+		return "", err
+	}
+	return newID, nil
+}
+
+// StreamDelete deletes entries from a stream by IDs
+func (r *RedisClientImpl) StreamDelete(key string, ids ...string) (int64, error) {
+	if r.client == nil {
+		return 0, fmt.Errorf("Redis 客户端未连接")
+	}
+	if len(ids) == 0 {
+		return 0, fmt.Errorf("Stream ID 不能为空")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	return r.client.XDel(ctx, key, ids...).Result()
+}
+
+func toStreamEntries(messages []redis.XMessage) []StreamEntry {
+	entries := make([]StreamEntry, 0, len(messages))
+	for _, msg := range messages {
+		fields := make(map[string]string, len(msg.Values))
+		for field, value := range msg.Values {
+			fields[field] = fmt.Sprint(value)
+		}
+		entries = append(entries, StreamEntry{
+			ID:     msg.ID,
+			Fields: fields,
+		})
+	}
+	return entries
+}
+
 // ExecuteCommand executes a raw Redis command
 func (r *RedisClientImpl) ExecuteCommand(args []string) (interface{}, error) {
 	if r.client == nil {

internal/sync/sql_helpers.go

@@ -22,8 +22,11 @@ func quoteIdentByType(dbType string, ident string) string {
 	}
 
 	switch dbType {
-	case "mysql":
+	case "mysql", "mariadb", "diros", "sphinx":
 		return "`" + strings.ReplaceAll(ident, "`", "``") + "`"
+	case "sqlserver":
+		escaped := strings.ReplaceAll(ident, "]", "]]")
+		return "[" + escaped + "]"
 	default:
 		return `"` + strings.ReplaceAll(ident, `"`, `""`) + `"`
 	}
@@ -71,7 +74,7 @@ func normalizeSchemaAndTable(dbType string, dbName string, tableName string) (st
 	}
 
 	switch strings.ToLower(strings.TrimSpace(dbType)) {
-	case "postgres", "kingbase":
+	case "postgres", "kingbase", "vastbase":
 		return "public", rawTable
 	default:
 		return rawDB, rawTable
@@ -88,7 +91,7 @@ func qualifiedNameForQuery(dbType string, schema string, table string, original
 	}
 
 	switch strings.ToLower(strings.TrimSpace(dbType)) {
-	case "postgres", "kingbase":
+	case "postgres", "kingbase", "vastbase":
 		s := strings.TrimSpace(schema)
 		if s == "" {
 			s = "public"
@@ -97,7 +100,7 @@ func qualifiedNameForQuery(dbType string, schema string, table string, original
 			return raw
 		}
 		return s + "." + table
-	case "mysql":
+	case "mysql", "mariadb", "diros", "sphinx":
 		s := strings.TrimSpace(schema)
 		if s == "" || table == "" {
 			return table

main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/options"
 	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
+	"github.com/wailsapp/wails/v2/pkg/options/mac"
 	"github.com/wailsapp/wails/v2/pkg/options/windows"
 )
 
@@ -41,6 +42,10 @@ func main() {
 			DisableWindowIcon:                 false,
 			DisableFramelessWindowDecorations: false,
 		},
+		Mac: &mac.Options{
+			WebviewIsTransparent: true,
+			WindowIsTranslucent:  true,
+		},
 	})
 
 	if err != nil {