Merge pull request #140 from Syngnat/release/0.5.0

Release/0.5.0

.github/workflows/release.yml

@@ -135,11 +135,11 @@ jobs:
         shell: bash
         run: |
           set -euo pipefail
-          TAG_ARGS=()
           if [ -n "${{ matrix.wails_tags }}" ]; then
-            TAG_ARGS+=(-tags "${{ matrix.wails_tags }}")
+            wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.build_name }} -tags "${{ matrix.wails_tags }}" -ldflags "-s -w -X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"
+          else
+            wails build -platform ${{ matrix.platform }} -clean -o ${{ matrix.build_name }} -ldflags "-s -w -X GoNavi-Wails/internal/app.AppVersion=${{ github.ref_name }}"
           fi
-          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 }}
@@ -149,12 +149,16 @@ jobs:
           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"

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,137 +64,123 @@
 
 ---
 
-## ✨ 核心特性
+## 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)
-*   Linux (AMD64，提供 WebKitGTK 4.0 与 4.1 变体产物)
+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:
 
-### Linux 启动报错缺少 `libwebkit2gtk` / `libjavascriptcoregtk`
+```bash
+sudo xattr -rd com.apple.quarantine /Applications/GoNavi.app
+```
 
-GoNavi 的 Linux 二进制依赖系统 WebKitGTK 运行库。不同发行版默认版本不同：
+Or right-click the app in Finder and choose **Open** with Control key flow.
 
-- Debian 13 / Ubuntu 24.04 及更新版本：通常为 WebKitGTK 4.1
-- Ubuntu 22.04 / Debian 12 等：通常为 WebKitGTK 4.0
+### Linux: missing `libwebkit2gtk` / `libjavascriptcoregtk`
 
-如果启动时报错（如 `libwebkit2gtk-4.0.so.37: cannot open shared object file`），请按系统安装对应依赖后重试：
+GoNavi depends on WebKitGTK runtime libraries.
 
 ```bash
 # Debian 13 / Ubuntu 24.04+
@@ -166,20 +192,20 @@ sudo apt-get update
 sudo apt-get install -y libgtk-3-0 libwebkit2gtk-4.0-37 libjavascriptcoregtk-4.0-18
 ```
 
-如果你使用的是 Release 中带 `-WebKit41` 后缀的 Linux 产物，请优先在 Debian 13 / Ubuntu 24.04+ 上使用；普通 Linux 产物更适合 WebKitGTK 4.0 运行环境。
+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).

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)。

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{}
+	}
+}

docs/driver-manifest.json

@@ -7,11 +7,11 @@
       "checksumPolicy": "off",
       "downloadUrl": "builtin://activate/mariadb"
     },
-    "diros": {
+    "doris": {
       "engine": "go",
       "version": "1.9.3",
       "checksumPolicy": "off",
-      "downloadUrl": "builtin://activate/diros"
+      "downloadUrl": "builtin://activate/doris"
     },
     "sphinx": {
       "engine": "go",
@@ -73,6 +73,12 @@
       "checksumPolicy": "off",
       "downloadUrl": "builtin://activate/tdengine"
     },
+    "clickhouse": {
+      "engine": "go",
+      "version": "2.43.0",
+      "checksumPolicy": "off",
+      "downloadUrl": "builtin://activate/clickhouse"
+    },
     "postgres": {
       "engine": "go",
       "version": "1.11.1",

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;
+}

frontend/src/App.tsx

@@ -1,7 +1,7 @@
 import React, { useState, useEffect } from 'react';
-import { Layout, Button, ConfigProvider, theme, Dropdown, MenuProps, message, Modal, Spin, Slider, Progress, Switch } 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 { 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';
@@ -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;
@@ -28,12 +28,16 @@ function App() {
   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 持续计算窗口背后的模糊合成
@@ -58,6 +62,83 @@ 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;
@@ -492,6 +573,7 @@ function App() {
   ];
 
   const [isAppearanceModalOpen, setIsAppearanceModalOpen] = useState(false);
+  const [isProxyModalOpen, setIsProxyModalOpen] = useState(false);
 
 
   // Log Panel: 最小高度按“工具栏 + 1 条日志行（微增）”限制
@@ -814,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>
@@ -954,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>
@@ -1008,6 +1091,81 @@ function App() {
               </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>
+
           <Modal
               title={updateDownloadProgress.version ? `下载更新 ${updateDownloadProgress.version}` : '下载更新'}
               open={updateDownloadProgress.open}

frontend/src/components/ConnectionModal.tsx

@@ -2,6 +2,7 @@ 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 { normalizeOpacityForPlatform } from '../utils/appearance';
 import { DBGetDatabases, GetDriverStatusList, MongoDiscoverMembers, TestConnection, RedisConnect, SelectSSHKeyFile } from '../../wailsjs/go/app/App';
 import { ConnectionConfig, MongoMemberInfo, SavedConnection } from '../types';
 
@@ -10,12 +11,19 @@ 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;
@@ -77,10 +85,35 @@ const ConnectionModal: React.FC<{
   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('', '');
@@ -407,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;
   };
 
@@ -430,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)) {
@@ -441,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';
   };
 
@@ -472,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}` : ''}`;
       }
 
@@ -1060,7 +1121,9 @@ const ConnectionModal: React.FC<{
               mongoReplicaPassword: '',
           });
       } else if (type !== 'custom') {
+          const defaultUser = type === 'clickhouse' ? 'default' : 'root';
           form.setFieldsValue({
+              user: defaultUser,
               database: '',
               port: defaultPort,
               mysqlTopology: 'single',
@@ -1100,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' }} /> },
@@ -1149,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}
@@ -1566,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" />
@@ -1602,7 +1666,7 @@ const ConnectionModal: React.FC<{
             </Form.Item>
 
             {useProxy && (
-                <div style={{ padding: '12px', background: '#f5f5f5', borderRadius: 6, marginTop: 12 }}>
+                <div style={tunnelSectionStyle}>
                     <div style={{ display: 'flex', gap: 16 }}>
                         <Form.Item name="proxyType" label="代理类型" rules={[{ required: useProxy, message: '请选择代理类型' }]} style={{ width: 180 }}>
                             <Select options={[
@@ -1724,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,
@@ -1740,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}

frontend/src/components/DataGrid.tsx

@@ -509,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;
@@ -534,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);
@@ -549,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) => {
@@ -605,7 +617,6 @@ const DataGrid: React.FC<DataGridProps> = ({
     dataIndex: '',
     title: '',
   });
-  const [cellSetValueInput, setCellSetValueInput] = useState('');
   const containerRef = useRef<HTMLDivElement>(null);
   const pendingScrollToBottomRef = useRef(false);
 
@@ -671,7 +682,6 @@ const DataGrid: React.FC<DataGridProps> = ({
       dataIndex,
       title: titleText,
     });
-    setCellSetValueInput(toFormText(record[dataIndex]));
   }, []);
 
   // Helper to export specific data
@@ -1409,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) {
@@ -1560,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;
@@ -1888,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
@@ -2380,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(() => {
@@ -2491,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
@@ -2779,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}
@@ -2792,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>
@@ -3057,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

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}

frontend/src/components/DriverManagerModal.tsx

@@ -1,7 +1,9 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { Alert, Button, Collapse, Modal, Progress, Select, Space, Table, Tag, Typography, message } from 'antd';
-import { DeleteOutlined, DownloadOutlined, FileSearchOutlined, ReloadOutlined } from '@ant-design/icons';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Alert, Button, Collapse, Modal, Progress, Select, Space, Switch, Table, Tag, Typography, message } from 'antd';
+import { DeleteOutlined, DownloadOutlined, FileSearchOutlined, FolderOpenOutlined, ReloadOutlined } from '@ant-design/icons';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
+import { useStore } from '../store';
+import { normalizeOpacityForPlatform } from '../utils/appearance';
 import {
   CheckDriverNetworkStatus,
   DownloadDriverPackage,
@@ -10,6 +12,7 @@ import {
   GetDriverStatusList,
   InstallLocalDriverPackage,
   RemoveDriverPackage,
+  SelectDriverPackageDirectory,
   SelectDriverPackageFile,
 } from '../../wailsjs/go/app/App';
 
@@ -46,6 +49,8 @@ type ProgressState = {
   percent: number;
 };
 
+type DriverActionKind = '' | 'install' | 'remove' | 'local';
+
 type DriverLogEntry = {
   time: string;
   text: string;
@@ -84,6 +89,7 @@ type DriverVersionOption = {
 
 const buildVersionOptionKey = (option: DriverVersionOption) => `${option.version}@@${option.downloadUrl}`;
 const buildVersionSizeLoadingKey = (driverType: string, optionKey: string) => `${driverType}@@${optionKey}`;
+const DRIVER_TABLE_SCROLL_X = 1450;
 
 const buildVersionSelectOptions = (options: DriverVersionOption[]) => {
   type SelectOption = { value: string; label: string };
@@ -132,20 +138,32 @@ const buildVersionSelectOptions = (options: DriverVersionOption[]) => {
 };
 
 const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({ open, onClose }) => {
+  const theme = useStore((state) => state.theme);
+  const appearance = useStore((state) => state.appearance);
+  const darkMode = theme === 'dark';
+  const opacity = normalizeOpacityForPlatform(appearance.opacity);
+  const modalContentRef = useRef<HTMLDivElement | null>(null);
+  const tableContainerRef = useRef<HTMLDivElement | null>(null);
+  const tableScrollTargetsRef = useRef<HTMLElement[]>([]);
+  const externalHScrollRef = useRef<HTMLDivElement | null>(null);
+  const horizontalSyncSourceRef = useRef<'table' | 'external' | ''>('');
   const [loading, setLoading] = useState(false);
   const [downloadDir, setDownloadDir] = useState('');
   const [networkChecking, setNetworkChecking] = useState(false);
   const [networkStatus, setNetworkStatus] = useState<DriverNetworkStatus | null>(null);
   const [rows, setRows] = useState<DriverStatusRow[]>([]);
-  const [actionDriver, setActionDriver] = useState('');
+  const [actionState, setActionState] = useState<{ driverType: string; kind: DriverActionKind }>({ driverType: '', kind: '' });
   const [progressMap, setProgressMap] = useState<Record<string, ProgressState>>({});
   const [operationLogMap, setOperationLogMap] = useState<Record<string, DriverLogEntry[]>>({});
   const [logDriverType, setLogDriverType] = useState('');
   const [logModalOpen, setLogModalOpen] = useState(false);
+  const [batchDirectoryImporting, setBatchDirectoryImporting] = useState(false);
+  const [forceOverwriteInstalled, setForceOverwriteInstalled] = useState(false);
   const [versionMap, setVersionMap] = useState<Record<string, DriverVersionOption[]>>({});
   const [selectedVersionMap, setSelectedVersionMap] = useState<Record<string, string>>({});
   const [versionLoadingMap, setVersionLoadingMap] = useState<Record<string, boolean>>({});
   const [versionSizeLoadingMap, setVersionSizeLoadingMap] = useState<Record<string, boolean>>({});
+  const [horizontalScrollWidth, setHorizontalScrollWidth] = useState(DRIVER_TABLE_SCROLL_X);
 
   const appendOperationLog = useCallback((
     driverType: string,
@@ -193,6 +211,76 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
     });
   }, []);
 
+  const refreshHorizontalScrollState = useCallback(() => {
+    const tableContainer = tableContainerRef.current;
+    const targets = tableContainer
+      ? [
+          ...new Set(
+            [
+              ...Array.from(tableContainer.querySelectorAll('.ant-table-content')),
+              ...Array.from(tableContainer.querySelectorAll('.ant-table-body')),
+            ].filter((node): node is HTMLElement => node instanceof HTMLElement),
+          ),
+        ]
+      : tableScrollTargetsRef.current;
+    if (!targets || targets.length === 0) {
+      setHorizontalScrollWidth(DRIVER_TABLE_SCROLL_X);
+      return;
+    }
+
+    const nextWidth = Math.max(
+      DRIVER_TABLE_SCROLL_X,
+      ...targets.map((target) => Math.max(0, target.scrollWidth)),
+    );
+    setHorizontalScrollWidth((prev) => (prev === nextWidth ? prev : nextWidth));
+
+    const externalScroll = externalHScrollRef.current;
+    if (!externalScroll || horizontalSyncSourceRef.current === 'external') {
+      return;
+    }
+    const preferredTarget =
+      targets.find((target) => target.scrollWidth > target.clientWidth + 1) ||
+      targets[0];
+    const targetScrollLeft = preferredTarget?.scrollLeft || 0;
+    if (Math.abs(externalScroll.scrollLeft - targetScrollLeft) > 1) {
+      externalScroll.scrollLeft = targetScrollLeft;
+    }
+  }, []);
+
+  const applyExternalScrollToTableTargets = useCallback(() => {
+    const tableContainer = tableContainerRef.current;
+    const externalScroll = externalHScrollRef.current;
+    if (!(tableContainer instanceof HTMLElement) || !(externalScroll instanceof HTMLDivElement)) {
+      return;
+    }
+    if (horizontalSyncSourceRef.current === 'table') {
+      return;
+    }
+
+    const liveTargets = [
+      ...new Set(
+        [
+          ...Array.from(tableContainer.querySelectorAll('.ant-table-content')),
+          ...Array.from(tableContainer.querySelectorAll('.ant-table-body')),
+        ].filter((node): node is HTMLElement => node instanceof HTMLElement),
+      ),
+    ];
+    if (liveTargets.length === 0) {
+      return;
+    }
+
+    horizontalSyncSourceRef.current = 'external';
+    liveTargets.forEach((target) => {
+      if (target.scrollWidth <= target.clientWidth + 1) {
+        return;
+      }
+      if (Math.abs(target.scrollLeft - externalScroll.scrollLeft) > 1) {
+        target.scrollLeft = externalScroll.scrollLeft;
+      }
+    });
+    horizontalSyncSourceRef.current = '';
+  }, []);
+
   const refreshStatus = useCallback(async (toastOnError = true) => {
     setLoading(true);
     try {
@@ -429,12 +517,125 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
 
   useEffect(() => {
     if (!open) {
+      setHorizontalScrollWidth(DRIVER_TABLE_SCROLL_X);
+      tableScrollTargetsRef.current = [];
       return;
     }
     refreshStatus(false);
     checkNetworkStatus(false);
   }, [checkNetworkStatus, open, refreshStatus]);
 
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    const tableContainer = tableContainerRef.current;
+    const externalScroll = externalHScrollRef.current;
+    if (!(tableContainer instanceof HTMLElement) || !(externalScroll instanceof HTMLDivElement)) {
+      return;
+    }
+
+    let currentTargets: HTMLElement[] = [];
+    let rafId: number | null = null;
+    let bodyResizeObserver: ResizeObserver | null = null;
+    let containerResizeObserver: ResizeObserver | null = null;
+
+    const pickSyncTarget = () => {
+      if (currentTargets.length === 0) {
+        return null;
+      }
+      return currentTargets.find((target) => target.scrollWidth > target.clientWidth + 1) || currentTargets[0];
+    };
+
+    const syncFromTableTarget = (event?: Event) => {
+      const source = event?.currentTarget instanceof HTMLElement ? event.currentTarget : null;
+      const activeTarget = source || pickSyncTarget();
+      if (!activeTarget) {
+        return;
+      }
+      if (horizontalSyncSourceRef.current === 'external') {
+        return;
+      }
+      horizontalSyncSourceRef.current = 'table';
+      if (Math.abs(externalScroll.scrollLeft - activeTarget.scrollLeft) > 1) {
+        externalScroll.scrollLeft = activeTarget.scrollLeft;
+      }
+      horizontalSyncSourceRef.current = '';
+    };
+
+    const bindCurrentTableTargets = () => {
+      const nextTargets = [
+        ...new Set(
+          [
+            ...Array.from(tableContainer.querySelectorAll('.ant-table-content')),
+            ...Array.from(tableContainer.querySelectorAll('.ant-table-body')),
+          ].filter((node): node is HTMLElement => node instanceof HTMLElement),
+        ),
+      ];
+
+      const sameTargets =
+        nextTargets.length === currentTargets.length &&
+        nextTargets.every((target, index) => target === currentTargets[index]);
+      if (sameTargets) {
+        return;
+      }
+
+      currentTargets.forEach((target) => {
+        target.removeEventListener('scroll', syncFromTableTarget);
+        bodyResizeObserver?.unobserve(target);
+      });
+
+      currentTargets = nextTargets;
+      tableScrollTargetsRef.current = nextTargets;
+      currentTargets.forEach((target) => {
+        target.addEventListener('scroll', syncFromTableTarget, { passive: true });
+        bodyResizeObserver?.observe(target);
+      });
+
+      refreshHorizontalScrollState();
+      syncFromTableTarget();
+    };
+
+    const scheduleRefresh = () => {
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+      }
+      rafId = requestAnimationFrame(() => {
+        bindCurrentTableTargets();
+        refreshHorizontalScrollState();
+      });
+    };
+
+    const mutationObserver = new MutationObserver(scheduleRefresh);
+    mutationObserver.observe(tableContainer, { childList: true, subtree: true });
+
+    bodyResizeObserver = typeof ResizeObserver !== 'undefined' ? new ResizeObserver(scheduleRefresh) : null;
+    containerResizeObserver = typeof ResizeObserver !== 'undefined' ? new ResizeObserver(scheduleRefresh) : null;
+    containerResizeObserver?.observe(tableContainer);
+    if (typeof ResizeObserver !== 'undefined') {
+      modalContentRef.current && containerResizeObserver?.observe(modalContentRef.current);
+    }
+    window.addEventListener('resize', scheduleRefresh);
+
+    scheduleRefresh();
+    return () => {
+      mutationObserver.disconnect();
+      window.removeEventListener('resize', scheduleRefresh);
+      currentTargets.forEach((target) => {
+        target.removeEventListener('scroll', syncFromTableTarget);
+      });
+      if (bodyResizeObserver) {
+        bodyResizeObserver.disconnect();
+      }
+      if (containerResizeObserver) {
+        containerResizeObserver.disconnect();
+      }
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+      }
+    };
+  }, [open, refreshHorizontalScrollState]);
+
   useEffect(() => {
     if (!open) {
       return;
@@ -470,7 +671,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
   }, [appendOperationLog, open]);
 
   const installDriver = useCallback(async (row: DriverStatusRow) => {
-    setActionDriver(row.type);
+    setActionState({ driverType: row.type, kind: 'install' });
     setProgressMap((prev) => ({
       ...prev,
       [row.type]: {
@@ -505,25 +706,25 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
       message.success(`${row.name}${versionTip} 已安装启用`);
       refreshStatus(false);
     } finally {
-      setActionDriver('');
+      setActionState({ driverType: '', kind: '' });
     }
   }, [appendOperationLog, downloadDir, loadVersionOptions, refreshStatus, selectedVersionMap, versionMap]);
 
-  const installDriverFromLocalFile = useCallback(async (row: DriverStatusRow) => {
-    const fileRes = await SelectDriverPackageFile(downloadDir);
-    if (!fileRes?.success) {
-      if (String(fileRes?.message || '') !== 'Cancelled') {
-        message.error(fileRes?.message || '选择本地驱动包失败');
+  const installDriverFromLocalPath = useCallback(async (
+    row: DriverStatusRow,
+    sourcePath: string,
+    sourceLabel: '文件' | '目录',
+    options?: { silentToast?: boolean; skipRefresh?: boolean },
+  ) => {
+    const pathText = String(sourcePath || '').trim();
+    if (!pathText) {
+      if (!options?.silentToast) {
+        message.error(`未选择有效的本地导入${sourceLabel}`);
       }
-      return;
-    }
-    const filePath = String((fileRes?.data as any)?.path || '').trim();
-    if (!filePath) {
-      message.error('未选择有效的驱动包文件');
-      return;
+      return false;
     }
 
-    setActionDriver(row.type);
+    setActionState({ driverType: row.type, kind: 'local' });
     setProgressMap((prev) => ({
       ...prev,
       [row.type]: {
@@ -532,23 +733,122 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
         percent: 0,
       },
     }));
-    appendOperationLog(row.type, `[START] 开始本地导入：${filePath}`);
+    appendOperationLog(row.type, `[START] 开始本地导入（${sourceLabel}）：${pathText}`);
     try {
-      const result = await InstallLocalDriverPackage(row.type, filePath, downloadDir);
+      const result = await InstallLocalDriverPackage(row.type, pathText, downloadDir);
       if (!result?.success) {
         const errText = result?.message || `导入 ${row.name} 本地驱动包失败`;
         appendOperationLog(row.type, `[ERROR] ${errText}`);
-        message.error(errText);
-        return;
+        if (!options?.silentToast) {
+          message.error(errText);
+        }
+        return false;
       }
       appendOperationLog(row.type, '[DONE] 本地导入安装完成');
-      message.success(`${row.name} 本地驱动包已安装启用`);
-      refreshStatus(false);
+      if (!options?.silentToast) {
+        message.success(`${row.name} 本地驱动包已安装启用`);
+      }
+      if (!options?.skipRefresh) {
+        await refreshStatus(false);
+      }
+      return true;
     } finally {
-      setActionDriver('');
+      setActionState({ driverType: '', kind: '' });
     }
   }, [appendOperationLog, downloadDir, refreshStatus]);
 
+  const installDriverFromLocalFile = useCallback(async (row: DriverStatusRow) => {
+    const fileRes = await SelectDriverPackageFile(downloadDir);
+    if (!fileRes?.success) {
+      if (String(fileRes?.message || '') !== 'Cancelled') {
+        message.error(fileRes?.message || '选择本地驱动包文件失败');
+      }
+      return;
+    }
+    const filePath = String((fileRes?.data as any)?.path || '').trim();
+    if (!filePath) {
+      message.error('未选择有效的驱动包文件');
+      return;
+    }
+    await installDriverFromLocalPath(row, filePath, '文件');
+  }, [downloadDir, installDriverFromLocalPath]);
+
+  const installDriversFromDirectory = useCallback(async () => {
+    const directoryRes = await SelectDriverPackageDirectory(downloadDir);
+    if (!directoryRes?.success) {
+      if (String(directoryRes?.message || '') !== 'Cancelled') {
+        message.error(directoryRes?.message || '选择本地驱动包目录失败');
+      }
+      return;
+    }
+
+    const directoryPath = String((directoryRes?.data as any)?.path || '').trim();
+    if (!directoryPath) {
+      message.error('未选择有效的驱动包目录');
+      return;
+    }
+    const optionalRows = rows.filter((item) => !item.builtIn);
+    if (optionalRows.length === 0) {
+      message.info('当前没有可导入的外置驱动');
+      return;
+    }
+
+    let successCount = 0;
+    let failCount = 0;
+    let dedupeSkipCount = 0;
+    let slimSkipCount = 0;
+
+    setBatchDirectoryImporting(true);
+    try {
+      for (const row of optionalRows) {
+        const alreadyInstalled = row.packageInstalled || row.connectable;
+        if (alreadyInstalled && !forceOverwriteInstalled) {
+          dedupeSkipCount += 1;
+          appendOperationLog(row.type, '[SKIP] 已检测到驱动已安装，目录导入去重跳过');
+          continue;
+        }
+        if (alreadyInstalled && forceOverwriteInstalled) {
+          appendOperationLog(row.type, '[INFO] 已启用覆盖已安装模式，执行重装导入');
+        }
+        const isSlimBuildUnavailable = (row.message || '').includes('精简构建') && !row.packageInstalled;
+        if (isSlimBuildUnavailable) {
+          slimSkipCount += 1;
+          appendOperationLog(row.type, '[WARN] 当前发行包为精简构建，已跳过目录导入');
+          continue;
+        }
+        const ok = await installDriverFromLocalPath(row, directoryPath, '目录', { silentToast: true, skipRefresh: true });
+        if (ok) {
+          successCount += 1;
+        } else {
+          failCount += 1;
+        }
+      }
+      await refreshStatus(false);
+    } finally {
+      setBatchDirectoryImporting(false);
+    }
+
+    const skipParts: string[] = [];
+    if (dedupeSkipCount > 0) {
+      skipParts.push(`去重跳过 ${dedupeSkipCount}`);
+    }
+    if (slimSkipCount > 0) {
+      skipParts.push(`精简版跳过 ${slimSkipCount}`);
+    }
+    const skipTip = skipParts.length > 0 ? `，${skipParts.join('，')}` : '';
+
+    const forceTip = forceOverwriteInstalled ? '（覆盖已安装）' : '';
+    if (failCount === 0) {
+      message.success(`目录导入完成${forceTip}：成功 ${successCount}${skipTip}`);
+      return;
+    }
+    if (successCount > 0) {
+      message.warning(`目录导入完成${forceTip}：成功 ${successCount}，失败 ${failCount}${skipTip}`);
+      return;
+    }
+    message.error(`目录导入失败${forceTip}：失败 ${failCount}${skipTip}`);
+  }, [appendOperationLog, downloadDir, forceOverwriteInstalled, installDriverFromLocalPath, refreshStatus, rows]);
+
   const openDriverLog = useCallback((driverType: string) => {
     const normalized = String(driverType || '').trim().toLowerCase();
     if (!normalized) {
@@ -559,7 +859,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
   }, []);
 
   const removeDriver = useCallback(async (row: DriverStatusRow) => {
-    setActionDriver(row.type);
+    setActionState({ driverType: row.type, kind: 'remove' });
     appendOperationLog(row.type, '[START] 开始移除驱动');
     try {
       const result = await RemoveDriverPackage(row.type, downloadDir);
@@ -578,7 +878,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
       });
       refreshStatus(false);
     } finally {
-      setActionDriver('');
+      setActionState({ driverType: '', kind: '' });
     }
   }, [appendOperationLog, downloadDir, refreshStatus]);
 
@@ -590,25 +890,6 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
         key: 'name',
         width: 150,
       },
-      {
-        title: '安装位置',
-        key: 'installPath',
-        width: 260,
-        render: (_: string, row: DriverStatusRow) => {
-          if (row.builtIn) {
-            return <Text type="secondary">内置</Text>;
-          }
-          const installPath = row.executablePath || row.installDir || '-';
-          if (installPath === '-') {
-            return <Text type="secondary">-</Text>;
-          }
-          return (
-            <Text copyable={{ text: installPath }} style={{ fontSize: 12 }}>
-              {installPath}
-            </Text>
-          );
-        },
-      },
       {
         title: '安装包大小',
         dataIndex: 'packageSizeText',
@@ -688,6 +969,14 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
           if (row.builtIn) {
             return <Text type="secondary">-</Text>;
           }
+          const versionLocked = row.packageInstalled || row.connectable;
+          if (versionLocked) {
+            const installedVersion = String(row.installedVersion || '').trim();
+            if (installedVersion) {
+              return <Text type="secondary">{installedVersion}（已安装，移除后可更换）</Text>;
+            }
+            return <Text type="secondary">已安装（移除后可更换）</Text>;
+          }
           const options = versionMap[row.type] || [];
           const selectedKey = selectedVersionMap[row.type];
           const selectOptions = buildVersionSelectOptions(options);
@@ -696,7 +985,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
               size="small"
               style={{ width: '100%' }}
               loading={!!versionLoadingMap[row.type]}
-              disabled={actionDriver === row.type}
+              disabled={actionState.driverType === row.type}
               placeholder={options.length > 0 ? '选择驱动版本' : '点击展开加载版本'}
               value={selectedKey}
               options={selectOptions as any}
@@ -726,7 +1015,9 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
             return <Text type="secondary">-</Text>;
           }
           const isSlimBuildUnavailable = (row.message || '').includes('精简构建');
-          const loadingAction = actionDriver === row.type;
+          const loadingInstallOrRemove =
+            actionState.driverType === row.type && (actionState.kind === 'install' || actionState.kind === 'remove');
+          const loadingLocal = actionState.driverType === row.type && actionState.kind === 'local';
           if (isSlimBuildUnavailable && !row.packageInstalled) {
             return <Text type="secondary">需 Full 版</Text>;
           }
@@ -738,7 +1029,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
             <Button
               danger
               icon={<DeleteOutlined />}
-              loading={loadingAction}
+              loading={loadingInstallOrRemove}
               onClick={() => removeDriver(row)}
             >
               移除
@@ -747,7 +1038,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
             <Button
               type="primary"
               icon={<DownloadOutlined />}
-              loading={loadingAction}
+              loading={loadingInstallOrRemove}
               onClick={() => installDriver(row)}
             >
               安装启用
@@ -759,7 +1050,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
               {mainAction}
               <Button
                 icon={<FileSearchOutlined />}
-                loading={loadingAction}
+                loading={loadingLocal}
                 onClick={() => installDriverFromLocalFile(row)}
               >
                 本地导入
@@ -776,7 +1067,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
         },
       },
     ];
-  }, [actionDriver, installDriver, installDriverFromLocalFile, loadVersionOptions, loadVersionPackageSize, openDriverLog, operationLogMap, progressMap, removeDriver, selectedVersionMap, versionLoadingMap, versionMap, versionSizeLoadingMap]);
+  }, [actionState, installDriver, installDriverFromLocalFile, loadVersionOptions, loadVersionPackageSize, openDriverLog, operationLogMap, progressMap, removeDriver, selectedVersionMap, versionLoadingMap, versionMap, versionSizeLoadingMap]);
 
   const activeLogRow = useMemo(() => {
     if (!logDriverType) {
@@ -788,6 +1079,11 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
   const activeDriverLogs = operationLogMap[logDriverType] || [];
   const activeDriverLogLines = activeDriverLogs.map((item) => `[${item.time}] ${item.text}`);
   const proxyEnvEntries = Object.entries(networkStatus?.proxyEnv || {});
+  const logBlockBackground = darkMode
+    ? `rgba(28, 28, 28, ${Math.max(opacity, 0.82)})`
+    : `rgba(255, 255, 255, ${Math.max(opacity, 0.92)})`;
+  const logBlockBorderColor = darkMode ? 'rgba(255, 255, 255, 0.16)' : 'rgba(0, 0, 0, 0.12)';
+  const logBlockTextColor = darkMode ? 'rgba(255, 255, 255, 0.88)' : 'rgba(0, 0, 0, 0.88)';
 
   return (
     <Modal
@@ -805,18 +1101,31 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
         },
       }}
       destroyOnClose
-      footer={[
-        <Button key="refresh" icon={<ReloadOutlined />} onClick={() => refreshStatus(true)} loading={loading}>
-          刷新
-        </Button>,
-        <Button key="network" onClick={() => checkNetworkStatus(true)} loading={networkChecking}>
-          网络检测
-        </Button>,
-        <Button key="close" type="primary" onClick={onClose}>
-          关闭
-        </Button>,
-      ]}
+      footer={(
+        <div className="driver-manager-footer">
+          <div
+            ref={externalHScrollRef}
+            className="driver-manager-hscroll"
+            aria-hidden={false}
+            onScroll={applyExternalScrollToTableTargets}
+          >
+            <div className="driver-manager-hscroll-inner" style={{ width: `${Math.max(horizontalScrollWidth, 1)}px` }} />
+          </div>
+          <Space className="driver-manager-footer-actions" size={8}>
+            <Button key="refresh" icon={<ReloadOutlined />} onClick={() => refreshStatus(true)} loading={loading}>
+              刷新
+            </Button>
+            <Button key="network" onClick={() => checkNetworkStatus(true)} loading={networkChecking}>
+              网络检测
+            </Button>
+            <Button key="close" type="primary" onClick={onClose}>
+              关闭
+            </Button>
+          </Space>
+        </div>
+      )}
     >
+      <div ref={modalContentRef}>
       <Space direction="vertical" size={12} style={{ width: '100%' }}>
         <Text type="secondary">除 MySQL / Redis / Oracle / PostgreSQL 外，其他数据源需先安装启用后再连接。</Text>
         {networkStatus ? (
@@ -868,7 +1177,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
           description={(
             <Space direction="vertical" size={6} style={{ width: '100%' }}>
               <Text type="secondary">自动下载和手动导入的驱动都会落盘到以下目录；后续版本升级可重复复用已下载驱动。</Text>
-              <Text type="secondary">手动导入支持单个驱动代理文件（如 `mariadb-driver-agent` / `mariadb-driver-agent.exe`）或驱动总包 `GoNavi-DriverAgents.zip`。</Text>
+              <Text type="secondary">行内“本地导入”仅用于单个驱动文件/总包（如 `mariadb-driver-agent`、`mariadb-driver-agent.exe`、`GoNavi-DriverAgents.zip`）；批量导入请使用上方“导入驱动目录”。</Text>
               <Paragraph copyable={{ text: downloadDir || '-' }} style={{ marginBottom: 0 }}>
                 驱动根目录：{downloadDir || '-'}
               </Paragraph>
@@ -881,16 +1190,42 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
           )}
         />
 
-        <Table
-          rowKey="type"
-          loading={loading}
-          columns={columns as any}
-          dataSource={rows}
-          pagination={false}
-          size="middle"
-          scroll={{ x: 1450 }}
-        />
+        <Space style={{ width: '100%', justifyContent: 'flex-end' }}>
+          <Space size={8}>
+            <Text type="secondary">覆盖已安装</Text>
+            <Switch
+              checked={forceOverwriteInstalled}
+              onChange={(checked) => setForceOverwriteInstalled(checked)}
+              disabled={batchDirectoryImporting}
+            />
+          </Space>
+          <Button
+            icon={<FolderOpenOutlined />}
+            loading={batchDirectoryImporting}
+            onClick={() => void installDriversFromDirectory()}
+          >
+            导入驱动目录
+          </Button>
+        </Space>
+
+        <div
+          ref={tableContainerRef}
+          className="driver-manager-table-wrap driver-manager-table-wrap-external-active"
+        >
+          <Table
+            className="driver-manager-table"
+            rowKey="type"
+            loading={loading}
+            columns={columns as any}
+            dataSource={rows}
+            pagination={false}
+            size="middle"
+            sticky={false}
+            scroll={{ x: DRIVER_TABLE_SCROLL_X }}
+          />
+        </div>
       </Space>
+      </div>
       <Modal
         title={`驱动日志 - ${activeLogRow?.name || logDriverType}`}
         open={logModalOpen}
@@ -914,7 +1249,7 @@ const DriverManagerModal: React.FC<{ open: boolean; onClose: () => void }> = ({
             </Paragraph>
           ) : null}
           {activeDriverLogLines.length > 0 ? (
-            <pre style={{ margin: 0, maxHeight: 360, overflow: 'auto', padding: 12, background: '#fafafa', borderRadius: 8, border: '1px solid #f0f0f0', whiteSpace: 'pre-wrap', wordBreak: 'break-word' }}>
+            <pre style={{ margin: 0, maxHeight: 360, overflow: 'auto', padding: 12, background: logBlockBackground, color: logBlockTextColor, borderRadius: 8, border: `1px solid ${logBlockBorderColor}`, whiteSpace: 'pre-wrap', wordBreak: 'break-word' }}>
               {activeDriverLogLines.join('\n')}
             </pre>
           ) : (

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;

frontend/src/components/RedisViewer.tsx

@@ -16,6 +16,10 @@ 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;
@@ -214,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>
     );
 };
@@ -241,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__');
 
@@ -300,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,
             };
         });
 
@@ -407,8 +389,6 @@ const buildRedisKeyTree = (
 
     return {
         treeData: toTreeNodes(root),
-        rawKeyByNodeKey,
-        leafNodeKeyByRawKey,
         groupKeys,
     };
 };
@@ -420,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);
@@ -445,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(() => {
@@ -466,20 +449,28 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
 
     const loadKeys = useCallback(async (
         pattern: string = '*',
-        fromCursor: number = 0,
+        fromCursor: string = '0',
         append: boolean = false,
-        targetCount: number = REDIS_KEY_INITIAL_LOAD_COUNT
+        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, targetCount);
+            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 = Number(result?.cursor || 0);
+                const nextCursor = normalizeRedisCursor(result?.cursor);
                 if (append) {
                     setKeys(prev => {
                         const keyMap = new Map<string, RedisKeyInfo>();
@@ -491,38 +482,43 @@ const RedisViewer: React.FC<RedisViewerProps> = ({ connectionId, redisDB }) => {
                     setKeys(scannedKeys);
                 }
                 setCursor(nextCursor);
-                setHasMore(nextCursor !== 0);
+                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, REDIS_KEY_INITIAL_LOAD_COUNT);
+        loadKeys(searchPattern, '0', false, getRedisScanLoadCount(searchPattern, false));
     }, [redisDB]);
 
     const handleSearch = (value: string) => {
         const pattern = value.trim() || '*';
         setSearchPattern(pattern);
-        setCursor(0);
-        loadKeys(pattern, 0, false, REDIS_KEY_INITIAL_LOAD_COUNT);
+        setCursor('0');
+        loadKeys(pattern, '0', false, getRedisScanLoadCount(pattern, false));
     };
 
     const handleLoadMore = () => {
         if (!hasMore || loading) {
             return;
         }
-        loadKeys(searchPattern, cursor, true, REDIS_KEY_LOAD_MORE_COUNT);
+        loadKeys(searchPattern, cursor, true, getRedisScanLoadCount(searchPattern, true));
     };
 
     const handleRefresh = () => {
-        setCursor(0);
-        loadKeys(searchPattern, 0, false, REDIS_KEY_INITIAL_LOAD_COUNT);
+        setCursor('0');
+        loadKeys(searchPattern, '0', false, getRedisScanLoadCount(searchPattern, false));
     };
 
     const loadKeyValue = async (key: string) => {
@@ -678,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));
@@ -703,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;
         }
@@ -722,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>;
@@ -1769,24 +1904,34 @@ 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} disabled={!hasMore || loading}>加载更多</Button>

frontend/src/store.ts

@@ -1,6 +1,6 @@
 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;
@@ -11,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',
@@ -37,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;
@@ -138,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;
 };
 
@@ -229,7 +246,8 @@ const sanitizeSavedConnection = (value: unknown, index: number): SavedConnection
   const raw = value as Record<string, unknown>;
   const config = sanitizeConnectionConfig(resolveConnectionConfigPayload(raw));
   const id = toTrimmedString(raw.id, `conn-${index + 1}`) || `conn-${index + 1}`;
-  const fallbackName = config.host ? `${config.type}-${config.host}` : `连接-${index + 1}`;
+  const 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);
@@ -288,6 +306,10 @@ export interface QueryOptions {
   showColumnType: boolean;
 }
 
+export interface GlobalProxyConfig extends ProxyConfig {
+  enabled: boolean;
+}
+
 interface AppState {
   connections: SavedConnection[];
   tabs: TabData[];
@@ -297,6 +319,7 @@ interface AppState {
   theme: 'light' | 'dark';
   appearance: { opacity: number; blur: number };
   startupFullscreen: boolean;
+  globalProxy: GlobalProxyConfig;
   sqlFormatOptions: { keywordCase: 'upper' | 'lower' };
   queryOptions: QueryOptions;
   sqlLogs: SqlLog[];
@@ -324,6 +347,7 @@ 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;
 
@@ -416,6 +440,21 @@ 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 {};
@@ -438,6 +477,7 @@ export const useStore = create<AppState>()(
       theme: 'light',
       appearance: { ...DEFAULT_APPEARANCE },
       startupFullscreen: DEFAULT_STARTUP_FULLSCREEN,
+      globalProxy: { ...DEFAULT_GLOBAL_PROXY },
       sqlFormatOptions: { keywordCase: 'upper' },
       queryOptions: { maxRows: 5000, showColumnComment: true, showColumnType: true },
       sqlLogs: [],
@@ -550,6 +590,7 @@ 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 } })),
 
@@ -579,7 +620,7 @@ 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) => {
         const state = unwrapPersistedAppState(persistedState) as Partial<AppState>;
         const nextState: Partial<AppState> = { ...state };
@@ -588,6 +629,7 @@ export const useStore = create<AppState>()(
         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);
@@ -602,8 +644,9 @@ export const useStore = create<AppState>()(
           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),
@@ -616,6 +659,7 @@ export const useStore = create<AppState>()(
         theme: state.theme,
         appearance: state.appearance,
         startupFullscreen: state.startupFullscreen,
+        globalProxy: state.globalProxy,
         sqlFormatOptions: state.sqlFormatOptions,
         queryOptions: state.queryOptions,
         tableAccessCount: state.tableAccessCount,

frontend/src/types.ts

@@ -137,7 +137,7 @@ export interface RedisKeyInfo {
 
 export interface RedisScanResult {
   keys: RedisKeyInfo[];
-  cursor: number;
+  cursor: string;
 }
 
 export interface RedisValue {

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, '``')}\``;
   }
 

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

@@ -12,6 +12,8 @@ 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>;
@@ -32,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>;
@@ -72,6 +76,8 @@ export function GetDriverVersionList(arg1:string,arg2:string):Promise<connection
 
 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>;
@@ -120,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>;
 
@@ -160,6 +166,8 @@ 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>;

frontend/wailsjs/go/app/App.js

@@ -18,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);
 }
@@ -58,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);
 }
@@ -138,6 +146,10 @@ 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']();
 }
@@ -314,6 +326,10 @@ 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);
 }

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
@@ -25,6 +26,8 @@ require (
 
 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
@@ -36,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
@@ -46,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
@@ -62,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
@@ -70,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
@@ -84,6 +91,9 @@ 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/sync v0.19.0 // indirect
 	golang.org/x/sys v0.40.0 // indirect

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=

internal/app/app.go

@@ -207,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()
@@ -254,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)
@@ -268,24 +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
 	}
 
-	connectConfig, proxyErr := resolveDialConfigWithProxy(config)
+	connectConfig, proxyErr := resolveDialConfigWithProxy(effectiveConfig)
 	if proxyErr != nil {
-		wrapped := wrapConnectError(config, proxyErr)
-		logger.Error(wrapped, "连接代理准备失败：%s 缓存Key=%s", formatConnSummary(config), shortKey)
+		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(config, err)
-		logger.Error(wrapped, "建立数据库连接失败：%s 缓存Key=%s", formatConnSummary(config), shortKey)
+		wrapped := wrapConnectError(effectiveConfig, err)
+		logger.Error(wrapped, "建立数据库连接失败：%s 缓存Key=%s", formatConnSummary(effectiveConfig), shortKey)
 		return nil, wrapped
 	}
 
@@ -301,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
 }

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":

internal/app/db_proxy.go

@@ -194,6 +194,8 @@ func defaultPortByType(driverType string) int {
 		return 1433
 	case "mongodb":
 		return 27017
+	case "clickhouse":
+		return 9000
 	case "highgo":
 		return 5866
 	default:

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
+}

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,7 +210,7 @@ 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: "当前连接正在使用目标数据库，请先连接到其他数据库后再重命名"}
@@ -216,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))
@@ -255,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)}
 	}
@@ -269,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":
@@ -301,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)}
 	}
@@ -404,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
@@ -458,8 +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 {
@@ -467,35 +553,65 @@ 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()}
 	}
-	if shouldFallbackCreateStatement(dbType, sqlStr) {
-		columns, colErr := dbInst.GetColumns(schemaName, pureTableName)
-		if colErr != nil {
-			logger.Error(colErr, "DBShowCreateTable 兜底加载字段失败：%s 表=%s", formatConnSummary(runConfig), tableName)
-			return connection.QueryResult{Success: false, Message: colErr.Error()}
-		}
-		fallbackDDL, buildErr := buildFallbackCreateStatement(dbType, schemaName, pureTableName, columns)
-		if buildErr != nil {
-			logger.Error(buildErr, "DBShowCreateTable 兜底生成 DDL 失败：%s 表=%s", formatConnSummary(runConfig), tableName)
-			return connection.QueryResult{Success: false, Message: buildErr.Error()}
-		}
-		sqlStr = fallbackDDL
-	}
 
 	return connection.QueryResult{Success: true, Data: sqlStr}
 }
 
-func shouldFallbackCreateStatement(dbType string, ddl string) bool {
+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 == "" {
@@ -663,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)}
 	}
@@ -752,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":

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

internal/app/methods_driver.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"net"
 	"net/http"
 	"net/url"
@@ -200,6 +201,7 @@ const (
 	driverBundleIndexMaxSize            = 1 << 20
 	driverManifestMaxSize               = 2 << 20
 	driverNetworkProbeTimeout           = 4 * time.Second
+	localDriverDirectoryScanMaxEntries  = 20000
 	driverChecksumPolicyStrict          = "strict"
 	driverChecksumPolicyWarn            = "warn"
 	driverChecksumPolicyOff             = "off"
@@ -212,7 +214,7 @@ const builtinDriverManifestJSON = `{
   "drivers": {
     "mysql":     { "engine": "go", "version": "1.9.3", "checksumPolicy": "off" },
     "mariadb":   { "engine": "go", "version": "1.9.3", "checksumPolicy": "off", "downloadUrl": "builtin://activate/mariadb" },
-    "diros":     { "engine": "go", "version": "1.9.3", "checksumPolicy": "off", "downloadUrl": "builtin://activate/diros" },
+    "doris":     { "engine": "go", "version": "1.9.3", "checksumPolicy": "off", "downloadUrl": "builtin://activate/doris" },
     "sphinx":    { "engine": "go", "version": "1.9.3", "checksumPolicy": "off", "downloadUrl": "builtin://activate/sphinx" },
     "sqlserver": { "engine": "go", "version": "1.9.6", "checksumPolicy": "off", "downloadUrl": "builtin://activate/sqlserver" },
     "sqlite":    { "engine": "go", "version": "1.44.3", "checksumPolicy": "off", "downloadUrl": "builtin://activate/sqlite" },
@@ -222,23 +224,25 @@ const builtinDriverManifestJSON = `{
     "highgo":    { "engine": "go", "version": "0.0.0-local", "checksumPolicy": "off", "downloadUrl": "builtin://activate/highgo" },
     "vastbase":  { "engine": "go", "version": "1.11.1", "checksumPolicy": "off", "downloadUrl": "builtin://activate/vastbase" },
     "mongodb":   { "engine": "go", "version": "2.5.0", "checksumPolicy": "off", "downloadUrl": "builtin://activate/mongodb" },
-    "tdengine":  { "engine": "go", "version": "3.7.8", "checksumPolicy": "off", "downloadUrl": "builtin://activate/tdengine" }
+    "tdengine":  { "engine": "go", "version": "3.7.8", "checksumPolicy": "off", "downloadUrl": "builtin://activate/tdengine" },
+    "clickhouse": { "engine": "go", "version": "2.43.0", "checksumPolicy": "off", "downloadUrl": "builtin://activate/clickhouse" }
   }
 }`
 
 var (
-	driverManifestCacheMu  sync.RWMutex
-	driverManifestCache    = make(map[string]driverManifestCacheEntry)
-	driverReleaseSizeMu    sync.RWMutex
-	driverReleaseSizeMap   = make(map[string]driverReleaseAssetSizeCacheEntry)
-	driverReleaseListMu    sync.RWMutex
-	driverReleaseList      = driverManifestReleaseListCache{}
-	driverModuleLatestMu   sync.RWMutex
-	driverModuleLatestMap  = make(map[string]goModuleLatestVersionCacheEntry)
-	driverModuleVersionMu  sync.RWMutex
-	driverModuleVersionMap = make(map[string]goModuleVersionListCacheEntry)
-	driverVersionWarmupMu  sync.Mutex
-	driverVersionWarmup    = driverVersionWarmupState{}
+	driverManifestCacheMu      sync.RWMutex
+	driverManifestCache        = make(map[string]driverManifestCacheEntry)
+	driverReleaseSizeMu        sync.RWMutex
+	driverReleaseSizeMap       = make(map[string]driverReleaseAssetSizeCacheEntry)
+	driverReleaseListMu        sync.RWMutex
+	driverReleaseList          = driverManifestReleaseListCache{}
+	driverModuleLatestMu       sync.RWMutex
+	driverModuleLatestMap      = make(map[string]goModuleLatestVersionCacheEntry)
+	driverModuleVersionMu      sync.RWMutex
+	driverModuleVersionMap     = make(map[string]goModuleVersionListCacheEntry)
+	driverVersionWarmupMu      sync.Mutex
+	driverVersionWarmup        = driverVersionWarmupState{}
+	errLocalDriverDirScanLimit = errors.New("local_driver_directory_scan_limit_exceeded")
 )
 
 type driverVersionWarmupState struct {
@@ -261,37 +265,39 @@ var pinnedDriverPackageMap = map[string]pinnedDriverPackage{
 }
 
 var latestDriverVersionMap = map[string]string{
-	"mysql":     "1.9.3",
-	"mariadb":   "1.9.3",
-	"diros":     "1.9.3",
-	"sphinx":    "1.9.3",
-	"sqlserver": "1.9.6",
-	"sqlite":    "1.46.1",
-	"duckdb":    "2.5.5",
-	"dameng":    "1.8.22",
-	"kingbase":  "0.0.0-20201021123113-29bd62a876c3",
-	"highgo":    "0.0.0-local",
-	"vastbase":  "1.11.2",
-	"mongodb":   "2.5.0",
-	"tdengine":  "3.7.8",
-	"oracle":    "2.9.0",
-	"postgres":  "1.11.2",
-	"redis":     "9.17.3",
+	"mysql":      "1.9.3",
+	"mariadb":    "1.9.3",
+	"diros":      "1.9.3",
+	"sphinx":     "1.9.3",
+	"sqlserver":  "1.9.6",
+	"sqlite":     "1.46.1",
+	"duckdb":     "2.5.5",
+	"dameng":     "1.8.22",
+	"kingbase":   "0.0.0-20201021123113-29bd62a876c3",
+	"highgo":     "0.0.0-local",
+	"vastbase":   "1.11.2",
+	"mongodb":    "2.5.0",
+	"tdengine":   "3.7.8",
+	"clickhouse": "2.43.0",
+	"oracle":     "2.9.0",
+	"postgres":   "1.11.2",
+	"redis":      "9.17.3",
 }
 
 var driverGoModulePathMap = map[string]string{
-	"mariadb":   "github.com/go-sql-driver/mysql",
-	"diros":     "github.com/go-sql-driver/mysql",
-	"sphinx":    "github.com/go-sql-driver/mysql",
-	"sqlserver": "github.com/microsoft/go-mssqldb",
-	"sqlite":    "modernc.org/sqlite",
-	"duckdb":    "github.com/duckdb/duckdb-go/v2",
-	"dameng":    "gitee.com/chunanyong/dm",
-	"kingbase":  "gitea.com/kingbase/gokb",
-	"highgo":    "github.com/highgo/pq-sm3",
-	"vastbase":  "github.com/lib/pq",
-	"mongodb":   "go.mongodb.org/mongo-driver/v2",
-	"tdengine":  "github.com/taosdata/driver-go/v3",
+	"mariadb":    "github.com/go-sql-driver/mysql",
+	"diros":      "github.com/go-sql-driver/mysql",
+	"sphinx":     "github.com/go-sql-driver/mysql",
+	"sqlserver":  "github.com/microsoft/go-mssqldb",
+	"sqlite":     "modernc.org/sqlite",
+	"duckdb":     "github.com/duckdb/duckdb-go/v2",
+	"dameng":     "gitee.com/chunanyong/dm",
+	"kingbase":   "gitea.com/kingbase/gokb",
+	"highgo":     "github.com/highgo/pq-sm3",
+	"vastbase":   "github.com/lib/pq",
+	"mongodb":    "go.mongodb.org/mongo-driver/v2",
+	"tdengine":   "github.com/taosdata/driver-go/v3",
+	"clickhouse": "github.com/ClickHouse/clickhouse-go/v2",
 }
 
 var fallbackRecentDriverVersionsMap = map[string][]goModuleVersionMeta{
@@ -357,9 +363,6 @@ func (a *App) SelectDriverPackageFile(currentPath string) connection.QueryResult
 	selection, err := runtime.OpenFileDialog(a.ctx, runtime.OpenDialogOptions{
 		Title:            "选择驱动包文件",
 		DefaultDirectory: defaultDir,
-		Filters: []runtime.FileFilter{
-			{DisplayName: "所有文件", Pattern: "*"},
-		},
 	})
 	if err != nil {
 		return connection.QueryResult{Success: false, Message: err.Error()}
@@ -374,6 +377,36 @@ func (a *App) SelectDriverPackageFile(currentPath string) connection.QueryResult
 	return connection.QueryResult{Success: true, Data: map[string]interface{}{"path": selection}}
 }
 
+func (a *App) SelectDriverPackageDirectory(currentPath string) connection.QueryResult {
+	defaultDir := strings.TrimSpace(currentPath)
+	if defaultDir == "" {
+		defaultDir = defaultDriverDownloadDirectory()
+	}
+	if filepath.Ext(defaultDir) != "" {
+		defaultDir = filepath.Dir(defaultDir)
+	}
+	if !filepath.IsAbs(defaultDir) {
+		if abs, err := filepath.Abs(defaultDir); err == nil {
+			defaultDir = abs
+		}
+	}
+
+	selection, err := runtime.OpenDirectoryDialog(a.ctx, runtime.OpenDialogOptions{
+		Title:            "选择驱动包目录",
+		DefaultDirectory: defaultDir,
+	})
+	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}}
+}
+
 func (a *App) ResolveDriverDownloadDirectory(directory string) connection.QueryResult {
 	resolved, err := resolveDriverDownloadDirectory(directory)
 	if err != nil {
@@ -423,7 +456,7 @@ func (a *App) ResolveDriverPackageDownloadURL(driverType string, repositoryURL s
 	if engine == driverEngineGo && !definition.BuiltIn {
 		urlText := strings.TrimSpace(definition.DefaultDownloadURL)
 		if urlText == "" {
-			urlText = fmt.Sprintf("builtin://activate/%s", definition.Type)
+			urlText = fmt.Sprintf("builtin://activate/%s", optionalDriverPublicTypeName(definition.Type))
 		}
 		data := map[string]interface{}{
 			"url":           urlText,
@@ -497,14 +530,14 @@ func (a *App) GetDriverVersionPackageSize(driverType string, version string) con
 	if sizeByAsset, err := loadReleaseAssetSizesCached("tag:"+tag, func() (*githubRelease, error) {
 		return fetchReleaseByTag(tag)
 	}); err == nil {
-		sizeBytes = sizeByAsset[assetName]
+		sizeBytes = resolveOptionalDriverAssetSize(sizeByAsset, normalizedType)
 		if sizeBytes > 0 {
 			sizeSource = "tag"
 		}
 	}
 	if sizeBytes <= 0 {
 		if sizeByAsset, err := loadReleaseAssetSizesCached("latest", fetchLatestReleaseForDriverAssets); err == nil {
-			sizeBytes = sizeByAsset[assetName]
+			sizeBytes = resolveOptionalDriverAssetSize(sizeByAsset, normalizedType)
 			if sizeBytes > 0 {
 				sizeSource = "latest"
 			}
@@ -681,7 +714,7 @@ func (a *App) InstallLocalDriverPackage(driverType string, filePath string, down
 
 	a.emitDriverDownloadProgress(definition.Type, "start", 0, 100, "开始安装本地驱动包")
 	selectedVersion := resolveDriverInstallVersion(definition.PinnedVersion, "local://manual", definition)
-	meta, installErr := installOptionalDriverAgentFromLocalFile(definition, filePath, resolvedDir, selectedVersion)
+	meta, installErr := installOptionalDriverAgentFromLocalPath(definition, filePath, resolvedDir, selectedVersion)
 	if installErr != nil {
 		errText := normalizeErrorMessage(installErr)
 		a.emitDriverDownloadProgress(definition.Type, "error", 0, 0, errText)
@@ -729,7 +762,7 @@ func (a *App) DownloadDriverPackage(driverType string, version string, downloadU
 		urlText = strings.TrimSpace(definition.DefaultDownloadURL)
 	}
 	if urlText == "" {
-		urlText = fmt.Sprintf("builtin://activate/%s", definition.Type)
+		urlText = fmt.Sprintf("builtin://activate/%s", optionalDriverPublicTypeName(definition.Type))
 	}
 	selectedVersion := resolveDriverInstallVersion(version, urlText, definition)
 
@@ -870,7 +903,7 @@ func probeDriverNetworkEndpoint(item driverNetworkProbeItem) driverNetworkProbeI
 		return probed
 	}
 
-	client := &http.Client{Timeout: driverNetworkProbeTimeout}
+	client := newHTTPClientWithGlobalProxy(driverNetworkProbeTimeout)
 	start := time.Now()
 	req, err := http.NewRequest(http.MethodHead, urlText, nil)
 	if err != nil {
@@ -1035,7 +1068,7 @@ func allDriverDefinitionsWithPackages(packages map[string]pinnedDriverPackage) [
 
 		// 其他数据源需要先在驱动管理中“安装启用”。
 		buildOptionalGoDriverDefinition("mariadb", "MariaDB", packages),
-		buildOptionalGoDriverDefinition("diros", "Diros", packages),
+		buildOptionalGoDriverDefinition("diros", "Doris", packages),
 		buildOptionalGoDriverDefinition("sphinx", "Sphinx", packages),
 		buildOptionalGoDriverDefinition("sqlserver", "SQL Server", packages),
 		buildOptionalGoDriverDefinition("sqlite", "SQLite", packages),
@@ -1046,6 +1079,7 @@ func allDriverDefinitionsWithPackages(packages map[string]pinnedDriverPackage) [
 		buildOptionalGoDriverDefinition("vastbase", "Vastbase", packages),
 		buildOptionalGoDriverDefinition("mongodb", "MongoDB", packages),
 		buildOptionalGoDriverDefinition("tdengine", "TDengine", packages),
+		buildOptionalGoDriverDefinition("clickhouse", "ClickHouse", packages),
 	}
 }
 
@@ -1212,7 +1246,7 @@ func resolveDriverVersionOptions(definition driverDefinition, repositoryURL stri
 			urlText = strings.TrimSpace(definition.DefaultDownloadURL)
 		}
 		if urlText == "" && effectiveDriverEngine(definition) == driverEngineGo {
-			urlText = fmt.Sprintf("builtin://activate/%s", driverType)
+			urlText = fmt.Sprintf("builtin://activate/%s", optionalDriverPublicTypeName(driverType))
 		}
 		if versionText == "" {
 			versionText = resolveDriverInstallVersion("", urlText, definition)
@@ -1349,7 +1383,7 @@ func resolveVersionedDriverOption(definition driverDefinition, version string, s
 
 	urlText := strings.TrimSpace(definition.DefaultDownloadURL)
 	if urlText == "" && effectiveDriverEngine(definition) == driverEngineGo {
-		urlText = fmt.Sprintf("builtin://activate/%s", driverType)
+		urlText = fmt.Sprintf("builtin://activate/%s", optionalDriverPublicTypeName(driverType))
 	}
 	if urlText == "" {
 		return "", "", false
@@ -1396,13 +1430,13 @@ func resolveDriverVersionPackageSizeBytes(definition driverDefinition, option dr
 
 	tag := "v" + version
 	if sizeByAsset, ok := readReleaseAssetSizesFromCache("tag:" + tag); ok {
-		return sizeByAsset[assetName]
+		return resolveOptionalDriverAssetSize(sizeByAsset, driverType)
 	}
 
 	// 下拉版本列表要求快速返回：仅复用已有缓存，不在这里触发网络请求。
 	if strings.EqualFold(strings.TrimSpace(option.Source), "latest") {
 		if sizeByAsset, ok := readReleaseAssetSizesFromCache("latest"); ok {
-			return sizeByAsset[assetName]
+			return resolveOptionalDriverAssetSize(sizeByAsset, driverType)
 		}
 	}
 	return 0
@@ -1548,7 +1582,7 @@ func fetchGoModuleVersionMetas(modulePath string) ([]goModuleVersionMeta, error)
 	}
 
 	endpoint := fmt.Sprintf("https://proxy.golang.org/%s/@v/list", escapeGoModulePathForProxy(trimmed))
-	client := &http.Client{Timeout: driverModuleLatestProbeTimeout}
+	client := newHTTPClientWithGlobalProxy(driverModuleLatestProbeTimeout)
 	req, err := http.NewRequest(http.MethodGet, endpoint, nil)
 	if err != nil {
 		return nil, err
@@ -1631,13 +1665,14 @@ func resolveDriverVersionOptionsFromReleases(definition driverDefinition) []driv
 	}
 
 	assetName := optionalDriverReleaseAssetName(driverType)
+	assetNames := optionalDriverReleaseAssetNames(driverType)
 	result := make([]driverVersionOptionItem, 0, len(releases))
 	for _, release := range releases {
 		if release.Prerelease {
 			continue
 		}
 		tag := strings.TrimSpace(release.TagName)
-		if tag == "" || !releaseContainsAsset(release, assetName) {
+		if tag == "" || !releaseContainsAnyAsset(release, assetNames) {
 			continue
 		}
 		result = append(result, driverVersionOptionItem{
@@ -1689,7 +1724,7 @@ func loadDriverReleaseListCached() ([]githubRelease, error) {
 
 func fetchDriverReleaseList() ([]githubRelease, error) {
 	apiURL := fmt.Sprintf("https://api.github.com/repos/%s/releases?per_page=30", updateRepo)
-	client := &http.Client{Timeout: driverReleaseListProbeTimeout}
+	client := newHTTPClientWithGlobalProxy(driverReleaseListProbeTimeout)
 	req, err := http.NewRequest(http.MethodGet, apiURL, nil)
 	if err != nil {
 		return nil, err
@@ -1714,14 +1749,24 @@ func fetchDriverReleaseList() ([]githubRelease, error) {
 	return releases, nil
 }
 
-func releaseContainsAsset(release githubRelease, assetName string) bool {
-	name := strings.TrimSpace(assetName)
-	if name == "" {
+func releaseContainsAnyAsset(release githubRelease, assetNames []string) bool {
+	normalizedNames := make([]string, 0, len(assetNames))
+	for _, assetName := range assetNames {
+		name := strings.TrimSpace(assetName)
+		if name == "" {
+			continue
+		}
+		normalizedNames = append(normalizedNames, name)
+	}
+	if len(normalizedNames) == 0 {
 		return false
 	}
 	for _, asset := range release.Assets {
-		if strings.EqualFold(strings.TrimSpace(asset.Name), name) {
-			return true
+		assetName := strings.TrimSpace(asset.Name)
+		for _, expected := range normalizedNames {
+			if strings.EqualFold(assetName, expected) {
+				return true
+			}
 		}
 	}
 	return false
@@ -2019,7 +2064,7 @@ func loadManifestContent(resolvedURL string) ([]byte, error) {
 		scheme := strings.ToLower(strings.TrimSpace(parsed.Scheme))
 		switch scheme {
 		case "http", "https":
-			client := &http.Client{Timeout: 12 * time.Second}
+			client := newHTTPClientWithGlobalProxy(12 * time.Second)
 			req, reqErr := http.NewRequest(http.MethodGet, parsed.String(), nil)
 			if reqErr != nil {
 				return nil, reqErr
@@ -2190,7 +2235,7 @@ func installOptionalDriverAgentPackage(a *App, definition driverDefinition, sele
 	}, nil
 }
 
-func installOptionalDriverAgentFromLocalFile(definition driverDefinition, filePath string, resolvedDir string, selectedVersion string) (installedDriverPackage, error) {
+func installOptionalDriverAgentFromLocalPath(definition driverDefinition, filePath string, resolvedDir string, selectedVersion string) (installedDriverPackage, error) {
 	driverType := normalizeDriverType(definition.Type)
 	displayName := resolveDriverDisplayName(definition)
 	pathText := strings.TrimSpace(filePath)
@@ -2204,9 +2249,6 @@ func installOptionalDriverAgentFromLocalFile(definition driverDefinition, filePa
 	if statErr != nil {
 		return installedDriverPackage{}, fmt.Errorf("读取本地驱动包失败：%w", statErr)
 	}
-	if info.IsDir() {
-		return installedDriverPackage{}, fmt.Errorf("本地驱动包路径为目录：%s", pathText)
-	}
 
 	executablePath, err := db.ResolveOptionalDriverAgentExecutablePath(resolvedDir, driverType)
 	if err != nil {
@@ -2216,8 +2258,23 @@ func installOptionalDriverAgentFromLocalFile(definition driverDefinition, filePa
 		return installedDriverPackage{}, fmt.Errorf("创建 %s 驱动目录失败：%w", displayName, mkErr)
 	}
 
+	sourcePath := pathText
+	sourceName := filepath.Base(pathText)
 	downloadSource := fmt.Sprintf("local://manual/%s", filepath.Base(pathText))
-	if strings.EqualFold(filepath.Ext(pathText), ".zip") {
+	if info.IsDir() {
+		matchedPath, matchedEntry, resolveErr := resolveLocalDriverAgentFromDirectory(pathText, driverType)
+		if resolveErr != nil {
+			return installedDriverPackage{}, resolveErr
+		}
+		sourcePath = matchedPath
+		sourceName = filepath.Base(matchedPath)
+		downloadSource = fmt.Sprintf("local://manual-dir/%s", filepath.Base(pathText))
+		if strings.TrimSpace(matchedEntry) != "" {
+			downloadSource = downloadSource + "#" + matchedEntry
+		}
+	}
+
+	if !info.IsDir() && strings.EqualFold(filepath.Ext(pathText), ".zip") {
 		entryName, extractErr := installOptionalDriverAgentFromLocalZip(pathText, definition, executablePath)
 		if extractErr != nil {
 			return installedDriverPackage{}, extractErr
@@ -2226,7 +2283,7 @@ func installOptionalDriverAgentFromLocalFile(definition driverDefinition, filePa
 			downloadSource = downloadSource + "#" + entryName
 		}
 	} else {
-		if copyErr := copyAgentBinary(pathText, executablePath); copyErr != nil {
+		if copyErr := copyAgentBinary(sourcePath, executablePath); copyErr != nil {
 			return installedDriverPackage{}, fmt.Errorf("导入本地驱动代理失败：%w", copyErr)
 		}
 	}
@@ -2238,8 +2295,8 @@ func installOptionalDriverAgentFromLocalFile(definition driverDefinition, filePa
 	return installedDriverPackage{
 		DriverType:     driverType,
 		Version:        strings.TrimSpace(selectedVersion),
-		FilePath:       pathText,
-		FileName:       filepath.Base(pathText),
+		FilePath:       sourcePath,
+		FileName:       sourceName,
 		ExecutablePath: executablePath,
 		DownloadURL:    downloadSource,
 		SHA256:         hash,
@@ -2247,6 +2304,153 @@ func installOptionalDriverAgentFromLocalFile(definition driverDefinition, filePa
 	}, nil
 }
 
+type localDriverCandidate struct {
+	absPath       string
+	relativePath  string
+	depth         int
+	inPlatformDir bool
+}
+
+func resolveLocalDriverAgentFromDirectory(directoryPath string, driverType string) (string, string, error) {
+	root := strings.TrimSpace(directoryPath)
+	if root == "" {
+		return "", "", fmt.Errorf("本地驱动目录路径为空")
+	}
+	if absPath, absErr := filepath.Abs(root); absErr == nil {
+		root = absPath
+	}
+	info, statErr := os.Stat(root)
+	if statErr != nil {
+		return "", "", fmt.Errorf("读取本地驱动目录失败：%w", statErr)
+	}
+	if !info.IsDir() {
+		return "", "", fmt.Errorf("本地驱动目录路径不是目录：%s", root)
+	}
+
+	normalizedType := normalizeDriverType(driverType)
+	displayDefinition, found := resolveDriverDefinition(normalizedType)
+	if !found {
+		displayDefinition = driverDefinition{Type: normalizedType, Name: normalizedType}
+	}
+	displayName := resolveDriverDisplayName(displayDefinition)
+	platformDir := optionalDriverBundlePlatformDir(stdRuntime.GOOS)
+	assetNameCandidates := optionalDriverReleaseAssetNames(normalizedType)
+	baseNameCandidates := optionalDriverExecutableBaseNames(normalizedType)
+	assetName := optionalDriverReleaseAssetName(normalizedType)
+
+	exactRelativePath := filepath.ToSlash(filepath.Join(platformDir, assetName))
+	for _, candidateName := range assetNameCandidates {
+		exactPath := filepath.Join(root, platformDir, candidateName)
+		if exactInfo, err := os.Stat(exactPath); err == nil && !exactInfo.IsDir() {
+			return exactPath, filepath.ToSlash(filepath.Join(platformDir, candidateName)), nil
+		}
+	}
+
+	for _, candidateName := range assetNameCandidates {
+		rootAssetPath := filepath.Join(root, candidateName)
+		if rootAssetInfo, err := os.Stat(rootAssetPath); err == nil && !rootAssetInfo.IsDir() {
+			return rootAssetPath, filepath.ToSlash(candidateName), nil
+		}
+	}
+
+	assetCandidates := make([]localDriverCandidate, 0, 8)
+	baseCandidates := make([]localDriverCandidate, 0, 8)
+	visited := 0
+	walkErr := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		visited++
+		if visited > localDriverDirectoryScanMaxEntries {
+			return errLocalDriverDirScanLimit
+		}
+		if d.IsDir() {
+			return nil
+		}
+		name := strings.TrimSpace(d.Name())
+		if name == "" {
+			return nil
+		}
+
+		relative, relErr := filepath.Rel(root, path)
+		if relErr != nil {
+			relative = name
+		}
+		normalizedRelative := filepath.ToSlash(strings.TrimPrefix(strings.TrimSpace(relative), "./"))
+		if normalizedRelative == "" {
+			normalizedRelative = name
+		}
+		normalizedLower := strings.ToLower(normalizedRelative)
+		platformPrefix := strings.ToLower(platformDir) + "/"
+		inPlatformDir := normalizedLower == strings.ToLower(platformDir) || strings.HasPrefix(normalizedLower, platformPrefix)
+		depth := strings.Count(normalizedRelative, "/")
+		candidate := localDriverCandidate{
+			absPath:       path,
+			relativePath:  normalizedRelative,
+			depth:         depth,
+			inPlatformDir: inPlatformDir,
+		}
+
+		for _, candidateName := range assetNameCandidates {
+			if strings.EqualFold(name, candidateName) {
+				assetCandidates = append(assetCandidates, candidate)
+				return nil
+			}
+		}
+		for _, candidateName := range baseNameCandidates {
+			if strings.EqualFold(name, candidateName) {
+				baseCandidates = append(baseCandidates, candidate)
+				return nil
+			}
+		}
+		return nil
+	})
+	if errors.Is(walkErr, errLocalDriverDirScanLimit) {
+		return "", "", fmt.Errorf("本地驱动目录条目过多（超过 %d），请缩小目录范围或直接选择 zip/单文件", localDriverDirectoryScanMaxEntries)
+	}
+	if walkErr != nil {
+		return "", "", fmt.Errorf("扫描本地驱动目录失败：%w", walkErr)
+	}
+
+	selectBest := func(candidates []localDriverCandidate) (localDriverCandidate, bool) {
+		if len(candidates) == 0 {
+			return localDriverCandidate{}, false
+		}
+		sort.Slice(candidates, func(i, j int) bool {
+			left := candidates[i]
+			right := candidates[j]
+			if left.inPlatformDir != right.inPlatformDir {
+				return left.inPlatformDir
+			}
+			if left.depth != right.depth {
+				return left.depth < right.depth
+			}
+			leftRelative := strings.ToLower(left.relativePath)
+			rightRelative := strings.ToLower(right.relativePath)
+			if leftRelative != rightRelative {
+				return leftRelative < rightRelative
+			}
+			return strings.ToLower(left.absPath) < strings.ToLower(right.absPath)
+		})
+		return candidates[0], true
+	}
+
+	if candidate, ok := selectBest(assetCandidates); ok {
+		return candidate.absPath, candidate.relativePath, nil
+	}
+	if candidate, ok := selectBest(baseCandidates); ok {
+		return candidate.absPath, candidate.relativePath, nil
+	}
+
+	return "", "", fmt.Errorf(
+		"目录中未找到 %s 代理文件（优先路径 %s，候选文件名 %s / %s）",
+		displayName,
+		exactRelativePath,
+		strings.Join(assetNameCandidates, " | "),
+		strings.Join(baseNameCandidates, " | "),
+	)
+}
+
 func installOptionalDriverAgentFromLocalZip(zipPath string, definition driverDefinition, executablePath string) (string, error) {
 	driverType := normalizeDriverType(definition.Type)
 	displayName := resolveDriverDisplayName(definition)
@@ -2257,24 +2461,31 @@ func installOptionalDriverAgentFromLocalZip(zipPath string, definition driverDef
 	defer reader.Close()
 
 	entryPath := optionalDriverBundleEntryPath(driverType)
-	expectedBaseName := optionalDriverReleaseAssetName(driverType)
+	entryPaths := optionalDriverBundleEntryPaths(driverType)
+	expectedBaseNames := optionalDriverReleaseAssetNames(driverType)
 	findEntry := func() *zip.File {
 		for _, file := range reader.File {
 			name := filepath.ToSlash(strings.TrimPrefix(strings.TrimSpace(file.Name), "./"))
-			if name == entryPath {
-				return file
+			for _, expectedPath := range entryPaths {
+				if name == expectedPath {
+					return file
+				}
 			}
 		}
 		for _, file := range reader.File {
 			name := filepath.ToSlash(strings.TrimPrefix(strings.TrimSpace(file.Name), "./"))
-			if strings.EqualFold(name, entryPath) {
-				return file
+			for _, expectedPath := range entryPaths {
+				if strings.EqualFold(name, expectedPath) {
+					return file
+				}
 			}
 		}
 		for _, file := range reader.File {
 			name := filepath.ToSlash(strings.TrimPrefix(strings.TrimSpace(file.Name), "./"))
-			if strings.EqualFold(filepath.Base(name), expectedBaseName) {
-				return file
+			for _, expectedName := range expectedBaseNames {
+				if strings.EqualFold(filepath.Base(name), expectedName) {
+					return file
+				}
 			}
 		}
 		return nil
@@ -2468,24 +2679,31 @@ func downloadOptionalDriverAgentFromBundle(a *App, definition driverDefinition,
 	defer reader.Close()
 
 	entryPath := optionalDriverBundleEntryPath(driverType)
-	expectedBaseName := optionalDriverReleaseAssetName(driverType)
+	entryPaths := optionalDriverBundleEntryPaths(driverType)
+	expectedBaseNames := optionalDriverReleaseAssetNames(driverType)
 	findEntry := func() *zip.File {
 		for _, file := range reader.File {
 			name := filepath.ToSlash(strings.TrimPrefix(strings.TrimSpace(file.Name), "./"))
-			if name == entryPath {
-				return file
+			for _, expectedPath := range entryPaths {
+				if name == expectedPath {
+					return file
+				}
 			}
 		}
 		for _, file := range reader.File {
 			name := filepath.ToSlash(strings.TrimPrefix(strings.TrimSpace(file.Name), "./"))
-			if strings.EqualFold(name, entryPath) {
-				return file
+			for _, expectedPath := range entryPaths {
+				if strings.EqualFold(name, expectedPath) {
+					return file
+				}
 			}
 		}
 		for _, file := range reader.File {
 			name := filepath.ToSlash(strings.TrimPrefix(strings.TrimSpace(file.Name), "./"))
-			if strings.EqualFold(filepath.Base(name), expectedBaseName) {
-				return file
+			for _, expectedName := range expectedBaseNames {
+				if strings.EqualFold(filepath.Base(name), expectedName) {
+					return file
+				}
 			}
 		}
 		return nil
@@ -2605,6 +2823,8 @@ func optionalDriverBuildTag(driverType string) (string, error) {
 		return "gonavi_mongodb_driver", nil
 	case "tdengine":
 		return "gonavi_tdengine_driver", nil
+	case "clickhouse":
+		return "gonavi_clickhouse_driver", nil
 	default:
 		return "", fmt.Errorf("未配置驱动构建标签：%s", driverType)
 	}
@@ -2634,22 +2854,93 @@ func fileExists(path string) bool {
 	return err == nil && !info.IsDir()
 }
 
-func optionalDriverExecutableBaseName(driverType string) string {
-	name := fmt.Sprintf("%s-driver-agent", normalizeDriverType(driverType))
+func optionalDriverPublicTypeName(driverType string) string {
+	switch normalizeDriverType(driverType) {
+	case "diros":
+		return "doris"
+	default:
+		return normalizeDriverType(driverType)
+	}
+}
+
+func optionalDriverExecutableBaseNameForType(typeName string) string {
+	base := strings.TrimSpace(typeName)
+	if base == "" {
+		base = "unknown"
+	}
+	name := fmt.Sprintf("%s-driver-agent", base)
 	if stdRuntime.GOOS == "windows" {
 		return name + ".exe"
 	}
 	return name
 }
 
-func optionalDriverReleaseAssetName(driverType string) string {
-	name := fmt.Sprintf("%s-driver-agent-%s-%s", normalizeDriverType(driverType), stdRuntime.GOOS, stdRuntime.GOARCH)
-	if stdRuntime.GOOS == "windows" {
+func optionalDriverReleaseAssetNameForType(typeName string, goos string, goarch string) string {
+	base := strings.TrimSpace(typeName)
+	if base == "" {
+		base = "unknown"
+	}
+	name := fmt.Sprintf("%s-driver-agent-%s-%s", base, goos, goarch)
+	if strings.EqualFold(goos, "windows") {
 		return name + ".exe"
 	}
 	return name
 }
 
+func optionalDriverExecutableBaseNames(driverType string) []string {
+	names := make([]string, 0, 2)
+	seen := make(map[string]struct{}, 2)
+	appendName := func(typeName string) {
+		name := optionalDriverExecutableBaseNameForType(typeName)
+		if strings.TrimSpace(name) == "" {
+			return
+		}
+		if _, ok := seen[name]; ok {
+			return
+		}
+		seen[name] = struct{}{}
+		names = append(names, name)
+	}
+
+	appendName(optionalDriverPublicTypeName(driverType))
+	return names
+}
+
+func optionalDriverReleaseAssetNames(driverType string) []string {
+	names := make([]string, 0, 2)
+	seen := make(map[string]struct{}, 2)
+	appendName := func(typeName string) {
+		name := optionalDriverReleaseAssetNameForType(typeName, stdRuntime.GOOS, stdRuntime.GOARCH)
+		if strings.TrimSpace(name) == "" {
+			return
+		}
+		if _, ok := seen[name]; ok {
+			return
+		}
+		seen[name] = struct{}{}
+		names = append(names, name)
+	}
+
+	appendName(optionalDriverPublicTypeName(driverType))
+	return names
+}
+
+func optionalDriverExecutableBaseName(driverType string) string {
+	names := optionalDriverExecutableBaseNames(driverType)
+	if len(names) == 0 {
+		return optionalDriverExecutableBaseNameForType("")
+	}
+	return names[0]
+}
+
+func optionalDriverReleaseAssetName(driverType string) string {
+	names := optionalDriverReleaseAssetNames(driverType)
+	if len(names) == 0 {
+		return optionalDriverReleaseAssetNameForType("", stdRuntime.GOOS, stdRuntime.GOARCH)
+	}
+	return names[0]
+}
+
 func optionalDriverBundlePlatformDir(goos string) string {
 	switch strings.ToLower(strings.TrimSpace(goos)) {
 	case "windows":
@@ -2663,8 +2954,41 @@ func optionalDriverBundlePlatformDir(goos string) string {
 	}
 }
 
+func optionalDriverBundleEntryPaths(driverType string) []string {
+	platformDir := optionalDriverBundlePlatformDir(stdRuntime.GOOS)
+	assetNames := optionalDriverReleaseAssetNames(driverType)
+	result := make([]string, 0, len(assetNames))
+	seen := make(map[string]struct{}, len(assetNames))
+	for _, assetName := range assetNames {
+		entry := filepath.ToSlash(filepath.Join(platformDir, assetName))
+		if _, ok := seen[entry]; ok {
+			continue
+		}
+		seen[entry] = struct{}{}
+		result = append(result, entry)
+	}
+	return result
+}
+
 func optionalDriverBundleEntryPath(driverType string) string {
-	return filepath.ToSlash(filepath.Join(optionalDriverBundlePlatformDir(stdRuntime.GOOS), optionalDriverReleaseAssetName(driverType)))
+	paths := optionalDriverBundleEntryPaths(driverType)
+	if len(paths) == 0 {
+		return filepath.ToSlash(filepath.Join(optionalDriverBundlePlatformDir(stdRuntime.GOOS), optionalDriverReleaseAssetName(driverType)))
+	}
+	return paths[0]
+}
+
+func resolveOptionalDriverAssetSize(sizeByAsset map[string]int64, driverType string) int64 {
+	if len(sizeByAsset) == 0 {
+		return 0
+	}
+	for _, assetName := range optionalDriverReleaseAssetNames(driverType) {
+		sizeBytes := sizeByAsset[assetName]
+		if sizeBytes > 0 {
+			return sizeBytes
+		}
+	}
+	return 0
 }
 
 func resolveOptionalDriverBundleDownloadURLs() []string {
@@ -2713,12 +3037,16 @@ func resolveOptionalDriverAgentDownloadURLs(definition driverDefinition, rawURL
 		}
 	}
 
-	assetName := optionalDriverReleaseAssetName(driverType)
+	assetNames := optionalDriverReleaseAssetNames(driverType)
 	currentVersion := normalizeVersion(getCurrentVersion())
 	if currentVersion != "" && currentVersion != "0.0.0" {
-		appendURL(fmt.Sprintf("https://github.com/Syngnat/GoNavi/releases/download/v%s/%s", currentVersion, assetName))
+		for _, assetName := range assetNames {
+			appendURL(fmt.Sprintf("https://github.com/Syngnat/GoNavi/releases/download/v%s/%s", currentVersion, assetName))
+		}
+	}
+	for _, assetName := range assetNames {
+		appendURL(fmt.Sprintf("https://github.com/Syngnat/GoNavi/releases/latest/download/%s", assetName))
 	}
-	appendURL(fmt.Sprintf("https://github.com/Syngnat/GoNavi/releases/latest/download/%s", assetName))
 	return candidates
 }
 
@@ -2747,8 +3075,23 @@ func findExistingOptionalDriverAgentCandidate(definition driverDefinition, targe
 
 func resolveOptionalDriverAgentCandidatePaths(definition driverDefinition) []string {
 	driverType := normalizeDriverType(definition.Type)
-	name := optionalDriverExecutableBaseName(driverType)
-	assetName := optionalDriverReleaseAssetName(driverType)
+	names := optionalDriverExecutableBaseNames(driverType)
+	assetNames := optionalDriverReleaseAssetNames(driverType)
+	pathTypeNames := make([]string, 0, 2)
+	seenPathType := make(map[string]struct{}, 2)
+	appendPathType := func(typeName string) {
+		trimmed := strings.TrimSpace(typeName)
+		if trimmed == "" {
+			return
+		}
+		if _, ok := seenPathType[trimmed]; ok {
+			return
+		}
+		seenPathType[trimmed] = struct{}{}
+		pathTypeNames = append(pathTypeNames, trimmed)
+	}
+	appendPathType(optionalDriverPublicTypeName(driverType))
+
 	candidates := make([]string, 0, 12)
 	appendPath := func(pathText string) {
 		trimmed := strings.TrimSpace(pathText)
@@ -2763,18 +3106,36 @@ func resolveOptionalDriverAgentCandidatePaths(definition driverDefinition) []str
 			resolved = evalPath
 		}
 		exeDir := filepath.Dir(resolved)
-		appendPath(filepath.Join(exeDir, name))
-		appendPath(filepath.Join(exeDir, assetName))
-		appendPath(filepath.Join(exeDir, "drivers", driverType, name))
-		appendPath(filepath.Join(exeDir, "drivers", driverType, assetName))
+		for _, name := range names {
+			appendPath(filepath.Join(exeDir, name))
+		}
+		for _, assetName := range assetNames {
+			appendPath(filepath.Join(exeDir, assetName))
+		}
+		for _, typeName := range pathTypeNames {
+			for _, name := range names {
+				appendPath(filepath.Join(exeDir, "drivers", typeName, name))
+			}
+			for _, assetName := range assetNames {
+				appendPath(filepath.Join(exeDir, "drivers", typeName, assetName))
+			}
+		}
 
 		resourcesDir := filepath.Clean(filepath.Join(exeDir, "..", "Resources"))
-		appendPath(filepath.Join(resourcesDir, "drivers", driverType, name))
-		appendPath(filepath.Join(resourcesDir, "drivers", driverType, assetName))
+		for _, typeName := range pathTypeNames {
+			for _, name := range names {
+				appendPath(filepath.Join(resourcesDir, "drivers", typeName, name))
+			}
+			for _, assetName := range assetNames {
+				appendPath(filepath.Join(resourcesDir, "drivers", typeName, assetName))
+			}
+		}
 	}
 	if wd, err := os.Getwd(); err == nil && strings.TrimSpace(wd) != "" {
-		appendPath(filepath.Join(wd, "dist", assetName))
-		appendPath(filepath.Join(wd, assetName))
+		for _, assetName := range assetNames {
+			appendPath(filepath.Join(wd, "dist", assetName))
+			appendPath(filepath.Join(wd, assetName))
+		}
 	}
 
 	unique := make([]string, 0, len(candidates))
@@ -2890,8 +3251,7 @@ func preloadOptionalDriverPackageSizes(definitions []driverDefinition) map[strin
 	fillFromSizes := func(sizeByAsset map[string]int64, driverTypes []string) []string {
 		missing := make([]string, 0, len(driverTypes))
 		for _, driverType := range driverTypes {
-			assetName := optionalDriverReleaseAssetName(driverType)
-			sizeBytes := sizeByAsset[assetName]
+			sizeBytes := resolveOptionalDriverAssetSize(sizeByAsset, driverType)
 			if sizeBytes > 0 {
 				result[driverType] = sizeBytes
 				continue
@@ -3026,7 +3386,7 @@ func fetchDriverBundleAssetSizeIndex(release *githubRelease) (map[string]int64,
 		return nil, fmt.Errorf("未找到驱动总包索引资产")
 	}
 
-	client := &http.Client{Timeout: driverReleaseAssetSizeProbeTimeout}
+	client := newHTTPClientWithGlobalProxy(driverReleaseAssetSizeProbeTimeout)
 	req, err := http.NewRequest(http.MethodGet, indexURL, nil)
 	if err != nil {
 		return nil, err
@@ -3074,7 +3434,7 @@ func fetchDriverReleaseByURL(apiURL string) (*githubRelease, error) {
 		return nil, fmt.Errorf("API 地址为空")
 	}
 
-	client := &http.Client{Timeout: driverReleaseAssetSizeProbeTimeout}
+	client := newHTTPClientWithGlobalProxy(driverReleaseAssetSizeProbeTimeout)
 	req, err := http.NewRequest(http.MethodGet, urlText, nil)
 	if err != nil {
 		return nil, err

internal/app/methods_file.go

@@ -701,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, "]", "]]")
@@ -950,6 +950,15 @@ func buildListViewQueries(config connection.ConnectionConfig, dbName string) []s
 		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{
@@ -1070,6 +1079,18 @@ WHERE s.name = '%s' AND v.name = '%s'`,
 			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{
@@ -1270,7 +1291,7 @@ func dumpTableSQL(
 				createSQL = ddl
 			}
 		} else {
-			ddl, err := dbInst.GetCreateStatement(schemaName, pureTableName)
+			ddl, err := resolveCreateStatementWithFallback(dbInst, config, dbName, tableName)
 			if err != nil {
 				if viewDDL, ok := tryGetViewCreateStatement(dbInst, config, dbName, schemaName, pureTableName); ok {
 					createSQL = viewDDL

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"

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

internal/app/methods_update.go

@@ -374,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
@@ -451,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
@@ -522,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

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"
+	}
+}

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

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

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

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

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

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

internal/redis/redis_impl.go

@@ -28,6 +28,11 @@ const (
 	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
@@ -110,21 +115,41 @@ 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
@@ -143,14 +168,14 @@ func (r *RedisClientImpl) ScanKeys(pattern string, cursor uint64, count int64) (
 
 		currentCursor = nextCursor
 		round++
-		if currentCursor == 0 || round >= redisScanMaxRounds {
+		if currentCursor == 0 || round >= maxRounds {
 			break
 		}
 	}
 
 	return &RedisScanResult{
 		Keys:   r.loadRedisKeyInfos(ctx, keys),
-		Cursor: currentCursor,
+		Cursor: strconv.FormatUint(currentCursor, 10),
 	}, nil
 }