mm_sqlite 1.3.9 → 1.4.0

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参数无效时
@@ -270,32 +153,8 @@ SQLite.prototype.getConn = async function (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;
-      }
-    }
+    // 统一从连接池获取连接
+    return await this._pool.getConnection(acquire_timeout);
   } catch (error) {
     this.log('error', '获取连接失败', error);
     return null;
@@ -323,18 +182,16 @@ 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`));
@@ -347,14 +204,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 +213,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 +249,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 +272,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;
 };
 
 /**
@@ -526,7 +359,7 @@ SQLite.prototype.read = async function (table, condition, options) {
     const results = await this.run(sql, params);
 
     if (this.config.debug) {
-      this.log('info', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
+      this.log('debug', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
     }
 
     // 确保返回数组格式
@@ -592,10 +425,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 +462,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 +479,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
@@ -737,223 +572,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 +600,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;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_sqlite",
-    "version": "1.3.9",
+    "version": "1.4.0",
     "description": "高性能SQLite数据库操作模块，提供与mm_mysql完全兼容的API接口，支持异步操作、事务处理和批量操作",
     "main": "index.js",
     "scripts": {

package/pool.js

@@ -0,0 +1,246 @@
+const sqlite3 = require('sqlite3').verbose();
+
+/**
+ * SQLite连接池类
+ * @class SQLitePool
+ */
+class SQLitePool {
+  /**
+   * 构造函数
+   * @param {object} config - 连接池配置
+   * @param {function} getDbFilename - 获取数据库文件名的函数
+   * @param {function} log - 日志函数
+   */
+  constructor(config, getDbFilename, log) {
+    this.config = config;
+    this._getDbFilename = getDbFilename;
+    this.log = log;
+
+    // 连接池状态
+    this._pool_connections = [];
+    this._pool_available = [];
+    this._pool_waiting = [];
+    this._pool_reaper = null;
+    this._is_initialized = false;
+  }
+
+  /**
+   * 初始化连接池
+   * @returns {Promise<void>}
+   */
+  async init() {
+    if (this._is_initialized) {
+      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._is_initialized = true;
+    } catch (error) {
+      this.log('error', '连接池初始化失败', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 获取数据库连接
+   * @param {number} timeout - 超时时间(毫秒)
+   * @returns {Promise<object>} 数据库连接
+   */
+  async getConnection(timeout) {
+    const acquire_timeout = 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();
+              conn.release = () => this.releaseConn(conn);
+              cleanup();
+              resolve(conn);
+            })
+            .catch(err => {
+              cleanup();
+              reject(err);
+            });
+          return;
+        }
+
+        // 没有可用连接且无法创建新连接，加入等待队列
+        this._pool_waiting.push({
+          resolve: (conn) => {
+            cleanup();
+            resolve(conn);
+          },
+          reject: (err) => {
+            cleanup();
+            reject(err);
+          }
+        });
+
+        // 设置重试定时器
+        timeout_id = setTimeout(() => {
+          tryGetConnection();
+        }, 100);
+      };
+
+      tryGetConnection();
+    });
+  }
+
+  /**
+   * 释放连接
+   * @param {object} conn - 数据库连接
+   */
+  releaseConn(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);
+      }
+    }
+  }
+
+  /**
+   * 关闭连接池
+   */
+  close() {
+    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._is_initialized = false;
+  }
+
+  /**
+   * 获取连接池统计信息
+   * @returns {object} 统计信息
+   */
+  getStats() {
+    return {
+      total: this._pool_connections.length,
+      available: this._pool_available.length,
+      waiting: this._pool_waiting.length,
+      is_initialized: this._is_initialized
+    };
+  }
+
+  /**
+   * 创建SQLite连接
+   * @private
+   * @returns {Promise<object>} 数据库连接对象
+   */
+  _createConnection() {
+    return new Promise((resolve, reject) => {
+      const db = new sqlite3.Database(this._getDbFilename(), (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          db.release = () => this.releaseConn(db);
+          resolve(db);
+        }
+      });
+    });
+  }
+
+  /**
+   * 回收空闲连接
+   * @private
+   */
+  _reapIdleConnections() {
+    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);
+      }
+    }
+  }
+}
+
+module.exports = SQLitePool;