mm_sqlite 1.3.5 → 1.3.8

package/db.js

@@ -11,8 +11,6 @@ class DB extends Sql {
    */
   constructor(sqlite) {
     super(sqlite.run, sqlite.exec);
-    // 保存sqlite实例引用
-    this._sqlite = sqlite;
     // 事务中
     this.task = 0;
 
@@ -25,7 +23,7 @@ class DB extends Sql {
      * 获取上级
      * @returns {object} 返回上级管理器
      */
-    this.parent = function () {
+    this.getParent = function () {
       return sqlite;
     };
   }
@@ -50,7 +48,7 @@ DB.prototype._createTimeoutPromise = function (timeout, message) {
  * @returns {string} 数据库
  */
 DB.prototype.database = function () {
-  return this.parent().config.database;
+  return this.getParent().config.database;
 };
 
 /**
@@ -60,7 +58,7 @@ DB.prototype.database = function () {
  * @returns {object} 返回管理器
  */
 DB.prototype.new = function (table, key) {
-  var db = this.parent().db();
+  var db = this.getParent().db();
   db.table = table;
   if (key) {
     db.key = key;
@@ -72,20 +70,14 @@ DB.prototype.new = function (table, key) {
 };
 
 /**
- * 获取数据库连接
+ * 获取数据库连接（修复死锁版）
  * @param {number} timeout 超时时间(毫秒)
  * @returns {Promise<object>} 数据库连接对象
  */
 DB.prototype.getConn = async function (timeout = 15000) {
-  if (!this._sqlite) {
-    throw new Error('SQLite实例未初始化');
-  }
   try {
-    // 使用Promise.race实现超时控制
-    return await Promise.race([
-      this._sqlite.getConn(),
-      this._createTimeoutPromise(timeout, '获取数据库连接超时')
-    ]);
+    // 直接使用SQLite实例的getConn方法，避免Promise.race导致的死锁
+    return await this.getParent().getConn(timeout);
   } catch (error) {
     this.log('error', '获取连接失败', error);
     // 重新抛出异常，因为调用方需要连接对象
@@ -100,7 +92,7 @@ DB.prototype.getConn = async function (timeout = 15000) {
 DB.prototype.start = async function() {
   this.task = 1;
   try {
-    await this.exec('BEGIN;', [], 15000);
+    await this.exec('BEGIN;');
     // 返回事务对象
     return {
       commit: async () => {
@@ -481,7 +473,7 @@ DB.prototype.emptyTable = function (table, timeout = 15000) {
   if (!table || typeof table !== 'string') {
     throw new TypeError('table must be a valid string');
   }
-  return this.exec('DELETE FROM `' + table + '`;', timeout);
+  return this.exec('DELETE FROM `' + table + '`;', [], timeout);
 };
 
 /**
@@ -572,11 +564,11 @@ DB.prototype.setField = async function (field, type, value = '', not_null = true
     } else {
       sql += ';';
     }
-    await this.exec(sql, timeout);
+    await this.exec(sql, [], timeout);
 
     sql = 'UPDATE TABLE `{0}` SET `{2}` = `{1}`;';
     sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', new_name);
-    var ret = await this.exec(sql, timeout);
+    var ret = await this.exec(sql, [], timeout);
 
     if (field !== new_name) {
       // sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
@@ -811,12 +803,11 @@ DB.prototype.getCreateTable = async function (table, timeout = 15000) {
 /**
  * @description 获取表数据的SQL插入语句
  * @param {string} table 表名
- * @param {number} batchSize 批量处理大小
- * @param batch_size
- * @param {number} timeout 超时时间(毫秒)
+ * @param {number} batch_size 批量处理大小
+ * @param {number} timeout - 超时时间(毫秒)
  * @returns {Promise | string} SQL插入语句
  */
-DB.prototype.getTableData = async function (table, batchSize = 100, timeout = 60000) {
+DB.prototype.getTableData = async function (table, batch_size = 100, timeout = 60000) {
   if (!table) {
     throw new TypeError('table must be specified');
   }

package/index.js

@@ -21,23 +21,23 @@ class SQLite extends Base {
     database: 'mm',
     charset: 'utf8mb4',
     timezone: '+08:00',
-    connect_timeout: 20000,
-    acquire_timeout: 20000,
-    query_timeout: 20000,
-    connection_limit: 500,
+    connect_timeout: 5000,        // 减少连接超时时间
+    acquire_timeout: 5000,        // 减少获取连接超时时间
+    query_timeout: 10000,         // 减少查询超时时间
+    connection_limit: 10,         // 减少最大连接数
     queue_limit: 0,
-    enable_keep_alive: true,
-    keep_alive_initial_delay: 10000,
-    enable_reconnect: true,
-    reconnect_interval: 1000,
-    max_reconnect_attempts: 5,
-    wait_for_connections: true,
+    enable_keep_alive: false,     // SQLite不需要保持连接
+    keep_alive_initial_delay: 0,
+    enable_reconnect: false,      // SQLite不需要重连
+    reconnect_interval: 0,
+    max_reconnect_attempts: 0,
+    wait_for_connections: false,
     // 连接池相关配置
     pool_min: 1,
-    pool_max: 5,
-    pool_acquire_timeout: 30000,
-    pool_idle_timeout: 60000,
-    pool_reap_interval: 1000
+    pool_max: 3,                  // 减少最大连接池大小
+    pool_acquire_timeout: 5000,   // 减少连接池获取超时
+    pool_idle_timeout: 30000,     // 减少空闲超时
+    pool_reap_interval: 5000      // 减少回收间隔
   };
 
   /**
@@ -46,26 +46,33 @@ class SQLite extends Base {
    */
   constructor(config) {
     super(config);
-    this._connection = null;
-    this._pool = null;
-    this._status = 'closed';
-    this._last_connect_time = 0;
-    this._reconnecting = false;
-    this._is_inited = false;
-    this._is_destroyed = false;
-    this._db = null;
-    this._open = false;
-    this._conn_retry_count = 0;
-
-    // 连接池相关属性
-    this._use_pool = this.config.connection_limit > 1;
     this._pool_connections = [];
     this._pool_available = [];
     this._pool_waiting = [];
-    this._pool_reaper = null;
   }
 }
 
+/**
+ * 预初始化数据库连接
+ * @private
+ */
+SQLite.prototype._preset = function () {
+  this._connection = null;
+  this._pool = null;
+  this._status = 'closed';
+  this._last_connect_time = 0;
+  this._reconnecting = false;
+  this._is_inited = false;
+  this._is_destroyed = false;
+  this._db = null;
+  this._open = false;
+  this._conn_retry_count = 0;
+
+  // 连接池相关属性
+  this._use_pool = this.config.connection_limit > 1;
+  this._pool_reaper = null;
+};
+
 /**
  * 初始化服务
  * @returns {Promise<void>}
@@ -150,16 +157,29 @@ SQLite.prototype.open = async function (timeout) {
       });
       return true;
     } else {
-      // 使用单连接模式
-      const conn_promise = this._openInternal();
-      const timeout_promise = new Promise((unused_resolve, reject) => {
-        setTimeout(() => {
-          reject(new Error(`数据库连接超时(${connect_timeout}ms)`));
-        }, connect_timeout);
-      });
-
+      // 使用单连接模式 - 替换Promise.race为更可靠的超时控制
+      let timeout_id = null;
+      let connection_success = false;
+      
       try {
-        await Promise.race([conn_promise, timeout_promise]);
+        // 设置超时控制
+        const timeout_promise = new Promise((resolve, reject) => {
+          timeout_id = setTimeout(() => {
+            if (!connection_success) {
+              reject(new Error(`数据库连接超时(${connect_timeout}ms)`));
+            }
+          }, connect_timeout);
+        });
+        
+        // 执行连接
+        await this._openInternal();
+        connection_success = true;
+        
+        // 清除超时定时器
+        if (timeout_id) {
+          clearTimeout(timeout_id);
+          timeout_id = null;
+        }
 
         this._last_connect_time = Date.now();
         this._status = 'connected';
@@ -169,7 +189,13 @@ SQLite.prototype.open = async function (timeout) {
         });
         return true;
       } catch (connection_err) {
+        // 确保超时定时器被清除
+        if (timeout_id) {
+          clearTimeout(timeout_id);
+          timeout_id = null;
+        }
         this.log('error', '连接过程错误详情', connection_err);
+        throw connection_err;
       }
     }
   } catch (err) {
@@ -248,25 +274,30 @@ SQLite.prototype.getConn = async function (timeout) {
       // 从连接池获取连接
       return await this._getPoolConnection();
     } else {
-      // 单连接模式
-      const conn_promise = new Promise((resolve) => {
-        resolve(this._db);
-      });
-      const timeout_promise = new Promise((unused_resolve, reject) => {
-        setTimeout(() => {
-          reject(new Error(`获取数据库连接超时(${acquire_timeout}ms)`));
-        }, acquire_timeout);
-      });
-
-      const conn = await Promise.race([conn_promise, timeout_promise]);
-      return conn;
+      // 单连接模式 - 替换Promise.race为更可靠的超时控制
+      let timeout_id = null;
+      
+      try {
+        return await new Promise((resolve, reject) => {
+          // 设置超时定时器
+          timeout_id = setTimeout(() => {
+            reject(new Error(`获取数据库连接超时(${acquire_timeout}ms)`));
+          }, acquire_timeout);
+          
+          // 直接返回连接，因为这是单连接模式
+          resolve(this._db);
+        });
+      } catch (error) {
+        // 确保超时定时器被清除
+        if (timeout_id) {
+          clearTimeout(timeout_id);
+          timeout_id = null;
+        }
+        throw error;
+      }
     }
   } catch (error) {
     this.log('error', '获取连接失败', error);
-
-    if (error.code && (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT')) {
-      this._handleConnectionError(error);
-    }
     return null;
   }
 };
@@ -300,9 +331,23 @@ SQLite.prototype.run = async function (sql, params = [], timeout = 30000) {
     conn = await this.getConn(query_timeout);
 
     const self = this;
-    // 直接在方法内部实现超时控制
-    const query_promise = new Promise((resolve, reject) => {
+    // 替换Promise.race为更可靠的超时控制
+    let timeout_id = null;
+    
+    const result = await new Promise((resolve, reject) => {
+      // 设置超时定时器
+      timeout_id = setTimeout(() => {
+        reject(new Error(`SQL查询超时: ${timeout}ms`));
+      }, timeout);
+      
+      // 执行SQL查询
       conn.all(sql, params || [], (error, rows) => {
+        // 清除超时定时器
+        if (timeout_id) {
+          clearTimeout(timeout_id);
+          timeout_id = null;
+        }
+        
         if (error) {
           self.sql = sql;
           self.error = {
@@ -318,14 +363,6 @@ SQLite.prototype.run = async function (sql, params = [], timeout = 30000) {
       });
     });
 
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => {
-        reject(new Error(`SQL查询超时: ${timeout}ms`));
-      }, timeout);
-    });
-
-    const result = await Promise.race([query_promise, timeout_promise]);
-
     // 连接池模式下释放连接
     if (this._use_pool && conn) {
       this._releasePoolConnection(conn);
@@ -340,11 +377,8 @@ SQLite.prototype.run = async function (sql, params = [], timeout = 30000) {
       this._releasePoolConnection(conn);
     }
 
-    // 处理连接错误，触发重连
-    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
-      this._handleConnectionError(err);
-    }
-    // 返回空数组，保持与MySQL一致的错误处理行为
+    // 简化错误处理：SQLite不需要复杂的连接错误处理
+    // 直接返回空数组，保持与MySQL一致的错误处理行为
     return [];
   }
 };
@@ -377,9 +411,23 @@ SQLite.prototype.exec = async function (sql, params, timeout) {
     // 获取连接
     conn = await this.getConn(timeout);
     var _this = this;
-    // 直接在方法内部实现超时控制
-    const query_promise = new Promise((resolve, reject) => {
+    // 替换Promise.race为更可靠的超时控制
+    let timeout_id = null;
+    
+    const result = await new Promise((resolve, reject) => {
+      // 设置超时定时器
+      timeout_id = setTimeout(() => {
+        reject(new Error(`SQL执行超时: ${timeout}ms`));
+      }, timeout);
+      
+      // 执行SQL语句
       conn.run(sql, params || [], function (error) {
+        // 清除超时定时器
+        if (timeout_id) {
+          clearTimeout(timeout_id);
+          timeout_id = null;
+        }
+        
         if (error) {
           _this.sql = sql;
           _this.error = {
@@ -395,14 +443,6 @@ SQLite.prototype.exec = async function (sql, params, timeout) {
       });
     });
 
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => {
-        reject(new Error(`SQL执行超时: ${timeout}ms`));
-      }, timeout);
-    });
-
-    const result = await Promise.race([query_promise, timeout_promise]);
-
     // 连接池模式下释放连接
     if (this._use_pool && conn) {
       this._releasePoolConnection(conn);
@@ -417,10 +457,7 @@ SQLite.prototype.exec = async function (sql, params, timeout) {
       this._releasePoolConnection(conn);
     }
 
-    // 处理连接错误，触发重连
-    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
-      this._handleConnectionError(err);
-    }
+    // 简化错误处理：SQLite不需要复杂的连接错误处理
     // 返回0，保持与MySQL一致的错误处理行为
     return 0;
   }
@@ -787,13 +824,23 @@ SQLite.prototype._reapIdleConnections = function () {
  * @returns {Promise<object>} 数据库连接
  */
 SQLite.prototype._getPoolConnection = async function () {
-  const acquire_timeout = this.config.pool_acquire_timeout;
+  const acquire_timeout = this.config.pool_acquire_timeout || 10000;
   const start_time = Date.now();
 
   return new Promise((resolve, reject) => {
+    let timeout_id = null;
+    
+    const cleanup = () => {
+      if (timeout_id) {
+        clearTimeout(timeout_id);
+        timeout_id = null;
+      }
+    };
+
     const tryGetConnection = () => {
       // 检查超时
       if (Date.now() - start_time > acquire_timeout) {
+        cleanup();
         reject(new Error(`获取连接超时(${acquire_timeout}ms)`));
         return;
       }
@@ -802,6 +849,7 @@ SQLite.prototype._getPoolConnection = async function () {
       if (this._pool_available.length > 0) {
         const conn = this._pool_available.shift();
         conn._last_used = Date.now();
+        cleanup();
         resolve(conn);
         return;
       }
@@ -812,14 +860,18 @@ SQLite.prototype._getPoolConnection = async function () {
           .then(conn => {
             this._pool_connections.push(conn);
             conn._last_used = Date.now();
+            cleanup();
             resolve(conn);
           })
-          .catch(reject);
+          .catch(err => {
+            cleanup();
+            reject(err);
+          });
         return;
       }
 
-      // 没有可用连接，等待一段时间后重试
-      setTimeout(tryGetConnection, 100);
+      // 没有可用连接，等待一段时间后重试（避免无限循环）
+      timeout_id = setTimeout(tryGetConnection, 50);
     };
 
     tryGetConnection();
@@ -853,15 +905,15 @@ SQLite.prototype._releasePoolConnection = function (conn) {
   if (!conn || !this._pool_connections.includes(conn)) {
     return;
   }
-  
+
   // 标记连接最后使用时间
   conn._last_used = Date.now();
-  
+
   // 将连接放回可用连接池
   if (!this._pool_available.includes(conn)) {
     this._pool_available.push(conn);
   }
-  
+
   // 如果有等待的连接请求，立即处理
   if (this._pool_waiting.length > 0) {
     const waiting = this._pool_waiting.shift();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_sqlite",
-    "version": "1.3.5",
+    "version": "1.3.8",
     "description": "高性能SQLite数据库操作模块，提供与mm_mysql完全兼容的API接口，支持异步操作、事务处理和批量操作",
     "main": "index.js",
     "scripts": {
@@ -38,12 +38,12 @@
         "node": ">=14.0.0"
     },
     "dependencies": {
-        "mm_expand": "^2.0.2",
+        "mm_expand": "^2.2.8",
         "sqlite3": "^6.0.1",
         "sqlstring": "^2.3.3"
     },
     "devDependencies": {
-        "eslint": "^10.1.0",
+        "eslint": "^10.2.0",
         "eslint-plugin-jsdoc": "^62.9.0",
         "mm_eslint": "^1.7.1"
     }

package/sql.js

@@ -897,7 +897,6 @@ Sql.prototype.del = async function (query, like) {
     var sql = this.toDelSql(query, like);
     this.sql = sql;
     var bl = await this.exec(sql);
-
     return bl;
   } catch (err) {
     this.error = err.message;
@@ -932,34 +931,23 @@ Sql.prototype.set = async function (query, body, like) {
 };
 
 /**
- * @description 查询数据
+ * @description 查询数据（优化版）
  * @param {object} query 查询条件
  * @param {string} sort 排序
  * @param {string} view 返回的字段
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @param {number} timeout 超时时间（毫秒），默认5000ms
  * @returns {Promise|Array} 查询结果
  */
-Sql.prototype.get = async function (query, sort, view, like, timeout = 30000) {
+Sql.prototype.get = async function (query, sort, view, like, timeout = 5000) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
 
   try {
-    // 使用Promise.race实现超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('查询操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 生成SQL并执行
-        var sql = this.toGetSql(query, sort, view, like);
-        var list = await this.run(sql);
-        return list;
-      })(),
-      timeout_promise
-    ]);
+    var sql = this.toGetSql(query, sort, view, like);
+    var list = await this.run(sql, [], timeout);
+    return list;
   } catch (err) {
     this.error = err.message;
     this.log('error', '查询数据失败', err);
@@ -1044,24 +1032,13 @@ Sql.prototype.count = async function (query, like, timeout = 30000) {
   }
 
   try {
-    // 添加超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('统计操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 正确生成count SQL
-        const where = typeof query === 'string' ? query : await this.toWhere(query, like);
-        const sql = 'SELECT COUNT(*) as num FROM `' + this.table + '`' + (where ? ' WHERE ' + where : '');
-        this.sql = sql;
-        const list = await this.run(sql);
-        const total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
-
-        return total;
-      })(),
-      timeout_promise
-    ]);
+    const where = typeof query === 'string' ? query : await this.toWhere(query, like);
+    const sql = 'SELECT COUNT(*) as num FROM `' + this.table + '`' + (where ? ' WHERE ' + where : '');
+    this.sql = sql;
+    const list = await this.run(sql);
+    const total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
+
+    return total;
   } catch (err) {
     this.error = err.message;
     this.log('error', '统计记录数失败', err);
@@ -1094,48 +1071,31 @@ Sql.prototype.addList = async function (list, batch_size = 100, timeout = 60000)
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('批量添加数据操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batch_size) {
-          // 使用批量插入语法，不使用事务包装
-          this.sql = this.toBatchAddSql(list);
-          return await this.exec(this.sql);
-        }
+    if (list.length <= batch_size) {
+      // 使用批量插入语法，不使用事务包装
+      this.sql = this.toBatchAddSql(list);
+      return await this.exec(this.sql);
+    }
 
-        // 分批处理大数据量
-        const total = Math.ceil(list.length / batch_size);
-        this.log('info', `开始分批添加数据，共${total}批，每批${batch_size}条`);
-
-        // 分批执行，每批一个单独的批量插入语句
-        let final_res = null;
-        for (let i = 0; i < total; i++) {
-          const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-          this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
-
-          // 生成批量插入SQL
-          const batch_sql = this.toBatchAddSql(batch);
-          this.sql = batch_sql;
-
-          // 为每批操作添加超时控制
-          final_res = await Promise.race([
-            this.exec(batch_sql),
-            new Promise((unused_resolve, reject) => {
-              setTimeout(() => reject(new Error(`第${i + 1}批数据处理超时`)), timeout / total);
-            })
-          ]);
-        }
+    // 分批处理大数据量
+    const total = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批添加数据，共${total}批，每批${batch_size}条`);
+
+    // 分批执行，每批一个单独的批量插入语句
+    let final_res = null;
+    for (let i = 0; i < total; i++) {
+      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+      this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-        this.log('success', `批量添加数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeout_promise
-    ]);
+      // 生成批量插入SQL
+      const batch_sql = this.toBatchAddSql(batch);
+      this.sql = batch_sql;
+
+      final_res = await this.exec(batch_sql);
+    }
+
+    this.log('success', `批量添加数据完成，共${list.length}条`);
+    return final_res;
   } catch (error) {
     this.log('error', '批量添加数据失败', error);
     // 返回默认操作结果对象，保持返回值类型一致
@@ -1197,71 +1157,53 @@ Sql.prototype.delList = async function (list, like, batch_size = 100, timeout =
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('批量删除数据操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batch_size) {
-          let sql = '';
-          for (const item of list) {
-            sql += this.toDelSql(item.query, like);
-          }
-          this.sql = sql;
-          return await this.exec(sql);
-        }
-
-        // 分批处理大数据量
-        const total = Math.ceil(list.length / batch_size);
-        this.log('info', `开始分批删除数据，共${total}批，每批${batch_size}条`);
-
-        // 使用事务包装整个操作以保证原子性
-        let final_res = null;
-        try {
-          // 开始事务
-          await this.exec('BEGIN;', 15000);
+    if (list.length <= batch_size) {
+      let sql = '';
+      for (const item of list) {
+        sql += this.toDelSql(item.query, like);
+      }
+      this.sql = sql;
+      return await this.exec(sql, [], timeout);
+    }
 
-          // 分批处理
-          for (let i = 0; i < total; i++) {
-            const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-            this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
+    // 分批处理大数据量
+    const total = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批删除数据，共${total}批，每批${batch_size}条`);
 
-            let batch_sql = '';
-            for (const item of batch) {
-              batch_sql += this.toDelSql(item.query, like);
-            }
+    // 使用事务包装整个操作以保证原子性
+    let final_res = null;
+    try {
+      // 开始事务
+      await this.exec('BEGIN;');
 
-            // 为每批操作添加超时控制
-            final_res = await Promise.race([
-              this.exec(batch_sql),
-              new Promise((unused_resolve, reject) => {
-                setTimeout(() => reject(new Error(`第${i + 1}批数据删除超时`)), timeout / total);
-              })
-            ]);
-          }
+      // 分批处理
+      for (let i = 0; i < total; i++) {
+        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+        this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-          // 提交事务
-          await this.exec('COMMIT;', 15000);
-        } catch (error) {
-          // 发生错误时回滚事务
-          try {
-            await this.exec('ROLLBACK;', 15000);
-            this.log('error', '批量删除数据失败，事务已回滚', error);
-          } catch (rollback_err) {
-            this.log('error', '批量删除数据失败，事务回滚也失败', rollback_err);
-          }
-          // 记录错误日志
-          this.log('error', 'SQL语句执行失败', error);
+        let batch_sql = '';
+        for (const item of batch) {
+          batch_sql += this.toDelSql(item.query, like);
         }
+        final_res = await this.exec(batch_sql, [], timeout);
+      }
 
-        this.log('success', `批量删除数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeout_promise
-    ]);
+      // 提交事务
+      await this.exec('COMMIT;', [], timeout);
+    } catch (error) {
+      // 发生错误时回滚事务
+      try {
+        await this.exec('ROLLBACK;', [], timeout);
+        this.log('error', '批量删除数据失败，事务已回滚', error);
+      } catch (rollback_err) {
+        this.log('error', '批量删除数据失败，事务回滚也失败', rollback_err);
+      }
+      // 记录错误日志
+      this.log('error', 'SQL语句执行失败', error);
+    }
+
+    this.log('success', `批量删除数据完成，共${list.length}条`);
+    return final_res;
   } catch (err) {
     this.log('error', '批量删除数据失败', err);
     // 返回默认操作结果对象，保持返回值类型一致
@@ -1281,69 +1223,52 @@ Sql.prototype.setList = async function (list, like = false, batch_size = 100, ti
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('批量更新数据操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batch_size) {
-          let sql = '';
-          for (const item of list) {
-            sql += this.toSetSql(item.query, item.obj, like);
-          }
-          this.sql = sql;
-          return await this.exec(sql);
-        }
+    if (list.length <= batch_size) {
+      let sql = '';
+      for (const item of list) {
+        sql += this.toSetSql(item.query, item.obj, like);
+      }
+      this.sql = sql;
+      return await this.exec(sql, [], timeout);
+    }
 
-        // 分批处理大数据量
-        const total = Math.ceil(list.length / batch_size);
-        this.log('info', `开始分批更新数据，共${total}批，每批${batch_size}条`);
+    // 分批处理大数据量
+    const total = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批更新数据，共${total}批，每批${batch_size}条`);
 
-        // 使用事务包装整个操作以保证原子性
-        let final_res = null;
-        try {
-          // 开始事务
-          await this.exec('BEGIN;', 15000);
+    // 使用事务包装整个操作以保证原子性
+    let final_res = null;
+    try {
+      // 开始事务
+      await this.exec('BEGIN;');
 
-          // 分批处理
-          for (let i = 0; i < total; i++) {
-            const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-            this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
+      // 分批处理
+      for (let i = 0; i < total; i++) {
+        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+        this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-            let batch_sql = '';
-            for (const item of batch) {
-              batch_sql += this.toSetSql(item.query, item.obj, like);
-            }
+        let batch_sql = '';
+        for (const item of batch) {
+          batch_sql += this.toSetSql(item.query, item.obj, like);
+        }
 
-            // 为每批操作添加超时控制
-            final_res = await Promise.race([
-              this.exec(batch_sql),
-              new Promise((unused_resolve, reject) => {
-                setTimeout(() => reject(new Error(`第${i + 1}批数据更新超时`)), timeout / total);
-              })
-            ]);
-          }
+        final_res = await this.exec(batch_sql, [], timeout);
+      }
 
-          // 提交事务
-          await this.exec('COMMIT;', 15000);
-        } catch (error) {
-          // 发生错误时回滚事务
-          try {
-            await this.exec('ROLLBACK;', 15000);
-            this.log('error', '批量更新数据失败，事务已回滚', error);
-          } catch (rollback_err) {
-            this.log('error', '批量更新数据失败，事务回滚也失败', rollback_err);
-          }
-        }
+      // 提交事务
+      await this.exec('COMMIT;', [], timeout);
+    } catch (error) {
+      // 发生错误时回滚事务
+      try {
+        await this.exec('ROLLBACK;', [], timeout);
+        this.log('error', '批量更新数据失败，事务已回滚', error);
+      } catch (rollback_err) {
+        this.log('error', '批量更新数据失败，事务回滚也失败', rollback_err);
+      }
+    }
 
-        this.log('success', `批量更新数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeout_promise
-    ]);
+    this.log('success', `批量更新数据完成，共${list.length}条`);
+    return final_res;
   } catch (err) {
     this.log('error', '批量更新数据失败', err);
     // 返回默认操作结果对象，保持返回值类型一致