Merge pull request #134 from Syngnat/release/0.4.9

release/0.4.9

.github/ISSUE_TEMPLATE/01-bug_report.yml

@@ -0,0 +1,58 @@
+name: 问题反馈
+description: 软件问题反馈
+title: "[Bug] "
+labels: ["bug"]
+
+body:
+  - type: checkboxes
+    id: searched
+    attributes:
+      label: 已经搜索过 Issues，未发现重复问题*
+      options:
+        - label: 我已经搜索过 Issues，没有发现重复问题
+    validations:
+      required: true
+
+  - type: input
+    id: system
+    attributes:
+      label: 操作系统及版本
+      placeholder: Windows 10 22H2 / macOS Mojave / Linux
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: 软件安装版本
+      placeholder: v0.2.3
+    validations:
+      required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 问题简述及复现流程
+      description: 请详细描述你遇到的问题，并提供复现步骤
+      placeholder: |
+        1. 打开软件
+        2. 点击 xxx
+        3. 预期结果是 ...
+        4. 实际结果是 ...
+        5. 截图 ...
+    validations:
+      required: true
+
+  - type: textarea
+    id: extra
+    attributes:
+      label: 其他补充
+      description: 如果你有额外信息，请在此填写
+      placeholder: 可选
+
+  - type: checkboxes
+    id: pr
+    attributes:
+      label: 是否愿意提交 PR 修复当前 Issue
+      options:
+        - label: 我愿意尝试提交 PR

.github/ISSUE_TEMPLATE/02-feature_request.yml

@@ -0,0 +1,37 @@
+name: 功能建议
+description: 添加全新功能或改进现有功能
+title: "[Enhancement] "
+labels: ["enhancement"]
+
+body:
+  - type: checkboxes
+    id: searched
+    attributes:
+      label: 已经搜索过 Issues，未发现重复问题*
+      options:
+        - label: 我已经搜索过 Issues，没有发现重复问题
+    validations:
+      required: true
+
+  - type: textarea
+    id: feature
+    attributes:
+      label: 功能描述
+      description: 请详细描述你希望添加或改进的功能
+      placeholder: 请描述你想要的功能
+    validations:
+      required: true
+
+  - type: textarea
+    id: extra
+    attributes:
+      label: 其他补充
+      description: 如果你有额外信息，请在此填写
+      placeholder: 可选
+
+  - type: checkboxes
+    id: pr
+    attributes:
+      label: 是否愿意提交 PR 实现当前 Issue
+      options:
+        - label: 我愿意尝试提交 PR

.github/ISSUE_TEMPLATE/03-generic.yml

@@ -0,0 +1,30 @@
+name: 其他反馈
+description: 其他类型反馈、建议或讨论
+title: "[Question] "
+labels: ["question"]
+
+body:
+  - type: checkboxes
+    id: searched
+    attributes:
+      label: 已经搜索过 Issues，未发现重复问题*
+      options:
+        - label: 我已经搜索过 Issues，没有发现重复问题
+    validations:
+      required: true
+
+  - type: textarea
+    id: content
+    attributes:
+      label: 内容
+      description: 请填写你的反馈、建议或讨论内容
+      placeholder: 请描述你的问题或想法
+    validations:
+      required: true
+
+  - type: textarea
+    id: extra
+    attributes:
+      label: 其他补充
+      description: 如果你有额外信息，请在此填写
+      placeholder: 可选

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/workflows/release-winget.yml

@@ -0,0 +1,22 @@
+name: Publish to WinGet
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        required: true
+        description: 'Tag of release you want to publish'
+        type: string
+
+jobs:
+  publish:
+    runs-on: windows-latest
+    steps:
+      - uses: vedantmgoyal9/winget-releaser@v2
+        with:
+          identifier: Syngnat.GoNavi
+          installers-regex: 'GoNavi-windows-(amd64|arm64)\.exe$'
+          release-tag: ${{ inputs.release_tag || github.ref_name }}
+          token: ${{ secrets.WINGET_TOKEN }}

.github/workflows/release.yml

@@ -19,16 +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
+            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
+            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
@@ -45,19 +88,111 @@ jobs:
         with:
           node-version: '20'
 
+      # Linux Dependencies (GTK3, WebKit2GTK required by Wails)
+      - name: Install Linux Dependencies
+        if: contains(matrix.platform, 'linux')
+        run: |
+          sudo apt-get update
+          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"
+          PLUGIN_URL="https://github.com/linuxdeploy/linuxdeploy-plugin-gtk/releases/download/continuous/linuxdeploy-plugin-gtk-x86_64.AppImage"
+
+          echo "📥 下载 linuxdeploy..."
+          wget --retry-connrefused --waitretry=1 --read-timeout=20 --timeout=15 --tries=3 \
+            -O /tmp/linuxdeploy "$LINUXDEPLOY_URL" || {
+            echo "⚠️ linuxdeploy 下载失败，AppImage 打包将跳过"
+            touch /tmp/skip-appimage
+          }
+
+          echo "📥 下载 linuxdeploy-plugin-gtk..."
+          wget --retry-connrefused --waitretry=1 --read-timeout=20 --timeout=15 --tries=3 \
+            -O /tmp/linuxdeploy-plugin-gtk "$PLUGIN_URL" || {
+            echo "⚠️ linuxdeploy-plugin-gtk 下载失败，AppImage 打包将跳过"
+            touch /tmp/skip-appimage
+          }
+
+          if [ ! -f /tmp/skip-appimage ]; then
+            chmod +x /tmp/linuxdeploy /tmp/linuxdeploy-plugin-gtk
+            echo "✅ AppImage 工具准备完成"
+          fi
+
       - name: Install Wails
         run: go install -v github.com/wailsapp/wails/v2/cmd/wails@latest
 
       - name: Build
         shell: bash
         run: |
-          wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.artifact_name }}
+          set -euo pipefail
+          if [ -n "${{ matrix.wails_tags }}" ]; then
+            wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.build_name }} -tags "${{ matrix.wails_tags }}" -ldflags "-s -w -X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"
+          else
+            wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.build_name }} -ldflags "-s -w -X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"
+          fi
+
+      - 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 clickhouse)
+          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)
@@ -68,9 +203,12 @@ jobs:
           APP_NAME=$(basename "$APP_PATH")
           
           echo "🔏 正在进行 Ad-hoc 签名..."
-          codesign --force --options runtime --deep --sign - "$APP_NAME"
+          # 注意：Ad-hoc + hardened runtime（--options runtime）在未配置 entitlements 时，
+          # 可能导致部分 macOS 机型上应用双击无响应。这里保持 Ad-hoc 深签名但禁用 runtime hardened。
+          codesign --force --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 \
@@ -84,35 +222,131 @@ 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: |
+          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
+          }
+
+          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 }}"
-          
-          if [ -f "$TARGET.exe" ]; then
-              FINAL_EXE="$TARGET.exe"
-          elif [ -f "$TARGET" ]; then
-              mv "$TARGET" "$TARGET.exe"
-              FINAL_EXE="$TARGET.exe"
-          else
+          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'!"
               exit 1
           fi
-          
-          echo "📦 正在移动 $FINAL_EXE 到根目录..."
-          mv "$FINAL_EXE" "../../$FINAL_EXE"
+
+          chmod +x "$TARGET"
+
+          # 1. Create 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
+              echo "⚠️ 跳过 AppImage 打包"
+              exit 0
+          fi
+
+          echo "📦 正在生成 AppImage..."
+
+          # Create AppDir structure
+          mkdir -p AppDir/usr/bin
+          mkdir -p AppDir/usr/share/applications
+          mkdir -p AppDir/usr/share/icons/hicolor/256x256/apps
+
+          cp "$TARGET" AppDir/usr/bin/gonavi
+
+          # Create desktop file
+          printf '%s\n' \
+            '[Desktop Entry]' \
+            'Name=GoNavi' \
+            'Exec=gonavi' \
+            'Icon=gonavi' \
+            'Type=Application' \
+            'Categories=Development;Database;' \
+            'Comment=Database Management Tool' \
+            > AppDir/usr/share/applications/gonavi.desktop
+
+          cp AppDir/usr/share/applications/gonavi.desktop AppDir/gonavi.desktop
+
+          # Create a simple icon (or use existing if available)
+          if [ -f "../../build/appicon.png" ]; then
+              cp "../../build/appicon.png" AppDir/usr/share/icons/hicolor/256x256/apps/gonavi.png
+              cp "../../build/appicon.png" AppDir/gonavi.png
+          else
+              # Create a placeholder icon
+              convert -size 256x256 xc:#336791 -fill white -gravity center -pointsize 48 -annotate 0 "GoNavi" AppDir/gonavi.png || \
+              wget -q "https://via.placeholder.com/256/336791/FFFFFF?text=GoNavi" -O AppDir/gonavi.png || \
+              touch AppDir/gonavi.png
+              cp AppDir/gonavi.png AppDir/usr/share/icons/hicolor/256x256/apps/gonavi.png
+          fi
+
+          # Build AppImage
+          export DEPLOY_GTK_VERSION=3
+          /tmp/linuxdeploy --appdir AppDir --plugin gtk --output appimage || {
+              echo "⚠️ AppImage 生成失败，但 tar.gz 已成功生成"
+              exit 0
+          }
+
+          # Rename output
+          mv GoNavi*.AppImage "$APPIMAGE_NAME" 2>/dev/null || {
+              echo "⚠️ AppImage 重命名失败"
+              exit 0
+          }
+
+          if [ -f "$APPIMAGE_NAME" ]; then
+              mv "$APPIMAGE_NAME" ../../
+              echo "✅ AppImage 生成成功"
+          fi
 
       # Upload to Actions Artifacts (Temporary Storage)
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         with:
           name: build-artifacts-${{ strategy.job-index }} # Unique name per job
-          path: GoNavi-*${{ matrix.asset_ext }}
+          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)
@@ -131,6 +365,76 @@ 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
+          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
         if: startsWith(github.ref, 'refs/tags/')

.gitignore

@@ -6,7 +6,7 @@
 frontend/release/
 **/release/
 **/dist/
-**/build/
+build/bin/
 
 # wails / node artifacts (按需)
 node_modules/
@@ -17,3 +17,5 @@ dist/
 GoNavi-Wails
 GoNavi-Wails.exe
 .ace-tool/
+.claude/
+tmpclaude-*

README.md

@@ -31,16 +31,45 @@
 - **虚拟滚动**：轻松处理海量数据展示，拒绝卡顿。
 
 ### 🔌 多数据库支持
-- **MySQL**：完整的支持，包括表结构设计、索引管理、外键管理等。
-- **PostgreSQL**：基础支持（持续完善中）。
+- **MySQL**：完整支持，涵盖数据编辑、结构管理与导入导出。
+- **PostgreSQL**：数据查看与编辑支持，事务提交能力持续完善。
 - **SQLite**：本地文件数据库支持。
+- **Oracle**：基础数据访问与编辑支持。
+- **Dameng（达梦）**：基础数据访问与编辑支持。
+- **Kingbase（人大金仓）**：基础数据访问与编辑支持。
+- **TDengine**：时序数据库连接、库表浏览与 SQL 查询支持。
+- **Redis**：Key/Value 浏览、命令执行、视图与编码切换。
+- **自定义驱动**：支持配置 Driver/DSN 接入更多数据源。
 - **SSH 隧道**：内置 SSH 隧道支持，安全连接内网数据库。
 
 ### 📊 强大的数据管理 (DataGrid)
 - **所见即所得编辑**：直接在表格中双击单元格修改数据。
-- **事务操作**：支持批量新增、修改、删除，一键提交或回滚事务。
+- **批量事务操作**：支持批量新增、修改、删除，一键提交或回滚事务。
+- **大字段编辑**：双击大字段自动打开弹窗编辑器，避免卡顿。
+- **右键上下文菜单**：快速设置 NULL、复制/导出等操作。
 - **智能上下文**：自动识别单表查询，解锁编辑功能；复杂查询自动切换为只读模式。
-- **数据导出**：支持导出为 CSV, Excel (XLSX), JSON, Markdown 等格式。
+- **批量导出/备份**：支持表与数据库的批量导出/备份。
+- **数据导出**：支持 CSV、Excel (XLSX)、JSON、Markdown 等格式。
+
+### 🧰 批量导出/备份
+- **数据库批量导出**：支持结构导出与结构+数据备份。
+- **表批量导出**：支持多表一键导出/备份。
+- **智能上下文检测**：自动判断目标范围，避免误操作。
+
+### 🧩 Redis 视图与编码
+- **视图模式切换**：自动/原始文本/UTF-8/十六进制多模式显示。
+- **智能解码**：针对二进制值进行 UTF-8 质量判定与中文字符识别。
+- **命令执行**：内置命令面板快速操作。
+
+### 🔄 数据同步与导入导出
+- **连接配置导入/导出**：支持配置 JSON 导入导出，便于团队共享。
+- **数据同步**：内置数据同步面板，支持跨库同步任务配置。
+
+### 🆙 在线更新
+- **自动更新**：启动/定时/手动检查更新，自动下载并提示重启完成更新。
+
+### 🧾 可观测性
+- **SQL 执行日志**：实时查看 SQL 与执行耗时，便于排障与优化。
 
 ### 📝 智能 SQL 编辑器
 - **Monaco Editor 内核**：集成 VS Code 同款编辑器，体验极佳。
@@ -100,6 +129,7 @@ wails build -clean
 支持构建：
 *   macOS (AMD64 / ARM64)
 *   Windows (AMD64)
+*   Linux (AMD64，提供 WebKitGTK 4.0 与 4.1 变体产物)
 
 ---
 
@@ -117,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,6 +12,7 @@ if [ -z "$VERSION" ]; then
     VERSION="0.0.0"
 fi
 echo "ℹ️  检测到版本号: $VERSION"
+LDFLAGS="-s -w -X GoNavi-Wails/internal/app.AppVersion=$VERSION"
 
 # 颜色配置
 GREEN='\033[0;32m'
@@ -27,7 +28,7 @@ mkdir -p $DIST_DIR
 
 # --- macOS ARM64 构建 ---
 echo -e "${GREEN}🍎 正在构建 macOS (arm64)...${NC}"
-wails build -platform darwin/arm64 -clean
+wails build -platform darwin/arm64 -clean -ldflags "$LDFLAGS"
 if [ $? -eq 0 ]; then
     APP_SRC="$BUILD_BIN_DIR/$DEFAULT_BINARY_NAME.app"
     APP_DEST_NAME="${APP_NAME}-${VERSION}-mac-arm64.app"
@@ -81,7 +82,7 @@ fi
 
 # --- macOS AMD64 构建 ---
 echo -e "${GREEN}🍎 正在构建 macOS (amd64)...${NC}"
-wails build -platform darwin/amd64 -clean
+wails build -platform darwin/amd64 -clean -ldflags "$LDFLAGS"
 if [ $? -eq 0 ]; then
     APP_SRC="$BUILD_BIN_DIR/$DEFAULT_BINARY_NAME.app"
     APP_DEST_NAME="${APP_NAME}-${VERSION}-mac-amd64.app"
@@ -131,19 +132,147 @@ fi
 # --- Windows AMD64 构建 ---
 echo -e "${GREEN}🪟 正在构建 Windows (amd64)...${NC}"
 if command -v x86_64-w64-mingw32-gcc &> /dev/null; then
-    wails build -platform windows/amd64 -clean
+    wails build -platform windows/amd64 -clean -ldflags "$LDFLAGS"
     if [ $? -eq 0 ]; then
         mv "$BUILD_BIN_DIR/${DEFAULT_BINARY_NAME}.exe" "$DIST_DIR/${APP_NAME}-${VERSION}-windows-amd64.exe"
         echo "   ✅ 已生成 ${APP_NAME}-${VERSION}-windows-amd64.exe"
     else
-        echo -e "${RED}   ❌ Windows 构建失败。${NC}"
+        echo -e "${RED}   ❌ Windows amd64 构建失败。${NC}"
     fi
 else
-    echo -e "${YELLOW}   ⚠️  未找到 MinGW 工具 (x86_64-w64-mingw32-gcc)，跳过 Windows 构建。${NC}"
+    echo -e "${YELLOW}   ⚠️  未找到 MinGW 工具 (x86_64-w64-mingw32-gcc)，跳过 Windows amd64 构建。${NC}"
+fi
+
+# --- Windows ARM64 构建 ---
+echo -e "${GREEN}🪟 正在构建 Windows (arm64)...${NC}"
+if command -v aarch64-w64-mingw32-gcc &> /dev/null; then
+    wails build -platform windows/arm64 -clean -ldflags "$LDFLAGS"
+    if [ $? -eq 0 ]; then
+        mv "$BUILD_BIN_DIR/${DEFAULT_BINARY_NAME}.exe" "$DIST_DIR/${APP_NAME}-${VERSION}-windows-arm64.exe"
+        echo "   ✅ 已生成 ${APP_NAME}-${VERSION}-windows-arm64.exe"
+    else
+        echo -e "${RED}   ❌ Windows arm64 构建失败。${NC}"
+    fi
+else
+    echo -e "${YELLOW}   ⚠️  未找到 MinGW ARM64 工具 (aarch64-w64-mingw32-gcc)，跳过 Windows arm64 构建。${NC}"
+    echo "      安装命令: brew install mingw-w64 (需要支持 ARM64 的版本)"
+fi
+
+# --- Linux AMD64 构建 ---
+echo -e "${GREEN}🐧 正在构建 Linux (amd64)...${NC}"
+# 检测当前系统
+CURRENT_OS=$(uname -s)
+CURRENT_ARCH=$(uname -m)
+
+if [ "$CURRENT_OS" = "Linux" ] && [ "$CURRENT_ARCH" = "x86_64" ]; then
+    # 本机 Linux amd64，直接构建
+    wails build -platform linux/amd64 -clean -ldflags "$LDFLAGS"
+    if [ $? -eq 0 ]; then
+        mv "$BUILD_BIN_DIR/${DEFAULT_BINARY_NAME}" "$DIST_DIR/${APP_NAME}-${VERSION}-linux-amd64"
+        chmod +x "$DIST_DIR/${APP_NAME}-${VERSION}-linux-amd64"
+        # 打包为 tar.gz
+        cd "$DIST_DIR"
+        tar -czvf "${APP_NAME}-${VERSION}-linux-amd64.tar.gz" "${APP_NAME}-${VERSION}-linux-amd64"
+        rm "${APP_NAME}-${VERSION}-linux-amd64"
+        cd ..
+        echo "   ✅ 已生成 ${APP_NAME}-${VERSION}-linux-amd64.tar.gz"
+    else
+        echo -e "${RED}   ❌ Linux amd64 构建失败。${NC}"
+    fi
+elif command -v x86_64-linux-gnu-gcc &> /dev/null; then
+    # macOS 或其他系统，尝试交叉编译
+    export CC=x86_64-linux-gnu-gcc
+    export CXX=x86_64-linux-gnu-g++
+    export CGO_ENABLED=1
+    wails build -platform linux/amd64 -clean -ldflags "$LDFLAGS"
+    if [ $? -eq 0 ]; then
+        mv "$BUILD_BIN_DIR/${DEFAULT_BINARY_NAME}" "$DIST_DIR/${APP_NAME}-${VERSION}-linux-amd64"
+        chmod +x "$DIST_DIR/${APP_NAME}-${VERSION}-linux-amd64"
+        cd "$DIST_DIR"
+        tar -czvf "${APP_NAME}-${VERSION}-linux-amd64.tar.gz" "${APP_NAME}-${VERSION}-linux-amd64"
+        rm "${APP_NAME}-${VERSION}-linux-amd64"
+        cd ..
+        echo "   ✅ 已生成 ${APP_NAME}-${VERSION}-linux-amd64.tar.gz"
+    else
+        echo -e "${RED}   ❌ Linux amd64 交叉编译失败。${NC}"
+    fi
+    unset CC CXX CGO_ENABLED
+else
+    echo -e "${YELLOW}   ⚠️  非 Linux 系统且未找到交叉编译工具，跳过 Linux amd64 构建。${NC}"
+    echo "      在 Linux 上运行此脚本可直接构建，或安装交叉编译工具链。"
+fi
+
+# --- Linux ARM64 构建 ---
+echo -e "${GREEN}🐧 正在构建 Linux (arm64)...${NC}"
+if [ "$CURRENT_OS" = "Linux" ] && [ "$CURRENT_ARCH" = "aarch64" ]; then
+    # 本机 Linux arm64，直接构建
+    wails build -platform linux/arm64 -clean -ldflags "$LDFLAGS"
+    if [ $? -eq 0 ]; then
+        mv "$BUILD_BIN_DIR/${DEFAULT_BINARY_NAME}" "$DIST_DIR/${APP_NAME}-${VERSION}-linux-arm64"
+        chmod +x "$DIST_DIR/${APP_NAME}-${VERSION}-linux-arm64"
+        cd "$DIST_DIR"
+        tar -czvf "${APP_NAME}-${VERSION}-linux-arm64.tar.gz" "${APP_NAME}-${VERSION}-linux-arm64"
+        rm "${APP_NAME}-${VERSION}-linux-arm64"
+        cd ..
+        echo "   ✅ 已生成 ${APP_NAME}-${VERSION}-linux-arm64.tar.gz"
+    else
+        echo -e "${RED}   ❌ Linux arm64 构建失败。${NC}"
+    fi
+elif command -v aarch64-linux-gnu-gcc &> /dev/null; then
+    # 交叉编译
+    export CC=aarch64-linux-gnu-gcc
+    export CXX=aarch64-linux-gnu-g++
+    export CGO_ENABLED=1
+    wails build -platform linux/arm64 -clean -ldflags "$LDFLAGS"
+    if [ $? -eq 0 ]; then
+        mv "$BUILD_BIN_DIR/${DEFAULT_BINARY_NAME}" "$DIST_DIR/${APP_NAME}-${VERSION}-linux-arm64"
+        chmod +x "$DIST_DIR/${APP_NAME}-${VERSION}-linux-arm64"
+        cd "$DIST_DIR"
+        tar -czvf "${APP_NAME}-${VERSION}-linux-arm64.tar.gz" "${APP_NAME}-${VERSION}-linux-arm64"
+        rm "${APP_NAME}-${VERSION}-linux-arm64"
+        cd ..
+        echo "   ✅ 已生成 ${APP_NAME}-${VERSION}-linux-arm64.tar.gz"
+    else
+        echo -e "${RED}   ❌ Linux arm64 交叉编译失败。${NC}"
+    fi
+    unset CC CXX CGO_ENABLED
+else
+    echo -e "${YELLOW}   ⚠️  非 Linux ARM64 系统且未找到交叉编译工具，跳过 Linux arm64 构建。${NC}"
+    echo "      安装命令 (Ubuntu): sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu"
+    echo "      安装命令 (macOS): brew install aarch64-linux-gnu-gcc (需要第三方 tap)"
 fi
 
 # 清理中间构建目录
 rm -rf "build/bin"
 
+echo -e "${GREEN}🔐 生成 SHA256SUMS...${NC}"
+if command -v sha256sum &> /dev/null; then
+    cd "$DIST_DIR"
+    : > SHA256SUMS
+    for f in *; do
+        [ -f "$f" ] || continue
+        sha256sum "$f" >> SHA256SUMS
+    done
+    cd ..
+elif command -v shasum &> /dev/null; then
+    cd "$DIST_DIR"
+    : > SHA256SUMS
+    for f in *; do
+        [ -f "$f" ] || continue
+        shasum -a 256 "$f" >> SHA256SUMS
+    done
+    cd ..
+else
+    echo -e "${YELLOW}   ⚠️  未找到 sha256sum/shasum，跳过校验文件生成。${NC}"
+fi
+
+echo ""
 echo -e "${GREEN}🎉 所有任务完成！构建产物在 'dist/' 目录下：${NC}"
-ls -1 "$DIST_DIR"
+ls -lh "$DIST_DIR"
+echo ""
+echo -e "${GREEN}📋 支持的平台：${NC}"
+echo "   • macOS (Intel/Apple Silicon): .dmg"
+echo "   • Windows (x64/ARM64): .exe"
+echo "   • Linux (x64/ARM64): .tar.gz"
+echo ""
+echo -e "${YELLOW}💡 提示：Linux AppImage 包请使用 GitHub Actions CI/CD 构建。${NC}"

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>

build/windows/info.json

@@ -0,0 +1,15 @@
+{
+	"fixed": {
+		"file_version": "{{.Info.ProductVersion}}"
+	},
+	"info": {
+		"0000": {
+			"ProductVersion": "{{.Info.ProductVersion}}",
+			"CompanyName": "{{.Info.CompanyName}}",
+			"FileDescription": "{{.Info.ProductName}}",
+			"LegalCopyright": "{{.Info.Copyright}}",
+			"ProductName": "{{.Info.ProductName}}",
+			"Comments": "{{.Info.Comments}}"
+		}
+	}
+}

build/windows/wails.exe.manifest

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+    <assemblyIdentity type="win32" name="com.wails.{{.Name}}" version="{{.Info.ProductVersion}}.0" processorArchitecture="*"/>
+    <dependency>
+        <dependentAssembly>
+            <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/>
+        </dependentAssembly>
+    </dependency>
+    <asmv3:application>
+        <asmv3:windowsSettings>
+            <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware> <!-- fallback for Windows 7 and 8 -->
+            <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2,permonitor</dpiAwareness> <!-- falls back to per-monitor if per-monitor v2 is not supported -->
+        </asmv3:windowsSettings>
+    </asmv3:application>
+</assembly>

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_clickhouse.go

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

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,89 @@
+{
+  "engine": "go",
+  "drivers": {
+    "mariadb": {
+      "engine": "go",
+      "version": "1.9.3",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/mariadb"
+    },
+    "diros": {
+      "engine": "go",
+      "version": "1.9.3",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/diros"
+    },
+    "sphinx": {
+      "engine": "go",
+      "version": "1.9.3",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/sphinx"
+    },
+    "sqlserver": {
+      "engine": "go",
+      "version": "1.9.6",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/sqlserver"
+    },
+    "sqlite": {
+      "engine": "go",
+      "version": "1.44.3",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/sqlite"
+    },
+    "duckdb": {
+      "engine": "go",
+      "version": "2.5.5",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/duckdb"
+    },
+    "dameng": {
+      "engine": "go",
+      "version": "1.8.22",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/dameng"
+    },
+    "kingbase": {
+      "engine": "go",
+      "version": "0.0.0-20201021123113-29bd62a876c3",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/kingbase"
+    },
+    "highgo": {
+      "engine": "go",
+      "version": "0.0.0-local",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/highgo"
+    },
+    "vastbase": {
+      "engine": "go",
+      "version": "1.11.1",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/vastbase"
+    },
+    "mongodb": {
+      "engine": "go",
+      "version": "2.5.0",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/mongodb"
+    },
+    "tdengine": {
+      "engine": "go",
+      "version": "3.7.8",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/tdengine"
+    },
+    "clickhouse": {
+      "engine": "go",
+      "version": "2.43.0",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/clickhouse"
+    },
+    "postgres": {
+      "engine": "go",
+      "version": "1.11.1",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/postgres"
+    }
+  }
+}

frontend/.gitignore

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

frontend/index.html

@@ -2,7 +2,7 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <link rel="icon" type="image/svg+xml" href="/logo.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>GoNavi</title>
   </head>
@@ -10,4 +10,4 @@
     <div id="root"></div>
     <script type="module" src="/src/main.tsx"></script>
   </body>
-</html>
+</html>

frontend/package.json.md5

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

frontend/public/logo.svg

@@ -0,0 +1,52 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <defs>
+    <!-- Background: Soft Light Grey -->
+    <linearGradient id="bgSoft" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#f5f7fa;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#c3cfe2;stop-opacity:1" />
+    </linearGradient>
+
+    <!-- Hexagon: Solid Tech Pink -->
+    <linearGradient id="solidPink" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#FF5F6D;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#FFC371;stop-opacity:1" /> 
+    </linearGradient>
+
+    <!-- N: Solid Tech Blue/Cyan -->
+    <linearGradient id="solidCyan" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#00c6ff;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#0072ff;stop-opacity:1" />
+    </linearGradient>
+
+    <filter id="hardShadow" x="-20%" y="-20%" width="140%" height="140%">
+      <feGaussianBlur in="SourceAlpha" stdDeviation="4"/>
+      <feOffset dx="4" dy="4" result="offsetblur"/>
+      <feComponentTransfer>
+        <feFuncA type="linear" slope="0.2"/>
+      </feComponentTransfer>
+      <feMerge>
+        <feMergeNode/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+  </defs>
+
+  <!-- Background -->
+  <rect x="32" y="32" width="448" height="448" rx="100" fill="url(#bgSoft)" />
+
+  <!-- Main Content Centered -->
+  <g transform="translate(106, 106) scale(0.6)" filter="url(#hardShadow)">
+    
+    <!-- Hex G -->
+    <path d="M 250 0 L 466 125 L 466 375 L 250 500 L 34 375 L 34 125 Z" 
+          fill="none" stroke="url(#solidPink)" stroke-width="45" stroke-linejoin="round"/>
+          
+    <!-- G Crossbar -->
+    <path d="M 466 300 L 330 300" stroke="url(#solidPink)" stroke-width="45" stroke-linecap="round"/>
+
+    <!-- Inner N -->
+    <path d="M 160 350 L 160 150 L 340 350 L 340 150" 
+          fill="none" stroke="url(#solidCyan)" stroke-width="50" stroke-linecap="round" stroke-linejoin="round"/>
+
+  </g>
+</svg>

frontend/src/App.css

@@ -3,6 +3,11 @@ html, body, #root {
   margin: 0;
   padding: 0;
   overflow: hidden; /* Disable global scrollbar */
+  background-color: transparent !important; /* CRITICAL: Allow Wails window transparency */
+}
+
+body, #root {
+  border-radius: 14px; /* Slightly rounded app window corners */
 }
 
 /* 侧边栏 Tree 样式优化 */
@@ -30,4 +35,60 @@ html, body, #root {
   text-overflow: ellipsis;
   white-space: nowrap;
   padding-right: 8px;
-}
+}
+
+/* Scrollbar styling for dark mode */
+body[data-theme='dark'] ::-webkit-scrollbar {
+    width: 10px;
+    height: 10px;
+}
+body[data-theme='dark'] ::-webkit-scrollbar-track {
+    background: #1f1f1f;
+}
+body[data-theme='dark'] ::-webkit-scrollbar-corner {
+    background: #1f1f1f;
+}
+body[data-theme='dark'] ::-webkit-scrollbar-thumb {
+    background: #424242;
+    border-radius: 4px;
+    border: 2px solid #1f1f1f;
+}
+body[data-theme='dark'] ::-webkit-scrollbar-thumb:hover {
+    background: #666;
+}
+
+/* Ensure body background matches theme to avoid white flashes, but kept transparent for window composition */
+body {
+    transition: color 0.3s;
+}
+
+body[data-theme='dark'] {
+    /* 移除全局 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 */
+.titlebar-close-btn:hover {
+    background-color: #ff4d4f !important;
+    color: #fff !important;
+}

frontend/src/components/DataViewer.tsx

@@ -4,16 +4,20 @@ 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 { buildOrderBySQL, buildWhereSQL, quoteQualifiedIdent, withSortBufferTuningSQL, type FilterCondition } from '../utils/sql';
 
 const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
   const [data, setData] = useState<any[]>([]);
   const [columnNames, setColumnNames] = useState<string[]>([]);
   const [pkColumns, setPkColumns] = useState<string[]>([]);
   const [loading, setLoading] = useState(false);
-  const { connections, addSqlLog } = useStore();
+  const connections = useStore(state => state.connections);
+  const addSqlLog = useStore(state => state.addSqlLog);
   const fetchSeqRef = useRef(0);
   const countSeqRef = useRef(0);
   const countKeyRef = useRef<string>('');
+  const pkSeqRef = useRef(0);
+  const pkKeyRef = useRef<string>('');
 
   const [pagination, setPagination] = useState({
       current: 1,
@@ -25,7 +29,16 @@ 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' || currentConnType === 'clickhouse';
+
+  useEffect(() => {
+    setPkColumns([]);
+    pkKeyRef.current = '';
+    countKeyRef.current = '';
+    setPagination(prev => ({ ...prev, current: 1, total: 0, totalKnown: false }));
+  }, [tab.connectionId, tab.dbName, tab.tableName]);
 
   const fetchData = useCallback(async (page = pagination.current, size = pagination.pageSize) => {
     const seq = ++fetchSeqRef.current;
@@ -46,74 +59,81 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
         ssh: conn.config.ssh || { host: "", port: 22, user: "", password: "", keyPath: "" }
     };
 
-    const quoteIdentPart = (ident: string) => {
-        if (!ident) return ident;
-        if (config.type === 'mysql') return `\`${ident.replace(/`/g, '``')}\``;
-        return `"${ident.replace(/"/g, '""')}"`;
-    };
-    const quoteQualifiedIdent = (ident: string) => {
-        const raw = (ident || '').trim();
-        if (!raw) return raw;
-        const parts = raw.split('.').filter(Boolean);
-        if (parts.length <= 1) return quoteIdentPart(raw);
-        return parts.map(quoteIdentPart).join('.');
-    };
-    const escapeLiteral = (val: string) => val.replace(/'/g, "''");
+    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 || '';
 
-    const whereParts: string[] = [];
-    filterConditions.forEach(cond => {
-        if (cond.column && cond.value) {
-            if (cond.op === 'LIKE') {
-                whereParts.push(`${quoteIdentPart(cond.column)} LIKE '%${escapeLiteral(cond.value)}%'`);
-            } else {
-                whereParts.push(`${quoteIdentPart(cond.column)} ${cond.op} '${escapeLiteral(cond.value)}'`);
-            }
-        }
-    });
-    const whereSQL = whereParts.length > 0 ? `WHERE ${whereParts.join(' AND ')}` : "";
+    const whereSQL = buildWhereSQL(dbType, filterConditions);
 
-    const countSql = `SELECT COUNT(*) as total FROM ${quoteQualifiedIdent(tableName)} ${whereSQL}`;
+    const countSql = `SELECT COUNT(*) as total FROM ${quoteQualifiedIdent(dbType, tableName)} ${whereSQL}`;
     
-    let sql = `SELECT * FROM ${quoteQualifiedIdent(tableName)} ${whereSQL}`;
-    if (sortInfo && sortInfo.order) {
-        sql += ` ORDER BY ${quoteIdentPart(sortInfo.columnKey)} ${sortInfo.order === 'ascend' ? 'ASC' : 'DESC'}`;
-    }
+    let sql = `SELECT * FROM ${quoteQualifiedIdent(dbType, tableName)} ${whereSQL}`;
+    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;
+        };
 
-        let pCols: Promise<any> | null = null;
-        if (pkColumns.length === 0) {
-             pCols = DBGetColumns(config as any, dbName, tableName);
+        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('已自动提升排序缓冲并重试成功。');
+            }
         }
-
-        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
-        });
-        
-        if (pCols) {
-            const resCols = await pCols;
-            if (resCols.success) {
-                const pks = (resCols.data as ColumnDefinition[]).filter(c => c.key === 'PRI').map(c => c.name);
-                setPkColumns(pks);
+        if (pkColumns.length === 0) {
+            const pkKey = `${tab.connectionId}|${dbName}|${tableName}`;
+            if (pkKeyRef.current !== pkKey) {
+                pkKeyRef.current = pkKey;
+                const pkSeq = ++pkSeqRef.current;
+                DBGetColumns(config as any, dbName, tableName)
+                    .then((resCols: any) => {
+                        if (pkSeqRef.current !== pkSeq) return;
+                        if (pkKeyRef.current !== pkKey) return;
+                        if (!resCols?.success) return;
+                        const pks = (resCols.data as ColumnDefinition[]).filter((c: any) => c.key === 'PRI').map((c: any) => c.name);
+                        setPkColumns(pks);
+                    })
+                    .catch(() => {
+                        if (pkSeqRef.current !== pkSeq) return;
+                        if (pkKeyRef.current !== pkKey) return;
+                    });
             }
         }
 
@@ -154,8 +174,11 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
                     countKeyRef.current = countKey;
                     const countSeq = ++countSeqRef.current;
                     const countStart = Date.now();
+                    // 大表 COUNT(*) 可能非常慢，且在部分运行时环境下会影响后续操作响应；
+                    // 这里为统计请求设置更短的超时，避免“后台统计”长期占用资源。
+                    const countConfig: any = { ...(config as any), timeout: 5 };
 
-                    DBQuery(config as any, dbName, countSql)
+                    DBQuery(countConfig, dbName, countSql)
                         .then((resCount: any) => {
                             const countDuration = Date.now() - countStart;
 
@@ -188,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;
@@ -196,38 +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(() => {
-    countKeyRef.current = '';
     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={{ height: '100%', width: '100%', overflow: 'hidden' }}>
+    <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}
@@ -243,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,929 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { Alert, Button, Collapse, Modal, Progress, Select, Space, Table, Tag, Typography, message } from 'antd';
+import { DeleteOutlined, DownloadOutlined, FileSearchOutlined, ReloadOutlined } from '@ant-design/icons';
+import { EventsOn } from '../../wailsjs/runtime/runtime';
+import {
+  CheckDriverNetworkStatus,
+  DownloadDriverPackage,
+  GetDriverVersionList,
+  GetDriverVersionPackageSize,
+  GetDriverStatusList,
+  InstallLocalDriverPackage,
+  RemoveDriverPackage,
+  SelectDriverPackageFile,
+} from '../../wailsjs/go/app/App';
+
+const { Paragraph, Text } = Typography;
+
+type DriverStatusRow = {
+  type: string;
+  name: string;
+  builtIn: boolean;
+  pinnedVersion?: string;
+  installedVersion?: string;
+  packageSizeText?: string;
+  runtimeAvailable: boolean;
+  packageInstalled: boolean;
+  connectable: boolean;
+  defaultDownloadUrl?: string;
+  installDir?: string;
+  packagePath?: string;
+  executablePath?: string;
+  downloadedAt?: 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;
+};
+
+type DriverLogEntry = {
+  time: string;
+  text: string;
+  signature: string;
+};
+
+type DriverNetworkProbe = {
+  name: string;
+  url: string;
+  reachable: boolean;
+  httpStatus?: number;
+  latencyMs?: number;
+  error?: string;
+};
+
+type DriverNetworkStatus = {
+  reachable: boolean;
+  summary: string;
+  recommendedProxy: boolean;
+  proxyConfigured: boolean;
+  proxyEnv?: Record<string, string>;
+  checks: DriverNetworkProbe[];
+  checkedAt?: string;
+  logPath?: string;
+};
+
+type DriverVersionOption = {
+  version: string;
+  downloadUrl: string;
+  packageSizeText?: string;
+  recommended?: boolean;
+  source?: string;
+  year?: string;
+  displayLabel?: string;
+};
+
+const buildVersionOptionKey = (option: DriverVersionOption) => `${option.version}@@${option.downloadUrl}`;
+const buildVersionSizeLoadingKey = (driverType: string, optionKey: string) => `${driverType}@@${optionKey}`;
+
+const buildVersionSelectOptions = (options: DriverVersionOption[]) => {
+  type SelectOption = { value: string; label: string };
+  type SelectGroup = { label: string; options: SelectOption[] };
+
+  if (options.length === 0) {
+    return [] as Array<SelectOption | SelectGroup>;
+  }
+
+  const yearGroups = new Map<string, SelectOption[]>();
+  const others: SelectOption[] = [];
+  options.forEach((option) => {
+    const selectOption: SelectOption = {
+      value: buildVersionOptionKey(option),
+      label: option.displayLabel || option.version || '默认版本',
+    };
+    const year = String(option.year || '').trim();
+    if (!year) {
+      others.push(selectOption);
+      return;
+    }
+    const group = yearGroups.get(year) || [];
+    group.push(selectOption);
+    yearGroups.set(year, group);
+  });
+
+  const sortedYears = Array.from(yearGroups.keys()).sort((a, b) => {
+    const left = Number.parseInt(a, 10);
+    const right = Number.parseInt(b, 10);
+    const leftValid = Number.isFinite(left);
+    const rightValid = Number.isFinite(right);
+    if (leftValid && rightValid) {
+      return right - left;
+    }
+    return b.localeCompare(a);
+  });
+
+  const grouped: SelectGroup[] = sortedYears.map((year) => ({
+    label: `${year} 年`,
+    options: yearGroups.get(year) || [],
+  }));
+  if (others.length > 0) {
+    grouped.push({ label: '其他', options: others });
+  }
+  return grouped;
+};
+
+const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({ open, onClose }) => {
+  const [loading, setLoading] = useState(false);
+  const [downloadDir, setDownloadDir] = useState('');
+  const [networkChecking, setNetworkChecking] = useState(false);
+  const [networkStatus, setNetworkStatus] = useState<DriverNetworkStatus | null>(null);
+  const [rows, setRows] = useState<DriverStatusRow[]>([]);
+  const [actionDriver, setActionDriver] = useState('');
+  const [progressMap, setProgressMap] = useState<Record<string, ProgressState>>({});
+  const [operationLogMap, setOperationLogMap] = useState<Record<string, DriverLogEntry[]>>({});
+  const [logDriverType, setLogDriverType] = useState('');
+  const [logModalOpen, setLogModalOpen] = useState(false);
+  const [versionMap, setVersionMap] = useState<Record<string, DriverVersionOption[]>>({});
+  const [selectedVersionMap, setSelectedVersionMap] = useState<Record<string, string>>({});
+  const [versionLoadingMap, setVersionLoadingMap] = useState<Record<string, boolean>>({});
+  const [versionSizeLoadingMap, setVersionSizeLoadingMap] = useState<Record<string, boolean>>({});
+
+  const appendOperationLog = useCallback((
+    driverType: string,
+    text: string,
+    signature?: string,
+    mode: 'append' | 'update-last' = 'append',
+  ) => {
+    const normalized = String(driverType || '').trim().toLowerCase();
+    const content = String(text || '').trim();
+    if (!normalized || !content) {
+      return;
+    }
+    const sign = String(signature || content).trim() || content;
+    const now = new Date().toLocaleTimeString();
+    setOperationLogMap((prev) => {
+      const history = prev[normalized] || [];
+      if (history.length > 0) {
+        const last = history[history.length - 1];
+        if (last.signature === sign) {
+          if (mode === 'update-last') {
+            if (last.text === content) {
+              return prev;
+            }
+            const nextHistory = [...history];
+            nextHistory[nextHistory.length - 1] = {
+              ...last,
+              text: content,
+              time: now,
+            };
+            return { ...prev, [normalized]: nextHistory };
+          }
+          return prev;
+        }
+      }
+      const nextHistory = [
+        ...history,
+        {
+          time: now,
+          text: content,
+          signature: sign,
+        },
+      ];
+      const sliced = nextHistory.length > 200 ? nextHistory.slice(nextHistory.length - 200) : nextHistory;
+      return { ...prev, [normalized]: sliced };
+    });
+  }, []);
+
+  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,
+        pinnedVersion: String(item.pinnedVersion || '').trim() || undefined,
+        installedVersion: String(item.installedVersion || '').trim() || undefined,
+        packageSizeText: String(item.packageSizeText || '').trim() || undefined,
+        runtimeAvailable: !!item.runtimeAvailable,
+        packageInstalled: !!item.packageInstalled,
+        connectable: !!item.connectable,
+        defaultDownloadUrl: String(item.defaultDownloadUrl || '').trim() || undefined,
+        installDir: String(item.installDir || '').trim() || undefined,
+        packagePath: String(item.packagePath || '').trim() || undefined,
+        executablePath: String(item.executablePath || '').trim() || undefined,
+        downloadedAt: String(item.downloadedAt || '').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]);
+
+  const checkNetworkStatus = useCallback(async (toastOnError = false) => {
+    setNetworkChecking(true);
+    try {
+      const res = await CheckDriverNetworkStatus();
+      if (!res?.success) {
+        if (toastOnError) {
+          message.error(res?.message || '驱动网络检测失败');
+        }
+        return;
+      }
+      const data = (res?.data || {}) as any;
+      const checks = Array.isArray(data.checks) ? data.checks : [];
+      const normalizedChecks: DriverNetworkProbe[] = checks.map((item: any) => ({
+        name: String(item.name || '').trim(),
+        url: String(item.url || '').trim(),
+        reachable: !!item.reachable,
+        httpStatus: Number(item.httpStatus || 0) || undefined,
+        latencyMs: Number(item.latencyMs || 0) || undefined,
+        error: String(item.error || '').trim() || undefined,
+      }));
+      setNetworkStatus({
+        reachable: !!data.reachable,
+        summary: String(data.summary || '').trim() || '驱动网络检测已完成',
+        recommendedProxy: !!data.recommendedProxy,
+        proxyConfigured: !!data.proxyConfigured,
+        proxyEnv: (data.proxyEnv || {}) as Record<string, string>,
+        checkedAt: String(data.checkedAt || '').trim() || undefined,
+        checks: normalizedChecks,
+        logPath: String(data.logPath || '').trim() || undefined,
+      });
+    } catch (err: any) {
+      if (toastOnError) {
+        message.error(`驱动网络检测失败：${err?.message || String(err)}`);
+      }
+    } finally {
+      setNetworkChecking(false);
+    }
+  }, []);
+
+  const loadVersionOptions = useCallback(async (row: DriverStatusRow, toastOnError = false) => {
+    if (row.builtIn) {
+      return [] as DriverVersionOption[];
+    }
+    const driverType = String(row.type || '').trim();
+    if (!driverType) {
+      return [] as DriverVersionOption[];
+    }
+    setVersionLoadingMap((prev) => ({ ...prev, [driverType]: true }));
+    try {
+      const res = await GetDriverVersionList(driverType, '');
+      if (!res?.success) {
+        if (toastOnError) {
+          message.error(res?.message || `${row.name} 版本列表加载失败`);
+        }
+        return [] as DriverVersionOption[];
+      }
+      const data = (res?.data || {}) as any;
+      const rawVersions = Array.isArray(data.versions) ? data.versions : [];
+      const options: DriverVersionOption[] = rawVersions
+        .map((item: any) => {
+          const version = String(item.version || '').trim();
+          const downloadUrl = String(item.downloadUrl || '').trim();
+          if (!version && !downloadUrl) {
+            return null;
+          }
+          return {
+            version,
+            downloadUrl,
+            packageSizeText: String(item.packageSizeText || '').trim() || undefined,
+            recommended: !!item.recommended,
+            source: String(item.source || '').trim() || undefined,
+            year: String(item.year || '').trim() || undefined,
+            displayLabel: String(item.displayLabel || '').trim() || undefined,
+          } as DriverVersionOption;
+        })
+        .filter((item: DriverVersionOption | null): item is DriverVersionOption => !!item);
+
+      if (options.length === 0) {
+        const fallbackVersion = String(row.pinnedVersion || '').trim();
+        const fallbackURL = String(row.defaultDownloadUrl || '').trim();
+        if (fallbackVersion || fallbackURL) {
+          options.push({
+            version: fallbackVersion,
+            downloadUrl: fallbackURL,
+            recommended: true,
+            source: 'fallback',
+            displayLabel: fallbackVersion || '默认版本',
+          });
+        }
+      }
+
+      setVersionMap((prev) => ({ ...prev, [driverType]: options }));
+      setSelectedVersionMap((prev) => {
+        const currentKey = prev[driverType];
+        if (currentKey && options.some((option) => buildVersionOptionKey(option) === currentKey)) {
+          return prev;
+        }
+        const preferred =
+          options.find((option) => option.version === row.installedVersion) ||
+          options.find((option) => option.version === row.pinnedVersion) ||
+          options.find((option) => option.recommended) ||
+          options[0];
+        if (!preferred) {
+          return prev;
+        }
+        return { ...prev, [driverType]: buildVersionOptionKey(preferred) };
+      });
+      return options;
+    } catch (err: any) {
+      if (toastOnError) {
+        message.error(`加载 ${row.name} 版本列表失败：${err?.message || String(err)}`);
+      }
+      return [] as DriverVersionOption[];
+    } finally {
+      setVersionLoadingMap((prev) => ({ ...prev, [driverType]: false }));
+    }
+  }, []);
+
+  const loadVersionPackageSize = useCallback(async (row: DriverStatusRow, optionKey: string) => {
+    if (row.builtIn) {
+      return;
+    }
+    const driverType = String(row.type || '').trim();
+    if (!driverType || !optionKey) {
+      return;
+    }
+
+    const options = versionMap[driverType] || [];
+    const selectedOption = options.find((item) => buildVersionOptionKey(item) === optionKey);
+    if (!selectedOption) {
+      return;
+    }
+    if (String(selectedOption.packageSizeText || '').trim()) {
+      return;
+    }
+
+    const versionText = String(selectedOption.version || '').trim();
+    if (!versionText) {
+      return;
+    }
+
+    const loadingKey = buildVersionSizeLoadingKey(driverType, optionKey);
+    if (versionSizeLoadingMap[loadingKey]) {
+      return;
+    }
+
+    setVersionSizeLoadingMap((prev) => ({ ...prev, [loadingKey]: true }));
+    try {
+      const res = await GetDriverVersionPackageSize(driverType, versionText);
+      if (!res?.success) {
+        return;
+      }
+      const data = (res?.data || {}) as any;
+      const sizeText = String(data.packageSizeText || '').trim();
+      if (!sizeText) {
+        return;
+      }
+
+      setVersionMap((prev) => {
+        const current = prev[driverType] || [];
+        let changed = false;
+        const next = current.map((item) => {
+          if (buildVersionOptionKey(item) !== optionKey) {
+            return item;
+          }
+          if (String(item.packageSizeText || '').trim() === sizeText) {
+            return item;
+          }
+          changed = true;
+          return { ...item, packageSizeText: sizeText };
+        });
+        if (!changed) {
+          return prev;
+        }
+        return { ...prev, [driverType]: next };
+      });
+    } finally {
+      setVersionSizeLoadingMap((prev) => {
+        if (!prev[loadingKey]) {
+          return prev;
+        }
+        const next = { ...prev };
+        delete next[loadingKey];
+        return next;
+      });
+    }
+  }, [versionMap, versionSizeLoadingMap]);
+
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    refreshStatus(false);
+    checkNetworkStatus(false);
+  }, [checkNetworkStatus, 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,
+        },
+      }));
+      const progressText = `${Math.round(percent)}%`;
+      const statusText = String(status || '').toUpperCase();
+      const lineText = `[${statusText}] ${messageText || '-'} (${progressText})`;
+      const lineSignature = `${statusText}|${messageText || '-'}`;
+      appendOperationLog(driverType, lineText, lineSignature, 'update-last');
+    });
+    return () => {
+      off();
+    };
+  }, [appendOperationLog, open]);
+
+  const installDriver = useCallback(async (row: DriverStatusRow) => {
+    setActionDriver(row.type);
+    setProgressMap((prev) => ({
+      ...prev,
+      [row.type]: {
+        status: 'start',
+        message: '开始安装',
+        percent: 0,
+      },
+    }));
+    appendOperationLog(row.type, '[START] 开始自动安装');
+    try {
+      let options = versionMap[row.type] || [];
+      if (options.length === 0) {
+        options = await loadVersionOptions(row, true);
+      }
+      const selectedKey = selectedVersionMap[row.type];
+      const selectedOption =
+        options.find((item) => buildVersionOptionKey(item) === selectedKey) ||
+        options.find((item) => item.recommended) ||
+        options[0];
+      const selectedVersion = selectedOption?.version || row.pinnedVersion || '';
+      const selectedDownloadURL = selectedOption?.downloadUrl || row.defaultDownloadUrl || '';
+
+      const result = await DownloadDriverPackage(row.type, selectedVersion, selectedDownloadURL, downloadDir);
+      if (!result?.success) {
+        const errText = result?.message || `安装 ${row.name} 失败`;
+        appendOperationLog(row.type, `[ERROR] ${errText}`);
+        message.error(errText);
+        return;
+      }
+      const versionTip = selectedVersion ? `（${selectedVersion}）` : '';
+      appendOperationLog(row.type, `[DONE] 自动安装完成 ${versionTip}`);
+      message.success(`${row.name}${versionTip} 已安装启用`);
+      refreshStatus(false);
+    } finally {
+      setActionDriver('');
+    }
+  }, [appendOperationLog, downloadDir, loadVersionOptions, refreshStatus, selectedVersionMap, versionMap]);
+
+  const installDriverFromLocalFile = useCallback(async (row: DriverStatusRow) => {
+    const fileRes = await SelectDriverPackageFile(downloadDir);
+    if (!fileRes?.success) {
+      if (String(fileRes?.message || '') !== 'Cancelled') {
+        message.error(fileRes?.message || '选择本地驱动包失败');
+      }
+      return;
+    }
+    const filePath = String((fileRes?.data as any)?.path || '').trim();
+    if (!filePath) {
+      message.error('未选择有效的驱动包文件');
+      return;
+    }
+
+    setActionDriver(row.type);
+    setProgressMap((prev) => ({
+      ...prev,
+      [row.type]: {
+        status: 'start',
+        message: '开始导入本地驱动包',
+        percent: 0,
+      },
+    }));
+    appendOperationLog(row.type, `[START] 开始本地导入：${filePath}`);
+    try {
+      const result = await InstallLocalDriverPackage(row.type, filePath, downloadDir);
+      if (!result?.success) {
+        const errText = result?.message || `导入 ${row.name} 本地驱动包失败`;
+        appendOperationLog(row.type, `[ERROR] ${errText}`);
+        message.error(errText);
+        return;
+      }
+      appendOperationLog(row.type, '[DONE] 本地导入安装完成');
+      message.success(`${row.name} 本地驱动包已安装启用`);
+      refreshStatus(false);
+    } finally {
+      setActionDriver('');
+    }
+  }, [appendOperationLog, downloadDir, refreshStatus]);
+
+  const openDriverLog = useCallback((driverType: string) => {
+    const normalized = String(driverType || '').trim().toLowerCase();
+    if (!normalized) {
+      return;
+    }
+    setLogDriverType(normalized);
+    setLogModalOpen(true);
+  }, []);
+
+  const removeDriver = useCallback(async (row: DriverStatusRow) => {
+    setActionDriver(row.type);
+    appendOperationLog(row.type, '[START] 开始移除驱动');
+    try {
+      const result = await RemoveDriverPackage(row.type, downloadDir);
+      if (!result?.success) {
+        const errText = result?.message || `移除 ${row.name} 失败`;
+        appendOperationLog(row.type, `[ERROR] ${errText}`);
+        message.error(errText);
+        return;
+      }
+      appendOperationLog(row.type, '[DONE] 驱动移除完成');
+      message.success(`${row.name} 已移除`);
+      setProgressMap((prev) => {
+        const next = { ...prev };
+        delete next[row.type];
+        return next;
+      });
+      refreshStatus(false);
+    } finally {
+      setActionDriver('');
+    }
+  }, [appendOperationLog, downloadDir, refreshStatus]);
+
+  const columns = useMemo(() => {
+    return [
+      {
+        title: '数据源',
+        dataIndex: 'name',
+        key: 'name',
+        width: 150,
+      },
+      {
+        title: '安装位置',
+        key: 'installPath',
+        width: 260,
+        render: (_: string, row: DriverStatusRow) => {
+          if (row.builtIn) {
+            return <Text type="secondary">内置</Text>;
+          }
+          const installPath = row.executablePath || row.installDir || '-';
+          if (installPath === '-') {
+            return <Text type="secondary">-</Text>;
+          }
+          return (
+            <Text copyable={{ text: installPath }} style={{ fontSize: 12 }}>
+              {installPath}
+            </Text>
+          );
+        },
+      },
+      {
+        title: '安装包大小',
+        dataIndex: 'packageSizeText',
+        key: 'packageSizeText',
+        width: 120,
+        render: (_: string | undefined, row: DriverStatusRow) => {
+          if (row.builtIn) {
+            return row.packageSizeText || '-';
+          }
+          const options = versionMap[row.type] || [];
+          const selectedKey = selectedVersionMap[row.type];
+          const loadingKey = buildVersionSizeLoadingKey(row.type, selectedKey || '');
+          const selectedOption =
+            options.find((item) => buildVersionOptionKey(item) === selectedKey) ||
+            options.find((item) => item.recommended) ||
+            options[0];
+          const anyKnownSize = options.find((item) => String(item.packageSizeText || '').trim())?.packageSizeText;
+          if (selectedKey && versionSizeLoadingMap[loadingKey]) {
+            return '计算中...';
+          }
+          return selectedOption?.packageSizeText || anyKnownSize || 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: 'driverVersion',
+        width: 230,
+        render: (_: string, row: DriverStatusRow) => {
+          if (row.builtIn) {
+            return <Text type="secondary">-</Text>;
+          }
+          const options = versionMap[row.type] || [];
+          const selectedKey = selectedVersionMap[row.type];
+          const selectOptions = buildVersionSelectOptions(options);
+          return (
+            <Select
+              size="small"
+              style={{ width: '100%' }}
+              loading={!!versionLoadingMap[row.type]}
+              disabled={actionDriver === row.type}
+              placeholder={options.length > 0 ? '选择驱动版本' : '点击展开加载版本'}
+              value={selectedKey}
+              options={selectOptions as any}
+              onOpenChange={(open) => {
+                if (open && options.length === 0 && !versionLoadingMap[row.type]) {
+                  void loadVersionOptions(row, true);
+                  return;
+                }
+                if (open && selectedKey) {
+                  void loadVersionPackageSize(row, selectedKey);
+                }
+              }}
+              onChange={(value) => {
+                setSelectedVersionMap((prev) => ({ ...prev, [row.type]: value }));
+                void loadVersionPackageSize(row, value);
+              }}
+            />
+          );
+        },
+      },
+      {
+        title: '操作',
+        key: 'actions',
+        width: 320,
+        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>;
+          }
+
+          const logs = operationLogMap[row.type] || [];
+          const hasLogs = logs.length > 0;
+
+          const mainAction = row.connectable ? (
+            <Button
+              danger
+              icon={<DeleteOutlined />}
+              loading={loadingAction}
+              onClick={() => removeDriver(row)}
+            >
+              移除
+            </Button>
+          ) : (
+            <Button
+              type="primary"
+              icon={<DownloadOutlined />}
+              loading={loadingAction}
+              onClick={() => installDriver(row)}
+            >
+              安装启用
+            </Button>
+          );
+
+          return (
+            <Space size={8} wrap>
+              {mainAction}
+              <Button
+                icon={<FileSearchOutlined />}
+                loading={loadingAction}
+                onClick={() => installDriverFromLocalFile(row)}
+              >
+                本地导入
+              </Button>
+              <Button
+                type={hasLogs ? 'default' : 'text'}
+                disabled={!hasLogs}
+                onClick={() => openDriverLog(row.type)}
+              >
+                日志
+              </Button>
+            </Space>
+          );
+        },
+      },
+    ];
+  }, [actionDriver, installDriver, installDriverFromLocalFile, loadVersionOptions, loadVersionPackageSize, openDriverLog, operationLogMap, progressMap, removeDriver, selectedVersionMap, versionLoadingMap, versionMap, versionSizeLoadingMap]);
+
+  const activeLogRow = useMemo(() => {
+    if (!logDriverType) {
+      return undefined;
+    }
+    return rows.find((item) => item.type === logDriverType);
+  }, [logDriverType, rows]);
+
+  const activeDriverLogs = operationLogMap[logDriverType] || [];
+  const activeDriverLogLines = activeDriverLogs.map((item) => `[${item.time}] ${item.text}`);
+  const proxyEnvEntries = Object.entries(networkStatus?.proxyEnv || {});
+
+  return (
+    <Modal
+      title="驱动管理"
+      open={open}
+      onCancel={onClose}
+      width={980}
+      style={{ top: 24 }}
+      styles={{
+        body: {
+          maxHeight: 'calc(100vh - 220px)',
+          overflowY: 'auto',
+          overflowX: 'hidden',
+          paddingRight: 18,
+        },
+      }}
+      destroyOnClose
+      footer={[
+        <Button key="refresh" icon={<ReloadOutlined />} onClick={() => refreshStatus(true)} loading={loading}>
+          刷新
+        </Button>,
+        <Button key="network" onClick={() => checkNetworkStatus(true)} loading={networkChecking}>
+          网络检测
+        </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>
+        {networkStatus ? (
+          <Alert
+            type={networkStatus.reachable ? 'success' : 'warning'}
+            showIcon
+            message={networkStatus.summary}
+            description={(
+              <Space direction="vertical" size={6} style={{ width: '100%' }}>
+                <Text type="secondary">
+                  驱动下载依赖 GitHub 与 Go 模块代理网络。若检测失败，建议先启用 HTTP/HTTPS/SOCKS5 代理后重试。
+                </Text>
+                <Collapse
+                  size="small"
+                  items={[
+                    {
+                      key: 'checks',
+                      label: '查看网络检测明细',
+                      children: (
+                        <Space direction="vertical" size={4} style={{ width: '100%' }}>
+                          {networkStatus.checks.map((item) => (
+                            <Text key={`${item.name}-${item.url}`} type={item.reachable ? 'secondary' : 'danger'}>
+                              {item.name}：{item.reachable ? '可达' : '不可达'}{item.httpStatus ? `，HTTP ${item.httpStatus}` : ''}{item.latencyMs ? `，${item.latencyMs}ms` : ''}{item.error ? `，${item.error}` : ''}
+                            </Text>
+                          ))}
+                          {proxyEnvEntries.length > 0 ? (
+                            <Text type="secondary">
+                              检测到代理环境变量：{proxyEnvEntries.map(([key]) => key).join('、')}
+                            </Text>
+                          ) : (
+                            <Text type="secondary">未检测到系统代理环境变量。</Text>
+                          )}
+                        </Space>
+                      ),
+                    },
+                  ]}
+                />
+              </Space>
+            )}
+          />
+        ) : (
+          <Alert type="info" showIcon message={networkChecking ? '正在检测驱动下载网络...' : '尚未完成网络检测'} />
+        )}
+
+        <Alert
+          type="info"
+          showIcon
+          message="驱动目录与复用说明"
+          description={(
+            <Space direction="vertical" size={6} style={{ width: '100%' }}>
+              <Text type="secondary">自动下载和手动导入的驱动都会落盘到以下目录；后续版本升级可重复复用已下载驱动。</Text>
+              <Text type="secondary">手动导入支持单个驱动代理文件（如 `mariadb-driver-agent` / `mariadb-driver-agent.exe`）或驱动总包 `GoNavi-DriverAgents.zip`。</Text>
+              <Paragraph copyable={{ text: downloadDir || '-' }} style={{ marginBottom: 0 }}>
+                驱动根目录：{downloadDir || '-'}
+              </Paragraph>
+              {networkStatus?.logPath ? (
+                <Paragraph copyable={{ text: networkStatus.logPath }} style={{ marginBottom: 0 }}>
+                  运行日志文件：{networkStatus.logPath}
+                </Paragraph>
+              ) : null}
+            </Space>
+          )}
+        />
+
+        <Table
+          rowKey="type"
+          loading={loading}
+          columns={columns as any}
+          dataSource={rows}
+          pagination={false}
+          size="middle"
+          scroll={{ x: 1450 }}
+        />
+      </Space>
+      <Modal
+        title={`驱动日志 - ${activeLogRow?.name || logDriverType}`}
+        open={logModalOpen}
+        onCancel={() => setLogModalOpen(false)}
+        footer={[
+          <Button key="close-log" type="primary" onClick={() => setLogModalOpen(false)}>
+            关闭
+          </Button>,
+        ]}
+        width={780}
+      >
+        <Space direction="vertical" size={8} style={{ width: '100%' }}>
+          {activeLogRow?.installDir ? (
+            <Paragraph copyable={{ text: activeLogRow.installDir }} style={{ marginBottom: 0 }}>
+              安装目录：{activeLogRow.installDir}
+            </Paragraph>
+          ) : null}
+          {activeLogRow?.executablePath ? (
+            <Paragraph copyable={{ text: activeLogRow.executablePath }} style={{ marginBottom: 0 }}>
+              驱动可执行文件：{activeLogRow.executablePath}
+            </Paragraph>
+          ) : null}
+          {activeDriverLogLines.length > 0 ? (
+            <pre style={{ margin: 0, maxHeight: 360, overflow: 'auto', padding: 12, background: '#fafafa', borderRadius: 8, border: '1px solid #f0f0f0', whiteSpace: 'pre-wrap', wordBreak: 'break-word' }}>
+              {activeDriverLogLines.join('\n')}
+            </pre>
+          ) : (
+            <Text type="secondary">当前驱动暂无操作日志。</Text>
+          )}
+        </Space>
+      </Modal>
+    </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;
@@ -10,7 +11,26 @@ interface LogPanelProps {
 }
 
 const LogPanel: React.FC<LogPanelProps> = ({ height, onClose, onResizeStart }) => {
-    const { sqlLogs, clearSqlLogs, darkMode } = useStore();
+    const sqlLogs = useStore(state => state.sqlLogs);
+    const clearSqlLogs = useStore(state => state.clearSqlLogs);
+    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, ${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}, ${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 = [
         {
@@ -51,8 +71,8 @@ const LogPanel: React.FC<LogPanelProps> = ({ height, onClose, onResizeStart }) =
     return (
         <div style={{ 
             height, 
-            borderTop: darkMode ? '1px solid #303030' : '1px solid #d9d9d9', 
-            background: darkMode ? '#1f1f1f' : '#fff',
+            borderTop: 'none', 
+            background: bgMain,
             display: 'flex',
             flexDirection: 'column',
             position: 'relative',
@@ -75,11 +95,10 @@ const LogPanel: React.FC<LogPanelProps> = ({ height, onClose, onResizeStart }) =
             {/* Toolbar */}
             <div style={{ 
                 padding: '4px 8px', 
-                borderBottom: darkMode ? '1px solid #303030' : '1px solid #f0f0f0',
+                borderBottom: 'none',
                 display: 'flex',
                 justifyContent: 'space-between',
                 alignItems: 'center',
-                background: darkMode ? '#2a2a2a' : '#fafafa',
                 height: 32
             }}>
                 <div style={{ display: 'flex', alignItems: 'center', gap: 8, fontWeight: 'bold', fontSize: '12px' }}>
@@ -96,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" 
@@ -107,8 +127,37 @@ 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>
     );
 };
 
-export default LogPanel;
+export default LogPanel;

frontend/src/components/RedisCommandEditor.tsx

@@ -0,0 +1,205 @@
+import React, { useState, useCallback, useRef } from 'react';
+import { Button, Space, message } from 'antd';
+import { PlayCircleOutlined, ClearOutlined } from '@ant-design/icons';
+import { useStore } from '../store';
+import Editor, { OnMount } from '@monaco-editor/react';
+
+interface RedisCommandEditorProps {
+    connectionId: string;
+    redisDB: number;
+}
+
+interface CommandResult {
+    command: string;
+    result: any;
+    error?: string;
+    timestamp: number;
+}
+
+const RedisCommandEditor: React.FC<RedisCommandEditorProps> = ({ connectionId, redisDB }) => {
+    const { connections } = useStore();
+    const connection = connections.find(c => c.id === connectionId);
+
+    const [command, setCommand] = useState('');
+    const [results, setResults] = useState<CommandResult[]>([]);
+    const [loading, setLoading] = useState(false);
+    const editorRef = useRef<any>(null);
+
+    const getConfig = useCallback(() => {
+        if (!connection) return null;
+        return {
+            ...connection.config,
+            port: Number(connection.config.port),
+            password: connection.config.password || "",
+            useSSH: connection.config.useSSH || false,
+            ssh: connection.config.ssh || { host: "", port: 22, user: "", password: "", keyPath: "" },
+            redisDB: redisDB
+        };
+    }, [connection, redisDB]);
+
+    const handleEditorMount: OnMount = (editor) => {
+        editorRef.current = editor;
+        // Add keyboard shortcut for execute
+        editor.addCommand(
+            // Ctrl/Cmd + Enter
+            2048 | 3, // KeyMod.CtrlCmd | KeyCode.Enter
+            () => handleExecute()
+        );
+    };
+
+    const handleExecute = async () => {
+        const config = getConfig();
+        if (!config) return;
+
+        const cmdToExecute = command.trim();
+        if (!cmdToExecute) {
+            message.warning('请输入命令');
+            return;
+        }
+
+        // Support multiple commands separated by newlines
+        const commands = cmdToExecute.split('\n').filter(c => c.trim() && !c.trim().startsWith('//') && !c.trim().startsWith('#'));
+
+        setLoading(true);
+        const newResults: CommandResult[] = [];
+
+        for (const cmd of commands) {
+            const trimmedCmd = cmd.trim();
+            if (!trimmedCmd) continue;
+
+            try {
+                const res = await (window as any).go.app.App.RedisExecuteCommand(config, trimmedCmd);
+                newResults.push({
+                    command: trimmedCmd,
+                    result: res.success ? res.data : null,
+                    error: res.success ? undefined : res.message,
+                    timestamp: Date.now()
+                });
+            } catch (e: any) {
+                newResults.push({
+                    command: trimmedCmd,
+                    result: null,
+                    error: e?.message || String(e),
+                    timestamp: Date.now()
+                });
+            }
+        }
+
+        setResults(prev => [...newResults, ...prev]);
+        setLoading(false);
+    };
+
+    const handleClear = () => {
+        setResults([]);
+    };
+
+    const formatResult = (result: any): string => {
+        if (result === null || result === undefined) {
+            return '(nil)';
+        }
+        if (typeof result === 'string') {
+            return `"${result}"`;
+        }
+        if (typeof result === 'number') {
+            return `(integer) ${result}`;
+        }
+        if (Array.isArray(result)) {
+            if (result.length === 0) {
+                return '(empty array)';
+            }
+            return result.map((item, index) => `${index + 1}) ${formatResult(item)}`).join('\n');
+        }
+        if (typeof result === 'object') {
+            return JSON.stringify(result, null, 2);
+        }
+        return String(result);
+    };
+
+    if (!connection) {
+        return <div style={{ padding: 20 }}>连接不存在</div>;
+    }
+
+    return (
+        <div style={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
+            {/* Command Input */}
+            <div style={{ borderBottom: '1px solid #f0f0f0' }}>
+                <div style={{ padding: '8px 12px', borderBottom: '1px solid #f0f0f0', display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+                    <Space>
+                        <span style={{ fontWeight: 500 }}>Redis 命令</span>
+                        <span style={{ color: '#999', fontSize: 12 }}>db{redisDB}</span>
+                    </Space>
+                    <Space>
+                        <Button
+                            type="primary"
+                            icon={<PlayCircleOutlined />}
+                            onClick={handleExecute}
+                            loading={loading}
+                        >
+                            执行 (Ctrl+Enter)
+                        </Button>
+                        <Button icon={<ClearOutlined />} onClick={handleClear}>清空结果</Button>
+                    </Space>
+                </div>
+                <Editor
+                    height="150px"
+                    defaultLanguage="plaintext"
+                    value={command}
+                    onChange={(value) => setCommand(value || '')}
+                    onMount={handleEditorMount}
+                    options={{
+                        minimap: { enabled: false },
+                        lineNumbers: 'on',
+                        fontSize: 14,
+                        wordWrap: 'on',
+                        scrollBeyondLastLine: false,
+                        automaticLayout: true,
+                        tabSize: 2
+                    }}
+                />
+            </div>
+
+            {/* Results */}
+            <div style={{ flex: 1, overflow: 'auto', background: '#1e1e1e', color: '#d4d4d4', fontFamily: 'monospace' }}>
+                {results.length === 0 ? (
+                    <div style={{ padding: 20, color: '#666', textAlign: 'center' }}>
+                        输入 Redis 命令并按 Ctrl+Enter 执行
+                        <br />
+                        <span style={{ fontSize: 12 }}>支持多行命令，每行一个命令</span>
+                    </div>
+                ) : (
+                    results.map((item, index) => (
+                        <div key={item.timestamp + index} style={{ padding: '8px 12px', borderBottom: '1px solid #333' }}>
+                            <div style={{ color: '#569cd6', marginBottom: 4 }}>
+                                &gt; {item.command}
+                            </div>
+                            {item.error ? (
+                                <div style={{ color: '#f14c4c', whiteSpace: 'pre-wrap' }}>
+                                    (error) {item.error}
+                                </div>
+                            ) : (
+                                <div style={{ color: '#ce9178', whiteSpace: 'pre-wrap' }}>
+                                    {formatResult(item.result)}
+                                </div>
+                            )}
+                        </div>
+                    ))
+                )}
+            </div>
+
+            {/* Common Commands Help */}
+            <div style={{ padding: '8px 12px', borderTop: '1px solid #f0f0f0', background: '#fafafa', fontSize: 12, color: '#666' }}>
+                常用命令:
+                <span style={{ marginLeft: 8 }}>
+                    <code>KEYS *</code> |
+                    <code style={{ marginLeft: 8 }}>GET key</code> |
+                    <code style={{ marginLeft: 8 }}>SET key value</code> |
+                    <code style={{ marginLeft: 8 }}>HGETALL key</code> |
+                    <code style={{ marginLeft: 8 }}>INFO</code> |
+                    <code style={{ marginLeft: 8 }}>DBSIZE</code>
+                </span>
+            </div>
+        </div>
+    );
+};
+
+export default RedisCommandEditor;

frontend/src/components/TabManager.tsx

@@ -1,12 +1,44 @@
 import React, { useMemo } from 'react';
-import { Tabs, Button } from 'antd';
+import { Tabs, Dropdown } from 'antd';
+import type { MenuProps } from 'antd';
 import { useStore } from '../store';
 import DataViewer from './DataViewer';
 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, activeTabId, setActiveTab, closeTab } = useStore();
+  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);
+  const closeOtherTabs = useStore(state => state.closeOtherTabs);
+  const closeTabsToLeft = useStore(state => state.closeTabsToLeft);
+  const closeTabsToRight = useStore(state => state.closeTabsToRight);
+  const closeAllTabs = useStore(state => state.closeAllTabs);
 
   const onChange = (newActiveKey: string) => {
     setActiveTab(newActiveKey);
@@ -18,7 +50,9 @@ const TabManager: React.FC = () => {
     }
   };
 
-  const items = useMemo(() => tabs.map(tab => {
+  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} />;
@@ -26,28 +60,112 @@ const TabManager: React.FC = () => {
       content = <DataViewer tab={tab} />;
     } else if (tab.type === 'design') {
       content = <TableDesigner tab={tab} />;
+    } else if (tab.type === 'redis-keys') {
+      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'] = [
+      {
+        key: 'close-other',
+        label: '关闭其他页',
+        disabled: tabs.length <= 1,
+        onClick: () => closeOtherTabs(tab.id),
+      },
+      {
+        key: 'close-left',
+        label: '关闭左侧',
+        disabled: index === 0,
+        onClick: () => closeTabsToLeft(tab.id),
+      },
+      {
+        key: 'close-right',
+        label: '关闭右侧',
+        disabled: index === tabs.length - 1,
+        onClick: () => closeTabsToRight(tab.id),
+      },
+      { type: 'divider' },
+      {
+        key: 'close-all',
+        label: '关闭所有',
+        disabled: tabs.length === 0,
+        onClick: () => closeAllTabs(),
+      },
+    ];
     
     return {
-      label: tab.title,
+      label: (
+        <Dropdown menu={{ items: menuItems }} trigger={['contextMenu']}>
+          <span onContextMenu={(e) => e.preventDefault()}>{displayTitle}</span>
+        </Dropdown>
+      ),
       key: tab.id,
       children: content,
     };
-  }), [tabs]);
+  }), [tabs, connections, closeOtherTabs, closeTabsToLeft, closeTabsToRight, closeAllTabs]);
 
   return (
     <>
         <style>{`
-            .ant-tabs-content { height: 100%; }
-            .ant-tabs-tabpane { height: 100%; }
+            .main-tabs {
+              height: 100%;
+              flex: 1 1 auto;
+              min-height: 0;
+              min-width: 0;
+              display: flex;
+              flex-direction: column;
+              overflow: hidden;
+            }
+            .main-tabs .ant-tabs-nav {
+              flex: 0 0 auto;
+            }
+            .main-tabs .ant-tabs-content-holder {
+              flex: 1 1 auto;
+              min-height: 0;
+              min-width: 0;
+              overflow: hidden;
+              display: flex;
+              flex-direction: column;
+            }
+            .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;
+            }
+            .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;
+            }
+            .main-tabs .ant-tabs-nav::before {
+                border-bottom: none !important;
+            }
         `}</style>
         <Tabs
+            className="main-tabs"
             type="editable-card"
             onChange={onChange}
             activeKey={activeTabId || undefined}
             onEdit={onEdit}
             items={items}
-            style={{ height: '100%' }}
             hideAdd
         />
     </>

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/global.d.ts

@@ -2,6 +2,13 @@ export {};
 
 declare global {
   interface Window {
+    go: any;
+    runtime: {
+        WindowMinimise: () => void;
+        WindowToggleMaximise: () => void;
+        Quit: () => void;
+        BrowserOpenURL: (url: string) => void;
+    };
     ipcRenderer: {
       send: (channel: string, ...args: any[]) => void;
       on: (channel: string, listener: (event: any, ...args: any[]) => void) => void;

frontend/src/main.tsx

@@ -3,6 +3,22 @@ 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'
+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,287 @@
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { SavedConnection, TabData, SavedQuery } from './types';
+import { ConnectionConfig, ProxyConfig, SavedConnection, TabData, SavedQuery } from './types';
+
+const DEFAULT_APPEARANCE = { opacity: 1.0, blur: 0 };
+const DEFAULT_STARTUP_FULLSCREEN = false;
+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 PERSIST_VERSION = 4;
+const DEFAULT_CONNECTION_TYPE = 'mysql';
+const DEFAULT_GLOBAL_PROXY: GlobalProxyConfig = {
+  enabled: false,
+  type: 'socks5',
+  host: '',
+  port: 1080,
+  user: '',
+  password: '',
+};
+const SUPPORTED_CONNECTION_TYPES = new Set([
+  'mysql',
+  'mariadb',
+  'diros',
+  'sphinx',
+  'clickhouse',
+  '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 'clickhouse':
+      return 9000;
+    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 proxyRaw = (raw.proxy && typeof raw.proxy === 'object') ? raw.proxy as Record<string, unknown> : {};
+  const proxyTypeRaw = toTrimmedString(proxyRaw.type, 'socks5').toLowerCase();
+  const proxyType: 'socks5' | 'http' = proxyTypeRaw === 'http' ? 'http' : 'socks5';
+  const proxy = {
+    type: proxyType,
+    host: toTrimmedString(proxyRaw.host),
+    port: normalizePort(proxyRaw.port, proxyTypeRaw === 'http' ? 8080 : 1080),
+    user: toTrimmedString(proxyRaw.user),
+    password: toTrimmedString(proxyRaw.password),
+  };
+
+  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,
+    useProxy: !!raw.useProxy,
+    proxy,
+    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 resolveConnectionConfigPayload = (raw: Record<string, unknown>): unknown => {
+  if (raw.config && typeof raw.config === 'object') {
+    return raw.config;
+  }
+  // 兼容历史/导入场景：连接对象可能是扁平结构（无 config 包装）。
+  const hasLegacyFlatConfig =
+    raw.type !== undefined ||
+    raw.host !== undefined ||
+    raw.port !== undefined ||
+    raw.user !== undefined ||
+    raw.database !== undefined;
+  if (hasLegacyFlatConfig) {
+    return raw;
+  }
+  return undefined;
+};
+
+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(resolveConnectionConfigPayload(raw));
+  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,35 +294,172 @@ export interface SqlLog {
   affectedRows?: number;
 }
 
+export interface QueryOptions {
+  maxRows: number;
+  showColumnComment: boolean;
+  showColumnType: boolean;
+}
+
+export interface GlobalProxyConfig extends ProxyConfig {
+  enabled: boolean;
+}
+
 interface AppState {
   connections: SavedConnection[];
   tabs: TabData[];
   activeTabId: string | null;
   activeContext: { connectionId: string; dbName: string } | null;
   savedQueries: SavedQuery[];
-  darkMode: boolean;
+  theme: 'light' | 'dark';
+  appearance: { opacity: number; blur: number };
+  startupFullscreen: boolean;
+  globalProxy: GlobalProxyConfig;
   sqlFormatOptions: { keywordCase: 'upper' | 'lower' };
+  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;
 
   saveQuery: (query: SavedQuery) => void;
   deleteQuery: (id: string) => void;
 
-  toggleDarkMode: () => void;
+  setTheme: (theme: 'light' | 'dark') => void;
+  setAppearance: (appearance: Partial<{ opacity: number; blur: number }>) => void;
+  setStartupFullscreen: (enabled: boolean) => void;
+  setGlobalProxy: (proxy: Partial<GlobalProxyConfig>) => void;
   setSqlFormatOptions: (options: { keywordCase: 'upper' | 'lower' }) => 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;
+};
+
+const sanitizeStartupFullscreen = (value: unknown): boolean => {
+  return value === true;
+};
+
+const sanitizeGlobalProxy = (value: unknown): GlobalProxyConfig => {
+  const raw = (value && typeof value === 'object') ? value as Record<string, unknown> : {};
+  const typeRaw = toTrimmedString(raw.type, DEFAULT_GLOBAL_PROXY.type).toLowerCase();
+  const type: 'socks5' | 'http' = typeRaw === 'http' ? 'http' : 'socks5';
+  const fallbackPort = type === 'http' ? 8080 : 1080;
+  return {
+    enabled: raw.enabled === true,
+    type,
+    host: toTrimmedString(raw.host),
+    port: normalizePort(raw.port, fallbackPort),
+    user: toTrimmedString(raw.user),
+    password: toTrimmedString(raw.password),
+  };
+};
+
+const unwrapPersistedAppState = (persistedState: unknown): Record<string, unknown> => {
+  if (!persistedState || typeof persistedState !== 'object') {
+    return {};
+  }
+  const raw = persistedState as Record<string, unknown>;
+  if (raw.state && typeof raw.state === 'object') {
+    return raw.state as Record<string, unknown>;
+  }
+  return raw;
+};
+
 export const useStore = create<AppState>()(
   persist(
     (set) => ({
@@ -50,13 +468,19 @@ export const useStore = create<AppState>()(
       activeTabId: null,
       activeContext: null,
       savedQueries: [],
-      darkMode: false,
+      theme: 'light',
+      appearance: { ...DEFAULT_APPEARANCE },
+      startupFullscreen: DEFAULT_STARTUP_FULLSCREEN,
+      globalProxy: { ...DEFAULT_GLOBAL_PROXY },
       sqlFormatOptions: { keywordCase: 'upper' },
+      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) })),
 
@@ -79,6 +503,69 @@ export const useStore = create<AppState>()(
         }
         return { tabs: newTabs, activeTabId: newActiveId };
       }),
+
+      closeOtherTabs: (id) => set((state) => {
+        const keep = state.tabs.find(t => t.id === id);
+        if (!keep) return state;
+        return { tabs: [keep], activeTabId: id };
+      }),
+
+      closeTabsToLeft: (id) => set((state) => {
+        const index = state.tabs.findIndex(t => t.id === id);
+        if (index === -1) return state;
+        const newTabs = state.tabs.slice(index);
+        const activeStillExists = state.activeTabId ? newTabs.some(t => t.id === state.activeTabId) : false;
+        return { tabs: newTabs, activeTabId: activeStillExists ? state.activeTabId : id };
+      }),
+
+      closeTabsToRight: (id) => set((state) => {
+        const index = state.tabs.findIndex(t => t.id === id);
+        if (index === -1) return state;
+        const newTabs = state.tabs.slice(0, index + 1);
+        const activeStillExists = state.activeTabId ? newTabs.some(t => t.id === state.activeTabId) : false;
+        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 }),
       setActiveContext: (context) => set({ activeContext: context }),
@@ -94,15 +581,84 @@ export const useStore = create<AppState>()(
 
       deleteQuery: (id) => set((state) => ({ savedQueries: state.savedQueries.filter(q => q.id !== id) })),
 
-      toggleDarkMode: () => set((state) => ({ darkMode: !state.darkMode })),
+      setTheme: (theme) => set({ theme }),
+      setAppearance: (appearance) => set((state) => ({ appearance: { ...state.appearance, ...appearance } })),
+      setStartupFullscreen: (enabled) => set({ startupFullscreen: !!enabled }),
+      setGlobalProxy: (proxy) => set((state) => ({ globalProxy: sanitizeGlobalProxy({ ...state.globalProxy, ...proxy }) })),
       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, darkMode: state.darkMode, sqlFormatOptions: state.sqlFormatOptions }), // Don't persist logs
+      version: PERSIST_VERSION,
+      migrate: (persistedState: unknown, version: number) => {
+        const state = unwrapPersistedAppState(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.startupFullscreen = sanitizeStartupFullscreen(state.startupFullscreen);
+        nextState.globalProxy = sanitizeGlobalProxy(state.globalProxy);
+        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 = unwrapPersistedAppState(persistedState) as Partial<AppState>;
+        return {
+          ...currentState,
+          ...state,
+          connections: sanitizeConnections(state.connections),
+          savedQueries: sanitizeSavedQueries(state.savedQueries),
+          theme: sanitizeTheme(state.theme),
+          appearance: sanitizeAppearance(state.appearance, PERSIST_VERSION),
+          startupFullscreen: sanitizeStartupFullscreen(state.startupFullscreen),
+          globalProxy: sanitizeGlobalProxy(state.globalProxy),
+          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,
+        startupFullscreen: state.startupFullscreen,
+        globalProxy: state.globalProxy,
+        sqlFormatOptions: state.sqlFormatOptions,
+        queryOptions: state.queryOptions,
+        tableAccessCount: state.tableAccessCount,
+        tableSortPreference: state.tableSortPreference
+      }), // Don't persist logs
     }
   )
-);
+);

frontend/src/types.ts

@@ -6,15 +6,51 @@ export interface SSHConfig {
   keyPath?: string;
 }
 
+export interface ProxyConfig {
+  type: 'socks5' | 'http';
+  host: string;
+  port: number;
+  user?: string;
+  password?: string;
+}
+
 export interface ConnectionConfig {
   type: string;
   host: string;
   port: number;
   user: string;
   password?: string;
+  savePassword?: boolean;
   database?: string;
   useSSH?: boolean;
   ssh?: SSHConfig;
+  useProxy?: boolean;
+  proxy?: ProxyConfig;
+  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 {
@@ -22,6 +58,7 @@ export interface SavedConnection {
   name: string;
   config: ConnectionConfig;
   includeDatabases?: string[];
+  includeRedisDatabases?: number[]; // Redis databases to show (0-15)
 }
 
 export interface ColumnDefinition {
@@ -60,13 +97,18 @@ export interface TriggerDefinition {
 export interface TabData {
   id: string;
   title: string;
-  type: 'query' | 'table' | 'design';
+  type: 'query' | 'table' | 'design' | 'redis-keys' | 'redis-command' | 'trigger' | 'view-def' | 'routine-def';
   connectionId: string;
   dbName?: string;
   tableName?: string;
   query?: string;
   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 {
@@ -85,3 +127,37 @@ export interface SavedQuery {
   dbName: string;
   createdAt: number;
 }
+
+// Redis types
+export interface RedisKeyInfo {
+  key: string;
+  type: string;
+  ttl: number;
+}
+
+export interface RedisScanResult {
+  keys: RedisKeyInfo[];
+  cursor: number;
+}
+
+export interface RedisValue {
+  type: 'string' | 'hash' | 'list' | 'set' | 'zset' | 'stream';
+  ttl: number;
+  value: any;
+  length: number;
+}
+
+export interface RedisDBInfo {
+  index: number;
+  keys: number;
+}
+
+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

@@ -0,0 +1,272 @@
+export type FilterCondition = {
+  id?: number;
+  enabled?: boolean;
+  column?: string;
+  op?: string;
+  value?: string;
+  value2?: string;
+};
+
+const normalizeIdentPart = (ident: string) => {
+  let raw = (ident || '').trim();
+  if (!raw) return raw;
+  const first = raw[0];
+  const last = raw[raw.length - 1];
+  if ((first === '"' && last === '"') || (first === '`' && last === '`')) {
+    raw = raw.slice(1, -1).trim();
+  }
+  raw = raw.replace(/["`]/g, '').trim();
+  return raw;
+};
+
+// 检查标识符是否需要引号（包含特殊字符或是保留字）
+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());
+};
+
+export const quoteIdentPart = (dbType: string, ident: string) => {
+  const raw = normalizeIdentPart(ident);
+  if (!raw) return raw;
+  const dbTypeLower = (dbType || '').toLowerCase();
+
+  if (dbTypeLower === 'mysql' || dbTypeLower === 'mariadb' || dbTypeLower === 'diros' || dbTypeLower === 'sphinx' || dbTypeLower === 'tdengine' || dbTypeLower === 'clickhouse') {
+    return `\`${raw.replace(/`/g, '``')}\``;
+  }
+
+  // 对于 KingBase/PostgreSQL，只在必要时加引号
+  if (dbTypeLower === 'kingbase' || dbTypeLower === 'postgres') {
+    if (needsQuote(raw)) {
+      return `"${raw.replace(/"/g, '""')}"`;
+    }
+    // 不加引号，保持原样（数据库会自动转小写处理）
+    return raw;
+  }
+
+  // 其他数据库默认加双引号
+  return `"${raw.replace(/"/g, '""')}"`;
+};
+
+export const quoteQualifiedIdent = (dbType: string, ident: string) => {
+  const raw = (ident || '').trim();
+  if (!raw) return raw;
+  const parts = raw.split('.').map(normalizeIdentPart).filter(Boolean);
+  if (parts.length <= 1) return quoteIdentPart(dbType, raw);
+  return parts.map(p => quoteIdentPart(dbType, p)).join('.');
+};
+
+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 [];
+  return raw
+    .split(/[\n,，]+/)
+    .map(s => s.trim())
+    .filter(Boolean);
+};
+
+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();
+    const value2 = (cond?.value2 ?? '').toString();
+
+    if (op === 'CUSTOM') {
+      const expr = value.trim();
+      if (expr) whereParts.push(`(${expr})`);
+      return;
+    }
+
+    if (!column) return;
+
+    const col = quoteIdentPart(dbType, column);
+
+    switch (op) {
+      case 'IS_NULL':
+        whereParts.push(`${col} IS NULL`);
+        return;
+      case 'IS_NOT_NULL':
+        whereParts.push(`${col} IS NOT NULL`);
+        return;
+      case 'IS_EMPTY':
+        // 兼容：空值通常理解为 NULL 或空字符串
+        whereParts.push(`(${col} IS NULL OR ${col} = '')`);
+        return;
+      case 'IS_NOT_EMPTY':
+        whereParts.push(`(${col} IS NOT NULL AND ${col} <> '')`);
+        return;
+      case 'BETWEEN': {
+        const v1 = value.trim();
+        const v2 = value2.trim();
+        if (!v1 || !v2) return;
+        whereParts.push(`${col} BETWEEN '${escapeLiteral(v1)}' AND '${escapeLiteral(v2)}'`);
+        return;
+      }
+      case 'NOT_BETWEEN': {
+        const v1 = value.trim();
+        const v2 = value2.trim();
+        if (!v1 || !v2) return;
+        whereParts.push(`${col} NOT BETWEEN '${escapeLiteral(v1)}' AND '${escapeLiteral(v2)}'`);
+        return;
+      }
+      case 'IN': {
+        const items = parseListValues(value);
+        if (items.length === 0) return;
+        const list = items.map(v => `'${escapeLiteral(v)}'`).join(', ');
+        whereParts.push(`${col} IN (${list})`);
+        return;
+      }
+      case 'NOT_IN': {
+        const items = parseListValues(value);
+        if (items.length === 0) return;
+        const list = items.map(v => `'${escapeLiteral(v)}'`).join(', ');
+        whereParts.push(`${col} NOT IN (${list})`);
+        return;
+      }
+      case 'CONTAINS': {
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} LIKE '%${escapeLiteral(v)}%'`);
+        return;
+      }
+      case 'NOT_CONTAINS': {
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} NOT LIKE '%${escapeLiteral(v)}%'`);
+        return;
+      }
+      case 'STARTS_WITH': {
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} LIKE '${escapeLiteral(v)}%'`);
+        return;
+      }
+      case 'NOT_STARTS_WITH': {
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} NOT LIKE '${escapeLiteral(v)}%'`);
+        return;
+      }
+      case 'ENDS_WITH': {
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} LIKE '%${escapeLiteral(v)}'`);
+        return;
+      }
+      case 'NOT_ENDS_WITH': {
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} NOT LIKE '%${escapeLiteral(v)}'`);
+        return;
+      }
+      case '=':
+      case '!=':
+      case '<':
+      case '<=':
+      case '>':
+      case '>=': {
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} ${op} '${escapeLiteral(v)}'`);
+        return;
+      }
+      default: {
+        // 兼容旧值：LIKE
+        if (op.toUpperCase() === 'LIKE') {
+          const v = value.trim();
+          if (!v) return;
+          whereParts.push(`${col} LIKE '%${escapeLiteral(v)}%'`);
+          return;
+        }
+
+        const v = value.trim();
+        if (!v) return;
+        whereParts.push(`${col} ${op} '${escapeLiteral(v)}'`);
+      }
+    }
+  });
+
+  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

@@ -12,4 +12,4 @@ export default defineConfig({
     outDir: 'dist', // Standard Wails output directory
     emptyOutDir: true,
   }
-})
+})

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

@@ -2,9 +2,18 @@
 // This file is automatically generated. DO NOT EDIT
 import {connection} from '../models';
 import {sync} from '../models';
+import {redis} from '../models';
 
 export function ApplyChanges(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:connection.ChangeSet):Promise<connection.QueryResult>;
 
+export function CheckDriverNetworkStatus():Promise<connection.QueryResult>;
+
+export function CheckForUpdates():Promise<connection.QueryResult>;
+
+export function ConfigureDriverRuntimeDirectory(arg1:string):Promise<connection.QueryResult>;
+
+export function ConfigureGlobalProxy(arg1:boolean,arg2:connection.ProxyConfig):Promise<connection.QueryResult>;
+
 export function CreateDatabase(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
 
 export function DBConnect(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
@@ -33,14 +42,52 @@ 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,arg4: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>;
+
+export function ExportQuery(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string,arg5:string):Promise<connection.QueryResult>;
+
 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 GetDriverVersionList(arg1:string,arg2:string):Promise<connection.QueryResult>;
+
+export function GetDriverVersionPackageSize(arg1:string,arg2:string):Promise<connection.QueryResult>;
+
+export function GetGlobalProxyConfig():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>;
@@ -53,4 +100,74 @@ 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>;
+
+export function RedisDeleteKeys(arg1:connection.ConnectionConfig,arg2:Array<string>):Promise<connection.QueryResult>;
+
+export function RedisExecuteCommand(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
+
+export function RedisFlushDB(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
+
+export function RedisGetDatabases(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
+
+export function RedisGetServerInfo(arg1:connection.ConnectionConfig):Promise<connection.QueryResult>;
+
+export function RedisGetValue(arg1:connection.ConnectionConfig,arg2:string):Promise<connection.QueryResult>;
+
+export function RedisListPush(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
+
+export function RedisListSet(arg1:connection.ConnectionConfig,arg2:string,arg3:number,arg4:string):Promise<connection.QueryResult>;
+
+export function RedisRenameKey(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;
+
+export function RedisScanKeys(arg1:connection.ConnectionConfig,arg2:string,arg3:number,arg4:number):Promise<connection.QueryResult>;
+
+export function RedisSelectDB(arg1:connection.ConnectionConfig,arg2:number):Promise<connection.QueryResult>;
+
+export function RedisSetAdd(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
+
+export function RedisSetHashField(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string):Promise<connection.QueryResult>;
+
+export function RedisSetRemove(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>):Promise<connection.QueryResult>;
+
+export function RedisSetString(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:number):Promise<connection.QueryResult>;
+
+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

@@ -6,6 +6,22 @@ export function ApplyChanges(arg1, arg2, arg3, arg4) {
   return window['go']['app']['App']['ApplyChanges'](arg1, arg2, arg3, arg4);
 }
 
+export function CheckDriverNetworkStatus() {
+  return window['go']['app']['App']['CheckDriverNetworkStatus']();
+}
+
+export function CheckForUpdates() {
+  return window['go']['app']['App']['CheckForUpdates']();
+}
+
+export function ConfigureDriverRuntimeDirectory(arg1) {
+  return window['go']['app']['App']['ConfigureDriverRuntimeDirectory'](arg1);
+}
+
+export function ConfigureGlobalProxy(arg1, arg2) {
+  return window['go']['app']['App']['ConfigureGlobalProxy'](arg1, arg2);
+}
+
 export function CreateDatabase(arg1, arg2) {
   return window['go']['app']['App']['CreateDatabase'](arg1, arg2);
 }
@@ -62,14 +78,74 @@ export function DataSyncPreview(arg1, arg2, arg3) {
   return window['go']['app']['App']['DataSyncPreview'](arg1, arg2, arg3);
 }
 
+export function DownloadDriverPackage(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['DownloadDriverPackage'](arg1, arg2, arg3, arg4);
+}
+
+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);
 }
 
+export function ExportDatabaseSQL(arg1, arg2, arg3) {
+  return window['go']['app']['App']['ExportDatabaseSQL'](arg1, arg2, arg3);
+}
+
+export function ExportQuery(arg1, arg2, arg3, arg4, arg5) {
+  return window['go']['app']['App']['ExportQuery'](arg1, arg2, arg3, arg4, arg5);
+}
+
 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);
+}
+
+export function GetAppInfo() {
+  return window['go']['app']['App']['GetAppInfo']();
+}
+
+export function GetDriverStatusList(arg1, arg2) {
+  return window['go']['app']['App']['GetDriverStatusList'](arg1, arg2);
+}
+
+export function GetDriverVersionList(arg1, arg2) {
+  return window['go']['app']['App']['GetDriverVersionList'](arg1, arg2);
+}
+
+export function GetDriverVersionPackageSize(arg1, arg2) {
+  return window['go']['app']['App']['GetDriverVersionPackageSize'](arg1, arg2);
+}
+
+export function GetGlobalProxyConfig() {
+  return window['go']['app']['App']['GetGlobalProxyConfig']();
+}
+
 export function ImportConfigFile() {
   return window['go']['app']['App']['ImportConfigFile']();
 }
@@ -78,6 +154,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);
 }
@@ -102,6 +194,146 @@ 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);
+}
+
+export function RedisDeleteHashField(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RedisDeleteHashField'](arg1, arg2, arg3);
+}
+
+export function RedisDeleteKeys(arg1, arg2) {
+  return window['go']['app']['App']['RedisDeleteKeys'](arg1, arg2);
+}
+
+export function RedisExecuteCommand(arg1, arg2) {
+  return window['go']['app']['App']['RedisExecuteCommand'](arg1, arg2);
+}
+
+export function RedisFlushDB(arg1) {
+  return window['go']['app']['App']['RedisFlushDB'](arg1);
+}
+
+export function RedisGetDatabases(arg1) {
+  return window['go']['app']['App']['RedisGetDatabases'](arg1);
+}
+
+export function RedisGetServerInfo(arg1) {
+  return window['go']['app']['App']['RedisGetServerInfo'](arg1);
+}
+
+export function RedisGetValue(arg1, arg2) {
+  return window['go']['app']['App']['RedisGetValue'](arg1, arg2);
+}
+
+export function RedisListPush(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RedisListPush'](arg1, arg2, arg3);
+}
+
+export function RedisListSet(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['RedisListSet'](arg1, arg2, arg3, arg4);
+}
+
+export function RedisRenameKey(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RedisRenameKey'](arg1, arg2, arg3);
+}
+
+export function RedisScanKeys(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['RedisScanKeys'](arg1, arg2, arg3, arg4);
+}
+
+export function RedisSelectDB(arg1, arg2) {
+  return window['go']['app']['App']['RedisSelectDB'](arg1, arg2);
+}
+
+export function RedisSetAdd(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RedisSetAdd'](arg1, arg2, arg3);
+}
+
+export function RedisSetHashField(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['RedisSetHashField'](arg1, arg2, arg3, arg4);
+}
+
+export function RedisSetRemove(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RedisSetRemove'](arg1, arg2, arg3);
+}
+
+export function RedisSetString(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['RedisSetString'](arg1, arg2, arg3, arg4);
+}
+
+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);
+}
+
+export function RedisZSetAdd(arg1, arg2, arg3) {
+  return window['go']['app']['App']['RedisZSetAdd'](arg1, arg2, arg3);
+}
+
+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

@@ -48,6 +48,26 @@ export namespace connection {
 		    return a;
 		}
 	}
+	export class ProxyConfig {
+	    type: string;
+	    host: string;
+	    port: number;
+	    user?: string;
+	    password?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new ProxyConfig(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.type = source["type"];
+	        this.host = source["host"];
+	        this.port = source["port"];
+	        this.user = source["user"];
+	        this.password = source["password"];
+	    }
+	}
 	export class SSHConfig {
 	    host: string;
 	    port: number;
@@ -74,12 +94,28 @@ export namespace connection {
 	    port: number;
 	    user: string;
 	    password: string;
+	    savePassword?: boolean;
 	    database: string;
 	    useSSH: boolean;
 	    ssh: SSHConfig;
+	    useProxy?: boolean;
+	    proxy?: ProxyConfig;
 	    driver?: string;
 	    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);
@@ -92,12 +128,28 @@ 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);
+	        this.useProxy = source["useProxy"];
+	        this.proxy = this.convertValues(source["proxy"], ProxyConfig);
 	        this.driver = source["driver"];
 	        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 {
@@ -118,6 +170,7 @@ export namespace connection {
 		    return a;
 		}
 	}
+	
 	export class QueryResult {
 	    success: boolean;
 	    message: string;
@@ -140,6 +193,25 @@ export namespace connection {
 
 }
 
+export namespace redis {
+	
+	export class ZSetMember {
+	    member: string;
+	    score: number;
+	
+	    static createFrom(source: any = {}) {
+	        return new ZSetMember(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.member = source["member"];
+	        this.score = source["score"];
+	    }
+	}
+
+}
+
 export namespace sync {
 	
 	export class TableOptions {

go.mod

@@ -5,24 +5,57 @@ go 1.24.3
 require (
 	gitea.com/kingbase/gokb v0.0.0-20201021123113-29bd62a876c3
 	gitee.com/chunanyong/dm v1.8.22
+	github.com/ClickHouse/clickhouse-go/v2 v2.43.0
+	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/mod v0.32.0
+	golang.org/x/net v0.49.0
+	golang.org/x/text v0.33.0
 	modernc.org/sqlite v1.44.3
 )
 
 require (
 	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/ClickHouse/ch-go v0.71.0 // indirect
+	github.com/andybalholm/brotli v1.2.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-faster/city v1.0.1 // indirect
+	github.com/go-faster/errors v0.7.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.8.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
@@ -31,22 +64,45 @@ 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/paulmach/orb v0.12.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/segmentio/asm v1.2.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
+	go.opentelemetry.io/otel v1.39.0 // indirect
+	go.opentelemetry.io/otel/trace v1.39.0 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	golang.org/x/exp v0.0.0-20260112195511-716be5621a96 // 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,31 +4,122 @@ 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/ClickHouse/ch-go v0.71.0 h1:bUdZ/EZj/LcVHsMqaRUP2holqygrPWQKeMjc6nZoyRM=
+github.com/ClickHouse/ch-go v0.71.0/go.mod h1:NwbNc+7jaqfY58dmdDUbG4Jl22vThgx1cYjBw0vtgXw=
+github.com/ClickHouse/clickhouse-go/v2 v2.43.0 h1:fUR05TrF1GyvLDa/mAQjkx7KbgwdLRffs2n9O3WobtE=
+github.com/ClickHouse/clickhouse-go/v2 v2.43.0/go.mod h1:o6jf7JM/zveWC/PP277BLxjHy5KjnGX/jfljhM4s34g=
+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/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+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.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-faster/city v1.0.1 h1:4WAxSZ3V2Ws4QRDrscLEDcibJY8uf41H6AhXDrNDcGw=
+github.com/go-faster/city v1.0.1/go.mod h1:jKcUJId49qdW3L1qKHH/3wPeUstCVpVSXTM6vO3VcTw=
+github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg=
+github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo=
 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/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+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/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 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.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+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/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go-version v1.8.0 h1:KAkNb1HAiZd1ukkxDFGmokVZe1Xy9HG6NUp+bPle2i4=
+github.com/hashicorp/go-version v1.8.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/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+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.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+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/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+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=
@@ -53,25 +144,71 @@ 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/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
 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/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/paulmach/orb v0.12.0 h1:z+zOwjmG3MyEEqzv92UN49Lg1JFYx0L9GpGKNVDKk1s=
+github.com/paulmach/orb v0.12.0/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU=
+github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
+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/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0=
+github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
+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.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+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/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
+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=
@@ -84,35 +221,124 @@ 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.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
+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.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
+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/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
+github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
+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.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+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 v1.11.4/go.mod h1:PTSz5yu21bkT/wXpkS7WR5f0ddqw5quethTUn9WM+2g=
+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=
+go.opentelemetry.io/otel v1.39.0 h1:8yPrr/S0ND9QEfTfdP9V+SiwT4E0G7Y5MO7p85nis48=
+go.opentelemetry.io/otel v1.39.0/go.mod h1:kLlFTywNWrFyEdH0oj2xK0bFYZtHRYUdv1NklR/tgc8=
+go.opentelemetry.io/otel/trace v1.39.0 h1:2d2vfpEDmCJ5zVYz7ijaJdOF59xLomrvj7bjt6/qCJI=
+go.opentelemetry.io/otel/trace v1.39.0/go.mod h1:88w4/PnZSazkGzz/w84VHpQafiU4EtqqlVdxWy+rNOA=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 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.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+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-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+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-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+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-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/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-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/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.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+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-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/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=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/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

@@ -10,23 +10,34 @@ import (
 	"net"
 	"strings"
 	"sync"
+	"time"
 
 	"GoNavi-Wails/internal/connection"
 	"GoNavi-Wails/internal/db"
 	"GoNavi-Wails/internal/logger"
+	proxytunnel "GoNavi-Wails/internal/proxy"
 )
 
+const dbCachePingInterval = 30 * time.Second
+
+type cachedDatabase struct {
+	inst     db.Database
+	lastPing time.Time
+}
+
 // App struct
 type App struct {
-	ctx     context.Context
-	dbCache map[string]db.Database // Cache for DB connections
-	mu      sync.Mutex             // 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
 }
 
 // NewApp creates a new App application struct
 func NewApp() *App {
 	return &App{
-		dbCache: make(map[string]db.Database),
+		dbCache: make(map[string]cachedDatabase),
 	}
 }
 
@@ -35,19 +46,30 @@ 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("应用开始关闭，准备释放资源")
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	for _, dbInst := range a.dbCache {
-		if err := dbInst.Close(); err != nil {
+		if err := dbInst.inst.Close(); err != nil {
 			logger.Error(err, "关闭数据库连接失败")
 		}
 	}
+	proxytunnel.CloseAllForwarders()
+	// Close all Redis connections
+	CloseAllRedisClients()
 	logger.Infof("资源释放完成，应用已关闭")
 	logger.Close()
 }
@@ -57,9 +79,8 @@ func getCacheKey(config connection.ConnectionConfig) string {
 	if !config.UseSSH {
 		config.SSH = connection.SSHConfig{}
 	}
-	// 保持与驱动默认一致，避免同一连接被重复缓存
-	if config.Type == "postgres" && config.Database == "" {
-		config.Database = "postgres"
+	if !config.UseProxy {
+		config.Proxy = connection.ProxyConfig{}
 	}
 
 	b, _ := json.Marshal(config)
@@ -90,10 +111,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 {
@@ -112,12 +134,54 @@ 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))
 	}
+	if config.UseProxy {
+		b.WriteString(fmt.Sprintf(" 代理=%s://%s:%d", strings.ToLower(strings.TrimSpace(config.Proxy.Type)), config.Proxy.Host, config.Proxy.Port))
+		if strings.TrimSpace(config.Proxy.User) != "" {
+			b.WriteString(" 代理认证=已配置")
+		}
+	}
 
 	if config.Type == "custom" {
 		driver := strings.TrimSpace(config.Driver)
@@ -134,49 +198,111 @@ func formatConnSummary(config connection.ConnectionConfig) string {
 	return b.String()
 }
 
+func (a *App) getDatabaseForcePing(config connection.ConnectionConfig) (db.Database, error) {
+	return a.getDatabaseWithPing(config, true)
+}
+
 // Helper: Get or create a database connection
 func (a *App) getDatabase(config connection.ConnectionConfig) (db.Database, error) {
-	key := getCacheKey(config)
+	return a.getDatabaseWithPing(config, false)
+}
+
+func (a *App) getDatabaseWithPing(config connection.ConnectionConfig, forcePing bool) (db.Database, error) {
+	effectiveConfig := applyGlobalProxyToConnection(config)
+
+	key := getCacheKey(effectiveConfig)
 	shortKey := key
 	if len(shortKey) > 12 {
 		shortKey = shortKey[:12]
 	}
-	if config.UseSSH && config.Type != "mysql" {
-		logger.Warnf("当前仅 MySQL 支持内置 SSH 直连，其他类型请使用本地端口转发：%s", formatConnSummary(config))
+
+	if supported, reason := db.DriverRuntimeSupportStatus(effectiveConfig.Type); !supported {
+		if strings.TrimSpace(reason) == "" {
+			reason = fmt.Sprintf("%s 驱动未启用，请先在驱动管理中安装启用", strings.TrimSpace(effectiveConfig.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()}
 	}
-	logger.Infof("获取数据库连接：%s 缓存Key=%s", formatConnSummary(config), shortKey)
 
-	a.mu.Lock()
-	defer a.mu.Unlock()
+	a.mu.RLock()
+	entry, ok := a.dbCache[key]
+	a.mu.RUnlock()
+	if ok {
+		needPing := forcePing
+		if !needPing {
+			lastPing := entry.lastPing
+			if lastPing.IsZero() || time.Since(lastPing) >= dbCachePingInterval {
+				needPing = true
+			}
+		}
 
-	if dbInst, ok := a.dbCache[key]; ok {
-		logger.Infof("命中连接缓存，开始检测可用性：缓存Key=%s", shortKey)
-		if err := dbInst.Ping(); err == nil {
-			logger.Infof("缓存连接可用：缓存Key=%s", shortKey)
-			return dbInst, nil
+		if !needPing {
+			return entry.inst, nil
+		}
+
+		if err := entry.inst.Ping(); err == nil {
+			// Update lastPing (best effort)
+			a.mu.Lock()
+			if cur, exists := a.dbCache[key]; exists && cur.inst == entry.inst {
+				cur.lastPing = time.Now()
+				a.dbCache[key] = cur
+			}
+			a.mu.Unlock()
+			return entry.inst, nil
 		} else {
-			logger.Error(err, "缓存连接不可用，准备重建：缓存Key=%s", shortKey)
+			logger.Error(err, "缓存连接不可用，准备重建：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
 		}
-		if err := dbInst.Close(); err != nil {
-			logger.Error(err, "关闭失效缓存连接失败：缓存Key=%s", shortKey)
+
+		// Ping failed: remove cached instance (best effort)
+		a.mu.Lock()
+		if cur, exists := a.dbCache[key]; exists && cur.inst == entry.inst {
+			if err := cur.inst.Close(); err != nil {
+				logger.Error(err, "关闭失效缓存连接失败：缓存Key=%s", shortKey)
+			}
+			delete(a.dbCache, key)
 		}
-		delete(a.dbCache, key)
+		a.mu.Unlock()
 	}
 
-	logger.Infof("创建数据库驱动实例：类型=%s 缓存Key=%s", config.Type, shortKey)
-	dbInst, err := db.NewDatabase(config.Type)
+	logger.Infof("获取数据库连接：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
+	logger.Infof("创建数据库驱动实例：类型=%s 缓存Key=%s", effectiveConfig.Type, shortKey)
+	dbInst, err := db.NewDatabase(effectiveConfig.Type)
 	if err != nil {
-		logger.Error(err, "创建数据库驱动实例失败：类型=%s 缓存Key=%s", config.Type, shortKey)
+		logger.Error(err, "创建数据库驱动实例失败：类型=%s 缓存Key=%s", effectiveConfig.Type, shortKey)
 		return nil, err
 	}
 
-	if err := dbInst.Connect(config); err != nil {
-		wrapped := wrapConnectError(config, err)
-		logger.Error(wrapped, "建立数据库连接失败：%s 缓存Key=%s", formatConnSummary(config), shortKey)
+	connectConfig, proxyErr := resolveDialConfigWithProxy(effectiveConfig)
+	if proxyErr != nil {
+		wrapped := wrapConnectError(effectiveConfig, proxyErr)
+		logger.Error(wrapped, "连接代理准备失败：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
 		return nil, wrapped
 	}
 
-	a.dbCache[key] = dbInst
-	logger.Infof("数据库连接成功并写入缓存：%s 缓存Key=%s", formatConnSummary(config), shortKey)
+	if err := dbInst.Connect(connectConfig); err != nil {
+		wrapped := wrapConnectError(effectiveConfig, err)
+		logger.Error(wrapped, "建立数据库连接失败：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
+		return nil, wrapped
+	}
+
+	now := time.Now()
+
+	a.mu.Lock()
+	if existing, exists := a.dbCache[key]; exists && existing.inst != nil {
+		a.mu.Unlock()
+		// Prefer existing cached connection to avoid cache racing duplicates.
+		_ = dbInst.Close()
+		return existing.inst, nil
+	}
+	a.dbCache[key] = cachedDatabase{inst: dbInst, lastPing: now}
+	a.mu.Unlock()
+
+	logger.Infof("数据库连接成功并写入缓存：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
 	return dbInst, nil
 }

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", "clickhouse":
+		// 这些类型的 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/db_proxy.go

@@ -0,0 +1,204 @@
+package app
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	"GoNavi-Wails/internal/connection"
+	proxytunnel "GoNavi-Wails/internal/proxy"
+)
+
+func resolveDialConfigWithProxy(raw connection.ConnectionConfig) (connection.ConnectionConfig, error) {
+	config := raw
+	if !config.UseProxy {
+		config.Proxy = connection.ProxyConfig{}
+		return config, nil
+	}
+
+	normalizedProxy, err := proxytunnel.NormalizeConfig(config.Proxy)
+	if err != nil {
+		return connection.ConnectionConfig{}, err
+	}
+	config.Proxy = normalizedProxy
+
+	if config.UseSSH {
+		sshPort := config.SSH.Port
+		if sshPort <= 0 {
+			sshPort = 22
+		}
+		forwardedSSH, err := buildProxyForwardAddress(normalizedProxy, strings.TrimSpace(config.SSH.Host), sshPort)
+		if err != nil {
+			return connection.ConnectionConfig{}, fmt.Errorf("代理连接 SSH 网关失败：%w", err)
+		}
+		config.SSH.Host = forwardedSSH.host
+		config.SSH.Port = forwardedSSH.port
+		config.UseProxy = false
+		config.Proxy = connection.ProxyConfig{}
+		return config, nil
+	}
+
+	normalizedType := strings.ToLower(strings.TrimSpace(config.Type))
+	if normalizedType == "sqlite" || normalizedType == "duckdb" || normalizedType == "custom" {
+		// 文件型/自定义 DSN 类型不走标准 host:port，不在此层改写。
+		return config, nil
+	}
+	if normalizedType == "mongodb" && config.MongoSRV {
+		// Mongo SRV 由驱动侧 Dialer 处理代理，避免破坏 DNS SRV 拓扑发现。
+		return config, nil
+	}
+
+	targetPort := config.Port
+	if targetPort <= 0 {
+		targetPort = defaultPortByType(normalizedType)
+	}
+	forwardedPrimary, err := buildProxyForwardAddress(normalizedProxy, strings.TrimSpace(config.Host), targetPort)
+	if err != nil {
+		return connection.ConnectionConfig{}, err
+	}
+	config.Host = forwardedPrimary.host
+	config.Port = forwardedPrimary.port
+
+	if len(config.Hosts) > 0 {
+		rewritten := make([]string, 0, len(config.Hosts))
+		seen := make(map[string]struct{}, len(config.Hosts))
+		for _, rawEntry := range config.Hosts {
+			targetHost, targetPort, ok := parseAddressWithDefaultPort(rawEntry, defaultPortByType(normalizedType))
+			if !ok {
+				continue
+			}
+			forwarded, forwardErr := buildProxyForwardAddress(normalizedProxy, targetHost, targetPort)
+			if forwardErr != nil {
+				return connection.ConnectionConfig{}, forwardErr
+			}
+			rewrittenAddress := formatHostPort(forwarded.host, forwarded.port)
+			if _, exists := seen[rewrittenAddress]; exists {
+				continue
+			}
+			seen[rewrittenAddress] = struct{}{}
+			rewritten = append(rewritten, rewrittenAddress)
+		}
+		config.Hosts = rewritten
+	}
+
+	config.UseProxy = false
+	config.Proxy = connection.ProxyConfig{}
+	return config, nil
+}
+
+type hostPort struct {
+	host string
+	port int
+}
+
+func buildProxyForwardAddress(proxyConfig connection.ProxyConfig, targetHost string, targetPort int) (hostPort, error) {
+	host := strings.TrimSpace(targetHost)
+	if host == "" {
+		host = "localhost"
+	}
+	port := targetPort
+	if port <= 0 {
+		return hostPort{}, fmt.Errorf("目标端口无效：%d", targetPort)
+	}
+
+	forwarder, err := proxytunnel.GetOrCreateLocalForwarder(proxyConfig, host, port)
+	if err != nil {
+		return hostPort{}, err
+	}
+	localHost, localPort, splitOK := parseAddressWithDefaultPort(forwarder.LocalAddr, 0)
+	if !splitOK || localPort <= 0 {
+		return hostPort{}, fmt.Errorf("解析代理本地转发地址失败：%s", forwarder.LocalAddr)
+	}
+	return hostPort{host: localHost, port: localPort}, nil
+}
+
+func parseAddressWithDefaultPort(raw string, defaultPort int) (string, int, bool) {
+	text := strings.TrimSpace(raw)
+	if text == "" {
+		return "", 0, false
+	}
+
+	if strings.HasPrefix(text, "[") {
+		if host, portText, err := net.SplitHostPort(text); err == nil {
+			if port, convErr := strconv.Atoi(portText); convErr == nil && port > 0 && port <= 65535 {
+				return strings.TrimSpace(host), port, true
+			}
+			return "", 0, false
+		}
+		trimmed := strings.Trim(strings.TrimPrefix(text, "["), "]")
+		if trimmed != "" && defaultPort > 0 {
+			return trimmed, defaultPort, true
+		}
+		return "", 0, false
+	}
+
+	if strings.Count(text, ":") == 0 {
+		if defaultPort <= 0 {
+			return "", 0, false
+		}
+		return text, defaultPort, true
+	}
+
+	if strings.Count(text, ":") == 1 {
+		host, portText, err := net.SplitHostPort(text)
+		if err == nil {
+			port, convErr := strconv.Atoi(portText)
+			if convErr == nil && port > 0 && port <= 65535 {
+				return strings.TrimSpace(host), port, true
+			}
+			return "", 0, false
+		}
+		if defaultPort > 0 {
+			return strings.TrimSpace(text), defaultPort, true
+		}
+		return "", 0, false
+	}
+
+	// IPv6 地址未带端口，使用默认端口。
+	if defaultPort > 0 {
+		return text, defaultPort, true
+	}
+	return "", 0, false
+}
+
+func formatHostPort(host string, port int) string {
+	h := strings.TrimSpace(host)
+	if strings.Contains(h, ":") && !strings.HasPrefix(h, "[") {
+		return fmt.Sprintf("[%s]:%d", h, port)
+	}
+	return fmt.Sprintf("%s:%d", h, port)
+}
+
+func defaultPortByType(driverType string) int {
+	switch strings.ToLower(strings.TrimSpace(driverType)) {
+	case "mysql", "mariadb":
+		return 3306
+	case "diros":
+		return 9030
+	case "sphinx":
+		return 9306
+	case "postgres", "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 "clickhouse":
+		return 9000
+	case "highgo":
+		return 5866
+	default:
+		return 0
+	}
+}

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/global_proxy.go

@@ -0,0 +1,191 @@
+package app
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	proxytunnel "GoNavi-Wails/internal/proxy"
+)
+
+type globalProxySnapshot struct {
+	Enabled bool                   `json:"enabled"`
+	Proxy   connection.ProxyConfig `json:"proxy"`
+}
+
+var globalProxyRuntime = struct {
+	mu      sync.RWMutex
+	enabled bool
+	proxy   connection.ProxyConfig
+}{}
+
+func currentGlobalProxyConfig() globalProxySnapshot {
+	globalProxyRuntime.mu.RLock()
+	defer globalProxyRuntime.mu.RUnlock()
+	if !globalProxyRuntime.enabled {
+		return globalProxySnapshot{
+			Enabled: false,
+			Proxy:   connection.ProxyConfig{},
+		}
+	}
+	return globalProxySnapshot{
+		Enabled: true,
+		Proxy:   globalProxyRuntime.proxy,
+	}
+}
+
+func setGlobalProxyConfig(enabled bool, proxyConfig connection.ProxyConfig) (globalProxySnapshot, error) {
+	if !enabled {
+		globalProxyRuntime.mu.Lock()
+		globalProxyRuntime.enabled = false
+		globalProxyRuntime.proxy = connection.ProxyConfig{}
+		globalProxyRuntime.mu.Unlock()
+		return currentGlobalProxyConfig(), nil
+	}
+
+	normalizedProxy, err := proxytunnel.NormalizeConfig(proxyConfig)
+	if err != nil {
+		return globalProxySnapshot{}, err
+	}
+
+	globalProxyRuntime.mu.Lock()
+	globalProxyRuntime.enabled = true
+	globalProxyRuntime.proxy = normalizedProxy
+	globalProxyRuntime.mu.Unlock()
+	return currentGlobalProxyConfig(), nil
+}
+
+func (a *App) ConfigureGlobalProxy(enabled bool, proxyConfig connection.ProxyConfig) connection.QueryResult {
+	snapshot, err := setGlobalProxyConfig(enabled, proxyConfig)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if snapshot.Enabled {
+		authState := ""
+		if strings.TrimSpace(snapshot.Proxy.User) != "" {
+			authState = "（认证：已配置）"
+		}
+		logger.Infof(
+			"全局代理已启用：%s://%s:%d%s",
+			strings.ToLower(strings.TrimSpace(snapshot.Proxy.Type)),
+			strings.TrimSpace(snapshot.Proxy.Host),
+			snapshot.Proxy.Port,
+			authState,
+		)
+	} else {
+		logger.Infof("全局代理已关闭")
+	}
+
+	return connection.QueryResult{
+		Success: true,
+		Message: "全局代理配置已生效",
+		Data:    snapshot,
+	}
+}
+
+func (a *App) GetGlobalProxyConfig() connection.QueryResult {
+	return connection.QueryResult{
+		Success: true,
+		Message: "OK",
+		Data:    currentGlobalProxyConfig(),
+	}
+}
+
+func applyGlobalProxyToConnection(config connection.ConnectionConfig) connection.ConnectionConfig {
+	effective := config
+	if effective.UseProxy {
+		return effective
+	}
+	if isFileDatabaseType(effective.Type) {
+		effective.Proxy = connection.ProxyConfig{}
+		return effective
+	}
+
+	snapshot := currentGlobalProxyConfig()
+	if !snapshot.Enabled {
+		effective.Proxy = connection.ProxyConfig{}
+		return effective
+	}
+
+	effective.UseProxy = true
+	effective.Proxy = snapshot.Proxy
+	return effective
+}
+
+func isFileDatabaseType(driverType string) bool {
+	switch strings.ToLower(strings.TrimSpace(driverType)) {
+	case "sqlite", "duckdb":
+		return true
+	default:
+		return false
+	}
+}
+
+func newHTTPClientWithGlobalProxy(timeout time.Duration) *http.Client {
+	client := &http.Client{
+		Timeout: timeout,
+	}
+	if transport := buildHTTPTransportWithGlobalProxy(); transport != nil {
+		client.Transport = transport
+	}
+	return client
+}
+
+func buildHTTPTransportWithGlobalProxy() *http.Transport {
+	baseTransport, ok := http.DefaultTransport.(*http.Transport)
+	if !ok || baseTransport == nil {
+		return nil
+	}
+
+	transport := baseTransport.Clone()
+	snapshot := currentGlobalProxyConfig()
+	if !snapshot.Enabled {
+		transport.Proxy = http.ProxyFromEnvironment
+		return transport
+	}
+
+	proxyURL, err := buildProxyURLFromConfig(snapshot.Proxy)
+	if err != nil {
+		logger.Warnf("全局代理配置无效，回退系统代理：%v", err)
+		transport.Proxy = http.ProxyFromEnvironment
+		return transport
+	}
+
+	transport.Proxy = http.ProxyURL(proxyURL)
+	return transport
+}
+
+func buildProxyURLFromConfig(proxyConfig connection.ProxyConfig) (*url.URL, error) {
+	normalizedProxy, err := proxytunnel.NormalizeConfig(proxyConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	proxyType := strings.ToLower(strings.TrimSpace(normalizedProxy.Type))
+	if proxyType != "http" && proxyType != "socks5" {
+		return nil, fmt.Errorf("不支持的代理类型：%s", normalizedProxy.Type)
+	}
+	if strings.TrimSpace(normalizedProxy.Host) == "" {
+		return nil, fmt.Errorf("代理地址不能为空")
+	}
+	if normalizedProxy.Port <= 0 || normalizedProxy.Port > 65535 {
+		return nil, fmt.Errorf("代理端口无效：%d", normalizedProxy.Port)
+	}
+
+	proxyURL := &url.URL{
+		Scheme: proxyType,
+		Host:   net.JoinHostPort(strings.TrimSpace(normalizedProxy.Host), strconv.Itoa(normalizedProxy.Port)),
+	}
+	if strings.TrimSpace(normalizedProxy.User) != "" {
+		proxyURL.User = url.UserPassword(strings.TrimSpace(normalizedProxy.User), normalizedProxy.Password)
+	}
+	return proxyURL, nil
+}

internal/app/methods_db.go

@@ -1,41 +1,79 @@
 package app
 
 import (
+	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	"GoNavi-Wails/internal/connection"
 	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/utils"
 )
 
 // Generic DB Methods
 
 func (a *App) DBConnect(config connection.ConnectionConfig) connection.QueryResult {
-	// getDatabase checks cache and Pings. If valid, reuses. If not, connects.
-	_, err := a.getDatabase(config)
+	// 连接测试需要强制 ping，避免缓存命中但连接已失效时误判成功。
+	_, err := a.getDatabaseForcePing(config)
 	if err != nil {
 		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: "连接成功"}
 }
 
 func (a *App) TestConnection(config connection.ConnectionConfig) connection.QueryResult {
-	_, err := a.getDatabase(config)
+	_, err := a.getDatabaseForcePing(config)
 	if err != nil {
 		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 {
@@ -44,9 +82,18 @@ 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 == "clickhouse" {
+		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)
@@ -57,6 +104,228 @@ 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", "clickhouse":
+			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
+		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", "clickhouse":
+		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
+		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", "clickhouse":
+	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", "clickhouse":
+		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", "clickhouse":
+	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)
@@ -91,16 +360,44 @@ func (a *App) DBQuery(config connection.ConnectionConfig, dbName string, query s
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
 
+	query = sanitizeSQLForPgLike(runConfig.Type, query)
+	timeoutSeconds := runConfig.Timeout
+	if timeoutSeconds <= 0 {
+		timeoutSeconds = 30
+	}
+	ctx, cancel := utils.ContextWithTimeout(time.Duration(timeoutSeconds) * time.Second)
+	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") {
-		data, columns, err := dbInst.Query(query)
+	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 {
+			QueryContext(context.Context, string) ([]map[string]interface{}, []string, error)
+		}); ok {
+			data, columns, err = q.QueryContext(ctx, query)
+		} else {
+			data, columns, err = dbInst.Query(query)
+		}
 		if err != nil {
 			logger.Error(err, "DBQuery 查询失败：%s SQL片段=%q", formatConnSummary(runConfig), sqlSnippet(query))
 			return connection.QueryResult{Success: false, Message: err.Error()}
 		}
 		return connection.QueryResult{Success: true, Data: data, Fields: columns}
 	} else {
-		affected, err := dbInst.Exec(query)
+		var affected int64
+		if e, ok := dbInst.(interface {
+			ExecContext(context.Context, string) (int64, error)
+		}); ok {
+			affected, err = e.ExecContext(ctx, query)
+		} else {
+			affected, err = dbInst.Exec(query)
+		}
 		if err != nil {
 			logger.Error(err, "DBQuery 执行失败：%s SQL片段=%q", formatConnSummary(runConfig), sqlSnippet(query))
 			return connection.QueryResult{Success: false, Message: err.Error()}
@@ -130,12 +427,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}
 }
 
@@ -164,6 +461,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 {
@@ -177,10 +475,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)
 
@@ -249,6 +657,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", "clickhouse":
+	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", "clickhouse":
+		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

@@ -0,0 +1,515 @@
+package app
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"strings"
+	"sync"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+	"GoNavi-Wails/internal/redis"
+)
+
+// Redis client cache
+var (
+	redisCache   = make(map[string]redis.RedisClient)
+	redisCacheMu sync.Mutex
+)
+
+// getRedisClient gets or creates a Redis client from cache
+func (a *App) getRedisClient(config connection.ConnectionConfig) (redis.RedisClient, error) {
+	key := getRedisClientCacheKey(config)
+	shortKey := key
+	if len(shortKey) > 12 {
+		shortKey = shortKey[:12]
+	}
+	logger.Infof("获取 Redis 连接：%s 缓存Key=%s", formatRedisConnSummary(config), shortKey)
+
+	redisCacheMu.Lock()
+	defer redisCacheMu.Unlock()
+
+	if client, ok := redisCache[key]; ok {
+		logger.Infof("命中 Redis 连接缓存，开始检测可用性：缓存Key=%s", shortKey)
+		if err := client.Ping(); err == nil {
+			logger.Infof("缓存 Redis 连接可用：缓存Key=%s", shortKey)
+			return client, nil
+		} else {
+			logger.Error(err, "缓存 Redis 连接不可用，准备重建：缓存Key=%s", shortKey)
+		}
+		client.Close()
+		delete(redisCache, key)
+	}
+
+	logger.Infof("创建 Redis 客户端实例：缓存Key=%s", shortKey)
+	client := redis.NewRedisClient()
+	if err := client.Connect(config); err != nil {
+		logger.Error(err, "Redis 连接失败：%s 缓存Key=%s", formatRedisConnSummary(config), shortKey)
+		return nil, err
+	}
+
+	redisCache[key] = client
+	logger.Infof("Redis 连接成功并写入缓存：%s 缓存Key=%s", formatRedisConnSummary(config), shortKey)
+	return client, nil
+}
+
+func getRedisClientCacheKey(config connection.ConnectionConfig) string {
+	if !config.UseSSH {
+		config.SSH = connection.SSHConfig{}
+	}
+	b, _ := json.Marshal(config)
+	sum := sha256.Sum256(b)
+	return hex.EncodeToString(sum[:])
+}
+
+func formatRedisConnSummary(config connection.ConnectionConfig) string {
+	timeoutSeconds := config.Timeout
+	if timeoutSeconds <= 0 {
+		timeoutSeconds = 30
+	}
+
+	var b strings.Builder
+	b.WriteString("类型=redis 地址=")
+	b.WriteString(config.Host)
+	b.WriteString(":")
+	b.WriteString(string(rune(config.Port + '0')))
+	b.WriteString(" DB=")
+	b.WriteString(string(rune(config.RedisDB + '0')))
+
+	if config.UseSSH {
+		b.WriteString(" SSH=")
+		b.WriteString(config.SSH.Host)
+		b.WriteString(":")
+		b.WriteString(string(rune(config.SSH.Port + '0')))
+		b.WriteString(" 用户=")
+		b.WriteString(config.SSH.User)
+	}
+
+	return b.String()
+}
+
+// RedisConnect tests a Redis connection
+func (a *App) RedisConnect(config connection.ConnectionConfig) connection.QueryResult {
+	config.Type = "redis"
+	_, err := a.getRedisClient(config)
+	if err != nil {
+		logger.Error(err, "RedisConnect 连接失败：%s", formatRedisConnSummary(config))
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	logger.Infof("RedisConnect 连接成功：%s", formatRedisConnSummary(config))
+	return connection.QueryResult{Success: true, Message: "连接成功"}
+}
+
+// RedisTestConnection tests a Redis connection (alias for RedisConnect)
+func (a *App) RedisTestConnection(config connection.ConnectionConfig) connection.QueryResult {
+	return a.RedisConnect(config)
+}
+
+// RedisScanKeys scans keys matching a pattern
+func (a *App) RedisScanKeys(config connection.ConnectionConfig, pattern string, cursor uint64, count int64) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	result, err := client.ScanKeys(pattern, cursor, count)
+	if err != nil {
+		logger.Error(err, "RedisScanKeys 扫描失败：pattern=%s", pattern)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Data: result}
+}
+
+// RedisGetValue gets the value of a key
+func (a *App) RedisGetValue(config connection.ConnectionConfig, key string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	value, err := client.GetValue(key)
+	if err != nil {
+		logger.Error(err, "RedisGetValue 获取失败：key=%s", key)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Data: value}
+}
+
+// RedisSetString sets a string value
+func (a *App) RedisSetString(config connection.ConnectionConfig, key, value string, ttl int64) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.SetString(key, value, ttl); err != nil {
+		logger.Error(err, "RedisSetString 设置失败：key=%s", key)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "设置成功"}
+}
+
+// RedisSetHashField sets a field in a hash
+func (a *App) RedisSetHashField(config connection.ConnectionConfig, key, field, value string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.SetHashField(key, field, value); err != nil {
+		logger.Error(err, "RedisSetHashField 设置失败：key=%s field=%s", key, field)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "设置成功"}
+}
+
+// RedisDeleteKeys deletes one or more keys
+func (a *App) RedisDeleteKeys(config connection.ConnectionConfig, keys []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.DeleteKeys(keys)
+	if err != nil {
+		logger.Error(err, "RedisDeleteKeys 删除失败：keys=%v", keys)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Data: map[string]int64{"deleted": deleted}}
+}
+
+// RedisSetTTL sets the TTL of a key
+func (a *App) RedisSetTTL(config connection.ConnectionConfig, key string, ttl int64) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.SetTTL(key, ttl); err != nil {
+		logger.Error(err, "RedisSetTTL 设置失败：key=%s ttl=%d", key, ttl)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "设置成功"}
+}
+
+// RedisExecuteCommand executes a raw Redis command
+func (a *App) RedisExecuteCommand(config connection.ConnectionConfig, command string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	// Parse command string into args
+	args := parseRedisCommand(command)
+	if len(args) == 0 {
+		return connection.QueryResult{Success: false, Message: "命令不能为空"}
+	}
+
+	result, err := client.ExecuteCommand(args)
+	if err != nil {
+		logger.Error(err, "RedisExecuteCommand 执行失败：command=%s", command)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Data: result}
+}
+
+// parseRedisCommand parses a Redis command string into arguments
+func parseRedisCommand(command string) []string {
+	command = strings.TrimSpace(command)
+	if command == "" {
+		return nil
+	}
+
+	var args []string
+	var current strings.Builder
+	inQuote := false
+	quoteChar := rune(0)
+
+	for _, ch := range command {
+		if inQuote {
+			if ch == quoteChar {
+				inQuote = false
+				args = append(args, current.String())
+				current.Reset()
+			} else {
+				current.WriteRune(ch)
+			}
+		} else {
+			if ch == '"' || ch == '\'' {
+				inQuote = true
+				quoteChar = ch
+			} else if ch == ' ' || ch == '\t' {
+				if current.Len() > 0 {
+					args = append(args, current.String())
+					current.Reset()
+				}
+			} else {
+				current.WriteRune(ch)
+			}
+		}
+	}
+
+	if current.Len() > 0 {
+		args = append(args, current.String())
+	}
+
+	return args
+}
+
+// RedisGetServerInfo returns server information
+func (a *App) RedisGetServerInfo(config connection.ConnectionConfig) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	info, err := client.GetServerInfo()
+	if err != nil {
+		logger.Error(err, "RedisGetServerInfo 获取失败")
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Data: info}
+}
+
+// RedisGetDatabases returns information about all databases
+func (a *App) RedisGetDatabases(config connection.ConnectionConfig) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	dbs, err := client.GetDatabases()
+	if err != nil {
+		logger.Error(err, "RedisGetDatabases 获取失败")
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Data: dbs}
+}
+
+// RedisSelectDB selects a database
+func (a *App) RedisSelectDB(config connection.ConnectionConfig, dbIndex int) connection.QueryResult {
+	config.Type = "redis"
+	config.RedisDB = dbIndex
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.SelectDB(dbIndex); err != nil {
+		logger.Error(err, "RedisSelectDB 切换失败：db=%d", dbIndex)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "切换成功"}
+}
+
+// RedisRenameKey renames a key
+func (a *App) RedisRenameKey(config connection.ConnectionConfig, oldKey, newKey string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.RenameKey(oldKey, newKey); err != nil {
+		logger.Error(err, "RedisRenameKey 重命名失败：%s -> %s", oldKey, newKey)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "重命名成功"}
+}
+
+// RedisDeleteHashField deletes fields from a hash
+func (a *App) RedisDeleteHashField(config connection.ConnectionConfig, key string, fields []string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.DeleteHashField(key, fields...); err != nil {
+		logger.Error(err, "RedisDeleteHashField 删除失败：key=%s fields=%v", key, fields)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "删除成功"}
+}
+
+// RedisListPush pushes values to a list
+func (a *App) RedisListPush(config connection.ConnectionConfig, key string, values []string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.ListPush(key, values...); err != nil {
+		logger.Error(err, "RedisListPush 添加失败：key=%s", key)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "添加成功"}
+}
+
+// RedisListSet sets a value at an index in a list
+func (a *App) RedisListSet(config connection.ConnectionConfig, key string, index int64, value string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.ListSet(key, index, value); err != nil {
+		logger.Error(err, "RedisListSet 设置失败：key=%s index=%d", key, index)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "设置成功"}
+}
+
+// RedisSetAdd adds members to a set
+func (a *App) RedisSetAdd(config connection.ConnectionConfig, key string, members []string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.SetAdd(key, members...); err != nil {
+		logger.Error(err, "RedisSetAdd 添加失败：key=%s", key)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "添加成功"}
+}
+
+// RedisSetRemove removes members from a set
+func (a *App) RedisSetRemove(config connection.ConnectionConfig, key string, members []string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.SetRemove(key, members...); err != nil {
+		logger.Error(err, "RedisSetRemove 删除失败：key=%s", key)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "删除成功"}
+}
+
+// RedisZSetAdd adds members to a sorted set
+func (a *App) RedisZSetAdd(config connection.ConnectionConfig, key string, members []redis.ZSetMember) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.ZSetAdd(key, members...); err != nil {
+		logger.Error(err, "RedisZSetAdd 添加失败：key=%s", key)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "添加成功"}
+}
+
+// RedisZSetRemove removes members from a sorted set
+func (a *App) RedisZSetRemove(config connection.ConnectionConfig, key string, members []string) connection.QueryResult {
+	config.Type = "redis"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.ZSetRemove(key, members...); err != nil {
+		logger.Error(err, "RedisZSetRemove 删除失败：key=%s", key)
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	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"
+	client, err := a.getRedisClient(config)
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	if err := client.FlushDB(); err != nil {
+		logger.Error(err, "RedisFlushDB 清空失败")
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+
+	return connection.QueryResult{Success: true, Message: "清空成功"}
+}
+
+// CloseAllRedisClients closes all cached Redis clients (called on shutdown)
+func CloseAllRedisClients() {
+	redisCacheMu.Lock()
+	defer redisCacheMu.Unlock()
+
+	for key, client := range redisCache {
+		if client != nil {
+			client.Close()
+			logger.Infof("已关闭 Redis 连接：%s", key[:12])
+		}
+	}
+	redisCache = make(map[string]redis.RedisClient)
+}

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

@@ -0,0 +1,236 @@
+package app
+
+import (
+	"strings"
+	"unicode"
+)
+
+func sanitizeSQLForPgLike(dbType string, query string) string {
+	switch strings.ToLower(strings.TrimSpace(dbType)) {
+	case "postgres", "kingbase", "highgo", "vastbase":
+		// 有些情况下会出现多层重复引用（例如 """"schema"""" 或 ""schema"""），单次修复不一定收敛。
+		// 这里做有限次数的迭代，直到输出不再变化。
+		out := query
+		for i := 0; i < 3; i++ {
+			fixed := fixBrokenDoubleDoubleQuotedIdent(out)
+			if fixed == out {
+				break
+			}
+			out = fixed
+		}
+		return out
+	default:
+		return query
+	}
+}
+
+// fixBrokenDoubleDoubleQuotedIdent fixes accidental identifiers like:
+//
+//	SELECT * FROM ""schema"".""table""
+//
+// which can be produced when a quoted identifier gets wrapped by quotes again.
+//
+// It is intentionally conservative:
+// - only runs outside strings/comments/dollar-quoted blocks
+// - does not touch valid escaped-quote sequences inside quoted identifiers (e.g. "a""b")
+func fixBrokenDoubleDoubleQuotedIdent(query string) string {
+	if !strings.Contains(query, `""`) {
+		return query
+	}
+
+	var b strings.Builder
+	b.Grow(len(query))
+
+	inSingle := false
+	inDoubleIdent := false
+	inLineComment := false
+	inBlockComment := false
+	dollarTag := ""
+
+	for i := 0; i < len(query); i++ {
+		ch := query[i]
+		next := byte(0)
+		if i+1 < len(query) {
+			next = query[i+1]
+		}
+
+		if inLineComment {
+			b.WriteByte(ch)
+			if ch == '\n' {
+				inLineComment = false
+			}
+			continue
+		}
+		if inBlockComment {
+			b.WriteByte(ch)
+			if ch == '*' && next == '/' {
+				b.WriteByte('/')
+				i++
+				inBlockComment = false
+			}
+			continue
+		}
+		if dollarTag != "" {
+			if strings.HasPrefix(query[i:], dollarTag) {
+				b.WriteString(dollarTag)
+				i += len(dollarTag) - 1
+				dollarTag = ""
+				continue
+			}
+			b.WriteByte(ch)
+			continue
+		}
+		if inSingle {
+			b.WriteByte(ch)
+			if ch == '\'' {
+				// escaped single quote
+				if next == '\'' {
+					b.WriteByte('\'')
+					i++
+					continue
+				}
+				inSingle = false
+			}
+			continue
+		}
+		if inDoubleIdent {
+			b.WriteByte(ch)
+			if ch == '"' {
+				// escaped quote inside identifier
+				if next == '"' {
+					b.WriteByte('"')
+					i++
+					continue
+				}
+				inDoubleIdent = false
+			}
+			continue
+		}
+
+		// --- Outside of all string/comment blocks ---
+		if ch == '-' && next == '-' {
+			b.WriteByte(ch)
+			b.WriteByte('-')
+			i++
+			inLineComment = true
+			continue
+		}
+		if ch == '/' && next == '*' {
+			b.WriteByte(ch)
+			b.WriteByte('*')
+			i++
+			inBlockComment = true
+			continue
+		}
+		if ch == '\'' {
+			b.WriteByte(ch)
+			inSingle = true
+			continue
+		}
+		if ch == '$' {
+			if tag := parseDollarTag(query[i:]); tag != "" {
+				b.WriteString(tag)
+				i += len(tag) - 1
+				dollarTag = tag
+				continue
+			}
+		}
+
+		if ch == '"' {
+			// Fix: ""ident"" -> "ident" (only when it looks like a plain identifier)
+			// Also handle variants like ""ident""" / """"ident"""" (extra quotes at either side).
+			if next == '"' {
+				if replacement, advance, ok := tryFixDoubleDoubleQuotedIdent(query, i); ok {
+					b.WriteString(replacement)
+					i = advance - 1
+					continue
+				}
+			}
+
+			b.WriteByte(ch)
+			inDoubleIdent = true
+			continue
+		}
+
+		b.WriteByte(ch)
+	}
+
+	return b.String()
+}
+
+func tryFixDoubleDoubleQuotedIdent(query string, start int) (replacement string, advance int, ok bool) {
+	// start points at the first quote of a broken identifier, usually like:
+	//   ""ident""  / ""ident""" / """"ident""""
+	if start < 0 || start+1 >= len(query) {
+		return "", 0, false
+	}
+	if query[start] != '"' || query[start+1] != '"' {
+		return "", 0, false
+	}
+	if start > 0 && query[start-1] == '"' {
+		return "", 0, false
+	}
+
+	runLen := 0
+	for start+runLen < len(query) && query[start+runLen] == '"' {
+		runLen++
+	}
+	if runLen < 2 || runLen%2 == 1 {
+		// Odd run (e.g. """...) can be a valid quoted identifier with escaped quotes.
+		return "", 0, false
+	}
+
+	contentStart := start + runLen
+	j := contentStart
+	for j < len(query) {
+		if query[j] == '"' {
+			endRunLen := 0
+			for j+endRunLen < len(query) && query[j+endRunLen] == '"' {
+				endRunLen++
+			}
+			if endRunLen >= 2 {
+				content := strings.TrimSpace(query[contentStart:j])
+				if looksLikeIdentifierContent(content) {
+					return `"` + content + `"`, j + endRunLen, true
+				}
+				return "", 0, false
+			}
+		}
+		// Fast abort: identifier-like content should not span lines.
+		if query[j] == '\n' || query[j] == '\r' {
+			break
+		}
+		j++
+	}
+	return "", 0, false
+}
+
+func looksLikeIdentifierContent(s string) bool {
+	if strings.TrimSpace(s) == "" {
+		return false
+	}
+	for _, r := range s {
+		if r == '_' || r == '$' || r == '-' || unicode.IsLetter(r) || unicode.IsDigit(r) {
+			continue
+		}
+		return false
+	}
+	return true
+}
+
+func parseDollarTag(s string) string {
+	// Match: $tag$ where tag is [A-Za-z0-9_]* (can be empty => $$)
+	if len(s) < 2 || s[0] != '$' {
+		return ""
+	}
+	for i := 1; i < len(s); i++ {
+		c := s[i]
+		if c == '$' {
+			return s[:i+1]
+		}
+		if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_') {
+			return ""
+		}
+	}
+	return ""
+}

internal/app/sql_sanitize_test.go

@@ -0,0 +1,55 @@
+package app
+
+import "testing"
+
+func TestSanitizeSQLForPgLike_FixesBrokenDoubleDoubleQuotes(t *testing.T) {
+	in := `SELECT * FROM ""ldf_server"".""t_user"" LIMIT 1`
+	out := sanitizeSQLForPgLike("kingbase", in)
+	want := `SELECT * FROM "ldf_server"."t_user" LIMIT 1`
+	if out != want {
+		t.Fatalf("unexpected sanitize output:\nIN:   %s\nOUT:  %s\nWANT: %s", in, out, want)
+	}
+}
+
+func TestSanitizeSQLForPgLike_FixesBrokenDoubleDoubleQuotes_WithExtraQuotes(t *testing.T) {
+	in := `SELECT * FROM ""ldf_server""".""t_user"" LIMIT 1`
+	out := sanitizeSQLForPgLike("kingbase", in)
+	want := `SELECT * FROM "ldf_server"."t_user" LIMIT 1`
+	if out != want {
+		t.Fatalf("unexpected sanitize output:\nIN:   %s\nOUT:  %s\nWANT: %s", in, out, want)
+	}
+}
+
+func TestSanitizeSQLForPgLike_FixesBrokenDoubleDoubleQuotes_WithQuadQuotes(t *testing.T) {
+	in := `SELECT * FROM """"ldf_server"""".""t_user"" LIMIT 1`
+	out := sanitizeSQLForPgLike("kingbase", in)
+	want := `SELECT * FROM "ldf_server"."t_user" LIMIT 1`
+	if out != want {
+		t.Fatalf("unexpected sanitize output:\nIN:   %s\nOUT:  %s\nWANT: %s", in, out, want)
+	}
+}
+
+func TestSanitizeSQLForPgLike_DoesNotTouchEscapedQuotesInsideIdentifier(t *testing.T) {
+	in := `SELECT "a""b" FROM "t""x"`
+	out := sanitizeSQLForPgLike("postgres", in)
+	if out != in {
+		t.Fatalf("should keep valid escaped quotes inside identifier:\nIN:  %s\nOUT: %s", in, out)
+	}
+}
+
+func TestSanitizeSQLForPgLike_DoesNotTouchDollarQuotedStrings(t *testing.T) {
+	in := "SELECT $$\"\"ldf_server\"\"$$, \"\"ldf_server\"\""
+	out := sanitizeSQLForPgLike("postgres", in)
+	want := "SELECT $$\"\"ldf_server\"\"$$, \"ldf_server\""
+	if out != want {
+		t.Fatalf("unexpected sanitize output for dollar quoted string:\nIN:   %s\nOUT:  %s\nWANT: %s", in, out, want)
+	}
+}
+
+func TestSanitizeSQLForPgLike_DoesNotModifyOtherDBTypes(t *testing.T) {
+	in := `SELECT * FROM ""ldf_server""`
+	out := sanitizeSQLForPgLike("mysql", in)
+	if out != in {
+		t.Fatalf("non-PG-like db should not be sanitized:\nIN:  %s\nOUT: %s", in, out)
+	}
+}

internal/app/version.go

@@ -0,0 +1,53 @@
+package app
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var AppVersion = "0.0.0"
+var AppBuildTime = ""
+
+func getCurrentVersion() string {
+	version := strings.TrimSpace(AppVersion)
+	if version == "" || version == "0.0.0" {
+		if env := strings.TrimSpace(os.Getenv("GONAVI_VERSION")); env != "" {
+			version = env
+		} else if pkgVersion, err := readPackageVersion(); err == nil && pkgVersion != "" {
+			version = pkgVersion
+		}
+	}
+	return normalizeVersion(version)
+}
+
+func readPackageVersion() (string, error) {
+	paths := []string{
+		filepath.Join("frontend", "package.json"),
+	}
+	exe, err := os.Executable()
+	if err == nil {
+		base := filepath.Dir(exe)
+		paths = append(paths, filepath.Join(base, "frontend", "package.json"))
+		paths = append(paths, filepath.Join(base, "..", "frontend", "package.json"))
+	}
+
+	for _, p := range paths {
+		data, err := os.ReadFile(p)
+		if err != nil {
+			continue
+		}
+		var payload struct {
+			Version string `json:"version"`
+		}
+		if err := json.Unmarshal(data, &payload); err != nil {
+			continue
+		}
+		if strings.TrimSpace(payload.Version) != "" {
+			return strings.TrimSpace(payload.Version), nil
+		}
+	}
+
+	return "", os.ErrNotExist
+}

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

@@ -9,19 +9,44 @@ type SSHConfig struct {
 	KeyPath  string `json:"keyPath"`
 }
 
+// ProxyConfig holds proxy connection details
+type ProxyConfig struct {
+	Type     string `json:"type"` // socks5 | http
+	Host     string `json:"host"`
+	Port     int    `json:"port"`
+	User     string `json:"user,omitempty"`
+	Password string `json:"password,omitempty"`
+}
+
 // 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)
+	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"`
+	UseProxy             bool        `json:"useProxy,omitempty"`
+	Proxy                ProxyConfig `json:"proxy,omitempty"`
+	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
@@ -88,3 +113,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/clickhouse_impl.go

@@ -0,0 +1,603 @@
+//go:build gonavi_full_drivers || gonavi_clickhouse_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/ClickHouse/clickhouse-go/v2"
+)
+
+const (
+	defaultClickHousePort     = 9000
+	defaultClickHouseUser     = "default"
+	defaultClickHouseDatabase = "default"
+)
+
+type ClickHouseDB struct {
+	conn        *sql.DB
+	pingTimeout time.Duration
+	forwarder   *ssh.LocalForwarder
+	database    string
+}
+
+func normalizeClickHouseConfig(config connection.ConnectionConfig) connection.ConnectionConfig {
+	normalized := applyClickHouseURI(config)
+	if strings.TrimSpace(normalized.Host) == "" {
+		normalized.Host = "localhost"
+	}
+	if normalized.Port <= 0 {
+		normalized.Port = defaultClickHousePort
+	}
+	if strings.TrimSpace(normalized.User) == "" {
+		normalized.User = defaultClickHouseUser
+	}
+	if strings.TrimSpace(normalized.Database) == "" {
+		normalized.Database = defaultClickHouseDatabase
+	}
+	return normalized
+}
+
+func applyClickHouseURI(config connection.ConnectionConfig) connection.ConnectionConfig {
+	uriText := strings.TrimSpace(config.URI)
+	if uriText == "" {
+		return config
+	}
+	lowerURI := strings.ToLower(uriText)
+	if !strings.HasPrefix(lowerURI, "clickhouse://") {
+		return config
+	}
+
+	parsed, err := url.Parse(uriText)
+	if err != nil {
+		return config
+	}
+
+	if parsed.User != nil {
+		if strings.TrimSpace(config.User) == "" {
+			config.User = parsed.User.Username()
+		}
+		if pass, ok := parsed.User.Password(); ok && config.Password == "" {
+			config.Password = pass
+		}
+	}
+
+	if dbName := strings.TrimPrefix(strings.TrimSpace(parsed.Path), "/"); dbName != "" && strings.TrimSpace(config.Database) == "" {
+		config.Database = dbName
+	}
+	if strings.TrimSpace(config.Database) == "" {
+		if dbName := strings.TrimSpace(parsed.Query().Get("database")); dbName != "" {
+			config.Database = dbName
+		}
+	}
+
+	defaultPort := config.Port
+	if defaultPort <= 0 {
+		defaultPort = defaultClickHousePort
+	}
+	if strings.TrimSpace(config.Host) == "" {
+		host, port, ok := parseHostPortWithDefault(parsed.Host, defaultPort)
+		if ok {
+			config.Host = host
+			config.Port = port
+		}
+	}
+	if config.Port <= 0 {
+		config.Port = defaultPort
+	}
+	return config
+}
+
+func (c *ClickHouseDB) getDSN(config connection.ConnectionConfig) string {
+	u := &url.URL{
+		Scheme: "clickhouse",
+		Host:   net.JoinHostPort(config.Host, strconv.Itoa(config.Port)),
+		Path:   "/" + strings.TrimPrefix(strings.TrimSpace(config.Database), "/"),
+	}
+	if strings.TrimSpace(config.Password) != "" {
+		u.User = url.UserPassword(strings.TrimSpace(config.User), config.Password)
+	} else {
+		u.User = url.User(strings.TrimSpace(config.User))
+	}
+
+	timeoutSeconds := getConnectTimeoutSeconds(config)
+	query := u.Query()
+	query.Set("dial_timeout", fmt.Sprintf("%ds", timeoutSeconds))
+	query.Set("read_timeout", fmt.Sprintf("%ds", timeoutSeconds))
+	query.Set("write_timeout", fmt.Sprintf("%ds", timeoutSeconds))
+	u.RawQuery = query.Encode()
+	return u.String()
+}
+
+func (c *ClickHouseDB) Connect(config connection.ConnectionConfig) error {
+	if supported, reason := DriverRuntimeSupportStatus("clickhouse"); !supported {
+		if strings.TrimSpace(reason) == "" {
+			reason = "ClickHouse 纯 Go 驱动未启用，请先在驱动管理中安装启用"
+		}
+		return fmt.Errorf("%s", reason)
+	}
+
+	if c.forwarder != nil {
+		_ = c.forwarder.Close()
+		c.forwarder = nil
+	}
+	if c.conn != nil {
+		_ = c.conn.Close()
+		c.conn = nil
+	}
+
+	runConfig := normalizeClickHouseConfig(config)
+	c.pingTimeout = getConnectTimeout(runConfig)
+	c.database = runConfig.Database
+
+	if runConfig.UseSSH {
+		logger.Infof("ClickHouse 使用 SSH 连接：地址=%s:%d 用户=%s", runConfig.Host, runConfig.Port, runConfig.User)
+		forwarder, err := ssh.GetOrCreateLocalForwarder(runConfig.SSH, runConfig.Host, runConfig.Port)
+		if err != nil {
+			return fmt.Errorf("创建 SSH 隧道失败：%w", err)
+		}
+		c.forwarder = forwarder
+
+		host, portText, err := net.SplitHostPort(forwarder.LocalAddr)
+		if err != nil {
+			return fmt.Errorf("解析本地转发地址失败：%w", err)
+		}
+		port, err := strconv.Atoi(portText)
+		if err != nil {
+			return fmt.Errorf("解析本地端口失败：%w", err)
+		}
+
+		runConfig.Host = host
+		runConfig.Port = port
+		runConfig.UseSSH = false
+		logger.Infof("ClickHouse 通过本地端口转发连接：%s -> %s:%d", forwarder.LocalAddr, config.Host, config.Port)
+	}
+
+	dbConn, err := sql.Open("clickhouse", c.getDSN(runConfig))
+	if err != nil {
+		return fmt.Errorf("打开数据库连接失败：%w", err)
+	}
+	c.conn = dbConn
+
+	if err := c.Ping(); err != nil {
+		_ = c.Close()
+		return fmt.Errorf("连接建立后验证失败：%w", err)
+	}
+	return nil
+}
+
+func (c *ClickHouseDB) Close() error {
+	if c.forwarder != nil {
+		if err := c.forwarder.Close(); err != nil {
+			logger.Warnf("关闭 ClickHouse SSH 端口转发失败：%v", err)
+		}
+		c.forwarder = nil
+	}
+	if c.conn != nil {
+		return c.conn.Close()
+	}
+	return nil
+}
+
+func (c *ClickHouseDB) Ping() error {
+	if c.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+	timeout := c.pingTimeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	ctx, cancel := utils.ContextWithTimeout(timeout)
+	defer cancel()
+	return c.conn.PingContext(ctx)
+}
+
+func (c *ClickHouseDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if c.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+	rows, err := c.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (c *ClickHouseDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	if c.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+	rows, err := c.conn.Query(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+	return scanRows(rows)
+}
+
+func (c *ClickHouseDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if c.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := c.conn.ExecContext(ctx, query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (c *ClickHouseDB) Exec(query string) (int64, error) {
+	if c.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := c.conn.Exec(query)
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+func (c *ClickHouseDB) GetDatabases() ([]string, error) {
+	data, _, err := c.Query("SELECT name FROM system.databases ORDER BY name")
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]string, 0, len(data))
+	for _, row := range data {
+		if val, ok := getClickHouseValueFromRow(row, "name", "database"); ok {
+			result = append(result, fmt.Sprintf("%v", val))
+			continue
+		}
+		for _, value := range row {
+			result = append(result, fmt.Sprintf("%v", value))
+			break
+		}
+	}
+	return result, nil
+}
+
+func (c *ClickHouseDB) GetTables(dbName string) ([]string, error) {
+	targetDB := strings.TrimSpace(dbName)
+	if targetDB == "" {
+		targetDB = strings.TrimSpace(c.database)
+	}
+
+	var query string
+	if targetDB != "" {
+		query = fmt.Sprintf(
+			"SELECT name FROM system.tables WHERE database = '%s' ORDER BY name",
+			escapeClickHouseSQLLiteral(targetDB),
+		)
+	} else {
+		query = "SELECT database, name FROM system.tables ORDER BY database, name"
+	}
+
+	data, _, err := c.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]string, 0, len(data))
+	for _, row := range data {
+		if targetDB != "" {
+			if val, ok := getClickHouseValueFromRow(row, "name", "table", "table_name"); ok {
+				result = append(result, fmt.Sprintf("%v", val))
+				continue
+			}
+		} else {
+			databaseValue, hasDB := getClickHouseValueFromRow(row, "database", "schema_name")
+			tableValue, hasTable := getClickHouseValueFromRow(row, "name", "table", "table_name")
+			if hasDB && hasTable {
+				result = append(result, fmt.Sprintf("%v.%v", databaseValue, tableValue))
+				continue
+			}
+		}
+		for _, value := range row {
+			result = append(result, fmt.Sprintf("%v", value))
+			break
+		}
+	}
+	return result, nil
+}
+
+func (c *ClickHouseDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	database, table, err := c.resolveDatabaseAndTable(dbName, tableName)
+	if err != nil {
+		return "", err
+	}
+
+	query := fmt.Sprintf("SHOW CREATE TABLE %s.%s", quoteClickHouseIdentifier(database), quoteClickHouseIdentifier(table))
+	data, _, err := c.Query(query)
+	if err != nil {
+		return "", err
+	}
+	if len(data) == 0 {
+		return "", fmt.Errorf("create statement not found")
+	}
+	row := data[0]
+	if val, ok := getClickHouseValueFromRow(row, "statement", "create_statement", "sql", "query"); ok {
+		text := strings.TrimSpace(fmt.Sprintf("%v", val))
+		if text != "" {
+			return text, nil
+		}
+	}
+
+	longest := ""
+	for _, value := range row {
+		text := strings.TrimSpace(fmt.Sprintf("%v", value))
+		if text == "" {
+			continue
+		}
+		if strings.Contains(strings.ToUpper(text), "CREATE ") && len(text) > len(longest) {
+			longest = text
+		}
+	}
+	if longest != "" {
+		return longest, nil
+	}
+	return "", fmt.Errorf("create statement not found")
+}
+
+func (c *ClickHouseDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	database, table, err := c.resolveDatabaseAndTable(dbName, tableName)
+	if err != nil {
+		return nil, err
+	}
+
+	query := fmt.Sprintf(`
+SELECT
+    name,
+    type,
+    default_kind,
+    default_expression,
+    is_in_primary_key,
+    is_in_sorting_key,
+    comment
+FROM system.columns
+WHERE database = '%s' AND table = '%s'
+ORDER BY position`,
+		escapeClickHouseSQLLiteral(database),
+		escapeClickHouseSQLLiteral(table),
+	)
+	data, _, err := c.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	columns := make([]connection.ColumnDefinition, 0, len(data))
+	for _, row := range data {
+		nameValue, _ := getClickHouseValueFromRow(row, "name", "column_name")
+		typeValue, _ := getClickHouseValueFromRow(row, "type", "data_type")
+		defaultKind, _ := getClickHouseValueFromRow(row, "default_kind")
+		defaultExpr, hasDefault := getClickHouseValueFromRow(row, "default_expression", "column_default")
+		commentValue, _ := getClickHouseValueFromRow(row, "comment")
+		inPrimary, _ := getClickHouseValueFromRow(row, "is_in_primary_key")
+		inSorting, _ := getClickHouseValueFromRow(row, "is_in_sorting_key")
+
+		colType := strings.TrimSpace(fmt.Sprintf("%v", typeValue))
+		nullable := "NO"
+		if strings.HasPrefix(strings.ToLower(colType), "nullable(") {
+			nullable = "YES"
+		}
+
+		key := ""
+		if isClickHouseTruthy(inPrimary) {
+			key = "PRI"
+		} else if isClickHouseTruthy(inSorting) {
+			key = "MUL"
+		}
+
+		extra := ""
+		kindText := strings.ToUpper(strings.TrimSpace(fmt.Sprintf("%v", defaultKind)))
+		if kindText != "" && kindText != "DEFAULT" {
+			extra = kindText
+		}
+
+		col := connection.ColumnDefinition{
+			Name:     strings.TrimSpace(fmt.Sprintf("%v", nameValue)),
+			Type:     colType,
+			Nullable: nullable,
+			Key:      key,
+			Extra:    extra,
+			Comment:  strings.TrimSpace(fmt.Sprintf("%v", commentValue)),
+		}
+		if hasDefault && defaultExpr != nil {
+			text := strings.TrimSpace(fmt.Sprintf("%v", defaultExpr))
+			if text != "" {
+				col.Default = &text
+			}
+		}
+		columns = append(columns, col)
+	}
+	return columns, nil
+}
+
+func (c *ClickHouseDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	targetDB := strings.TrimSpace(dbName)
+	if targetDB == "" {
+		targetDB = strings.TrimSpace(c.database)
+	}
+
+	var query string
+	if targetDB != "" {
+		query = fmt.Sprintf(`
+SELECT
+    database,
+    table,
+    name,
+    type
+FROM system.columns
+WHERE database = '%s'
+ORDER BY table, position`,
+			escapeClickHouseSQLLiteral(targetDB),
+		)
+	} else {
+		query = `
+SELECT
+    database,
+    table,
+    name,
+    type
+FROM system.columns
+WHERE database NOT IN ('system', 'information_schema', 'INFORMATION_SCHEMA')
+ORDER BY database, table, position`
+	}
+
+	data, _, err := c.Query(query)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]connection.ColumnDefinitionWithTable, 0, len(data))
+	for _, row := range data {
+		databaseValue, _ := getClickHouseValueFromRow(row, "database")
+		tableValue, hasTable := getClickHouseValueFromRow(row, "table", "table_name")
+		nameValue, hasName := getClickHouseValueFromRow(row, "name", "column_name")
+		typeValue, _ := getClickHouseValueFromRow(row, "type", "data_type")
+		if !hasTable || !hasName {
+			continue
+		}
+
+		tableName := strings.TrimSpace(fmt.Sprintf("%v", tableValue))
+		if targetDB == "" {
+			dbText := strings.TrimSpace(fmt.Sprintf("%v", databaseValue))
+			if dbText != "" {
+				tableName = dbText + "." + tableName
+			}
+		}
+
+		result = append(result, connection.ColumnDefinitionWithTable{
+			TableName: tableName,
+			Name:      strings.TrimSpace(fmt.Sprintf("%v", nameValue)),
+			Type:      strings.TrimSpace(fmt.Sprintf("%v", typeValue)),
+		})
+	}
+	return result, nil
+}
+
+func (c *ClickHouseDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	return []connection.IndexDefinition{}, nil
+}
+
+func (c *ClickHouseDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	return []connection.ForeignKeyDefinition{}, nil
+}
+
+func (c *ClickHouseDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	return []connection.TriggerDefinition{}, nil
+}
+
+func (c *ClickHouseDB) resolveDatabaseAndTable(dbName, tableName string) (string, string, error) {
+	rawTable := strings.TrimSpace(tableName)
+	if rawTable == "" {
+		return "", "", fmt.Errorf("table name required")
+	}
+
+	resolvedDB := strings.TrimSpace(dbName)
+	resolvedTable := rawTable
+	if parts := strings.SplitN(rawTable, ".", 2); len(parts) == 2 {
+		if dbPart := normalizeClickHouseIdentifierPart(parts[0]); dbPart != "" {
+			resolvedDB = dbPart
+		}
+		resolvedTable = normalizeClickHouseIdentifierPart(parts[1])
+	} else {
+		resolvedTable = normalizeClickHouseIdentifierPart(rawTable)
+	}
+
+	if resolvedDB == "" {
+		resolvedDB = strings.TrimSpace(c.database)
+	}
+	if resolvedDB == "" {
+		resolvedDB = defaultClickHouseDatabase
+	}
+	if resolvedTable == "" {
+		return "", "", fmt.Errorf("table name required")
+	}
+	return resolvedDB, resolvedTable, nil
+}
+
+func normalizeClickHouseIdentifierPart(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 = text[1 : len(text)-1]
+		}
+	}
+	return strings.TrimSpace(text)
+}
+
+func quoteClickHouseIdentifier(raw string) string {
+	return "`" + strings.ReplaceAll(strings.TrimSpace(raw), "`", "``") + "`"
+}
+
+func escapeClickHouseSQLLiteral(raw string) string {
+	return strings.ReplaceAll(strings.TrimSpace(raw), "'", "''")
+}
+
+func getClickHouseValueFromRow(row map[string]interface{}, keys ...string) (interface{}, bool) {
+	if len(row) == 0 {
+		return nil, false
+	}
+	for _, key := range keys {
+		if value, ok := row[key]; ok {
+			return value, true
+		}
+	}
+	for existingKey, value := range row {
+		for _, key := range keys {
+			if strings.EqualFold(existingKey, key) {
+				return value, true
+			}
+		}
+	}
+	return nil, false
+}
+
+func isClickHouseTruthy(value interface{}) bool {
+	switch val := value.(type) {
+	case bool:
+		return val
+	case int:
+		return val != 0
+	case int8:
+		return val != 0
+	case int16:
+		return val != 0
+	case int32:
+		return val != 0
+	case int64:
+		return val != 0
+	case uint:
+		return val != 0
+	case uint8:
+		return val != 0
+	case uint16:
+		return val != 0
+	case uint32:
+		return val != 0
+	case uint64:
+		return val != 0
+	case string:
+		normalized := strings.ToLower(strings.TrimSpace(val))
+		return normalized == "1" || normalized == "true" || normalized == "yes" || normalized == "y"
+	default:
+		normalized := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", value)))
+		return normalized == "1" || normalized == "true" || normalized == "yes" || normalized == "y"
+	}
+}

internal/db/custom_impl.go

@@ -1,6 +1,7 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"strings"
@@ -57,6 +58,20 @@ func (c *CustomDB) Ping() error {
 	return c.conn.PingContext(ctx)
 }
 
+func (c *CustomDB) QueryContext(ctx context.Context, query string) ([]map[string]interface{}, []string, error) {
+	if c.conn == nil {
+		return nil, nil, fmt.Errorf("connection not open")
+	}
+
+	rows, err := c.conn.QueryContext(ctx, query)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	return scanRows(rows)
+}
+
 func (c *CustomDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if c.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -67,33 +82,18 @@ func (c *CustomDB) Query(query string) ([]map[string]interface{}, []string, erro
 		return nil, nil, err
 	}
 	defer rows.Close()
+	return scanRows(rows)
+}
 
-	columns, err := rows.Columns()
+func (c *CustomDB) ExecContext(ctx context.Context, query string) (int64, error) {
+	if c.conn == nil {
+		return 0, fmt.Errorf("connection not open")
+	}
+	res, err := c.conn.ExecContext(ctx, query)
 	if err != nil {
-		return nil, nil, err
+		return 0, err
 	}
-
-	var resultData []map[string]interface{}
-
-	for rows.Next() {
-		values := make([]interface{}, len(columns))
-		valuePtrs := make([]interface{}, len(columns))
-		for i := range columns {
-			valuePtrs[i] = &values[i]
-		}
-
-		if err := rows.Scan(valuePtrs...); err != nil {
-			continue
-		}
-
-		entry := make(map[string]interface{})
-		for i, col := range columns {
-			entry[col] = normalizeQueryValue(values[i])
-		}
-		resultData = append(resultData, entry)
-	}
-
-	return resultData, columns, nil
+	return res.RowsAffected()
 }
 
 func (c *CustomDB) Exec(query string) (int64, error) {
@@ -248,7 +248,141 @@ func (c *CustomDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDe
 }
 
 func (c *CustomDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
-	return fmt.Errorf("read-only mode for custom")
+	if c.conn == nil {
+		return fmt.Errorf("connection not open")
+	}
+
+	tx, err := c.conn.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	driver := strings.ToLower(strings.TrimSpace(c.driver))
+	isMySQL := strings.Contains(driver, "mysql")
+	isPostgres := strings.Contains(driver, "postgres") || strings.Contains(driver, "kingbase") || strings.Contains(driver, "pg")
+	isOracle := strings.Contains(driver, "oracle") || strings.Contains(driver, "ora") || strings.Contains(driver, "dm") || strings.Contains(driver, "dameng")
+
+	quoteIdent := func(name string) string {
+		n := strings.TrimSpace(name)
+		if isMySQL {
+			n = strings.Trim(n, "`")
+			n = strings.ReplaceAll(n, "`", "``")
+			if n == "" {
+				return "``"
+			}
+			return "`" + n + "`"
+		}
+		n = strings.Trim(n, "\"")
+		n = strings.ReplaceAll(n, "\"", "\"\"")
+		if n == "" {
+			return "\"\""
+		}
+		return `"` + n + `"`
+	}
+
+	placeholder := func(idx int) string {
+		if isPostgres {
+			return fmt.Sprintf("$%d", idx)
+		}
+		if isOracle {
+			return fmt.Sprintf(":%d", idx)
+		}
+		// MySQL / SQLite / default
+		return "?"
+	}
+
+	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 = %s", quoteIdent(k), placeholder(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 = %s", quoteIdent(k), placeholder(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 = %s", quoteIdent(k), placeholder(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, placeholder(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()
 }
 
 func (c *CustomDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {

internal/db/dameng_impl.go

@@ -1,6 +1,9 @@
+//go:build gonavi_full_drivers || gonavi_dameng_driver
+
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"net"
@@ -10,6 +13,7 @@ import (
 	"time"
 
 	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
 	"GoNavi-Wails/internal/ssh"
 	"GoNavi-Wails/internal/utils"
 
@@ -19,6 +23,7 @@ import (
 type DamengDB struct {
 	conn        *sql.DB
 	pingTimeout time.Duration
+	forwarder   *ssh.LocalForwarder // Store SSH tunnel forwarder
 }
 
 func (d *DamengDB) getDSN(config connection.ConnectionConfig) string {
@@ -26,16 +31,6 @@ func (d *DamengDB) getDSN(config connection.ConnectionConfig) string {
 	// or dm://user:password@host:port
 
 	address := net.JoinHostPort(config.Host, strconv.Itoa(config.Port))
-	if config.UseSSH {
-		// SSH logic similar to others, assumes port forwarding
-		_, err := ssh.RegisterSSHNetwork(config.SSH)
-		if err == nil {
-			// DM driver likely uses standard net.Dial, so we might need a local listener
-			// or assume port forwarding is handled externally or implicitly via "tcp" override if driver allows.
-			// Similar to Oracle, we skip complex custom dialer injection for now.
-		}
-	}
-
 	escapedPassword := url.PathEscape(config.Password)
 	q := url.Values{}
 	if config.Database != "" {
@@ -55,7 +50,42 @@ func (d *DamengDB) getDSN(config connection.ConnectionConfig) string {
 }
 
 func (d *DamengDB) Connect(config connection.ConnectionConfig) error {
-	dsn := d.getDSN(config)
+	var dsn string
+	var err error
+
+	if config.UseSSH {
+		// Create SSH tunnel with local port forwarding
+		logger.Infof("达梦数据库使用 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)
+		}
+		d.forwarder = forwarder
+
+		// Parse local address
+		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)
+		}
+
+		// Create a modified config pointing to local forwarder
+		localConfig := config
+		localConfig.Host = host
+		localConfig.Port = port
+		localConfig.UseSSH = false
+
+		dsn = d.getDSN(localConfig)
+		logger.Infof("达梦数据库通过本地端口转发连接：%s -> %s:%d", forwarder.LocalAddr, config.Host, config.Port)
+	} else {
+		dsn = d.getDSN(config)
+	}
+
 	db, err := sql.Open("dm", dsn)
 	if err != nil {
 		return fmt.Errorf("打开数据库连接失败：%w", err)
@@ -69,6 +99,15 @@ func (d *DamengDB) Connect(config connection.ConnectionConfig) error {
 }
 
 func (d *DamengDB) Close() error {
+	// Close SSH forwarder first if exists
+	if d.forwarder != nil {
+		if err := d.forwarder.Close(); err != nil {
+			logger.Warnf("关闭达梦数据库 SSH 端口转发失败：%v", err)
+		}
+		d.forwarder = nil
+	}
+
+	// Then close database connection
 	if d.conn != nil {
 		return d.conn.Close()
 	}
@@ -88,6 +127,20 @@ func (d *DamengDB) Ping() error {
 	return d.conn.PingContext(ctx)
 }
 
+func (d *DamengDB) 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 *DamengDB) Query(query string) ([]map[string]interface{}, []string, error) {
 	if d.conn == nil {
 		return nil, nil, fmt.Errorf("connection not open")
@@ -98,33 +151,18 @@ func (d *DamengDB) Query(query string) ([]map[string]interface{}, []string, erro
 		return nil, nil, err
 	}
 	defer rows.Close()
+	return scanRows(rows)
+}
 
-	columns, err := rows.Columns()
+func (d *DamengDB) 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 nil, nil, err
+		return 0, err
 	}
-
-	var resultData []map[string]interface{}
-
-	for rows.Next() {
-		values := make([]interface{}, len(columns))
-		valuePtrs := make([]interface{}, len(columns))
-		for i := range columns {
-			valuePtrs[i] = &values[i]
-		}
-
-		if err := rows.Scan(valuePtrs...); err != nil {
-			continue
-		}
-
-		entry := make(map[string]interface{})
-		for i, col := range columns {
-			entry[col] = normalizeQueryValue(values[i])
-		}
-		resultData = append(resultData, entry)
-	}
-
-	return resultData, columns, nil
+	return res.RowsAffected()
 }
 
 func (d *DamengDB) Exec(query string) (int64, error) {
@@ -337,7 +375,117 @@ func (d *DamengDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDe
 }
 
 func (d *DamengDB) ApplyChanges(tableName string, changes connection.ChangeSet) error {
-	return fmt.Errorf("read-only mode implemented for Dameng so far")
+	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 := ""
+	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()
 }
 
 func (d *DamengDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {

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,19 @@
+//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")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("clickhouse"), "clickhouse")
+}

internal/db/database_optional_factories_lite.go

@@ -0,0 +1,19 @@
+//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")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("clickhouse"), "clickhouse")
+}

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,225 @@
+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":   {},
+	"clickhouse": {},
+}
+
+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"
+	case "clickhouse":
+		return "ClickHouse"
+	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,47 @@ 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)
+	}
+}
+
+func TestClickHouseDSN_EscapesPasswordAndSetsTimeout(t *testing.T) {
+	c := &ClickHouseDB{}
+	cfg := normalizeClickHouseConfig(connection.ConnectionConfig{
+		Type:     "clickhouse",
+		Host:     "127.0.0.1",
+		Port:     9000,
+		User:     "default",
+		Password: "p@ss:wo/rd",
+		Database: "analytics",
+		Timeout:  15,
+	})
+
+	dsn := c.getDSN(cfg)
+	if strings.Contains(dsn, cfg.Password) {
+		t.Fatalf("dsn 包含原始密码：%s", dsn)
+	}
+	if !strings.Contains(dsn, "p%40ss%3Awo%2Frd") {
+		t.Fatalf("dsn 未正确转义密码：%s", dsn)
+	}
+	if !strings.Contains(dsn, "dial_timeout=15s") {
+		t.Fatalf("dsn 缺少 dial_timeout 参数：%s", dsn)
+	}
+	if !strings.Contains(dsn, "/analytics") {
+		t.Fatalf("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)
+}