mm_sql 1.4.2 → 1.4.4

package/admin_vs_direct_test.js

@@ -2,10 +2,10 @@ const { mysqlAdmin } = require('../mm_mysql');
 
 /**
  * 测试run方法对不存在的表的处理
- * @param {Object} admin_mysql - mysqlAdmin实例
- * @param {Object} direct_mysql - 直接Mysql实例
+ * @param {object} admin_mysql - mysqlAdmin实例
+ * @param {object} direct_mysql - 直接Mysql实例
  */
-async function testRunMethod(admin_mysql, direct_mysql) {
+async function runMethod(admin_mysql, direct_mysql) {
   console.log('\n测试1: 比较对不存在的表的处理...');
   
   // mysqlAdmin实例测试
@@ -29,10 +29,10 @@ async function testRunMethod(admin_mysql, direct_mysql) {
 
 /**
  * 比较实例类型和属性
- * @param {Object} admin_mysql - mysqlAdmin实例
- * @param {Object} direct_mysql - 直接Mysql实例
+ * @param {object} admin_mysql - mysqlAdmin实例
+ * @param {object} direct_mysql - 直接Mysql实例
  */
-function compareInstanceType(admin_mysql, direct_mysql) {
+function instanceType(admin_mysql, direct_mysql) {
   console.log('\n测试2: 比较实例类型和属性...');
   console.log('mysqlAdmin实例类型:', admin_mysql.constructor.name);
   console.log('直接Mysql实例类型:', direct_mysql.constructor.name);
@@ -42,10 +42,10 @@ function compareInstanceType(admin_mysql, direct_mysql) {
 
 /**
  * 检查缓存问题
- * @param {Object} config - 数据库配置
- * @param {Object} admin_mysql - mysqlAdmin实例
+ * @param {object} config - 数据库配置
+ * @param {object} admin_mysql - mysqlAdmin实例
  */
-async function checkCache(config, admin_mysql) {
+async function cache(config, admin_mysql) {
   console.log('\n测试3: 检查缓存问题...');
   const admin_mysql2 = mysqlAdmin('compare_test', config); // 相同scope
   const admin_mysql3 = mysqlAdmin('compare_test2', config); // 不同scope
@@ -87,9 +87,9 @@ async function compareAdminDirect() {
     const direct_mysql = new Mysql(config);
     console.log('✅ 直接Mysql实例创建成功');
     
-    await testRunMethod(admin_mysql, direct_mysql);
-    compareInstanceType(admin_mysql, direct_mysql);
-    await checkCache(config, admin_mysql);
+    await runMethod(admin_mysql, direct_mysql);
+    instanceType(admin_mysql, direct_mysql);
+    await cache(config, admin_mysql);
     
   } catch (error) {
     console.log('❌ 实例创建失败:', error.message);
@@ -99,7 +99,7 @@ async function compareAdminDirect() {
 /**
  * 测试mm_sql模块中的适配器行为
  */
-async function checkSqlAdapter() {
+async function sqlAdapter() {
   console.log('\n=== 测试mm_sql模块中的适配器行为 ===');
   
   try {
@@ -151,7 +151,7 @@ async function main() {
   console.log('开始比较mysqlAdmin和直接Mysql实例的行为...\n');
   
   await compareAdminDirect();
-  await checkSqlAdapter();
+  await sqlAdapter();
   
   console.log('\n比较测试完成');
 }

package/debug_error_test.js

@@ -1,5 +1,51 @@
 const { Sql } = require('./index.js');
 
+/**
+ * 测试适配器直接调用
+ * @param {object} mysql_sql - MySQL实例
+ */
+async function adapterDirect(mysql_sql) {
+  console.log('\n测试1: 直接调用适配器run方法...');
+  try {
+    await mysql_sql._adapter.run('SELECT * FROM non_existent_table_xyz');
+    console.log('❌ 适配器应该对无效SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ 适配器正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 测试mm_sql的run方法调用
+ * @param {object} mysql_sql - MySQL实例
+ */
+async function sqlRun(mysql_sql) {
+  console.log('\n测试2: 通过mm_sql的run方法调用...');
+  try {
+    await mysql_sql.run('SELECT * FROM non_existent_table_xyz');
+    console.log('❌ mm_sql应该对无效SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ mm_sql正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 测试参数验证
+ * @param {object} mysql_sql - MySQL实例
+ */
+async function paramValid(mysql_sql) {
+  console.log('\n测试3: 测试参数验证...');
+  try {
+    await mysql_sql.run(123); // 无效参数类型
+    console.log('❌ mm_sql应该对无效参数抛出TypeError，但没有抛出');
+  } catch (error) {
+    if (error instanceof TypeError) {
+      console.log('✅ mm_sql正确抛出TypeError:', error.message);
+    } else {
+      console.log('❌ mm_sql抛出错误但不是TypeError:', error.message);
+    }
+  }
+}
+
 /**
  * 调试MySQL错误传播
  */
@@ -20,42 +66,61 @@ async function debugMysqlError() {
     console.log('✅ mm_sql MySQL实例创建成功');
     console.log('适配器类型:', mysql_sql._adapter?.constructor?.name);
     
-    // 测试1: 直接调用适配器的run方法
-    console.log('\n测试1: 直接调用适配器run方法...');
-    try {
-      await mysql_sql._adapter.run('SELECT * FROM non_existent_table_xyz');
-      console.log('❌ 适配器应该对无效SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ 适配器正确抛出错误:', error.message);
-    }
-    
-    // 测试2: 通过mm_sql的run方法调用
-    console.log('\n测试2: 通过mm_sql的run方法调用...');
-    try {
-      await mysql_sql.run('SELECT * FROM non_existent_table_xyz');
-      console.log('❌ mm_sql应该对无效SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ mm_sql正确抛出错误:', error.message);
-    }
-    
-    // 测试3: 测试参数验证
-    console.log('\n测试3: 测试参数验证...');
-    try {
-      await mysqlSql.run(123); // 无效参数类型
-      console.log('❌ mm_sql应该对无效参数抛出TypeError，但没有抛出');
-    } catch (error) {
-      if (error instanceof TypeError) {
-        console.log('✅ mm_sql正确抛出TypeError:', error.message);
-      } else {
-        console.log('❌ mm_sql抛出错误但不是TypeError:', error.message);
-      }
-    }
+    await adapterDirect(mysql_sql);
+    await sqlRun(mysql_sql);
+    await paramValid(mysql_sql);
     
   } catch (error) {
     console.log('❌ mm_sql实例创建失败:', error.message);
   }
 }
 
+/**
+ * 测试SQLite适配器直接调用
+ * @param {object} sqlite_sql - SQLite实例
+ */
+async function sqliteAdapter(sqlite_sql) {
+  console.log('\n测试1: 直接调用适配器run方法...');
+  try {
+    await sqlite_sql._adapter.run('SELECT * FROM non_existent_table_xyz');
+    console.log('❌ 适配器应该对无效SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ 适配器正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 测试SQLite的run方法调用
+ * @param {object} sqlite_sql - SQLite实例
+ */
+async function sqliteRun(sqlite_sql) {
+  console.log('\n测试2: 通过mm_sql的run方法调用...');
+  try {
+    await sqlite_sql.run('SELECT * FROM non_existent_table_xyz');
+    console.log('❌ mm_sql应该对无效SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ mm_sql正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 测试SQLite参数验证
+ * @param {object} sqlite_sql - SQLite实例
+ */
+async function sqliteParam(sqlite_sql) {
+  console.log('\n测试3: 测试参数验证...');
+  try {
+    await sqlite_sql.run(123); // 无效参数类型
+    console.log('❌ mm_sql应该对无效参数抛出TypeError，但没有抛出');
+  } catch (error) {
+    if (error instanceof TypeError) {
+      console.log('✅ mm_sql正确抛出TypeError:', error.message);
+    } else {
+      console.log('❌ mm_sql抛出错误但不是TypeError:', error.message);
+    }
+  }
+}
+
 /**
  * 调试SQLite错误传播
  */
@@ -73,36 +138,9 @@ async function debugSqliteError() {
     console.log('✅ mm_sql SQLite实例创建成功');
     console.log('适配器类型:', sqlite_sql._adapter?.constructor?.name);
     
-    // 测试1: 直接调用适配器的run方法
-    console.log('\n测试1: 直接调用适配器run方法...');
-    try {
-      await sqlite_sql._adapter.run('SELECT * FROM non_existent_table_xyz');
-      console.log('❌ 适配器应该对无效SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ 适配器正确抛出错误:', error.message);
-    }
-    
-    // 测试2: 通过mm_sql的run方法调用
-    console.log('\n测试2: 通过mm_sql的run方法调用...');
-    try {
-      await sqlite_sql.run('SELECT * FROM non_existent_table_xyz');
-      console.log('❌ mm_sql应该对无效SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ mm_sql正确抛出错误:', error.message);
-    }
-    
-    // 测试3: 测试参数验证
-    console.log('\n测试3: 测试参数验证...');
-    try {
-      await sqlite_sql.run(123); // 无效参数类型
-      console.log('❌ mm_sql应该对无效参数抛出TypeError，但没有抛出');
-    } catch (error) {
-      if (error instanceof TypeError) {
-        console.log('✅ mm_sql正确抛出TypeError:', error.message);
-      } else {
-        console.log('❌ mm_sql抛出错误但不是TypeError:', error.message);
-      }
-    }
+    await testSqliteAdapter(sqlite_sql);
+    await testSqliteRun(sqlite_sql);
+    await testSqliteParam(sqlite_sql);
     
   } catch (error) {
     console.log('❌ mm_sql实例创建失败:', error.message);

package/detailed_error_test.js

@@ -1,5 +1,69 @@
 const { mysqlAdmin } = require('../mm_mysql');
 
+/**
+ * 测试MySQL语法错误
+ * @param {Object} mysql - MySQL实例
+ */
+async function testMysqlSyntax(mysql) {
+  console.log('\n测试1: 语法错误的SQL...');
+  try {
+    await mysql.run('SELECT * FROM'); // 语法错误
+    console.log('❌ MySQL应该对语法错误SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ MySQL正确抛出语法错误:', error.message);
+  }
+}
+
+/**
+ * 测试MySQL不存在的表
+ * @param {Object} mysql - MySQL实例
+ */
+async function testMysqlTable(mysql) {
+  console.log('\n测试2: 不存在的表...');
+  try {
+    const result = await mysql.run('SELECT * FROM non_existent_table_xyz');
+    console.log('MySQL返回结果:', result);
+    console.log('结果类型:', typeof result);
+    console.log('结果长度:', Array.isArray(result) ? result.length : 'N/A');
+    
+    if (Array.isArray(result) && result.length === 0) {
+      console.log('⚠️ MySQL对不存在的表返回空数组而不是抛出错误');
+    } else {
+      console.log('❌ MySQL应该对不存在的表抛出错误，但没有抛出');
+    }
+  } catch (error) {
+    console.log('✅ MySQL正确抛出表不存在错误:', error.message);
+  }
+}
+
+/**
+ * 测试MySQL不存在的数据库
+ * @param {Object} mysql - MySQL实例
+ */
+async function testMysqlDb(mysql) {
+  console.log('\n测试3: 不存在的数据库...');
+  try {
+    await mysql.run('SELECT * FROM non_existent_db.non_existent_table');
+    console.log('❌ MySQL应该对不存在的数据库抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ MySQL正确抛出数据库不存在错误:', error.message);
+  }
+}
+
+/**
+ * 测试MySQL权限错误
+ * @param {Object} mysql - MySQL实例
+ */
+async function testMysqlPerm(mysql) {
+  console.log('\n测试4: 权限错误...');
+  try {
+    await mysql.run('DROP TABLE IF EXISTS important_system_table');
+    console.log('❌ MySQL应该对权限错误抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ MySQL正确抛出权限错误:', error.message);
+  }
+}
+
 /**
  * 详细测试MySQL错误处理
  */
@@ -18,52 +82,49 @@ async function mysqlErrorTest() {
     
     console.log('✅ MySQL实例创建成功');
     
-    // 测试1: 语法错误的SQL
-    console.log('\n测试1: 语法错误的SQL...');
-    try {
-      await mysql.run('SELECT * FROM'); // 语法错误
-      console.log('❌ MySQL应该对语法错误SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ MySQL正确抛出语法错误:', error.message);
-    }
+    await testMysqlSyntax(mysql);
+    await testMysqlTable(mysql);
+    await testMysqlDb(mysql);
+    await testMysqlPerm(mysql);
     
-    // 测试2: 不存在的表（语法正确但表不存在）
-    console.log('\n测试2: 不存在的表...');
-    try {
-      const result = await mysql.run('SELECT * FROM non_existent_table_xyz');
-      console.log('MySQL返回结果:', result);
-      console.log('结果类型:', typeof result);
-      console.log('结果长度:', Array.isArray(result) ? result.length : 'N/A');
-      
-      if (Array.isArray(result) && result.length === 0) {
-        console.log('⚠️ MySQL对不存在的表返回空数组而不是抛出错误');
-      } else {
-        console.log('❌ MySQL应该对不存在的表抛出错误，但没有抛出');
-      }
-    } catch (error) {
-      console.log('✅ MySQL正确抛出表不存在错误:', error.message);
-    }
-    
-    // 测试3: 不存在的数据库
-    console.log('\n测试3: 不存在的数据库...');
-    try {
-      await mysql.run('SELECT * FROM non_existent_db.non_existent_table');
-      console.log('❌ MySQL应该对不存在的数据库抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ MySQL正确抛出数据库不存在错误:', error.message);
-    }
+  } catch (error) {
+    console.log('❌ MySQL实例创建失败:', error.message);
+  }
+}
+
+/**
+ * 测试SQLite语法错误
+ * @param {Object} sqlite - SQLite实例
+ */
+async function testSqliteSyntax(sqlite) {
+  console.log('\n测试1: 语法错误的SQL...');
+  try {
+    await sqlite.run('SELECT * FROM'); // 语法错误
+    console.log('❌ SQLite应该对语法错误SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ SQLite正确抛出语法错误:', error.message);
+  }
+}
+
+/**
+ * 测试SQLite不存在的表
+ * @param {Object} sqlite - SQLite实例
+ */
+async function testSqliteTable(sqlite) {
+  console.log('\n测试2: 不存在的表...');
+  try {
+    const result = await sqlite.run('SELECT * FROM non_existent_table_xyz');
+    console.log('SQLite返回结果:', result);
+    console.log('结果类型:', typeof result);
+    console.log('结果长度:', Array.isArray(result) ? result.length : 'N/A');
     
-    // 测试4: 权限错误
-    console.log('\n测试4: 权限错误...');
-    try {
-      await mysql.run('DROP TABLE IF EXISTS important_system_table');
-      console.log('❌ MySQL应该对权限错误抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ MySQL正确抛出权限错误:', error.message);
+    if (Array.isArray(result) && result.length === 0) {
+      console.log('⚠️ SQLite对不存在的表返回空数组而不是抛出错误');
+    } else {
+      console.log('❌ SQLite应该对不存在的表抛出错误，但没有抛出');
     }
-    
   } catch (error) {
-    console.log('❌ MySQL实例创建失败:', error.message);
+    console.log('✅ SQLite正确抛出表不存在错误:', error.message);
   }
 }
 
@@ -84,31 +145,8 @@ async function sqliteErrorTest() {
     
     console.log('✅ SQLite实例创建成功');
     
-    // 测试1: 语法错误的SQL
-    console.log('\n测试1: 语法错误的SQL...');
-    try {
-      await sqlite.run('SELECT * FROM'); // 语法错误
-      console.log('❌ SQLite应该对语法错误SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ SQLite正确抛出语法错误:', error.message);
-    }
-    
-    // 测试2: 不存在的表（语法正确但表不存在）
-    console.log('\n测试2: 不存在的表...');
-    try {
-      const result = await sqlite.run('SELECT * FROM non_existent_table_xyz');
-      console.log('SQLite返回结果:', result);
-      console.log('结果类型:', typeof result);
-      console.log('结果长度:', Array.isArray(result) ? result.length : 'N/A');
-      
-      if (Array.isArray(result) && result.length === 0) {
-        console.log('⚠️ SQLite对不存在的表返回空数组而不是抛出错误');
-      } else {
-        console.log('❌ SQLite应该对不存在的表抛出错误，但没有抛出');
-      }
-    } catch (error) {
-      console.log('✅ SQLite正确抛出表不存在错误:', error.message);
-    }
+    await testSqliteSyntax(sqlite);
+    await testSqliteTable(sqlite);
     
   } catch (error) {
     console.log('❌ SQLite实例创建失败:', error.message);

package/index.js

@@ -304,4 +304,44 @@ Sql.prototype.db = function () {
 };
 
 // 导出模块
-exports.Sql = Sql;
+exports.Sql = Sql;
+
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+  $.pool = {};
+}
+if (!$.pool.sql) {
+  $.pool.sql = {};
+}
+
+/**
+ * @description Sql管理器，用于创建缓存（线程安全版）
+ * @param {string} scope 作用域
+ * @param {object} config 配置参数
+ * @returns {object} 返回一个Sql类实例
+ */
+function sqlAdmin(scope, config) {
+  if (!scope) {
+    scope = 'sys';
+  }
+
+  // 检查是否已存在实例
+  if ($.pool.sql[scope]) {
+    return $.pool.sql[scope];
+  }
+
+  // 同步方式创建实例（无需锁，因为Node.js是单线程的）
+  if (!$.pool.sql[scope]) {
+    $.pool.sql[scope] = new Sql(config);
+  }
+
+  return $.pool.sql[scope];
+}
+
+/**
+ * @module 导出Sql管理器
+ */
+exports.sqlAdmin = sqlAdmin;

package/mysql_error_test.js

@@ -3,7 +3,7 @@ const { mysqlAdmin } = require('../mm_mysql');
 /**
  * 测试mysqlAdmin的错误传播
  */
-async function testMysqlAdminErrorPropagation() {
+async function testMysqlAdminError() {
   console.log('=== 测试mysqlAdmin错误传播 ===');
   
   try {
@@ -18,37 +18,50 @@ async function testMysqlAdminErrorPropagation() {
     
     console.log('✅ mysqlAdmin实例创建成功');
     
-    // 测试无效SQL - 应该抛出错误
-    try {
-      console.log('测试无效SQL...');
-      await mysql.run('SELECT * FROM non_existent_table_xyz');
-      console.log('❌ mysqlAdmin应该对无效SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ mysqlAdmin正确抛出错误:', error.message);
-    }
-    
-    // 测试无效参数 - 应该抛出TypeError
-    try {
-      console.log('测试无效参数...');
-      await mysql.run('SELECT * FROM test', 'invalid_param');
-      console.log('❌ mysqlAdmin应该对无效参数抛出TypeError，但没有抛出');
-    } catch (error) {
-      if (error instanceof TypeError) {
-        console.log('✅ mysqlAdmin正确抛出TypeError:', error.message);
-      } else {
-        console.log('❌ mysqlAdmin抛出错误但不是TypeError:', error.message);
-      }
-    }
+    await sql(mysql);
+    await param(mysql);
     
   } catch (error) {
     console.log('❌ mysqlAdmin实例创建失败:', error.message);
   }
 }
 
+/**
+ * 测试无效SQL
+ * @param {object} mysql - mysql实例
+ */
+async function sql(mysql) {
+  try {
+    console.log('测试无效SQL...');
+    await mysql.run('SELECT * FROM non_existent_table_xyz');
+    console.log('❌ mysqlAdmin应该对无效SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ mysqlAdmin正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 测试无效参数
+ * @param {object} mysql - mysql实例
+ */
+async function param(mysql) {
+  try {
+    console.log('测试无效参数...');
+    await mysql.run('SELECT * FROM test', 'invalid_param');
+    console.log('❌ mysqlAdmin应该对无效参数抛出TypeError，但没有抛出');
+  } catch (error) {
+    if (error instanceof TypeError) {
+      console.log('✅ mysqlAdmin正确抛出TypeError:', error.message);
+    } else {
+      console.log('❌ mysqlAdmin抛出错误但不是TypeError:', error.message);
+    }
+  }
+}
+
 /**
  * 测试直接使用Mysql类的错误传播
  */
-async function testDirectMysqlErrorPropagation() {
+async function testDirectMysqlError() {
   console.log('\n=== 测试直接Mysql类错误传播 ===');
   
   try {
@@ -65,41 +78,54 @@ async function testDirectMysqlErrorPropagation() {
     
     console.log('✅ 直接Mysql实例创建成功');
     
-    // 测试无效SQL - 应该抛出错误
-    try {
-      console.log('测试无效SQL...');
-      await mysql.run('SELECT * FROM non_existent_table_xyz');
-      console.log('❌ 直接Mysql应该对无效SQL抛出错误，但没有抛出');
-    } catch (error) {
-      console.log('✅ 直接Mysql正确抛出错误:', error.message);
-    }
-    
-    // 测试无效参数 - 应该抛出TypeError
-    try {
-      console.log('测试无效参数...');
-      await mysql.run('SELECT * FROM test', 'invalid_param');
-      console.log('❌ 直接Mysql应该对无效参数抛出TypeError，但没有抛出');
-    } catch (error) {
-      if (error instanceof TypeError) {
-        console.log('✅ 直接Mysql正确抛出TypeError:', error.message);
-      } else {
-        console.log('❌ 直接Mysql抛出错误但不是TypeError:', error.message);
-      }
-    }
+    await directSql(mysql);
+    await direct(mysql);
     
   } catch (error) {
     console.log('❌ 直接Mysql实例创建失败:', error.message);
   }
 }
 
+/**
+ * 测试直接Mysql实例的无效SQL
+ * @param {object} mysql - mysql实例
+ */
+async function directSql(mysql) {
+  try {
+    console.log('测试无效SQL...');
+    await mysql.run('SELECT * FROM non_existent_table_xyz');
+    console.log('❌ 直接Mysql应该对无效SQL抛出错误，但没有抛出');
+  } catch (error) {
+    console.log('✅ 直接Mysql正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 测试直接Mysql实例的无效参数
+ * @param {object} mysql - mysql实例
+ */
+async function direct(mysql) {
+  try {
+    console.log('测试无效参数...');
+    await mysql.run('SELECT * FROM test', 'invalid_param');
+    console.log('❌ 直接Mysql应该对无效参数抛出TypeError，但没有抛出');
+  } catch (error) {
+    if (error instanceof TypeError) {
+      console.log('✅ 直接Mysql正确抛出TypeError:', error.message);
+    } else {
+      console.log('❌ 直接Mysql抛出错误但不是TypeError:', error.message);
+    }
+  }
+}
+
 /**
  * 主测试函数
  */
 async function main() {
   console.log('开始测试MySQL错误传播...\n');
   
-  await testMysqlAdminErrorPropagation();
-  await testDirectMysqlErrorPropagation();
+  await testMysqlAdminError();
+  await testDirectMysqlError();
   
   console.log('\n测试完成');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_sql",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "一个通用的SQL帮助类，支持通过切换db_type实现对不同数据库的操作，包括MySQL和SQLite等",
   "main": "index.js",
   "scripts": {
@@ -44,8 +44,8 @@
     "node": ">=12.0.0"
   },
   "dependencies": {
-    "mm_mysql": "^2.2.7",
-    "mm_sqlite": "^1.2.7"
+    "mm_mysql": "^2.2.8",
+    "mm_sqlite": "^1.2.8"
   },
   "devDependencies": {
     "eslint": "^9.39.2",