mm_sqlite 1.3.9 → 1.4.2

package/index.js

@@ -3,6 +3,8 @@ const {
   DB
 } = require('./db');
 const { Base } = require('mm_expand');
+const SQLitePool = require('./pool');
+
 
 /**
  * SQLite数据库操作类
@@ -21,23 +23,15 @@ class SQLite extends Base {
     database: 'mm',
     charset: 'utf8mb4',
     timezone: '+08:00',
-    connect_timeout: 5000,        // 减少连接超时时间
-    acquire_timeout: 5000,        // 减少获取连接超时时间
-    query_timeout: 10000,         // 减少查询超时时间
-    connection_limit: 10,         // 减少最大连接数
-    queue_limit: 0,
-    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: 3,                  // 减少最大连接池大小
-    pool_acquire_timeout: 5000,   // 减少连接池获取超时
-    pool_idle_timeout: 30000,     // 减少空闲超时
-    pool_reap_interval: 5000      // 减少回收间隔
+    connect_timeout: 5000,        // 连接超时时间
+    acquire_timeout: 5000,        // 获取连接超时时间
+    query_timeout: 10000,         // 查询超时时间
+    // 连接池配置（统一使用连接池模式）
+    pool_min: 1,                  // 最小连接数
+    pool_max: 3,                  // 最大连接数
+    pool_acquire_timeout: 5000,   // 连接池获取超时
+    pool_idle_timeout: 30000,     // 空闲超时
+    pool_reap_interval: 5000      // 回收间隔
   };
 
   /**
@@ -46,9 +40,6 @@ class SQLite extends Base {
    */
   constructor(config) {
     super(config);
-    this._pool_connections = [];
-    this._pool_available = [];
-    this._pool_waiting = [];
   }
 }
 
@@ -58,7 +49,6 @@ class SQLite extends Base {
  */
 SQLite.prototype._preset = function () {
   this._connection = null;
-  this._pool = null;
   this._status = 'closed';
   this._last_connect_time = 0;
   this._reconnecting = false;
@@ -67,29 +57,8 @@ SQLite.prototype._preset = function () {
   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>}
- */
-SQLite.prototype._initService = async function () {
-  if (this._is_inited) {
-    this.log('warn', 'SQLite服务已初始化');
-    return;
-  }
-
-  try {
-    this.log('debug', '初始化SQLite服务', { config: this.config });
-    this._is_inited = true;
-    this.log('debug', 'SQLite服务初始化完成');
-  } catch (error) {
-    this.log('error', 'SQLite服务初始化失败', error);
-  }
+  // 初始化连接池实例
+  this._pool = new SQLitePool(this.config, this._getDbFilename.bind(this), this.log.bind(this));
 };
 
 /**
@@ -106,24 +75,7 @@ SQLite.prototype._getDbFilename = function () {
 };
 
 /**
- * 内部打开数据库连接
- * @private
- * @returns {Promise<void>}
- */
-SQLite.prototype._openInternal = async function () {
-  return new Promise((resolve, reject) => {
-    this._db = new sqlite3.Database(this._getDbFilename(), (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-/**
- * 打开数据库连接
+ * 打开数据库连接（统一使用连接池模式）
  * @param {number} timeout - 超时时间(毫秒)
  * @returns {Promise<boolean>}
  * @throws {TypeError} 当timeout参数无效时
@@ -139,65 +91,16 @@ SQLite.prototype.open = async function (timeout) {
     return true;
   }
 
-  const connect_timeout = timeout || this.config.connect_timeout || 10000;
   this._status = 'connecting';
 
   try {
     this.config.dir.addDir();
-    if (this._use_pool) {
-      // 使用连接池模式
-      await this._initPool();
-      this._last_connect_time = Date.now();
-      this._status = 'connected';
-      this.log('info', '数据库连接池初始化成功', {
-        dir: this.config.dir,
-        database: this.config.database,
-        pool_min: this.config.pool_min,
-        pool_max: this.config.pool_max
-      });
-      return true;
-    } else {
-      // 使用单连接模式 - 替换Promise.race为更可靠的超时控制
-      let timeout_id = null;
-      let connection_success = false;
-      
-      try {
-        // 设置超时控制
-        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';
-        this.log('info', '数据库连接成功', {
-          dir: this.config.dir,
-          database: this.config.database
-        });
-        return true;
-      } catch (connection_err) {
-        // 确保超时定时器被清除
-        if (timeout_id) {
-          clearTimeout(timeout_id);
-          timeout_id = null;
-        }
-        this.log('error', '连接过程错误详情', connection_err);
-        throw connection_err;
-      }
-    }
+    // 统一使用连接池模式
+    await this._pool.init();
+    this._last_connect_time = Date.now();
+    this._status = 'connected';
+    return true;
   } catch (err) {
     this._status = 'closed';
     this.log('error', '数据库连接失败', err);
@@ -206,7 +109,7 @@ SQLite.prototype.open = async function (timeout) {
 };
 
 /**
- * 关闭数据库连接
+ * 关闭数据库连接（统一使用连接池模式）
  * @returns {Promise<boolean>}
  */
 SQLite.prototype.close = function () {
@@ -217,32 +120,12 @@ SQLite.prototype.close = function () {
 
   return new Promise((resolve) => {
     try {
-      if (this._use_pool) {
-        // 关闭连接池
-        this._closePool();
-        this._db = null;
-        this._open = false;
-        this._status = 'closed';
-        this.log('info', '数据库连接池已关闭');
-        resolve(true);
-      } else if (this._db) {
-        // 单连接模式
-        this.log('debug', '关闭数据库连接');
-        this._db.close((err) => {
-          if (err) {
-            this.log('error', '关闭数据库失败', err);
-          } else {
-            this.log('info', '数据库已关闭');
-          }
-          this._db = null;
-          this._open = false;
-          this._status = 'closed';
-          resolve(!err);
-        });
-      } else {
-        this._status = 'closed';
-        resolve(true);
-      }
+      // 统一关闭连接池
+      this._pool.close();
+      this._db = null;
+      this._open = false;
+      this._status = 'closed';
+      resolve(true);
     } catch (err) {
       this.log('error', '关闭数据库连接时发生异常', err);
       this._status = 'closed';
@@ -252,7 +135,7 @@ SQLite.prototype.close = function () {
 };
 
 /**
- * 获取数据库连接
+ * 获取数据库连接（统一使用连接池模式）
  * @param {number} timeout - 超时时间(毫秒)
  * @returns {Promise<object>}
  * @throws {TypeError} 当timeout参数无效时
@@ -269,37 +152,8 @@ SQLite.prototype.getConn = async function (timeout) {
     await this.open(acquire_timeout);
   }
 
-  try {
-    if (this._use_pool) {
-      // 从连接池获取连接
-      return await this._getPoolConnection();
-    } else {
-      // 单连接模式 - 替换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);
-    return null;
-  }
+  // 统一从连接池获取连接
+  return await this._pool.getConnection(acquire_timeout);
 };
 
 /**
@@ -323,23 +177,21 @@ SQLite.prototype.run = async function (sql, params = [], timeout = 30000) {
   }
 
   this.error = null;
+  this.sql = '';
   let conn = null;
   const query_timeout = timeout || this.config.query_timeout || 30000;
-
+  let ret = [];
   try {
     // 获取连接
     conn = await this.getConn(query_timeout);
-
-    const self = this;
-    // 替换Promise.race为更可靠的超时控制
     let timeout_id = null;
-    
-    const result = await new Promise((resolve, reject) => {
+
+    ret = await new Promise((resolve, reject) => {
       // 设置超时定时器
       timeout_id = setTimeout(() => {
         reject(new Error(`SQL查询超时: ${timeout}ms`));
       }, timeout);
-      
+
       // 执行SQL查询
       conn.all(sql, params || [], (error, rows) => {
         // 清除超时定时器
@@ -347,14 +199,8 @@ SQLite.prototype.run = async function (sql, params = [], timeout = 30000) {
           clearTimeout(timeout_id);
           timeout_id = null;
         }
-        
         if (error) {
-          self.sql = sql;
-          self.error = {
-            code: error.errno,
-            message: error.message
-          };
-          // 不抛出错误，保持与MySQL一致的错误处理行为
+          reject(error);
           resolve([]);
         } else {
           // 保持与MySQL兼容的返回值格式，始终返回数组
@@ -362,25 +208,19 @@ SQLite.prototype.run = async function (sql, params = [], timeout = 30000) {
         }
       });
     });
-
-    // 连接池模式下释放连接
-    if (this._use_pool && conn) {
-      this._releasePoolConnection(conn);
-    }
-
-    return result;
-  } catch (err) {
-    this.log('error', 'SQL执行失败', err);
-
-    // 连接池模式下释放连接
-    if (this._use_pool && conn) {
-      this._releasePoolConnection(conn);
-    }
-
-    // 简化错误处理：SQLite不需要复杂的连接错误处理
-    // 直接返回空数组，保持与MySQL一致的错误处理行为
-    return [];
+  } catch (error) {
+    this.log('error', 'SQL执行失败', error);
+    this.sql = sql;
+    this.error = {
+      code: error.errno,
+      message: error.message
+    };
+    ret = [];
+  }
+  finally {
+    await releaseConn(conn);
   }
+  return ret;
 };
 
 /**
@@ -404,22 +244,22 @@ SQLite.prototype.exec = async function (sql, params, timeout) {
   }
 
   this.error = null;
+  this.sql = '';
   let conn = null;
   timeout = timeout || this.config.query_timeout || 30000;
-
+  let ret = 0;
   try {
     // 获取连接
     conn = await this.getConn(timeout);
-    var _this = this;
+    this.sql = sql;
     // 替换Promise.race为更可靠的超时控制
     let timeout_id = null;
-    
-    const result = await new Promise((resolve, reject) => {
+    ret = await new Promise((resolve, reject) => {
       // 设置超时定时器
       timeout_id = setTimeout(() => {
         reject(new Error(`SQL执行超时: ${timeout}ms`));
       }, timeout);
-      
+
       // 执行SQL语句
       conn.run(sql, params || [], function (error) {
         // 清除超时定时器
@@ -427,40 +267,28 @@ SQLite.prototype.exec = async function (sql, params, timeout) {
           clearTimeout(timeout_id);
           timeout_id = null;
         }
-        
         if (error) {
-          _this.sql = sql;
-          _this.error = {
-            code: error.errno,
-            message: error.message
-          };
-          // 不抛出错误，保持与MySQL一致的错误处理行为
-          resolve(0);
+          reject(error);
         } else {
-          // 保持与MySQL兼容的返回值格式
           resolve(this.lastID || this.changes || 1);
         }
       });
     });
-
-    // 连接池模式下释放连接
-    if (this._use_pool && conn) {
-      this._releasePoolConnection(conn);
-    }
-
-    return result;
-  } catch (err) {
-    this.log('error', 'SQL执行失败', err);
-
-    // 连接池模式下释放连接
-    if (this._use_pool && conn) {
-      this._releasePoolConnection(conn);
-    }
-
+  } catch (error) {
+    this.log('error', 'SQL执行失败', error);
+    this.sql = sql;
+    this.error = {
+      code: error.errno,
+      message: error.message
+    };
     // 简化错误处理：SQLite不需要复杂的连接错误处理
     // 返回0，保持与MySQL一致的错误处理行为
-    return 0;
+    ret = 0;
   }
+  finally {
+    await releaseConn(conn);
+  }
+  return ret;
 };
 
 /**
@@ -483,59 +311,53 @@ SQLite.prototype.read = async function (table, condition, options) {
     throw new TypeError('options must be object');
   }
 
-  try {
-    // 检查连接状态
-    if (this._status !== 'connected') {
-      throw new Error('数据库连接未建立');
-    }
-
-    // 构建基础SQL查询
-    let sql = `SELECT * FROM ${table}`;
-    const params = [];
+  // 检查连接状态
+  if (this._status !== 'connected') {
+    throw new Error('数据库连接未建立');
+  }
 
-    // 处理条件
-    if (condition && Object.keys(condition).length > 0) {
-      const where_clauses = [];
-      for (const [field, value] of Object.entries(condition)) {
-        where_clauses.push(`${field} = ?`);
-        params.push(value);
-      }
-      sql += ` WHERE ${where_clauses.join(' AND ')}`;
-    }
+  // 构建基础SQL查询
+  let sql = `SELECT * FROM ${table}`;
+  const params = [];
 
-    // 处理排序
-    if (options && options.order_by) {
-      sql += ` ORDER BY ${options.order_by}`;
+  // 处理条件
+  if (condition && Object.keys(condition).length > 0) {
+    const where_clauses = [];
+    for (const [field, value] of Object.entries(condition)) {
+      where_clauses.push(`${field} = ?`);
+      params.push(value);
     }
+    sql += ` WHERE ${where_clauses.join(' AND ')}`;
+  }
 
-    // 处理分页
-    if (options && options.limit) {
-      sql += ` LIMIT ${options.limit}`;
-    }
+  // 处理排序
+  if (options && options.order_by) {
+    sql += ` ORDER BY ${options.order_by}`;
+  }
 
-    if (options && options.offset) {
-      sql += ` OFFSET ${options.offset}`;
-    }
+  // 处理分页
+  if (options && options.limit) {
+    sql += ` LIMIT ${options.limit}`;
+  }
 
-    // 记录查询日志
-    if (this.config.debug) {
-      this.log('debug', '查询数据', { sql, params });
-    }
+  if (options && options.offset) {
+    sql += ` OFFSET ${options.offset}`;
+  }
 
-    // 执行查询
-    const results = await this.run(sql, params);
+  // 记录查询日志
+  if (this.config.debug) {
+    this.log('debug', '查询数据', { sql, params });
+  }
 
-    if (this.config.debug) {
-      this.log('info', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
-    }
+  // 执行查询
+  const results = await this.run(sql, params);
 
-    // 确保返回数组格式
-    return Array.isArray(results) ? results : [results];
-  } catch (error) {
-    this.log('error', '查询失败', error);
-    // 返回空数组作为默认值，保持返回值类型一致
-    return [];
+  if (this.config.debug) {
+    this.log('debug', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
   }
+
+  // 确保返回数组格式
+  return Array.isArray(results) ? results : [results];
 };
 
 /**
@@ -582,7 +404,7 @@ SQLite.prototype.db = function () {
  * 开始事务
  * @returns {Promise<object>} 事务连接对象
  */
-SQLite.prototype.beginTrans = async function () {
+SQLite.prototype.beginTransaction = async function () {
   try {
     // 检查连接状态
     if (this._status !== 'connected') {
@@ -592,10 +414,15 @@ SQLite.prototype.beginTrans = async function () {
     // 获取连接
     const conn = await this.getConn();
 
+    // 标记连接为事务中
+    conn._in_transaction = true;
+
     // 开始事务
     await new Promise((resolve, reject) => {
       conn.run('BEGIN TRANSACTION', (error) => {
         if (error) {
+          // 事务开始失败，清除事务标记
+          conn._in_transaction = false;
           reject(error);
         } else {
           resolve();
@@ -624,10 +451,9 @@ SQLite.prototype.beginTrans = async function () {
           this.log('debug', '事务提交');
         }
 
-        // 连接池模式下释放连接
-        if (this._use_pool) {
-          this._releasePoolConnection(conn);
-        }
+        // 清除事务标记并释放连接
+        conn._in_transaction = false;
+        await releaseConn(conn);
       },
       rollback: async () => {
         await new Promise((resolve, reject) => {
@@ -642,11 +468,9 @@ SQLite.prototype.beginTrans = async function () {
         if (this.config.debug) {
           this.log('debug', '事务回滚');
         }
-
-        // 连接池模式下释放连接
-        if (this._use_pool) {
-          this._releasePoolConnection(conn);
-        }
+        // 清除事务标记并释放连接
+        conn._in_transaction = false;
+        await releaseConn(conn);
       },
       exec: async (sql, params) => {
         // 在事务中执行SQL
@@ -680,7 +504,7 @@ SQLite.prototype.beginTrans = async function () {
  * @returns {Promise<*>} 回调函数的返回值
  * @throws {TypeError} 当callback参数无效时
  */
-SQLite.prototype.trans = async function (callback) {
+SQLite.prototype.transaction = async function (callback) {
   // 参数校验
   if (typeof callback !== 'function') {
     throw new TypeError('callback must be function');
@@ -690,7 +514,7 @@ SQLite.prototype.trans = async function (callback) {
 
   try {
     // 开始事务
-    trans = await this.beginTrans();
+    trans = await this.beginTransaction();
 
     // 执行回调函数，传入事务对象
     const result = await callback(trans);
@@ -737,223 +561,6 @@ SQLite.prototype.table = function (name, key) {
   return db;
 };
 
-/**
- * 创建SQLite连接
- * @private
- * @returns {Promise<object>} 数据库连接对象
- */
-SQLite.prototype._createConnection = function () {
-  return new Promise((resolve, reject) => {
-    const db = new sqlite3.Database(this._getDbFilename(), (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(db);
-      }
-    });
-  });
-};
-
-/**
- * 初始化连接池
- * @private
- * @returns {Promise<void>}
- */
-SQLite.prototype._initPool = async function () {
-  if (this._pool_reaper) {
-    return; // 连接池已初始化
-  }
-
-  try {
-    // 创建最小连接数
-    for (let i = 0; i < this.config.pool_min; i++) {
-      const conn = await this._createConnection();
-      this._pool_connections.push(conn);
-      this._pool_available.push(conn);
-    }
-
-    // 启动连接回收器
-    this._pool_reaper = setInterval(() => {
-      this._reapIdleConnections();
-    }, this.config.pool_reap_interval);
-
-    this.log('debug', '连接池初始化完成', {
-      min: this.config.pool_min,
-      max: this.config.pool_max,
-      current: this._pool_connections.length
-    });
-  } catch (error) {
-    this.log('error', '连接池初始化失败', error);
-    throw error;
-  }
-};
-
-/**
- * 回收空闲连接
- * @private
- */
-SQLite.prototype._reapIdleConnections = function () {
-  const now = Date.now();
-  const idle_timeout = this.config.pool_idle_timeout;
-
-  for (let i = this._pool_available.length - 1; i >= 0; i--) {
-    const conn = this._pool_available[i];
-    if (conn._last_used && now - conn._last_used > idle_timeout) {
-      // 关闭并移除空闲连接
-      conn.close((err) => {
-        if (err) {
-          this.log('error', '关闭空闲连接失败', err);
-        }
-      });
-
-      // 从连接池中移除
-      const conn_idx = this._pool_connections.indexOf(conn);
-      if (conn_idx > -1) {
-        this._pool_connections.splice(conn_idx, 1);
-      }
-      this._pool_available.splice(i, 1);
-
-      this.log('debug', '回收空闲连接');
-    }
-  }
-};
-
-/**
- * 从连接池获取连接
- * @private
- * @returns {Promise<object>} 数据库连接
- */
-SQLite.prototype._getPoolConnection = async function () {
-  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;
-      }
-
-      // 检查是否有可用连接
-      if (this._pool_available.length > 0) {
-        const conn = this._pool_available.shift();
-        conn._last_used = Date.now();
-        cleanup();
-        resolve(conn);
-        return;
-      }
-
-      // 检查是否可以创建新连接
-      if (this._pool_connections.length < this.config.pool_max) {
-        this._createConnection()
-          .then(conn => {
-            this._pool_connections.push(conn);
-            conn._last_used = Date.now();
-            cleanup();
-            resolve(conn);
-          })
-          .catch(err => {
-            cleanup();
-            reject(err);
-          });
-        return;
-      }
-
-      // 没有可用连接，等待一段时间后重试（避免无限循环）
-      timeout_id = setTimeout(tryGetConnection, 50);
-    };
-
-    tryGetConnection();
-  });
-};
-
-/**
- * 释放连接回连接池
- * @private
- * @param {object} conn - 数据库连接
- */
-SQLite.prototype._releaseConn = function (conn) {
-  if (this._pool_connections.includes(conn)) {
-    conn._last_used = Date.now();
-    this._pool_available.push(conn);
-
-    // 处理等待队列
-    if (this._pool_waiting.length > 0) {
-      const waiting = this._pool_waiting.shift();
-      waiting.resolve(conn);
-    }
-  }
-};
-
-/**
- * 释放连接池连接
- * @private
- * @param {object} conn - 数据库连接
- */
-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();
-    const next_conn = this._pool_available.shift();
-    if (next_conn && waiting.resolve) {
-      waiting.resolve(next_conn);
-    }
-  }
-};
-
-/**
- * 关闭连接池
- * @private
- */
-SQLite.prototype._closePool = function () {
-  if (this._pool_reaper) {
-    clearInterval(this._pool_reaper);
-    this._pool_reaper = null;
-  }
-
-  // 关闭所有连接
-  this._pool_connections.forEach(conn => {
-    try {
-      conn.close((err) => {
-        if (err) {
-          this.log('error', '关闭连接池连接失败', err);
-        }
-      });
-    } catch (error) {
-      this.log('error', '关闭连接池连接异常', error);
-    }
-  });
-
-  this._pool_connections = [];
-  this._pool_available = [];
-  this._pool_waiting = [];
-
-  this.log('debug', '连接池已关闭');
-};
-
 /**
  * 确保连接池对象存在
  */
@@ -982,6 +589,18 @@ function sqliteAdmin(scope, config) {
   return obj;
 }
 
+/**
+ * 安全释放数据库连接
+ * @param {object} conn - 数据库连接对象
+ * @returns {Promise<void>}
+ */
+async function releaseConn(conn) {
+  if (!conn) {
+    return;
+  }
+  await conn.release();
+}
+
 // 模块导出
 exports.SQLite = SQLite;
 exports.sqliteAdmin = sqliteAdmin;