mm_sqlite 1.3.7 → 1.3.8

package/db.js

@@ -23,7 +23,7 @@ class DB extends Sql {
      * 获取上级
      * @returns {object} 返回上级管理器
      */
-    this.parent = function () {
+    this.getParent = function () {
       return sqlite;
     };
   }
@@ -48,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;
 };
 
 /**
@@ -58,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;
@@ -77,7 +77,7 @@ DB.prototype.new = function (table, key) {
 DB.prototype.getConn = async function (timeout = 15000) {
   try {
     // 直接使用SQLite实例的getConn方法，避免Promise.race导致的死锁
-    return await this.parent().getConn(timeout);
+    return await this.getParent().getConn(timeout);
   } catch (error) {
     this.log('error', '获取连接失败', error);
     // 重新抛出异常，因为调用方需要连接对象

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();

package/package.json

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

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;