📝 docs(i18n-readme): 建立README中英双文档结构并统一能力描述

- 英文主 README 覆盖项目定位、性能特性与安装说明 - 中文 README 覆盖同等信息密度，避免内容断层 - 中英文文档统一支持数据源表格与驱动模式说明 - 完成语言切换链接配置，便于读者快速切换
🎨 style(connection-modal): 优化新建连接弹窗尺寸与分类栏视觉一致性
2026-05-12 20:29:43 +08:00 · 2026-02-28 15:54:46 +08:00 · 2026-02-28 15:36:26 +08:00 · 2026-02-28 15:27:58 +08:00 · 2026-02-28 15:00:13 +08:00 · 2026-02-28 13:55:42 +08:00
60 changed files with 8868 additions and 852 deletions
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -22,26 +22,56 @@ jobs:
            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
            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
            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
@@ -63,7 +93,17 @@ jobs:
        if: contains(matrix.platform, 'linux')
        run: |
          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libfuse2
+          sudo apt-get install -y libgtk-3-dev
+
+          # WebKitGTK 4.1 需要 libsoup3；4.0 使用 libsoup2（通常由 webkit2gtk dev 包拉起）
+          if [ "${{ matrix.linux_webkit }}" = "4.1" ]; then
+            sudo apt-get install -y libwebkit2gtk-4.1-dev libsoup-3.0-dev
+          else
+            sudo apt-get install -y libwebkit2gtk-4.0-dev
+          fi
+
+          # AppImage 运行/打包可能需要 FUSE2。不同发行版/版本包名不同，做兼容兜底。
+          sudo apt-get install -y libfuse2 || sudo apt-get install -y libfuse2t64 || true

          # Download linuxdeploy tools for AppImage packaging
          LINUXDEPLOY_URL="https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
@@ -94,21 +134,31 @@ jobs:
      - name: Build
        shell: bash
        run: |
-          wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.build_name }} -ldflags "-s -w -X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"
+          set -euo pipefail
+          TAG_ARGS=()
+          if [ -n "${{ matrix.wails_tags }}" ]; then
+            TAG_ARGS+=(-tags "${{ matrix.wails_tags }}")
+          fi
+          wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.build_name }} "${TAG_ARGS[@]}" -ldflags "-s -w -X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"

      - name: Build Optional Driver Agents
+        if: ${{ matrix.build_optional_agents }}
        shell: bash
        run: |
          set -euo pipefail
          TARGET_PLATFORM="${{ matrix.platform }}"
          GOOS="${TARGET_PLATFORM%%/*}"
          GOARCH="${TARGET_PLATFORM##*/}"
-          DRIVERS=(mariadb diros sphinx sqlserver sqlite duckdb dameng kingbase highgo vastbase mongodb tdengine)
+          DRIVERS=(mariadb doris 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"
+            BUILD_DRIVER="$DRIVER"
+            if [ "$DRIVER" = "doris" ]; then
+              BUILD_DRIVER="diros"
+            fi
+            TAG="gonavi_${BUILD_DRIVER}_driver"
            OUTPUT="${DRIVER}-driver-agent-${GOOS}-${GOARCH}"
            if [ "$GOOS" = "windows" ]; then
              OUTPUT="${OUTPUT}.exe"
@@ -157,10 +207,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.build_name }}.dmg"
-          FINAL_NAME="GoNavi-$VERSION-${{ matrix.os_name }}-${{ matrix.arch_name }}.dmg"
+          FINAL_NAME="GoNavi-$VERSION-${{ matrix.os_name }}-${{ matrix.arch_name }}${{ matrix.artifact_suffix }}.dmg"
          echo "📦 正在生成 DMG: $DMG_NAME..."
          
          create-dmg \
@@ -187,8 +239,8 @@ jobs:
              $version = $version.Substring(1)
          }
          $target = "${{ matrix.build_name }}"
-          $finalExeName = "GoNavi-$version-${{ matrix.os_name }}-${{ matrix.arch_name }}.exe"
-          $finalZipName = "GoNavi-$version-${{ matrix.os_name }}-${{ matrix.arch_name }}.zip"
+          $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"
@@ -214,8 +266,8 @@ jobs:
          VERSION="${VERSION#v}"
          cd build/bin
          TARGET="${{ matrix.build_name }}"
-          TAR_NAME="GoNavi-$VERSION-${{ matrix.os_name }}-${{ matrix.arch_name }}.tar.gz"
-          APPIMAGE_NAME="GoNavi-$VERSION-${{ matrix.os_name }}-${{ matrix.arch_name }}.AppImage"
+          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'!"
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# GoNavi - 现代化的轻量级数据库管理工具
+# GoNavi - A Modern Lightweight Database Client

 [![Go Version](https://img.shields.io/github/go-mod/go-version/Syngnat/GoNavi)](https://go.dev/)
 [![Wails Version](https://img.shields.io/badge/Wails-v2-red)](https://wails.io)
@@ -6,11 +6,51 @@
 [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](LICENSE)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/Syngnat/GoNavi/release.yml?label=Build)](https://github.com/Syngnat/GoNavi/actions)

-**GoNavi** 是一款基于 **Wails (Go)** 和 **React** 构建的现代化、高性能、跨平台数据库管理客户端。它旨在提供如原生应用般流畅的用户体验，同时保持极低的资源占用。
+**Language**: English | [简体中文](README.zh-CN.md)

-相比于 Electron 应用，GoNavi 的体积更小（~10MB），启动速度更快，内存占用更低。
+GoNavi is a modern, high-performance, cross-platform database client built with **Wails (Go)** and **React**.
+It delivers native-like responsiveness with low resource usage.

-<h2 align="center">📸 项目截图</h2>
+Compared with many Electron-based clients, GoNavi is typically smaller in binary size (around 10MB class), starts faster, and uses less memory.
+
+---
+
+## Project Overview
+
+GoNavi is designed for developers and DBAs who need a unified desktop experience across multiple databases.
+
+- **Native-performance architecture**: Wails (Go + WebView) with lightweight runtime overhead.
+- **Large dataset usability**: virtualized rendering and optimized DataGrid workflows for high-volume tables.
+- **Unified connectivity**: URI build/parse, SSH tunnel, proxy support, and on-demand driver activation.
+- **Production-oriented workflow**: SQL editor, object management, batch export/backup, sync tools, execution logs, and update checks.
+
+## Supported Data Sources
+
+> `Built-in`: available out of the box.  
+> `Optional driver agent`: install/enable via Driver Manager first.
+
+| Category | Data Source | Driver Mode | Typical Capabilities |
+|---|---|---|---|
+| Relational | MySQL | Built-in | Schema browsing, SQL query, data editing, export/backup |
+| Relational | PostgreSQL | Built-in | Schema browsing, SQL query, data editing, object management |
+| Relational | Oracle | Built-in | Query execution, object browsing, data editing |
+| Cache | Redis | Built-in | Key browsing, command execution, encoding/view switch |
+| Relational | MariaDB | Optional driver agent | Querying, object management, data editing |
+| Relational | Doris | Optional driver agent | Querying, object browsing, SQL execution |
+| Search | Sphinx | Optional driver agent | SphinxQL querying and object browsing |
+| Relational | SQL Server | Optional driver agent | Schema browsing, SQL query, object management |
+| File-based | SQLite | Optional driver agent | Local DB browsing, editing, export |
+| File-based | DuckDB | Optional driver agent | Large-table query, pagination, file-DB workflow |
+| Domestic DB | Dameng | Optional driver agent | Querying, object browsing, data editing |
+| Domestic DB | Kingbase | Optional driver agent | Querying, object browsing, data editing |
+| Domestic DB | HighGo | Optional driver agent | Querying, object browsing, data editing |
+| Domestic DB | Vastbase | Optional driver agent | Querying, object browsing, data editing |
+| Document | MongoDB | Optional driver agent | Document query, collection browsing, connection management |
+| Time-series | TDengine | Optional driver agent | Time-series schema browsing and querying |
+| Columnar Analytics | ClickHouse | Optional driver agent | Analytical query, object browsing, SQL execution |
+| Extensibility | Custom Driver/DSN | Custom | Extend to more data sources via Driver + DSN |
+
+<h2 align="center">📸 Screenshots</h2>

 <div align="center">
    <img width="25%" alt="image" src="https://github.com/user-attachments/assets/341cda98-79a5-4198-90f3-1335131ccde0" />
@@ -24,140 +64,148 @@

 ---

-## ✨ 核心特性
+## Key Features

-### 🚀 极致性能
- **零卡顿交互**：采用独创的 "幽灵拖拽" (Ghost Resizing) 技术，在包含数万行数据的表格中调整列宽，依然保持 60fps+ 的丝滑体验。
- **虚拟滚动**：轻松处理海量数据展示，拒绝卡顿。
+### Performance
+- **Smooth interaction under load**: optimized table interaction (including column resize workflow on large datasets).
+- **Virtualized rendering**: keeps large result sets responsive.

-### 🔌 多数据库支持
- **MySQL**：完整支持，涵盖数据编辑、结构管理与导入导出。
- **PostgreSQL**：数据查看与编辑支持，事务提交能力持续完善。
- **SQLite**：本地文件数据库支持。
- **Oracle**：基础数据访问与编辑支持。
- **Dameng（达梦）**：基础数据访问与编辑支持。
- **Kingbase（人大金仓）**：基础数据访问与编辑支持。
- **TDengine**：时序数据库连接、库表浏览与 SQL 查询支持。
- **Redis**：Key/Value 浏览、命令执行、视图与编码切换。
- **自定义驱动**：支持配置 Driver/DSN 接入更多数据源。
- **SSH 隧道**：内置 SSH 隧道支持，安全连接内网数据库。
+### Data Management (DataGrid)
+- In-place cell editing.
+- Batch insert/update/delete with transaction-oriented submit/rollback.
+- Large-field popup editor.
+- Context actions (set NULL, copy/export, etc.).
+- Smart read/write mode switching based on query context.
+- Export formats: CSV, Excel (XLSX), JSON, Markdown.

-### 📊 强大的数据管理 (DataGrid)
- **所见即所得编辑**：直接在表格中双击单元格修改数据。
- **批量事务操作**：支持批量新增、修改、删除，一键提交或回滚事务。
- **大字段编辑**：双击大字段自动打开弹窗编辑器，避免卡顿。
- **右键上下文菜单**：快速设置 NULL、复制/导出等操作。
- **智能上下文**：自动识别单表查询，解锁编辑功能；复杂查询自动切换为只读模式。
- **批量导出/备份**：支持表与数据库的批量导出/备份。
- **数据导出**：支持 CSV、Excel (XLSX)、JSON、Markdown 等格式。
+### SQL Editor
+- Monaco Editor core.
+- Context-aware completion for databases/tables/columns.
+- Multi-tab query workflow.

-### 🧰 批量导出/备份
- **数据库批量导出**：支持结构导出与结构+数据备份。
- **表批量导出**：支持多表一键导出/备份。
- **智能上下文检测**：自动判断目标范围，避免误操作。
+### Batch Export / Backup
+- Database-level and table-level batch export/backup.
+- Scope-aware operation flow to reduce mistakes.

-### 🧩 Redis 视图与编码
- **视图模式切换**：自动/原始文本/UTF-8/十六进制多模式显示。
- **智能解码**：针对二进制值进行 UTF-8 质量判定与中文字符识别。
- **命令执行**：内置命令面板快速操作。
+### Connectivity
+- URI generation/parsing.
+- SSH tunnel support.
+- Proxy support.
+- Config import/export (JSON).
+- Optional driver management and activation.

-### 🔄 数据同步与导入导出
- **连接配置导入/导出**：支持配置 JSON 导入导出，便于团队共享。
- **数据同步**：内置数据同步面板，支持跨库同步任务配置。
+### Redis Tools
+- Multi-view value rendering (auto/raw text/UTF-8/hex).
+- Built-in command execution panel.

-### 🆙 在线更新
- **自动更新**：启动/定时/手动检查更新，自动下载并提示重启完成更新。
+### Observability and Update
+- SQL execution logs with timing information.
+- Startup/scheduled/manual update checks.

-### 🧾 可观测性
- **SQL 执行日志**：实时查看 SQL 与执行耗时，便于排障与优化。
-
-### 📝 智能 SQL 编辑器
- **Monaco Editor 内核**：集成 VS Code 同款编辑器，体验极佳。
- **智能补全**：自动感知当前连接上下文，提供数据库、表名、字段名的实时补全。
- **多标签页**：支持多窗口并行操作，像浏览器一样管理你的查询会话。
-
-### 🎨 现代化 UI
- **Ant Design 5**：企业级 UI 设计语言。
- **暗黑模式**：内置深色/浅色主题切换，适应不同光照环境。
- **响应式布局**：灵活的侧边栏与布局调整。
+### UI/UX
+- Ant Design 5 based interface.
+- Light/Dark themes.
+- Flexible sidebar and layout behavior.

 ---

-## 🛠️ 技术栈
+## Tech Stack

-*   **后端 (Backend)**: Go 1.24 + Wails v2
-*   **前端 (Frontend)**: React 18 + TypeScript + Vite
-*   **UI 框架**: Ant Design 5
-*   **状态管理**: Zustand
-*   **编辑器**: Monaco Editor
+- **Backend**: Go 1.24 + Wails v2
+- **Frontend**: React 18 + TypeScript + Vite
+- **UI**: Ant Design 5
+- **State Management**: Zustand
+- **Editor**: Monaco Editor

 ---

-## 📦 安装与运行
+## Installation and Run

-### 前置要求
-*   [Go](https://go.dev/dl/) 1.21+
-*   [Node.js](https://nodejs.org/) 18+
-*   [Wails CLI](https://wails.io/docs/gettingstarted/installation): `go install github.com/wailsapp/wails/v2/cmd/wails@latest`
+### Prerequisites
+- [Go](https://go.dev/dl/) 1.21+
+- [Node.js](https://nodejs.org/) 18+
+- [Wails CLI](https://wails.io/docs/gettingstarted/installation):
+  `go install github.com/wailsapp/wails/v2/cmd/wails@latest`

-### 开发模式
+### Development Mode

 ```bash
-# 克隆项目
+# Clone
 git clone https://github.com/Syngnat/GoNavi.git
 cd GoNavi

-# 启动开发服务器 (支持热重载)
+# Start development with hot reload
 wails dev
 ```

-### 编译构建
+### Build

 ```bash
-# 构建当前平台的可执行文件
+# Build for current platform
 wails build

-# 清理并构建 (推荐发布前使用)
+# Clean build (recommended before release)
 wails build -clean
 ```

-构建产物将位于 `build/bin` 目录下。
+Artifacts are generated in `build/bin`.

-### 跨平台编译 (GitHub Actions)
+### Cross-Platform Release (GitHub Actions)

-本项目内置了 GitHub Actions 流水线，Push `v*` 格式的 Tag 即可自动触发构建并发布 Release。
-支持构建：
-*   macOS (AMD64 / ARM64)
-*   Windows (AMD64)
+The repository includes a release workflow.
+Push a `v*` tag to trigger automated build and release.
+
+Target artifacts include:
+- macOS (AMD64 / ARM64)
+- Windows (AMD64)
+- Linux (AMD64, WebKitGTK 4.0 and 4.1 variants)

 ---

-## ❓ 常见问题 (Troubleshooting)
+## Troubleshooting

-### macOS 提示 "应用已损坏，无法打开"
+### macOS: "App is damaged and can’t be opened"

-由于本项目尚未购买 Apple 开发者证书进行签名（Notarization），macOS 的 Gatekeeper 安全机制可能会拦截应用的运行。请按照以下步骤解决：
+Without Apple notarization, Gatekeeper may block startup.

-1.  将下载的 `GoNavi.app` 拖入 **应用程序** 文件夹。
-2.  打开 **终端 (Terminal)**。
-3.  复制并执行以下命令（输入密码时不会显示）：
-    ```bash
-    sudo xattr -rd com.apple.quarantine /Applications/GoNavi.app
-    ```
-4.  或者：在 Finder 中右键点击应用图标，按住 `Control` 键选择 **打开**，然后在弹出的窗口中再次点击 **打开**。
+1. Move `GoNavi.app` to **Applications**.
+2. Open **Terminal**.
+3. Run:
+
+```bash
+sudo xattr -rd com.apple.quarantine /Applications/GoNavi.app
+```
+
+Or right-click the app in Finder and choose **Open** with Control key flow.
+
+### Linux: missing `libwebkit2gtk` / `libjavascriptcoregtk`
+
+GoNavi depends on WebKitGTK runtime libraries.
+
+```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
+```
+
+If you use Linux artifacts with the `-WebKit41` suffix, prefer Debian 13 / Ubuntu 24.04+.

 ---

-## 🤝 贡献指南
+## Contributing

-欢迎提交 Issue 和 Pull Request！
+Issues and pull requests are welcome.

-1.  Fork 本仓库
-2.  创建你的特性分支 (`git checkout -b feature/AmazingFeature`)
-3.  提交你的改动 (`git commit -m 'feat: Add some AmazingFeature'`)
-4.  推送到分支 (`git push origin feature/AmazingFeature`)
-5.  开启一个 Pull Request
+1. Fork the repository.
+2. Create a feature branch.
+3. Commit your changes.
+4. Push to your branch.
+5. Open a pull request.

-## 📄 开源协议
+## License

-本项目采用 [Apache-2.0 协议](LICENSE) 开源。
+Licensed under [Apache-2.0](LICENSE).
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -0,0 +1,194 @@
+# GoNavi - 现代化轻量级数据库客户端
+
+[![Go Version](https://img.shields.io/github/go-mod/go-version/Syngnat/GoNavi)](https://go.dev/)
+[![Wails Version](https://img.shields.io/badge/Wails-v2-red)](https://wails.io)
+[![React Version](https://img.shields.io/badge/React-v18-blue)](https://reactjs.org/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](LICENSE)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/Syngnat/GoNavi/release.yml?label=Build)](https://github.com/Syngnat/GoNavi/actions)
+
+**语言**: [English](README.md) | 简体中文
+
+GoNavi 是基于 **Wails (Go)** 与 **React** 构建的跨平台数据库管理工具，强调原生性能、低资源占用与多数据源统一工作流。
+
+相比常见 Electron 客户端，GoNavi 在体积、启动速度和内存占用上更轻量。
+
+---
+
+## 项目简介
+
+GoNavi 面向开发者与 DBA，核心目标是让数据库操作在桌面端做到“快、稳、统一”。
+
+- **原生性能架构**：Wails（Go + WebView），降低运行时开销。
+- **大数据可用性**：虚拟滚动 + DataGrid 交互优化，提升大结果集可操作性。
+- **统一连接能力**：支持 URI 生成/解析、SSH 隧道、代理、驱动按需安装。
+- **工程化能力完整**：覆盖 SQL 编辑、对象管理、批量导出/备份、数据同步、执行日志、在线更新。
+
+## 支持的数据源
+
+> `内置`：主程序开箱即用。  
+> `可选驱动代理`：需在驱动管理中安装启用后可用。
+
+| 类别 | 数据源 | 驱动模式 | 典型能力 |
+|---|---|---|---|
+| 关系型 | MySQL | 内置 | 库表浏览、SQL 查询、数据编辑、导出/备份 |
+| 关系型 | PostgreSQL | 内置 | 库表浏览、SQL 查询、数据编辑、对象管理 |
+| 关系型 | Oracle | 内置 | 连接查询、对象浏览、数据编辑 |
+| 缓存 | Redis | 内置 | Key 浏览、命令执行、编码/视图切换 |
+| 关系型 | MariaDB | 可选驱动代理 | 连接查询、对象管理、数据编辑 |
+| 关系型 | Doris | 可选驱动代理 | 连接查询、对象浏览、SQL 执行 |
+| 搜索 | Sphinx | 可选驱动代理 | SphinxQL 查询与对象浏览 |
+| 关系型 | SQL Server | 可选驱动代理 | 库表浏览、SQL 查询、对象管理 |
+| 文件型 | SQLite | 可选驱动代理 | 本地文件库浏览、编辑、导出 |
+| 文件型 | DuckDB | 可选驱动代理 | 大表查询、分页浏览、文件库管理 |
+| 国产数据库 | Dameng | 可选驱动代理 | 连接查询、对象浏览、数据编辑 |
+| 国产数据库 | Kingbase | 可选驱动代理 | 连接查询、对象浏览、数据编辑 |
+| 国产数据库 | HighGo | 可选驱动代理 | 连接查询、对象浏览、数据编辑 |
+| 国产数据库 | Vastbase | 可选驱动代理 | 连接查询、对象浏览、数据编辑 |
+| 文档型 | MongoDB | 可选驱动代理 | 文档查询、集合浏览、连接管理 |
+| 时序 | TDengine | 可选驱动代理 | 时序库表浏览、查询分析 |
+| 列式分析 | ClickHouse | 可选驱动代理 | 分析查询、对象浏览、SQL 执行 |
+| 扩展接入 | Custom Driver/DSN | 自定义 | 通过 Driver + DSN 接入更多数据源 |
+
+<h2 align="center">📸 项目截图</h2>
+
+<div align="center">
+    <img width="25%" alt="image" src="https://github.com/user-attachments/assets/341cda98-79a5-4198-90f3-1335131ccde0" />
+    <img width="25%" alt="image" src="https://github.com/user-attachments/assets/224a74e7-65df-4aef-9710-d8e82e3a70c1" />
+    <img width="25%" alt="image" src="https://github.com/user-attachments/assets/ec522145-5ceb-4481-ae46-a9251c89bdfc" />
+    <br />
+    <img width="25%" alt="image" src="https://github.com/user-attachments/assets/330ce49b-45f1-4919-ae14-75f7d47e5f73" />
+    <img width="14%" alt="image" src="https://github.com/user-attachments/assets/d15fa9e9-5486-423b-a0e9-53b467e45432" />
+    <img width="25%" alt="image" src="https://github.com/user-attachments/assets/f0c57590-d987-4ecf-89b2-64efad60b6d7" />
+</div>
+
+---
+
+## 核心特性
+
+### 性能与交互
+- 大数据场景下保持流畅交互（含 DataGrid 列宽拖拽、批量编辑流程优化）。
+- 虚拟滚动渲染，降低大结果集卡顿风险。
+
+### 数据管理（DataGrid）
+- 单元格所见即所得编辑。
+- 批量新增/修改/删除，支持事务提交与回滚。
+- 大字段弹窗编辑。
+- 右键上下文操作（NULL、复制、导出等）。
+- 根据查询上下文智能切换读写模式。
+- 支持 CSV / XLSX / JSON / Markdown 导出。
+
+### SQL 编辑器
+- 基于 Monaco Editor。
+- 上下文补全（数据库/表/字段）。
+- 多标签查询工作流。
+
+### 连接与驱动
+- URI 生成与解析。
+- SSH 隧道、代理支持。
+- 连接配置 JSON 导入/导出。
+- 可选驱动安装与启用管理。
+
+### Redis 工具
+- 自动/原始文本/UTF-8/十六进制等视图模式。
+- 内置命令执行面板。
+
+### 可观测性与更新
+- SQL 执行日志（含耗时）。
+- 启动/定时/手动更新检查。
+
+### UI 体验
+- Ant Design 5 体系。
+- 深色/浅色主题切换。
+- 灵活布局与侧边栏行为。
+
+---
+
+## 技术栈
+
+- **后端**: Go 1.24 + Wails v2
+- **前端**: React 18 + TypeScript + Vite
+- **UI 框架**: Ant Design 5
+- **状态管理**: Zustand
+- **编辑器**: Monaco Editor
+
+---
+
+## 安装与运行
+
+### 前置要求
+- [Go](https://go.dev/dl/) 1.21+
+- [Node.js](https://nodejs.org/) 18+
+- [Wails CLI](https://wails.io/docs/gettingstarted/installation):
+  `go install github.com/wailsapp/wails/v2/cmd/wails@latest`
+
+### 开发模式
+
+```bash
+# 克隆项目
+git clone https://github.com/Syngnat/GoNavi.git
+cd GoNavi
+
+# 启动开发（热重载）
+wails dev
+```
+
+### 编译构建
+
+```bash
+# 构建当前平台
+wails build
+
+# 清理后构建（发布前推荐）
+wails build -clean
+```
+
+构建产物位于 `build/bin`。
+
+### 跨平台发布（GitHub Actions）
+
+仓库内置发布流水线，推送 `v*` Tag 可自动构建并发布 Release。
+
+支持目标：
+- macOS (AMD64 / ARM64)
+- Windows (AMD64)
+- Linux (AMD64，含 WebKitGTK 4.0 / 4.1 变体)
+
+---
+
+## 常见问题
+
+### macOS 提示“应用已损坏，无法打开”
+
+在未进行 Apple Notarization 时，Gatekeeper 可能拦截应用。
+
+```bash
+sudo xattr -rd com.apple.quarantine /Applications/GoNavi.app
+```
+
+### Linux 缺少 `libwebkit2gtk` / `libjavascriptcoregtk`
+
+```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
+```
+
+---
+
+## 贡献指南
+
+欢迎提交 Issue 与 Pull Request。
+
+1. Fork 本仓库。
+2. 创建特性分支。
+3. 提交改动。
+4. 推送分支。
+5. 发起 Pull Request。
+
+## 开源协议
+
+本项目采用 [Apache-2.0 协议](LICENSE)。
--- a/cmd/optional-driver-agent/provider_clickhouse.go
+++ b/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{}
+	}
+}
--- a/docs/driver-manifest.json
+++ b/docs/driver-manifest.json
@@ -3,79 +3,85 @@
  "drivers": {
    "mariadb": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "1.9.3",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/mariadb"
    },
-    "diros": {
+    "doris": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "1.9.3",
      "checksumPolicy": "off",
-      "downloadUrl": "builtin://activate/diros"
+      "downloadUrl": "builtin://activate/doris"
    },
    "sphinx": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "1.9.3",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/sphinx"
    },
    "sqlserver": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "1.9.6",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/sqlserver"
    },
    "sqlite": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "1.44.3",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/sqlite"
    },
    "duckdb": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "2.5.5",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/duckdb"
    },
    "dameng": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "1.8.22",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/dameng"
    },
    "kingbase": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "0.0.0-20201021123113-29bd62a876c3",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/kingbase"
    },
    "highgo": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "0.0.0-local",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/highgo"
    },
    "vastbase": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "1.11.1",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/vastbase"
    },
    "mongodb": {
      "engine": "go",
-      "version": "go-embedded",
+      "version": "2.5.0",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/mongodb"
    },
    "tdengine": {
      "engine": "go",
-      "version": "go-embedded",
+      "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": "go-embedded",
+      "version": "1.11.1",
      "checksumPolicy": "off",
      "downloadUrl": "builtin://activate/postgres"
    }
--- a/frontend/src/App.css
+++ b/frontend/src/App.css
@@ -92,3 +92,53 @@ body[data-theme='dark'] {
    background-color: #ff4d4f !important;
    color: #fff !important;
 }
+
+/* 驱动管理：统一关闭 antd sticky 横向条，仅保留自定义独立横向条 */
+.driver-manager-table .ant-table-sticky-scroll {
+    display: none !important;
+}
+
+/* 仅在独立横向条激活时隐藏表格自身横向滚动条，避免出现双横向条 */
+.driver-manager-table-wrap.driver-manager-table-wrap-external-active .driver-manager-table .ant-table-content,
+.driver-manager-table-wrap.driver-manager-table-wrap-external-active .driver-manager-table .ant-table-body {
+    overflow-x: auto !important;
+    -ms-overflow-style: none;
+    scrollbar-width: none;
+}
+
+.driver-manager-table-wrap.driver-manager-table-wrap-external-active .driver-manager-table .ant-table-content::-webkit-scrollbar:horizontal,
+.driver-manager-table-wrap.driver-manager-table-wrap-external-active .driver-manager-table .ant-table-body::-webkit-scrollbar:horizontal {
+    height: 0 !important;
+}
+
+.driver-manager-table-wrap {
+    width: 100%;
+    max-width: 100%;
+    overflow-x: hidden;
+}
+
+.driver-manager-footer {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.driver-manager-footer-actions {
+    width: 100%;
+    display: flex;
+    justify-content: flex-end;
+}
+
+.driver-manager-hscroll {
+    width: 100%;
+    height: 12px;
+    overflow-x: auto;
+    overflow-y: hidden;
+    scrollbar-gutter: stable;
+    background: transparent;
+}
+
+.driver-manager-hscroll-inner {
+    height: 1px;
+}
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,8 +1,8 @@
 import React, { useState, useEffect } from 'react';
-import { Layout, Button, ConfigProvider, theme, Dropdown, MenuProps, message, Modal, Spin, Slider, Progress } from 'antd';
+import { Layout, Button, ConfigProvider, theme, Dropdown, MenuProps, message, Modal, Spin, Slider, Progress, Switch, Input, InputNumber, Select } from 'antd';
 import zhCN from 'antd/locale/zh_CN';
-import { PlusOutlined, BulbOutlined, BulbFilled, ConsoleSqlOutlined, UploadOutlined, DownloadOutlined, CloudDownloadOutlined, BugOutlined, ToolOutlined, InfoCircleOutlined, GithubOutlined, SkinOutlined, CheckOutlined, MinusOutlined, BorderOutlined, CloseOutlined, SettingOutlined } from '@ant-design/icons';
-import { Environment, EventsOn } from '../wailsjs/runtime/runtime';
+import { PlusOutlined, BulbOutlined, BulbFilled, ConsoleSqlOutlined, UploadOutlined, DownloadOutlined, CloudDownloadOutlined, BugOutlined, ToolOutlined, GlobalOutlined, InfoCircleOutlined, GithubOutlined, SkinOutlined, CheckOutlined, MinusOutlined, BorderOutlined, CloseOutlined, SettingOutlined } from '@ant-design/icons';
+import { Environment, EventsOn, WindowFullscreen, WindowIsFullscreen, WindowIsMaximised, WindowMaximise } from '../wailsjs/runtime/runtime';
 import Sidebar from './components/Sidebar';
 import TabManager from './components/TabManager';
 import ConnectionModal from './components/ConnectionModal';
@@ -12,7 +12,7 @@ import LogPanel from './components/LogPanel';
 import { useStore } from './store';
 import { SavedConnection } from './types';
 import { blurToFilter, normalizeBlurForPlatform, normalizeOpacityForPlatform, isWindowsPlatform } from './utils/appearance';
-import { SetWindowTranslucency } from '../wailsjs/go/app/App';
+import { ConfigureGlobalProxy, SetWindowTranslucency } from '../wailsjs/go/app/App';
 import './App.css';

 const { Sider, Content } = Layout;
@@ -26,12 +26,18 @@ function App() {
  const setTheme = useStore(state => state.setTheme);
  const appearance = useStore(state => state.appearance);
  const setAppearance = useStore(state => state.setAppearance);
+  const startupFullscreen = useStore(state => state.startupFullscreen);
+  const setStartupFullscreen = useStore(state => state.setStartupFullscreen);
+  const globalProxy = useStore(state => state.globalProxy);
+  const setGlobalProxy = useStore(state => state.setGlobalProxy);
  const darkMode = themeMode === 'dark';
  const effectiveOpacity = normalizeOpacityForPlatform(appearance.opacity);
  const effectiveBlur = normalizeBlurForPlatform(appearance.blur);
  const blurFilter = blurToFilter(effectiveBlur);
  const windowCornerRadius = 14;
  const [isLinuxRuntime, setIsLinuxRuntime] = useState(false);
+  const [isStoreHydrated, setIsStoreHydrated] = useState(() => useStore.persist.hasHydrated());
+  const globalProxyInvalidHintShownRef = React.useRef(false);

  // 同步 macOS 窗口透明度：opacity=1.0 且 blur=0 时关闭 NSVisualEffectView，
  // 避免 GPU 持续计算窗口背后的模糊合成
@@ -56,6 +62,161 @@ function App() {
      };
  }, []);

+  useEffect(() => {
+      if (isStoreHydrated) {
+          return;
+      }
+      const unsubscribe = useStore.persist.onFinishHydration(() => {
+          setIsStoreHydrated(true);
+      });
+      return () => {
+          unsubscribe();
+      };
+  }, [isStoreHydrated]);
+
+  useEffect(() => {
+      if (!isStoreHydrated) {
+          return;
+      }
+
+      const host = String(globalProxy.host || '').trim();
+      const port = Number(globalProxy.port);
+      const portValid = Number.isFinite(port) && port > 0 && port <= 65535;
+      const invalidWhenEnabled = globalProxy.enabled && (!host || !portValid);
+
+      if (invalidWhenEnabled) {
+          if (!globalProxyInvalidHintShownRef.current) {
+              message.warning({
+                  content: '全局代理已开启，但地址或端口无效，当前按未启用处理',
+                  key: 'global-proxy-invalid',
+              });
+              globalProxyInvalidHintShownRef.current = true;
+          }
+      } else {
+          globalProxyInvalidHintShownRef.current = false;
+          message.destroy('global-proxy-invalid');
+      }
+
+      const enabledForBackend = globalProxy.enabled && !invalidWhenEnabled;
+      let cancelled = false;
+      ConfigureGlobalProxy(enabledForBackend, {
+          type: globalProxy.type,
+          host,
+          port: portValid ? port : (globalProxy.type === 'http' ? 8080 : 1080),
+          user: String(globalProxy.user || '').trim(),
+          password: globalProxy.password || '',
+      })
+          .then((res) => {
+              if (cancelled || res?.success) {
+                  return;
+              }
+              message.error({
+                  content: '全局代理配置失败: ' + (res?.message || '未知错误'),
+                  key: 'global-proxy-sync-error',
+              });
+          })
+          .catch((err) => {
+              if (cancelled) {
+                  return;
+              }
+              const errMsg = err instanceof Error ? err.message : String(err || '未知错误');
+              message.error({
+                  content: '全局代理配置失败: ' + errMsg,
+                  key: 'global-proxy-sync-error',
+              });
+          });
+
+      return () => {
+          cancelled = true;
+      };
+  }, [
+      isStoreHydrated,
+      globalProxy.enabled,
+      globalProxy.type,
+      globalProxy.host,
+      globalProxy.port,
+      globalProxy.user,
+      globalProxy.password,
+  ]);
+
+  useEffect(() => {
+      let cancelled = false;
+      let startupWindowTimer: number | null = null;
+      const maxApplyAttempts = 6;
+      const applyRetryDelayMs = 400;
+      const settleDelayMs = 160;
+
+      const checkStartupPreferenceApplied = async (): Promise<boolean> => {
+          try {
+              if (await WindowIsFullscreen()) {
+                  return true;
+              }
+          } catch (_) {
+              // ignore
+          }
+          try {
+              if (await WindowIsMaximised()) {
+                  return true;
+              }
+          } catch (_) {
+              // ignore
+          }
+          return false;
+      };
+
+      const applyStartupWindowPreference = (attempt: number) => {
+          if (startupWindowTimer !== null) {
+              window.clearTimeout(startupWindowTimer);
+          }
+          startupWindowTimer = window.setTimeout(() => {
+              if (cancelled) {
+                  return;
+              }
+              if (!useStore.getState().startupFullscreen) {
+                  return;
+              }
+              Promise.resolve()
+                  .then(async () => {
+                      if (await checkStartupPreferenceApplied()) {
+                          return;
+                      }
+                      // 优先尝试全屏，若当前平台/时机不生效，后续走最大化兜底。
+                      WindowFullscreen();
+                      await new Promise((resolve) => window.setTimeout(resolve, settleDelayMs));
+                      if (await checkStartupPreferenceApplied()) {
+                          return;
+                      }
+                      WindowMaximise();
+                      await new Promise((resolve) => window.setTimeout(resolve, settleDelayMs));
+                      if (await checkStartupPreferenceApplied()) {
+                          return;
+                      }
+                      if (attempt < maxApplyAttempts) {
+                          applyStartupWindowPreference(attempt + 1);
+                      }
+                  });
+          }, 300);
+      };
+
+      if (useStore.persist.hasHydrated()) {
+          applyStartupWindowPreference(1);
+      }
+      const unsubscribeHydration = useStore.persist.onFinishHydration(() => {
+          if (cancelled) {
+              return;
+          }
+          applyStartupWindowPreference(1);
+      });
+
+      return () => {
+          cancelled = true;
+          if (startupWindowTimer !== null) {
+              window.clearTimeout(startupWindowTimer);
+          }
+          unsubscribeHydration();
+      };
+  }, []);
+
  // Background Helper
  const getBg = (darkHex: string, lightHex: string) => {
      if (!darkMode) return `rgba(255, 255, 255, ${effectiveOpacity})`; // Light mode usually white
@@ -412,6 +573,7 @@ function App() {
  ];

  const [isAppearanceModalOpen, setIsAppearanceModalOpen] = useState(false);
+  const [isProxyModalOpen, setIsProxyModalOpen] = useState(false);


  // Log Panel: 最小高度按“工具栏 + 1 条日志行（微增）”限制
@@ -734,6 +896,7 @@ function App() {
            <Dropdown menu={{ items: toolsMenu }} placement="bottomLeft">
                <Button type="text" icon={<ToolOutlined />} title="工具">工具</Button>
            </Dropdown>
+            <Button type="text" icon={<GlobalOutlined />} title="代理" onClick={() => setIsProxyModalOpen(true)}>代理</Button>
            <Dropdown menu={{ items: themeMenu }} placement="bottomLeft">
                <Button type="text" icon={<SkinOutlined />} title="主题">主题</Button>
            </Dropdown>
@@ -874,7 +1037,7 @@ function App() {
              open={isAppearanceModalOpen}
              onCancel={() => setIsAppearanceModalOpen(false)}
              footer={null}
-              width={400}
+              width={460}
          >
              <div style={{ display: 'flex', flexDirection: 'column', gap: 24, padding: '12px 0' }}>
                  <div>
@@ -915,6 +1078,91 @@ function App() {
                          </>
                      )}
                  </div>
+                  <div>
+                      <div style={{ marginBottom: 8, fontWeight: 500 }}>启动窗口</div>
+                      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12 }}>
+                          <span>启动时全屏</span>
+                          <Switch checked={startupFullscreen} onChange={(checked) => setStartupFullscreen(checked)} />
+                      </div>
+                      <div style={{ fontSize: 12, color: '#888', marginTop: 4 }}>
+                          * 修改后下次启动生效
+                      </div>
+                  </div>
+              </div>
+          </Modal>
+
+          <Modal
+              title="全局代理设置"
+              open={isProxyModalOpen}
+              onCancel={() => setIsProxyModalOpen(false)}
+              footer={null}
+              width={460}
+          >
+              <div style={{ display: 'flex', flexDirection: 'column', gap: 24, padding: '12px 0' }}>
+                  <div>
+                      <div style={{ marginBottom: 8, fontWeight: 500 }}>全局代理</div>
+                      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12 }}>
+                          <span>启用全局代理</span>
+                          <Switch checked={globalProxy.enabled} onChange={(checked) => setGlobalProxy({ enabled: checked })} />
+                      </div>
+                      <div style={{ marginTop: 12, display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 12, opacity: globalProxy.enabled ? 1 : 0.7 }}>
+                          <div>
+                              <div style={{ marginBottom: 6, fontSize: 12, color: '#8c8c8c' }}>代理类型</div>
+                              <Select
+                                  value={globalProxy.type}
+                                  disabled={!globalProxy.enabled}
+                                  options={[
+                                      { value: 'socks5', label: 'SOCKS5' },
+                                      { value: 'http', label: 'HTTP' },
+                                  ]}
+                                  onChange={(value) => setGlobalProxy({ type: value as 'socks5' | 'http' })}
+                              />
+                          </div>
+                          <div>
+                              <div style={{ marginBottom: 6, fontSize: 12, color: '#8c8c8c' }}>端口</div>
+                              <InputNumber
+                                  min={1}
+                                  max={65535}
+                                  style={{ width: '100%' }}
+                                  value={globalProxy.port}
+                                  disabled={!globalProxy.enabled}
+                                  onChange={(value) => setGlobalProxy({
+                                      port: typeof value === 'number' ? value : (globalProxy.type === 'http' ? 8080 : 1080),
+                                  })}
+                              />
+                          </div>
+                          <div style={{ gridColumn: '1 / span 2' }}>
+                              <div style={{ marginBottom: 6, fontSize: 12, color: '#8c8c8c' }}>代理地址</div>
+                              <Input
+                                  placeholder="例如：127.0.0.1"
+                                  value={globalProxy.host}
+                                  disabled={!globalProxy.enabled}
+                                  onChange={(e) => setGlobalProxy({ host: e.target.value })}
+                              />
+                          </div>
+                          <div>
+                              <div style={{ marginBottom: 6, fontSize: 12, color: '#8c8c8c' }}>用户名（可选）</div>
+                              <Input
+                                  placeholder="proxy-user"
+                                  value={globalProxy.user}
+                                  disabled={!globalProxy.enabled}
+                                  onChange={(e) => setGlobalProxy({ user: e.target.value })}
+                              />
+                          </div>
+                          <div>
+                              <div style={{ marginBottom: 6, fontSize: 12, color: '#8c8c8c' }}>密码（可选）</div>
+                              <Input.Password
+                                  placeholder="proxy-password"
+                                  value={globalProxy.password}
+                                  disabled={!globalProxy.enabled}
+                                  onChange={(e) => setGlobalProxy({ password: e.target.value })}
+                              />
+                          </div>
+                      </div>
+                      <div style={{ fontSize: 12, color: '#888', marginTop: 6 }}>
+                          * 作用于更新检查、驱动管理网络请求，以及未单独配置代理的数据库连接
+                      </div>
+                  </div>
              </div>
          </Modal>

--- a/frontend/src/components/ConnectionModal.tsx
+++ b/frontend/src/components/ConnectionModal.tsx
@@ -2,20 +2,28 @@ import React, { useState, useEffect, useRef } from 'react';
 import { Modal, Form, Input, InputNumber, Button, message, Checkbox, Divider, Select, Alert, Card, Row, Col, Typography, Collapse, Space, Table, Tag } from 'antd';
 import { DatabaseOutlined, ConsoleSqlOutlined, FileTextOutlined, CloudServerOutlined, AppstoreAddOutlined, CloudOutlined, CheckCircleFilled, CloseCircleFilled } from '@ant-design/icons';
 import { useStore } from '../store';
-import { DBGetDatabases, GetDriverStatusList, MongoDiscoverMembers, TestConnection, RedisConnect } from '../../wailsjs/go/app/App';
-import { MongoMemberInfo, SavedConnection } from '../types';
+import { normalizeOpacityForPlatform } from '../utils/appearance';
+import { DBGetDatabases, GetDriverStatusList, MongoDiscoverMembers, TestConnection, RedisConnect, SelectSSHKeyFile } from '../../wailsjs/go/app/App';
+import { ConnectionConfig, MongoMemberInfo, SavedConnection } from '../types';

 const { Meta } = Card;
 const { Text } = Typography;
 const MAX_URI_LENGTH = 4096;
 const MAX_URI_HOSTS = 32;
 const MAX_TIMEOUT_SECONDS = 3600;
+const STEP1_MODAL_WIDTH = 760;
+const STEP2_MODAL_WIDTH = 680;
+const STEP1_MODAL_MIN_BODY_HEIGHT = 460;
+const STEP1_SIDEBAR_DIVIDER_DARK = 'rgba(255, 255, 255, 0.16)';
+const STEP1_SIDEBAR_DIVIDER_LIGHT = 'rgba(0, 0, 0, 0.08)';

 const getDefaultPortByType = (type: string) => {
  switch (type) {
    case 'mysql': return 3306;
+    case 'doris':
    case 'diros': return 9030;
    case 'sphinx': return 9306;
+    case 'clickhouse': return 9000;
    case 'postgres': return 5432;
    case 'redis': return 6379;
    case 'tdengine': return 6041;
@@ -58,6 +66,7 @@ const ConnectionModal: React.FC<{
  const [form] = Form.useForm();
  const [loading, setLoading] = useState(false);
  const [useSSH, setUseSSH] = useState(false);
+  const [useProxy, setUseProxy] = useState(false);
  const [dbType, setDbType] = useState('mysql');
  const [step, setStep] = useState(1); // 1: Select Type, 2: Configure
  const [activeGroup, setActiveGroup] = useState(0); // Active category index in step 1
@@ -71,14 +80,40 @@ const ConnectionModal: React.FC<{
  const [typeSelectWarning, setTypeSelectWarning] = useState<{ driverName: string; reason: string } | null>(null);
  const [driverStatusMap, setDriverStatusMap] = useState<Record<string, DriverStatusSnapshot>>({});
  const [driverStatusLoaded, setDriverStatusLoaded] = useState(false);
+  const [selectingSSHKey, setSelectingSSHKey] = useState(false);
  const testInFlightRef = useRef(false);
  const testTimerRef = useRef<number | null>(null);
  const addConnection = useStore((state) => state.addConnection);
  const updateConnection = useStore((state) => state.updateConnection);
+  const theme = useStore((state) => state.theme);
+  const appearance = useStore((state) => state.appearance);
+  const darkMode = theme === 'dark';
+  const effectiveOpacity = normalizeOpacityForPlatform(appearance.opacity);
  const mysqlTopology = Form.useWatch('mysqlTopology', form) || 'single';
  const mongoTopology = Form.useWatch('mongoTopology', form) || 'single';
  const mongoSrv = Form.useWatch('mongoSrv', form) || false;

+  const getSectionBg = (darkHex: string) => {
+      if (!darkMode) {
+          return `rgba(245, 245, 245, ${Math.max(effectiveOpacity, 0.92)})`;
+      }
+      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}, ${Math.max(effectiveOpacity, 0.82)})`;
+  };
+
+  const step1SidebarDividerColor = darkMode ? STEP1_SIDEBAR_DIVIDER_DARK : STEP1_SIDEBAR_DIVIDER_LIGHT;
+
+  const tunnelSectionStyle: React.CSSProperties = {
+      padding: '12px',
+      background: getSectionBg('#2a2a2a'),
+      borderRadius: 6,
+      marginTop: 12,
+      border: darkMode ? '1px solid rgba(255, 255, 255, 0.16)' : '1px solid rgba(0, 0, 0, 0.06)',
+  };
+
  const fetchDriverStatusMap = async (): Promise<Record<string, DriverStatusSnapshot>> => {
      const result: Record<string, DriverStatusSnapshot> = {};
      const res = await GetDriverStatusList('', '');
@@ -405,6 +440,31 @@ const ConnectionModal: React.FC<{
          };
      }

+      if (type === 'clickhouse') {
+          const parsed = parseMultiHostUri(trimmedUri, 'clickhouse');
+          if (!parsed) {
+              return null;
+          }
+          if (!parsed.hosts.length || parsed.hosts.length > MAX_URI_HOSTS) {
+              return null;
+          }
+          if (parsed.hosts.some((entry) => !isValidUriHostEntry(entry))) {
+              return null;
+          }
+          const hostList = normalizeAddressList(parsed.hosts, 9000);
+          if (!hostList.length) {
+              return null;
+          }
+          const primary = parseHostPort(hostList[0] || 'localhost:9000', 9000);
+          return {
+              host: primary?.host || 'localhost',
+              port: primary?.port || 9000,
+              user: parsed.username,
+              password: parsed.password,
+              database: parsed.database || '',
+          };
+      }
+
      return null;
  };

@@ -428,7 +488,7 @@ const ConnectionModal: React.FC<{
  const getUriPlaceholder = () => {
      if (dbType === 'mysql' || dbType === 'mariadb' || dbType === 'diros' || dbType === 'sphinx') {
          const defaultPort = getDefaultPortByType(dbType);
-          const scheme = dbType === 'diros' ? 'diros' : 'mysql';
+          const scheme = dbType === 'diros' ? 'doris' : 'mysql';
          return `${scheme}://user:pass@127.0.0.1:${defaultPort},127.0.0.2:${defaultPort}/db_name?topology=replica`;
      }
      if (isFileDatabaseType(dbType)) {
@@ -439,6 +499,9 @@ const ConnectionModal: React.FC<{
      if (dbType === 'mongodb') {
          return 'mongodb+srv://user:pass@cluster0.example.com/db_name?authSource=admin&authMechanism=SCRAM-SHA-256';
      }
+      if (dbType === 'clickhouse') {
+          return 'clickhouse://default:pass@127.0.0.1:9000/default';
+      }
      return '例如: postgres://user:pass@127.0.0.1:5432/db_name';
  };

@@ -470,7 +533,7 @@ const ConnectionModal: React.FC<{
          }
          const dbPath = database ? `/${encodeURIComponent(database)}` : '/';
          const query = params.toString();
-          const scheme = type === 'diros' ? 'diros' : 'mysql';
+          const scheme = type === 'diros' ? 'doris' : 'mysql';
          return `${scheme}://${encodedAuth}${hosts.join(',')}${dbPath}${query ? `?${query}` : ''}`;
      }

@@ -578,6 +641,30 @@ const ConnectionModal: React.FC<{
      }
  };

+  const handleSelectSSHKeyFile = async () => {
+      if (selectingSSHKey) {
+          return;
+      }
+      try {
+          setSelectingSSHKey(true);
+          const currentPath = String(form.getFieldValue('sshKeyPath') || '').trim();
+          const res = await SelectSSHKeyFile(currentPath);
+          if (res?.success) {
+              const data = res.data || {};
+              const selectedPath = typeof data === 'string' ? data : String(data.path || '').trim();
+              if (selectedPath) {
+                  form.setFieldValue('sshKeyPath', selectedPath);
+              }
+          } else if (res?.message !== 'Cancelled') {
+              message.error(`选择私钥文件失败: ${res?.message || '未知错误'}`);
+          }
+      } catch (e: any) {
+          message.error(`选择私钥文件失败: ${e?.message || String(e)}`);
+      } finally {
+          setSelectingSSHKey(false);
+      }
+  };
+
  useEffect(() => {
      if (open) {
          setTestResult(null); // Reset test result
@@ -630,6 +717,12 @@ const ConnectionModal: React.FC<{
                  sshUser: config.ssh?.user,
                  sshPassword: config.ssh?.password,
                  sshKeyPath: config.ssh?.keyPath,
+                  useProxy: config.useProxy,
+                  proxyType: config.proxy?.type || 'socks5',
+                  proxyHost: config.proxy?.host,
+                  proxyPort: config.proxy?.port,
+                  proxyUser: config.proxy?.user,
+                  proxyPassword: config.proxy?.password,
                  driver: config.driver,
                  dsn: config.dsn,
                  timeout: config.timeout || 30,
@@ -649,6 +742,7 @@ const ConnectionModal: React.FC<{
                  mongoReplicaPassword: config.mongoReplicaPassword || ''
              });
              setUseSSH(config.useSSH || false);
+              setUseProxy(config.useProxy || false);
              setDbType(configType);
              // 如果是 Redis 编辑模式，设置已保存的 Redis 数据库列表
              if (configType === 'redis') {
@@ -659,6 +753,7 @@ const ConnectionModal: React.FC<{
              setStep(1);
              form.resetFields();
              setUseSSH(false);
+              setUseProxy(false);
              setDbType('mysql');
              setActiveGroup(0);
          }
@@ -708,6 +803,7 @@ const ConnectionModal: React.FC<{
      setLoading(false);
      form.resetFields();
      setUseSSH(false);
+      setUseProxy(false);
      setDbType('mysql');
      setStep(1);
      onClose();
@@ -827,7 +923,7 @@ const ConnectionModal: React.FC<{
      }
  };

-  const buildConfig = async (values: any, forPersist: boolean) => {
+  const buildConfig = async (values: any, forPersist: boolean): Promise<ConnectionConfig> => {
      const mergedValues = { ...values };
      const parsedUriValues = parseUriToValues(mergedValues.uri, mergedValues.type);
      const isEmptyField = (value: unknown) => (
@@ -926,6 +1022,22 @@ const ConnectionModal: React.FC<{
          password: mergedValues.sshPassword || "",
          keyPath: mergedValues.sshKeyPath || ""
      } : { host: "", port: 22, user: "", password: "", keyPath: "" };
+      const effectiveUseProxy = !isFileDbType && !!mergedValues.useProxy;
+      const proxyTypeRaw = String(mergedValues.proxyType || 'socks5').toLowerCase();
+      const proxyType: 'socks5' | 'http' = proxyTypeRaw === 'http' ? 'http' : 'socks5';
+      const proxyConfig: NonNullable<ConnectionConfig['proxy']> = effectiveUseProxy ? {
+          type: proxyType,
+          host: String(mergedValues.proxyHost || '').trim(),
+          port: Number(mergedValues.proxyPort || (proxyTypeRaw === 'http' ? 8080 : 1080)),
+          user: String(mergedValues.proxyUser || '').trim(),
+          password: mergedValues.proxyPassword || "",
+      } : {
+          type: 'socks5',
+          host: '',
+          port: 1080,
+          user: '',
+          password: '',
+      };

      const keepPassword = !forPersist || savePassword;

@@ -939,6 +1051,8 @@ const ConnectionModal: React.FC<{
          database: mergedValues.database || "",
          useSSH: !!mergedValues.useSSH,
          ssh: sshConfig,
+          useProxy: effectiveUseProxy,
+          proxy: proxyConfig,
          driver: mergedValues.driver,
          dsn: mergedValues.dsn,
          timeout: Number(mergedValues.timeout || 30),
@@ -972,6 +1086,7 @@ const ConnectionModal: React.FC<{
      const defaultPort = getDefaultPortByType(type);
      if (isFileDatabaseType(type)) {
          setUseSSH(false);
+          setUseProxy(false);
          form.setFieldsValue({
              host: '',
              port: 0,
@@ -984,6 +1099,12 @@ const ConnectionModal: React.FC<{
              sshUser: '',
              sshPassword: '',
              sshKeyPath: '',
+              useProxy: false,
+              proxyType: 'socks5',
+              proxyHost: '',
+              proxyPort: 1080,
+              proxyUser: '',
+              proxyPassword: '',
              mysqlTopology: 'single',
              mongoTopology: 'single',
              mongoSrv: false,
@@ -1000,7 +1121,10 @@ const ConnectionModal: React.FC<{
              mongoReplicaPassword: '',
          });
      } else if (type !== 'custom') {
+          const defaultUser = type === 'clickhouse' ? 'default' : 'root';
          form.setFieldsValue({
+              user: defaultUser,
+              database: '',
              port: defaultPort,
              mysqlTopology: 'single',
              mongoTopology: 'single',
@@ -1039,8 +1163,9 @@ const ConnectionModal: React.FC<{
      { label: '关系型数据库', items: [
          { key: 'mysql', name: 'MySQL', icon: <ConsoleSqlOutlined style={{ fontSize: 24, color: '#00758F' }} /> },
          { key: 'mariadb', name: 'MariaDB', icon: <ConsoleSqlOutlined style={{ fontSize: 24, color: '#003545' }} /> },
-          { key: 'diros', name: 'Diros', icon: <ConsoleSqlOutlined style={{ fontSize: 24, color: '#0050b3' }} /> },
+          { key: 'diros', name: 'Doris', icon: <ConsoleSqlOutlined style={{ fontSize: 24, color: '#0050b3' }} /> },
          { key: 'sphinx', name: 'Sphinx', icon: <ConsoleSqlOutlined style={{ fontSize: 24, color: '#2F5D62' }} /> },
+          { key: 'clickhouse', name: 'ClickHouse', icon: <DatabaseOutlined style={{ fontSize: 24, color: '#FFCC01' }} /> },
          { key: 'postgres', name: 'PostgreSQL', icon: <DatabaseOutlined style={{ fontSize: 24, color: '#336791' }} /> },
          { key: 'sqlserver', name: 'SQL Server', icon: <DatabaseOutlined style={{ fontSize: 24, color: '#CC2927' }} /> },
          { key: 'sqlite', name: 'SQLite', icon: <FileTextOutlined style={{ fontSize: 24, color: '#003B57' }} /> },
@@ -1088,7 +1213,7 @@ const ConnectionModal: React.FC<{
          )}
      <div style={{ display: 'flex', height: 360 }}>
          {/* 左侧分类导航 */}
-          <div style={{ width: 120, borderRight: '1px solid #f0f0f0', paddingRight: 8, flexShrink: 0 }}>
+          <div style={{ width: 120, borderRight: `1px solid ${step1SidebarDividerColor}`, paddingRight: 8, flexShrink: 0 }}>
              {dbTypeGroups.map((group, idx) => (
                  <div
                      key={group.label}
@@ -1139,9 +1264,13 @@ const ConnectionModal: React.FC<{
            type: 'mysql',
            host: 'localhost',
            port: 3306,
+            database: '',
            user: 'root',
            useSSH: false,
            sshPort: 22,
+            useProxy: false,
+            proxyType: 'socks5',
+            proxyPort: 1080,
            timeout: 30,
            uri: '',
            mysqlTopology: 'single',
@@ -1166,6 +1295,21 @@ const ConnectionModal: React.FC<{
                setUriFeedback(null);
            }
            if (changed.useSSH !== undefined) setUseSSH(changed.useSSH);
+            if (changed.useProxy !== undefined) setUseProxy(changed.useProxy);
+            if (changed.proxyType !== undefined) {
+                const nextType = String(changed.proxyType || 'socks5').toLowerCase();
+                if (nextType === 'http') {
+                    const currentPort = Number(form.getFieldValue('proxyPort') || 0);
+                    if (!currentPort || currentPort === 1080) {
+                        form.setFieldValue('proxyPort', 8080);
+                    }
+                } else {
+                    const currentPort = Number(form.getFieldValue('proxyPort') || 0);
+                    if (!currentPort || currentPort === 8080) {
+                        form.setFieldValue('proxyPort', 1080);
+                    }
+                }
+            }
            // Type change handled by step 1, but keep sync if select changes (hidden now)
            if (changed.type !== undefined) setDbType(changed.type);
            if (
@@ -1260,6 +1404,16 @@ const ConnectionModal: React.FC<{
            )}
        </div>

+        {(dbType === 'postgres' || dbType === 'kingbase' || dbType === 'highgo' || dbType === 'vastbase') && (
+        <Form.Item
+            name="database"
+            label="默认连接数据库（可选）"
+            help="留空会自动尝试 postgres、template1、与当前用户名同名数据库"
+        >
+            <Input placeholder="例如：appdb" />
+        </Form.Item>
+        )}
+
        {(dbType === 'mysql' || dbType === 'mariadb' || dbType === 'diros' || dbType === 'sphinx') && (
        <>
            <Form.Item name="mysqlTopology" label="连接模式">
@@ -1476,7 +1630,7 @@ const ConnectionModal: React.FC<{
            </Form.Item>

            {useSSH && (
-                <div style={{ padding: '12px', background: '#f5f5f5', borderRadius: 6, marginTop: 12 }}>
+                <div style={tunnelSectionStyle}>
                    <div style={{ display: 'flex', gap: 16 }}>
                        <Form.Item name="sshHost" label="SSH 主机 (域名或IP)" rules={[{ required: useSSH, message: '请输入SSH主机' }]} style={{ flex: 1 }}>
                            <Input placeholder="例如: ssh.example.com 或 192.168.1.100" />
@@ -1493,12 +1647,51 @@ const ConnectionModal: React.FC<{
                            <Input.Password placeholder="密码" />
                        </Form.Item>
                    </div>
-                     <Form.Item name="sshKeyPath" label="私钥路径 (可选)" help="例如: /Users/name/.ssh/id_rsa">
-                        <Input placeholder="绝对路径" />
+                    <Form.Item label="私钥路径 (可选)" help="例如: /Users/name/.ssh/id_rsa">
+                        <Space.Compact style={{ width: '100%' }}>
+                            <Form.Item name="sshKeyPath" noStyle>
+                                <Input placeholder="绝对路径" />
+                            </Form.Item>
+                            <Button onClick={handleSelectSSHKeyFile} loading={selectingSSHKey}>
+                                浏览...
+                            </Button>
+                        </Space.Compact>
                    </Form.Item>
                </div>
            )}

+            <Divider style={{ margin: '12px 0' }} />
+            <Form.Item name="useProxy" valuePropName="checked" style={{ marginBottom: 0 }}>
+                <Checkbox>使用代理 (SOCKS5 / HTTP CONNECT)</Checkbox>
+            </Form.Item>
+
+            {useProxy && (
+                <div style={tunnelSectionStyle}>
+                    <div style={{ display: 'flex', gap: 16 }}>
+                        <Form.Item name="proxyType" label="代理类型" rules={[{ required: useProxy, message: '请选择代理类型' }]} style={{ width: 180 }}>
+                            <Select options={[
+                                { value: 'socks5', label: 'SOCKS5' },
+                                { value: 'http', label: 'HTTP CONNECT' },
+                            ]} />
+                        </Form.Item>
+                        <Form.Item name="proxyHost" label="代理主机" rules={[{ required: useProxy, message: '请输入代理主机' }]} style={{ flex: 1 }}>
+                            <Input placeholder="例如: 127.0.0.1 或 proxy.company.com" />
+                        </Form.Item>
+                        <Form.Item name="proxyPort" label="端口" rules={[{ required: useProxy, message: '请输入代理端口' }]} style={{ width: 120 }}>
+                            <InputNumber style={{ width: '100%' }} min={1} max={65535} />
+                        </Form.Item>
+                    </div>
+                    <div style={{ display: 'flex', gap: 16 }}>
+                        <Form.Item name="proxyUser" label="代理用户名（可选）" style={{ flex: 1 }}>
+                            <Input placeholder="留空表示无认证" />
+                        </Form.Item>
+                        <Form.Item name="proxyPassword" label="代理密码（可选）" style={{ flex: 1 }}>
+                            <Input.Password placeholder="留空表示无认证" />
+                        </Form.Item>
+                    </div>
+                </div>
+            )}
+
            <Divider style={{ margin: '12px 0' }} />
            
            <Collapse 
@@ -1595,7 +1788,7 @@ const ConnectionModal: React.FC<{
  };

  const modalBodyStyle = step === 1
-      ? { padding: '16px 24px', overflow: 'hidden' as const }
+      ? { padding: '16px 24px', overflow: 'hidden' as const, minHeight: STEP1_MODAL_MIN_BODY_HEIGHT }
      : {
          padding: '16px 24px',
          overflowY: 'auto' as const,
@@ -1611,7 +1804,7 @@ const ConnectionModal: React.FC<{
          footer={getFooter()}
          centered
          wrapClassName="connection-modal-wrap"
-          width={step === 1 ? 650 : 600}
+          width={step === 1 ? STEP1_MODAL_WIDTH : STEP2_MODAL_WIDTH}
          zIndex={10001}
          destroyOnHidden
          maskClosable={false}
--- a/frontend/src/components/DataGrid.tsx
+++ b/frontend/src/components/DataGrid.tsx
@@ -90,6 +90,14 @@ const normalizeDateTimeString = (val: string) => {
    return `${match[1]} ${match[2]}`;
 };

+const isTemporalColumnType = (columnType?: string): boolean => {
+    const raw = String(columnType || '').trim().toLowerCase();
+    if (!raw) return false;
+    if (raw.includes('datetime') || raw.includes('timestamp')) return true;
+    const base = raw.split(/[ (]/)[0];
+    return base === 'date' || base === 'time' || base === 'year';
+};
+
 // --- Helper: Format Value ---
 const formatCellValue = (val: any) => {
    try {
@@ -501,7 +509,17 @@ interface DataGridProps {
    onReload?: () => void;
    onSort?: (field: string, order: string) => void;
    onPageChange?: (page: number, size: number) => void;
-    pagination?: { current: number, pageSize: number, total: number, totalKnown?: boolean };
+    pagination?: {
+        current: number,
+        pageSize: number,
+        total: number,
+        totalKnown?: boolean,
+        totalApprox?: boolean,
+        totalCountLoading?: boolean,
+        totalCountCancelled?: boolean,
+    };
+    onRequestTotalCount?: () => void;
+    onCancelTotalCount?: () => void;
    sortInfoExternal?: { columnKey: string, order: string } | null;
    // Filtering
    showFilter?: boolean;
@@ -526,7 +544,7 @@ type ColumnMeta = {

 const DataGrid: React.FC<DataGridProps> = ({ 
    data, columnNames, loading, tableName, dbName, connectionId, pkColumns = [], readOnly = false,
-    onReload, onSort, onPageChange, pagination, sortInfoExternal, showFilter, onToggleFilter, onApplyFilter
+    onReload, onSort, onPageChange, pagination, onRequestTotalCount, onCancelTotalCount, sortInfoExternal, showFilter, onToggleFilter, onApplyFilter
 }) => {
  const connections = useStore(state => state.connections);
  const addSqlLog = useStore(state => state.addSqlLog);
@@ -541,6 +559,8 @@ const DataGrid: React.FC<DataGridProps> = ({
  const showColumnComment = queryOptions?.showColumnComment !== false;
  const showColumnType = queryOptions?.showColumnType !== false;
  const selectionColumnWidth = 46;
+  const connTypeLower = String(connections.find(c => c.id === connectionId)?.config?.type || '').trim().toLowerCase();
+  const isDuckDBConnection = connTypeLower === 'duckdb';

  // Background Helper
  const getBg = (darkHex: string) => {
@@ -597,7 +617,6 @@ const DataGrid: React.FC<DataGridProps> = ({
    dataIndex: '',
    title: '',
  });
-  const [cellSetValueInput, setCellSetValueInput] = useState('');
  const containerRef = useRef<HTMLDivElement>(null);
  const pendingScrollToBottomRef = useRef(false);

@@ -611,6 +630,8 @@ const DataGrid: React.FC<DataGridProps> = ({
  // 使用 ref 来优化拖拽性能，完全避免状态更新
  const cellSelectionRafRef = useRef<number | null>(null);
  const cellSelectionScrollRafRef = useRef<number | null>(null);
+  const cellSelectionAutoScrollRafRef = useRef<number | null>(null);
+  const cellSelectionPointerRef = useRef<{ x: number; y: number } | null>(null);
  const isDraggingRef = useRef(false);

  // 导入预览 Modal 状态
@@ -661,7 +682,6 @@ const DataGrid: React.FC<DataGridProps> = ({
      dataIndex,
      title: titleText,
    });
-    setCellSetValueInput(toFormText(record[dataIndex]));
  }, []);

  // Helper to export specific data
@@ -764,6 +784,35 @@ const DataGrid: React.FC<DataGridProps> = ({
      return next;
  }, [columnMetaMap]);

+  const normalizeCommitCellValue = useCallback(
+      (columnName: string, value: any, mode: 'insert' | 'update') => {
+          if (value === undefined) return undefined;
+          const normalizedName = String(columnName || '').trim();
+          const meta = columnMetaMap[normalizedName] || columnMetaMapByLowerName[normalizedName.toLowerCase()];
+          const temporal = isTemporalColumnType(meta?.type);
+
+          if (!temporal) {
+              return value;
+          }
+
+          if (value === null) {
+              return null;
+          }
+
+          if (typeof value === 'string') {
+              const raw = value.trim();
+              if (raw === '') {
+                  // INSERT 空时间值直接忽略字段，让数据库默认值生效；UPDATE 空时间值转 NULL。
+                  return mode === 'insert' ? undefined : null;
+              }
+              return normalizeDateTimeString(value);
+          }
+
+          return value;
+      },
+      [columnMetaMap, columnMetaMapByLowerName]
+  );
+
  const renderColumnTitle = useCallback((name: string): React.ReactNode => {
      const normalizedName = String(name || '');
      const meta = columnMetaMap[normalizedName] || columnMetaMapByLowerName[normalizedName.toLowerCase()];
@@ -1065,6 +1114,11 @@ const DataGrid: React.FC<DataGridProps> = ({
    currentSelectionRef.current = new Set();
    selectionStartRef.current = null;
    isDraggingRef.current = false;
+    cellSelectionPointerRef.current = null;
+    if (cellSelectionAutoScrollRafRef.current !== null) {
+      cancelAnimationFrame(cellSelectionAutoScrollRafRef.current);
+      cellSelectionAutoScrollRafRef.current = null;
+    }
    updateCellSelection(new Set());
  }, [batchEditValue, batchEditSetNull, addedRows, modifiedRows, rowKeyStr, updateCellSelection]);

@@ -1074,8 +1128,12 @@ const DataGrid: React.FC<DataGridProps> = ({

    const container = containerRef.current;
    if (!container) return;
+    const EDGE_THRESHOLD_PX = 28;
+    const MIN_SCROLL_STEP = 8;
+    const MAX_SCROLL_STEP = 24;

-    const getCellInfo = (target: HTMLElement): { rowKey: string; colName: string } | null => {
+    const getCellInfo = (target: HTMLElement | null): { rowKey: string; colName: string } | null => {
+      if (!target) return null;
      const td = target.closest('td[data-row-key][data-col-name]') as HTMLElement;
      if (!td) return null;
      const rowKey = td.getAttribute('data-row-key');
@@ -1084,35 +1142,12 @@ const DataGrid: React.FC<DataGridProps> = ({
      return { rowKey, colName };
    };

-    const onMouseDown = (e: MouseEvent) => {
-      const cellInfo = getCellInfo(e.target as HTMLElement);
-      if (!cellInfo) return;
-
-      e.preventDefault();
-      isDraggingRef.current = true;
-      const currentData = displayDataRef.current;
-      const nextRowIndexMap = new Map<string, number>();
-      currentData.forEach((r, idx) => {
-        const k = r?.[GONAVI_ROW_KEY];
-        if (k === undefined) return;
-        nextRowIndexMap.set(String(k), idx);
-      });
-      rowIndexMapRef.current = nextRowIndexMap;
-
-      const startRowIndex = nextRowIndexMap.get(cellInfo.rowKey) ?? -1;
-      const startColIndex = columnIndexMap.get(cellInfo.colName) ?? -1;
-      selectionStartRef.current = { rowKey: cellInfo.rowKey, colName: cellInfo.colName, rowIndex: startRowIndex, colIndex: startColIndex };
-      currentSelectionRef.current = new Set([makeCellKey(cellInfo.rowKey, cellInfo.colName)]);
-      updateCellSelection(currentSelectionRef.current);
+    const getCellInfoFromPoint = (x: number, y: number): { rowKey: string; colName: string } | null => {
+      const target = document.elementFromPoint(x, y) as HTMLElement | null;
+      return getCellInfo(target);
    };

-    const onMouseMove = (e: MouseEvent) => {
-      if (!isDraggingRef.current || !selectionStartRef.current) return;
-
-      const cellInfo = getCellInfo(e.target as HTMLElement);
-      if (!cellInfo) return;
-
-      // 使用 RAF 节流
+    const scheduleSelectionUpdate = (cellInfo: { rowKey: string; colName: string }) => {
      if (cellSelectionRafRef.current !== null) {
        cancelAnimationFrame(cellSelectionRafRef.current);
      }
@@ -1151,9 +1186,124 @@ const DataGrid: React.FC<DataGridProps> = ({
      });
    };

+    const stopAutoScroll = () => {
+      if (cellSelectionAutoScrollRafRef.current !== null) {
+        cancelAnimationFrame(cellSelectionAutoScrollRafRef.current);
+        cellSelectionAutoScrollRafRef.current = null;
+      }
+    };
+
+    const getScrollStep = (distanceToEdge: number): number => {
+      const ratio = Math.min(1, Math.max(0, distanceToEdge / EDGE_THRESHOLD_PX));
+      return Math.round(MIN_SCROLL_STEP + (MAX_SCROLL_STEP - MIN_SCROLL_STEP) * ratio);
+    };
+
+    const autoScrollTick = () => {
+      if (!isDraggingRef.current || !selectionStartRef.current) {
+        stopAutoScroll();
+        return;
+      }
+
+      const pointer = cellSelectionPointerRef.current;
+      const tableBody = container.querySelector('.ant-table-body') as HTMLElement | null;
+      if (!pointer || !tableBody) {
+        cellSelectionAutoScrollRafRef.current = requestAnimationFrame(autoScrollTick);
+        return;
+      }
+
+      const rect = tableBody.getBoundingClientRect();
+      const maxScrollTop = Math.max(0, tableBody.scrollHeight - tableBody.clientHeight);
+      const maxScrollLeft = Math.max(0, tableBody.scrollWidth - tableBody.clientWidth);
+      let deltaY = 0;
+      let deltaX = 0;
+
+      if (pointer.y < rect.top + EDGE_THRESHOLD_PX && tableBody.scrollTop > 0) {
+        const distance = rect.top + EDGE_THRESHOLD_PX - pointer.y;
+        deltaY = -getScrollStep(distance);
+      } else if (pointer.y > rect.bottom - EDGE_THRESHOLD_PX && tableBody.scrollTop < maxScrollTop) {
+        const distance = pointer.y - (rect.bottom - EDGE_THRESHOLD_PX);
+        deltaY = getScrollStep(distance);
+      }
+
+      if (pointer.x < rect.left + EDGE_THRESHOLD_PX && tableBody.scrollLeft > 0) {
+        const distance = rect.left + EDGE_THRESHOLD_PX - pointer.x;
+        deltaX = -getScrollStep(distance);
+      } else if (pointer.x > rect.right - EDGE_THRESHOLD_PX && tableBody.scrollLeft < maxScrollLeft) {
+        const distance = pointer.x - (rect.right - EDGE_THRESHOLD_PX);
+        deltaX = getScrollStep(distance);
+      }
+
+      let didScroll = false;
+      if (deltaY !== 0) {
+        const nextTop = Math.max(0, Math.min(maxScrollTop, tableBody.scrollTop + deltaY));
+        if (nextTop !== tableBody.scrollTop) {
+          tableBody.scrollTop = nextTop;
+          didScroll = true;
+        }
+      }
+
+      if (deltaX !== 0) {
+        const nextLeft = Math.max(0, Math.min(maxScrollLeft, tableBody.scrollLeft + deltaX));
+        if (nextLeft !== tableBody.scrollLeft) {
+          tableBody.scrollLeft = nextLeft;
+          didScroll = true;
+        }
+      }
+
+      if (didScroll) {
+        const cellInfo = getCellInfoFromPoint(pointer.x, pointer.y);
+        if (cellInfo) scheduleSelectionUpdate(cellInfo);
+      }
+
+      cellSelectionAutoScrollRafRef.current = requestAnimationFrame(autoScrollTick);
+    };
+
+    const ensureAutoScroll = () => {
+      if (cellSelectionAutoScrollRafRef.current !== null) return;
+      cellSelectionAutoScrollRafRef.current = requestAnimationFrame(autoScrollTick);
+    };
+
+    const onMouseDown = (e: MouseEvent) => {
+      const target = e.target instanceof HTMLElement ? e.target : null;
+      const cellInfo = getCellInfo(target);
+      if (!cellInfo) return;
+
+      e.preventDefault();
+      isDraggingRef.current = true;
+      cellSelectionPointerRef.current = { x: e.clientX, y: e.clientY };
+      const currentData = displayDataRef.current;
+      const nextRowIndexMap = new Map<string, number>();
+      currentData.forEach((r, idx) => {
+        const k = r?.[GONAVI_ROW_KEY];
+        if (k === undefined) return;
+        nextRowIndexMap.set(String(k), idx);
+      });
+      rowIndexMapRef.current = nextRowIndexMap;
+
+      const startRowIndex = nextRowIndexMap.get(cellInfo.rowKey) ?? -1;
+      const startColIndex = columnIndexMap.get(cellInfo.colName) ?? -1;
+      selectionStartRef.current = { rowKey: cellInfo.rowKey, colName: cellInfo.colName, rowIndex: startRowIndex, colIndex: startColIndex };
+      currentSelectionRef.current = new Set([makeCellKey(cellInfo.rowKey, cellInfo.colName)]);
+      updateCellSelection(currentSelectionRef.current);
+      ensureAutoScroll();
+    };
+
+    const onMouseMove = (e: MouseEvent) => {
+      if (!isDraggingRef.current || !selectionStartRef.current) return;
+      cellSelectionPointerRef.current = { x: e.clientX, y: e.clientY };
+      ensureAutoScroll();
+
+      const target = e.target instanceof HTMLElement ? e.target : null;
+      const cellInfo = getCellInfo(target) || getCellInfoFromPoint(e.clientX, e.clientY);
+      if (!cellInfo) return;
+      scheduleSelectionUpdate(cellInfo);
+    };
+
    const onMouseUp = () => {
      if (!isDraggingRef.current) return;
      isDraggingRef.current = false;
+      cellSelectionPointerRef.current = null;
+      stopAutoScroll();

      if (cellSelectionRafRef.current !== null) {
        cancelAnimationFrame(cellSelectionRafRef.current);
@@ -1194,6 +1344,8 @@ const DataGrid: React.FC<DataGridProps> = ({
        cancelAnimationFrame(cellSelectionScrollRafRef.current);
        cellSelectionScrollRafRef.current = null;
      }
+      stopAutoScroll();
+      cellSelectionPointerRef.current = null;
      isDraggingRef.current = false;
    };
  }, [cellEditMode, columnNames, columnIndexMap, updateCellSelection]);
@@ -1267,6 +1419,18 @@ const DataGrid: React.FC<DataGridProps> = ({

  const hasChanges = addedRows.length > 0 || Object.keys(modifiedRows).length > 0 || deletedRowKeys.size > 0;

+  const addedRowKeySet = useMemo(() => {
+      const next = new Set<string>();
+      addedRows.forEach((row) => {
+          const key = row?.[GONAVI_ROW_KEY];
+          if (key === undefined || key === null) return;
+          next.add(rowKeyStr(key));
+      });
+      return next;
+  }, [addedRows, rowKeyStr]);
+
+  const modifiedRowKeySet = useMemo(() => new Set(Object.keys(modifiedRows)), [modifiedRows]);
+
  const handleTableChange = (pag: any, filtersArg: any, sorter: any) => {
      if (isResizingRef.current) return; // Block sort if resizing
      if (sorter.field) {
@@ -1418,12 +1582,6 @@ const DataGrid: React.FC<DataGridProps> = ({
    setCellContextMenu(prev => ({ ...prev, visible: false }));
  }, [cellContextMenu, handleCellSave]);

-  const handleCellSetValue = useCallback(() => {
-    if (!cellContextMenu.record) return;
-    handleCellSave({ ...cellContextMenu.record, [cellContextMenu.dataIndex]: cellSetValueInput });
-    setCellContextMenu(prev => ({ ...prev, visible: false }));
-  }, [cellContextMenu, cellSetValueInput, handleCellSave]);
-
  const handleCellEditorSave = useCallback(() => {
      if (!cellEditorMeta) return;
      const apply = cellEditorApplyRef.current;
@@ -1746,6 +1904,11 @@ const DataGrid: React.FC<DataGridProps> = ({
                  {formatCellValue(text)}
              </div>
          ),
+          shouldCellUpdate: (record: Item, prevRecord: Item) => {
+              const rowKeyChanged = record?.[GONAVI_ROW_KEY] !== prevRecord?.[GONAVI_ROW_KEY];
+              if (rowKeyChanged) return true;
+              return !isCellValueEqualForDiff(record?.[key], prevRecord?.[key]);
+          },
          onHeaderCell: (column: any) => ({
              width: column.width,
              onResizeStart: handleResizeStart(key), // Only need start
@@ -1814,7 +1977,17 @@ const DataGrid: React.FC<DataGridProps> = ({
      const updates: any[] = [];
      const deletes: any[] = [];

-      addedRows.forEach(row => { const { [GONAVI_ROW_KEY]: _rowKey, ...vals } = row; inserts.push(vals); });
+      addedRows.forEach(row => {
+          const { [GONAVI_ROW_KEY]: _rowKey, ...vals } = row;
+          const normalizedValues: Record<string, any> = {};
+          Object.entries(vals).forEach(([col, val]) => {
+              const normalizedVal = normalizeCommitCellValue(col, val, 'insert');
+              if (normalizedVal !== undefined) {
+                  normalizedValues[col] = normalizedVal;
+              }
+          });
+          inserts.push(normalizedValues);
+      });
      deletedRowKeys.forEach(keyStr => {
          // Find original data
          const originalRow = data.find(d => rowKeyStr(d?.[GONAVI_ROW_KEY]) === keyStr) || addedRows.find(d => rowKeyStr(d?.[GONAVI_ROW_KEY]) === keyStr);
@@ -1847,8 +2020,16 @@ const DataGrid: React.FC<DataGridProps> = ({
              });
          }

-          if (Object.keys(values).length === 0) return;
-          updates.push({ keys: pkData, values });
+          const normalizedValues: Record<string, any> = {};
+          Object.entries(values).forEach(([col, val]) => {
+              const normalizedVal = normalizeCommitCellValue(col, val, 'update');
+              if (normalizedVal !== undefined) {
+                  normalizedValues[col] = normalizedVal;
+              }
+          });
+
+          if (Object.keys(normalizedValues).length === 0) return;
+          updates.push({ keys: pkData, values: normalizedValues });
      });

      if (inserts.length === 0 && updates.length === 0 && deletes.length === 0) {
@@ -2220,6 +2401,31 @@ const DataGrid: React.FC<DataGridProps> = ({
      header: { cell: ResizableTitle }
  }), []); 

+  const dataContextValue = useMemo(() => ({
+      selectedRowKeysRef,
+      displayDataRef,
+      handleCopyInsert,
+      handleCopyJson,
+      handleCopyCsv,
+      handleExportSelected,
+      copyToClipboard,
+      tableName,
+      enableRowContextMenu: !canModifyData,
+  }), [handleCopyCsv, handleCopyInsert, handleCopyJson, handleExportSelected, copyToClipboard, tableName, canModifyData]);
+
+  const cellContextMenuValue = useMemo(() => ({
+      showMenu: showCellContextMenu,
+      handleBatchFillToSelected,
+  }), [showCellContextMenu, handleBatchFillToSelected]);
+
+  const rowSelectionConfig = useMemo(() => ({
+      selectedRowKeys,
+      onChange: setSelectedRowKeys,
+      columnWidth: selectionColumnWidth,
+  }), [selectedRowKeys, selectionColumnWidth]);
+
+  const rowPropsFactory = useCallback((record: any) => ({ record } as any), []);
+
  const totalWidth = columns.reduce((sum, col) => sum + (Number(col.width) || 200), 0) + selectionColumnWidth;
  const enableVirtual = mergedDisplayData.length >= 200;
  const tableScrollX = useMemo(() => {
@@ -2277,6 +2483,7 @@ const DataGrid: React.FC<DataGridProps> = ({
                                currentSelectionRef.current = new Set();
                                selectionStartRef.current = null;
                                isDraggingRef.current = false;
+                                cellSelectionPointerRef.current = null;
                                if (cellSelectionRafRef.current !== null) {
                                    cancelAnimationFrame(cellSelectionRafRef.current);
                                    cellSelectionRafRef.current = null;
@@ -2285,6 +2492,10 @@ const DataGrid: React.FC<DataGridProps> = ({
                                    cancelAnimationFrame(cellSelectionScrollRafRef.current);
                                    cellSelectionScrollRafRef.current = null;
                                }
+                                if (cellSelectionAutoScrollRafRef.current !== null) {
+                                    cancelAnimationFrame(cellSelectionAutoScrollRafRef.current);
+                                    cellSelectionAutoScrollRafRef.current = null;
+                                }
                                updateCellSelection(new Set());
                                if (!next) setBatchEditModalOpen(false);
                                message.info(next ? '已进入单元格编辑模式，可拖拽选择多个单元格' : '已退出单元格编辑模式');
@@ -2326,6 +2537,26 @@ const DataGrid: React.FC<DataGridProps> = ({
               </>
           )}

+           {isDuckDBConnection && onRequestTotalCount && (
+               <>
+                   <div style={{ width: 1, background: '#eee', height: 20, margin: '0 8px' }} />
+                   <Tooltip title={pagination?.totalCountLoading ? '取消本次精确总数统计（不会影响当前浏览）' : '按当前筛选统计精确总数'}>
+                       <Button
+                           icon={pagination?.totalCountLoading ? <CloseOutlined /> : <VerticalAlignBottomOutlined />}
+                           onClick={() => {
+                               if (pagination?.totalCountLoading) {
+                                   if (onCancelTotalCount) onCancelTotalCount();
+                                   return;
+                               }
+                               onRequestTotalCount();
+                           }}
+                       >
+                           {pagination?.totalCountLoading ? '取消统计' : '统计总数'}
+                       </Button>
+                   </Tooltip>
+               </>
+           )}
+
           <div style={{ marginLeft: 'auto' }} />
 	           <div style={{ flexShrink: 0 }}>
 	               <Popover
@@ -2348,12 +2579,26 @@ const DataGrid: React.FC<DataGridProps> = ({
 	                   onChange={(val) => {
 	                       const nextMode = String(val) as GridViewMode;
 	                       if (nextMode === 'json' && cellEditMode) {
-	                           setCellEditMode(false);
-	                           setSelectedCells(new Set());
-	                           currentSelectionRef.current = new Set();
-	                           selectionStartRef.current = null;
-	                           updateCellSelection(new Set());
-	                       }
+                           setCellEditMode(false);
+                           setSelectedCells(new Set());
+                           currentSelectionRef.current = new Set();
+                           selectionStartRef.current = null;
+                           isDraggingRef.current = false;
+                           cellSelectionPointerRef.current = null;
+                           if (cellSelectionRafRef.current !== null) {
+                               cancelAnimationFrame(cellSelectionRafRef.current);
+                               cellSelectionRafRef.current = null;
+                           }
+                           if (cellSelectionScrollRafRef.current !== null) {
+                               cancelAnimationFrame(cellSelectionScrollRafRef.current);
+                               cellSelectionScrollRafRef.current = null;
+                           }
+                           if (cellSelectionAutoScrollRafRef.current !== null) {
+                               cancelAnimationFrame(cellSelectionAutoScrollRafRef.current);
+                               cellSelectionAutoScrollRafRef.current = null;
+                           }
+                           updateCellSelection(new Set());
+                       }
 	                       if (nextMode === 'text') {
 	                           const selectedKey = selectedRowKeys[0];
 	                           if (selectedKey !== undefined) {
@@ -2600,8 +2845,8 @@ const DataGrid: React.FC<DataGridProps> = ({

        {viewMode === 'table' ? (
            <Form component={false} form={form}>
-                <DataContext.Provider value={{ selectedRowKeysRef, displayDataRef, handleCopyInsert, handleCopyJson, handleCopyCsv, handleExportSelected, copyToClipboard, tableName, enableRowContextMenu: !canModifyData }}>
-                    <CellContextMenuContext.Provider value={{ showMenu: showCellContextMenu, handleBatchFillToSelected }}>
+                <DataContext.Provider value={dataContextValue}>
+                    <CellContextMenuContext.Provider value={cellContextMenuValue}>
                            <EditableContext.Provider value={form}>
                                <Table
                                    components={tableComponents}
@@ -2613,23 +2858,21 @@ const DataGrid: React.FC<DataGridProps> = ({
                                    scroll={{ x: tableScrollX, y: tableHeight }}
                                    sticky={tableStickyConfig}
                                    virtual={enableVirtual}
-                                    loading={loading}
+                                        loading={loading}
                                        rowKey={GONAVI_ROW_KEY}
                                        pagination={false}
                                        onChange={handleTableChange}
                                        bordered
-                                        rowSelection={{
-                                            selectedRowKeys,
-                                            onChange: setSelectedRowKeys,
-                                            columnWidth: selectionColumnWidth,
-                                        }}
+                                        rowSelection={rowSelectionConfig}
                                        rowClassName={(record) => {
                                            const k = record?.[GONAVI_ROW_KEY];
-                                            if (k !== undefined && addedRows.some(r => r?.[GONAVI_ROW_KEY] === k)) return 'row-added';
-                                            if (k !== undefined && (modifiedRows[rowKeyStr(k)] || deletedRowKeys.has(rowKeyStr(k)))) return 'row-modified'; // deleted won't show
+                                            if (k === undefined || k === null) return '';
+                                            const keyStr = rowKeyStr(k);
+                                            if (addedRowKeySet.has(keyStr)) return 'row-added';
+                                            if (modifiedRowKeySet.has(keyStr) || deletedRowKeys.has(keyStr)) return 'row-modified'; // deleted won't show
                                            return '';
                                        }}
-                                        onRow={(record) => ({ record } as any)}
+                                        onRow={rowPropsFactory}
                                    />
                            </EditableContext.Provider>
                    </CellContextMenuContext.Provider>
@@ -2878,8 +3121,20 @@ const DataGrid: React.FC<DataGridProps> = ({
                   pageSize={pagination.pageSize}
                   total={pagination.total}
                   showTotal={(total, range) => {
-                       const currentCount = Math.max(0, range[1] - range[0] + 1);
-                       if (pagination.totalKnown === false) return `当前 ${currentCount} 条 / 正在统计总数...`;
+                       const hasValidRange = Array.isArray(range) && range[0] > 0 && range[1] >= range[0];
+                       const currentCount = hasValidRange ? Math.max(0, range[1] - range[0] + 1) : 0;
+                       if (pagination.totalKnown === false) {
+                           if (isDuckDBConnection) {
+                               if (pagination.totalCountLoading) return `当前 ${currentCount} 条 / 正在统计精确总数...`;
+                               if (pagination.totalApprox && Number.isFinite(total) && total > 0) return `当前 ${currentCount} 条 / 约 ${total} 条`;
+                               if (pagination.totalCountCancelled) return `当前 ${currentCount} 条 / 已取消统计`;
+                               return `当前 ${currentCount} 条 / 总数未统计`;
+                           }
+                           return `当前 ${currentCount} 条 / 正在统计总数...`;
+                       }
+                       if (isDuckDBConnection && (!Number.isFinite(total) || total <= 0)) {
+                           return '当前 0 条 / 共 0 条';
+                       }
                       return `当前 ${currentCount} 条 / 共 ${total} 条`;
                   }}
                   showSizeChanger
--- a/frontend/src/components/DataViewer.tsx
+++ b/frontend/src/components/DataViewer.tsx
@@ -2,10 +2,112 @@ import React, { useEffect, useState, useCallback, useRef } from 'react';
 import { message } from 'antd';
 import { TabData, ColumnDefinition } from '../types';
 import { useStore } from '../store';
-import { DBQuery, DBGetColumns } from '../../wailsjs/go/app/App';
+import { DBQuery, DBGetColumns, DBQueryIsolated } from '../../wailsjs/go/app/App';
 import DataGrid, { GONAVI_ROW_KEY } from './DataGrid';
 import { buildOrderBySQL, buildWhereSQL, quoteQualifiedIdent, withSortBufferTuningSQL, type FilterCondition } from '../utils/sql';

+type ViewerPaginationState = {
+  current: number;
+  pageSize: number;
+  total: number;
+  totalKnown: boolean;
+  totalApprox: boolean;
+  totalCountLoading: boolean;
+  totalCountCancelled: boolean;
+};
+
+const toNonNegativeFiniteNumber = (value: unknown): number | null => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) && value >= 0 ? value : null;
+  }
+  if (typeof value === 'bigint') {
+    return value >= 0n ? Number(value) : null;
+  }
+  if (typeof value === 'string') {
+    const text = value.trim();
+    if (!text) return null;
+    const parsed = Number(text);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+  }
+  return null;
+};
+
+const parseTotalFromCountRow = (row: any): number | null => {
+  if (!row || typeof row !== 'object') return null;
+  const entries = Object.entries(row as Record<string, unknown>);
+  if (entries.length === 0) return null;
+
+  for (const [key, raw] of entries) {
+    const normalized = String(key || '').trim().toLowerCase();
+    if (normalized === 'total' || normalized === 'count' || normalized.includes('count')) {
+      const parsed = toNonNegativeFiniteNumber(raw);
+      if (parsed !== null) return parsed;
+    }
+  }
+
+  for (const [, raw] of entries) {
+    const parsed = toNonNegativeFiniteNumber(raw);
+    if (parsed !== null) return parsed;
+  }
+
+  return null;
+};
+
+const parseDuckDBApproxTotalRow = (row: any): number | null => {
+  if (!row || typeof row !== 'object') return null;
+  const entries = Object.entries(row as Record<string, unknown>);
+  if (entries.length === 0) return null;
+
+  const preferredKeys = ['approx_total', 'estimated_size', 'estimated_rows', 'row_count', 'count', 'total'];
+  for (const preferred of preferredKeys) {
+    for (const [key, raw] of entries) {
+      if (String(key || '').trim().toLowerCase() !== preferred) continue;
+      const parsed = toNonNegativeFiniteNumber(raw);
+      if (parsed !== null) return parsed;
+    }
+  }
+
+  for (const [key, raw] of entries) {
+    const normalized = String(key || '').trim().toLowerCase();
+    if (normalized.includes('estimate') || normalized.includes('row') || normalized.includes('count') || normalized.includes('total')) {
+      const parsed = toNonNegativeFiniteNumber(raw);
+      if (parsed !== null) return parsed;
+    }
+  }
+  return null;
+};
+
+const normalizeDuckDBIdentifier = (raw: string): string => {
+  const text = String(raw || '').trim();
+  if (text.length >= 2) {
+    const first = text[0];
+    const last = text[text.length - 1];
+    if ((first === '"' && last === '"') || (first === '`' && last === '`')) {
+      return text.slice(1, -1).trim();
+    }
+  }
+  return text;
+};
+
+const resolveDuckDBSchemaAndTable = (dbName: string, tableName: string) => {
+  const rawTable = String(tableName || '').trim();
+  if (!rawTable) return { schemaName: 'main', pureTableName: '' };
+
+  const parts = rawTable.split('.');
+  if (parts.length >= 2) {
+    const pureTableName = normalizeDuckDBIdentifier(parts[parts.length - 1]);
+    const schemaName = normalizeDuckDBIdentifier(parts[parts.length - 2]);
+    if (schemaName && pureTableName) {
+      return { schemaName, pureTableName };
+    }
+  }
+
+  const fallbackSchema = normalizeDuckDBIdentifier(String(dbName || '').trim()) || 'main';
+  return { schemaName: fallbackSchema, pureTableName: normalizeDuckDBIdentifier(rawTable) };
+};
+
+const escapeSQLLiteral = (value: string): string => String(value || '').replace(/'/g, "''");
+
 const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
  const [data, setData] = useState<any[]>([]);
  const [columnNames, setColumnNames] = useState<string[]>([]);
@@ -16,14 +118,26 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
  const fetchSeqRef = useRef(0);
  const countSeqRef = useRef(0);
  const countKeyRef = useRef<string>('');
+  const duckdbApproxSeqRef = useRef(0);
+  const duckdbApproxKeyRef = useRef<string>('');
+  const manualCountSeqRef = useRef(0);
+  const manualCountKeyRef = useRef<string>('');
  const pkSeqRef = useRef(0);
  const pkKeyRef = useRef<string>('');
+  const latestConfigRef = useRef<any>(null);
+  const latestDbTypeRef = useRef<string>('');
+  const latestDbNameRef = useRef<string>('');
+  const latestCountSqlRef = useRef<string>('');
+  const latestCountKeyRef = useRef<string>('');

-  const [pagination, setPagination] = useState({
+  const [pagination, setPagination] = useState<ViewerPaginationState>({
      current: 1,
      pageSize: 100,
      total: 0,
-      totalKnown: false
+      totalKnown: false,
+      totalApprox: false,
+      totalCountLoading: false,
+      totalCountCancelled: false,
  });

  const [sortInfo, setSortInfo] = useState<{ columnKey: string, order: string } | null>(null);
@@ -31,15 +145,108 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
  const [showFilter, setShowFilter] = useState(false);
  const [filterConditions, setFilterConditions] = useState<FilterCondition[]>([]);
  const currentConnType = (connections.find(c => c.id === tab.connectionId)?.config?.type || '').toLowerCase();
-  const forceReadOnly = currentConnType === 'tdengine';
+  const forceReadOnly = currentConnType === 'tdengine' || currentConnType === 'clickhouse';
+
+  const runIsolatedQuery = useCallback(async (queryConfig: any, dbName: string, sql: string) => {
+    return DBQueryIsolated(queryConfig as any, dbName, sql);
+  }, []);

  useEffect(() => {
    setPkColumns([]);
    pkKeyRef.current = '';
    countKeyRef.current = '';
-    setPagination(prev => ({ ...prev, current: 1, total: 0, totalKnown: false }));
+    duckdbApproxKeyRef.current = '';
+    manualCountKeyRef.current = '';
+    latestConfigRef.current = null;
+    latestDbTypeRef.current = '';
+    latestDbNameRef.current = '';
+    latestCountSqlRef.current = '';
+    latestCountKeyRef.current = '';
+    setPagination(prev => ({
+      ...prev,
+      current: 1,
+      total: 0,
+      totalKnown: false,
+      totalApprox: false,
+      totalCountLoading: false,
+      totalCountCancelled: false,
+    }));
  }, [tab.connectionId, tab.dbName, tab.tableName]);

+  const handleDuckDBManualCount = useCallback(async () => {
+    if (latestDbTypeRef.current !== 'duckdb') {
+      return;
+    }
+    const config = latestConfigRef.current;
+    const dbName = latestDbNameRef.current;
+    const countSql = latestCountSqlRef.current;
+    const countKey = latestCountKeyRef.current;
+
+    if (!config || !countSql || !countKey) {
+      message.warning('当前结果集尚未就绪，请先执行一次加载');
+      return;
+    }
+
+    manualCountKeyRef.current = countKey;
+    const countSeq = ++manualCountSeqRef.current;
+    const countStart = Date.now();
+    setPagination(prev => ({ ...prev, totalCountLoading: true, totalCountCancelled: false }));
+    const countConfig: any = { ...(config as any), timeout: 120 };
+
+    try {
+      const resCount = await runIsolatedQuery(countConfig, dbName, countSql);
+      const countDuration = Date.now() - countStart;
+      addSqlLog({
+        id: `log-${Date.now()}-duckdb-manual-count`,
+        timestamp: Date.now(),
+        sql: countSql,
+        status: resCount?.success ? 'success' : 'error',
+        duration: countDuration,
+        message: resCount?.success ? '' : String(resCount?.message || '统计失败'),
+        dbName
+      });
+
+      if (manualCountSeqRef.current !== countSeq) return;
+      if (manualCountKeyRef.current !== countKey) return;
+
+      if (!resCount?.success) {
+        setPagination(prev => ({ ...prev, totalCountLoading: false }));
+        message.error(String(resCount?.message || '统计总数失败'));
+        return;
+      }
+      if (!Array.isArray(resCount.data) || resCount.data.length === 0) {
+        setPagination(prev => ({ ...prev, totalCountLoading: false }));
+        return;
+      }
+
+      const total = parseTotalFromCountRow(resCount.data[0]);
+      if (total === null) {
+        setPagination(prev => ({ ...prev, totalCountLoading: false }));
+        message.error('统计结果解析失败');
+        return;
+      }
+
+      setPagination(prev => ({
+        ...prev,
+        total,
+        totalKnown: true,
+        totalApprox: false,
+        totalCountLoading: false,
+        totalCountCancelled: false,
+      }));
+    } catch (e: any) {
+      if (manualCountSeqRef.current !== countSeq) return;
+      if (manualCountKeyRef.current !== countKey) return;
+      setPagination(prev => ({ ...prev, totalCountLoading: false }));
+      message.error(`统计总数失败: ${String(e?.message || e)}`);
+    }
+  }, [addSqlLog, runIsolatedQuery]);
+
+  const handleDuckDBCancelManualCount = useCallback(() => {
+    manualCountSeqRef.current++;
+    setPagination(prev => ({ ...prev, totalCountLoading: false, totalCountCancelled: true }));
+  }, []);
+
  const fetchData = useCallback(async (page = pagination.current, size = pagination.pageSize) => {
    const seq = ++fetchSeqRef.current;
    setLoading(true);
@@ -157,25 +364,70 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
            const countKey = `${tab.connectionId}|${dbName}|${tableName}|${whereSQL}`;
            const derivedTotalKnown = !hasMore;
            const derivedTotal = derivedTotalKnown ? offset + resultData.length : page * size + 1;
+            const isDuckDB = dbTypeLower === 'duckdb';
+            const minExpectedTotal = hasMore ? offset + resultData.length + 1 : offset + resultData.length;
            if (derivedTotalKnown) countKeyRef.current = countKey;
+            latestConfigRef.current = config;
+            latestDbTypeRef.current = dbTypeLower;
+            latestDbNameRef.current = dbName;
+            latestCountSqlRef.current = countSql;
+            latestCountKeyRef.current = countKey;

            setPagination(prev => {
                if (derivedTotalKnown) {
-                    return { ...prev, current: page, pageSize: size, total: derivedTotal, totalKnown: true };
+                    return {
+                        ...prev,
+                        current: page,
+                        pageSize: size,
+                        total: derivedTotal,
+                        totalKnown: true,
+                        totalApprox: false,
+                        totalCountLoading: false,
+                        totalCountCancelled: false,
+                    };
                }
                if (prev.totalKnown && countKeyRef.current === countKey) {
-                    return { ...prev, current: page, pageSize: size };
+                    if (!isDuckDB) {
+                        return { ...prev, current: page, pageSize: size };
+                    }
+                    // 当当前页存在“下一页”信号时，已知总数至少应大于当前页末尾。
+                    // 若旧总数不满足该条件（例如历史统计值为 0），降级为未知总数并回退到 derivedTotal。
+                    if (Number.isFinite(prev.total) && prev.total >= minExpectedTotal) {
+                        return { ...prev, current: page, pageSize: size };
+                    }
                }
-                return { ...prev, current: page, pageSize: size, total: derivedTotal, totalKnown: false };
+                const keepManualCounting = prev.totalCountLoading && manualCountKeyRef.current === countKey;
+                if (isDuckDB && prev.totalApprox && duckdbApproxKeyRef.current === countKey && Number.isFinite(prev.total) && prev.total >= minExpectedTotal) {
+                    return {
+                        ...prev,
+                        current: page,
+                        pageSize: size,
+                        totalKnown: false,
+                        totalApprox: true,
+                        totalCountLoading: keepManualCounting,
+                        totalCountCancelled: false,
+                    };
+                }
+                return {
+                    ...prev,
+                    current: page,
+                    pageSize: size,
+                    total: derivedTotal,
+                    totalKnown: false,
+                    totalApprox: false,
+                    totalCountLoading: keepManualCounting,
+                    totalCountCancelled: keepManualCounting ? false : prev.totalCountCancelled,
+                };
            });

-            if (!derivedTotalKnown) {
+            const shouldRunAsyncCount = !derivedTotalKnown && !isDuckDB;
+            if (shouldRunAsyncCount) {
                if (countKeyRef.current !== countKey) {
                    countKeyRef.current = countKey;
                    const countSeq = ++countSeqRef.current;
                    const countStart = Date.now();
                    // 大表 COUNT(*) 可能非常慢，且在部分运行时环境下会影响后续操作响应；
-                    // 这里为统计请求设置更短的超时，避免“后台统计”长期占用资源。
+                    // DuckDB 大文件场景下该统计会显著拖慢翻页，已禁用后台 COUNT。
                    const countConfig: any = { ...(config as any), timeout: 5 };

                    DBQuery(countConfig, dbName, countSql)
@@ -198,10 +450,21 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
                            if (!resCount.success) return;
                            if (!Array.isArray(resCount.data) || resCount.data.length === 0) return;

-                            const total = Number(resCount.data[0]?.['total']);
-                            if (!Number.isFinite(total) || total < 0) return;
+                            let total: number | null = null;
+                            const parsed = Number(resCount.data[0]?.['total']);
+                            if (Number.isFinite(parsed) && parsed >= 0) {
+                                total = parsed;
+                            }
+                            if (total === null) return;

-                            setPagination(prev => ({ ...prev, total, totalKnown: true }));
+                            setPagination(prev => ({
+                                ...prev,
+                                total,
+                                totalKnown: true,
+                                totalApprox: false,
+                                totalCountLoading: false,
+                                totalCountCancelled: false,
+                            }));
                        })
                        .catch(() => {
                            if (countSeqRef.current !== countSeq) return;
@@ -210,6 +473,50 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
                        });
                }
            }
+
+            if (isDuckDB && !derivedTotalKnown && whereSQL.trim() === '' && duckdbApproxKeyRef.current !== countKey) {
+                duckdbApproxKeyRef.current = countKey;
+                const approxSeq = ++duckdbApproxSeqRef.current;
+                const { schemaName, pureTableName } = resolveDuckDBSchemaAndTable(dbName, tableName);
+                const escapedSchema = escapeSQLLiteral(schemaName);
+                const escapedTable = escapeSQLLiteral(pureTableName);
+                const approxConfig: any = { ...(config as any), timeout: 3 };
+                const approxSqlCandidates = [
+                    `SELECT estimated_size AS approx_total FROM duckdb_tables() WHERE schema_name='${escapedSchema}' AND table_name='${escapedTable}' LIMIT 1`,
+                    `SELECT estimated_size AS approx_total FROM duckdb_tables() WHERE table_name='${escapedTable}' ORDER BY CASE WHEN schema_name='${escapedSchema}' THEN 0 ELSE 1 END LIMIT 1`,
+                ];
+
+                (async () => {
+                    for (const approxSql of approxSqlCandidates) {
+                        try {
+                            const approxRes = await runIsolatedQuery(approxConfig, dbName, approxSql);
+                            if (duckdbApproxSeqRef.current !== approxSeq) return;
+                            if (countKeyRef.current !== countKey) return;
+                            if (!approxRes?.success || !Array.isArray(approxRes.data) || approxRes.data.length === 0) continue;
+
+                            const approxTotal = parseDuckDBApproxTotalRow(approxRes.data[0]);
+                            if (approxTotal === null) continue;
+                            if (!Number.isFinite(approxTotal) || approxTotal < minExpectedTotal) continue;
+
+                            setPagination(prev => {
+                                if (countKeyRef.current !== countKey) return prev;
+                                if (prev.totalKnown) return prev;
+                                return {
+                                    ...prev,
+                                    total: approxTotal,
+                                    totalKnown: false,
+                                    totalApprox: true,
+                                    totalCountCancelled: false,
+                                };
+                            });
+                            return;
+                        } catch {
+                            if (duckdbApproxSeqRef.current !== approxSeq) return;
+                            if (countKeyRef.current !== countKey) return;
+                        }
+                    }
+                })();
+            }
        } else {
            message.error(String(resData.message || '查询失败'));
        }
@@ -227,7 +534,7 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
        });
    }
    if (fetchSeqRef.current === seq) setLoading(false);
-  }, [connections, tab, sortInfo, filterConditions, pkColumns]); 
+  }, [connections, tab, sortInfo, filterConditions, pkColumns, runIsolatedQuery]); 
  // 依赖 pkColumns：在无手动排序时可回退到主键稳定排序。
  // 主键信息只会在首次加载后更新一次，避免循环查询。

@@ -266,6 +573,8 @@ const DataViewer: React.FC<{ tab: TabData }> = ({ tab }) => {
          onSort={handleSort}
          onPageChange={handlePageChange}
          pagination={pagination}
+          onRequestTotalCount={currentConnType === 'duckdb' ? handleDuckDBManualCount : undefined}
+          onCancelTotalCount={currentConnType === 'duckdb' ? handleDuckDBCancelManualCount : undefined}
          showFilter={showFilter}
          onToggleFilter={handleToggleFilter}
          onApplyFilter={handleApplyFilter}
--- a/frontend/src/components/DriverManagerModal.tsx
+++ b/frontend/src/components/DriverManagerModal.tsx
--- a/frontend/src/components/QueryEditor.tsx
+++ b/frontend/src/components/QueryEditor.tsx
@@ -922,7 +922,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {

  const applyAutoLimit = (sql: string, dbType: string, maxRows: number): { sql: string; applied: boolean; maxRows: number } => {
      const normalizedType = (dbType || 'mysql').toLowerCase();
-      const supportsLimit = normalizedType === 'mysql' || normalizedType === 'mariadb' || normalizedType === 'diros' || normalizedType === 'sphinx' || normalizedType === 'postgres' || normalizedType === 'kingbase' || normalizedType === 'sqlite' || normalizedType === 'duckdb' || normalizedType === 'tdengine' || normalizedType === '';
+      const supportsLimit = normalizedType === 'mysql' || normalizedType === 'mariadb' || normalizedType === 'diros' || normalizedType === 'sphinx' || normalizedType === 'postgres' || normalizedType === 'kingbase' || normalizedType === 'sqlite' || normalizedType === 'duckdb' || normalizedType === 'tdengine' || normalizedType === 'clickhouse' || normalizedType === '';
      if (!supportsLimit) return { sql, applied: false, maxRows };
      if (!Number.isFinite(maxRows) || maxRows <= 0) return { sql, applied: false, maxRows };

@@ -1001,7 +1001,7 @@ const QueryEditor: React.FC<{ tab: TabData }> = ({ tab }) => {
        const maxRows = Number(queryOptions?.maxRows) || 0;
        const dbType = String((config as any).type || 'mysql');
        const normalizedDbType = dbType.toLowerCase();
-        const forceReadOnlyResult = normalizedDbType === 'tdengine';
+        const forceReadOnlyResult = normalizedDbType === 'tdengine' || normalizedDbType === 'clickhouse';
        const wantsLimitProbe = Number.isFinite(maxRows) && maxRows > 0;
        const probeLimit = wantsLimitProbe ? (maxRows + 1) : 0;
        let anyTruncated = false;
--- a/frontend/src/components/RedisViewer.tsx
+++ b/frontend/src/components/RedisViewer.tsx
@@ -14,6 +14,12 @@ const REDIS_TREE_KEY_TYPE_WIDTH = 92;
 const REDIS_TREE_KEY_TYPE_WIDTH_NARROW = 84;
 const REDIS_TREE_KEY_TTL_WIDTH = 92;
 const REDIS_TREE_HIDE_TTL_THRESHOLD = 460;
+const REDIS_KEY_INITIAL_LOAD_COUNT = 2000;
+const REDIS_KEY_LOAD_MORE_COUNT = 2000;
+const REDIS_KEY_SEARCH_INITIAL_LOAD_COUNT = 600;
+const REDIS_KEY_SEARCH_LOAD_MORE_COUNT = 1000;
+const REDIS_LARGE_KEYSPACE_THRESHOLD = 10000;
+const REDIS_LARGE_KEYSPACE_MAX_EXPANDED_GROUPS = 200;

 interface RedisViewerProps {
    connectionId: string;
@@ -212,18 +218,17 @@ const ResizableDivider: React.FC<{
        <div
            onMouseDown={handleMouseDown}
            style={{
-                width: 6,
+                width: 5,
                cursor: 'col-resize',
-                background: '#f0f0f0',
+                background: 'transparent',
                flexShrink: 0,
                display: 'flex',
                alignItems: 'center',
-                justifyContent: 'center'
+                justifyContent: 'center',
+                zIndex: 10,
            }}
-            onMouseEnter={(e) => (e.currentTarget.style.background = '#d9d9d9')}
-            onMouseLeave={(e) => (e.currentTarget.style.background = '#f0f0f0')}
+            title="拖动调整宽度"
        >
-            <div style={{ width: 2, height: 30, background: '#bfbfbf', borderRadius: 1 }} />
        </div>
    );
 };
@@ -239,36 +244,79 @@ type RedisKeyTreeGroup = {
    path: string;
    children: Map<string, RedisKeyTreeGroup>;
    leaves: RedisKeyTreeLeaf[];
+    leafCount: number;
 };

 type RedisKeyTreeResult = {
-    treeData: DataNode[];
-    rawKeyByNodeKey: Map<string, string>;
-    leafNodeKeyByRawKey: Map<string, string>;
+    treeData: RedisTreeDataNode[];
    groupKeys: string[];
 };

+type RedisTreeDataNode = DataNode & {
+    nodeType: 'group' | 'leaf';
+    groupName?: string;
+    groupLeafCount?: number;
+    leafLabel?: string;
+    rawKey?: string;
+    keyType?: string;
+    ttl?: number;
+};
+
+const buildLeafNodeKey = (rawKey: string): string => `key:${rawKey}`;
+
+const parseRawKeyFromNodeKey = (nodeKey: React.Key): string | null => {
+    const keyText = String(nodeKey);
+    if (!keyText.startsWith('key:')) {
+        return null;
+    }
+    return keyText.slice(4);
+};
+
+const getRedisScanLoadCount = (pattern: string, append: boolean): number => {
+    const normalizedPattern = pattern.trim() || '*';
+    if (normalizedPattern === '*') {
+        return append ? REDIS_KEY_LOAD_MORE_COUNT : REDIS_KEY_INITIAL_LOAD_COUNT;
+    }
+    return append ? REDIS_KEY_SEARCH_LOAD_MORE_COUNT : REDIS_KEY_SEARCH_INITIAL_LOAD_COUNT;
+};
+
+const normalizeRedisCursor = (value: unknown): string => {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed === '' ? '0' : trimmed;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            return '0';
+        }
+        return Math.trunc(value).toString();
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    return '0';
+};
+
 const normalizeKeySegment = (segment: string): string => {
    return segment === '' ? EMPTY_SEGMENT_LABEL : segment;
 };

 const createTreeGroup = (name: string, path: string): RedisKeyTreeGroup => {
-    return { name, path, children: new Map(), leaves: [] };
+    return { name, path, children: new Map(), leaves: [], leafCount: 0 };
 };

-const countGroupLeafNodes = (group: RedisKeyTreeGroup): number => {
+const calculateGroupLeafCount = (group: RedisKeyTreeGroup): number => {
    let count = group.leaves.length;
    group.children.forEach((child) => {
-        count += countGroupLeafNodes(child);
+        count += calculateGroupLeafCount(child);
    });
+    group.leafCount = count;
    return count;
 };

 const buildRedisKeyTree = (
    keys: RedisKeyInfo[],
-    formatTTL: (ttl: number) => string,
-    getTypeColor: (type: string) => string,
-    showTTL: boolean
+    sortLeafNodes: boolean
 ): RedisKeyTreeResult => {
    const root = createTreeGroup('__root__', '__root__');

@@ -298,105 +346,41 @@ const buildRedisKeyTree = (

        current.leaves.push({ keyInfo, label: leafLabel });
    });
+    calculateGroupLeafCount(root);

-    const rawKeyByNodeKey = new Map<string, string>();
-    const leafNodeKeyByRawKey = new Map<string, string>();
    const groupKeys: string[] = [];

-    const toTreeNodes = (group: RedisKeyTreeGroup): DataNode[] => {
+    const toTreeNodes = (group: RedisKeyTreeGroup): RedisTreeDataNode[] => {
        const childGroups = Array.from(group.children.values()).sort((a, b) => a.name.localeCompare(b.name));
-        const childLeaves = [...group.leaves].sort((a, b) => a.keyInfo.key.localeCompare(b.keyInfo.key));
+        const childLeaves = sortLeafNodes
+            ? [...group.leaves].sort((a, b) => a.keyInfo.key.localeCompare(b.keyInfo.key))
+            : group.leaves;

-        const groupNodes: DataNode[] = childGroups.map((child) => {
+        const groupNodes: RedisTreeDataNode[] = childGroups.map((child) => {
            const groupNodeKey = `group:${child.path}`;
            groupKeys.push(groupNodeKey);
            return {
                key: groupNodeKey,
-                title: (
-                    <Space size={6}>
-                        <FolderOpenOutlined style={{ color: '#8c8c8c' }} />
-                        <span>{child.name}</span>
-                        <span style={{ fontSize: 12, color: '#999' }}>({countGroupLeafNodes(child)})</span>
-                    </Space>
-                ),
+                title: child.name,
+                nodeType: 'group',
+                groupName: child.name,
+                groupLeafCount: child.leafCount,
                selectable: false,
                disableCheckbox: true,
                children: toTreeNodes(child),
            };
        });

-        const leafNodes: DataNode[] = childLeaves.map((leaf) => {
-            const nodeKey = `key:${leaf.keyInfo.key}`;
-            rawKeyByNodeKey.set(nodeKey, leaf.keyInfo.key);
-            leafNodeKeyByRawKey.set(leaf.keyInfo.key, nodeKey);
+        const leafNodes: RedisTreeDataNode[] = childLeaves.map((leaf) => {
            return {
-                key: nodeKey,
+                key: buildLeafNodeKey(leaf.keyInfo.key),
                isLeaf: true,
-                title: (
-                    <div
-                        style={{
-                            display: 'flex',
-                            alignItems: 'center',
-                            gap: 8,
-                            minWidth: 0,
-                            width: '100%',
-                            overflow: 'hidden',
-                        }}
-                    >
-                        <div
-                            style={{
-                                display: 'flex',
-                                alignItems: 'center',
-                                gap: 6,
-                                minWidth: 0,
-                                flex: 1,
-                                overflow: 'hidden',
-                            }}
-                        >
-                            <KeyOutlined style={{ color: '#1677ff', flexShrink: 0 }} />
-                            <Tooltip title={leaf.keyInfo.key}>
-                                <span
-                                    style={{
-                                        minWidth: 0,
-                                        overflow: 'hidden',
-                                        textOverflow: 'ellipsis',
-                                        whiteSpace: 'nowrap',
-                                        display: 'block',
-                                    }}
-                                >
-                                    {leaf.label}
-                                </span>
-                            </Tooltip>
-                        </div>
-                        <Tag
-                            color={getTypeColor(leaf.keyInfo.type)}
-                            style={{
-                                marginInlineEnd: 0,
-                                width: showTTL ? REDIS_TREE_KEY_TYPE_WIDTH : REDIS_TREE_KEY_TYPE_WIDTH_NARROW,
-                                textAlign: 'center',
-                                flexShrink: 0
-                            }}
-                        >
-                            {leaf.keyInfo.type}
-                        </Tag>
-                        {showTTL && (
-                            <span
-                                style={{
-                                    width: REDIS_TREE_KEY_TTL_WIDTH,
-                                    fontSize: 12,
-                                    color: '#999',
-                                    textAlign: 'left',
-                                    whiteSpace: 'nowrap',
-                                    flexShrink: 0,
-                                    overflow: 'hidden',
-                                    textOverflow: 'ellipsis',
-                                }}
-                            >
-                                {formatTTL(leaf.keyInfo.ttl)}
-                            </span>
-                        )}
-                    </div>
-                ),
+                title: leaf.label,
+                nodeType: 'leaf',
+                leafLabel: leaf.label,
+                rawKey: leaf.keyInfo.key,
+                keyType: leaf.keyInfo.type,
+                ttl: leaf.keyInfo.ttl,
            };
        });

@@ -405,8 +389,6 @@ const buildRedisKeyTree = (

    return {
        treeData: toTreeNodes(root),
-        rawKeyByNodeKey,
-        leafNodeKeyByRawKey,
        groupKeys,
    };
 };
@@ -418,7 +400,7 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
    const [keys, setKeys] = useState<RedisKeyInfo[]>([]);
    const [loading, setLoading] = useState(false);
    const [searchPattern, setSearchPattern] = useState('*');
-    const [cursor, setCursor] = useState<number>(0);
+    const [cursor, setCursor] = useState<string>('0');
    const [hasMore, setHasMore] = useState(false);
    const [selectedKey, setSelectedKey] = useState<string | null>(null);
    const [keyValue, setKeyValue] = useState<RedisValue | null>(null);
@@ -443,11 +425,14 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
        onSave: (newValue: string) => Promise<void>;
    } | null>(null);
    const jsonEditValueRef = useRef<string>('');
+    const latestLoadRequestIdRef = useRef(0);

    // 面板宽度状态和 ref - 默认占据 50% 宽度
    const [leftPanelWidth, setLeftPanelWidth] = useState<number | string>('50%');
    const leftPanelRef = useRef<HTMLDivElement>(null);
+    const treeContainerRef = useRef<HTMLDivElement>(null);
    const [showTreeKeyTTL, setShowTreeKeyTTL] = useState(true);
+    const [treeHeight, setTreeHeight] = useState(500);
    const [expandedGroupKeys, setExpandedGroupKeys] = useState<string[]>([]);

    const getConfig = useCallback(() => {
@@ -462,55 +447,78 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
        };
    }, [connection, redisDB]);

-    const loadKeys = useCallback(async (pattern: string = '*', fromCursor: number = 0, append: boolean = false) => {
+    const loadKeys = useCallback(async (
+        pattern: string = '*',
+        fromCursor: string = '0',
+        append: boolean = false,
+        targetCount?: number
+    ) => {
        const config = getConfig();
        if (!config) return;

+        const normalizedPattern = pattern.trim() || '*';
+        const effectiveTargetCount = targetCount ?? getRedisScanLoadCount(normalizedPattern, append);
+        const requestId = latestLoadRequestIdRef.current + 1;
+        latestLoadRequestIdRef.current = requestId;
+
        setLoading(true);
        try {
-            const res = await (window as any).go.app.App.RedisScanKeys(config, pattern, fromCursor, 100);
+            const res = await (window as any).go.app.App.RedisScanKeys(config, normalizedPattern, fromCursor, effectiveTargetCount);
+            if (requestId !== latestLoadRequestIdRef.current) {
+                return;
+            }
            if (res.success) {
                const result = res.data;
+                const scannedKeys = Array.isArray(result?.keys) ? result.keys : [];
+                const nextCursor = normalizeRedisCursor(result?.cursor);
                if (append) {
                    setKeys(prev => {
                        const keyMap = new Map<string, RedisKeyInfo>();
                        prev.forEach(item => keyMap.set(item.key, item));
-                        result.keys.forEach((item: RedisKeyInfo) => keyMap.set(item.key, item));
+                        scannedKeys.forEach((item: RedisKeyInfo) => keyMap.set(item.key, item));
                        return Array.from(keyMap.values());
                    });
                } else {
-                    setKeys(result.keys);
+                    setKeys(scannedKeys);
                }
-                setCursor(result.cursor);
-                setHasMore(result.cursor !== 0);
+                setCursor(nextCursor);
+                setHasMore(nextCursor !== '0');
            } else {
                message.error('加载 Key 失败: ' + res.message);
            }
        } catch (e: any) {
+            if (requestId !== latestLoadRequestIdRef.current) {
+                return;
+            }
            message.error('加载 Key 失败: ' + (e?.message || String(e)));
        } finally {
-            setLoading(false);
+            if (requestId === latestLoadRequestIdRef.current) {
+                setLoading(false);
+            }
        }
    }, [getConfig]);

    useEffect(() => {
-        loadKeys(searchPattern, 0, false);
+        loadKeys(searchPattern, '0', false, getRedisScanLoadCount(searchPattern, false));
    }, [redisDB]);

    const handleSearch = (value: string) => {
        const pattern = value.trim() || '*';
        setSearchPattern(pattern);
-        setCursor(0);
-        loadKeys(pattern, 0, false);
+        setCursor('0');
+        loadKeys(pattern, '0', false, getRedisScanLoadCount(pattern, false));
    };

    const handleLoadMore = () => {
-        loadKeys(searchPattern, cursor, true);
+        if (!hasMore || loading) {
+            return;
+        }
+        loadKeys(searchPattern, cursor, true, getRedisScanLoadCount(searchPattern, true));
    };

    const handleRefresh = () => {
-        setCursor(0);
-        loadKeys(searchPattern, 0, false);
+        setCursor('0');
+        loadKeys(searchPattern, '0', false, getRedisScanLoadCount(searchPattern, false));
    };

    const loadKeyValue = async (key: string) => {
@@ -666,23 +674,51 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
        return () => window.removeEventListener('resize', handleWindowResize);
    }, []);

+    useEffect(() => {
+        const target = treeContainerRef.current;
+        if (!target) return;
+
+        const updateTreeHeight = (nextHeight: number) => {
+            if (nextHeight <= 0) return;
+            setTreeHeight((prev) => (prev === nextHeight ? prev : nextHeight));
+        };
+
+        updateTreeHeight(Math.round(target.getBoundingClientRect().height));
+
+        if (typeof ResizeObserver !== 'undefined') {
+            const observer = new ResizeObserver((entries) => {
+                const nextHeight = Math.round(entries[0]?.contentRect.height || target.getBoundingClientRect().height);
+                updateTreeHeight(nextHeight);
+            });
+            observer.observe(target);
+            return () => observer.disconnect();
+        }
+
+        const handleWindowResize = () => {
+            updateTreeHeight(Math.round(target.getBoundingClientRect().height));
+        };
+        window.addEventListener('resize', handleWindowResize);
+        return () => window.removeEventListener('resize', handleWindowResize);
+    }, []);
+
+    const isLargeKeyspace = keys.length >= REDIS_LARGE_KEYSPACE_THRESHOLD;
+
    const keyTree = useMemo(() => {
-        return buildRedisKeyTree(keys, formatTTL, getTypeColor, showTreeKeyTTL);
-    }, [keys, showTreeKeyTTL]);
+        return buildRedisKeyTree(keys, !isLargeKeyspace);
+    }, [isLargeKeyspace, keys]);
+
+    const groupKeySet = useMemo(() => new Set(keyTree.groupKeys), [keyTree.groupKeys]);

    const selectedTreeNodeKeys = useMemo(() => {
        if (!selectedKey) {
            return [] as string[];
        }
-        const nodeKey = keyTree.leafNodeKeyByRawKey.get(selectedKey);
-        return nodeKey ? [nodeKey] : [];
-    }, [selectedKey, keyTree]);
+        return [buildLeafNodeKey(selectedKey)];
+    }, [selectedKey]);

    const checkedTreeNodeKeys = useMemo(() => {
-        return selectedKeys
-            .map(rawKey => keyTree.leafNodeKeyByRawKey.get(rawKey))
-            .filter((nodeKey): nodeKey is string => Boolean(nodeKey));
-    }, [selectedKeys, keyTree]);
+        return selectedKeys.map(rawKey => buildLeafNodeKey(rawKey));
+    }, [selectedKeys]);

    useEffect(() => {
        const existingKeySet = new Set(keys.map(item => item.key));
@@ -691,16 +727,19 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {

    useEffect(() => {
        setExpandedGroupKeys((prev) => {
-            const validKeys = prev.filter(nodeKey => keyTree.groupKeys.includes(nodeKey));
-            return validKeys;
+            const validKeys = prev.filter(nodeKey => groupKeySet.has(nodeKey));
+            if (!isLargeKeyspace) {
+                return validKeys;
+            }
+            return validKeys.slice(0, REDIS_LARGE_KEYSPACE_MAX_EXPANDED_GROUPS);
        });
-    }, [keyTree]);
+    }, [groupKeySet, isLargeKeyspace]);

    const handleTreeSelect = (nodeKeys: React.Key[]) => {
        if (nodeKeys.length === 0) {
            return;
        }
-        const rawKey = keyTree.rawKeyByNodeKey.get(String(nodeKeys[0]));
+        const rawKey = parseRawKeyFromNodeKey(nodeKeys[0]);
        if (!rawKey) {
            return;
        }
@@ -710,11 +749,119 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
    const handleTreeCheck = (checked: React.Key[] | { checked: React.Key[]; halfChecked: React.Key[] }) => {
        const checkedNodeKeys = Array.isArray(checked) ? checked : checked.checked;
        const rawKeys = checkedNodeKeys
-            .map(nodeKey => keyTree.rawKeyByNodeKey.get(String(nodeKey)))
+            .map(nodeKey => parseRawKeyFromNodeKey(nodeKey))
            .filter((rawKey): rawKey is string => Boolean(rawKey));
        setSelectedKeys(rawKeys);
    };

+    const renderTreeNodeTitle = useCallback((nodeData: DataNode) => {
+        const treeNode = nodeData as RedisTreeDataNode;
+
+        if (treeNode.nodeType === 'group') {
+            return (
+                <Space size={6}>
+                    <FolderOpenOutlined style={{ color: '#8c8c8c' }} />
+                    <span>{treeNode.groupName}</span>
+                    <span style={{ fontSize: 12, color: '#999' }}>({treeNode.groupLeafCount ?? 0})</span>
+                </Space>
+            );
+        }
+
+        const leafLabel = treeNode.leafLabel ?? '';
+        const rawKey = treeNode.rawKey ?? parseRawKeyFromNodeKey(treeNode.key ?? '') ?? '';
+        const keyType = treeNode.keyType ?? 'unknown';
+        const ttl = typeof treeNode.ttl === 'number' ? treeNode.ttl : -1;
+
+        if (isLargeKeyspace) {
+            return (
+                <div style={{ minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                    <span>{leafLabel}</span>
+                    <span style={{ marginLeft: 8, color: '#999', fontSize: 12 }}>[{keyType}]</span>
+                    {showTreeKeyTTL && (
+                        <span style={{ marginLeft: 8, color: '#999', fontSize: 12 }}>{formatTTL(ttl)}</span>
+                    )}
+                </div>
+            );
+        }
+
+        return (
+            <div
+                style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: 8,
+                    minWidth: 0,
+                    width: '100%',
+                    overflow: 'hidden',
+                }}
+            >
+                <div
+                    style={{
+                        display: 'flex',
+                        alignItems: 'center',
+                        gap: 6,
+                        minWidth: 0,
+                        flex: 1,
+                        overflow: 'hidden',
+                    }}
+                >
+                    <KeyOutlined style={{ color: '#1677ff', flexShrink: 0 }} />
+                    <Tooltip title={rawKey}>
+                        <span
+                            style={{
+                                minWidth: 0,
+                                overflow: 'hidden',
+                                textOverflow: 'ellipsis',
+                                whiteSpace: 'nowrap',
+                                display: 'block',
+                            }}
+                        >
+                            {leafLabel}
+                        </span>
+                    </Tooltip>
+                </div>
+                <Tag
+                    color={getTypeColor(keyType)}
+                    style={{
+                        marginInlineEnd: 0,
+                        width: showTreeKeyTTL ? REDIS_TREE_KEY_TYPE_WIDTH : REDIS_TREE_KEY_TYPE_WIDTH_NARROW,
+                        textAlign: 'center',
+                        flexShrink: 0
+                    }}
+                >
+                    {keyType}
+                </Tag>
+                {showTreeKeyTTL && (
+                    <span
+                        style={{
+                            width: REDIS_TREE_KEY_TTL_WIDTH,
+                            fontSize: 12,
+                            color: '#999',
+                            textAlign: 'left',
+                            whiteSpace: 'nowrap',
+                            flexShrink: 0,
+                            overflow: 'hidden',
+                            textOverflow: 'ellipsis',
+                        }}
+                    >
+                        {formatTTL(ttl)}
+                    </span>
+                )}
+            </div>
+        );
+    }, [formatTTL, getTypeColor, isLargeKeyspace, showTreeKeyTTL]);
+
+    const handleTreeExpand = (nextExpandedKeys: React.Key[]) => {
+        const validGroupKeys = nextExpandedKeys
+            .map(key => String(key))
+            .filter(nodeKey => groupKeySet.has(nodeKey));
+        if (isLargeKeyspace) {
+            setExpandedGroupKeys(validGroupKeys.slice(0, REDIS_LARGE_KEYSPACE_MAX_EXPANDED_GROUPS));
+            return;
+        }
+        setExpandedGroupKeys(validGroupKeys);
+    };
+
    const renderValueEditor = () => {
        if (!keyValue || !selectedKey) {
            return <div style={{ padding: 20, textAlign: 'center', color: '#999' }}>选择一个 Key 查看详情</div>;
@@ -1757,27 +1904,37 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
                        </Popconfirm>
                    </div>
                </div>
-                <div style={{ flex: 1, overflow: 'auto' }}>
-                    <Spin spinning={loading} size="small">
-                        <Tree
-                            blockNode
-                            showIcon={false}
-                            checkable
-                            checkStrictly
-                            selectable
-                            treeData={keyTree.treeData}
-                            selectedKeys={selectedTreeNodeKeys}
-                            checkedKeys={checkedTreeNodeKeys}
-                            expandedKeys={expandedGroupKeys}
-                            onExpand={(nextExpandedKeys) => setExpandedGroupKeys(nextExpandedKeys as string[])}
-                            onSelect={(nodeKeys) => handleTreeSelect(nodeKeys)}
-                            onCheck={(checked) => handleTreeCheck(checked)}
-                            style={{ padding: '8px 6px' }}
-                        />
-                    </Spin>
+                <div style={{ flex: 1, minHeight: 0, display: 'flex', flexDirection: 'column' }}>
+                    {isLargeKeyspace && (
+                        <div style={{ padding: '6px 8px', fontSize: 12, color: '#8c8c8c', borderBottom: '1px solid #f0f0f0' }}>
+                            已启用大数据量性能模式（简化节点渲染，最多保留 {REDIS_LARGE_KEYSPACE_MAX_EXPANDED_GROUPS} 个展开分组）
+                        </div>
+                    )}
+                    <div ref={treeContainerRef} style={{ flex: 1, minHeight: 0, overflow: 'hidden' }}>
+                        <Spin spinning={loading} size="small" style={{ width: '100%' }}>
+                            <Tree
+                                blockNode
+                                showIcon={false}
+                                checkable
+                                checkStrictly
+                                selectable
+                                virtual
+                                height={Math.max(treeHeight - 8, 220)}
+                                treeData={keyTree.treeData}
+                                titleRender={renderTreeNodeTitle}
+                                selectedKeys={selectedTreeNodeKeys}
+                                checkedKeys={checkedTreeNodeKeys}
+                                expandedKeys={expandedGroupKeys}
+                                onExpand={handleTreeExpand}
+                                onSelect={(nodeKeys) => handleTreeSelect(nodeKeys)}
+                                onCheck={(checked) => handleTreeCheck(checked)}
+                                style={{ padding: '8px 6px' }}
+                            />
+                        </Spin>
+                    </div>
                    {hasMore && (
                        <div style={{ padding: 8, textAlign: 'center' }}>
-                            <Button onClick={handleLoadMore} loading={loading}>加载更多</Button>
+                            <Button onClick={handleLoadMore} loading={loading} disabled={!hasMore || loading}>加载更多</Button>
                        </div>
                    )}
                </div>
--- a/frontend/src/components/Sidebar.tsx
+++ b/frontend/src/components/Sidebar.tsx
@@ -46,6 +46,17 @@ interface TreeNode {
 }

 type BatchTableExportMode = 'schema' | 'backup' | 'dataOnly';
+type BatchObjectType = 'table' | 'view';
+type BatchObjectFilterType = 'all' | BatchObjectType;
+type BatchSelectionScope = 'filtered' | 'all';
+
+interface BatchObjectItem {
+  title: string;
+  key: string;
+  objectName: string;
+  objectType: BatchObjectType;
+  dataRef: any;
+}

 const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }> = ({ onEditConnection }) => {
  const connections = useStore(state => state.connections);
@@ -118,12 +129,53 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>

  // Batch Operations Modal
  const [isBatchModalOpen, setIsBatchModalOpen] = useState(false);
-  const [batchTables, setBatchTables] = useState<any[]>([]);
+  const [batchTables, setBatchTables] = useState<BatchObjectItem[]>([]);
  const [checkedTableKeys, setCheckedTableKeys] = useState<string[]>([]);
  const [batchDbContext, setBatchDbContext] = useState<any>(null);
  const [selectedConnection, setSelectedConnection] = useState<string>('');
  const [selectedDatabase, setSelectedDatabase] = useState<string>('');
  const [availableDatabases, setAvailableDatabases] = useState<any[]>([]);
+  const [batchFilterKeyword, setBatchFilterKeyword] = useState<string>('');
+  const [batchFilterType, setBatchFilterType] = useState<BatchObjectFilterType>('all');
+  const [batchSelectionScope, setBatchSelectionScope] = useState<BatchSelectionScope>('filtered');
+  const filteredBatchObjects = useMemo(() => {
+      const keyword = batchFilterKeyword.trim().toLowerCase();
+      return batchTables.filter((item) => {
+          if (batchFilterType !== 'all' && item.objectType !== batchFilterType) {
+              return false;
+          }
+          if (!keyword) {
+              return true;
+          }
+          return item.title.toLowerCase().includes(keyword) || item.objectName.toLowerCase().includes(keyword);
+      });
+  }, [batchFilterKeyword, batchFilterType, batchTables]);
+  const groupedBatchObjects = useMemo(() => {
+      const tables = filteredBatchObjects.filter(item => item.objectType === 'table');
+      const views = filteredBatchObjects.filter(item => item.objectType === 'view');
+      return { tables, views };
+  }, [filteredBatchObjects]);
+  const allBatchObjectKeys = useMemo(() => batchTables.map(item => item.key), [batchTables]);
+  const allBatchObjectKeysByType = useMemo(() => {
+      if (batchFilterType === 'all') {
+          return allBatchObjectKeys;
+      }
+      return batchTables
+          .filter((item) => item.objectType === batchFilterType)
+          .map((item) => item.key);
+  }, [allBatchObjectKeys, batchFilterType, batchTables]);
+  const filteredBatchObjectKeys = useMemo(() => filteredBatchObjects.map(item => item.key), [filteredBatchObjects]);
+  const selectionScopeTargetKeys = useMemo(
+      () => (batchSelectionScope === 'filtered' ? filteredBatchObjectKeys : allBatchObjectKeysByType),
+      [allBatchObjectKeysByType, batchSelectionScope, filteredBatchObjectKeys]
+  );
+  useEffect(() => {
+      if (batchFilterType === 'all') {
+          return;
+      }
+      const allowed = new Set(allBatchObjectKeysByType);
+      setCheckedTableKeys((prev) => prev.filter((key) => allowed.has(key)));
+  }, [allBatchObjectKeysByType, batchFilterType]);

  // Batch Database Operations Modal
  const [isBatchDbModalOpen, setIsBatchDbModalOpen] = useState(false);
@@ -1097,7 +1149,7 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
      if (type === 'folder-columns') openDesign(info.node, 'columns', false);
      else if (type === 'folder-indexes') openDesign(info.node, 'indexes', false);
      else if (type === 'folder-fks') openDesign(info.node, 'foreignKeys', false);
-      else if (type === 'folder-triggers') openDesign(info.node, 'triggers', true);
+      else if (type === 'folder-triggers') openDesign(info.node, 'triggers', false);
  };

  const onExpand = (newExpandedKeys: React.Key[]) => {
@@ -1288,7 +1340,7 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
          if (node.type === 'database') {
              connId = node.dataRef.id;
              dbName = node.title;
-          } else if (node.type === 'table') {
+          } else if (node.type === 'table' || node.type === 'view') {
              connId = node.dataRef.id;
              dbName = node.dataRef.dbName;
          }
@@ -1299,6 +1351,9 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
      setBatchTables([]);
      setCheckedTableKeys([]);
      setAvailableDatabases([]);
+      setBatchFilterKeyword('');
+      setBatchFilterType('all');
+      setBatchSelectionScope('filtered');

      if (connId) {
          const conn = connections.find(c => c.id === connId);
@@ -1356,23 +1411,42 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
          ssh: conn.config.ssh || { host: "", port: 22, user: "", password: "", keyPath: "" }
      };

-      const res = await DBGetTables(config as any, dbName);
-      if (res.success) {
-          const tables = (res.data as any[]).map((row: any) => {
-              const tableName = Object.values(row)[0] as string;
-              return {
-                  title: tableName,
-                  key: `${conn.id}-${dbName}-${tableName}`,
-                  tableName: tableName,
-                  dataRef: { ...conn, tableName, dbName }
-              };
-          });
+      const [res, viewResult] = await Promise.all([
+          DBGetTables(config as any, dbName),
+          loadViews(conn, dbName).catch(() => ({ views: [], supported: false })),
+      ]);

-          setBatchTables(tables);
-          setCheckedTableKeys([]);
-      } else {
+      if (!res.success) {
          message.error('获取表列表失败: ' + res.message);
+          return;
      }
+
+      const viewSet = new Set(viewResult.views.map(view => view.toLowerCase()));
+
+      const tableObjects: BatchObjectItem[] = (res.data as any[])
+          .map((row: any) => Object.values(row)[0] as string)
+          .filter((tableName: string) => !viewSet.has(tableName.toLowerCase()))
+          .map((tableName: string) => ({
+              title: getSidebarTableDisplayName(conn, tableName),
+              key: `${conn.id}-${dbName}-table-${tableName}`,
+              objectName: tableName,
+              objectType: 'table' as const,
+              dataRef: { ...conn, tableName, dbName, objectType: 'table' },
+          }));
+
+      const viewObjects: BatchObjectItem[] = viewResult.views.map((viewName: string) => ({
+          title: getSidebarTableDisplayName(conn, viewName),
+          key: `${conn.id}-${dbName}-view-${viewName}`,
+          objectName: viewName,
+          objectType: 'view' as const,
+          dataRef: { ...conn, tableName: viewName, dbName, objectType: 'view' },
+      }));
+
+      tableObjects.sort((a, b) => a.title.toLowerCase().localeCompare(b.title.toLowerCase()));
+      viewObjects.sort((a, b) => a.title.toLowerCase().localeCompare(b.title.toLowerCase()));
+
+      setBatchTables([...tableObjects, ...viewObjects]);
+      setCheckedTableKeys([]);
  };

  const handleConnectionChange = async (connId: string) => {
@@ -1380,6 +1454,9 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
      setSelectedDatabase('');
      setBatchTables([]);
      setCheckedTableKeys([]);
+      setBatchFilterKeyword('');
+      setBatchFilterType('all');
+      setBatchSelectionScope('filtered');

      const conn = connections.find(c => c.id === connId);
      if (conn) {
@@ -1389,6 +1466,9 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>

  const handleDatabaseChange = async (dbName: string) => {
      setSelectedDatabase(dbName);
+      setBatchFilterKeyword('');
+      setBatchFilterType('all');
+      setBatchSelectionScope('filtered');

      const conn = connections.find(c => c.id === selectedConnection);
      if (conn && dbName) {
@@ -1397,31 +1477,36 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
  };

  const handleBatchExport = async (mode: BatchTableExportMode) => {
-      const selectedTables = batchTables.filter(t => checkedTableKeys.includes(t.key));
-      if (selectedTables.length === 0) {
-          message.warning('请至少选择一张表');
+      const selectedObjects = batchTables.filter(t => checkedTableKeys.includes(t.key));
+      if (selectedObjects.length === 0) {
+          message.warning('请至少选择一个对象');
          return;
      }

      setIsBatchModalOpen(false);

      const { conn, dbName } = batchDbContext;
-      const tableNames = selectedTables.map(t => t.tableName);
+      const objectNames = selectedObjects.map(t => t.objectName);
+      const selectedViewCount = selectedObjects.filter(item => item.objectType === 'view').length;

      const loadingText = mode === 'backup'
-          ? `正在备份选中表 (${tableNames.length})...`
+          ? `正在备份选中对象 (${objectNames.length})...`
          : mode === 'dataOnly'
-              ? `正在导出选中表数据 (INSERT) (${tableNames.length})...`
-              : `正在导出选中表结构 (${tableNames.length})...`;
+              ? `正在导出选中对象数据 (INSERT) (${objectNames.length})...`
+              : `正在导出选中对象结构 (${objectNames.length})...`;
      const hide = message.loading(loadingText, 0);
      try {
          const app = (window as any).go.app.App;
          const res = mode === 'dataOnly'
-              ? await app.ExportTablesDataSQL(normalizeConnConfig(conn.config), dbName, tableNames)
-              : await app.ExportTablesSQL(normalizeConnConfig(conn.config), dbName, tableNames, mode === 'backup');
+              ? await app.ExportTablesDataSQL(normalizeConnConfig(conn.config), dbName, objectNames)
+              : await app.ExportTablesSQL(normalizeConnConfig(conn.config), dbName, objectNames, mode === 'backup');
          hide();
          if (res.success) {
-              message.success('导出成功');
+              if (mode !== 'schema' && selectedViewCount > 0) {
+                  message.success(`导出成功（已自动跳过 ${selectedViewCount} 个视图的数据导出）`);
+              } else {
+                  message.success('导出成功');
+              }
          } else if (res.message !== 'Cancelled') {
              message.error('导出失败: ' + res.message);
          }
@@ -1432,17 +1517,44 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
  };

  const handleCheckAll = (checked: boolean) => {
-      if (checked) {
-          setCheckedTableKeys(batchTables.map(t => t.key));
-      } else {
-          setCheckedTableKeys([]);
+      if (batchSelectionScope === 'all') {
+          setCheckedTableKeys(checked ? allBatchObjectKeys : []);
+          return;
      }
+      if (filteredBatchObjectKeys.length === 0) {
+          return;
+      }
+      if (checked) {
+          setCheckedTableKeys(prev => {
+              const nextSet = new Set(prev);
+              filteredBatchObjectKeys.forEach((key) => nextSet.add(key));
+              return allBatchObjectKeys.filter((key) => nextSet.has(key));
+          });
+          return;
+      }
+      const filteredKeySet = new Set(filteredBatchObjectKeys);
+      setCheckedTableKeys(prev => prev.filter((key) => !filteredKeySet.has(key)));
  };

  const handleInvertSelection = () => {
-      const allKeys = batchTables.map(t => t.key);
-      const newChecked = allKeys.filter(k => !checkedTableKeys.includes(k));
-      setCheckedTableKeys(newChecked);
+      if (batchSelectionScope === 'all') {
+          setCheckedTableKeys(prev => allBatchObjectKeys.filter((key) => !prev.includes(key)));
+          return;
+      }
+      if (filteredBatchObjectKeys.length === 0) {
+          return;
+      }
+      setCheckedTableKeys(prev => {
+          const nextSet = new Set(prev);
+          filteredBatchObjectKeys.forEach((key) => {
+              if (nextSet.has(key)) {
+                  nextSet.delete(key);
+              } else {
+                  nextSet.add(key);
+              }
+          });
+          return allBatchObjectKeys.filter((key) => nextSet.has(key));
+      });
  };

  const openBatchDatabaseModal = async () => {
@@ -2836,6 +2948,43 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
                </div>
            </div>

+            {batchTables.length > 0 && (
+                <div style={{ marginBottom: 16 }}>
+                    <Space wrap size={8} style={{ width: '100%' }}>
+                        <Input
+                            allowClear
+                            value={batchFilterKeyword}
+                            onChange={(e) => setBatchFilterKeyword(e.target.value)}
+                            placeholder="筛选表/视图名称"
+                            prefix={<SearchOutlined />}
+                            style={{ width: 260 }}
+                        />
+                        <Select
+                            value={batchFilterType}
+                            onChange={(value) => setBatchFilterType(value as BatchObjectFilterType)}
+                            style={{ width: 140 }}
+                            options={[
+                                { label: '全部对象', value: 'all' },
+                                { label: '仅表', value: 'table' },
+                                { label: '仅视图', value: 'view' },
+                            ]}
+                        />
+                        <Select
+                            value={batchSelectionScope}
+                            onChange={(value) => setBatchSelectionScope(value as BatchSelectionScope)}
+                            style={{ width: 220 }}
+                            options={[
+                                { label: '勾选作用于：当前筛选结果', value: 'filtered' },
+                                { label: '勾选作用于：全部对象', value: 'all' },
+                            ]}
+                        />
+                    </Space>
+                    <div style={{ marginTop: 6, color: '#999', fontSize: 12 }}>
+                        当前筛选命中 {filteredBatchObjects.length} / {batchTables.length} 个对象
+                    </div>
+                </div>
+            )}
+
            {batchTables.length > 0 && (
                <>
                    <div style={{ marginBottom: 16 }}>
@@ -2843,23 +2992,26 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
                            <Button
                                size="small"
                                onClick={() => handleCheckAll(true)}
+                                disabled={selectionScopeTargetKeys.length === 0}
                            >
                                全选
                            </Button>
                            <Button
                                size="small"
                                onClick={() => handleCheckAll(false)}
+                                disabled={selectionScopeTargetKeys.length === 0}
                            >
                                取消全选
                            </Button>
                            <Button
                                size="small"
                                onClick={handleInvertSelection}
+                                disabled={selectionScopeTargetKeys.length === 0}
                            >
                                反选
                            </Button>
                            <span style={{ color: '#999' }}>
-                                已选择 {checkedTableKeys.length} / {batchTables.length} 张表
+                                已选择 {checkedTableKeys.length} / {batchTables.length} 个对象
                            </span>
                        </Space>
                    </div>
@@ -2869,14 +3021,43 @@ const Sidebar: React.FC<{ onEditConnection?: (conn: SavedConnection) => void }>
                            onChange={(values) => setCheckedTableKeys(values as string[])}
                            style={{ width: '100%' }}
                        >
-                            <Space direction="vertical" style={{ width: '100%' }}>
-                                {batchTables.map(table => (
-                                    <Checkbox key={table.key} value={table.key}>
-                                        <TableOutlined style={{ marginRight: 8 }} />
-                                        {table.title}
-                                    </Checkbox>
-                                ))}
-                            </Space>
+                            <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}>
+                                {groupedBatchObjects.tables.length > 0 && (
+                                    <div>
+                                        <div style={{ marginBottom: 6, color: darkMode ? '#bfbfbf' : '#595959', fontSize: 12 }}>
+                                            表 ({groupedBatchObjects.tables.length})
+                                        </div>
+                                        <Space direction="vertical" style={{ width: '100%' }}>
+                                            {groupedBatchObjects.tables.map(table => (
+                                                <Checkbox key={table.key} value={table.key}>
+                                                    <TableOutlined style={{ marginRight: 8 }} />
+                                                    {table.title}
+                                                </Checkbox>
+                                            ))}
+                                        </Space>
+                                    </div>
+                                )}
+                                {groupedBatchObjects.views.length > 0 && (
+                                    <div>
+                                        <div style={{ marginBottom: 6, color: darkMode ? '#bfbfbf' : '#595959', fontSize: 12 }}>
+                                            视图 ({groupedBatchObjects.views.length})
+                                        </div>
+                                        <Space direction="vertical" style={{ width: '100%' }}>
+                                            {groupedBatchObjects.views.map(view => (
+                                                <Checkbox key={view.key} value={view.key}>
+                                                    <EyeOutlined style={{ marginRight: 8 }} />
+                                                    {view.title}
+                                                </Checkbox>
+                                            ))}
+                                        </Space>
+                                    </div>
+                                )}
+                                {groupedBatchObjects.tables.length === 0 && groupedBatchObjects.views.length === 0 && (
+                                    <div style={{ color: '#999', padding: '8px 0' }}>
+                                        无匹配对象
+                                    </div>
+                                )}
+                            </div>
                        </Checkbox.Group>
                    </div>
                </>
--- a/frontend/src/components/TableDesigner.tsx
+++ b/frontend/src/components/TableDesigner.tsx
@@ -75,6 +75,22 @@ const MYSQL_INDEX_TYPE_OPTIONS = [
    { label: 'RTREE', value: 'RTREE' },
 ];

+const PGLIKE_INDEX_TYPE_OPTIONS = [
+    { label: '默认', value: 'DEFAULT' },
+    { label: 'BTREE', value: 'BTREE' },
+    { label: 'HASH', value: 'HASH' },
+    { label: 'GIN', value: 'GIN' },
+    { label: 'GIST', value: 'GIST' },
+    { label: 'BRIN', value: 'BRIN' },
+    { label: 'SPGIST', value: 'SPGIST' },
+];
+
+const SQLSERVER_INDEX_TYPE_OPTIONS = [
+    { label: '默认', value: 'DEFAULT' },
+    { label: 'CLUSTERED', value: 'CLUSTERED' },
+    { label: 'NONCLUSTERED', value: 'NONCLUSTERED' },
+];
+
 const CHARSETS = [
    { label: 'utf8mb4 (Recommended)', value: 'utf8mb4' },
    { label: 'utf8', value: 'utf8' },
@@ -612,9 +628,41 @@ const TableDesigner: React.FC<{ tab: TabData }> = ({ tab }) => {

  // --- Trigger Handlers ---

+  const normalizeDbType = (rawType: string): string => {
+      const normalized = String(rawType || '').trim().toLowerCase();
+      if (normalized === 'postgresql' || normalized === 'pg') return 'postgres';
+      if (normalized === 'mssql' || normalized === 'sql_server' || normalized === 'sql-server') return 'sqlserver';
+      if (normalized === 'doris') return 'diros';
+      return normalized;
+  };
+
+  const inferDialectFromCustomDriver = (driver: string): string => {
+      const customDriver = normalizeDbType(driver);
+      if (!customDriver) return 'custom';
+      if (
+          customDriver === 'mariadb'
+          || customDriver === 'diros'
+          || customDriver === 'sphinx'
+          || customDriver === 'tidb'
+          || customDriver === 'oceanbase'
+          || customDriver === 'starrocks'
+          || customDriver.includes('mysql')
+      ) {
+          return 'mysql';
+      }
+      if (customDriver === 'dameng') return 'dm';
+      return customDriver;
+  };
+
  const getDbType = (): string => {
    const conn = connections.find(c => c.id === tab.connectionId);
-    const type = String(conn?.config?.type || '').toLowerCase();
+    const type = normalizeDbType(String(conn?.config?.type || ''));
+    if (!type) return '';
+
+    if (type === 'custom') {
+        return inferDialectFromCustomDriver(String((conn?.config as any)?.driver || ''));
+    }
+
    if (type === 'mariadb' || type === 'diros' || type === 'sphinx') return 'mysql';
    if (type === 'dameng') return 'dm';
    return type;
@@ -1037,24 +1085,141 @@ ${selectedTrigger.statement}`;
  }, [groupedForeignKeys, selectedForeignKey]);

  const escapeBacktickIdentifier = (name: string) => String(name || '').replace(/`/g, '``');
+  const escapeBracketIdentifier = (name: string) => String(name || '').replace(/]/g, ']]');
+  const escapeDoubleQuoteIdentifier = (name: string) => String(name || '').replace(/"/g, '""');
  const escapeSqlString = (value: string) => String(value || '').replace(/'/g, "''");

-  const quoteMysqlIdentifierPath = (path: string): string => {
-      const trimmed = String(path || '').trim();
-      if (!trimmed) return '';
-      // If user already provided backticks, respect as-is.
-      if (trimmed.includes('`')) return trimmed;
-      return trimmed
-          .split('.')
-          .map(seg => `\`${escapeBacktickIdentifier(seg)}\``)
-          .join('.');
+  const stripIdentifierQuotes = (part: string): string => {
+      const text = String(part || '').trim();
+      if (!text) return '';
+      if ((text.startsWith('`') && text.endsWith('`')) || (text.startsWith('"') && text.endsWith('"'))) {
+          return text.slice(1, -1).trim();
+      }
+      if (text.startsWith('[') && text.endsWith(']')) {
+          return text.slice(1, -1).trim();
+      }
+      return text;
  };

-  const getMysqlTableRef = (): string => {
-      const tbl = String(tab.tableName || '').trim();
-      const schema = String(tab.dbName || '').trim();
-      if (!schema) return `\`${escapeBacktickIdentifier(tbl)}\``;
-      return `\`${escapeBacktickIdentifier(schema)}\`.\`${escapeBacktickIdentifier(tbl)}\``;
+  const splitQualifiedName = (qualifiedName: string): { schemaName: string; objectName: string } => {
+      const raw = String(qualifiedName || '').trim();
+      if (!raw) return { schemaName: '', objectName: '' };
+      const idx = raw.lastIndexOf('.');
+      if (idx <= 0 || idx >= raw.length - 1) return { schemaName: '', objectName: raw };
+      return {
+          schemaName: stripIdentifierQuotes(raw.substring(0, idx)),
+          objectName: stripIdentifierQuotes(raw.substring(idx + 1)),
+      };
+  };
+
+  const isPgLikeDialect = (dbType: string): boolean =>
+      dbType === 'postgres' || dbType === 'kingbase' || dbType === 'highgo' || dbType === 'vastbase';
+  const isOracleLikeDialect = (dbType: string): boolean => dbType === 'oracle' || dbType === 'dm';
+  const isSqlServerDialect = (dbType: string): boolean => dbType === 'sqlserver';
+  const isMysqlLikeDialect = (dbType: string): boolean => dbType === 'mysql';
+  const isNonRelationalDialect = (dbType: string): boolean => dbType === 'redis' || dbType === 'mongodb';
+  const lacksAlterForeignKeySupport = (dbType: string): boolean => dbType === 'sqlite' || dbType === 'duckdb' || dbType === 'tdengine';
+  const lacksTableCommentSupport = (dbType: string): boolean => dbType === 'sqlite';
+
+  const quoteIdentifierPartByDialect = (part: string, dbType: string): string => {
+      const ident = stripIdentifierQuotes(part);
+      if (!ident) return '';
+      if (isMysqlLikeDialect(dbType) || dbType === 'tdengine') {
+          return `\`${escapeBacktickIdentifier(ident)}\``;
+      }
+      if (isSqlServerDialect(dbType)) {
+          return `[${escapeBracketIdentifier(ident)}]`;
+      }
+      return `"${escapeDoubleQuoteIdentifier(ident)}"`;
+  };
+
+  const quoteIdentifierPathByDialect = (path: string, dbType: string): string => {
+      const raw = String(path || '').trim();
+      if (!raw) return '';
+      const parts = raw
+          .split('.')
+          .map(part => stripIdentifierQuotes(part))
+          .filter(Boolean);
+      if (parts.length === 0) return '';
+      return parts.map(part => quoteIdentifierPartByDialect(part, dbType)).join('.');
+  };
+
+  const resolveTableInfo = () => {
+      const dbType = getDbType();
+      const rawTable = String(tab.tableName || '').trim();
+      const rawDb = String(tab.dbName || '').trim();
+      const parsed = splitQualifiedName(rawTable);
+      const table = parsed.objectName || stripIdentifierQuotes(rawTable);
+      let schema = parsed.schemaName;
+
+      if (!schema) {
+          if (isPgLikeDialect(dbType)) {
+              schema = rawDb || 'public';
+          } else if (isSqlServerDialect(dbType)) {
+              schema = 'dbo';
+          } else if (isOracleLikeDialect(dbType)) {
+              schema = rawDb;
+          } else {
+              schema = rawDb;
+          }
+      }
+
+      const qualifiedName = schema ? `${schema}.${table}` : table;
+      return {
+          dbType,
+          schema: stripIdentifierQuotes(schema),
+          table: stripIdentifierQuotes(table),
+          qualifiedName,
+          tableRef: quoteIdentifierPathByDialect(qualifiedName, dbType),
+      };
+  };
+
+  const supportsIndexSchemaOps = (): boolean => {
+      const dbType = getDbType();
+      if (!dbType) return false;
+      if (isNonRelationalDialect(dbType)) return false;
+      return true;
+  };
+
+  const supportsForeignKeySchemaOps = (): boolean => {
+      const dbType = getDbType();
+      if (!dbType) return false;
+      if (isNonRelationalDialect(dbType)) return false;
+      if (lacksAlterForeignKeySupport(dbType)) return false;
+      return true;
+  };
+
+  const supportsTableCommentOps = (): boolean => {
+      const dbType = getDbType();
+      if (!dbType) return false;
+      if (isNonRelationalDialect(dbType)) return false;
+      if (lacksTableCommentSupport(dbType)) return false;
+      return true;
+  };
+
+  const getIndexKindOptions = () => {
+      const dbType = getDbType();
+      if (isMysqlLikeDialect(dbType)) {
+          return [
+              { label: '普通索引（非聚合）', value: 'NORMAL' },
+              { label: '唯一索引', value: 'UNIQUE' },
+              { label: '主键索引（聚合）', value: 'PRIMARY' },
+              { label: '全文索引', value: 'FULLTEXT' },
+              { label: '空间索引', value: 'SPATIAL' },
+          ];
+      }
+      return [
+          { label: '普通索引', value: 'NORMAL' },
+          { label: '唯一索引', value: 'UNIQUE' },
+      ];
+  };
+
+  const getIndexTypeOptions = () => {
+      const dbType = getDbType();
+      if (isMysqlLikeDialect(dbType)) return MYSQL_INDEX_TYPE_OPTIONS;
+      if (isPgLikeDialect(dbType)) return PGLIKE_INDEX_TYPE_OPTIONS;
+      if (isSqlServerDialect(dbType)) return SQLSERVER_INDEX_TYPE_OPTIONS;
+      return [{ label: '默认', value: 'DEFAULT' }];
  };

  const buildCreateTableSql = (targetTableName: string, targetColumns: EditableColumn[], targetCharset: string, targetCollation: string) => {
@@ -1127,8 +1292,6 @@ ${selectedTrigger.statement}`;
      }
  };

-  const supportsMysqlSchemaOps = () => getDbType() === 'mysql';
-
  const executeSchemaSql = async (sql: string, successMessage: string): Promise<boolean> => {
      const conn = connections.find(c => c.id === tab.connectionId);
      if (!conn) {
@@ -1163,13 +1326,59 @@ ${selectedTrigger.statement}`;
      setIsTableCommentModalOpen(true);
  };

+  const buildTableCommentSql = (nextComment: string): string | null => {
+      const tableInfo = resolveTableInfo();
+      const dbType = tableInfo.dbType;
+      const escapedComment = escapeSqlString(nextComment);
+      if (isNonRelationalDialect(dbType)) return null;
+      if (isMysqlLikeDialect(dbType)) {
+          return `ALTER TABLE ${tableInfo.tableRef} COMMENT = '${escapedComment}';`;
+      }
+      if (isPgLikeDialect(dbType) || isOracleLikeDialect(dbType)) {
+          return `COMMENT ON TABLE ${tableInfo.tableRef} IS '${escapedComment}';`;
+      }
+      if (isSqlServerDialect(dbType)) {
+          const schemaName = escapeSqlString(tableInfo.schema || 'dbo');
+          const tableName = escapeSqlString(tableInfo.table);
+          return `IF EXISTS (
+    SELECT 1
+    FROM sys.extended_properties ep
+    JOIN sys.tables t ON ep.major_id = t.object_id AND ep.minor_id = 0
+    JOIN sys.schemas s ON t.schema_id = s.schema_id
+    WHERE ep.name = N'MS_Description'
+      AND s.name = N'${schemaName}'
+      AND t.name = N'${tableName}'
+)
+BEGIN
+    EXEC sp_updateextendedproperty
+        @name = N'MS_Description',
+        @value = N'${escapedComment}',
+        @level0type = N'SCHEMA', @level0name = N'${schemaName}',
+        @level1type = N'TABLE', @level1name = N'${tableName}';
+END
+ELSE
+BEGIN
+    EXEC sp_addextendedproperty
+        @name = N'MS_Description',
+        @value = N'${escapedComment}',
+        @level0type = N'SCHEMA', @level0name = N'${schemaName}',
+        @level1type = N'TABLE', @level1name = N'${tableName}';
+END;`;
+      }
+      return `COMMENT ON TABLE ${tableInfo.tableRef} IS '${escapedComment}';`;
+  };
+
  const handleSaveTableComment = async () => {
-      if (!supportsMysqlSchemaOps()) {
+      if (!supportsTableCommentOps()) {
          message.warning('当前数据库暂不支持在此修改表备注');
          return;
      }
      if (!tab.tableName) return;
-      const sql = `ALTER TABLE ${getMysqlTableRef()} COMMENT = '${escapeSqlString(tableCommentDraft)}';`;
+      const sql = buildTableCommentSql(tableCommentDraft);
+      if (!sql) {
+          message.warning('当前数据库暂不支持在此修改表备注');
+          return;
+      }
      setTableCommentSaving(true);
      const ok = await executeSchemaSql(sql, '表备注更新成功');
      setTableCommentSaving(false);
@@ -1209,6 +1418,10 @@ ${selectedTrigger.statement}`;
      } else if (selectedIndex.nonUnique === 0) {
          kind = 'UNIQUE';
      }
+      const supportedKinds = new Set(getIndexKindOptions().map(item => item.value));
+      if (!supportedKinds.has(kind)) {
+          kind = selectedIndex.nonUnique === 0 ? 'UNIQUE' : 'NORMAL';
+      }

      setIndexForm({
          name: kind === 'PRIMARY' ? 'PRIMARY' : selectedName,
@@ -1221,51 +1434,132 @@ ${selectedTrigger.statement}`;
      setIsIndexModalOpen(true);
  };

-  const buildIndexAddClause = (form: IndexFormState): string | null => {
+  const buildIndexCreateSql = (form: IndexFormState): string | null => {
+      const tableInfo = resolveTableInfo();
+      const dbType = tableInfo.dbType;
      const kind: IndexKind = form.kind || 'NORMAL';
      const indexName = String(form.name || '').trim();
-      const colSql = form.columnNames.map(col => `\`${escapeBacktickIdentifier(col)}\``).join(', ');
+      const cleanedCols = form.columnNames.map(col => String(col || '').trim()).filter(Boolean);
+      if (cleanedCols.length === 0) {
+          message.error('请至少选择一个字段');
+          return null;
+      }
+      const colSql = cleanedCols
+          .map(col => quoteIdentifierPartByDialect(col, dbType))
+          .join(', ');

-      if (kind === 'PRIMARY') {
-          return `ADD PRIMARY KEY (${colSql})`;
+      if (isMysqlLikeDialect(dbType)) {
+          if (kind === 'PRIMARY') {
+              return `ALTER TABLE ${tableInfo.tableRef}\nADD PRIMARY KEY (${colSql});`;
+          }
+
+          if (!indexName) {
+              message.error('请输入索引名');
+              return null;
+          }
+
+          const indexRef = quoteIdentifierPartByDialect(indexName, dbType);
+          if (kind === 'FULLTEXT') {
+              return `ALTER TABLE ${tableInfo.tableRef}\nADD FULLTEXT INDEX ${indexRef} (${colSql});`;
+          }
+          if (kind === 'SPATIAL') {
+              return `ALTER TABLE ${tableInfo.tableRef}\nADD SPATIAL INDEX ${indexRef} (${colSql});`;
+          }
+
+          const normalizedType = String(form.indexType || '').trim().toUpperCase() || 'DEFAULT';
+          if (normalizedType === 'FULLTEXT' || normalizedType === 'SPATIAL') {
+              message.error(`请将“索引类别”切换为 ${normalizedType} 索引`);
+              return null;
+          }
+          const usingSql = normalizedType !== 'DEFAULT' ? ` USING ${normalizedType}` : '';
+          const prefix = kind === 'UNIQUE' ? 'ADD UNIQUE INDEX' : 'ADD INDEX';
+          return `ALTER TABLE ${tableInfo.tableRef}\n${prefix} ${indexRef}${usingSql} (${colSql});`;
      }

+      if (kind === 'PRIMARY' || kind === 'FULLTEXT' || kind === 'SPATIAL') {
+          message.warning('当前数据库仅支持普通索引与唯一索引维护');
+          return null;
+      }
      if (!indexName) {
          message.error('请输入索引名');
          return null;
      }

-      if (kind === 'FULLTEXT') {
-          return `ADD FULLTEXT INDEX \`${escapeBacktickIdentifier(indexName)}\` (${colSql})`;
-      }
-      if (kind === 'SPATIAL') {
-          return `ADD SPATIAL INDEX \`${escapeBacktickIdentifier(indexName)}\` (${colSql})`;
+      const indexRef = quoteIdentifierPartByDialect(indexName, dbType);
+      const normalizedType = String(form.indexType || '').trim().toUpperCase() || 'DEFAULT';
+      const uniquePrefix = kind === 'UNIQUE' ? 'UNIQUE ' : '';
+
+      if (isPgLikeDialect(dbType)) {
+          const usingSql = normalizedType !== 'DEFAULT' ? ` USING ${normalizedType}` : '';
+          return `CREATE ${uniquePrefix}INDEX ${indexRef} ON ${tableInfo.tableRef}${usingSql} (${colSql});`;
      }

-      const normalizedType = String(form.indexType || '').trim().toUpperCase() || 'DEFAULT';
-      if (normalizedType === 'FULLTEXT' || normalizedType === 'SPATIAL') {
-          message.error(`请将“索引类别”切换为 ${normalizedType} 索引`);
+      if (isSqlServerDialect(dbType)) {
+          const methodSql = normalizedType === 'CLUSTERED' || normalizedType === 'NONCLUSTERED'
+              ? `${normalizedType} `
+              : '';
+          return `CREATE ${uniquePrefix}${methodSql}INDEX ${indexRef} ON ${tableInfo.tableRef} (${colSql});`;
+      }
+
+      if (isOracleLikeDialect(dbType) || dbType === 'sqlite') {
+          return `CREATE ${uniquePrefix}INDEX ${indexRef} ON ${tableInfo.tableRef} (${colSql});`;
+      }
+
+      if (isNonRelationalDialect(dbType)) {
+          message.warning('当前数据源不支持关系型索引维护');
          return null;
      }
-
-      const usingSql = normalizedType !== 'DEFAULT' ? ` USING ${normalizedType}` : '';
-      const prefix = kind === 'UNIQUE' ? 'ADD UNIQUE INDEX' : 'ADD INDEX';
-      return `${prefix} \`${escapeBacktickIdentifier(indexName)}\`${usingSql} (${colSql})`;
+      return `CREATE ${uniquePrefix}INDEX ${indexRef} ON ${tableInfo.tableRef} (${colSql});`;
  };

-  const buildIndexDropClause = (indexName: string) => {
-      if (String(indexName || '').trim().toUpperCase() === 'PRIMARY') {
-          return 'DROP PRIMARY KEY';
+  const buildIndexDropSql = (indexName: string): string | null => {
+      const tableInfo = resolveTableInfo();
+      const dbType = tableInfo.dbType;
+      const name = String(indexName || '').trim();
+      if (!name) return null;
+
+      if (isMysqlLikeDialect(dbType)) {
+          if (name.toUpperCase() === 'PRIMARY') {
+              return `ALTER TABLE ${tableInfo.tableRef}\nDROP PRIMARY KEY;`;
+          }
+          const indexRef = quoteIdentifierPartByDialect(name, dbType);
+          return `DROP INDEX ${indexRef} ON ${tableInfo.tableRef};`;
      }
-      return `DROP INDEX \`${escapeBacktickIdentifier(indexName)}\``;
+
+      if (isSqlServerDialect(dbType)) {
+          const indexRef = quoteIdentifierPartByDialect(name, dbType);
+          return `DROP INDEX ${indexRef} ON ${tableInfo.tableRef};`;
+      }
+
+      if (isPgLikeDialect(dbType) || isOracleLikeDialect(dbType) || dbType === 'sqlite') {
+          const fullIndexName = name.includes('.') || !tableInfo.schema
+              ? name
+              : `${tableInfo.schema}.${name}`;
+          const indexRef = quoteIdentifierPathByDialect(fullIndexName, dbType);
+          return `DROP INDEX ${indexRef};`;
+      }
+
+      if (isNonRelationalDialect(dbType)) {
+          return null;
+      }
+      const fullIndexName = name.includes('.') || !tableInfo.schema
+          ? name
+          : `${tableInfo.schema}.${name}`;
+      const indexRef = quoteIdentifierPathByDialect(fullIndexName, dbType);
+      return `DROP INDEX ${indexRef};`;
  };

  const handleSubmitIndex = async () => {
-      if (!supportsMysqlSchemaOps()) {
+      if (!supportsIndexSchemaOps()) {
          message.warning('当前数据库暂不支持在此维护索引');
          return;
      }
      if (!tab.tableName) return;
+      const supportedKinds = new Set(getIndexKindOptions().map(item => item.value));
+      if (!supportedKinds.has(indexForm.kind)) {
+          message.warning('当前数据库不支持该索引类型');
+          return;
+      }
      const nextName = indexForm.kind === 'PRIMARY' ? 'PRIMARY' : String(indexForm.name || '').trim();
      if (indexForm.kind !== 'PRIMARY' && !nextName) {
          message.error('请输入索引名');
@@ -1287,16 +1581,21 @@ ${selectedTrigger.statement}`;
      }

      setIndexSaving(true);
-      const addClause = buildIndexAddClause({ ...indexForm, name: nextName });
-      if (!addClause) {
+      const addSql = buildIndexCreateSql({ ...indexForm, name: nextName });
+      if (!addSql) {
          setIndexSaving(false);
          return;
      }
-      let sql = `ALTER TABLE ${getMysqlTableRef()}\n${addClause};`;
+      let sql = addSql;

      if (indexModalMode === 'edit' && selectedIndex) {
-          const dropClause = buildIndexDropClause(selectedIndex.name);
-          sql = `ALTER TABLE ${getMysqlTableRef()}\n${dropClause},\n${addClause};`;
+          const dropSql = buildIndexDropSql(selectedIndex.name);
+          if (!dropSql) {
+              setIndexSaving(false);
+              message.warning('当前数据库暂不支持删除该索引');
+              return;
+          }
+          sql = `${dropSql}\n${addSql}`;
      }

      const ok = await executeSchemaSql(sql, indexModalMode === 'create' ? '索引新增成功' : '索引修改成功');
@@ -1311,7 +1610,7 @@ ${selectedTrigger.statement}`;
          message.warning('请先选择一个索引');
          return;
      }
-      if (!supportsMysqlSchemaOps()) {
+      if (!supportsIndexSchemaOps()) {
          message.warning('当前数据库暂不支持在此维护索引');
          return;
      }
@@ -1323,8 +1622,11 @@ ${selectedTrigger.statement}`;
          okType: 'danger',
          cancelText: '取消',
          onOk: async () => {
-              const dropClause = buildIndexDropClause(selectedIndex.name);
-              const sql = `ALTER TABLE ${getMysqlTableRef()}\n${dropClause};`;
+              const sql = buildIndexDropSql(selectedIndex.name);
+              if (!sql) {
+                  message.warning('当前数据库暂不支持删除该索引');
+                  return;
+              }
              await executeSchemaSql(sql, '索引删除成功');
          }
      });
@@ -1356,18 +1658,40 @@ ${selectedTrigger.statement}`;
      setIsForeignKeyModalOpen(true);
  };

-  const buildForeignKeyAddClause = (form: ForeignKeyFormState) => {
-      const localColsSql = form.columnNames.map(col => `\`${escapeBacktickIdentifier(col)}\``).join(', ');
-      const refColsSql = form.refColumnNames.map(col => `\`${escapeBacktickIdentifier(col)}\``).join(', ');
-      const refTableSql = quoteMysqlIdentifierPath(form.refTableName);
-      return `ADD CONSTRAINT \`${escapeBacktickIdentifier(form.constraintName)}\` FOREIGN KEY (${localColsSql}) REFERENCES ${refTableSql} (${refColsSql})`;
+  const buildForeignKeyAddSql = (form: ForeignKeyFormState): string | null => {
+      const tableInfo = resolveTableInfo();
+      const dbType = tableInfo.dbType;
+      if (!supportsForeignKeySchemaOps()) return null;
+
+      const localColsSql = form.columnNames
+          .map(col => quoteIdentifierPartByDialect(col, dbType))
+          .join(', ');
+      const refColsSql = form.refColumnNames
+          .map(col => quoteIdentifierPartByDialect(col, dbType))
+          .join(', ');
+      const refParts = splitQualifiedName(form.refTableName);
+      const refObjectName = refParts.objectName || String(form.refTableName || '').trim();
+      const refTableName = !refParts.schemaName && tableInfo.schema && (isPgLikeDialect(dbType) || isSqlServerDialect(dbType) || isOracleLikeDialect(dbType))
+          ? `${tableInfo.schema}.${refObjectName}`
+          : String(form.refTableName || '').trim();
+      const refTableSql = quoteIdentifierPathByDialect(refTableName, dbType);
+      const constraintSql = quoteIdentifierPartByDialect(form.constraintName, dbType);
+      return `ALTER TABLE ${tableInfo.tableRef}\nADD CONSTRAINT ${constraintSql} FOREIGN KEY (${localColsSql}) REFERENCES ${refTableSql} (${refColsSql});`;
  };

-  const buildForeignKeyDropClause = (constraintName: string) =>
-      `DROP FOREIGN KEY \`${escapeBacktickIdentifier(constraintName)}\``;
+  const buildForeignKeyDropSql = (constraintName: string): string | null => {
+      const tableInfo = resolveTableInfo();
+      const dbType = tableInfo.dbType;
+      if (!supportsForeignKeySchemaOps()) return null;
+      const constraintSql = quoteIdentifierPartByDialect(constraintName, dbType);
+      if (isMysqlLikeDialect(dbType)) {
+          return `ALTER TABLE ${tableInfo.tableRef}\nDROP FOREIGN KEY ${constraintSql};`;
+      }
+      return `ALTER TABLE ${tableInfo.tableRef}\nDROP CONSTRAINT ${constraintSql};`;
+  };

  const handleSubmitForeignKey = async () => {
-      if (!supportsMysqlSchemaOps()) {
+      if (!supportsForeignKeySchemaOps()) {
          message.warning('当前数据库暂不支持在此维护外键');
          return;
      }
@@ -1408,17 +1732,27 @@ ${selectedTrigger.statement}`;
      }

      setForeignKeySaving(true);
-      const addClause = buildForeignKeyAddClause({
+      const addSql = buildForeignKeyAddSql({
          ...foreignKeyForm,
          constraintName: nextConstraint,
          columnNames: localCols,
          refTableName: refTable,
          refColumnNames: refCols,
      });
-      let sql = `ALTER TABLE ${getMysqlTableRef()}\n${addClause};`;
+      if (!addSql) {
+          setForeignKeySaving(false);
+          message.warning('当前数据库暂不支持在此维护外键');
+          return;
+      }
+      let sql = addSql;
      if (foreignKeyModalMode === 'edit' && selectedForeignKey) {
-          const dropClause = buildForeignKeyDropClause(selectedForeignKey.constraintName);
-          sql = `ALTER TABLE ${getMysqlTableRef()}\n${dropClause},\n${addClause};`;
+          const dropSql = buildForeignKeyDropSql(selectedForeignKey.constraintName);
+          if (!dropSql) {
+              setForeignKeySaving(false);
+              message.warning('当前数据库暂不支持删除该外键');
+              return;
+          }
+          sql = `${dropSql}\n${addSql}`;
      }

      const ok = await executeSchemaSql(sql, foreignKeyModalMode === 'create' ? '外键新增成功' : '外键修改成功');
@@ -1433,7 +1767,7 @@ ${selectedTrigger.statement}`;
          message.warning('请先选择一个外键');
          return;
      }
-      if (!supportsMysqlSchemaOps()) {
+      if (!supportsForeignKeySchemaOps()) {
          message.warning('当前数据库暂不支持在此维护外键');
          return;
      }
@@ -1445,7 +1779,11 @@ ${selectedTrigger.statement}`;
          okType: 'danger',
          cancelText: '取消',
          onOk: async () => {
-              const sql = `ALTER TABLE ${getMysqlTableRef()}\n${buildForeignKeyDropClause(selectedForeignKey.constraintName)};`;
+              const sql = buildForeignKeyDropSql(selectedForeignKey.constraintName);
+              if (!sql) {
+                  message.warning('当前数据库暂不支持删除该外键');
+                  return;
+              }
              await executeSchemaSql(sql, '外键删除成功');
          }
      });
@@ -1677,7 +2015,7 @@ ${selectedTrigger.statement}`;
            )}
            {!readOnly && <Button icon={<SaveOutlined />} type="primary" onClick={generateDDL}>保存</Button>}
            {!isNewTable && <Button icon={<ReloadOutlined />} onClick={fetchData}>刷新</Button>}
-            {!isNewTable && !readOnly && supportsMysqlSchemaOps() && (
+            {!isNewTable && !readOnly && supportsTableCommentOps() && (
                <Button icon={<EditOutlined />} onClick={openTableCommentModal}>表备注</Button>
            )}
            {!readOnly && <Button icon={<PlusOutlined />} onClick={handleAddColumn}>添加字段</Button>}
@@ -1710,15 +2048,15 @@ ${selectedTrigger.statement}`;
                            <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
                                {!readOnly && (
                                    <div style={{ display: 'flex', gap: 8 }}>
-                                        <Button size="small" icon={<PlusOutlined />} onClick={openCreateIndexModal}>新增</Button>
-                                        <Button size="small" icon={<EditOutlined />} disabled={!selectedIndex} onClick={openEditIndexModal}>修改</Button>
-                                        <Button size="small" icon={<DeleteOutlined />} danger disabled={!selectedIndex} onClick={handleDeleteIndex}>删除</Button>
-                                        {!supportsMysqlSchemaOps() && (
+                                        <Button size="small" icon={<PlusOutlined />} disabled={!supportsIndexSchemaOps()} onClick={openCreateIndexModal}>新增</Button>
+                                        <Button size="small" icon={<EditOutlined />} disabled={!supportsIndexSchemaOps() || !selectedIndex} onClick={openEditIndexModal}>修改</Button>
+                                        <Button size="small" icon={<DeleteOutlined />} danger disabled={!supportsIndexSchemaOps() || !selectedIndex} onClick={handleDeleteIndex}>删除</Button>
+                                        {!supportsIndexSchemaOps() && (
                                            <span style={{ marginLeft: 'auto', color: '#faad14', fontSize: 12, alignSelf: 'center' }}>
                                                当前数据库暂不支持索引编辑，仅支持查看
                                            </span>
                                        )}
-                                        {supportsMysqlSchemaOps() && selectedIndex && (
+                                        {supportsIndexSchemaOps() && selectedIndex && (
                                            <span style={{ marginLeft: 'auto', color: '#888', fontSize: 12, alignSelf: 'center' }}>
                                                已选择：{selectedIndex.name}
                                            </span>
@@ -1813,15 +2151,15 @@ ${selectedTrigger.statement}`;
                            <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
                                {!readOnly && (
                                    <div style={{ display: 'flex', gap: 8 }}>
-                                        <Button size="small" icon={<PlusOutlined />} onClick={openCreateForeignKeyModal}>新增</Button>
-                                        <Button size="small" icon={<EditOutlined />} disabled={!selectedForeignKey} onClick={openEditForeignKeyModal}>修改</Button>
-                                        <Button size="small" icon={<DeleteOutlined />} danger disabled={!selectedForeignKey} onClick={handleDeleteForeignKey}>删除</Button>
-                                        {!supportsMysqlSchemaOps() && (
+                                        <Button size="small" icon={<PlusOutlined />} disabled={!supportsForeignKeySchemaOps()} onClick={openCreateForeignKeyModal}>新增</Button>
+                                        <Button size="small" icon={<EditOutlined />} disabled={!supportsForeignKeySchemaOps() || !selectedForeignKey} onClick={openEditForeignKeyModal}>修改</Button>
+                                        <Button size="small" icon={<DeleteOutlined />} danger disabled={!supportsForeignKeySchemaOps() || !selectedForeignKey} onClick={handleDeleteForeignKey}>删除</Button>
+                                        {!supportsForeignKeySchemaOps() && (
                                            <span style={{ marginLeft: 'auto', color: '#faad14', fontSize: 12, alignSelf: 'center' }}>
                                                当前数据库暂不支持外键编辑，仅支持查看
                                            </span>
                                        )}
-                                        {supportsMysqlSchemaOps() && selectedForeignKey && (
+                                        {supportsForeignKeySchemaOps() && selectedForeignKey && (
                                            <span style={{ marginLeft: 'auto', color: '#888', fontSize: 12, alignSelf: 'center' }}>
                                                已选择：{selectedForeignKey.constraintName}
                                            </span>
@@ -2077,13 +2415,7 @@ ${selectedTrigger.statement}`;
                <Space wrap>
                    <Select
                        value={indexForm.kind}
-                        options={[
-                            { label: '普通索引（非聚合）', value: 'NORMAL' },
-                            { label: '唯一索引', value: 'UNIQUE' },
-                            { label: '主键索引（聚合）', value: 'PRIMARY' },
-                            { label: '全文索引', value: 'FULLTEXT' },
-                            { label: '空间索引', value: 'SPATIAL' },
-                        ]}
+                        options={getIndexKindOptions()}
                        onChange={(val: IndexKind) =>
                            setIndexForm(prev => ({
                                ...prev,
@@ -2097,7 +2429,7 @@ ${selectedTrigger.statement}`;
                    <Select
                        value={indexForm.indexType}
                        onChange={(val) => setIndexForm(prev => ({ ...prev, indexType: val }))}
-                        options={MYSQL_INDEX_TYPE_OPTIONS}
+                        options={getIndexTypeOptions()}
                        style={{ width: 160 }}
                        disabled={indexForm.kind === 'PRIMARY' || indexForm.kind === 'FULLTEXT' || indexForm.kind === 'SPATIAL'}
                    />
--- a/frontend/src/store.ts
+++ b/frontend/src/store.ts
@@ -1,8 +1,9 @@
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { ConnectionConfig, 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;
@@ -10,12 +11,23 @@ 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',
+  'doris',
  'diros',
  'sphinx',
+  'clickhouse',
  'postgres',
  'redis',
  'tdengine',
@@ -36,12 +48,15 @@ const getDefaultPortByType = (type: string): number => {
    case 'mysql':
    case 'mariadb':
      return 3306;
+    case 'doris':
    case 'diros':
      return 9030;
    case 'duckdb':
      return 0;
    case 'sphinx':
      return 9306;
+    case 'clickhouse':
+      return 9000;
    case 'postgres':
    case 'vastbase':
      return 5432;
@@ -137,6 +152,9 @@ const sanitizeAddressList = (value: unknown): string[] => {

 const normalizeConnectionType = (value: unknown): string => {
  const type = toTrimmedString(value).toLowerCase();
+  if (type === 'doris') {
+    return 'diros';
+  }
  return SUPPORTED_CONNECTION_TYPES.has(type) ? type : DEFAULT_CONNECTION_TYPE;
 };

@@ -155,6 +173,16 @@ const sanitizeConnectionConfig = (value: unknown): ConnectionConfig => {
    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,
@@ -167,6 +195,8 @@ const sanitizeConnectionConfig = (value: unknown): ConnectionConfig => {
    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',
@@ -194,12 +224,30 @@ const sanitizeConnectionConfig = (value: unknown): ConnectionConfig => {
  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(raw.config);
+  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 displayType = config.type === 'diros' ? 'doris' : config.type;
+  const fallbackName = config.host ? `${displayType}-${config.host}` : `连接-${index + 1}`;
  const name = toTrimmedString(raw.name, fallbackName) || fallbackName;
  const includeDatabases = sanitizeStringArray(raw.includeDatabases, 256);
  const includeRedisDatabases = sanitizeNumberArray(raw.includeRedisDatabases, 0, 15);
@@ -258,6 +306,10 @@ export interface QueryOptions {
  showColumnType: boolean;
 }

+export interface GlobalProxyConfig extends ProxyConfig {
+  enabled: boolean;
+}
+
 interface AppState {
  connections: SavedConnection[];
  tabs: TabData[];
@@ -266,6 +318,8 @@ interface AppState {
  savedQueries: SavedQuery[];
  theme: 'light' | 'dark';
  appearance: { opacity: number; blur: number };
+  startupFullscreen: boolean;
+  globalProxy: GlobalProxyConfig;
  sqlFormatOptions: { keywordCase: 'upper' | 'lower' };
  queryOptions: QueryOptions;
  sqlLogs: SqlLog[];
@@ -292,6 +346,8 @@ interface AppState {

  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;

@@ -380,6 +436,36 @@ const sanitizeAppearance = (
  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) => ({
@@ -390,6 +476,8 @@ export const useStore = create<AppState>()(
      savedQueries: [],
      theme: 'light',
      appearance: { ...DEFAULT_APPEARANCE },
+      startupFullscreen: DEFAULT_STARTUP_FULLSCREEN,
+      globalProxy: { ...DEFAULT_GLOBAL_PROXY },
      sqlFormatOptions: { keywordCase: 'upper' },
      queryOptions: { maxRows: 5000, showColumnComment: true, showColumnType: true },
      sqlLogs: [],
@@ -501,6 +589,8 @@ export const useStore = create<AppState>()(

      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 } })),

@@ -530,17 +620,16 @@ export const useStore = create<AppState>()(
    }),
    {
      name: 'lite-db-storage', // name of the item in the storage (must be unique)
-      version: 3,
+      version: PERSIST_VERSION,
      migrate: (persistedState: unknown, version: number) => {
-        if (!persistedState || typeof persistedState !== 'object') {
-          return persistedState as AppState;
-        }
-        const state = persistedState as Partial<AppState>;
+        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);
@@ -548,16 +637,16 @@ export const useStore = create<AppState>()(
        return nextState as AppState;
      },
      merge: (persistedState, currentState) => {
-        const state = (persistedState && typeof persistedState === 'object')
-          ? persistedState as Partial<AppState>
-          : {};
+        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, 3),
+          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),
@@ -569,6 +658,8 @@ export const useStore = create<AppState>()(
        savedQueries: state.savedQueries,
        theme: state.theme,
        appearance: state.appearance,
+        startupFullscreen: state.startupFullscreen,
+        globalProxy: state.globalProxy,
        sqlFormatOptions: state.sqlFormatOptions,
        queryOptions: state.queryOptions,
        tableAccessCount: state.tableAccessCount,
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -6,6 +6,14 @@ 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;
@@ -16,6 +24,8 @@ export interface ConnectionConfig {
  database?: string;
  useSSH?: boolean;
  ssh?: SSHConfig;
+  useProxy?: boolean;
+  proxy?: ProxyConfig;
  driver?: string;
  dsn?: string;
  timeout?: number;
@@ -127,7 +137,7 @@ export interface RedisKeyInfo {

 export interface RedisScanResult {
  keys: RedisKeyInfo[];
-  cursor: number;
+  cursor: string;
 }

 export interface RedisValue {
--- a/frontend/src/utils/sql.ts
+++ b/frontend/src/utils/sql.ts
@@ -36,7 +36,7 @@ export const quoteIdentPart = (dbType: string, ident: string) => {
  if (!raw) return raw;
  const dbTypeLower = (dbType || '').toLowerCase();

-  if (dbTypeLower === 'mysql' || dbTypeLower === 'mariadb' || dbTypeLower === 'diros' || dbTypeLower === 'sphinx' || dbTypeLower === 'tdengine') {
+  if (dbTypeLower === 'mysql' || dbTypeLower === 'mariadb' || dbTypeLower === 'diros' || dbTypeLower === 'sphinx' || dbTypeLower === 'tdengine' || dbTypeLower === 'clickhouse') {
    return `\`${raw.replace(/`/g, '``')}\``;
  }

--- a/frontend/src/vite-env.d.ts
+++ b/frontend/src/vite-env.d.ts
@@ -0,0 +1,2 @@
+/// <reference types="vite/client" />
+
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -12,4 +12,4 @@ export default defineConfig({
    outDir: 'dist', // Standard Wails output directory
    emptyOutDir: true,
  }
-})
+})
--- a/frontend/wailsjs/go/app/App.d.ts
+++ b/frontend/wailsjs/go/app/App.d.ts
@@ -6,10 +6,14 @@ 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>;
@@ -30,6 +34,8 @@ export function DBGetTriggers(arg1:connection.ConnectionConfig,arg2:string,arg3:

 export function DBQuery(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;

+export function DBQueryIsolated(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;
+
 export function DBShowCreateTable(arg1:connection.ConnectionConfig,arg2:string,arg3:string):Promise<connection.QueryResult>;

 export function DataSync(arg1:sync.SyncConfig):Promise<sync.SyncResult>;
@@ -38,7 +44,7 @@ export function DataSyncAnalyze(arg1:sync.SyncConfig):Promise<connection.QueryRe

 export function DataSyncPreview(arg1:sync.SyncConfig,arg2:string,arg3:number):Promise<connection.QueryResult>;

-export function DownloadDriverPackage(arg1:string,arg2:string,arg3:string):Promise<connection.QueryResult>;
+export function DownloadDriverPackage(arg1:string,arg2:string,arg3:string,arg4:string):Promise<connection.QueryResult>;

 export function DownloadUpdate():Promise<connection.QueryResult>;

@@ -66,6 +72,12 @@ 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>;
@@ -114,7 +126,7 @@ export function RedisListSet(arg1:connection.ConnectionConfig,arg2:string,arg3:n

 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 RedisScanKeys(arg1:connection.ConnectionConfig,arg2:string,arg3:any,arg4:number):Promise<connection.QueryResult>;

 export function RedisSelectDB(arg1:connection.ConnectionConfig,arg2:number):Promise<connection.QueryResult>;

@@ -154,8 +166,12 @@ export function ResolveDriverRepositoryURL(arg1:string):Promise<connection.Query

 export function SelectDriverDownloadDirectory(arg1:string):Promise<connection.QueryResult>;

+export function SelectDriverPackageDirectory(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>;
--- a/frontend/wailsjs/go/app/App.js
+++ b/frontend/wailsjs/go/app/App.js
@@ -6,6 +6,10 @@ 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']();
 }
@@ -14,6 +18,10 @@ 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);
 }
@@ -54,6 +62,10 @@ export function DBQuery(arg1, arg2, arg3) {
  return window['go']['app']['App']['DBQuery'](arg1, arg2, arg3);
 }

+export function DBQueryIsolated(arg1, arg2, arg3) {
+  return window['go']['app']['App']['DBQueryIsolated'](arg1, arg2, arg3);
+}
+
 export function DBShowCreateTable(arg1, arg2, arg3) {
  return window['go']['app']['App']['DBShowCreateTable'](arg1, arg2, arg3);
 }
@@ -70,8 +82,8 @@ export function DataSyncPreview(arg1, arg2, arg3) {
  return window['go']['app']['App']['DataSyncPreview'](arg1, arg2, arg3);
 }

-export function DownloadDriverPackage(arg1, arg2, arg3) {
-  return window['go']['app']['App']['DownloadDriverPackage'](arg1, arg2, arg3);
+export function DownloadDriverPackage(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['DownloadDriverPackage'](arg1, arg2, arg3, arg4);
 }

 export function DownloadUpdate() {
@@ -126,6 +138,18 @@ 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']();
 }
@@ -302,10 +326,18 @@ export function SelectDriverDownloadDirectory(arg1) {
  return window['go']['app']['App']['SelectDriverDownloadDirectory'](arg1);
 }

+export function SelectDriverPackageDirectory(arg1) {
+  return window['go']['app']['App']['SelectDriverPackageDirectory'](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);
 }
--- a/frontend/wailsjs/go/models.ts
+++ b/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;
@@ -78,6 +98,8 @@ export namespace connection {
 	    database: string;
 	    useSSH: boolean;
 	    ssh: SSHConfig;
+	    useProxy?: boolean;
+	    proxy?: ProxyConfig;
 	    driver?: string;
 	    dsn?: string;
 	    timeout?: number;
@@ -110,6 +132,8 @@ export namespace connection {
 	        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"];
@@ -146,6 +170,7 @@ export namespace connection {
 		    return a;
 		}
 	}
+	
 	export class QueryResult {
 	    success: boolean;
 	    message: string;
--- a/go.mod
+++ b/go.mod
@@ -5,6 +5,7 @@ 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
@@ -17,12 +18,16 @@ require (
 	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
@@ -34,6 +39,8 @@ require (
 	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
@@ -44,7 +51,7 @@ require (
 	github.com/google/flatbuffers v25.12.19+incompatible // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
-	github.com/hashicorp/go-version v1.7.0 // indirect
+	github.com/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
@@ -60,6 +67,7 @@ require (
 	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
@@ -68,6 +76,7 @@ require (
 	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
@@ -82,9 +91,10 @@ require (
 	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/mod v0.32.0 // indirect
-	golang.org/x/net v0.49.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/sys v0.40.0 // indirect
 	golang.org/x/telemetry v0.0.0-20260116145544-c6413dc483f5 // indirect
--- a/go.sum
+++ b/go.sum
@@ -16,6 +16,10 @@ github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.1.1 h1:bFWuo
 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=
@@ -52,6 +56,10 @@ github.com/duckdb/duckdb-go/v2 v2.5.5 h1:TlK8ipnzoKW2aNrjGqRkFWLCDpJDxR/VwH8ezEc
 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=
@@ -62,19 +70,23 @@ 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 v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
 github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/flatbuffers v25.12.19+incompatible h1:haMV2JRRJCe1998HeW/p0X9UaMTK6SDo0ffLn2+DbLs=
 github.com/google/flatbuffers v25.12.19+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/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=
@@ -83,20 +95,29 @@ github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
 github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/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=
@@ -134,8 +155,14 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 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=
@@ -159,6 +186,8 @@ 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=
@@ -169,6 +198,7 @@ github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpE
 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=
@@ -176,6 +206,7 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 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=
@@ -192,8 +223,10 @@ github.com/wailsapp/wails/v2 v2.11.0 h1:seLacV8pqupq32IjS4Y7V8ucab0WZwtK6VvUVxSB
 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=
@@ -202,38 +235,64 @@ github.com/xuri/excelize/v2 v2.10.0 h1:8aKsP7JD39iKLc6dH5Tw3dgV3sPRh8uRVXu/fMstf
 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-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.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=
@@ -260,15 +319,25 @@ 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.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=
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -15,6 +15,7 @@ import (
 	"GoNavi-Wails/internal/connection"
 	"GoNavi-Wails/internal/db"
 	"GoNavi-Wails/internal/logger"
+	proxytunnel "GoNavi-Wails/internal/proxy"
 )

 const dbCachePingInterval = 30 * time.Second
@@ -66,6 +67,7 @@ func (a *App) Shutdown(ctx context.Context) {
 			logger.Error(err, "关闭数据库连接失败")
 		}
 	}
+	proxytunnel.CloseAllForwarders()
 	// Close all Redis connections
 	CloseAllRedisClients()
 	logger.Infof("资源释放完成，应用已关闭")
@@ -77,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)
@@ -175,6 +176,12 @@ func formatConnSummary(config connection.ConnectionConfig) string {
 	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)
@@ -200,16 +207,44 @@ func (a *App) getDatabase(config connection.ConnectionConfig) (db.Database, erro
 	return a.getDatabaseWithPing(config, false)
 }

+func (a *App) openDatabaseIsolated(config connection.ConnectionConfig) (db.Database, error) {
+	effectiveConfig := applyGlobalProxyToConnection(config)
+	if supported, reason := db.DriverRuntimeSupportStatus(effectiveConfig.Type); !supported {
+		if strings.TrimSpace(reason) == "" {
+			reason = fmt.Sprintf("%s 驱动未启用，请先在驱动管理中安装启用", strings.TrimSpace(effectiveConfig.Type))
+		}
+		return nil, withLogHint{err: fmt.Errorf("%s", reason), logPath: logger.Path()}
+	}
+
+	dbInst, err := db.NewDatabase(effectiveConfig.Type)
+	if err != nil {
+		return nil, err
+	}
+
+	connectConfig, proxyErr := resolveDialConfigWithProxy(effectiveConfig)
+	if proxyErr != nil {
+		_ = dbInst.Close()
+		return nil, wrapConnectError(effectiveConfig, proxyErr)
+	}
+	if err := dbInst.Connect(connectConfig); err != nil {
+		_ = dbInst.Close()
+		return nil, wrapConnectError(effectiveConfig, err)
+	}
+	return dbInst, nil
+}
+
 func (a *App) getDatabaseWithPing(config connection.ConnectionConfig, forcePing bool) (db.Database, error) {
-	key := getCacheKey(config)
+	effectiveConfig := applyGlobalProxyToConnection(config)
+
+	key := getCacheKey(effectiveConfig)
 	shortKey := key
 	if len(shortKey) > 12 {
 		shortKey = shortKey[:12]
 	}

-	if supported, reason := db.DriverRuntimeSupportStatus(config.Type); !supported {
+	if supported, reason := db.DriverRuntimeSupportStatus(effectiveConfig.Type); !supported {
 		if strings.TrimSpace(reason) == "" {
-			reason = fmt.Sprintf("%s 驱动未启用，请先在驱动管理中安装启用", strings.TrimSpace(config.Type))
+			reason = fmt.Sprintf("%s 驱动未启用，请先在驱动管理中安装启用", strings.TrimSpace(effectiveConfig.Type))
 		}
 		// Best-effort cleanup: if cached instance exists for this exact config, close it.
 		a.mu.Lock()
@@ -247,7 +282,7 @@ func (a *App) getDatabaseWithPing(config connection.ConnectionConfig, forcePing
 			a.mu.Unlock()
 			return entry.inst, nil
 		} else {
-			logger.Error(err, "缓存连接不可用，准备重建：%s 缓存Key=%s", formatConnSummary(config), shortKey)
+			logger.Error(err, "缓存连接不可用，准备重建：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
 		}

 		// Ping failed: remove cached instance (best effort)
@@ -261,17 +296,24 @@ func (a *App) getDatabaseWithPing(config connection.ConnectionConfig, forcePing
 		a.mu.Unlock()
 	}

-	logger.Infof("获取数据库连接：%s 缓存Key=%s", formatConnSummary(config), shortKey)
-	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
+	}
+
+	if err := dbInst.Connect(connectConfig); err != nil {
+		wrapped := wrapConnectError(effectiveConfig, err)
+		logger.Error(wrapped, "建立数据库连接失败：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
 		return nil, wrapped
 	}

@@ -287,6 +329,6 @@ func (a *App) getDatabaseWithPing(config connection.ConnectionConfig, forcePing
 	a.dbCache[key] = cachedDatabase{inst: dbInst, lastPing: now}
 	a.mu.Unlock()

-	logger.Infof("数据库连接成功并写入缓存：%s 缓存Key=%s", formatConnSummary(config), shortKey)
+	logger.Infof("数据库连接成功并写入缓存：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
 	return dbInst, nil
 }
--- a/internal/app/db_context.go
+++ b/internal/app/db_context.go
@@ -14,7 +14,7 @@ func normalizeRunConfig(config connection.ConnectionConfig, dbName string) conne
 	}

 	switch strings.ToLower(strings.TrimSpace(config.Type)) {
-	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "highgo", "vastbase", "sqlserver", "mongodb", "tdengine":
+	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "highgo", "vastbase", "sqlserver", "mongodb", "tdengine", "clickhouse":
 		// 这些类型的 dbName 表示"数据库"，需要写入连接配置以选择目标库。
 		runConfig.Database = name
 	case "dameng":
--- a/internal/app/db_proxy.go
+++ b/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
+	}
+}
--- a/internal/app/global_proxy.go
+++ b/internal/app/global_proxy.go
@@ -0,0 +1,291 @@
+package app
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"errors"
+	"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
+}{}
+
+type localProxyTLSFallbackTransport struct {
+	primary       *http.Transport
+	fallback      *http.Transport
+	proxyEndpoint string
+}
+
+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.RoundTripper {
+	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)
+	if !isLoopbackProxyHost(snapshot.Proxy.Host) {
+		return transport
+	}
+
+	fallbackTransport := transport.Clone()
+	fallbackTransport.TLSClientConfig = cloneTLSConfigWithInsecureSkipVerify(fallbackTransport.TLSClientConfig)
+	return &localProxyTLSFallbackTransport{
+		primary:       transport,
+		fallback:      fallbackTransport,
+		proxyEndpoint: proxyURL.Redacted(),
+	}
+}
+
+func (t *localProxyTLSFallbackTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	resp, err := t.primary.RoundTrip(req)
+	if err == nil {
+		return resp, nil
+	}
+	if !isTLSFallbackCandidate(req.Method, err) {
+		return nil, err
+	}
+
+	retryReq, cloneErr := cloneRequestForRetry(req)
+	if cloneErr != nil {
+		return nil, err
+	}
+	logger.Warnf("检测到本地代理 TLS 证书不受信任，启用兼容回退：代理=%s 目标=%s 错误=%v", t.proxyEndpoint, req.URL.String(), err)
+	return t.fallback.RoundTrip(retryReq)
+}
+
+func isTLSFallbackCandidate(method string, err error) bool {
+	if !isIdempotentRequestMethod(method) {
+		return false
+	}
+	return isUnknownAuthorityError(err)
+}
+
+func isIdempotentRequestMethod(method string) bool {
+	switch strings.ToUpper(strings.TrimSpace(method)) {
+	case http.MethodGet, http.MethodHead:
+		return true
+	default:
+		return false
+	}
+}
+
+func cloneRequestForRetry(req *http.Request) (*http.Request, error) {
+	cloned := req.Clone(req.Context())
+	if req.Body == nil || req.Body == http.NoBody {
+		return cloned, nil
+	}
+	if req.GetBody == nil {
+		return nil, fmt.Errorf("request body not replayable")
+	}
+	body, err := req.GetBody()
+	if err != nil {
+		return nil, err
+	}
+	cloned.Body = body
+	return cloned, nil
+}
+
+func isUnknownAuthorityError(err error) bool {
+	var unknownErr x509.UnknownAuthorityError
+	if errors.As(err, &unknownErr) {
+		return true
+	}
+	return strings.Contains(strings.ToLower(err.Error()), "x509: certificate signed by unknown authority")
+}
+
+func cloneTLSConfigWithInsecureSkipVerify(base *tls.Config) *tls.Config {
+	if base == nil {
+		return &tls.Config{InsecureSkipVerify: true}
+	}
+	cloned := base.Clone()
+	cloned.InsecureSkipVerify = true
+	return cloned
+}
+
+func isLoopbackProxyHost(host string) bool {
+	trimmed := strings.TrimSpace(host)
+	if trimmed == "" {
+		return false
+	}
+	if strings.EqualFold(trimmed, "localhost") {
+		return true
+	}
+	ip := net.ParseIP(trimmed)
+	if ip == nil {
+		return false
+	}
+	return ip.IsLoopback()
+}
+
+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
+}
--- a/internal/app/methods_db.go
+++ b/internal/app/methods_db.go
@@ -7,6 +7,7 @@ import (
 	"time"

 	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/db"
 	"GoNavi-Wails/internal/logger"
 	"GoNavi-Wails/internal/utils"
 )
@@ -88,6 +89,8 @@ func (a *App) CreateDatabase(config connection.ConnectionConfig, dbName string)
 		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" {
@@ -110,16 +113,39 @@ func resolveDDLDBType(config connection.ConnectionConfig) string {

 	driver := strings.ToLower(strings.TrimSpace(config.Driver))
 	switch driver {
-	case "postgresql":
+	case "postgresql", "postgres", "pg", "pq", "pgx":
 		return "postgres"
-	case "dm":
+	case "dm", "dameng", "dm8":
 		return "dameng"
-	case "sqlite3":
+	case "sqlite3", "sqlite":
 		return "sqlite"
 	case "sphinxql":
 		return "sphinx"
 	case "diros", "doris":
 		return "diros"
+	case "kingbase", "kingbase8", "kingbasees", "kingbasev8":
+		return "kingbase"
+	case "highgo":
+		return "highgo"
+	case "vastbase":
+		return "vastbase"
+	}
+
+	switch {
+	case strings.Contains(driver, "postgres"):
+		return "postgres"
+	case strings.Contains(driver, "kingbase"):
+		return "kingbase"
+	case strings.Contains(driver, "highgo"):
+		return "highgo"
+	case strings.Contains(driver, "vastbase"):
+		return "vastbase"
+	case strings.Contains(driver, "sqlite"):
+		return "sqlite"
+	case strings.Contains(driver, "sphinx"):
+		return "sphinx"
+	case strings.Contains(driver, "diros"), strings.Contains(driver, "doris"):
+		return "diros"
 	default:
 		return driver
 	}
@@ -162,7 +188,7 @@ func buildRunConfigForDDL(config connection.ConnectionConfig, dbType string, dbN
 	if strings.EqualFold(strings.TrimSpace(config.Type), "custom") {
 		// custom 连接的 dbName 语义依赖 driver，尽量在常见驱动上对齐内置类型行为。
 		switch dbType {
-		case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "vastbase", "dameng":
+		case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "vastbase", "dameng", "clickhouse":
 			if strings.TrimSpace(dbName) != "" {
 				runConfig.Database = strings.TrimSpace(dbName)
 			}
@@ -184,15 +210,12 @@ func (a *App) RenameDatabase(config connection.ConnectionConfig, oldName string,
 	dbType := resolveDDLDBType(config)
 	switch dbType {
 	case "mysql", "mariadb", "diros", "sphinx":
-		return connection.QueryResult{Success: false, Message: "MySQL/MariaDB/Diros/Sphinx 不支持直接重命名数据库，请新建库后迁移数据"}
+		return connection.QueryResult{Success: false, Message: "MySQL/MariaDB/Doris/Sphinx 不支持直接重命名数据库，请新建库后迁移数据"}
 	case "postgres", "kingbase", "highgo", "vastbase":
 		if strings.EqualFold(strings.TrimSpace(config.Database), oldName) {
 			return connection.QueryResult{Success: false, Message: "当前连接正在使用目标数据库，请先连接到其他数据库后再重命名"}
 		}
 		runConfig := config
-		if strings.TrimSpace(runConfig.Database) == "" {
-			runConfig.Database = "postgres"
-		}
 		dbInst, err := a.getDatabase(runConfig)
 		if err != nil {
 			return connection.QueryResult{Success: false, Message: err.Error()}
@@ -219,7 +242,7 @@ func (a *App) DropDatabase(config connection.ConnectionConfig, dbName string) co
 		sql       string
 	)
 	switch dbType {
-	case "mysql", "mariadb", "diros", "tdengine":
+	case "mysql", "mariadb", "diros", "tdengine", "clickhouse":
 		runConfig = config
 		runConfig.Database = ""
 		sql = fmt.Sprintf("DROP DATABASE %s", quoteIdentByType(dbType, dbName))
@@ -228,9 +251,6 @@ func (a *App) DropDatabase(config connection.ConnectionConfig, dbName string) co
 			return connection.QueryResult{Success: false, Message: "当前连接正在使用目标数据库，请先连接到其他数据库后再删除"}
 		}
 		runConfig = config
-		if strings.TrimSpace(runConfig.Database) == "" {
-			runConfig.Database = "postgres"
-		}
 		sql = fmt.Sprintf("DROP DATABASE %s", quoteIdentByType(dbType, dbName))
 	default:
 		return connection.QueryResult{Success: false, Message: fmt.Sprintf("当前数据源(%s)暂不支持删除数据库", dbType)}
@@ -261,7 +281,7 @@ func (a *App) RenameTable(config connection.ConnectionConfig, dbName string, old

 	dbType := resolveDDLDBType(config)
 	switch dbType {
-	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "sqlite", "duckdb", "oracle", "dameng", "highgo", "vastbase", "sqlserver":
+	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)}
 	}
@@ -275,7 +295,7 @@ func (a *App) RenameTable(config connection.ConnectionConfig, dbName string, old

 	var sql string
 	switch dbType {
-	case "mysql", "mariadb", "diros", "sphinx":
+	case "mysql", "mariadb", "diros", "sphinx", "clickhouse":
 		newQualifiedTable := quoteTableIdentByType(dbType, schemaName, newTableName)
 		sql = fmt.Sprintf("RENAME TABLE %s TO %s", oldQualifiedTable, newQualifiedTable)
 	case "sqlserver":
@@ -307,7 +327,7 @@ func (a *App) DropTable(config connection.ConnectionConfig, dbName string, table

 	dbType := resolveDDLDBType(config)
 	switch dbType {
-	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "sqlite", "duckdb", "oracle", "dameng", "highgo", "vastbase", "sqlserver", "tdengine":
+	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)}
 	}
@@ -410,6 +430,66 @@ func (a *App) DBQuery(config connection.ConnectionConfig, dbName string, query s
 	}
 }

+func (a *App) DBQueryIsolated(config connection.ConnectionConfig, dbName string, query string) connection.QueryResult {
+	runConfig := normalizeRunConfig(config, dbName)
+
+	dbInst, err := a.openDatabaseIsolated(runConfig)
+	if err != nil {
+		logger.Error(err, "DBQueryIsolated 获取连接失败：%s", formatConnSummary(runConfig))
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	defer func() {
+		if closeErr := dbInst.Close(); closeErr != nil {
+			logger.Error(closeErr, "DBQueryIsolated 关闭临时连接失败：%s", formatConnSummary(runConfig))
+		}
+	}()
+
+	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))
+	isReadQuery := strings.HasPrefix(lowerQuery, "select") || strings.HasPrefix(lowerQuery, "show") || strings.HasPrefix(lowerQuery, "describe") || strings.HasPrefix(lowerQuery, "explain")
+	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, "DBQueryIsolated 查询失败：%s SQL片段=%q", formatConnSummary(runConfig), sqlSnippet(query))
+			return connection.QueryResult{Success: false, Message: err.Error()}
+		}
+		return connection.QueryResult{Success: true, Data: data, Fields: columns}
+	}
+
+	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, "DBQueryIsolated 执行失败：%s SQL片段=%q", formatConnSummary(runConfig), sqlSnippet(query))
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	return connection.QueryResult{Success: true, Data: map[string]int64{"affectedRows": affected}}
+}
+
 func sqlSnippet(query string) string {
 	q := strings.TrimSpace(query)
 	const max = 200
@@ -464,7 +544,8 @@ 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)
+	runConfig := buildRunConfigForDDL(config, dbType, dbName)

 	dbInst, err := a.getDatabase(runConfig)
 	if err != nil {
@@ -472,8 +553,7 @@ func (a *App) DBShowCreateTable(config connection.ConnectionConfig, dbName strin
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}

-	schemaName, pureTableName := normalizeSchemaAndTable(config, dbName, tableName)
-	sqlStr, err := dbInst.GetCreateStatement(schemaName, pureTableName)
+	sqlStr, err := resolveCreateStatementWithFallback(dbInst, config, dbName, tableName)
 	if err != nil {
 		logger.Error(err, "DBShowCreateTable 获取建表语句失败：%s 表=%s", formatConnSummary(runConfig), tableName)
 		return connection.QueryResult{Success: false, Message: err.Error()}
@@ -482,6 +562,147 @@ func (a *App) DBShowCreateTable(config connection.ConnectionConfig, dbName strin
 	return connection.QueryResult{Success: true, Data: sqlStr}
 }

+func resolveCreateStatementWithFallback(dbInst db.Database, config connection.ConnectionConfig, dbName string, tableName string) (string, error) {
+	dbType := resolveDDLDBType(config)
+	schemaName, pureTableName := normalizeSchemaAndTableByType(dbType, dbName, tableName)
+	if pureTableName == "" {
+		return "", fmt.Errorf("表名不能为空")
+	}
+
+	sqlStr, sourceErr := dbInst.GetCreateStatement(schemaName, pureTableName)
+	if sourceErr == nil && !shouldFallbackCreateStatement(dbType, sqlStr) {
+		return sqlStr, nil
+	}
+
+	if !supportsCreateStatementFallback(dbType) {
+		if sourceErr != nil {
+			return "", sourceErr
+		}
+		return sqlStr, nil
+	}
+
+	columns, colErr := dbInst.GetColumns(schemaName, pureTableName)
+	if colErr != nil {
+		if sourceErr != nil {
+			return "", sourceErr
+		}
+		return "", colErr
+	}
+
+	fallbackDDL, buildErr := buildFallbackCreateStatement(dbType, schemaName, pureTableName, columns)
+	if buildErr != nil {
+		if sourceErr != nil {
+			return "", sourceErr
+		}
+		return "", buildErr
+	}
+	return fallbackDDL, nil
+}
+
+func supportsCreateStatementFallback(dbType string) bool {
+	switch dbType {
+	case "postgres", "kingbase", "highgo", "vastbase":
+		return true
+	default:
+		return false
+	}
+}
+
+func shouldFallbackCreateStatement(dbType string, ddl string) bool {
+	if !supportsCreateStatementFallback(dbType) {
+		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)

@@ -558,7 +779,7 @@ func (a *App) DropView(config connection.ConnectionConfig, dbName string, viewNa

 	dbType := resolveDDLDBType(config)
 	switch dbType {
-	case "mysql", "mariadb", "diros", "sphinx", "postgres", "kingbase", "sqlite", "duckdb", "oracle", "dameng", "highgo", "vastbase", "sqlserver":
+	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)}
 	}
@@ -647,7 +868,7 @@ func (a *App) RenameView(config connection.ConnectionConfig, dbName string, oldN

 	var sql string
 	switch dbType {
-	case "mysql", "mariadb", "diros", "sphinx":
+	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":
--- a/internal/app/methods_db_create_statement_test.go
+++ b/internal/app/methods_db_create_statement_test.go
@@ -0,0 +1,174 @@
+package app
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+type fakeCreateStatementDB struct {
+	createSQL  string
+	createErr  error
+	columns    []connection.ColumnDefinition
+	columnsErr error
+
+	createSchema string
+	createTable  string
+	colsSchema   string
+	colsTable    string
+}
+
+func (f *fakeCreateStatementDB) Connect(config connection.ConnectionConfig) error { return nil }
+func (f *fakeCreateStatementDB) Close() error                                     { return nil }
+func (f *fakeCreateStatementDB) Ping() error                                      { return nil }
+func (f *fakeCreateStatementDB) Query(query string) ([]map[string]interface{}, []string, error) {
+	return nil, nil, nil
+}
+func (f *fakeCreateStatementDB) Exec(query string) (int64, error)          { return 0, nil }
+func (f *fakeCreateStatementDB) GetDatabases() ([]string, error)           { return nil, nil }
+func (f *fakeCreateStatementDB) GetTables(dbName string) ([]string, error) { return nil, nil }
+func (f *fakeCreateStatementDB) GetCreateStatement(dbName, tableName string) (string, error) {
+	f.createSchema = dbName
+	f.createTable = tableName
+	return f.createSQL, f.createErr
+}
+func (f *fakeCreateStatementDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
+	f.colsSchema = dbName
+	f.colsTable = tableName
+	return f.columns, f.columnsErr
+}
+func (f *fakeCreateStatementDB) GetAllColumns(dbName string) ([]connection.ColumnDefinitionWithTable, error) {
+	return nil, nil
+}
+func (f *fakeCreateStatementDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
+	return nil, nil
+}
+func (f *fakeCreateStatementDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {
+	return nil, nil
+}
+func (f *fakeCreateStatementDB) GetTriggers(dbName, tableName string) ([]connection.TriggerDefinition, error) {
+	return nil, nil
+}
+
+func TestResolveDDLDBType_CustomDriverAlias(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name   string
+		driver string
+		want   string
+	}{
+		{name: "postgresql alias", driver: "postgresql", want: "postgres"},
+		{name: "pgx alias", driver: "pgx", want: "postgres"},
+		{name: "kingbase8 alias", driver: "kingbase8", want: "kingbase"},
+		{name: "kingbase contains alias", driver: "kingbasees", want: "kingbase"},
+		{name: "dm alias", driver: "dm8", want: "dameng"},
+		{name: "sqlite alias", driver: "sqlite3", want: "sqlite"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			cfg := connection.ConnectionConfig{Type: "custom", Driver: tc.driver}
+			if got := resolveDDLDBType(cfg); got != tc.want {
+				t.Fatalf("resolveDDLDBType() mismatch, want=%q got=%q", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestResolveCreateStatementWithFallback_CustomKingbaseUsesPublicSchema(t *testing.T) {
+	t.Parallel()
+
+	dbInst := &fakeCreateStatementDB{
+		createSQL: "SHOW CREATE TABLE not directly supported in Kingbase/Postgres via SQL",
+		columns: []connection.ColumnDefinition{
+			{Name: "id", Type: "bigint", Nullable: "NO", Key: "PRI"},
+		},
+	}
+
+	ddl, err := resolveCreateStatementWithFallback(dbInst, connection.ConnectionConfig{
+		Type:   "custom",
+		Driver: "kingbase8",
+	}, "demo_db", "orders")
+	if err != nil {
+		t.Fatalf("resolveCreateStatementWithFallback() unexpected error: %v", err)
+	}
+	if dbInst.createSchema != "public" || dbInst.colsSchema != "public" {
+		t.Fatalf("expected fallback schema public, got create=%q columns=%q", dbInst.createSchema, dbInst.colsSchema)
+	}
+	if !strings.Contains(ddl, `CREATE TABLE "public"."orders"`) {
+		t.Fatalf("expected fallback DDL with public schema, got: %s", ddl)
+	}
+}
+
+func TestResolveCreateStatementWithFallback_KeepQualifiedSchema(t *testing.T) {
+	t.Parallel()
+
+	dbInst := &fakeCreateStatementDB{
+		createSQL: "-- SHOW CREATE TABLE not fully supported for PostgreSQL in this MVP.",
+		columns: []connection.ColumnDefinition{
+			{Name: "id", Type: "integer", Nullable: "NO", Key: "PRI"},
+		},
+	}
+
+	ddl, err := resolveCreateStatementWithFallback(dbInst, connection.ConnectionConfig{
+		Type:   "custom",
+		Driver: "postgresql",
+	}, "demo_db", "sales.orders")
+	if err != nil {
+		t.Fatalf("resolveCreateStatementWithFallback() unexpected error: %v", err)
+	}
+	if dbInst.createSchema != "sales" || dbInst.colsSchema != "sales" {
+		t.Fatalf("expected schema sales, got create=%q columns=%q", dbInst.createSchema, dbInst.colsSchema)
+	}
+	if !strings.Contains(ddl, `CREATE TABLE "sales"."orders"`) {
+		t.Fatalf("expected fallback DDL with sales schema, got: %s", ddl)
+	}
+}
+
+func TestResolveCreateStatementWithFallback_NoFallbackForMySQL(t *testing.T) {
+	t.Parallel()
+
+	dbInst := &fakeCreateStatementDB{
+		createSQL:  "SHOW CREATE TABLE not directly supported in Kingbase/Postgres via SQL",
+		columnsErr: errors.New("should not be called"),
+	}
+
+	ddl, err := resolveCreateStatementWithFallback(dbInst, connection.ConnectionConfig{
+		Type: "mysql",
+	}, "demo_db", "orders")
+	if err != nil {
+		t.Fatalf("resolveCreateStatementWithFallback() unexpected error: %v", err)
+	}
+	if ddl != dbInst.createSQL {
+		t.Fatalf("expected original ddl for mysql, got: %s", ddl)
+	}
+	if dbInst.colsTable != "" {
+		t.Fatalf("mysql path should not call GetColumns, got table=%q", dbInst.colsTable)
+	}
+}
+
+func TestResolveCreateStatementWithFallback_FallbackWhenCreateStatementError(t *testing.T) {
+	t.Parallel()
+
+	dbInst := &fakeCreateStatementDB{
+		createErr: errors.New("statement unsupported"),
+		columns: []connection.ColumnDefinition{
+			{Name: "id", Type: "bigint", Nullable: "NO", Key: "PRI"},
+		},
+	}
+
+	ddl, err := resolveCreateStatementWithFallback(dbInst, connection.ConnectionConfig{
+		Type: "postgres",
+	}, "demo_db", "orders")
+	if err != nil {
+		t.Fatalf("resolveCreateStatementWithFallback() unexpected error: %v", err)
+	}
+	if !strings.Contains(ddl, `CREATE TABLE "public"."orders"`) {
+		t.Fatalf("expected fallback DDL for postgres error path, got: %s", ddl)
+	}
+}
--- a/internal/app/methods_driver.go
+++ b/internal/app/methods_driver.go
--- a/internal/app/methods_file.go
+++ b/internal/app/methods_file.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"math"
 	"os"
+	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
@@ -77,6 +78,48 @@ func (a *App) ImportConfigFile() connection.QueryResult {
 	return connection.QueryResult{Success: true, Data: string(content)}
 }

+func (a *App) SelectSSHKeyFile(currentPath string) connection.QueryResult {
+	defaultDir := strings.TrimSpace(currentPath)
+	if defaultDir == "" {
+		if home, err := os.UserHomeDir(); err == nil {
+			defaultDir = filepath.Join(home, ".ssh")
+		}
+	}
+	if filepath.Ext(defaultDir) != "" {
+		defaultDir = filepath.Dir(defaultDir)
+	}
+	if defaultDir != "" && !filepath.IsAbs(defaultDir) {
+		if abs, err := filepath.Abs(defaultDir); err == nil {
+			defaultDir = abs
+		}
+	}
+
+	selection, err := runtime.OpenFileDialog(a.ctx, runtime.OpenDialogOptions{
+		Title:            "选择 SSH 私钥文件",
+		DefaultDirectory: defaultDir,
+		Filters: []runtime.FileFilter{
+			{
+				DisplayName: "私钥文件",
+				Pattern:     "*.pem;*.key;*.ppk;*id_rsa*",
+			},
+			{
+				DisplayName: "所有文件",
+				Pattern:     "*",
+			},
+		},
+	})
+	if err != nil {
+		return connection.QueryResult{Success: false, Message: err.Error()}
+	}
+	if strings.TrimSpace(selection) == "" {
+		return connection.QueryResult{Success: false, Message: "Cancelled"}
+	}
+	if abs, err := filepath.Abs(selection); err == nil {
+		selection = abs
+	}
+	return connection.QueryResult{Success: true, Data: map[string]interface{}{"path": selection}}
+}
+
 // PreviewImportFile 解析导入文件，返回字段列表、总行数、前 5 行预览数据
 func (a *App) PreviewImportFile(filePath string) connection.QueryResult {
 	if filePath == "" {
@@ -485,7 +528,8 @@ func (a *App) ExportTable(config connection.ConnectionConfig, dbName string, tab
 		if err := writeSQLHeader(w, runConfig, dbName); err != nil {
 			return connection.QueryResult{Success: false, Message: err.Error()}
 		}
-		if err := dumpTableSQL(w, dbInst, runConfig, dbName, tableName, true, true); err != nil {
+		viewLookup := listViewNameLookup(dbInst, runConfig, dbName)
+		if err := dumpTableSQL(w, dbInst, runConfig, dbName, tableName, true, true, viewLookup); err != nil {
 			return connection.QueryResult{Success: false, Message: err.Error()}
 		}
 		if err := writeSQLFooter(w, runConfig); err != nil {
@@ -556,7 +600,7 @@ func (a *App) exportTablesSQL(config connection.ConnectionConfig, dbName string,
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}

-	tables := make([]string, 0, len(tableNames))
+	objects := make([]string, 0, len(tableNames))
 	seen := make(map[string]struct{}, len(tableNames))
 	for _, t := range tableNames {
 		t = strings.TrimSpace(t)
@@ -567,9 +611,10 @@ func (a *App) exportTablesSQL(config connection.ConnectionConfig, dbName string,
 			continue
 		}
 		seen[t] = struct{}{}
-		tables = append(tables, t)
+		objects = append(objects, t)
 	}
-	sort.Strings(tables)
+	viewLookup := listViewNameLookup(dbInst, runConfig, dbName)
+	objects = buildExportObjectOrder(runConfig, dbName, objects, viewLookup, false)

 	f, err := os.Create(filename)
 	if err != nil {
@@ -583,8 +628,8 @@ func (a *App) exportTablesSQL(config connection.ConnectionConfig, dbName string,
 	if err := writeSQLHeader(w, runConfig, dbName); err != nil {
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
-	for _, t := range tables {
-		if err := dumpTableSQL(w, dbInst, runConfig, dbName, t, includeSchema, includeData); err != nil {
+	for _, objectName := range objects {
+		if err := dumpTableSQL(w, dbInst, runConfig, dbName, objectName, includeSchema, includeData, viewLookup); err != nil {
 			return connection.QueryResult{Success: false, Message: err.Error()}
 		}
 	}
@@ -623,7 +668,8 @@ func (a *App) ExportDatabaseSQL(config connection.ConnectionConfig, dbName strin
 	if err != nil {
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
-	sort.Strings(tables)
+	viewLookup := listViewNameLookup(dbInst, runConfig, dbName)
+	objects := buildExportObjectOrder(runConfig, dbName, tables, viewLookup, true)

 	f, err := os.Create(filename)
 	if err != nil {
@@ -637,8 +683,8 @@ func (a *App) ExportDatabaseSQL(config connection.ConnectionConfig, dbName strin
 	if err := writeSQLHeader(w, runConfig, dbName); err != nil {
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
-	for _, t := range tables {
-		if err := dumpTableSQL(w, dbInst, runConfig, dbName, t, true, includeData); err != nil {
+	for _, objectName := range objects {
+		if err := dumpTableSQL(w, dbInst, runConfig, dbName, objectName, true, includeData, viewLookup); err != nil {
 			return connection.QueryResult{Success: false, Message: err.Error()}
 		}
 	}
@@ -655,7 +701,7 @@ func quoteIdentByType(dbType string, ident string) string {
 	}

 	switch dbType {
-	case "mysql", "mariadb", "diros", "sphinx", "tdengine":
+	case "mysql", "mariadb", "diros", "sphinx", "tdengine", "clickhouse":
 		return "`" + strings.ReplaceAll(ident, "`", "``") + "`"
 	case "sqlserver":
 		escaped := strings.ReplaceAll(ident, "]", "]]")
@@ -743,6 +789,425 @@ func ensureSQLTerminator(sql string) string {
 	return sql + ";"
 }

+func buildExportObjectOrder(
+	config connection.ConnectionConfig,
+	dbName string,
+	rawObjects []string,
+	viewLookup map[string]string,
+	includeAllViews bool,
+) []string {
+	tableSet := make(map[string]string, len(rawObjects))
+	viewSet := make(map[string]string, len(rawObjects))
+
+	for _, rawName := range rawObjects {
+		objectName := strings.TrimSpace(rawName)
+		if objectName == "" {
+			continue
+		}
+		key := normalizeExportObjectKey(config, dbName, objectName)
+		if key == "" {
+			continue
+		}
+		if canonicalViewName, ok := viewLookup[key]; ok {
+			if strings.TrimSpace(canonicalViewName) == "" {
+				canonicalViewName = objectName
+			}
+			viewSet[key] = canonicalViewName
+			delete(tableSet, key)
+			continue
+		}
+		if _, isView := viewSet[key]; isView {
+			continue
+		}
+		if _, exists := tableSet[key]; !exists {
+			tableSet[key] = objectName
+		}
+	}
+
+	if includeAllViews {
+		for key, viewName := range viewLookup {
+			canonicalViewName := strings.TrimSpace(viewName)
+			if canonicalViewName == "" {
+				continue
+			}
+			viewSet[key] = canonicalViewName
+			delete(tableSet, key)
+		}
+	}
+
+	tables := mapValuesSorted(tableSet)
+	views := mapValuesSorted(viewSet)
+	return append(tables, views...)
+}
+
+func mapValuesSorted(values map[string]string) []string {
+	if len(values) == 0 {
+		return nil
+	}
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		if value == "" {
+			continue
+		}
+		result = append(result, value)
+	}
+	sort.Strings(result)
+	return result
+}
+
+func normalizeExportObjectKey(config connection.ConnectionConfig, dbName string, objectName string) string {
+	schemaName, pureName := normalizeSchemaAndTable(config, dbName, objectName)
+	return normalizeExportObjectKeyByParts(schemaName, pureName)
+}
+
+func normalizeExportObjectKeyByParts(schemaName, objectName string) string {
+	return strings.ToLower(strings.TrimSpace(qualifyTable(schemaName, objectName)))
+}
+
+func listViewNameLookup(dbInst db.Database, config connection.ConnectionConfig, dbName string) map[string]string {
+	viewLookup := make(map[string]string)
+	queries := buildListViewQueries(config, dbName)
+	for _, query := range queries {
+		if strings.TrimSpace(query) == "" {
+			continue
+		}
+		rows, _, err := dbInst.Query(query)
+		if err != nil {
+			continue
+		}
+		for _, row := range rows {
+			tableType := strings.ToUpper(exportRowValueCI(row, "table_type", "type"))
+			if tableType != "" && tableType != "VIEW" {
+				continue
+			}
+			schemaName := exportRowValueCI(row, "schema_name", "table_schema", "owner", "schema", "db")
+			viewName := exportRowValueCI(row, "object_name", "view_name", "table_name", "name")
+			if viewName == "" {
+				viewName = exportInferObjectName(row)
+			}
+			if strings.TrimSpace(viewName) == "" {
+				continue
+			}
+			fullName := strings.TrimSpace(qualifyTable(schemaName, viewName))
+			if fullName == "" {
+				fullName = strings.TrimSpace(viewName)
+			}
+			key := normalizeExportObjectKey(config, dbName, fullName)
+			if key == "" {
+				continue
+			}
+			if _, exists := viewLookup[key]; !exists {
+				viewLookup[key] = fullName
+			}
+		}
+	}
+	return viewLookup
+}
+
+func buildListViewQueries(config connection.ConnectionConfig, dbName string) []string {
+	dbType := resolveDDLDBType(config)
+	escapedDbName := escapeSQLLiteral(dbName)
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx":
+		queries := []string{
+			fmt.Sprintf(`SELECT TABLE_SCHEMA AS schema_name, TABLE_NAME AS object_name, TABLE_TYPE AS table_type FROM information_schema.tables WHERE TABLE_TYPE='VIEW' AND TABLE_SCHEMA='%s' ORDER BY TABLE_NAME`, escapedDbName),
+		}
+		if strings.TrimSpace(dbName) != "" {
+			queries = append(queries, fmt.Sprintf("SHOW FULL TABLES FROM %s WHERE Table_type = 'VIEW'", quoteIdentByType("mysql", dbName)))
+		}
+		return queries
+	case "postgres", "kingbase", "highgo", "vastbase":
+		return []string{
+			`SELECT table_schema AS schema_name, table_name AS object_name FROM information_schema.views WHERE table_schema NOT IN ('pg_catalog', 'information_schema') ORDER BY table_schema, table_name`,
+		}
+	case "sqlserver":
+		safeDBName := strings.TrimSpace(config.Database)
+		if safeDBName == "" {
+			safeDBName = strings.TrimSpace(dbName)
+		}
+		if safeDBName == "" {
+			return nil
+		}
+		safeDB := quoteIdentByType("sqlserver", safeDBName)
+		return []string{
+			fmt.Sprintf(`SELECT s.name AS schema_name, v.name AS object_name FROM %s.sys.views v JOIN %s.sys.schemas s ON v.schema_id = s.schema_id ORDER BY s.name, v.name`, safeDB, safeDB),
+		}
+	case "oracle", "dameng":
+		if strings.TrimSpace(dbName) == "" {
+			return []string{
+				`SELECT VIEW_NAME AS object_name FROM user_views ORDER BY VIEW_NAME`,
+			}
+		}
+		return []string{
+			fmt.Sprintf("SELECT OWNER AS schema_name, VIEW_NAME AS object_name FROM all_views WHERE OWNER = '%s' ORDER BY VIEW_NAME", strings.ToUpper(escapedDbName)),
+		}
+	case "sqlite":
+		return []string{
+			"SELECT name AS object_name FROM sqlite_master WHERE type='view' ORDER BY name",
+		}
+	case "duckdb":
+		return []string{
+			`SELECT table_schema AS schema_name, table_name AS object_name FROM information_schema.views WHERE table_schema NOT IN ('information_schema', 'pg_catalog') ORDER BY table_schema, table_name`,
+		}
+	case "clickhouse":
+		if strings.TrimSpace(dbName) == "" {
+			return []string{
+				`SELECT database AS schema_name, name AS object_name FROM system.tables WHERE engine LIKE '%View%' ORDER BY database, name`,
+			}
+		}
+		return []string{
+			fmt.Sprintf(`SELECT database AS schema_name, name AS object_name FROM system.tables WHERE engine LIKE '%%View%%' AND database='%s' ORDER BY name`, escapedDbName),
+		}
+	default:
+		if strings.TrimSpace(dbName) == "" {
+			return []string{
+				`SELECT table_schema AS schema_name, table_name AS object_name FROM information_schema.views`,
+			}
+		}
+		return []string{
+			fmt.Sprintf(`SELECT table_schema AS schema_name, table_name AS object_name FROM information_schema.views WHERE table_schema='%s'`, escapedDbName),
+		}
+	}
+}
+
+func tryGetViewCreateStatement(
+	dbInst db.Database,
+	config connection.ConnectionConfig,
+	dbName string,
+	schemaName string,
+	viewName string,
+) (string, bool) {
+	queries := buildViewCreateQueries(config, dbName, schemaName, viewName)
+	for _, query := range queries {
+		if strings.TrimSpace(query) == "" {
+			continue
+		}
+		rows, _, err := dbInst.Query(query)
+		if err != nil || len(rows) == 0 {
+			continue
+		}
+		createSQL := strings.TrimSpace(extractViewCreateSQL(rows[0]))
+		if createSQL == "" {
+			continue
+		}
+		if looksLikeSelectOrWith(createSQL) {
+			qualifiedView := qualifyTable(schemaName, viewName)
+			createSQL = fmt.Sprintf("CREATE VIEW %s AS %s", quoteQualifiedIdentByType(config.Type, qualifiedView), strings.TrimSuffix(strings.TrimSpace(createSQL), ";"))
+		}
+		return ensureSQLTerminator(createSQL), true
+	}
+	return "", false
+}
+
+func buildViewCreateQueries(config connection.ConnectionConfig, dbName, schemaName, viewName string) []string {
+	dbType := resolveDDLDBType(config)
+	safeSchema := strings.TrimSpace(schemaName)
+	safeView := strings.TrimSpace(viewName)
+	if safeView == "" {
+		return nil
+	}
+	escapedSchema := escapeSQLLiteral(safeSchema)
+	escapedView := escapeSQLLiteral(safeView)
+	escapedDB := escapeSQLLiteral(dbName)
+
+	switch dbType {
+	case "mysql", "mariadb", "diros", "sphinx":
+		if safeSchema == "" {
+			safeSchema = strings.TrimSpace(dbName)
+		}
+		if safeSchema != "" {
+			return []string{
+				fmt.Sprintf("SHOW CREATE VIEW %s.%s", quoteIdentByType("mysql", safeSchema), quoteIdentByType("mysql", safeView)),
+			}
+		}
+		return []string{
+			fmt.Sprintf("SHOW CREATE VIEW %s", quoteIdentByType("mysql", safeView)),
+		}
+	case "postgres", "kingbase", "highgo", "vastbase":
+		if safeSchema == "" {
+			safeSchema = "public"
+		}
+		regClassName := fmt.Sprintf(`"%s"."%s"`, strings.ReplaceAll(safeSchema, `"`, `""`), strings.ReplaceAll(safeView, `"`, `""`))
+		regClassName = strings.ReplaceAll(regClassName, "'", "''")
+		return []string{
+			fmt.Sprintf("SELECT pg_get_viewdef('%s'::regclass, true) AS ddl", regClassName),
+		}
+	case "sqlserver":
+		schema := safeSchema
+		if schema == "" {
+			schema = "dbo"
+		}
+		safeDBName := strings.TrimSpace(config.Database)
+		if safeDBName == "" {
+			safeDBName = strings.TrimSpace(dbName)
+		}
+		if safeDBName == "" {
+			return nil
+		}
+		safeDB := quoteIdentByType("sqlserver", safeDBName)
+		return []string{
+			fmt.Sprintf(`SELECT m.definition AS ddl
+FROM %s.sys.views v
+JOIN %s.sys.schemas s ON v.schema_id = s.schema_id
+JOIN %s.sys.sql_modules m ON v.object_id = m.object_id
+WHERE s.name = '%s' AND v.name = '%s'`,
+				safeDB, safeDB, safeDB, escapeSQLLiteral(schema), escapedView),
+		}
+	case "oracle", "dameng":
+		if safeSchema == "" {
+			safeSchema = strings.TrimSpace(dbName)
+		}
+		if safeSchema != "" {
+			return []string{
+				fmt.Sprintf("SELECT DBMS_METADATA.GET_DDL('VIEW', '%s', '%s') AS ddl FROM DUAL", strings.ToUpper(escapedView), strings.ToUpper(escapeSQLLiteral(safeSchema))),
+			}
+		}
+		return []string{
+			fmt.Sprintf("SELECT DBMS_METADATA.GET_DDL('VIEW', '%s') AS ddl FROM DUAL", strings.ToUpper(escapedView)),
+		}
+	case "sqlite":
+		return []string{
+			fmt.Sprintf("SELECT sql AS ddl FROM sqlite_master WHERE type='view' AND name='%s'", escapedView),
+		}
+	case "duckdb":
+		if safeSchema == "" {
+			safeSchema = "main"
+			escapedSchema = "main"
+		}
+		return []string{
+			fmt.Sprintf("SELECT sql AS ddl FROM duckdb_views() WHERE view_name = '%s' AND schema_name = '%s' LIMIT 1", escapedView, escapedSchema),
+			fmt.Sprintf("SELECT view_definition AS ddl FROM information_schema.views WHERE table_name = '%s' AND table_schema = '%s' LIMIT 1", escapedView, escapedSchema),
+		}
+	case "clickhouse":
+		if safeSchema == "" {
+			safeSchema = strings.TrimSpace(dbName)
+		}
+		if safeSchema != "" {
+			return []string{
+				fmt.Sprintf("SHOW CREATE TABLE %s.%s", quoteIdentByType("clickhouse", safeSchema), quoteIdentByType("clickhouse", safeView)),
+			}
+		}
+		return []string{
+			fmt.Sprintf("SHOW CREATE TABLE %s", quoteIdentByType("clickhouse", safeView)),
+		}
+	default:
+		if safeSchema != "" {
+			return []string{
+				fmt.Sprintf("SELECT view_definition AS ddl FROM information_schema.views WHERE table_name = '%s' AND table_schema = '%s' LIMIT 1", escapedView, escapedSchema),
+			}
+		}
+		if strings.TrimSpace(dbName) != "" {
+			return []string{
+				fmt.Sprintf("SELECT view_definition AS ddl FROM information_schema.views WHERE table_name = '%s' AND table_schema = '%s' LIMIT 1", escapedView, escapedDB),
+			}
+		}
+		return []string{
+			fmt.Sprintf("SELECT view_definition AS ddl FROM information_schema.views WHERE table_name = '%s' LIMIT 1", escapedView),
+		}
+	}
+}
+
+func extractViewCreateSQL(row map[string]interface{}) string {
+	if row == nil {
+		return ""
+	}
+	ddl := exportRowValueCI(row, "create view", "create_statement", "create_sql", "ddl", "sql", "view_definition", "definition")
+	if ddl != "" {
+		return ddl
+	}
+	for _, value := range row {
+		if value == nil {
+			continue
+		}
+		text := strings.TrimSpace(fmt.Sprintf("%v", value))
+		if text == "" || text == "<nil>" {
+			continue
+		}
+		lower := strings.ToLower(text)
+		if strings.HasPrefix(lower, "create ") || strings.HasPrefix(lower, "select ") || strings.HasPrefix(lower, "with ") {
+			return text
+		}
+	}
+	return ""
+}
+
+func exportRowValueCI(row map[string]interface{}, candidates ...string) string {
+	if len(row) == 0 || len(candidates) == 0 {
+		return ""
+	}
+	for _, candidate := range candidates {
+		candidate = strings.ToLower(strings.TrimSpace(candidate))
+		if candidate == "" {
+			continue
+		}
+		for key, value := range row {
+			normalizedKey := strings.ToLower(strings.TrimSpace(key))
+			if normalizedKey != candidate {
+				continue
+			}
+			if value == nil {
+				return ""
+			}
+			text := strings.TrimSpace(fmt.Sprintf("%v", value))
+			if text == "<nil>" {
+				return ""
+			}
+			return text
+		}
+	}
+	return ""
+}
+
+func exportInferObjectName(row map[string]interface{}) string {
+	if len(row) == 0 {
+		return ""
+	}
+	for key, value := range row {
+		normalizedKey := strings.ToLower(strings.TrimSpace(key))
+		if normalizedKey == "" {
+			continue
+		}
+		if strings.Contains(normalizedKey, "type") {
+			continue
+		}
+		if strings.Contains(normalizedKey, "table") || strings.Contains(normalizedKey, "view") || strings.Contains(normalizedKey, "name") || strings.Contains(normalizedKey, "ddl") || strings.Contains(normalizedKey, "sql") {
+			if value == nil {
+				continue
+			}
+			text := strings.TrimSpace(fmt.Sprintf("%v", value))
+			if text == "" || text == "<nil>" {
+				continue
+			}
+			return text
+		}
+	}
+	for _, value := range row {
+		if value == nil {
+			continue
+		}
+		text := strings.TrimSpace(fmt.Sprintf("%v", value))
+		if text == "" || text == "<nil>" {
+			continue
+		}
+		return text
+	}
+	return ""
+}
+
+func looksLikeSelectOrWith(sql string) bool {
+	trimmed := strings.TrimSpace(strings.TrimSuffix(sql, ";"))
+	if trimmed == "" {
+		return false
+	}
+	lower := strings.ToLower(trimmed)
+	return strings.HasPrefix(lower, "select ") || strings.HasPrefix(lower, "with ") || lower == "select" || lower == "with"
+}
+
+func escapeSQLLiteral(value string) string {
+	return strings.ReplaceAll(strings.TrimSpace(value), "'", "''")
+}
+
 func isMySQLHexLiteral(s string) bool {
 	if len(s) < 3 || !(strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X")) {
 		return false
@@ -798,13 +1263,63 @@ func formatSQLValue(dbType string, v interface{}) string {
 	}
 }

-func dumpTableSQL(w *bufio.Writer, dbInst db.Database, config connection.ConnectionConfig, dbName, tableName string, includeSchema bool, includeData bool) error {
+func dumpTableSQL(
+	w *bufio.Writer,
+	dbInst db.Database,
+	config connection.ConnectionConfig,
+	dbName,
+	tableName string,
+	includeSchema bool,
+	includeData bool,
+	viewLookup map[string]string,
+) error {
 	schemaName, pureTableName := normalizeSchemaAndTable(config, dbName, tableName)
+	objectKey := normalizeExportObjectKeyByParts(schemaName, pureTableName)
+	_, isView := viewLookup[objectKey]
+	var createSQL string
+
+	if includeSchema {
+		if isView {
+			viewDDL, ok := tryGetViewCreateStatement(dbInst, config, dbName, schemaName, pureTableName)
+			if ok {
+				createSQL = viewDDL
+			} else {
+				ddl, err := dbInst.GetCreateStatement(schemaName, pureTableName)
+				if err != nil {
+					return err
+				}
+				createSQL = ddl
+			}
+		} else {
+			ddl, err := resolveCreateStatementWithFallback(dbInst, config, dbName, tableName)
+			if err != nil {
+				if viewDDL, ok := tryGetViewCreateStatement(dbInst, config, dbName, schemaName, pureTableName); ok {
+					createSQL = viewDDL
+					isView = true
+				} else {
+					return err
+				}
+			} else {
+				createSQL = ddl
+			}
+		}
+	}
+
+	if includeData && !includeSchema && !isView {
+		if _, ok := tryGetViewCreateStatement(dbInst, config, dbName, schemaName, pureTableName); ok {
+			isView = true
+		}
+	}
+
+	objectLabel := "Table"
+	if isView {
+		objectLabel = "View"
+	}

 	if _, err := w.WriteString("\n-- ----------------------------\n"); err != nil {
 		return err
 	}
-	if _, err := w.WriteString(fmt.Sprintf("-- Table: %s\n", qualifyTable(schemaName, pureTableName))); err != nil {
+	if _, err := w.WriteString(fmt.Sprintf("-- %s: %s\n", objectLabel, qualifyTable(schemaName, pureTableName))); err != nil {
 		return err
 	}
 	if _, err := w.WriteString("-- ----------------------------\n\n"); err != nil {
@@ -812,10 +1327,6 @@ func dumpTableSQL(w *bufio.Writer, dbInst db.Database, config connection.Connect
 	}

 	if includeSchema {
-		createSQL, err := dbInst.GetCreateStatement(schemaName, pureTableName)
-		if err != nil {
-			return err
-		}
 		if _, err := w.WriteString(ensureSQLTerminator(createSQL)); err != nil {
 			return err
 		}
@@ -828,6 +1339,13 @@ func dumpTableSQL(w *bufio.Writer, dbInst db.Database, config connection.Connect
 		return nil
 	}

+	if isView {
+		if _, err := w.WriteString("-- View data export skipped (INSERT for views is not emitted).\n"); err != nil {
+			return err
+		}
+		return nil
+	}
+
 	qualified := qualifyTable(schemaName, pureTableName)
 	selectSQL := fmt.Sprintf("SELECT * FROM %s", quoteQualifiedIdentByType(config.Type, qualified))
 	data, columns, err := dbInst.Query(selectSQL)
--- a/internal/app/methods_redis.go
+++ b/internal/app/methods_redis.go
@@ -4,6 +4,9 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
+	"fmt"
+	"math"
+	"strconv"
 	"strings"
 	"sync"

@@ -107,14 +110,20 @@ func (a *App) RedisTestConnection(config connection.ConnectionConfig) connection
 }

 // RedisScanKeys scans keys matching a pattern
-func (a *App) RedisScanKeys(config connection.ConnectionConfig, pattern string, cursor uint64, count int64) connection.QueryResult {
+func (a *App) RedisScanKeys(config connection.ConnectionConfig, pattern string, cursor any, 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)
+	parsedCursor, err := parseRedisScanCursor(cursor)
+	if err != nil {
+		logger.Warnf("RedisScanKeys 游标解析失败，已回退到起始游标：cursor=%v err=%v", cursor, err)
+		parsedCursor = 0
+	}
+
+	result, err := client.ScanKeys(pattern, parsedCursor, count)
 	if err != nil {
 		logger.Error(err, "RedisScanKeys 扫描失败：pattern=%s", pattern)
 		return connection.QueryResult{Success: false, Message: err.Error()}
@@ -123,6 +132,82 @@ func (a *App) RedisScanKeys(config connection.ConnectionConfig, pattern string,
 	return connection.QueryResult{Success: true, Data: result}
 }

+func parseRedisScanCursor(cursor any) (uint64, error) {
+	switch v := cursor.(type) {
+	case nil:
+		return 0, nil
+	case uint64:
+		return v, nil
+	case uint32:
+		return uint64(v), nil
+	case uint16:
+		return uint64(v), nil
+	case uint8:
+		return uint64(v), nil
+	case uint:
+		return uint64(v), nil
+	case int64:
+		if v < 0 {
+			return 0, fmt.Errorf("游标不能为负数: %d", v)
+		}
+		return uint64(v), nil
+	case int32:
+		if v < 0 {
+			return 0, fmt.Errorf("游标不能为负数: %d", v)
+		}
+		return uint64(v), nil
+	case int16:
+		if v < 0 {
+			return 0, fmt.Errorf("游标不能为负数: %d", v)
+		}
+		return uint64(v), nil
+	case int8:
+		if v < 0 {
+			return 0, fmt.Errorf("游标不能为负数: %d", v)
+		}
+		return uint64(v), nil
+	case int:
+		if v < 0 {
+			return 0, fmt.Errorf("游标不能为负数: %d", v)
+		}
+		return uint64(v), nil
+	case float64:
+		return parseRedisScanCursorFromFloat(v)
+	case float32:
+		return parseRedisScanCursorFromFloat(float64(v))
+	case json.Number:
+		return parseRedisScanCursor(strings.TrimSpace(v.String()))
+	case string:
+		trimmed := strings.TrimSpace(v)
+		if trimmed == "" {
+			return 0, nil
+		}
+		parsed, err := strconv.ParseUint(trimmed, 10, 64)
+		if err != nil {
+			return 0, fmt.Errorf("无效游标: %q", v)
+		}
+		return parsed, nil
+	default:
+		return 0, fmt.Errorf("不支持的游标类型: %T", cursor)
+	}
+}
+
+func parseRedisScanCursorFromFloat(value float64) (uint64, error) {
+	if math.IsNaN(value) || math.IsInf(value, 0) {
+		return 0, fmt.Errorf("无效浮点游标: %v", value)
+	}
+	if value < 0 {
+		return 0, fmt.Errorf("游标不能为负数: %v", value)
+	}
+	if math.Trunc(value) != value {
+		return 0, fmt.Errorf("游标必须为整数: %v", value)
+	}
+	if value > float64(math.MaxUint64) {
+		return 0, fmt.Errorf("游标超出范围: %v", value)
+	}
+	return uint64(value), nil
+}
+
 // RedisGetValue gets the value of a key
 func (a *App) RedisGetValue(config connection.ConnectionConfig, key string) connection.QueryResult {
 	config.Type = "redis"
--- a/internal/app/methods_redis_cursor_test.go
+++ b/internal/app/methods_redis_cursor_test.go
@@ -0,0 +1,50 @@
+package app
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestParseRedisScanCursor(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name    string
+		input   any
+		want    uint64
+		wantErr bool
+	}{
+		{name: "nil defaults to zero", input: nil, want: 0},
+		{name: "empty string defaults to zero", input: "  ", want: 0},
+		{name: "string cursor", input: "123", want: 123},
+		{name: "uint64 cursor", input: uint64(456), want: 456},
+		{name: "int cursor", input: int(789), want: 789},
+		{name: "float cursor", input: float64(42), want: 42},
+		{name: "json number cursor", input: json.Number("88"), want: 88},
+		{name: "negative int rejected", input: -1, wantErr: true},
+		{name: "fraction float rejected", input: float64(1.5), wantErr: true},
+		{name: "invalid string rejected", input: "abc", wantErr: true},
+		{name: "unsupported type rejected", input: true, wantErr: true},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := parseRedisScanCursor(tc.input)
+			if tc.wantErr {
+				if err == nil {
+					t.Fatalf("expected error, got nil (value=%d)", got)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if got != tc.want {
+				t.Fatalf("parseRedisScanCursor() mismatch, want=%d got=%d", tc.want, got)
+			}
+		})
+	}
+}
--- a/internal/app/methods_update.go
+++ b/internal/app/methods_update.go
@@ -13,6 +13,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	stdRuntime "runtime"
+	"strconv"
 	"strings"
 	"time"

@@ -373,7 +374,7 @@ func getCurrentAuthor() string {
 }

 func fetchLatestRelease() (*githubRelease, error) {
-	client := &http.Client{Timeout: 15 * time.Second}
+	client := newHTTPClientWithGlobalProxy(15 * time.Second)
 	req, err := http.NewRequest(http.MethodGet, updateAPIURL, nil)
 	if err != nil {
 		return nil, err
@@ -450,7 +451,7 @@ func fetchReleaseSHA256(assets []githubAsset) (map[string]string, error) {
 		return nil, errors.New("Release 未提供 SHA256SUMS")
 	}

-	client := &http.Client{Timeout: 15 * time.Second}
+	client := newHTTPClientWithGlobalProxy(15 * time.Second)
 	req, err := http.NewRequest(http.MethodGet, checksumURL, nil)
 	if err != nil {
 		return nil, err
@@ -521,7 +522,7 @@ func (w *downloadProgressWriter) Write(p []byte) (int, error) {
 }

 func downloadFileWithHash(url, filePath string, onProgress func(downloaded, total int64)) (string, error) {
-	client := &http.Client{Timeout: 10 * time.Minute}
+	client := newHTTPClientWithGlobalProxy(10 * time.Minute)
 	req, err := http.NewRequest(http.MethodGet, url, nil)
 	if err != nil {
 		return "", err
@@ -857,55 +858,55 @@ func launchLinuxUpdate(staged *stagedUpdate, targetExe string, pid int) error {
 }

 func buildWindowsScript(source, target, stagedDir, logPath string, pid int) string {
-	return fmt.Sprintf(`@echo off
+	script := `@echo off
 setlocal EnableExtensions EnableDelayedExpansion
-set "SOURCE=%s"
-set "TARGET=%s"
-set "STAGED=%s"
-set "LOG_FILE=%s"
-set PID=%d
+set "SOURCE=__GONAVI_UPDATE_SOURCE__"
+set "TARGET=__GONAVI_UPDATE_TARGET__"
+set "STAGED=__GONAVI_UPDATE_STAGED__"
+set "LOG_FILE=__GONAVI_UPDATE_LOG__"
+set PID=__GONAVI_UPDATE_PID__

 call :log updater started
-if not exist "%%SOURCE%%" (
-  call :log source file not found: %%SOURCE%%
+if not exist "%SOURCE%" (
+  call :log source file not found: %SOURCE%
  exit /b 1
 )

-for %%I in ("%%TARGET%%") do set "TARGET_NAME=%%~nxI"
-for %%I in ("%%SOURCE%%") do set "SOURCE_EXT=%%~xI"
+for %%I in ("%TARGET%") do set "TARGET_NAME=%%~nxI"
+for %%I in ("%SOURCE%") do set "SOURCE_EXT=%%~xI"
 set "SOURCE_EXE="

-if /I "%%SOURCE_EXT%%"==".zip" (
-  set "EXTRACT_DIR=%%STAGED%%\_extract"
-  if exist "%%EXTRACT_DIR%%" (
-    rmdir /S /Q "%%EXTRACT_DIR%%" >> "%%LOG_FILE%%" 2>&1
+if /I "%SOURCE_EXT%"==".zip" (
+  set "EXTRACT_DIR=%STAGED%\_extract"
+  if exist "%EXTRACT_DIR%" (
+    rmdir /S /Q "%EXTRACT_DIR%" >> "%LOG_FILE%" 2>&1
  )
-  mkdir "%%EXTRACT_DIR%%" >> "%%LOG_FILE%%" 2>&1
-  powershell -NoProfile -ExecutionPolicy Bypass -Command "$src=$env:SOURCE; $dst=$env:EXTRACT_DIR; Expand-Archive -LiteralPath $src -DestinationPath $dst -Force" >> "%%LOG_FILE%%" 2>&1
-  if %%ERRORLEVEL%% NEQ 0 (
-    call :log expand zip failed: %%SOURCE%%
+  mkdir "%EXTRACT_DIR%" >> "%LOG_FILE%" 2>&1
+  powershell -NoProfile -ExecutionPolicy Bypass -Command "$src=$env:SOURCE; $dst=$env:EXTRACT_DIR; Expand-Archive -LiteralPath $src -DestinationPath $dst -Force" >> "%LOG_FILE%" 2>&1
+  if %ERRORLEVEL% NEQ 0 (
+    call :log expand zip failed: %SOURCE%
    exit /b 1
  )
-  if exist "%%EXTRACT_DIR%%\%%TARGET_NAME%%" (
-    set "SOURCE_EXE=%%EXTRACT_DIR%%\%%TARGET_NAME%%"
+  if exist "%EXTRACT_DIR%\%TARGET_NAME%" (
+    set "SOURCE_EXE=%EXTRACT_DIR%\%TARGET_NAME%"
  ) else (
-    for /R "%%EXTRACT_DIR%%" %%F in (*.exe) do (
+    for /R "%EXTRACT_DIR%" %%F in (*.exe) do (
      if not defined SOURCE_EXE (
        set "SOURCE_EXE=%%~fF"
      )
    )
  )
  if not defined SOURCE_EXE (
-    call :log no executable found in portable zip: %%SOURCE%%
+    call :log no executable found in portable zip: %SOURCE%
    exit /b 1
  )
 ) else (
-  set "SOURCE_EXE=%%SOURCE%%"
+  set "SOURCE_EXE=%SOURCE%"
 )

 :waitloop
-tasklist /FI "PID eq %%PID%%" | find "%%PID%%" >nul
-if %%ERRORLEVEL%%==0 (
+tasklist /FI "PID eq %PID%" | find "%PID%" >nul
+if %ERRORLEVEL%==0 (
  timeout /t 1 /nobreak >nul
  goto waitloop
 )
@@ -913,11 +914,11 @@ call :log host process exited

 set /a RETRY=0
 :move_retry
-move /Y "%%SOURCE_EXE%%" "%%TARGET%%" >> "%%LOG_FILE%%" 2>&1
-if %%ERRORLEVEL%%==0 goto move_done
+move /Y "%SOURCE_EXE%" "%TARGET%" >> "%LOG_FILE%" 2>&1
+if %ERRORLEVEL%==0 goto move_done

-copy /Y "%%SOURCE_EXE%%" "%%TARGET%%" >> "%%LOG_FILE%%" 2>&1
-if %%ERRORLEVEL%%==0 goto move_done
+copy /Y "%SOURCE_EXE%" "%TARGET%" >> "%LOG_FILE%" 2>&1
+if %ERRORLEVEL%==0 goto move_done

 set /a RETRY+=1
 if !RETRY! LSS 20 (
@@ -929,23 +930,30 @@ call :log replace failed after retries (portable mode, no elevation): check dire
 exit /b 1

 :move_done
-start "" "%%TARGET%%" >> "%%LOG_FILE%%" 2>&1
-if %%ERRORLEVEL%% NEQ 0 (
+start "" "%TARGET%" >> "%LOG_FILE%" 2>&1
+if %ERRORLEVEL% NEQ 0 (
  call :log cmd start failed, trying powershell Start-Process
-  powershell -NoProfile -ExecutionPolicy Bypass -Command "Start-Process -FilePath '%%TARGET%%'" >> "%%LOG_FILE%%" 2>&1
-  if %%ERRORLEVEL%% NEQ 0 (
+  powershell -NoProfile -ExecutionPolicy Bypass -Command "Start-Process -FilePath '%TARGET%'" >> "%LOG_FILE%" 2>&1
+  if %ERRORLEVEL% NEQ 0 (
    call :log relaunch failed
    exit /b 1
  )
 )
-rmdir /S /Q "%%STAGED%%" >> "%%LOG_FILE%%" 2>&1
+rmdir /S /Q "%STAGED%" >> "%LOG_FILE%" 2>&1
 call :log update finished
 exit /b 0

 :log
-echo [%%date%% %%time%%] %%*>>"%%LOG_FILE%%"
+echo [%date% %time%] %*>>"%LOG_FILE%"
 exit /b 0
-`, source, target, stagedDir, logPath, pid)
+`
+	return strings.NewReplacer(
+		"__GONAVI_UPDATE_SOURCE__", source,
+		"__GONAVI_UPDATE_TARGET__", target,
+		"__GONAVI_UPDATE_STAGED__", stagedDir,
+		"__GONAVI_UPDATE_LOG__", logPath,
+		"__GONAVI_UPDATE_PID__", strconv.Itoa(pid),
+	).Replace(script)
 }

 func buildMacScript(dmgPath, targetApp, stagedDir, mountDir, logPath string, pid int) string {
--- a/internal/app/methods_update_windows_script_test.go
+++ b/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)
+		}
+	}
+}
--- a/internal/connection/types.go
+++ b/internal/connection/types.go
@@ -9,33 +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"`
-	SavePassword         bool      `json:"savePassword,omitempty"` // Persist password in saved connection
-	Database             string    `json:"database"`
-	UseSSH               bool      `json:"useSSH"`
-	SSH                  SSHConfig `json:"ssh"`
-	Driver               string    `json:"driver,omitempty"`               // For custom connection
-	DSN                  string    `json:"dsn,omitempty"`                  // For custom connection
-	Timeout              int       `json:"timeout,omitempty"`              // Connection timeout in seconds (default: 30)
-	RedisDB              int       `json:"redisDB,omitempty"`              // Redis database index (0-15)
-	URI                  string    `json:"uri,omitempty"`                  // Connection URI for copy/paste
-	Hosts                []string  `json:"hosts,omitempty"`                // Multi-host addresses: host:port
-	Topology             string    `json:"topology,omitempty"`             // single | replica
-	MySQLReplicaUser     string    `json:"mysqlReplicaUser,omitempty"`     // MySQL replica auth user
-	MySQLReplicaPassword string    `json:"mysqlReplicaPassword,omitempty"` // MySQL replica auth password
-	ReplicaSet           string    `json:"replicaSet,omitempty"`           // MongoDB replica set name
-	AuthSource           string    `json:"authSource,omitempty"`           // MongoDB authSource
-	ReadPreference       string    `json:"readPreference,omitempty"`       // MongoDB readPreference
-	MongoSRV             bool      `json:"mongoSrv,omitempty"`             // MongoDB use mongodb+srv URI scheme
-	MongoAuthMechanism   string    `json:"mongoAuthMechanism,omitempty"`   // MongoDB authMechanism
-	MongoReplicaUser     string    `json:"mongoReplicaUser,omitempty"`     // MongoDB replica auth user
-	MongoReplicaPassword string    `json:"mongoReplicaPassword,omitempty"` // MongoDB replica auth password
+	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
--- a/internal/db/agent_process_stub.go
+++ b/internal/db/agent_process_stub.go
@@ -0,0 +1,9 @@
+//go:build !windows
+
+package db
+
+import "os/exec"
+
+func configureAgentProcess(cmd *exec.Cmd) {
+	_ = cmd
+}
--- a/internal/db/agent_process_windows.go
+++ b/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,
+	}
+}
--- a/internal/db/clickhouse_impl.go
+++ b/internal/db/clickhouse_impl.go
@@ -0,0 +1,594 @@
+//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"
+
+	clickhouse "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) buildClickHouseOptions(config connection.ConnectionConfig) *clickhouse.Options {
+	timeout := getConnectTimeout(config)
+	return &clickhouse.Options{
+		Addr: []string{
+			net.JoinHostPort(config.Host, strconv.Itoa(config.Port)),
+		},
+		Auth: clickhouse.Auth{
+			Database: strings.TrimSpace(config.Database),
+			Username: strings.TrimSpace(config.User),
+			Password: config.Password,
+		},
+		DialTimeout: timeout,
+		ReadTimeout: timeout,
+	}
+}
+
+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)
+	}
+
+	c.conn = clickhouse.OpenDB(c.buildClickHouseOptions(runConfig))
+
+	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"
+	}
+}
--- a/internal/db/database_optional_factories_full.go
+++ b/internal/db/database_optional_factories_full.go
@@ -15,4 +15,5 @@ func registerOptionalDatabaseFactories() {
 	registerDatabaseFactory(newOptionalDriverAgentDatabase("vastbase"), "vastbase")
 	registerDatabaseFactory(newOptionalDriverAgentDatabase("mongodb"), "mongodb")
 	registerDatabaseFactory(newOptionalDriverAgentDatabase("tdengine"), "tdengine")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("clickhouse"), "clickhouse")
 }
--- a/internal/db/database_optional_factories_lite.go
+++ b/internal/db/database_optional_factories_lite.go
@@ -15,4 +15,5 @@ func registerOptionalDatabaseFactories() {
 	registerDatabaseFactory(newOptionalDriverAgentDatabase("vastbase"), "vastbase")
 	registerDatabaseFactory(newOptionalDriverAgentDatabase("mongodb"), "mongodb")
 	registerDatabaseFactory(newOptionalDriverAgentDatabase("tdengine"), "tdengine")
+	registerDatabaseFactory(newOptionalDriverAgentDatabase("clickhouse"), "clickhouse")
 }
--- a/internal/db/diros_impl.go
+++ b/internal/db/diros_impl.go
@@ -21,7 +21,7 @@ const (
 	defaultDirosPort = 9030
 )

-// DirosDB 使用独立 driver 名称（diros）接入，底层协议兼容 MySQL。
+// DirosDB 使用独立 driver 名称（diros）接入，底层协议兼容 MySQL（对外显示为 Doris）。
 type DirosDB struct {
 	MySQLDB
 }
@@ -146,7 +146,7 @@ func (d *DirosDB) getDSN(config connection.ConnectionConfig) string {
 			protocol = netName
 			address = normalizeMySQLAddress(config.Host, config.Port)
 		} else {
-			logger.Warnf("注册 Diros SSH 网络失败，将尝试直连：地址=%s:%d 用户=%s，原因：%v", config.Host, config.Port, config.User, err)
+			logger.Warnf("注册 Doris SSH 网络失败，将尝试直连：地址=%s:%d 用户=%s，原因：%v", config.Host, config.Port, config.User, err)
 		}
 	}

@@ -177,7 +177,7 @@ func (d *DirosDB) Connect(config connection.ConnectionConfig) error {
 	runConfig := applyDirosURI(config)
 	addresses := collectDirosAddresses(runConfig)
 	if len(addresses) == 0 {
-		return fmt.Errorf("连接建立后验证失败：未找到可用的 Diros 地址")
+		return fmt.Errorf("连接建立后验证失败：未找到可用的 Doris 地址")
 	}

 	var errorDetails []string
@@ -214,7 +214,7 @@ func (d *DirosDB) Connect(config connection.ConnectionConfig) error {
 	}

 	if len(errorDetails) == 0 {
-		return fmt.Errorf("连接建立后验证失败：未找到可用的 Diros 地址")
+		return fmt.Errorf("连接建立后验证失败：未找到可用的 Doris 地址")
 	}
 	return fmt.Errorf("连接建立后验证失败：%s", strings.Join(errorDetails, "；"))
 }
--- a/internal/db/driver_support.go
+++ b/internal/db/driver_support.go
@@ -18,18 +18,19 @@ var coreBuiltinDrivers = map[string]struct{}{
 // optionalGoDrivers 表示需要用户“安装启用”后才能使用的纯 Go 驱动。
 // 注意：这是一种运行时门控（installed.json 标记），并不减少主二进制体积。
 var optionalGoDrivers = map[string]struct{}{
-	"mariadb":   {},
-	"diros":     {},
-	"sphinx":    {},
-	"sqlserver": {},
-	"sqlite":    {},
-	"duckdb":    {},
-	"dameng":    {},
-	"kingbase":  {},
-	"highgo":    {},
-	"vastbase":  {},
-	"mongodb":   {},
-	"tdengine":  {},
+	"mariadb":    {},
+	"diros":      {},
+	"sphinx":     {},
+	"sqlserver":  {},
+	"sqlite":     {},
+	"duckdb":     {},
+	"dameng":     {},
+	"kingbase":   {},
+	"highgo":     {},
+	"vastbase":   {},
+	"mongodb":    {},
+	"tdengine":   {},
+	"clickhouse": {},
 }

 var (
@@ -60,7 +61,7 @@ func driverDisplayName(driverType string) string {
 	case "mariadb":
 		return "MariaDB"
 	case "diros":
-		return "Diros"
+		return "Doris"
 	case "sphinx":
 		return "Sphinx"
 	case "postgres":
@@ -83,6 +84,8 @@ func driverDisplayName(driverType string) string {
 		return "MongoDB"
 	case "tdengine":
 		return "TDengine"
+	case "clickhouse":
+		return "ClickHouse"
 	default:
 		return strings.ToUpper(strings.TrimSpace(driverType))
 	}
--- a/internal/db/dsn_test.go
+++ b/internal/db/dsn_test.go
@@ -5,6 +5,7 @@ package db
 import (
 	"strings"
 	"testing"
+	"time"

 	"GoNavi-Wails/internal/connection"
 )
@@ -114,3 +115,48 @@ func TestTDengineDSN_UsesWebSocketFormat(t *testing.T) {
 		t.Fatalf("tdengine dsn 格式不正确：%s", dsn)
 	}
 }
+
+func TestClickHouseOptions_UsesStructuredTimeoutAndAuth(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,
+	})
+
+	opts := c.buildClickHouseOptions(cfg)
+	if opts == nil {
+		t.Fatal("options 为空")
+	}
+	if len(opts.Addr) != 1 || opts.Addr[0] != "127.0.0.1:9000" {
+		t.Fatalf("addr 不符合预期：%v", opts.Addr)
+	}
+	if opts.Auth.Username != "default" {
+		t.Fatalf("username 不符合预期：%s", opts.Auth.Username)
+	}
+	if opts.Auth.Password != cfg.Password {
+		t.Fatalf("password 不符合预期：%s", opts.Auth.Password)
+	}
+	if opts.Auth.Database != "analytics" {
+		t.Fatalf("database 不符合预期：%s", opts.Auth.Database)
+	}
+	if opts.DialTimeout != 15*time.Second {
+		t.Fatalf("dial timeout 不符合预期：%s", opts.DialTimeout)
+	}
+	if opts.ReadTimeout != 15*time.Second {
+		t.Fatalf("read timeout 不符合预期：%s", opts.ReadTimeout)
+	}
+	if _, ok := opts.Settings["write_timeout"]; ok {
+		t.Fatalf("options 不应包含 write_timeout 设置：%v", opts.Settings)
+	}
+	if _, ok := opts.Settings["read_timeout"]; ok {
+		t.Fatalf("options 不应通过 settings 传递 read_timeout：%v", opts.Settings)
+	}
+	if _, ok := opts.Settings["dial_timeout"]; ok {
+		t.Fatalf("options 不应通过 settings 传递 dial_timeout：%v", opts.Settings)
+	}
+}
--- a/internal/db/mongodb_impl.go
+++ b/internal/db/mongodb_impl.go
@@ -14,6 +14,7 @@ import (

 	"GoNavi-Wails/internal/connection"
 	"GoNavi-Wails/internal/logger"
+	proxytunnel "GoNavi-Wails/internal/proxy"
 	"GoNavi-Wails/internal/ssh"

 	"go.mongodb.org/mongo-driver/v2/bson"
@@ -29,6 +30,14 @@ type MongoDB struct {
 	forwarder   *ssh.LocalForwarder
 }

+type mongoProxyDialer struct {
+	proxyConfig connection.ProxyConfig
+}
+
+func (d *mongoProxyDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	return proxytunnel.DialContext(ctx, d.proxyConfig, network, address)
+}
+
 const defaultMongoPort = 27017

 func normalizeMongoAddress(host string, port int) string {
@@ -328,6 +337,9 @@ func (m *MongoDB) Connect(config connection.ConnectionConfig) error {

 		uri := m.getURI(attemptConfig)
 		clientOpts := options.Client().ApplyURI(uri)
+		if attemptConfig.UseProxy {
+			clientOpts.SetDialer(&mongoProxyDialer{proxyConfig: attemptConfig.Proxy})
+		}
 		client, err := mongo.Connect(clientOpts)
 		if err != nil {
 			errorDetails = append(errorDetails, fmt.Sprintf("%s连接失败: %v", authLabel, err))
--- a/internal/db/mysql_agent_impl.go
+++ b/internal/db/mysql_agent_impl.go
@@ -67,11 +67,16 @@ func newMySQLAgentClient(executablePath string) (*mysqlAgentClient, error) {
 	if pathText == "" {
 		return nil, fmt.Errorf("MySQL 驱动代理路径为空")
 	}
-	if info, err := os.Stat(pathText); err != nil || info.IsDir() {
+	info, err := os.Stat(pathText)
+	if err != nil {
 		return nil, fmt.Errorf("MySQL 驱动代理不存在：%s", pathText)
 	}
+	if info.IsDir() {
+		return nil, fmt.Errorf("MySQL 驱动代理路径是目录：%s", pathText)
+	}

 	cmd := exec.Command(pathText)
+	configureAgentProcess(cmd)
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		return nil, fmt.Errorf("创建 MySQL 驱动代理 stdin 失败：%w", err)
--- a/internal/db/mysql_impl.go
+++ b/internal/db/mysql_impl.go
@@ -501,6 +501,8 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		return fmt.Errorf("connection not open")
 	}

+	columnTypeMap := m.loadColumnTypeMap(tableName)
+
 	tx, err := m.conn.Begin()
 	if err != nil {
 		return err
@@ -513,7 +515,7 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		var args []interface{}
 		for k, v := range pk {
 			wheres = append(wheres, fmt.Sprintf("`%s` = ?", k))
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizeMySQLValueForWrite(k, v, columnTypeMap))
 		}
 		if len(wheres) == 0 {
 			continue
@@ -535,7 +537,7 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e

 		for k, v := range update.Values {
 			sets = append(sets, fmt.Sprintf("`%s` = ?", k))
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizeMySQLValueForWrite(k, v, columnTypeMap))
 		}

 		if len(sets) == 0 {
@@ -545,7 +547,7 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		var wheres []string
 		for k, v := range update.Keys {
 			wheres = append(wheres, fmt.Sprintf("`%s` = ?", k))
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizeMySQLValueForWrite(k, v, columnTypeMap))
 		}

 		if len(wheres) == 0 {
@@ -569,12 +571,24 @@ func (m *MySQLDB) ApplyChanges(tableName string, changes connection.ChangeSet) e
 		var args []interface{}

 		for k, v := range row {
+			normalizedValue, omit := normalizeMySQLValueForInsert(k, v, columnTypeMap)
+			if omit {
+				continue
+			}
 			cols = append(cols, fmt.Sprintf("`%s`", k))
 			placeholders = append(placeholders, "?")
-			args = append(args, normalizeMySQLDateTimeValue(v))
+			args = append(args, normalizedValue)
 		}

 		if len(cols) == 0 {
+			query := fmt.Sprintf("INSERT INTO `%s` () VALUES ()", tableName)
+			res, err := tx.Exec(query)
+			if err != nil {
+				return fmt.Errorf("insert error: %v", err)
+			}
+			if affected, err := res.RowsAffected(); err == nil && affected == 0 {
+				return fmt.Errorf("插入未生效：未影响任何行")
+			}
 			continue
 		}

@@ -629,6 +643,69 @@ func normalizeMySQLDateTimeValue(value interface{}) interface{} {
 	return value
 }

+func (m *MySQLDB) loadColumnTypeMap(tableName string) map[string]string {
+	result := map[string]string{}
+	table := strings.TrimSpace(tableName)
+	if table == "" {
+		return result
+	}
+
+	columns, err := m.GetColumns("", table)
+	if err != nil {
+		logger.Warnf("加载列元数据失败（不影响提交）：表=%s err=%v", table, err)
+		return result
+	}
+
+	for _, col := range columns {
+		name := strings.ToLower(strings.TrimSpace(col.Name))
+		if name == "" {
+			continue
+		}
+		result[name] = strings.TrimSpace(col.Type)
+	}
+	return result
+}
+
+func normalizeMySQLValueForInsert(columnName string, value interface{}, columnTypeMap map[string]string) (interface{}, bool) {
+	columnType := strings.ToLower(strings.TrimSpace(columnTypeMap[strings.ToLower(strings.TrimSpace(columnName))]))
+	if !isMySQLTemporalColumnType(columnType) {
+		return value, false
+	}
+	text, ok := value.(string)
+	if ok && strings.TrimSpace(text) == "" {
+		// INSERT 空时间字段不写入，交给 DB 默认值处理（如 CURRENT_TIMESTAMP）。
+		return nil, true
+	}
+	return normalizeMySQLDateTimeValue(value), false
+}
+
+func normalizeMySQLValueForWrite(columnName string, value interface{}, columnTypeMap map[string]string) interface{} {
+	columnType := strings.ToLower(strings.TrimSpace(columnTypeMap[strings.ToLower(strings.TrimSpace(columnName))]))
+	if !isMySQLTemporalColumnType(columnType) {
+		return value
+	}
+	text, ok := value.(string)
+	if ok && strings.TrimSpace(text) == "" {
+		return nil
+	}
+	return normalizeMySQLDateTimeValue(value)
+}
+
+func isMySQLTemporalColumnType(columnType string) bool {
+	raw := strings.ToLower(strings.TrimSpace(columnType))
+	if raw == "" {
+		return false
+	}
+	if strings.Contains(raw, "datetime") || strings.Contains(raw, "timestamp") {
+		return true
+	}
+	base := raw
+	if idx := strings.IndexAny(base, "( "); idx >= 0 {
+		base = base[:idx]
+	}
+	return base == "date" || base == "time" || base == "year"
+}
+
 func hasTimezoneOffset(text string) bool {
 	pos := strings.LastIndexAny(text, "+-")
 	if pos < 0 || pos < 10 || pos+1 >= len(text) {
--- a/internal/db/optional_driver_agent_impl.go
+++ b/internal/db/optional_driver_agent_impl.go
@@ -68,11 +68,16 @@ func newOptionalDriverAgentClient(driverType string, executablePath string) (*op
 	if pathText == "" {
 		return nil, fmt.Errorf("%s 驱动代理路径为空", driverDisplayName(driverType))
 	}
-	if info, err := os.Stat(pathText); err != nil || info.IsDir() {
+	info, err := os.Stat(pathText)
+	if err != nil {
 		return nil, fmt.Errorf("%s 驱动代理不存在：%s", driverDisplayName(driverType), pathText)
 	}
+	if info.IsDir() {
+		return nil, fmt.Errorf("%s 驱动代理路径是目录：%s", driverDisplayName(driverType), pathText)
+	}

 	cmd := exec.Command(pathText)
+	configureAgentProcess(cmd)
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		return nil, fmt.Errorf("创建 %s 驱动代理 stdin 失败：%w", driverDisplayName(driverType), err)
--- a/internal/db/postgres_connect_test.go
+++ b/internal/db/postgres_connect_test.go
@@ -0,0 +1,48 @@
+package db
+
+import (
+	"reflect"
+	"testing"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+func TestResolvePostgresConnectDatabases_ExplicitDatabase(t *testing.T) {
+	cfg := connection.ConnectionConfig{
+		Type:     "postgres",
+		Database: "analytics",
+		User:     "app_user",
+	}
+
+	got := resolvePostgresConnectDatabases(cfg)
+	want := []string{"analytics"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected databases, got=%v want=%v", got, want)
+	}
+}
+
+func TestResolvePostgresConnectDatabases_FallbackOrder(t *testing.T) {
+	cfg := connection.ConnectionConfig{
+		Type: "postgres",
+		User: "app_user",
+	}
+
+	got := resolvePostgresConnectDatabases(cfg)
+	want := []string{"postgres", "template1", "app_user"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected databases, got=%v want=%v", got, want)
+	}
+}
+
+func TestResolvePostgresConnectDatabases_DeduplicateUserDefault(t *testing.T) {
+	cfg := connection.ConnectionConfig{
+		Type: "postgres",
+		User: "postgres",
+	}
+
+	got := resolvePostgresConnectDatabases(cfg)
+	want := []string{"postgres", "template1"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected databases, got=%v want=%v", got, want)
+	}
+}
--- a/internal/db/postgres_impl.go
+++ b/internal/db/postgres_impl.go
@@ -24,6 +24,30 @@ type PostgresDB struct {
 	forwarder   *ssh.LocalForwarder // Store SSH tunnel forwarder
 }

+func resolvePostgresConnectDatabases(config connection.ConnectionConfig) []string {
+	explicit := strings.TrimSpace(config.Database)
+	if explicit != "" {
+		return []string{explicit}
+	}
+
+	candidates := []string{"postgres", "template1", strings.TrimSpace(config.User)}
+	seen := make(map[string]struct{}, len(candidates))
+	result := make([]string, 0, len(candidates))
+	for _, name := range candidates {
+		trimmed := strings.TrimSpace(name)
+		if trimmed == "" {
+			continue
+		}
+		normalized := strings.ToLower(trimmed)
+		if _, exists := seen[normalized]; exists {
+			continue
+		}
+		seen[normalized] = struct{}{}
+		result = append(result, trimmed)
+	}
+	return result
+}
+
 func (p *PostgresDB) getDSN(config connection.ConnectionConfig) string {
 	// postgres://user:password@host:port/dbname?sslmode=disable
 	dbname := config.Database
@@ -53,8 +77,23 @@ func (p *PostgresDB) Connect(config connection.ConnectionConfig) error {
 		return fmt.Errorf("%s", reason)
 	}

-	var dsn string
-	var err error
+	runConfig := config
+	p.pingTimeout = getConnectTimeout(config)
+
+	cleanupOnFailure := true
+	defer func() {
+		if !cleanupOnFailure {
+			return
+		}
+		if p.conn != nil {
+			_ = p.conn.Close()
+			p.conn = nil
+		}
+		if p.forwarder != nil {
+			_ = p.forwarder.Close()
+			p.forwarder = nil
+		}
+	}()

 	if config.UseSSH {
 		// Create SSH tunnel with local port forwarding
@@ -83,24 +122,44 @@ func (p *PostgresDB) Connect(config connection.ConnectionConfig) error {
 		localConfig.Port = port
 		localConfig.UseSSH = false // Disable SSH flag for DSN generation

-		dsn = p.getDSN(localConfig)
+		runConfig = localConfig
 		logger.Infof("PostgreSQL 通过本地端口转发连接：%s -> %s:%d", forwarder.LocalAddr, config.Host, config.Port)
-	} else {
-		dsn = p.getDSN(config)
 	}

-	db, err := sql.Open("postgres", dsn)
-	if err != nil {
-		return fmt.Errorf("打开数据库连接失败：%w", err)
-	}
-	p.conn = db
-	p.pingTimeout = getConnectTimeout(config)
+	attemptDBs := resolvePostgresConnectDatabases(runConfig)
+	var failures []string
+	for _, dbName := range attemptDBs {
+		attemptConfig := runConfig
+		attemptConfig.Database = dbName
+		dsn := p.getDSN(attemptConfig)

-	// Force verification
-	if err := p.Ping(); err != nil {
-		return fmt.Errorf("连接建立后验证失败：%w", err)
+		dbConn, err := sql.Open("postgres", dsn)
+		if err != nil {
+			failures = append(failures, fmt.Sprintf("数据库=%s 打开连接失败: %v", dbName, err))
+			continue
+		}
+		p.conn = dbConn
+
+		// Force verification
+		if err := p.Ping(); err != nil {
+			failures = append(failures, fmt.Sprintf("数据库=%s 验证失败: %v", dbName, err))
+			_ = dbConn.Close()
+			p.conn = nil
+			continue
+		}
+
+		if strings.TrimSpace(config.Database) == "" && !strings.EqualFold(dbName, "postgres") {
+			logger.Infof("PostgreSQL 自动选择连接数据库：%s", dbName)
+		}
+
+		cleanupOnFailure = false
+		return nil
 	}
-	return nil
+
+	if len(failures) == 0 {
+		return fmt.Errorf("连接建立后验证失败：未找到可用的连接数据库")
+	}
+	return fmt.Errorf("连接建立后验证失败：%s", strings.Join(failures, "；"))
 }

 func (p *PostgresDB) Close() error {
--- a/internal/proxy/proxy.go
+++ b/internal/proxy/proxy.go
@@ -0,0 +1,344 @@
+package proxy
+
+import (
+	"bufio"
+	"context"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"GoNavi-Wails/internal/connection"
+	"GoNavi-Wails/internal/logger"
+
+	xproxy "golang.org/x/net/proxy"
+)
+
+const (
+	defaultDialTimeout = 8 * time.Second
+)
+
+type LocalForwarder struct {
+	LocalAddr  string
+	RemoteAddr string
+	ProxyAddr  string
+	ProxyType  string
+
+	cfg       connection.ProxyConfig
+	listener  net.Listener
+	closeChan chan struct{}
+	closeOnce sync.Once
+
+	closed   bool
+	closedMu sync.RWMutex
+}
+
+var (
+	forwarderMu     sync.RWMutex
+	localForwarders = make(map[string]*LocalForwarder)
+)
+
+func NormalizeConfig(config connection.ProxyConfig) (connection.ProxyConfig, error) {
+	result := connection.ProxyConfig{
+		Type:     strings.ToLower(strings.TrimSpace(config.Type)),
+		Host:     strings.TrimSpace(config.Host),
+		Port:     config.Port,
+		User:     strings.TrimSpace(config.User),
+		Password: config.Password,
+	}
+
+	switch result.Type {
+	case "socks5", "socks5h", "http":
+	default:
+		return result, fmt.Errorf("不支持的代理类型：%s", config.Type)
+	}
+	if result.Type == "socks5h" {
+		result.Type = "socks5"
+	}
+	if result.Host == "" {
+		return result, fmt.Errorf("代理主机为空")
+	}
+	if result.Port <= 0 || result.Port > 65535 {
+		return result, fmt.Errorf("代理端口无效：%d", result.Port)
+	}
+	return result, nil
+}
+
+func GetOrCreateLocalForwarder(proxyConfig connection.ProxyConfig, remoteHost string, remotePort int) (*LocalForwarder, error) {
+	cfg, err := NormalizeConfig(proxyConfig)
+	if err != nil {
+		return nil, err
+	}
+	if strings.TrimSpace(remoteHost) == "" || remotePort <= 0 {
+		return nil, fmt.Errorf("无效的远端地址：%s:%d", remoteHost, remotePort)
+	}
+
+	key := forwarderCacheKey(cfg, remoteHost, remotePort)
+	forwarderMu.RLock()
+	forwarder, exists := localForwarders[key]
+	forwarderMu.RUnlock()
+	if exists && forwarder != nil && !forwarder.IsClosed() {
+		return forwarder, nil
+	}
+
+	if exists {
+		forwarderMu.Lock()
+		delete(localForwarders, key)
+		forwarderMu.Unlock()
+	}
+
+	next, err := NewLocalForwarder(cfg, remoteHost, remotePort)
+	if err != nil {
+		return nil, err
+	}
+
+	forwarderMu.Lock()
+	localForwarders[key] = next
+	forwarderMu.Unlock()
+	return next, nil
+}
+
+func forwarderCacheKey(cfg connection.ProxyConfig, remoteHost string, remotePort int) string {
+	trimmedHost := strings.TrimSpace(remoteHost)
+	credential := cfg.User + "\x00" + cfg.Password
+	credentialHash := sha256.Sum256([]byte(credential))
+	// 仅保留短指纹用于区分不同认证信息，避免在 key 日志中泄露明文口令。
+	fingerprint := hex.EncodeToString(credentialHash[:8])
+	return fmt.Sprintf("%s://%s:%d@%s:%d#%s", cfg.Type, cfg.Host, cfg.Port, trimmedHost, remotePort, fingerprint)
+}
+
+func NewLocalForwarder(proxyConfig connection.ProxyConfig, remoteHost string, remotePort int) (*LocalForwarder, error) {
+	cfg, err := NormalizeConfig(proxyConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return nil, fmt.Errorf("创建本地代理监听失败：%w", err)
+	}
+
+	localAddr := listener.Addr().String()
+	remoteAddr := net.JoinHostPort(strings.TrimSpace(remoteHost), fmt.Sprintf("%d", remotePort))
+	proxyAddr := net.JoinHostPort(cfg.Host, fmt.Sprintf("%d", cfg.Port))
+	forwarder := &LocalForwarder{
+		LocalAddr:  localAddr,
+		RemoteAddr: remoteAddr,
+		ProxyAddr:  proxyAddr,
+		ProxyType:  cfg.Type,
+		cfg:        cfg,
+		listener:   listener,
+		closeChan:  make(chan struct{}),
+	}
+
+	go forwarder.forward()
+	logger.Infof("已创建代理端口转发：本地 %s -> 远端 %s（代理 %s://%s）", localAddr, remoteAddr, cfg.Type, proxyAddr)
+	return forwarder, nil
+}
+
+func (f *LocalForwarder) forward() {
+	for {
+		localConn, err := f.listener.Accept()
+		if err != nil {
+			select {
+			case <-f.closeChan:
+				return
+			default:
+				logger.Warnf("接受本地代理连接失败：%v", err)
+				return
+			}
+		}
+		go f.handleConnection(localConn)
+	}
+}
+
+func (f *LocalForwarder) handleConnection(localConn net.Conn) {
+	defer localConn.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), defaultDialTimeout)
+	remoteConn, err := dialThroughProxy(ctx, f.cfg, "tcp", f.RemoteAddr)
+	cancel()
+	if err != nil {
+		logger.Warnf("通过代理连接远端失败：远端=%s 代理=%s://%s 错误=%v", f.RemoteAddr, f.ProxyType, f.ProxyAddr, err)
+		return
+	}
+	defer remoteConn.Close()
+
+	errc := make(chan error, 2)
+	var closeOnce sync.Once
+	closeBoth := func() {
+		_ = localConn.Close()
+		_ = remoteConn.Close()
+	}
+	go func() {
+		_, copyErr := io.Copy(remoteConn, localConn)
+		closeOnce.Do(closeBoth)
+		errc <- copyErr
+	}()
+	go func() {
+		_, copyErr := io.Copy(localConn, remoteConn)
+		closeOnce.Do(closeBoth)
+		errc <- copyErr
+	}()
+	<-errc
+	<-errc
+}
+
+func (f *LocalForwarder) Close() error {
+	var err error
+	f.closeOnce.Do(func() {
+		f.closedMu.Lock()
+		f.closed = true
+		f.closedMu.Unlock()
+		close(f.closeChan)
+		err = f.listener.Close()
+		if err != nil {
+			logger.Warnf("关闭代理端口转发失败：%v", err)
+		}
+	})
+	return err
+}
+
+func (f *LocalForwarder) IsClosed() bool {
+	f.closedMu.RLock()
+	defer f.closedMu.RUnlock()
+	return f.closed
+}
+
+func CloseAllForwarders() {
+	forwarderMu.Lock()
+	defer forwarderMu.Unlock()
+
+	for key, forwarder := range localForwarders {
+		if forwarder == nil {
+			continue
+		}
+		_ = forwarder.Close()
+		logger.Infof("已关闭代理端口转发：%s", key)
+	}
+	localForwarders = make(map[string]*LocalForwarder)
+}
+
+func DialContext(ctx context.Context, proxyConfig connection.ProxyConfig, network, address string) (net.Conn, error) {
+	cfg, err := NormalizeConfig(proxyConfig)
+	if err != nil {
+		return nil, err
+	}
+	return dialThroughProxy(ctx, cfg, network, address)
+}
+
+func dialThroughProxy(ctx context.Context, cfg connection.ProxyConfig, network, address string) (net.Conn, error) {
+	switch cfg.Type {
+	case "socks5":
+		return dialSOCKS5(ctx, cfg, network, address)
+	case "http":
+		return dialHTTPConnect(ctx, cfg, address)
+	default:
+		return nil, fmt.Errorf("不支持的代理类型：%s", cfg.Type)
+	}
+}
+
+func dialSOCKS5(ctx context.Context, cfg connection.ProxyConfig, network, address string) (net.Conn, error) {
+	proxyAddr := net.JoinHostPort(cfg.Host, fmt.Sprintf("%d", cfg.Port))
+	var auth *xproxy.Auth
+	if cfg.User != "" || cfg.Password != "" {
+		auth = &xproxy.Auth{
+			User:     cfg.User,
+			Password: cfg.Password,
+		}
+	}
+	dialer, err := xproxy.SOCKS5("tcp", proxyAddr, auth, &net.Dialer{Timeout: defaultDialTimeout})
+	if err != nil {
+		return nil, fmt.Errorf("创建 SOCKS5 代理拨号器失败：%w", err)
+	}
+
+	type result struct {
+		conn net.Conn
+		err  error
+	}
+	ch := make(chan result, 1)
+	go func() {
+		conn, dialErr := dialer.Dial(network, address)
+		ch <- result{conn: conn, err: dialErr}
+	}()
+
+	select {
+	case <-ctx.Done():
+		go func() {
+			r := <-ch
+			if r.conn != nil {
+				_ = r.conn.Close()
+			}
+		}()
+		return nil, ctx.Err()
+	case r := <-ch:
+		if r.err != nil {
+			return nil, fmt.Errorf("SOCKS5 代理连接失败：%w", r.err)
+		}
+		return r.conn, nil
+	}
+}
+
+func dialHTTPConnect(ctx context.Context, cfg connection.ProxyConfig, address string) (net.Conn, error) {
+	proxyAddr := net.JoinHostPort(cfg.Host, fmt.Sprintf("%d", cfg.Port))
+	dialer := &net.Dialer{Timeout: defaultDialTimeout}
+	conn, err := dialer.DialContext(ctx, "tcp", proxyAddr)
+	if err != nil {
+		return nil, fmt.Errorf("连接 HTTP 代理失败：%w", err)
+	}
+
+	connectReq := &http.Request{
+		Method: http.MethodConnect,
+		URL:    &url.URL{Opaque: address},
+		Host:   address,
+		Header: make(http.Header),
+	}
+	if cfg.User != "" || cfg.Password != "" {
+		raw := cfg.User + ":" + cfg.Password
+		connectReq.Header.Set("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(raw)))
+	}
+	if err := connectReq.Write(conn); err != nil {
+		_ = conn.Close()
+		return nil, fmt.Errorf("发送 HTTP CONNECT 请求失败：%w", err)
+	}
+
+	reader := bufio.NewReader(conn)
+	resp, err := http.ReadResponse(reader, connectReq)
+	if err != nil {
+		_ = conn.Close()
+		return nil, fmt.Errorf("读取 HTTP CONNECT 响应失败：%w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		_ = conn.Close()
+		return nil, fmt.Errorf("HTTP 代理 CONNECT 失败：%s", strings.TrimSpace(resp.Status))
+	}
+
+	if reader.Buffered() == 0 {
+		return conn, nil
+	}
+	return &bufferedConn{Conn: conn, reader: reader}, nil
+}
+
+type bufferedConn struct {
+	net.Conn
+	reader *bufio.Reader
+}
+
+func (c *bufferedConn) Read(p []byte) (int, error) {
+	if c.reader == nil {
+		return c.Conn.Read(p)
+	}
+	if c.reader.Buffered() == 0 {
+		c.reader = nil
+		return c.Conn.Read(p)
+	}
+	return c.reader.Read(p)
+}
--- a/internal/proxy/proxy_test.go
+++ b/internal/proxy/proxy_test.go
@@ -0,0 +1,44 @@
+package proxy
+
+import (
+	"strings"
+	"testing"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+func TestNormalizeConfigSupportsSocks5hAlias(t *testing.T) {
+	cfg, err := NormalizeConfig(connection.ProxyConfig{
+		Type: "SOCKS5H",
+		Host: "127.0.0.1",
+		Port: 1080,
+	})
+	if err != nil {
+		t.Fatalf("NormalizeConfig returned error: %v", err)
+	}
+	if cfg.Type != "socks5" {
+		t.Fatalf("expected normalized proxy type socks5, got %s", cfg.Type)
+	}
+}
+
+func TestForwarderCacheKeyIncludesCredentialFingerprint(t *testing.T) {
+	base := connection.ProxyConfig{
+		Type:     "socks5",
+		Host:     "127.0.0.1",
+		Port:     1080,
+		User:     "tester",
+		Password: "first-password",
+	}
+	other := base
+	other.Password = "second-password"
+
+	keyA := forwarderCacheKey(base, "db.internal", 3306)
+	keyB := forwarderCacheKey(other, "db.internal", 3306)
+
+	if keyA == keyB {
+		t.Fatalf("expected different cache key for different credentials")
+	}
+	if strings.Contains(keyA, base.Password) || strings.Contains(keyB, other.Password) {
+		t.Fatalf("cache key should not contain raw password")
+	}
+}
--- a/internal/redis/redis.go
+++ b/internal/redis/redis.go
@@ -26,7 +26,7 @@ type RedisKeyInfo struct {
 // RedisScanResult represents the result of a SCAN operation
 type RedisScanResult struct {
 	Keys   []RedisKeyInfo `json:"keys"`
-	Cursor uint64         `json:"cursor"`
+	Cursor string         `json:"cursor"`
 }

 // RedisClient defines the interface for Redis operations
--- a/internal/redis/redis_impl.go
+++ b/internal/redis/redis_impl.go
@@ -22,6 +22,19 @@ type RedisClientImpl struct {
 	forwarder *ssh.LocalForwarder
 }

+const (
+	redisScanDefaultTargetCount int64 = 2000
+	redisScanMaxTargetCount     int64 = 10000
+	redisScanMinStepCount       int64 = 200
+	redisScanMaxStepCount       int64 = 2000
+	redisScanMaxRounds                = 64
+	redisScanMaxDuration              = 12 * time.Second
+	redisSearchMaxTargetCount   int64 = 1000
+	redisSearchMaxStepCount     int64 = 1000
+	redisSearchMaxRounds              = 16
+	redisSearchMaxDuration            = 3 * time.Second
+)
+
 // NewRedisClient creates a new Redis client instance
 func NewRedisClient() RedisClient {
 	return &RedisClientImpl{}
@@ -102,27 +115,96 @@ func (r *RedisClientImpl) ScanKeys(pattern string, cursor uint64, count int64) (
 		return nil, fmt.Errorf("Redis 客户端未连接")
 	}

-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
 	if pattern == "" {
 		pattern = "*"
 	}
+
+	isSearchPattern := pattern != "*"
+	targetCount := normalizeRedisScanTargetCount(count)
+	scanStepCount := normalizeRedisScanStepCount(targetCount)
+	maxRounds := redisScanMaxRounds
+	maxDuration := redisScanMaxDuration
+	if isSearchPattern {
+		if targetCount > redisSearchMaxTargetCount {
+			targetCount = redisSearchMaxTargetCount
+		}
+		if scanStepCount > redisSearchMaxStepCount {
+			scanStepCount = redisSearchMaxStepCount
+		}
+		maxRounds = redisSearchMaxRounds
+		maxDuration = redisSearchMaxDuration
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), maxDuration+5*time.Second)
+	defer cancel()
+
+	currentCursor := cursor
+	round := 0
+	scanStartedAt := time.Now()
+
+	keys := make([]string, 0, int(targetCount))
+	seen := make(map[string]struct{}, int(targetCount))
+
+	for len(keys) < int(targetCount) {
+		if time.Since(scanStartedAt) >= maxDuration {
+			break
+		}
+
+		batch, nextCursor, err := r.client.Scan(ctx, currentCursor, pattern, scanStepCount).Result()
+		if err != nil {
+			return nil, err
+		}
+
+		for _, key := range batch {
+			if _, ok := seen[key]; ok {
+				continue
+			}
+			seen[key] = struct{}{}
+			keys = append(keys, key)
+			if len(keys) >= int(targetCount) {
+				break
+			}
+		}
+
+		currentCursor = nextCursor
+		round++
+		if currentCursor == 0 || round >= maxRounds {
+			break
+		}
+	}
+
+	return &RedisScanResult{
+		Keys:   r.loadRedisKeyInfos(ctx, keys),
+		Cursor: strconv.FormatUint(currentCursor, 10),
+	}, nil
+}
+
+func normalizeRedisScanTargetCount(count int64) int64 {
 	if count <= 0 {
-		count = 100
+		return redisScanDefaultTargetCount
+	}
+	if count > redisScanMaxTargetCount {
+		return redisScanMaxTargetCount
+	}
+	return count
+}
+
+func normalizeRedisScanStepCount(targetCount int64) int64 {
+	if targetCount < redisScanMinStepCount {
+		return redisScanMinStepCount
+	}
+	if targetCount > redisScanMaxStepCount {
+		return redisScanMaxStepCount
+	}
+	return targetCount
+}
+
+func (r *RedisClientImpl) loadRedisKeyInfos(ctx context.Context, keys []string) []RedisKeyInfo {
+	result := make([]RedisKeyInfo, 0, len(keys))
+	if len(keys) == 0 {
+		return result
 	}

-	keys, nextCursor, err := r.client.Scan(ctx, cursor, pattern, count).Result()
-	if err != nil {
-		return nil, err
-	}
-
-	result := &RedisScanResult{
-		Keys:   make([]RedisKeyInfo, 0, len(keys)),
-		Cursor: nextCursor,
-	}
-
-	// Get type and TTL for each key
 	pipe := r.client.Pipeline()
 	typeResults := make([]*redis.StatusCmd, len(keys))
 	ttlResults := make([]*redis.DurationCmd, len(keys))
@@ -132,37 +214,44 @@ func (r *RedisClientImpl) ScanKeys(pattern string, cursor uint64, count int64) (
 		ttlResults[i] = pipe.TTL(ctx, key)
 	}

-	_, err = pipe.Exec(ctx)
+	_, err := pipe.Exec(ctx)
 	if err != nil && err != redis.Nil {
-		// Fallback: get info one by one
 		for _, key := range keys {
-			keyType, _ := r.GetKeyType(key)
-			ttl, _ := r.GetTTL(key)
-			result.Keys = append(result.Keys, RedisKeyInfo{
+			keyType, typeErr := r.client.Type(ctx, key).Result()
+			if typeErr != nil && typeErr != redis.Nil {
+				keyType = ""
+			}
+			ttlValue, ttlErr := r.client.TTL(ctx, key).Result()
+			if ttlErr != nil && ttlErr != redis.Nil {
+				ttlValue = -2
+			}
+			result = append(result, RedisKeyInfo{
 				Key:  key,
 				Type: keyType,
-				TTL:  ttl,
+				TTL:  toRedisTTLSeconds(ttlValue),
 			})
 		}
-		return result, nil
+		return result
 	}

 	for i, key := range keys {
-		keyType := typeResults[i].Val()
-		ttl := int64(ttlResults[i].Val().Seconds())
-		if ttlResults[i].Val() == -1 {
-			ttl = -1
-		} else if ttlResults[i].Val() == -2 {
-			ttl = -2
-		}
-		result.Keys = append(result.Keys, RedisKeyInfo{
+		result = append(result, RedisKeyInfo{
 			Key:  key,
-			Type: keyType,
-			TTL:  ttl,
+			Type: typeResults[i].Val(),
+			TTL:  toRedisTTLSeconds(ttlResults[i].Val()),
 		})
 	}
+	return result
+}

-	return result, nil
+func toRedisTTLSeconds(ttl time.Duration) int64 {
+	if ttl == -1 {
+		return -1
+	}
+	if ttl == -2 {
+		return -2
+	}
+	return int64(ttl.Seconds())
 }

 // GetKeyType returns the type of a key
--- a/main.go
+++ b/main.go
@@ -41,6 +41,7 @@ func main() {
 			BackdropType:                      windows.Acrylic,
 			DisableWindowIcon:                 false,
 			DisableFramelessWindowDecorations: false,
+			WebviewUserDataPath:               resolveWindowsWebviewUserDataPath(),
 		},
 		Mac: &mac.Options{
 			WebviewIsTransparent: true,
--- a/main_windows_webview_userdata.go
+++ b/main_windows_webview_userdata.go
@@ -0,0 +1,123 @@
+//go:build windows
+
+package main
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func resolveWindowsWebviewUserDataPath() string {
+	appDataDir := strings.TrimSpace(os.Getenv("APPDATA"))
+	if appDataDir == "" {
+		return ""
+	}
+
+	targetDir := filepath.Join(appDataDir, "GoNavi", "WebView2")
+	_ = migrateLegacyWindowsWebviewUserData(appDataDir, targetDir)
+	return targetDir
+}
+
+func migrateLegacyWindowsWebviewUserData(appDataDir, targetDir string) error {
+	if dirHasContent(targetDir) {
+		return nil
+	}
+
+	exeName := "GoNavi.exe"
+	if exePath, err := os.Executable(); err == nil {
+		base := strings.TrimSpace(filepath.Base(exePath))
+		if base != "" {
+			exeName = base
+		}
+	}
+	exeBase := strings.TrimSuffix(exeName, filepath.Ext(exeName))
+
+	candidates := []string{
+		filepath.Join(appDataDir, exeName),
+		filepath.Join(appDataDir, exeBase),
+		filepath.Join(appDataDir, "GoNavi.exe"),
+		filepath.Join(appDataDir, "GoNavi"),
+	}
+
+	seen := make(map[string]struct{}, len(candidates))
+	for _, candidate := range candidates {
+		src := filepath.Clean(strings.TrimSpace(candidate))
+		if src == "" || strings.EqualFold(src, filepath.Clean(targetDir)) {
+			continue
+		}
+		key := strings.ToLower(src)
+		if _, exists := seen[key]; exists {
+			continue
+		}
+		seen[key] = struct{}{}
+
+		if !dirHasContent(src) {
+			continue
+		}
+		return copyDirTree(src, targetDir)
+	}
+	return nil
+}
+
+func dirHasContent(path string) bool {
+	info, err := os.Stat(path)
+	if err != nil || !info.IsDir() {
+		return false
+	}
+	entries, err := os.ReadDir(path)
+	return err == nil && len(entries) > 0
+}
+
+func copyDirTree(srcDir, dstDir string) error {
+	if err := os.MkdirAll(dstDir, 0o755); err != nil {
+		return err
+	}
+
+	return filepath.WalkDir(srcDir, func(srcPath string, d os.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		relPath, err := filepath.Rel(srcDir, srcPath)
+		if err != nil {
+			return err
+		}
+		if relPath == "." {
+			return nil
+		}
+		dstPath := filepath.Join(dstDir, relPath)
+
+		if d.IsDir() {
+			return os.MkdirAll(dstPath, 0o755)
+		}
+
+		info, err := d.Info()
+		if err != nil {
+			return err
+		}
+		return copyFileWithMode(srcPath, dstPath, info.Mode())
+	})
+}
+
+func copyFileWithMode(srcPath, dstPath string, mode os.FileMode) error {
+	srcFile, err := os.Open(srcPath)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	if err := os.MkdirAll(filepath.Dir(dstPath), 0o755); err != nil {
+		return err
+	}
+	dstFile, err := os.OpenFile(dstPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, mode.Perm())
+	if err != nil {
+		return err
+	}
+	defer dstFile.Close()
+
+	if _, err := io.Copy(dstFile, srcFile); err != nil {
+		return err
+	}
+	return nil
+}
--- a/main_windows_webview_userdata_stub.go
+++ b/main_windows_webview_userdata_stub.go
@@ -0,0 +1,7 @@
+//go:build !windows
+
+package main
+
+func resolveWindowsWebviewUserDataPath() string {
+	return ""
+}
--- a/BIN
+++ b/BIN
Author	SHA1	Message	Date
Syngnat	ec59023736	📝 docs(i18n-readme): 建立README中英双文档结构并统一能力描述 - 英文主 README 覆盖项目定位、性能特性与安装说明 - 中文 README 覆盖同等信息密度，避免内容断层 - 中英文文档统一支持数据源表格与驱动模式说明 - 完成语言切换链接配置，便于读者快速切换	2026-02-28 15:54:46 +08:00
Syngnat	4a96cb93d2	🎨 style(connection-modal): 优化新建连接弹窗尺寸与分类栏视觉一致性 - 统一调整弹窗 step1/step2 尺寸参数，改善布局观感 - 增加 step1 内容区最小高度，减少拥挤感 - 分类栏分割线改为主题感知颜色，消除深色模式下突兀白线	2026-02-28 15:36:26 +08:00
Syngnat	4c322db9d0	💥 breaking(driver-manager): 统一 Doris 驱动命名并移除 diros 历史包兼容 - 前后端统一 Doris 展示与连接命名，修复 diros 拼写问题 - GitHub Actions 驱动产物改为 doris-driver-agent-* 命名 - 构建流程保持内部 gonavi_diros_driver 映射，避免构建链路中断 - 驱动安装/下载/解压链路仅识别 doris 资产名，不再兼容 diros 历史包 - 内置与文档 manifest 下载地址统一为 builtin://activate/doris - close #132	2026-02-28 15:27:58 +08:00
Syngnat	ed18c8285f	🐛 fix(db-compat): 修复PG系建表语句兼容并优化DuckDB大表总数统计 - 统一 DBShowCreateTable 与导出链路的 DDL 兜底逻辑，修复 Kingbase/Postgres 占位语句问题 - 增强 custom driver 到 postgres/kingbase/highgo/vastbase 的映射并补充回归测试 - DuckDB 关闭自动后台 COUNT(*)，避免大文件场景翻页与查询卡顿 - 新增近似总数展示、手动精确统计与取消统计交互 - 新增 DBQueryIsolated 独立连接查询能力并同步前端 wailsjs 接口 - refs #136	2026-02-28 15:00:13 +08:00
Syngnat	5f8cedabd8	🐛 fix(update-proxy): 修复本地代理下检查更新 TLS 证书未知颁发者失败 - 在全局代理 HTTP 传输层增加本地回环代理兼容回退能力 - 回退触发条件限制为 unknown authority 且仅 GET/HEAD 请求 - 保留默认 TLS 校验策略并输出告警日志便于审计定位 - refs #139	2026-02-28 13:55:42 +08:00
Syngnat	20923989b9	🐛 fix(connection-modal): 修复透明暗色模式下 SSH/代理配置区块白底问题 - 为连接弹窗接入主题与透明度状态，按模式动态计算区块背景 - 将 SSH 与代理配置容器统一替换为自适应样式并补齐边框层次 - 保持连接测试与保存逻辑不变，仅修复显示层	2026-02-28 13:37:19 +08:00
Syngnat	210106cde7	🐛 fix(driver-modal): 修复驱动日志弹窗在透明暗色主题下对比度异常 - 将日志内容容器改为 dark/light 双模式自适应样式 - 使用全局外观透明度参数参与日志背景渲染 - 保持驱动安装与日志采集逻辑不变，仅修复显示层	2026-02-28 13:27:49 +08:00
Syngnat	87aac277ec	🎨 style(redis-viewer): 对齐 Redis 拖拽分割条与侧边栏宽度调整样式 - 分割条宽度调整为与 host 侧边栏一致 - 分割条背景统一为 transparent，去除 hover 强对比效果 - 保持拖拽命中区与提示文案，提升整体样式一致性	2026-02-28 12:53:06 +08:00
Syngnat	4de3f408c5	🐛 fix(redis-scan): 修复大数据量下命名空间加载不完整问题 - 前后端 Redis SCAN 游标统一为字符串传递，避免 Number 精度丢失 - RedisScanKeys 增加 string/number 游标兼容解析，异常游标降级并告警 - 新增游标解析单测 - refs #135	2026-02-28 12:32:22 +08:00
Syngnat	439625a49c	🔧 fix(duckdb-pagination): 修复 DuckDB 总数异常导致分页不可用 - 修正 DataViewer 在 hasMore 与 totalKnown 冲突时的分页状态处理 - 增强 DuckDB COUNT(*) 结果解析，兼容字段名与数值类型差异 - 将分页兜底逻辑收敛为 DuckDB 专用，避免影响其他数据库 - 修复 total=0 时分页文案显示异常 - refs #136	2026-02-28 12:14:34 +08:00
Syngnat	884d72f3d3	♻️ refactor(clickhouse): 使用结构化 Options 替代 DSN 连接构造 - 用 buildClickHouseOptions 收敛连接参数生成逻辑 - 将连接入口改为 clickhouse.OpenDB(Options) - 清理 DSN 中的 write_timeout/read_timeout/dial_timeout 透传路径 - 同步重写 ClickHouse 相关测试断言 - refs #138	2026-02-28 11:56:59 +08:00
Syngnat	98c1600e13	✨ feat(driver-manager): 增强驱动管理本地导入并统一滚动交互体验 - 新增驱动目录批量导入入口，支持覆盖已安装开关与去重处理 - 行内本地导入聚焦单文件场景，目录导入与单文件导入流程统一 - 已安装驱动版本选择锁定，避免安装后误改版本 - 补充驱动下载网络检测与日志可见性，提升问题定位效率 - 重构驱动管理横向滚动条实现，修复双滚动条/消失/位置异常问题	2026-02-28 11:33:21 +08:00
Syngnat	587ed3444b	⚡️ perf(ci-assets): 完整化驱动打包资产覆盖范围 - 将 clickhouse 纳入可选驱动构建数组 - 提升发布资产完整性与可用性 - 减少驱动安装阶段因资产缺失导致的失败	2026-02-27 17:37:40 +08:00
Syngnat	5986b71c4d	⚡️ perf(redis-datagrid): 优化大数据场景下搜索与右键菜单响应性能 - RedisViewer 引入树节点轻量化、虚拟滚动与大 keyspace 性能模式，降低 Key 列表卡顿 - Redis 搜索按模式分级加载并增加请求乱序保护，避免搜索结果回写抖动 - Redis 后端 ScanKeys 为搜索模式增加时间预算与轮次上限，优先返回可继续分页结果 - DataGrid 稳定 Context/rowSelection/onRow 引用并增加 shouldCellUpdate，减少右键触发全表重渲染	2026-02-27 17:22:38 +08:00
Syngnat	cb18bc3067	✨ feat(driver-proxy): 新增ClickHouse数据源并提供全局代理独立入口 - 新增 ClickHouse 可选驱动实现与 optional-driver-agent provider，补齐驱动注册与清单配置 - 补齐 ClickHouse 连接与 SQL 适配：连接默认端口/用户、LIMIT、标识符引用、只读编辑限制 - 新增全局代理后端能力与前端持久化配置，更新检查和驱动网络请求统一走代理客户端	2026-02-27 16:39:13 +08:00
Syngnat	9685102229	✨ feat(sidebar-batch-table): 批量操作表新增对象筛选与作用范围控制 - 批量操作表弹窗新增关键字筛选（忽略大小写包含匹配） - 新增类型筛选（全部对象/仅表/仅视图） - 新增勾选作用范围切换（当前筛选结果/全部对象） - 全选、取消全选、反选逻辑按作用范围执行 - 筛选区域展示命中计数与无匹配空态提示 - refs #130	2026-02-27 14:21:14 +08:00
Syngnat	3505b4428a	Merge remote-tracking branch 'origin/fix/windows-issue-20260226-ygf' into fix/windows-issue-20260226-ygf	2026-02-27 13:57:04 +08:00
Syngnat	9ebdf7f053	✨ feat(appearance): 新增启动时全屏开关并支持启动窗口状态自动应用 - 在外观设置中提供用户可控的启动全屏偏好项 - 持久化保存用户偏好，重启后自动恢复 - 启动阶段按偏好自动执行全屏，失败时回退最大化 - 保持现有标题栏窗口操作行为不变 - refs #129	2026-02-27 13:56:36 +08:00
Syngnat	9ad852c10b	🐛 fix(redis-viewer): 修复大数据量场景 Key 加载不完整问题 - 后端 ScanKeys 改为按目标数量多轮聚合扫描，不再只依赖单轮返回结果 - 新增扫描目标数/步长/轮次上限，避免扫描过少或无限循环 - 前端首屏加载、搜索、刷新统一按较大批次请求，避免回退到几百条 - 加载更多改为按固定批次继续拉取并保持去重合并 - refs #129	2026-02-27 13:56:36 +08:00
Syngnat	2a8fff4d93	✨ feat(driver-manager): 增强驱动管理网络诊断与本地导入能力 - 新增 CheckDriverNetworkStatus，探测 GitHub API/Release/Go Proxy 可达性并返回代理环境信息。 - 驱动管理弹窗新增网络检测结果、驱动目录复用说明、本地导入入口与日志查看。 - 操作日志支持同签名进度覆盖更新，下载百分比动态刷新，不再重复新增日志行。 - 修正弹窗滚动行为与表格滚动体验。 - refs #128	2026-02-27 13:56:36 +08:00
Syngnat	eca560b4e5	🐛 fix(data-grid): 修复单元格编辑器拖拽越界不自动滚动 - 在 DataGrid 拖拽选区流程新增边缘自动滚动能力（横向+纵向） - 拖拽过程中增加鼠标位置跟踪并通过 RAF 循环驱动滚动 - 通过 elementFromPoint 兜底命中单元格，保证越界拖拽时选区持续更新 - 在 mouseup、模式切换和退出编辑器时统一清理 RAF 与拖拽状态 - refs #127	2026-02-27 13:56:36 +08:00
Syngnat	2f475dddc0	🐛 fix(windows-upgrade): 修复Windows升级后连接列表丢失问题 - 启动参数新增固定 WebviewUserDataPath 到 %APPDATA%/GoNavi/WebView2 - 首次启动自动迁移历史 WebView 数据目录 - 保留现有存储键，避免破坏已落盘配置 - 前端持久化读取增加历史结构兼容 - refs #125	2026-02-27 13:56:35 +08:00
Syngnat	ad9d8a12be	✨ feat(appearance): 新增启动时全屏开关并支持启动窗口状态自动应用 - 在外观设置中提供用户可控的启动全屏偏好项 - 持久化保存用户偏好，重启后自动恢复 - 启动阶段按偏好自动执行全屏，失败时回退最大化 - 保持现有标题栏窗口操作行为不变 - refs #129	2026-02-27 13:55:37 +08:00
Syngnat	095b22951e	🐛 fix(redis-viewer): 修复大数据量场景 Key 加载不完整问题 - 后端 ScanKeys 改为按目标数量多轮聚合扫描，不再只依赖单轮返回结果 - 新增扫描目标数/步长/轮次上限，避免扫描过少或无限循环 - 前端首屏加载、搜索、刷新统一按较大批次请求，避免回退到几百条 - 加载更多改为按固定批次继续拉取并保持去重合并 - refs #129	2026-02-27 13:26:28 +08:00
Syngnat	7350a011e3	✨ feat(driver-manager): 增强驱动管理网络诊断与本地导入能力 - 新增 CheckDriverNetworkStatus，探测 GitHub API/Release/Go Proxy 可达性并返回代理环境信息。 - 驱动管理弹窗新增网络检测结果、驱动目录复用说明、本地导入入口与日志查看。 - 操作日志支持同签名进度覆盖更新，下载百分比动态刷新，不再重复新增日志行。 - 修正弹窗滚动行为与表格滚动体验。 - refs #128	2026-02-27 12:29:54 +08:00
Syngnat	53b5802add	🐛 fix(data-grid): 修复单元格编辑器拖拽越界不自动滚动 - 在 DataGrid 拖拽选区流程新增边缘自动滚动能力（横向+纵向） - 拖拽过程中增加鼠标位置跟踪并通过 RAF 循环驱动滚动 - 通过 elementFromPoint 兜底命中单元格，保证越界拖拽时选区持续更新 - 在 mouseup、模式切换和退出编辑器时统一清理 RAF 与拖拽状态 - refs #127	2026-02-27 10:57:05 +08:00
Syngnat	54e7077317	🐛 fix(windows-upgrade): 修复Windows升级后连接列表丢失问题 - 启动参数新增固定 WebviewUserDataPath 到 %APPDATA%/GoNavi/WebView2 - 首次启动自动迁移历史 WebView 数据目录 - 保留现有存储键，避免破坏已落盘配置 - 前端持久化读取增加历史结构兼容	2026-02-27 10:45:57 +08:00
Syngnat	96de46cf1e	🐛 fix(postgres-connection): 修复无postgres库时连接失败并支持默认连接库配置 - PostgreSQL 空 database 时按 postgres、template1、用户名同名库回退连接 - 移除后端对 database=postgres 的硬编码写死逻辑 - 连接弹窗新增 PostgreSQL 默认连接数据库（可选）配置项 - refs #120	2026-02-27 09:49:47 +08:00
Syngnat	7d5592d8d9	✨ feat(db): 数据库连接新增 SOCKS5/HTTP 代理能力并兼容 SRV/SSH 场景 - 后端 ConnectionConfig 增加代理配置并完成规范化处理 - 普通 TCP 数据源通过本地转发接入代理 - MongoDB 使用 Dialer 支持代理连接（含 SRV） - 前端连接配置新增代理 UI、字段清洗与数据回填 - refs #122	2026-02-27 09:31:24 +08:00
Syngnat	d0ba8822f3	✨ feat(driver-manager): 完善驱动多版本安装与版本级包大小动态展示 - 新增驱动版本列表能力，支持按版本选择安装 - 新增按版本查询安装包大小接口，前端切换版本后动态刷新 - 增加版本大小查询回退策略（tag 未命中时回退 latest） - 优化版本下拉加载链路并增加后台预热，降低首次展开等待	2026-02-27 08:37:35 +08:00
Syngnat	140db73ef4	🐛 fix(startup-release): 修复 Win/mac 发布包白屏与无响应问题 - 移除 v0.4.7 引入的高风险 chunk 拆分配置 - 恢复 main.tsx 的 Monaco 稳定初始化方式 - 调整 release workflow 的 macOS codesign 参数避免双击无反应	2026-02-26 15:21:36 +08:00
Syngnat	bec5013a44	🐛 fix(update-windows): 修复自动更新脚本变量转义导致TARGET语法错误 - 将 buildWindowsScript 改为模板占位符替换，避免 fmt.Sprintf 吞掉批处理百分号 - 修正 for %%I/%%F 语法，消除“此时不应有 TARGET~nxI”报错 - 保留原有更新重试与日志流程，不改变下载与安装主链路 - refs #112	2026-02-26 14:23:36 +08:00
Syngnat	66a3113fa8	🐛 fix(datagrid-mysql): 修复MySQL行编辑时datetime空值提交失败 - 前端按列类型归一化 temporal 字段，INSERT 空值跳过字段、UPDATE 空值转 NULL - 后端 ApplyChanges 增加 temporal 字段兜底，避免空字符串写入 datetime/timestamp - 新增全默认值插入路径，兼容 CURRENT_TIMESTAMP 等默认值场景 - refs #113	2026-02-26 14:13:27 +08:00
Syngnat	a435d62d3b	✨ feat(connection-modal): 新增SSH私钥文件浏览选择能力 - 新增私钥文件选择入口，减少手动输入路径错误 - 复用系统文件对话框并自动回填私钥路径 - 保留手动输入作为兜底方式 - refs #119	2026-02-26 13:57:50 +08:00
Syngnat	50d92d3184	🐛 fix(backup-export): 修复批量备份未区分视图与表导致导出失败 - 批量操作弹窗按“表/视图”分组展示并支持混合勾选 - 批量导出改为对象集合传参，统一结构/数据导出入口 - SQL 导出链路新增视图识别与排序，避免将视图当表处理 - 增加多方言视图 DDL 查询与回退逻辑，规避 create statement not found - 视图数据导出阶段自动跳过并追加说明注释 - refs #117	2026-02-26 13:45:17 +08:00
Syngnat	91658848c9	🔧 fix(frontend): 修复表设计能力门禁并优化构建分包策略 - 修复触发器分组进入设计页时误设只读，恢复索引/外键页增删改按钮显示 - 重构 TableDesigner 数据源方言识别，移除 MySQL 与固定方言白名单硬限制 - 按能力控制索引/外键/表备注编辑入口，并补充多方言 DDL 生成与通用兜底 - 收敛已知不支持场景：sqlite/duckdb/tdengine 禁用外键编辑，sqlite 禁用表备注编辑 - Monaco 改为按需 worker（editor/json）并补齐 vite 类型声明，避免构建类型报错 - 细化 Vite manualChunks（antd/monaco 子模块拆分），消除 >500k chunk 告警 - refs #115	2026-02-26 12:08:07 +08:00
Syngnat	fda30539b6	🐛 fix(highgo): 修复海量数据源复制表结构仅返回注释 - 识别 HighGo 占位建表语句 - 通过 GetColumns 生成包含字段与主键的建表SQL - 避免右键复制表结构出现空字段 - refs #99	2026-02-14 15:45:02 +08:00
Syngnat	1ba68fcbfe	🐛 fix(release): 修复 Debian 13 Linux 产物 WebKitGTK 依赖不兼容 - Linux Release 增加 WebKitGTK 4.1 变体（-WebKit41），保留 4.0 产物 - CI 按 WebKit 版本安装依赖，并为 Wails 注入 webkit2_41 构建标签 - 完善驱动代理可执行文件路径校验错误提示（区分不存在/目录） - README 补充 Linux 依赖排障与产物选择说明 - refs #98	2026-02-14 15:17:03 +08:00
Syngnat	f0e1c7e72c	🔧 fix(driver-agent): 修复 Windows 启动驱动代理弹出终端窗口 - 为 Windows 新增 agent 进程启动参数（HideWindow + CREATE_NO_WINDOW） - optional driver agent 启动路径统一应用进程隐藏配置 - MySQL agent 启动路径同步应用进程隐藏配置	2026-02-14 15:01:29 +08:00