mm_sqlite 1.3.2 → 1.3.3

package/index.js

@@ -1,196 +1,937 @@
-require('mm_expand');
 const sqlite3 = require('sqlite3').verbose();
 const {
-	DB
+  DB
 } = require('./db');
+const { Base } = require('mm_expand');
 
-var pool = {};
-
-/// 数据库封装
-class Sqlite {
-	/**
-	 * @description 创建Redis帮助类函数 (构造函数)
-	 * @param {String} scope 作用域
-	 * @param {String} dir 当前路径
-	 * @constructor
-	 */
-	constructor(scope, dir) {
-		// 作用域
-		this.scope;
-		if (scope) {
-			this.scope = scope;
-		} else {
-			this.scope = $.val.scope + '';
-		}
-		// 当前目录
-		this.dir = __dirname;
-		if (dir) {
-			this.dir = dir;
-		}
-		// 错误提示
-		this.error;
-		/**
-		 * sql语句
-		 */
-		this.sql = "";
-		// 执行结果
-		this.results = [];
-		// 连接器
-		this.conn;
-		
-		// 数据库配置参数
-		this.config = {
-			// 服务器地址
-			host: "./db/".fullname(this.dir),
-			// 数据库
-			database: "mm"
-		};
-		
-		// 唯一标识符
-		this.identifier = this.config.host + "/" + this.config.database;
-		
-		// 定义当前类, 用于数据库实例化访问
-		var $this = this;
-		
-		/**
-		 * @description 查询sql
-		 * @param {String} sql 查询参
-		 * @param {Array} val 替换值
-		 * @return {Promise|Array} 异步构造器, 当await时返回执行结果
-		 */
-		this.run = function(sql, val) {
-			var _this = this;
-			this.sql = sql;
-			// 返回一个 Promise
-			return new Promise((resolve, reject) => {
-				$this.all(sql, val, function(err, rows) {
-					if (err) {
-						// reject(err);
-						_this.error = {
-							code: err.errno,
-							message: $.info(err).between('Error: ', ']')
-						};
-						resolve(rows);
-					} else {
-						_this.error = undefined;
-						resolve(rows);
-					}
-				});
-			});
-		};
-		
-		/**
-		 * @description 增删改sql
-		 * @param {String} sql 查询参
-		 * @param {Array} val 替换值
-		 * @return {Promise|Array} 异步构造器, 当await时返回执行结果
-		 */
-		this.exec = function(sql) {
-			var _this = this;
-			this.sql = sql;
-			// 返回一个 Promise
-			return new Promise((resolve, reject) => {
-				$this.exec(sql, function(err, rows) {
-					if (err) {
-						// reject(err);
-						_this.error = {
-							code: err.errno,
-							message: $.info(err).between('Error: ', ']')
-						};
-						resolve(false);
-					} else {
-						_this.error = undefined;
-						resolve(true);
-					}
-				});
-			});
-		};
-		
-		/**
-		 * @description 获取数据库管理器
-		 */
-		this.db = function() {
-			return new DB($this.config.database, $this.run, $this.exec);
-		};
-	}
+/**
+ * SQLite数据库操作类
+ * @class SQLite
+ * @augments Base
+ */
+class SQLite extends Base {
+  /**
+   * 默认配置
+   */
+  static config = {
+    dir: './db/'.fullname(),
+    user: 'root',
+    password: '',
+    database: 'mm',
+    charset: 'utf8mb4',
+    timezone: '+08:00',
+    connect_timeout: 20000,
+    acquire_timeout: 20000,
+    query_timeout: 20000,
+    connection_limit: 500,
+    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,
+    // 连接池相关配置
+    pool_min: 1,
+    pool_max: 5,
+    pool_acquire_timeout: 30000,
+    pool_idle_timeout: 60000,
+    pool_reap_interval: 1000
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config - 配置对象
+   */
+  constructor(config) {
+    const merged_cfg = { ...SQLite.config, ...config || {}};
+    super(merged_cfg);
+
+    this.config = merged_cfg;
+    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;
+  }
 }
 
 /**
- * 设置配置参数
- * @param {Object} cg 配置对象或配置路径
+ * 初始化服务
+ * @returns {Promise<void>}
  */
-Sqlite.prototype.setConfig = function(cg) {
-	var obj;
-	if (typeof(cg) === "string") {
-		obj = cg.loadJson(this.dir);
-	} else {
-		obj = cg;
-	}
-	$.push(this.config, obj);
-	this.identifier = this.config.host + "/" + this.config.database;
+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);
+  }
 };
 
 /**
- * @description 打开数据库, 如果没有则建立数据库连接再打开
+ * 获取数据库文件名
+ * @returns {string} 数据库文件名
  */
-Sqlite.prototype.open = function() {
-	if (!pool[this.identifier]) {
-		var file = this.config.host + this.config.database + '.db';
-		var _this = this;
-		pool[this.identifier] = new sqlite3.Database(file, sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE,
-			function(err) {
-				if (err) {
-					_this.error = {
-						code: err.errno,
-						message: $.info(err).between('Error: ', ']')
-					};
-				} else {
-					_this.error = undefined;
-				}
-			});
-	}
+SQLite.prototype._getDbFilename = function () {
+  var file = this.config.database;
+  if (file.indexOf('.') === -1) {
+    file += '.db';
+  }
+
+  return file.fullname(this.config.dir);
 };
+
 /**
- * @description 关闭连接
+ * 内部打开数据库连接
+ * @private
+ * @returns {Promise<void>}
  */
-Sqlite.prototype.close = function() {
-	if (pool[this.identifier]) {
-		pool[this.identifier].close();
-		pool[this.identifier] = null;
-	}
+SQLite.prototype._openInternal = async function () {
+  return new Promise((resolve, reject) => {
+    this._db = new sqlite3.Database(this._getDbFilename(), (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
 };
 
-// 定义当前类, 用于数据库实例化访问
-var $this = this;
+/**
+ * 打开数据库连接
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise<boolean>}
+ * @throws {TypeError} 当timeout参数无效时
+ */
+SQLite.prototype.open = async function (timeout) {
+  // 参数校验
+  if (timeout !== undefined && typeof timeout !== 'number') {
+    throw new TypeError('timeout must be number');
+  }
 
+  if (this._status === 'connected' || this._status === 'connecting') {
+    this.log('warn', '数据库连接已存在或正在连接中');
+    return true;
+  }
 
-exports.Sqlite = Sqlite;
+  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 {
+      // 使用单连接模式
+      const conn_promise = this._openInternal();
+      const timeout_promise = new Promise((unused_resolve, reject) => {
+        setTimeout(() => {
+          reject(new Error(`数据库连接超时(${connect_timeout}ms)`));
+        }, connect_timeout);
+      });
+
+      try {
+        await Promise.race([conn_promise, timeout_promise]);
+
+        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) {
+        this.log('error', '连接过程错误详情', connection_err);
+      }
+    }
+  } catch (err) {
+    this._status = 'closed';
+    this.log('error', '数据库连接失败', err);
+    return false;
+  }
+};
 
 /**
- * @description sqlite连接池
+ * 关闭数据库连接
+ * @returns {Promise<boolean>}
  */
-if (!$.pool.sqlite) {
-	$.pool.sqlite = {};
-}
+SQLite.prototype.close = function () {
+  if (this._status !== 'connected') {
+    this.log('warn', '数据库连接未建立');
+    return Promise.resolve(false);
+  }
+
+  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);
+      }
+    } catch (err) {
+      this.log('error', '关闭数据库连接时发生异常', err);
+      this._status = 'closed';
+      resolve(false);
+    }
+  });
+};
+
+/**
+ * 获取数据库连接
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise<object>}
+ * @throws {TypeError} 当timeout参数无效时
+ */
+SQLite.prototype.getConn = async function (timeout) {
+  // 参数校验
+  if (timeout !== undefined && typeof timeout !== 'number') {
+    throw new TypeError('timeout must be number');
+  }
+
+  const acquire_timeout = timeout || this.config.acquire_timeout || this.config.connect_timeout || 20000;
+
+  if (this._status !== 'connected') {
+    await this.open(acquire_timeout);
+  }
+
+  try {
+    if (this._use_pool) {
+      // 从连接池获取连接
+      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;
+    }
+  } catch (error) {
+    this.log('error', '获取连接失败', error);
+
+    if (error.code && (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(error);
+    }
+    return null;
+  }
+};
+
+/**
+ * 执行SQL查询
+ * @param {string} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise<object>}
+ * @throws {TypeError} 当sql参数无效时
+ */
+SQLite.prototype.run = async function (sql, params = [], timeout = 30000) {
+  // 参数校验
+  if (typeof sql !== 'string' || sql.trim() === '') {
+    throw new TypeError('sql must be non-empty string');
+  }
+  if (params !== undefined && !Array.isArray(params)) {
+    throw new TypeError('params must be array');
+  }
+  if (timeout !== undefined && typeof timeout !== 'number') {
+    throw new TypeError('timeout must be number');
+  }
+
+  this.error = null;
+  let conn = null;
+  const query_timeout = timeout || this.config.query_timeout || 30000;
+
+  try {
+    // 获取连接
+    conn = await this.getConn(query_timeout);
+
+    const self = this;
+    // 直接在方法内部实现超时控制
+    const query_promise = new Promise((resolve, reject) => {
+      conn.all(sql, params || [], (error, rows) => {
+        if (error) {
+          self.sql = sql;
+          self.error = {
+            code: error.errno,
+            message: error.message
+          };
+          // 不抛出错误，保持与MySQL一致的错误处理行为
+          resolve([]);
+        } else {
+          // 保持与MySQL兼容的返回值格式，始终返回数组
+          resolve(rows);
+        }
+      });
+    });
+
+    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);
+    }
+
+    return result;
+  } catch (err) {
+    this.log('error', 'SQL执行失败', err);
+
+    // 连接池模式下释放连接
+    if (this._use_pool && conn) {
+      this._releasePoolConnection(conn);
+    }
+
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(err);
+    }
+    // 返回空数组，保持与MySQL一致的错误处理行为
+    return [];
+  }
+};
+
+/**
+ * 执行SQL语句（用于执行非查询语句如INSERT/UPDATE/DELETE）
+ * @param {string} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise<object>}
+ * @throws {TypeError} 当sql参数无效时
+ */
+SQLite.prototype.exec = async function (sql, params, timeout) {
+  // 参数校验
+  if (typeof sql !== 'string' || sql.trim() === '') {
+    throw new TypeError('sql must be non-empty string');
+  }
+  if (params !== undefined && !Array.isArray(params)) {
+    throw new TypeError('params must be array');
+  }
+  if (timeout !== undefined && typeof timeout !== 'number') {
+    throw new TypeError('timeout must be number');
+  }
+
+  this.error = null;
+  let conn = null;
+  timeout = timeout || this.config.query_timeout || 30000;
+
+  try {
+    // 获取连接
+    conn = await this.getConn(timeout);
+    var _this = this;
+    // 直接在方法内部实现超时控制
+    const query_promise = new Promise((resolve, reject) => {
+      conn.run(sql, params || [], function (error) {
+        if (error) {
+          _this.sql = sql;
+          _this.error = {
+            code: error.errno,
+            message: error.message
+          };
+          // 不抛出错误，保持与MySQL一致的错误处理行为
+          resolve(0);
+        } else {
+          // 保持与MySQL兼容的返回值格式
+          resolve(this.lastID || this.changes || 1);
+        }
+      });
+    });
+
+    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);
+    }
+
+    return result;
+  } catch (err) {
+    this.log('error', 'SQL执行失败', err);
+
+    // 连接池模式下释放连接
+    if (this._use_pool && conn) {
+      this._releasePoolConnection(conn);
+    }
+
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(err);
+    }
+    // 返回0，保持与MySQL一致的错误处理行为
+    return 0;
+  }
+};
+
+/**
+ * 读取整张表的数据
+ * @param {string} table - 表名
+ * @param {object} condition - 查询条件
+ * @param {object} options - 选项（order_by, limit, offset等）
+ * @returns {Promise<Array>}
+ * @throws {TypeError} 当table参数无效时
+ */
+SQLite.prototype.read = async function (table, condition, options) {
+  // 参数校验
+  if (typeof table !== 'string' || table.trim() === '') {
+    throw new TypeError('table must be non-empty string');
+  }
+  if (condition !== undefined && (typeof condition !== 'object' || Array.isArray(condition))) {
+    throw new TypeError('condition must be object');
+  }
+  if (options !== undefined && (typeof options !== 'object' || Array.isArray(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 (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.order_by) {
+      sql += ` ORDER BY ${options.order_by}`;
+    }
+
+    // 处理分页
+    if (options && options.limit) {
+      sql += ` LIMIT ${options.limit}`;
+    }
+
+    if (options && options.offset) {
+      sql += ` OFFSET ${options.offset}`;
+    }
+
+    // 记录查询日志
+    if (this.config.debug) {
+      this.log('debug', '查询数据', { sql, params });
+    }
+
+    // 执行查询
+    const results = await this.run(sql, params);
+
+    if (this.config.debug) {
+      this.log('info', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
+    }
+
+    // 确保返回数组格式
+    return Array.isArray(results) ? results : [results];
+  } catch (error) {
+    this.log('error', '查询失败', error);
+    // 返回空数组作为默认值，保持返回值类型一致
+    return [];
+  }
+};
+
+/**
+ * 获取数据库管理器（保持兼容性）
+ * @returns {object} DB实例
+ */
+SQLite.prototype.db = function () {
+  return new DB(this);
+};
+
+// /**
+//  * 获取数据库操作实例
+//  * @param {String} database - 数据库名称
+//  * @returns {Object} 数据库操作实例
+//  * @throws {TypeError} 当database参数无效时
+//  */
+// SQLite.prototype.db = function (database) {
+//     // 参数校验
+//     if (database !== undefined && typeof database !== 'string') {
+//         throw new TypeError('database must be string');
+//     }
+
+//     if (this._status !== 'connected') {
+//         throw new Error('数据库连接未建立');
+//     }
+
+//     // 优化：缓存DB实例，避免重复创建
+//     if (!this._db_instance) {
+//         this._db_instance = new DB(this);
+
+//         // 为DB实例添加必要的方法，确保与MySQL接口兼容
+//         this._db_instance.run = this.run.bind(this);
+//         this._db_instance.exec = this.exec.bind(this);
+//     }
+
+//     if (database) {
+//         this._db_instance.database = database;
+//     }
+
+//     return this._db_instance;
+// };
+
+/**
+ * 开始事务
+ * @returns {Promise<object>} 事务连接对象
+ */
+SQLite.prototype.beginTrans = async function () {
+  try {
+    // 检查连接状态
+    if (this._status !== 'connected') {
+      throw new Error('数据库连接未建立');
+    }
+
+    // 获取连接
+    const conn = await this.getConn();
+
+    // 开始事务
+    await new Promise((resolve, reject) => {
+      conn.run('BEGIN TRANSACTION', (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    if (this.config.debug) {
+      this.log('debug', '事务开始');
+    }
+
+    // 返回事务连接对象，包含提交和回滚方法
+    return {
+      conn,
+      commit: async () => {
+        await new Promise((resolve, reject) => {
+          conn.run('COMMIT', (error) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
+            }
+          });
+        });
+        if (this.config.debug) {
+          this.log('debug', '事务提交');
+        }
+
+        // 连接池模式下释放连接
+        if (this._use_pool) {
+          this._releasePoolConnection(conn);
+        }
+      },
+      rollback: async () => {
+        await new Promise((resolve, reject) => {
+          conn.run('ROLLBACK', (error) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
+            }
+          });
+        });
+        if (this.config.debug) {
+          this.log('debug', '事务回滚');
+        }
+
+        // 连接池模式下释放连接
+        if (this._use_pool) {
+          this._releasePoolConnection(conn);
+        }
+      },
+      exec: async (sql, params) => {
+        // 在事务中执行SQL
+        return new Promise((resolve, reject) => {
+          conn.run(sql, params || [], function (error) {
+            if (error) {
+              this.sql = error.sql;
+              this.error = {
+                code: error.errno,
+                message: error.message
+              };
+              reject(error);
+              resolve(0);
+            } else {
+              resolve(this.lastID || this.changes || 1);
+            }
+          });
+        });
+      }
+    };
+  } catch (error) {
+    this.log('error', '事务开始失败', error);
+    // 重新抛出异常，因为调用方需要事务对象
+    throw error;
+  }
+};
+
+/**
+ * 在事务中执行多个操作
+ * @param {Function} callback - 包含事务操作的回调函数
+ * @returns {Promise<*>} 回调函数的返回值
+ * @throws {TypeError} 当callback参数无效时
+ */
+SQLite.prototype.trans = async function (callback) {
+  // 参数校验
+  if (typeof callback !== 'function') {
+    throw new TypeError('callback must be function');
+  }
+
+  let trans = null;
+
+  try {
+    // 开始事务
+    trans = await this.beginTrans();
+
+    // 执行回调函数，传入事务对象
+    const result = await callback(trans);
+
+    // 提交事务
+    await trans.commit();
+
+    return result;
+  } catch (error) {
+    // 如果有事务，回滚
+    if (trans) {
+      await trans.rollback().catch(err => {
+        this.log('error', '事务回滚失败', err);
+      });
+    }
+
+    this.log('error', '事务执行失败', error);
+    // 重新抛出异常，因为调用方需要事务执行结果
+    throw error;
+  }
+};
+
+/**
+ * 设置当前操作的表名
+ * @param {string} name - 表名
+ * @param {string} key  - 主键
+ * @returns {object} 数据库操作实例
+ * @throws {TypeError} 当name参数无效时
+ */
+SQLite.prototype.table = function (name, key) {
+  // 参数校验
+  if (typeof name !== 'string' || name.trim() === '') {
+    throw new TypeError('name must be non-empty string');
+  }
+  if (key !== undefined && typeof key !== 'string') {
+    throw new TypeError('key must be string');
+  }
+
+  var db = this.db();
+  db.table = name;
+  if (key) {
+    db.key = key;
+  }
+  return db;
+};
+
 /**
- * @description sqlite管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {String} dir 当前路径
- * @return {Object} 返回一个缓存类
- */
-function sqlite_admin(scope, dir) {
-	if (!scope) {
-		scope = $.val.scope
-	}
-	var obj = $.pool.sqlite[scope];
-	if (!obj) {
-		$.pool.sqlite[scope] = new Sqlite(scope, dir);
-		obj = $.pool.sqlite[scope];
-	}
-	return obj;
+ * 创建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;
+  const start_time = Date.now();
+
+  return new Promise((resolve, reject) => {
+    const tryGetConnection = () => {
+      // 检查超时
+      if (Date.now() - start_time > acquire_timeout) {
+        reject(new Error(`获取连接超时(${acquire_timeout}ms)`));
+        return;
+      }
+
+      // 检查是否有可用连接
+      if (this._pool_available.length > 0) {
+        const conn = this._pool_available.shift();
+        conn._last_used = Date.now();
+        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();
+            resolve(conn);
+          })
+          .catch(reject);
+        return;
+      }
+
+      // 没有可用连接，等待一段时间后重试
+      setTimeout(tryGetConnection, 100);
+    };
+
+    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', '连接池已关闭');
+};
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+  $.pool = {};
 }
+if (!$.pool.sqlite) {
+  $.pool.sqlite = {};
+}
+
 /**
- * @module 导出sqlite管理器
+ * Sqlite管理器，用于创建缓存
+ * @param {string} scope 作用域
+ * @param {object} config 配置参数
+ * @returns {object} 返回一个Sqlite类实例
  */
-exports.sqlite_admin = sqlite_admin;
+function sqliteAdmin(scope, config) {
+  if (!scope) {
+    scope = 'sys';
+  }
+  var obj = $.pool.sqlite[scope];
+  if (!obj) {
+    $.pool.sqlite[scope] = new SQLite(config);
+    obj = $.pool.sqlite[scope];
+  }
+  return obj;
+}
+
+// 模块导出
+exports.SQLite = SQLite;
+exports.sqliteAdmin = sqliteAdmin;