mm_sqlite 1.3.9 → 1.4.2

package/package.json

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

package/pool.js

@@ -0,0 +1,241 @@
+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;
+    }
+
+    // 创建最小连接数
+    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;
+  }
+
+  /**
+   * 获取数据库连接
+   * @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;