@cmd233/mcp-database-server 1.1.7 → 1.2.0

package/dist/src/db/index.js

@@ -93,3 +93,40 @@ export function getDescribeTableQuery(tableName) {
     }
     return dbAdapter.getDescribeTableQuery(tableName);
 }
+/**
+ * 获取列出视图的数据库特定查询
+ * 仅 SQL Server 支持，其他数据库返回空结果
+ */
+export function getListViewsQuery() {
+    if (!dbAdapter) {
+        throw new Error("数据库未初始化");
+    }
+    if (dbAdapter.getListViewsQuery) {
+        return dbAdapter.getListViewsQuery();
+    }
+    // 不支持视图的数据库返回空结果查询
+    return "SELECT 1 as name WHERE 1=0";
+}
+/**
+ * 获取视图定义的数据库特定查询
+ * 仅 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;
+}

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

@@ -55,7 +55,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 +63,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 +76,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 +97,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 配置。`);
             }

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

@@ -24,7 +24,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 +35,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}`);
         }
     }
@@ -54,7 +54,8 @@ export class PostgresqlAdapter {
         }
         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;
         }
@@ -74,7 +75,8 @@ export class PostgresqlAdapter {
         }
         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

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

@@ -13,14 +13,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();
                 }
             });

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

@@ -68,27 +68,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 +139,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 +163,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;
         }
@@ -207,17 +207,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
             };
         });
@@ -251,8 +256,8 @@ 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 表名或视图名
      */
     getDescribeTableQuery(tableName) {
         return `
@@ -272,10 +277,11 @@ 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 = '${tableName}' AND s.name = c.TABLE_SCHEMA
+            AND o.type IN ('U', 'V')
           )
           AND ep.minor_id = c.ORDINAL_POSITION
           AND ep.name = 'MS_Description'
@@ -286,13 +292,23 @@ export class SqlServerAdapter {
     `;
     }
     /**
-     * 根据查询类型获取受影响行数的辅助方法
+     * 获取列出视图的数据库特定查询
      */
-    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 视图名
+     * 注意: 使用 WITH ENCRYPTION 创建的视图无法获取定义
+     */
+    getViewDefinitionQuery(viewName) {
+        return `SELECT VIEW_DEFINITION as definition FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '${viewName}'`;
+    }
+    /**
+     * 检查数据库是否支持视图功能
+     */
+    supportsViews() {
+        return true;
     }
 }