@harneon-ai/db 0.0.1 → 0.0.3

package/dist/db/metadata-queries.js

@@ -14,10 +14,10 @@
  */
 /** 列出指定 schema 下的所有用户表和视图 */
 export async function listTables(pool, schema = 'public') {
-    const result = await pool.query(`SELECT table_name, table_type
-     FROM information_schema.tables
-     WHERE table_schema = $1
-       AND table_type IN ('BASE TABLE', 'VIEW')
+    const result = await pool.query(`SELECT table_name, table_type
+     FROM information_schema.tables
+     WHERE table_schema = $1
+       AND table_type IN ('BASE TABLE', 'VIEW')
      ORDER BY table_name`, [schema]);
     return result.rows;
 }
@@ -29,20 +29,20 @@ export async function listTables(pool, schema = 'public') {
  * - pg_description 通过 objoid + objsubid(列序号) 关联到列注释
  */
 export async function describeTable(pool, tableName, schema = 'public') {
-    const result = await pool.query(`SELECT
-       c.column_name,
-       c.data_type,
-       c.is_nullable,
-       c.column_default,
-       c.character_maximum_length,
-       c.ordinal_position,
-       pgd.description AS comment
-     FROM information_schema.columns c
-     LEFT JOIN pg_catalog.pg_statio_all_tables st
-       ON st.schemaname = c.table_schema AND st.relname = c.table_name
-     LEFT JOIN pg_catalog.pg_description pgd
-       ON pgd.objoid = st.relid AND pgd.objsubid = c.ordinal_position
-     WHERE c.table_schema = $1 AND c.table_name = $2
+    const result = await pool.query(`SELECT
+       c.column_name,
+       c.data_type,
+       c.is_nullable,
+       c.column_default,
+       c.character_maximum_length,
+       c.ordinal_position,
+       pgd.description AS comment
+     FROM information_schema.columns c
+     LEFT JOIN pg_catalog.pg_statio_all_tables st
+       ON st.schemaname = c.table_schema AND st.relname = c.table_name
+     LEFT JOIN pg_catalog.pg_description pgd
+       ON pgd.objoid = st.relid AND pgd.objsubid = c.ordinal_position
+     WHERE c.table_schema = $1 AND c.table_name = $2
      ORDER BY c.ordinal_position`, [schema, tableName]);
     return result.rows;
 }
@@ -56,38 +56,38 @@ export async function describeTable(pool, tableName, schema = 'public') {
  * - pg_attribute: 索引包含的列名
  */
 export async function describeIndexes(pool, tableName, schema = 'public') {
-    const result = await pool.query(`SELECT
-       i.relname AS index_name,
-       pg_get_indexdef(i.oid) AS index_definition,
-       ix.indisunique AS is_unique,
-       am.amname AS index_method,
-       array_to_string(ARRAY(
-         SELECT a.attname
-         FROM pg_catalog.pg_attribute a
-         WHERE a.attrelid = i.oid
-         ORDER BY a.attnum
-       ), ', ') AS index_columns
-     FROM pg_catalog.pg_index ix
-     JOIN pg_catalog.pg_class t ON t.oid = ix.indrelid
-     JOIN pg_catalog.pg_class i ON i.oid = ix.indexrelid
-     JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace
-     JOIN pg_catalog.pg_am am ON am.oid = i.relam
-     WHERE n.nspname = $1 AND t.relname = $2
+    const result = await pool.query(`SELECT
+       i.relname AS index_name,
+       pg_get_indexdef(i.oid) AS index_definition,
+       ix.indisunique AS is_unique,
+       am.amname AS index_method,
+       array_to_string(ARRAY(
+         SELECT a.attname
+         FROM pg_catalog.pg_attribute a
+         WHERE a.attrelid = i.oid
+         ORDER BY a.attnum
+       ), ', ') AS index_columns
+     FROM pg_catalog.pg_index ix
+     JOIN pg_catalog.pg_class t ON t.oid = ix.indrelid
+     JOIN pg_catalog.pg_class i ON i.oid = ix.indexrelid
+     JOIN pg_catalog.pg_namespace n ON n.oid = t.relnamespace
+     JOIN pg_catalog.pg_am am ON am.oid = i.relam
+     WHERE n.nspname = $1 AND t.relname = $2
      ORDER BY i.relname`, [schema, tableName]);
     return result.rows;
 }
 /** 查询表的约束信息（主键、外键、唯一约束） */
 export async function getTableConstraints(pool, tableName, schema = 'public') {
-    const result = await pool.query(`SELECT
-       tc.constraint_name,
-       tc.constraint_type,
-       string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) AS columns
-     FROM information_schema.table_constraints tc
-     JOIN information_schema.key_column_usage kcu
-       ON tc.constraint_name = kcu.constraint_name
-       AND tc.table_schema = kcu.table_schema
-     WHERE tc.table_schema = $1 AND tc.table_name = $2
-     GROUP BY tc.constraint_name, tc.constraint_type
+    const result = await pool.query(`SELECT
+       tc.constraint_name,
+       tc.constraint_type,
+       string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) AS columns
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     WHERE tc.table_schema = $1 AND tc.table_name = $2
+     GROUP BY tc.constraint_name, tc.constraint_type
      ORDER BY tc.constraint_type, tc.constraint_name`, [schema, tableName]);
     return result.rows;
 }
@@ -100,14 +100,14 @@ export async function getTableConstraints(pool, tableName, schema = 'public') {
  * @returns 表统计信息，表不存在时返回 null
  */
 export async function getTableStats(pool, tableName, schema = 'public') {
-    const result = await pool.query(`SELECT
-       s.n_live_tup AS estimated_rows,
-       pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
-       pg_size_pretty(pg_table_size(c.oid)) AS table_size,
-       pg_size_pretty(pg_indexes_size(c.oid)) AS index_size
-     FROM pg_catalog.pg_stat_user_tables s
-     JOIN pg_catalog.pg_class c ON c.relname = s.relname
-     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace AND n.nspname = s.schemaname
+    const result = await pool.query(`SELECT
+       s.n_live_tup AS estimated_rows,
+       pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+       pg_size_pretty(pg_table_size(c.oid)) AS table_size,
+       pg_size_pretty(pg_indexes_size(c.oid)) AS index_size
+     FROM pg_catalog.pg_stat_user_tables s
+     JOIN pg_catalog.pg_class c ON c.relname = s.relname
+     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace AND n.nspname = s.schemaname
      WHERE s.schemaname = $1 AND s.relname = $2`, [schema, tableName]);
     return result.rows[0] ?? null;
 }

package/dist/db/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 数据库抽象层共享类型定义
+ *
+ * 本文件定义了驱动抽象体系中的核心类型，使上层代码（工具层、连接管理器）
+ * 与具体数据库实现解耦。
+ *
+ * 类型体系:
+ * - DatabaseConnection: 统一的数据库连接抽象，屏蔽 pg.Pool / mysql2.Pool 等差异
+ * - QueryResult: 统一的查询结果格式
+ * - DriverConnectionConfig: 驱动创建连接时需要的配置参数
+ * - ConnectionParams: 从 JDBC URL 解析出的连接参数
+ * - 元数据类型（TableInfo、ColumnInfo 等）: 各驱动的元数据查询返回统一的结构
+ */
+/** information_schema.tables 查询结果 */
+export interface TableInfo {
+    table_name: string;
+    table_type: string;
+}
+/** 列信息查询结果（含列注释） */
+export interface ColumnInfo {
+    column_name: string;
+    data_type: string;
+    is_nullable: string;
+    column_default: string | null;
+    character_maximum_length: number | null;
+    comment: string | null;
+    ordinal_position: number;
+}
+/** 索引信息查询结果 */
+export interface IndexInfo {
+    index_name: string;
+    index_columns: string;
+    is_unique: boolean;
+    index_method: string;
+    index_definition: string;
+}
+/** 约束信息查询结果 */
+export interface ConstraintInfo {
+    constraint_name: string;
+    constraint_type: string;
+    columns: string;
+}
+/**
+ * 表统计信息查询结果
+ *
+ * 注意: estimated_rows 在不同数据库中精度不同:
+ * - PostgreSQL: 基于 pg_stat_user_tables.n_live_tup（ANALYZE 后相对准确）
+ * - MySQL: 基于 information_schema.TABLES.TABLE_ROWS（InnoDB 为粗略估算）
+ */
+export interface TableStats {
+    estimated_rows: number;
+    total_size: string;
+    table_size: string;
+    index_size: string;
+}
+/**
+ * 统一的数据库连接抽象
+ *
+ * 工具层只需要 query 和 end 两个能力，保持最小抽象。
+ * 具体的连接池管理（最大连接数、超时等）由各驱动内部处理。
+ */
+export interface DatabaseConnection {
+    query<T>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    end(): Promise<void>;
+}
+/** 统一的查询结果格式 */
+export interface QueryResult<T = Record<string, unknown>> {
+    rows: T[];
+    rowCount: number | null;
+}
+/**
+ * 驱动创建连接时需要的配置参数
+ *
+ * 对应 YAML 配置中单个数据源的连接信息。
+ * host/port/database 由驱动从 JDBC URL 解析得出。
+ */
+export interface DriverConnectionConfig {
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+}
+/**
+ * 从 JDBC URL 解析出的连接参数
+ *
+ * 各驱动实现自己的 parseJdbcUrl()，因为不同数据库的 JDBC URL 格式不同:
+ * - PostgreSQL: jdbc:postgresql://host:port/database
+ * - MySQL: jdbc:mysql://host:port/database
+ */
+export interface ConnectionParams {
+    host: string;
+    port: number;
+    database: string;
+}

package/dist/db/types.js

@@ -0,0 +1,14 @@
+/**
+ * 数据库抽象层共享类型定义
+ *
+ * 本文件定义了驱动抽象体系中的核心类型，使上层代码（工具层、连接管理器）
+ * 与具体数据库实现解耦。
+ *
+ * 类型体系:
+ * - DatabaseConnection: 统一的数据库连接抽象，屏蔽 pg.Pool / mysql2.Pool 等差异
+ * - QueryResult: 统一的查询结果格式
+ * - DriverConnectionConfig: 驱动创建连接时需要的配置参数
+ * - ConnectionParams: 从 JDBC URL 解析出的连接参数
+ * - 元数据类型（TableInfo、ColumnInfo 等）: 各驱动的元数据查询返回统一的结构
+ */
+export {};

package/dist/index.d.ts

@@ -4,20 +4,21 @@
  *
  * 架构概述:
  * - 本项目是一个 MCP (Model Context Protocol) Server，通过 stdio 传输与 AI 客户端（如 Claude Desktop/Claude Code）通信
- * - 提供只读的 PostgreSQL 数据库元数据查询能力，支持 ShardingSphere 风格的分片拓扑解析
- * - 配置文件采用 YAML 格式，兼容 ShardingSphere 配置，管理多个数据源和分片规则
+ * - 提供只读的数据库元数据查询能力（支持 PostgreSQL、MySQL 等），支持 ShardingSphere 风格的分片拓扑解析
+ * - 配置采用多文件 YAML 格式，由 ConfigManager 统一管理，支持从旧版单文件自动迁移
  *
  * 安全策略（多层防御）:
- * 1. 连接级别: pg.Pool 设置 default_transaction_read_only=on，数据库层面禁止写操作
- * 2. SQL 级别: query_metadata tool 仅允许查询 information_schema/pg_catalog 的 SELECT 语句
+ * 1. 连接级别: 各数据库驱动在连接创建时强制只读模式，数据库层面禁止写操作
+ * 2. SQL 级别: query_metadata tool 通过驱动的 validateMetadataQuery() 验证 SQL 安全性
  * 3. Tool 级别: 所有预定义 tool 只执行固定的元数据查询 SQL
  *
  * 模块结构:
- * - src/config/  — 配置类型定义(types.ts)和 YAML 解析器(parser.ts)
- * - src/db/      — 数据库连接池管理(connection-manager.ts)和元数据查询封装(metadata-queries.ts)
- * - src/tools/   — 8 个 MCP Tool 的实现，每个 tool 一个文件
+ * - src/config/  — 配置类型定义(types.ts)、YAML 解析器(parser.ts)、配置管理器(config-manager.ts)
+ * - src/db/      — 驱动抽象(driver.ts/types.ts)、驱动注册(driver-registry.ts)、驱动实现(drivers/)、连接管理(connection-manager.ts)
+ * - src/tools/   — MCP Tool 的实现，每个 tool 一个文件
  *
  * 启动流程:
- * 1. 读取 YAML 配置文件 → 2. 创建 ConnectionManager → 3. 注册 MCP Tools → 4. 启动 stdio 传输
+ * 1. 初始化 ConfigManager → 2. 迁移旧版配置 → 3. 加载所有配置文件
+ * → 4. 创建 ConnectionManager → 5. 注册 MCP Tools → 6. 启动 stdio 传输
  */
 export {};

package/dist/index.js

@@ -4,28 +4,28 @@
  *
  * 架构概述:
  * - 本项目是一个 MCP (Model Context Protocol) Server，通过 stdio 传输与 AI 客户端（如 Claude Desktop/Claude Code）通信
- * - 提供只读的 PostgreSQL 数据库元数据查询能力，支持 ShardingSphere 风格的分片拓扑解析
- * - 配置文件采用 YAML 格式，兼容 ShardingSphere 配置，管理多个数据源和分片规则
+ * - 提供只读的数据库元数据查询能力（支持 PostgreSQL、MySQL 等），支持 ShardingSphere 风格的分片拓扑解析
+ * - 配置采用多文件 YAML 格式，由 ConfigManager 统一管理，支持从旧版单文件自动迁移
  *
  * 安全策略（多层防御）:
- * 1. 连接级别: pg.Pool 设置 default_transaction_read_only=on，数据库层面禁止写操作
- * 2. SQL 级别: query_metadata tool 仅允许查询 information_schema/pg_catalog 的 SELECT 语句
+ * 1. 连接级别: 各数据库驱动在连接创建时强制只读模式，数据库层面禁止写操作
+ * 2. SQL 级别: query_metadata tool 通过驱动的 validateMetadataQuery() 验证 SQL 安全性
  * 3. Tool 级别: 所有预定义 tool 只执行固定的元数据查询 SQL
  *
  * 模块结构:
- * - src/config/  — 配置类型定义(types.ts)和 YAML 解析器(parser.ts)
- * - src/db/      — 数据库连接池管理(connection-manager.ts)和元数据查询封装(metadata-queries.ts)
- * - src/tools/   — 8 个 MCP Tool 的实现，每个 tool 一个文件
+ * - src/config/  — 配置类型定义(types.ts)、YAML 解析器(parser.ts)、配置管理器(config-manager.ts)
+ * - src/db/      — 驱动抽象(driver.ts/types.ts)、驱动注册(driver-registry.ts)、驱动实现(drivers/)、连接管理(connection-manager.ts)
+ * - src/tools/   — MCP Tool 的实现，每个 tool 一个文件
  *
  * 启动流程:
- * 1. 读取 YAML 配置文件 → 2. 创建 ConnectionManager → 3. 注册 MCP Tools → 4. 启动 stdio 传输
+ * 1. 初始化 ConfigManager → 2. 迁移旧版配置 → 3. 加载所有配置文件
+ * → 4. 创建 ConnectionManager → 5. 注册 MCP Tools → 6. 启动 stdio 传输
  */
-import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { parseConfig } from './config/parser.js';
+import { ConfigManager } from './config/config-manager.js';
 import { ConnectionManager } from './db/connection-manager.js';
 import { registerListDatasources } from './tools/list-datasources.js';
 import { registerListTables } from './tools/list-tables.js';
@@ -35,20 +35,21 @@ import { registerShardingTopology } from './tools/sharding-topology.js';
 import { registerQueryMetadata } from './tools/query-metadata.js';
 import { registerTestConnection } from './tools/test-connection.js';
 import { registerSaveDatasourceConfig } from './tools/save-datasource-config.js';
+import { registerDeleteDatasourceConfig } from './tools/delete-datasource-config.js';
+import { registerUpdateDatasourceConfig } from './tools/update-datasource-config.js';
 async function main() {
-    // 配置文件路径优先级: 命令行参数 > 环境变量 > 默认路径
-    // 全局安装时默认配置路径为 ~/.harneon-ai/db/datasource.yaml，与 npm 组织名 @harneon-ai 一致
-    const defaultConfigPath = path.join(os.homedir(), '.harneon-ai', 'db', 'datasource.yaml');
-    const configPath = process.argv[2] || process.env.DB_CONFIG_PATH || defaultConfigPath;
-    // 容错启动: 配置文件不存在时使用空配置，允许用户通过 save_datasource_config 创建首份配置
-    let config;
-    if (fs.existsSync(configPath)) {
-        config = parseConfig(configPath);
-    }
-    else {
-        config = { dataSources: {} };
-        console.error(`配置文件 ${configPath} 不存在，使用空配置启动。可通过 save_datasource_config 工具创建配置。`);
-    }
+    // 配置目录和旧版配置文件路径
+    const defaultConfigDir = path.join(os.homedir(), '.harneon-ai', 'db', 'configs');
+    const legacyConfigPath = path.join(os.homedir(), '.harneon-ai', 'db', 'datasource.yaml');
+    // 支持命令行参数或环境变量指定配置目录
+    const configDir = process.argv[2] || process.env.DB_CONFIG_DIR || defaultConfigDir;
+    const configManager = new ConfigManager(configDir);
+    // 自动迁移旧版单文件配置到新的多文件格式
+    const legacyPath = process.env.DB_CONFIG_PATH || legacyConfigPath;
+    configManager.migrateFromLegacy(legacyPath);
+    // 加载配置目录下的所有数据库配置文件
+    configManager.loadAll();
+    const config = configManager.combinedConfig;
     // ConnectionManager 采用懒初始化策略，此时不会创建任何数据库连接
     const connectionManager = new ConnectionManager(config);
     const server = new McpServer({
@@ -63,18 +64,22 @@ async function main() {
     // - describe_indexes: 查询表的索引信息
     // - sharding_topology: 查看分片拓扑（纯配置解析，不连接数据库）
     // - query_metadata: 执行自定义元数据查询（带安全过滤）
-    // 数据源注册工具:
-    // - test_connection: 测试 PostgreSQL 连接（独立于配置和连接池）
+    // 数据源配置管理工具:
+    // - test_connection: 测试数据库连接（独立于配置和连接池，自动检测数据库类型）
     // - save_datasource_config: 保存数据源配置到 YAML 文件并更新内存状态
-    registerListDatasources(server, config, connectionManager);
+    // - delete_datasource_config: 两步确认删除数据源配置（含磁盘文件和内存状态）
+    // - update_datasource_config: 按类别更新数据源配置（基本信息/连接/凭据/数据源增删）
+    registerListDatasources(server, config, connectionManager, configManager);
     registerListTables(server, config, connectionManager);
     registerDescribeTable(server, config, connectionManager);
     registerDescribeIndexes(server, config, connectionManager);
     registerShardingTopology(server, config, connectionManager);
     registerQueryMetadata(server, config, connectionManager);
     registerTestConnection(server);
-    registerSaveDatasourceConfig(server, config, connectionManager, configPath);
-    // 优雅退出: 收到终止信号时关闭所有数据库连接池
+    registerSaveDatasourceConfig(server, config, connectionManager, configManager);
+    registerDeleteDatasourceConfig(server, configManager, connectionManager);
+    registerUpdateDatasourceConfig(server, configManager, connectionManager);
+    // 优雅退出: 收到终止信号时关闭所有数据库连接
     const shutdown = async () => {
         await connectionManager.shutdown();
         process.exit(0);

package/dist/tools/delete-datasource-config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * MCP Tool: delete_datasource_config
+ *
+ * 删除数据库配置文件，采用两步确认码机制防止误删:
+ * - 第一次调用（不传 confirmationCode）: 返回配置概要和 6 位确认码
+ * - 第二次调用（传入 confirmationCode）: 验证确认码并执行删除
+ * 确认码 1 小时内有效，使用即作废
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { ConfigManager } from '../config/config-manager.js';
+import { ConnectionManager } from '../db/connection-manager.js';
+export declare function registerDeleteDatasourceConfig(server: McpServer, configManager: ConfigManager, connectionManager: ConnectionManager): void;

package/dist/tools/delete-datasource-config.js

@@ -0,0 +1,75 @@
+/**
+ * MCP Tool: delete_datasource_config
+ *
+ * 删除数据库配置文件，采用两步确认码机制防止误删:
+ * - 第一次调用（不传 confirmationCode）: 返回配置概要和 6 位确认码
+ * - 第二次调用（传入 confirmationCode）: 验证确认码并执行删除
+ * 确认码 1 小时内有效，使用即作废
+ */
+import { z } from 'zod';
+export function registerDeleteDatasourceConfig(server, configManager, connectionManager) {
+    server.tool('delete_datasource_config', '删除数据库配置。首次调用返回确认码，再次调用传入确认码执行删除。', {
+        name: z.string().min(1).describe('要删除的数据库配置名称'),
+        confirmationCode: z.string().optional().describe('确认码（第二次调用时传入）'),
+    }, async (params) => {
+        try {
+            if (!params.confirmationCode) {
+                // 第一步: 展示配置概要并生成确认码
+                const dbConfig = configManager.getConfig(params.name);
+                if (!dbConfig) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: `配置 "${params.name}" 不存在`,
+                                    availableConfigs: configManager.listConfigs().map(c => c.name),
+                                }),
+                            }],
+                    };
+                }
+                const code = configManager.requestDelete(params.name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                step: 'confirmation_required',
+                                confirmationCode: code,
+                                configName: params.name,
+                                description: dbConfig.description ?? '',
+                                datasources: Object.keys(dbConfig.dataSources),
+                                message: `即将删除配置 "${params.name}"，包含 ${Object.keys(dbConfig.dataSources).length} 个数据源。请使用确认码 ${code} 再次调用此工具确认删除。确认码 1 小时内有效。`,
+                            }),
+                        }],
+                };
+            }
+            else {
+                // 第二步: 验证确认码并执行删除
+                const deleted = configManager.confirmDelete(params.name, params.confirmationCode);
+                await connectionManager.reloadConfig();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                step: 'deleted',
+                                configName: deleted.name,
+                                deletedDatasources: Object.keys(deleted.dataSources),
+                                remainingConfigs: configManager.listConfigs().map(c => c.name),
+                            }),
+                        }],
+                };
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: errorMessage }),
+                    }],
+            };
+        }
+    });
+}

package/dist/tools/describe-indexes.d.ts

@@ -2,7 +2,7 @@
  * MCP Tool: describe_indexes
  *
  * 查询指定表的所有索引信息。
- * 通过 pg_catalog 系统表查询，返回索引名称、包含列、唯一性、索引方法（btree/hash/gin 等）
+ * 通过驱动抽象层查询，返回索引名称、包含列、唯一性、索引方法
  * 以及完整的 CREATE INDEX 语句定义。
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';

package/dist/tools/describe-indexes.js

@@ -2,20 +2,22 @@
  * MCP Tool: describe_indexes
  *
  * 查询指定表的所有索引信息。
- * 通过 pg_catalog 系统表查询，返回索引名称、包含列、唯一性、索引方法（btree/hash/gin 等）
+ * 通过驱动抽象层查询，返回索引名称、包含列、唯一性、索引方法
  * 以及完整的 CREATE INDEX 语句定义。
  */
 import { z } from 'zod';
-import { describeIndexes } from '../db/metadata-queries.js';
 export function registerDescribeIndexes(server, _config, connectionManager) {
     server.tool('describe_indexes', '查询指定表的所有索引信息', {
         datasource: z.string().describe('数据源名称'),
         table: z.string().describe('表名'),
-        schema: z.string().optional().default('public').describe('Schema 名称，默认 public'),
+        schema: z.string().optional().default('public').describe('Schema 名称（PostgreSQL 默认 public，MySQL 中对应 database 名，留空使用连接默认值）'),
     }, async ({ datasource, table, schema }) => {
         try {
-            const pool = await connectionManager.getPool(datasource);
-            const indexes = await describeIndexes(pool, table, schema);
+            const [conn, driver] = await Promise.all([
+                connectionManager.getConnection(datasource),
+                connectionManager.getDriver(datasource),
+            ]);
+            const indexes = await driver.describeIndexes(conn, table, schema);
             return {
                 content: [{
                         type: 'text',

package/dist/tools/describe-table.d.ts

@@ -7,6 +7,7 @@
  * - stats: 统计信息（行数估算、表大小、索引大小）
  *
  * 三个查询并行执行以减少延迟。
+ * 通过驱动抽象层查询，支持不同数据库类型。
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ParsedConfig } from '../config/types.js';

package/dist/tools/describe-table.js

@@ -7,22 +7,25 @@
  * - stats: 统计信息（行数估算、表大小、索引大小）
  *
  * 三个查询并行执行以减少延迟。
+ * 通过驱动抽象层查询，支持不同数据库类型。
  */
 import { z } from 'zod';
-import { describeTable, getTableConstraints, getTableStats } from '../db/metadata-queries.js';
 export function registerDescribeTable(server, _config, connectionManager) {
     server.tool('describe_table', '查询指定表的详细结构（列信息、约束、统计）', {
         datasource: z.string().describe('数据源名称'),
         table: z.string().describe('表名'),
-        schema: z.string().optional().default('public').describe('Schema 名称，默认 public'),
+        schema: z.string().optional().default('public').describe('Schema 名称（PostgreSQL 默认 public，MySQL 中对应 database 名，留空使用连接默认值）'),
     }, async ({ datasource, table, schema }) => {
         try {
-            const pool = await connectionManager.getPool(datasource);
+            const [conn, driver] = await Promise.all([
+                connectionManager.getConnection(datasource),
+                connectionManager.getDriver(datasource),
+            ]);
             // 并行查询列信息、约束和统计，减少总延迟
             const [columns, constraints, stats] = await Promise.all([
-                describeTable(pool, table, schema),
-                getTableConstraints(pool, table, schema),
-                getTableStats(pool, table, schema),
+                driver.describeTable(conn, table, schema),
+                driver.getTableConstraints(conn, table, schema),
+                driver.getTableStats(conn, table, schema),
             ]);
             const result = { columns, constraints, stats };
             return {

package/dist/tools/list-datasources.d.ts

@@ -1,11 +1,12 @@
 /**
  * MCP Tool: list_datasources
  *
- * 列出所有已配置的数据源连接信息。
+ * 列出所有已配置的数据源连接信息，包括数据源所属的配置文件信息。
  * 这是一个纯配置读取操作，不连接任何数据库。
  * 密码字段始终显示为 '***'，防止敏感信息泄露。
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ParsedConfig } from '../config/types.js';
 import { type ConnectionManager } from '../db/connection-manager.js';
-export declare function registerListDatasources(server: McpServer, config: ParsedConfig, _connectionManager: ConnectionManager): void;
+import { type ConfigManager } from '../config/config-manager.js';
+export declare function registerListDatasources(server: McpServer, config: ParsedConfig, _connectionManager: ConnectionManager, configManager?: ConfigManager): void;

package/dist/tools/list-datasources.js

@@ -1,19 +1,22 @@
 /**
  * MCP Tool: list_datasources
  *
- * 列出所有已配置的数据源连接信息。
+ * 列出所有已配置的数据源连接信息，包括数据源所属的配置文件信息。
  * 这是一个纯配置读取操作，不连接任何数据库。
  * 密码字段始终显示为 '***'，防止敏感信息泄露。
  */
-import { parseJdbcUrl } from '../config/parser.js';
-export function registerListDatasources(server, config, _connectionManager) {
-    server.tool('list_datasources', '列出所有配置的数据源信息（密码已隐藏）', {}, // 无输入参数
+import { detectDriverType, getDriver } from '../db/driver-registry.js';
+export function registerListDatasources(server, config, _connectionManager, configManager) {
+    server.tool('list_datasources', '列出所有配置的数据源信息，包括所属配置及配置概览（密码已隐藏）', {}, // 无输入参数
     async () => {
-        const datasources = Object.entries(config.dataSources).map(([name, ds]) => {
+        const datasources = await Promise.all(Object.entries(config.dataSources).map(async ([name, ds]) => {
             const jdbcUrl = ds.jdbcUrl || ds.url || '';
             let host = '', port = 0, database = '';
+            let driverType = '';
             try {
-                const parsed = parseJdbcUrl(jdbcUrl);
+                driverType = ds['driverType'] || detectDriverType(jdbcUrl);
+                const driver = await getDriver(driverType);
+                const parsed = driver.parseJdbcUrl(jdbcUrl);
                 host = parsed.host;
                 port = parsed.port;
                 database = parsed.database;
@@ -23,17 +26,25 @@ export function registerListDatasources(server, config, _connectionManager) {
             }
             return {
                 name,
+                configName: configManager?.getConfigNameByDatasource(name) ?? 'unknown',
+                driverType,
                 host,
                 port,
                 database,
                 username: ds.username,
                 password: '***', // 安全: 始终隐藏密码
             };
-        });
+        }));
+        // 配置概览：列出所有数据库配置及其包含的数据源数量
+        const configs = configManager?.listConfigs().map(c => ({
+            name: c.name,
+            description: c.description ?? '',
+            datasourceCount: Object.keys(c.dataSources).length,
+        })) ?? [];
         return {
             content: [{
                     type: 'text',
-                    text: JSON.stringify(datasources, null, 2),
+                    text: JSON.stringify({ configs, datasources }, null, 2),
                 }],
         };
     });

package/dist/tools/list-tables.d.ts

@@ -2,7 +2,7 @@
  * MCP Tool: list_tables
  *
  * 列出指定数据源中的所有用户表和视图。
- * 查询 information_schema.tables，仅返回 BASE TABLE 和 VIEW 类型。
+ * 通过驱动抽象层查询，支持不同数据库类型（PostgreSQL、MySQL 等）。
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ParsedConfig } from '../config/types.js';