@cmd233/mcp-database-server 1.1.7 → 1.3.0

package/{readme.md → README.md}

@@ -105,6 +105,8 @@ node dist/src/index.js --mysql --host <host-name> --database <database-name> --p
 必需参数:
 - `--host`: MySQL 主机名或 IP 地址
 - `--database`: 数据库名称
+
+可选参数:
 - `--port`: 端口号(默认: 3306)
 
 可选参数:
@@ -285,15 +287,18 @@ MCP 数据库服务器提供以下可供 Claude 使用的工具:
 | 工具 | 描述 | 必需参数 |
 |------|-------------|---------------------|
 | `read_query` | 执行 SELECT 查询以读取数据 | `query`: SQL SELECT 语句 |
-| `write_query` | 执行 INSERT、UPDATE 或 DELETE 查询 | `query`: SQL 修改语句 |
-| `create_table` | 在数据库中创建新表 | `query`: CREATE TABLE 语句 |
-| `alter_table` | 修改现有表架构 | `query`: ALTER TABLE 语句 |
+| `write_query` | 执行 INSERT、UPDATE、DELETE 或 TRUNCATE 查询 | `query`: SQL 修改语句<br>`confirm`: 安全标志(必须为 true) |
+| `create_table` | 在数据库中创建新表 | `query`: CREATE TABLE 语句<br>`confirm`: 安全标志(必须为 true) |
+| `alter_table` | 修改现有表架构 | `query`: ALTER TABLE 语句<br>`confirm`: 安全标志(必须为 true) |
 | `drop_table` | 从数据库中删除表 | `table_name`: 表名<br>`confirm`: 安全标志(必须为 true) |
 | `list_tables` | 获取所有表的列表 | 无 |
 | `describe_table` | 查看表的架构信息 | `table_name`: 表名 |
 | `export_query` | 将查询结果导出为 CSV/JSON | `query`: SQL SELECT 语句<br>`format`: "csv" 或 "json" |
-| `append_insight` | 添加业务洞察到备忘录 | `insight`: 洞察文本 |
-| `list_insights` | 列出所有业务洞察 | 无 |
+| `append_insight` | 添加业务洞察到备忘录 (**仅 SQLite**) | `insight`: 洞察文本<br>`confirm`: 安全标志(必须为 true) |
+| `list_insights` | 列出所有业务洞察 (**仅 SQLite**) | 无 |
+| `list_views` | 列出所有视图 (**仅 SQL Server**) | 无 |
+| `describe_view` | 获取视图结构 (**仅 SQL Server**) | `view_name`: 视图名 |
+| `get_view_definition` | 获取视图定义 SQL (**仅 SQL Server**) | `view_name`: 视图名 |
 
 有关如何在 Claude 中使用这些工具的实际示例,请参阅[使用示例](docs/usage-examples.md)。
 

package/dist/src/db/index.js

@@ -93,3 +93,95 @@ export function getDescribeTableQuery(tableName) {
     }
     return dbAdapter.getDescribeTableQuery(tableName);
 }
+/**
+ * 获取列出视图的数据库特定查询
+ * 仅 SQL Server 支持
+ * @returns SQL 查询字符串
+ * @throws 如果数据库不支持视图功能
+ */
+export function getListViewsQuery() {
+    if (!dbAdapter) {
+        throw new Error("数据库未初始化");
+    }
+    if (dbAdapter.getListViewsQuery) {
+        return dbAdapter.getListViewsQuery();
+    }
+    // 统一错误处理策略：不支持视图时抛出明确错误
+    throw new Error("当前数据库不支持视图功能");
+}
+/**
+ * 获取视图定义的数据库特定查询
+ * 仅 SQL Server 支持
+ * @param viewName 视图名
+ */
+export function getViewDefinitionQuery(viewName) {
+    if (!dbAdapter) {
+        throw new Error("数据库未初始化");
+    }
+    if (dbAdapter.getViewDefinitionQuery) {
+        return dbAdapter.getViewDefinitionQuery(viewName);
+    }
+    throw new Error("当前数据库不支持视图功能");
+}
+/**
+ * 检查数据库是否支持视图功能
+ */
+export function supportsViews() {
+    if (!dbAdapter) {
+        return false;
+    }
+    return dbAdapter.supportsViews ? dbAdapter.supportsViews() : false;
+}
+/**
+ * 检查存储过程功能是否可用
+ * @returns 可用的数据库适配器
+ * @throws 如果数据库未初始化或不支持存储过程功能
+ */
+function requireProcedureSupport() {
+    if (!dbAdapter) {
+        throw new Error('数据库未初始化');
+    }
+    if (!dbAdapter.getListProceduresQuery) {
+        throw new Error('当前数据库不支持存储过程功能');
+    }
+    return dbAdapter;
+}
+/**
+ * 获取列出存储过程的查询
+ * 仅 SQL Server 支持
+ * @returns SQL 查询字符串
+ * @throws 如果数据库不支持存储过程功能
+ */
+export function getListProceduresQuery() {
+    return requireProcedureSupport().getListProceduresQuery();
+}
+/**
+ * 获取存储过程参数信息的查询
+ * 仅 SQL Server 支持
+ * @param procedureName 存储过程名
+ * @returns SQL 查询字符串
+ * @throws 如果数据库不支持存储过程功能
+ */
+export function getDescribeProcedureQuery(procedureName) {
+    return requireProcedureSupport().getDescribeProcedureQuery(procedureName);
+}
+/**
+ * 获取存储过程定义的查询
+ * 仅 SQL Server 支持
+ * @param procedureName 存储过程名
+ * @returns SQL 查询字符串
+ * @throws 如果数据库不支持存储过程功能
+ */
+export function getProcedureDefinitionQuery(procedureName) {
+    return requireProcedureSupport().getProcedureDefinitionQuery(procedureName);
+}
+/**
+ * 检查数据库是否支持存储过程功能
+ * @returns 如果支持返回 true，否则返回 false
+ */
+export function supportsProcedures() {
+    if (!dbAdapter) {
+        return false;
+    }
+    return dbAdapter.supportsProcedures ? dbAdapter.supportsProcedures() : false;
+}

package/dist/src/db/mysql-adapter.js

@@ -1,3 +1,4 @@
+import { validateForbiddenOperations } from "./sql-validator.js";
 import mysql from "mysql2/promise";
 import { Signer } from "@aws-sdk/rds-signer";
 /**
@@ -55,7 +56,7 @@ export class MysqlAdapter {
             throw new Error("AWS IAM 认证需要 AWS 用户名参数");
         }
         try {
-            console.info(`[INFO] Generating AWS auth token for region: ${this.awsRegion}, host: ${this.host}, user: ${this.config.user}`);
+            console.info(`[INFO] 正在为区域 ${this.awsRegion} 生成 AWS 认证令牌, 主机: ${this.host}, 用户: ${this.config.user}`);
             const signer = new Signer({
                 region: this.awsRegion,
                 hostname: this.host,
@@ -63,7 +64,7 @@ export class MysqlAdapter {
                 username: this.config.user,
             });
             const token = await signer.getAuthToken();
-            console.info(`[INFO] AWS auth token generated successfully`);
+            console.info(`[INFO] AWS 认证令牌生成成功`);
             return token;
         }
         catch (err) {
@@ -76,10 +77,10 @@ export class MysqlAdapter {
      */
     async init() {
         try {
-            console.info(`[INFO] Connecting to MySQL: ${this.host}, Database: ${this.database}`);
+            console.info(`[INFO] 正在连接 MySQL: ${this.host}, 数据库: ${this.database}`);
             // 处理 AWS IAM 认证
             if (this.awsIamAuth) {
-                console.info(`[INFO] Using AWS IAM authentication for user: ${this.config.user}`);
+                console.info(`[INFO] 正在为用户 ${this.config.user} 使用 AWS IAM 认证`);
                 try {
                     const authToken = await this.generateAwsAuthToken();
                     // 使用生成的令牌作为密码创建新配置
@@ -97,10 +98,10 @@ export class MysqlAdapter {
             else {
                 this.connection = await mysql.createConnection(this.config);
             }
-            console.info(`[INFO] MySQL connection established successfully`);
+            console.info(`[INFO] MySQL 连接成功建立`);
         }
         catch (err) {
-            console.error(`[ERROR] MySQL connection error: ${err.message}`);
+            console.error(`[ERROR] MySQL 连接错误: ${err.message}`);
             if (this.awsIamAuth) {
                 throw new Error(`使用 AWS IAM 认证连接 MySQL 失败: ${err.message}。请验证您的 AWS 凭据、IAM 权限和 RDS 配置。`);
             }
@@ -116,6 +117,8 @@ export class MysqlAdapter {
         if (!this.connection) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作（防止恶意查询）
+        validateForbiddenOperations(query);
         try {
             const [rows] = await this.connection.execute(query, params);
             return Array.isArray(rows) ? rows : [];
@@ -131,6 +134,8 @@ export class MysqlAdapter {
         if (!this.connection) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         try {
             const [result] = await this.connection.execute(query, params);
             const changes = result.affectedRows || 0;
@@ -148,6 +153,8 @@ export class MysqlAdapter {
         if (!this.connection) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         try {
             await this.connection.query(query);
         }

package/dist/src/db/postgresql-adapter.js

@@ -1,3 +1,4 @@
+import { validateForbiddenOperations } from "./sql-validator.js";
 import pg from 'pg';
 /**
  * PostgreSQL 数据库适配器实现
@@ -24,7 +25,7 @@ export class PostgresqlAdapter {
      */
     async init() {
         try {
-            console.error(`[INFO] Connecting to PostgreSQL: ${this.host}, Database: ${this.database}`);
+            console.error(`[INFO] 正在连接 PostgreSQL: ${this.host}, 数据库: ${this.database}`);
             console.error(`[DEBUG] Connection details:`, {
                 host: this.host,
                 database: this.database,
@@ -35,10 +36,10 @@ export class PostgresqlAdapter {
             });
             this.client = new pg.Client(this.config);
             await this.client.connect();
-            console.error(`[INFO] PostgreSQL connection established successfully`);
+            console.error(`[INFO] PostgreSQL 连接成功建立`);
         }
         catch (err) {
-            console.error(`[ERROR] PostgreSQL connection error: ${err.message}`);
+            console.error(`[ERROR] PostgreSQL 连接错误: ${err.message}`);
             throw new Error(`连接 PostgreSQL 失败: ${err.message}`);
         }
     }
@@ -52,9 +53,12 @@ export class PostgresqlAdapter {
         if (!this.client) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作（防止恶意查询）
+        validateForbiddenOperations(query);
         try {
             // PostgreSQL 使用 $1, $2 等作为参数化查询的占位符
-            const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
+            let paramIndex = 0;
+            const preparedQuery = query.replace(/\?/g, () => `$${++paramIndex}`);
             const result = await this.client.query(preparedQuery, params);
             return result.rows;
         }
@@ -72,9 +76,12 @@ export class PostgresqlAdapter {
         if (!this.client) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         try {
             // 将 ? 替换为编号参数
-            const preparedQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
+            let paramIndex = 0;
+            const preparedQuery = query.replace(/\?/g, () => `$${++paramIndex}`);
             let lastID = 0;
             let changes = 0;
             // 对于 INSERT 查询,尝试获取插入的 ID
@@ -106,6 +113,8 @@ export class PostgresqlAdapter {
         if (!this.client) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         try {
             await this.client.query(query);
         }

package/dist/src/db/sql-validator.js

@@ -0,0 +1,34 @@
+/**
+ * SQL 操作验证工具
+ * 集中管理禁用的 SQL 操作，确保数据库安全
+ */
+/**
+ * 禁用的 SQL 操作类型及其错误消息
+ * 使用更严格的模式，检测注释后的危险语句
+ */
+const FORBIDDEN_OPERATIONS = [
+    {
+        type: 'DROP',
+        // 匹配 DROP，忽略前导空白和单行注释
+        pattern: /^(\s*|--[^\n]*\n)*DROP\s/i,
+        message: 'DROP 操作已被禁用，此类操作应由 DBA 在数据库层面处理'
+    },
+    {
+        type: 'TRUNCATE',
+        // 匹配 TRUNCATE，忽略前导空白和单行注释
+        pattern: /^(\s*|--[^\n]*\n)*TRUNCATE\s/i,
+        message: 'TRUNCATE 操作已被禁用，因为它不可回滚且不触发触发器'
+    }
+];
+/**
+ * 验证 SQL 查询是否包含禁用的操作
+ * @param query 要验证的 SQL 查询
+ * @throws Error 如果查询包含禁用的操作
+ */
+export function validateForbiddenOperations(query) {
+    for (const { pattern, message } of FORBIDDEN_OPERATIONS) {
+        if (pattern.test(query)) {
+            throw new Error(message);
+        }
+    }
+}

package/dist/src/db/sqlite-adapter.js

@@ -1,4 +1,5 @@
 import sqlite3 from "sqlite3";
+import { validateForbiddenOperations } from "./sql-validator.js";
 /**
  * SQLite 数据库适配器实现
  */
@@ -13,14 +14,14 @@ export class SqliteAdapter {
     async init() {
         return new Promise((resolve, reject) => {
             // 确保数据库路径可访问
-            console.error(`[INFO] Opening SQLite database at: ${this.dbPath}`);
+            console.error(`[INFO] 正在打开 SQLite 数据库: ${this.dbPath}`);
             this.db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, (err) => {
                 if (err) {
-                    console.error(`[ERROR] SQLite connection error: ${err.message}`);
+                    console.error(`[ERROR] SQLite 连接错误: ${err.message}`);
                     reject(err);
                 }
                 else {
-                    console.error("[INFO] SQLite database opened successfully");
+                    console.error("[INFO] SQLite 数据库成功打开");
                     resolve();
                 }
             });
@@ -36,6 +37,8 @@ export class SqliteAdapter {
         if (!this.db) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作（防止恶意查询）
+        validateForbiddenOperations(query);
         return new Promise((resolve, reject) => {
             this.db.all(query, params, (err, rows) => {
                 if (err) {
@@ -57,6 +60,8 @@ export class SqliteAdapter {
         if (!this.db) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         return new Promise((resolve, reject) => {
             this.db.run(query, params, function (err) {
                 if (err) {
@@ -77,6 +82,8 @@ export class SqliteAdapter {
         if (!this.db) {
             throw new Error("数据库未初始化");
         }
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         return new Promise((resolve, reject) => {
             this.db.exec(query, (err) => {
                 if (err) {

package/dist/src/db/sqlserver-adapter.js

@@ -1,4 +1,31 @@
+import { validateForbiddenOperations } from "./sql-validator.js";
 import sql from 'mssql';
+/**
+ * 验证并转义 SQL Server 标识符名称
+ * 防止 SQL 注入攻击
+ * @param name 标识符名称（表名、视图名、存储过程名等）
+ * @returns 转义后的安全标识符
+ * @throws 如果标识符包含非法字符
+ */
+function escapeIdentifier(name) {
+    // 检查名称是否为空
+    if (!name || typeof name !== 'string') {
+        throw new Error('标识符名称不能为空');
+    }
+    // 检查名称长度（SQL Server 限制为 128 字符）
+    if (name.length > 128) {
+        throw new Error('标识符名称长度超过限制（最大 128 字符）');
+    }
+    // 检查是否包含危险的 SQL 字符
+    // 只允许字母、数字、下划线和常见的安全字符
+    const validNamePattern = /^[a-zA-Z_][a-zA-Z0-9_@$#]*$/;
+    if (!validNamePattern.test(name)) {
+        throw new Error(`标识符名称包含非法字符: ${name.substring(0, 20)}...`);
+    }
+    // 使用方括号转义标识符
+    // 方括号内的右方括号需要转义为两个右方括号
+    return `[${name.replace(/]/g, ']]')}]`;
+}
 /**
  * SQL Server 数据库适配器实现
  */
@@ -68,27 +95,27 @@ export class SqlServerAdapter {
                     await this.pool.close();
                 }
                 catch (closeErr) {
-                    console.error(`[WARN] Error closing old connection pool: ${closeErr.message}`);
+                    console.error(`[WARN] 关闭旧连接池时出错: ${closeErr.message}`);
                 }
                 this.pool = null;
             }
-            console.error(`[INFO] Connecting to SQL Server: ${this.server}, Database: ${this.database}`);
+            console.error(`[INFO] 正在连接 SQL Server: ${this.server}, 数据库: ${this.database}`);
             const pool = new sql.ConnectionPool(this.config);
             // 使用单次监听器防止内存泄漏
             pool.once('error', (err) => {
-                console.error(`[ERROR] SQL Server connection pool error: ${err.message}`);
+                console.error(`[ERROR] SQL Server 连接池错误: ${err.message}`);
                 // 标记连接池为不可用，下次查询时会自动重连
                 if (this.pool === pool) {
                     this.pool = null;
                 }
             });
             this.pool = await pool.connect();
-            console.error(`[INFO] SQL Server connection established successfully`);
+            console.error(`[INFO] SQL Server 连接成功建立`);
             return this.pool;
         }
         catch (err) {
             this.pool = null;
-            console.error(`[ERROR] SQL Server connection error: ${err.message}`);
+            console.error(`[ERROR] SQL Server 连接错误: ${err.message}`);
             throw new Error(`连接 SQL Server 失败: ${err.message}`);
         }
         finally {
@@ -139,7 +166,7 @@ export class SqlServerAdapter {
                 // 只有在获取连接池后（即 poolAcquired = true）发生的连接错误才重试
                 // ensureConnection 本身的错误（如认证失败、连接超时）不应重试
                 if (isConnectionError && poolAcquired && attempt < retries && this.pool !== null) {
-                    console.error(`[WARN] Connection error detected, attempting reconnect (attempt ${attempt + 1}/${retries}): ${lastError.message}`);
+                    console.error(`[WARN] 检测到连接错误，正在尝试重新连接 (尝试 ${attempt + 1}/${retries}): ${lastError.message}`);
                     this.pool = null;
                     poolAcquired = false; // 重置标记
                     await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
@@ -163,7 +190,7 @@ export class SqlServerAdapter {
                 await this.pool.close();
             }
             catch (err) {
-                console.error(`[WARN] Error closing connection pool: ${err.message}`);
+                console.error(`[WARN] 关闭连接池时出错: ${err.message}`);
             }
             this.pool = null;
         }
@@ -176,6 +203,8 @@ export class SqlServerAdapter {
      * @returns 包含查询结果的 Promise
      */
     async all(query, params = []) {
+        // 验证禁用的操作（防止恶意查询）
+        validateForbiddenOperations(query);
         return this.executeWithRetry(async (pool) => {
             const request = pool.request();
             // 向请求添加参数
@@ -196,6 +225,8 @@ export class SqlServerAdapter {
      * @returns 包含结果信息的 Promise
      */
     async run(query, params = []) {
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         return this.executeWithRetry(async (pool) => {
             const request = pool.request();
             // 向请求添加参数
@@ -207,17 +238,22 @@ export class SqlServerAdapter {
             const preparedQuery = query.replace(/\?/g, () => `@param${paramIndex++}`);
             // 如果是 INSERT,添加标识值的输出参数
             let lastID = 0;
+            let changes = 0;
             if (query.trim().toUpperCase().startsWith('INSERT')) {
                 request.output('insertedId', sql.Int, 0);
                 const updatedQuery = `${preparedQuery}; SELECT @insertedId = SCOPE_IDENTITY();`;
                 const result = await request.query(updatedQuery);
                 lastID = result.output.insertedId || 0;
+                // 使用 rowsAffected 获取受影响行数
+                changes = result.rowsAffected?.[0] || (lastID > 0 ? 1 : 0);
             }
             else {
-                await request.query(preparedQuery);
+                const result = await request.query(preparedQuery);
+                // 使用 rowsAffected 获取受影响行数
+                changes = result.rowsAffected?.[0] || 0;
             }
             return {
-                changes: this.getAffectedRows(query, lastID),
+                changes: changes,
                 lastID: lastID
             };
         });
@@ -228,6 +264,8 @@ export class SqlServerAdapter {
      * @returns 执行完成后解析的 Promise
      */
     async exec(query) {
+        // 验证禁用的操作
+        validateForbiddenOperations(query);
         return this.executeWithRetry(async (pool) => {
             const request = pool.request();
             await request.batch(query);
@@ -251,10 +289,13 @@ export class SqlServerAdapter {
         return "SELECT TABLE_NAME as name FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME";
     }
     /**
-     * 获取描述表的数据库特定查询
-     * @param tableName 表名
+     * 获取描述表或视图的数据库特定查询
+     * @param tableName 表名或视图名
+     * @returns SQL 查询字符串
      */
     getDescribeTableQuery(tableName) {
+        // 验证并转义表名，防止 SQL 注入
+        const escapedTableName = escapeIdentifier(tableName);
         return `
       SELECT
         c.COLUMN_NAME as name,
@@ -272,27 +313,89 @@ export class SqlServerAdapter {
       LEFT JOIN
         sys.extended_properties ep
           ON ep.major_id = (
-            SELECT t.object_id
-            FROM sys.tables t
-            INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
-            WHERE t.name = '${tableName}' AND s.name = c.TABLE_SCHEMA
+            SELECT o.object_id
+            FROM sys.objects o
+            INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+            WHERE o.name = ${escapedTableName} AND s.name = c.TABLE_SCHEMA
+            AND o.type IN ('U', 'V')
           )
           AND ep.minor_id = c.ORDINAL_POSITION
           AND ep.name = 'MS_Description'
       WHERE
-        c.TABLE_NAME = '${tableName}'
+        c.TABLE_NAME = ${escapedTableName}
       ORDER BY
         c.ORDINAL_POSITION
     `;
     }
     /**
-     * 根据查询类型获取受影响行数的辅助方法
+     * 获取列出视图的数据库特定查询
      */
-    getAffectedRows(query, lastID) {
-        const queryType = query.trim().split(' ')[0].toUpperCase();
-        if (queryType === 'INSERT' && lastID > 0) {
-            return 1;
-        }
-        return 0; // 对于 SELECT 返回 0,对于 UPDATE/DELETE 在没有额外查询的情况下未知
+    getListViewsQuery() {
+        return "SELECT TABLE_NAME as name FROM INFORMATION_SCHEMA.VIEWS ORDER BY TABLE_NAME";
+    }
+    /**
+     * 获取视图定义的数据库特定查询
+     * @param viewName 视图名
+     * @returns SQL 查询字符串
+     * 注意: 使用 WITH ENCRYPTION 创建的视图无法获取定义
+     */
+    getViewDefinitionQuery(viewName) {
+        // 验证并转义视图名，防止 SQL 注入
+        const escapedViewName = escapeIdentifier(viewName);
+        return `SELECT VIEW_DEFINITION as definition FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = ${escapedViewName}`;
+    }
+    /**
+     * 检查数据库是否支持视图功能
+     */
+    supportsViews() {
+        return true;
+    }
+    /**
+     * 检查数据库是否支持存储过程功能
+     */
+    supportsProcedures() {
+        return true;
+    }
+    /**
+     * 获取列出存储过程的数据库特定查询
+     */
+    getListProceduresQuery() {
+        return "SELECT ROUTINE_NAME as name FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_TYPE = 'PROCEDURE' ORDER BY ROUTINE_NAME";
+    }
+    /**
+     * 获取存储过程参数信息的查询
+     * @param procedureName 存储过程名
+     * @returns SQL 查询字符串
+     */
+    getDescribeProcedureQuery(procedureName) {
+        // 验证并转义存储过程名，防止 SQL 注入
+        const escapedProcedureName = escapeIdentifier(procedureName);
+        return `
+      SELECT
+        PARAMETER_NAME as name,
+        DATA_TYPE +
+            CASE
+                WHEN CHARACTER_MAXIMUM_LENGTH IS NOT NULL
+                THEN '(' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + ')'
+                ELSE ''
+            END as type,
+        PARAMETER_MODE as direction,
+        CASE WHEN PARAMETER_MODE IN ('OUT', 'INOUT') THEN 1 ELSE 0 END as is_output,
+        NULL as default_value
+      FROM INFORMATION_SCHEMA.PARAMETERS
+      WHERE SPECIFIC_NAME = ${escapedProcedureName}
+      ORDER BY ORDINAL_POSITION
+    `;
+    }
+    /**
+     * 获取存储过程定义的查询
+     * @param procedureName 存储过程名
+     * @returns SQL 查询字符串
+     * 注意: 使用 WITH ENCRYPTION 创建的存储过程无法获取定义
+     */
+    getProcedureDefinitionQuery(procedureName) {
+        // 验证并转义存储过程名，防止 SQL 注入
+        const escapedProcedureName = escapeIdentifier(procedureName);
+        return `SELECT ROUTINE_DEFINITION as definition FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_TYPE = 'PROCEDURE' AND ROUTINE_NAME = ${escapedProcedureName}`;
     }
 }