mm_sqlite 1.1.4 → 1.1.5

package/index.js

@@ -1,55 +1,71 @@
 const sqlite3 = require('sqlite3').verbose();
-const DB = require('./db');
-const { BaseService } = require('mm_base_service');
+const {
+    DB
+} = require('./db');
+const { Base } = require('mm_expand');
+
 /**
  * SQLite数据库操作类
  * @class Sqlite
- * @extends BaseService
+ * @extends Base
  */
-class Sqlite extends BaseService {
-  /**
-   * 默认配置
-   */
-  static default_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: 1,
-    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
-  };
-
-  /**
-   * 构造函数
-   * @param {Object} config - 配置对象
-   */
-  constructor(config) {
-    const merged_config = Object.assign({}, Sqlite.default_config, config || {});
-    super(merged_config);
-
-    this.config = merged_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;
-  }
+class Sqlite extends Base {
+    /**
+     * 默认配置
+     */
+    static default_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: 1,
+        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_config = Object.assign({}, Sqlite.default_config, config || {});
+        super(merged_config);
+
+        this.config = merged_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;
+    }
 }
 
 /**
@@ -57,123 +73,112 @@ class Sqlite extends BaseService {
  * @returns {Promise<void>}
  */
 Sqlite.prototype._initService = async function () {
-  if (this._is_inited) {
-    $.log.warn('SQLite服务已初始化');
-    return;
-  }
-
-  try {
-    $.log.debug('[Sqlite] [_initService]', '初始化SQLite服务', { config: this.config });
-    this._is_inited = true;
-    $.log.debug('[Sqlite] [_initService]', 'SQLite服务初始化完成');
-  } catch (error) {
-    $.log.error('[Sqlite] [_initService]', 'SQLite服务初始化失败', { error: error.message });
-    throw error;
-  }
+    if (this._is_inited) {
+        this.logger('warn', 'SQLite服务已初始化');
+        return;
+    }
+
+    try {
+        this.logger('debug', '初始化SQLite服务', { config: this.config });
+        this._is_inited = true;
+        this.logger('debug', 'SQLite服务初始化完成');
+    } catch (error) {
+        this.logger('error', 'SQLite服务初始化失败', error);
+    }
 };
 
 /**
- * 打开数据库连接
- * @param {Number} timeout - 超时时间(毫秒)
- * @returns {Promise<boolean>}
+ * 获取数据库文件名
+ * @returns {string} 数据库文件名
  */
-Sqlite.prototype.open = async function (timeout) {
-  if (this._status === 'connected' || this._status === 'connecting') {
-    $.log.warn('数据库连接已存在或正在连接中');
-    return true;
-  }
-
-  timeout = timeout || this.config.connect_timeout || 10000;
-  this._status = 'connecting';
-
-  try {
-    // 创建连接
-    const connection_promise = this._openInternal();
-    const timeout_promise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`数据库连接超时(${timeout}ms)`));
-      }, timeout);
-    });
+Sqlite.prototype._getDbFilename = function () {
+    var file = this.config.database;
+    if (file.indexOf(".") === -1) {
+        file += ".db";
+    }
 
-    try {
-      await Promise.race([connection_promise, timeout_promise]);
-
-      this._last_connect_time = Date.now();
-      this._status = 'connected';
-      $.log.info(`[${this.constructor.name}] [open]`, '数据库连接成功', {
-        dir: this.config.dir,
-        database: this.config.database
-      });
-      return true;
-    } catch (connection_err) {
-      $.log.error(`[${this.constructor.name}] [open]`, '连接过程错误详情', {
-        error: connection_err.message,
-        code: connection_err.code,
-        syscall: connection_err.syscall,
-        address: connection_err.address,
-        dir: connection_err.dir,
-        stack: connection_err.stack
-      });
-      throw connection_err;
-    }
-  } catch (err) {
-    this._status = 'closed';
-    $.log.error(`[${this.constructor.name}] [open]`, '数据库连接失败', {
-      error: err.message,
-      dir: this.config.dir,
-      database: this.config.database
-    });
-    throw err;
-  }
-};
+    return file.fullname(this.config.dir);
+}
 
 /**
- * 内部连接方法
+ * 内部打开数据库连接
  * @private
  * @returns {Promise<void>}
  */
-Sqlite.prototype._openInternal = function () {
-  return new Promise((resolve, reject) => {
-    try {
-
-      // 确保数据库目录存在
-      const file = this._getDatabasePath();
+Sqlite.prototype._openInternal = async function () {
+    return new Promise((resolve, reject) => {
+        this._db = new sqlite3.Database(this._getDbFilename(), (err) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve();
+            }
+        });
+    });
+};
 
-      if (!file.hasDir()) {
-        file.addDir();
-      }
+/**
+ * 打开数据库连接
+ * @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');
+    }
 
-      // 创建数据库连接
-      this._db = new sqlite3.Database(file);
-      this._open = true;
-      this._conn_retry_count = 0;
+    if (this._status === 'connected' || this._status === 'connecting') {
+        this.logger('warn', '数据库连接已存在或正在连接中');
+        return true;
+    }
 
-      // 设置连接错误处理
-      this._db.on('error', (err) => {
-        $.log.error('SQLite数据库连接错误:', err);
-        this._handleConnectionError(err);
-      });
+    timeout = timeout || this.config.connect_timeout || 10000;
+    this._status = 'connecting';
 
-      $.log.debug(`SQLite数据库已打开: ${file}`);
-      resolve();
-    } catch (error) {
-      reject(error);
+    try {
+        this.config.dir.addDir();
+        if (this._use_pool) {
+            // 使用连接池模式
+            await this._initPool();
+            this._last_connect_time = Date.now();
+            this._status = 'connected';
+            this.logger('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 connection_promise = this._openInternal();
+            const timeout_promise = new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`数据库连接超时(${timeout}ms)`));
+                }, timeout);
+            });
+
+            try {
+                await Promise.race([connection_promise, timeout_promise]);
+
+                this._last_connect_time = Date.now();
+                this._status = 'connected';
+                this.logger('info', '数据库连接成功', {
+                    dir: this.config.dir,
+                    database: this.config.database
+                });
+                return true;
+            } catch (connection_err) {
+                this.logger('error', '连接过程错误详情', connection_err);
+            }
+        }
+    } catch (err) {
+        this._status = 'closed';
+        this.logger('error', '数据库连接失败', err);
+        return false;
     }
-  });
-};
-
-/**
- * 获取数据库路径
- * @private
- * @returns {String}
- */
-Sqlite.prototype._getDatabasePath = function () {
-  const db_name = this.config.database || 'mm';
-  if (db_name.endsWith('.db')) {
-    db_name = db_name.replace('.db', '');
-  }
-  const db_dir = this.config.dir || '/db/'.fullname();
-  return `./${db_name}.db`.fullname(db_dir);
 };
 
 /**
@@ -181,168 +186,91 @@ Sqlite.prototype._getDatabasePath = function () {
  * @returns {Promise<boolean>}
  */
 Sqlite.prototype.close = function () {
-  if (this._status !== 'connected') {
-    $.log.warn('数据库连接未建立');
-    return Promise.resolve(false);
-  }
-
-  return new Promise((resolve) => {
-    try {
-      if (this._db) {
-        $.log.debug('关闭数据库连接');
-        this._db.close((err) => {
-          if (err) {
-            $.log.error('关闭数据库失败', { error: err.message });
-          } else {
-            $.log.info('数据库已关闭');
-          }
-          this._db = null;
-          this._open = false;
-          this._status = 'closed';
-          resolve(!err);
-        });
-      } else {
-        this._status = 'closed';
-        resolve(true);
-      }
-    } catch (err) {
-      $.log.error('关闭数据库连接时发生异常', { error: err.message });
-      this._status = 'closed';
-      resolve(false);
+    if (this._status !== 'connected') {
+        this.logger('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.logger('info', '数据库连接池已关闭');
+                resolve(true);
+            } else if (this._db) {
+                // 单连接模式
+                this.logger('debug', '关闭数据库连接');
+                this._db.close((err) => {
+                    if (err) {
+                        this.logger('error', '关闭数据库失败', err);
+                    } else {
+                        this.logger('info', '数据库已关闭');
+                    }
+                    this._db = null;
+                    this._open = false;
+                    this._status = 'closed';
+                    resolve(!err);
+                });
+            } else {
+                this._status = 'closed';
+                resolve(true);
+            }
+        } catch (err) {
+            this.logger('error', '关闭数据库连接时发生异常', err);
+            this._status = 'closed';
+            resolve(false);
+        }
+    });
 };
 
 /**
  * 获取数据库连接
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise<Object>}
+ * @throws {TypeError} 当timeout参数无效时
  */
 Sqlite.prototype.getConn = async function (timeout) {
-  timeout = timeout || this.config.acquire_timeout || this.config.connect_timeout || 20000;
-
-  // $.log.debug(`[${this.constructor.name}] [getConn] 使用超时时间: ${timeout}ms`);
-
-  if (this._status !== 'connected') {
-    throw new Error('数据库连接未建立');
-  }
-
-  try {
-    const connection_promise = new Promise((resolve) => {
-      resolve(this._db);
-    });
-    const timeout_promise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`获取数据库连接超时(${timeout}ms)`));
-      }, timeout);
-    });
-
-    const conn = await Promise.race([connection_promise, timeout_promise]);
-
-    // $.log.debug(`[${this.constructor.name}] [getConn] 成功获取数据库连接`);
-
-    // 处理连接错误
-    conn.on('error', (err) => {
-      if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
-        this._handleConnectionError(err);
-      }
-    });
-
-    return conn;
-  } catch (error) {
-    $.log.error(`[${this.constructor.name}] [getConn] 获取连接失败`, {
-      error: error.message
-    });
-
-    if (error.code && (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT')) {
-      this._handleConnectionError(error);
+    // 参数校验
+    if (timeout !== undefined && typeof timeout !== 'number') {
+        throw new TypeError('timeout must be number');
     }
 
-    throw error;
-  }
-};
+    timeout = timeout || this.config.acquire_timeout || this.config.connect_timeout || 20000;
 
-/**
- * 处理连接错误
- * @private
- * @param {Error} err - 错误对象
- */
-Sqlite.prototype._handleConnectionError = function (err) {
-  if (this._reconnecting) {
-    $.log.debug('重连已在进行中');
-    return;
-  }
-
-  if (this.config.enable_reconnect) {
-    $.log.info('开始自动重连...');
-    this._reconnect(this.config.max_reconnect_attempts || 3)
-      .catch(reconnect_err => {
-        $.log.error('重连失败', { error: reconnect_err.message });
-        this._status = 'closed';
-      });
-  } else {
-    $.log.warn('自动重连已禁用');
-    this._status = 'closed';
-  }
-};
+    if (this._status !== 'connected') {
+        throw new Error('数据库连接未建立');
+    }
 
-/**
- * 重新连接数据库
- * @private
- * @param {Number} max_retries - 最大重试次数
- * @returns {Promise<boolean>}
- */
-Sqlite.prototype._reconnect = async function (max_retries) {
-  if (this._reconnecting) {
-    $.log.warn('重连已在进行中');
-    return false;
-  }
-
-  this._reconnecting = true;
-  let retry_count = 0;
-
-  try {
-    // 先关闭现有连接
-    if (this._status === 'connected') {
-      await this.close();
-    }
-
-    while (retry_count < max_retries) {
-      retry_count++;
-      $.log.info(`第${retry_count}/${max_retries}次尝试重连`);
-
-      try {
-        const reconnect_timeout = this.config.connect_timeout || this.config.acquire_timeout || 20000;
-        $.log.debug(`重连超时设置为: ${reconnect_timeout}ms`);
-        await this.open(reconnect_timeout);
-        $.log.info('重连成功');
-        return true;
-      } catch (err) {
-        $.log.error(`重连失败(${retry_count}/${max_retries})`, { error: err.message });
+    try {
+        if (this._use_pool) {
+            // 从连接池获取连接
+            return await this._getPoolConnection();
+        } else {
+            // 单连接模式
+            const connection_promise = new Promise((resolve) => {
+                resolve(this._db);
+            });
+            const timeout_promise = new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`获取数据库连接超时(${timeout}ms)`));
+                }, timeout);
+            });
+
+            const conn = await Promise.race([connection_promise, timeout_promise]);
+            return conn;
+        }
+    } catch (error) {
+        this.logger('error', '获取连接失败', error);
 
-        if (retry_count < max_retries) {
-          const wait_time = this.config.reconnect_interval || 1000;
-          $.log.debug(`等待${wait_time}ms后重试`);
-          await this._sleep(wait_time);
+        if (error.code && (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT')) {
+            this._handleConnectionError(error);
         }
-      }
+        return null;
     }
-
-    $.log.error(`达到最大重试次数(${max_retries})，重连失败`);
-    throw new Error(`重连失败：达到最大重试次数(${max_retries})`);
-  } finally {
-    this._reconnecting = false;
-  }
-};
-
-/**
- * 休眠函数
- * @private
- * @param {Number} ms - 休眠时间(毫秒)
- * @returns {Promise<void>}
- */
-Sqlite.prototype._sleep = function (ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
 };
 
 /**
@@ -351,50 +279,82 @@ Sqlite.prototype._sleep = function (ms) {
  * @param {Array} params - 参数数组
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise<Object>}
+ * @throws {TypeError} 当sql参数无效时
  */
 Sqlite.prototype.run = async function (sql, params, timeout) {
-  let conn = null;
-  timeout = timeout || this.config.query_timeout || 30000;
-
-  try {
-    // 获取连接
-    conn = await this.getConn(timeout);
-
-    // 直接在方法内部实现超时控制
-    const query_promise = new Promise((resolve, reject) => {
-      conn.all(sql, params || [], (error, rows) => {
-        if (error) {
-          reject(error);
-        } else {
-          // 保持与MySQL兼容的返回值格式，始终返回数组
-          resolve(rows);
-        }
-      });
-    });
+    // 参数校验
+    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');
+    }
 
-    const timeout_promise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`SQL查询超时: ${timeout}ms`));
-      }, timeout);
-    });
+    this.error = null;
+    let conn = null;
+    timeout = timeout || this.config.query_timeout || 30000;
 
-    const result = await Promise.race([query_promise, timeout_promise]);
+    try {
+        // 获取连接
+        conn = await this.getConn(timeout);
+
+        var _this = this;
+        // 直接在方法内部实现超时控制
+        const query_promise = new Promise((resolve, reject) => {
+            conn.all(sql, params || [], (error, rows) => {
+                if (error) {
+                    _this.sql = sql;
+                    _this.error = {
+                        code: error.errno,
+                        message: error.message
+                    }
+                    reject(error);
+                } else {
+                    // 保持与MySQL兼容的返回值格式，始终返回数组
+                    resolve(rows);
+                }
+            });
+        });
 
-    return result;
-  } catch (err) {
-    $.log.error('[Sqlite] [run]', 'SQL执行失败', {
-      error: err.message,
-      sql: typeof sql === 'string' ? sql.substring(0, 200) : sql,
-      params: params
-    });
+        const timeout_promise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`SQL查询超时: ${timeout}ms`));
+            }, timeout);
+        });
 
-    // 处理连接错误，触发重连
-    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
-      this._handleConnectionError(err);
-    }
+        const result = await Promise.race([query_promise, timeout_promise]);
+
+        // 连接池模式下释放连接
+        if (this._use_pool && conn) {
+            this._releasePoolConnection(conn);
+        }
 
-    throw err;
-  }
+        return result;
+    } catch (err) {
+        this.logger('error', 'SQL执行失败', err);
+
+        // 连接池模式下释放连接
+        if (this._use_pool && conn) {
+            this._releasePoolConnection(conn);
+        }
+
+        // 处理连接错误，触发重连
+        if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+            this._handleConnectionError(err);
+        }
+        this.sql = sql;
+        // 记录错误信息
+        this.error = {
+            code: err.code,
+            message: err.message
+        };
+
+        // 返回空数组作为默认值，保持返回值类型一致
+        return [];
+    }
 };
 
 /**
@@ -403,54 +363,82 @@ Sqlite.prototype.run = async function (sql, params, timeout) {
  * @param {Array} params - 参数数组
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise<Object>}
+ * @throws {TypeError} 当sql参数无效时
  */
 Sqlite.prototype.exec = async function (sql, params, timeout) {
-  let conn = null;
-  timeout = timeout || this.config.query_timeout || 30000;
-
-  try {
-    // 获取连接
-    conn = await this.getConn(timeout);
-
-    // 直接在方法内部实现超时控制
-    const query_promise = new Promise((resolve, reject) => {
-      conn.run(sql, params || [], function (error) {
-        if (error) {
-          reject(error);
-        } else {
-          // 保持与MySQL兼容的返回值格式
-          resolve({
-            affected_rows: this.changes || 0,
-            insert_id: this.lastID || 0,
-            changed_rows: this.changes || 0
-          });
-        }
-      });
-    });
+    // 参数校验
+    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');
+    }
 
-    const timeout_promise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`SQL执行超时: ${timeout}ms`));
-      }, timeout);
-    });
+    this.error = null;
+    let conn = null;
+    timeout = timeout || this.config.query_timeout || 30000;
 
-    const result = await Promise.race([query_promise, timeout_promise]);
+    try {
+        // 获取连接
+        conn = await this.getConn(timeout);
+        var _this = this;
+        // 直接在方法内部实现超时控制
+        const query_promise = new Promise((resolve, reject) => {
+            conn.run(sql, params || [], function (error, rows) {
+                if (error) {
+                    _this.sql = error.sql;
+                    _this.error = {
+                        code: error.errno,
+                        message: error.message
+                    }
+                    reject(error);
+                    resolve(0);
+                } else {
+                    // 保持与MySQL兼容的返回值格式
+                    resolve(this.lastID || this.changes || 1);
+                }
+            });
+        });
 
-    return result;
-  } catch (err) {
-    $.log.error('[Sqlite] [exec]', 'SQL执行失败', {
-      error: err.message,
-      sql: sql.substring(0, 200),
-      params: params
-    });
+        const timeout_promise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`SQL执行超时: ${timeout}ms`));
+            }, timeout);
+        });
 
-    // 处理连接错误，触发重连
-    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
-      this._handleConnectionError(err);
-    }
+        const result = await Promise.race([query_promise, timeout_promise]);
+
+        // 连接池模式下释放连接
+        if (this._use_pool && conn) {
+            this._releasePoolConnection(conn);
+        }
+
+        return result;
+    } catch (err) {
+        this.logger('error', 'SQL执行失败', err);
+
+        // 连接池模式下释放连接
+        if (this._use_pool && conn) {
+            this._releasePoolConnection(conn);
+        }
 
-    throw err;
-  }
+        // 处理连接错误，触发重连
+        if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+            this._handleConnectionError(err);
+        }
+        this.sql = sql;
+        // 记录错误信息
+        this.error = {
+            code: err.code,
+            message: err.message
+        };
+
+        // 返回默认操作结果对象，保持返回值类型一致
+        return 0;
+    }
 };
 
 /**
@@ -459,101 +447,105 @@ Sqlite.prototype.exec = async function (sql, params, timeout) {
  * @param {Object} condition - 查询条件
  * @param {Object} options - 选项（order_by, limit, offset等）
  * @returns {Promise<Array>}
+ * @throws {TypeError} 当table参数无效时
  */
 Sqlite.prototype.read = async function (table, condition, options) {
-  try {
-    // 检查连接状态
-    if (this._status !== 'connected') {
-      throw new Error('数据库连接未建立');
+    // 参数校验
+    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');
     }
 
-    // 构建基础SQL查询
-    let sql = `SELECT * FROM ${table}`;
-    const params = [];
+    try {
+        // 检查连接状态
+        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) {
-      $.log.debug(`[${this.constructor.name}] [read] 查询数据`, { sql, params });
-    }
+        if (options && options.offset) {
+            sql += ` OFFSET ${options.offset}`;
+        }
 
-    // 执行查询
-    const results = await this.run(sql, params);
+        // 记录查询日志
+        if (this.config.debug) {
+            this.logger('debug', '查询数据', { sql, params });
+        }
 
-    if (this.config.debug) {
-      $.log.info(`[${this.constructor.name}] [read] 查询成功`, { count: Array.isArray(results) ? results.length : 1 });
-    }
+        // 执行查询
+        const results = await this.run(sql, params);
 
-    // 确保返回数组格式
-    return Array.isArray(results) ? results : [results];
-  } catch (error) {
-    // 记录错误日志
-    $.log.error(`[${this.constructor.name}] [read] 查询失败`, {
-      error: error.message,
-      table: table,
-      condition: condition
-    });
+        if (this.config.debug) {
+            this.logger('info', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
+        }
 
-    // 抛出错误
-    throw error;
-  }
+        // 确保返回数组格式
+        return Array.isArray(results) ? results : [results];
+    } catch (error) {
+        this.logger('error', '查询失败', error);
+        // 返回空数组作为默认值，保持返回值类型一致
+        return [];
+    }
 };
 
 /**
  * 获取数据库操作实例
  * @param {String} database - 数据库名称
  * @returns {Object} 数据库操作实例
+ * @throws {TypeError} 当database参数无效时
  */
 Sqlite.prototype.db = function (database) {
-  if (this._status !== 'connected') {
-    throw new Error('数据库连接未建立');
-  }
+    // 参数校验
+    if (database !== undefined && typeof database !== 'string') {
+        throw new TypeError('database must be string');
+    }
 
-  // 优化：缓存DB实例，避免重复创建
-  if (!this._db_instance) {
-    this._db_instance = new DB(this);
+    if (this._status !== 'connected') {
+        throw new Error('数据库连接未建立');
+    }
 
-    // 为DB实例添加必要的方法，确保与MySQL接口兼容
-    this._db_instance.run = this.run.bind(this);
-    this._db_instance.exec = this.exec.bind(this);
-  }
+    // 优化：缓存DB实例，避免重复创建
+    if (!this._db_instance) {
+        this._db_instance = new DB(this);
 
-  if (database) {
-    this._db_instance.database = database;
-  }
+        // 为DB实例添加必要的方法，确保与MySQL接口兼容
+        this._db_instance.run = this.run.bind(this);
+        this._db_instance.exec = this.exec.bind(this);
+    }
 
-  return this._db_instance;
-};
+    if (database) {
+        this._db_instance.database = database;
+    }
 
-/**
- * 获取数据库管理器模型
- * @returns {Object} 数据库管理器模型
- */
-Sqlite.prototype.dbs = function () {
-  return this.db();
+    return this._db_instance;
 };
 
 /**
@@ -561,116 +553,134 @@ Sqlite.prototype.dbs = function () {
  * @returns {Promise<Object>} 事务连接对象
  */
 Sqlite.prototype.beginTransaction = async function () {
-  try {
-    // 检查连接状态
-    if (this._status !== 'connected') {
-      throw new Error('数据库连接未建立');
-    }
-
-    // 获取连接
-    const connection = await this.getConn();
-
-    // 开始事务
-    await new Promise((resolve, reject) => {
-      connection.run('BEGIN TRANSACTION', (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
+    try {
+        // 检查连接状态
+        if (this._status !== 'connected') {
+            throw new Error('数据库连接未建立');
         }
-      });
-    });
 
-    if (this.config.debug) {
-      $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务开始`);
-    }
+        // 获取连接
+        const connection = await this.getConn();
 
-    // 返回事务连接对象，包含提交和回滚方法
-    return {
-      connection,
-      commit: async () => {
+        // 开始事务
         await new Promise((resolve, reject) => {
-          connection.run('COMMIT', (error) => {
-            if (error) {
-              reject(error);
-            } else {
-              resolve();
-            }
-          });
-        });
-        if (this.config.debug) {
-          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务提交`);
-        }
-      },
-      rollback: async () => {
-        await new Promise((resolve, reject) => {
-          connection.run('ROLLBACK', (error) => {
-            if (error) {
-              reject(error);
-            } else {
-              resolve();
-            }
-          });
+            connection.run('BEGIN TRANSACTION', (error) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve();
+                }
+            });
         });
+
         if (this.config.debug) {
-          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务回滚`);
+            this.logger('debug', '事务开始');
         }
-      },
-      exec: async (sql, params) => {
-        // 在事务中执行SQL
-        return new Promise((resolve, reject) => {
-          connection.run(sql, params || [], function (error) {
-            if (error) {
-              reject(error);
-            } else {
-              resolve({
-                affected_rows: this.changes,
-                insert_id: this.lastID,
-                changed_rows: this.changes,
-                last_id: this.lastID,
-                changes: this.changes
-              });
+
+        // 返回事务连接对象，包含提交和回滚方法
+        return {
+            connection,
+            commit: async () => {
+                await new Promise((resolve, reject) => {
+                    connection.run('COMMIT', (error) => {
+                        if (error) {
+                            reject(error);
+                        } else {
+                            resolve();
+                        }
+                    });
+                });
+                if (this.config.debug) {
+                    this.logger('debug', '事务提交');
+                }
+
+                // 连接池模式下释放连接
+                if (this._use_pool) {
+                    this._releasePoolConnection(connection);
+                }
+            },
+            rollback: async () => {
+                await new Promise((resolve, reject) => {
+                    connection.run('ROLLBACK', (error) => {
+                        if (error) {
+                            reject(error);
+                        } else {
+                            resolve();
+                        }
+                    });
+                });
+                if (this.config.debug) {
+                    this.logger('debug', '事务回滚');
+                }
+
+                // 连接池模式下释放连接
+                if (this._use_pool) {
+                    this._releasePoolConnection(connection);
+                }
+            },
+            exec: async (sql, params) => {
+                // 在事务中执行SQL
+                return new Promise((resolve, reject) => {
+                    connection.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) {
-    $.log.error(`[${this.constructor.name}] [beginTransaction] 事务开始失败`, { error: error.message });
-    throw error;
-  }
+        };
+    } catch (error) {
+        this.logger('error', '事务开始失败', error);
+        // 重新抛出异常，因为调用方需要事务对象
+        throw error;
+    }
 };
 
 /**
  * 在事务中执行多个操作
  * @param {Function} callback - 包含事务操作的回调函数
  * @returns {Promise<*>} 回调函数的返回值
+ * @throws {TypeError} 当callback参数无效时
  */
 Sqlite.prototype.transaction = async function (callback) {
-  let transaction = null;
+    // 参数校验
+    if (typeof callback !== 'function') {
+        throw new TypeError('callback must be function');
+    }
 
-  try {
-    // 开始事务
-    transaction = await this.beginTransaction();
+    let transaction = null;
 
-    // 执行回调函数，传入事务对象
-    const result = await callback(transaction);
+    try {
+        // 开始事务
+        transaction = await this.beginTransaction();
 
-    // 提交事务
-    await transaction.commit();
+        // 执行回调函数，传入事务对象
+        const result = await callback(transaction);
 
-    return result;
-  } catch (error) {
-    // 如果有事务，回滚
-    if (transaction) {
-      await transaction.rollback().catch(err => {
-        $.log.error(`[${this.constructor.name}] [transaction] 事务回滚失败`, { error: err.message });
-      });
-    }
+        // 提交事务
+        await transaction.commit();
 
-    $.log.error(`[${this.constructor.name}] [transaction] 事务执行失败`, { error: error.message });
-    throw error;
-  }
+        return result;
+    } catch (error) {
+        // 如果有事务，回滚
+        if (transaction) {
+            await transaction.rollback().catch(err => {
+                this.logger('error', '事务回滚失败', err);
+            });
+        }
+
+        this.logger('error', '事务执行失败', error);
+        // 重新抛出异常，因为调用方需要事务执行结果
+        throw error;
+    }
 };
 
 /**
@@ -678,14 +688,23 @@ Sqlite.prototype.transaction = async function (callback) {
  * @param {String} name - 表名
  * @param {String} key  - 主键
  * @returns {Object} 数据库操作实例
+ * @throws {TypeError} 当name参数无效时
  */
 Sqlite.prototype.table = function (name, key) {
-  var db = this.db();
-  db.table = name;
-  if (key) {
-    db.key = key;
-  }
-  return db;
+    // 参数校验
+    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;
 };
 
 // close 方法已在文件前面部分实现，这里不再重复
@@ -694,10 +713,10 @@ Sqlite.prototype.table = function (name, key) {
  * 确保连接池对象存在
  */
 if (!$.pool) {
-  $.pool = {};
+    $.pool = {};
 }
 if (!$.pool.sqlite) {
-  $.pool.sqlite = {};
+    $.pool.sqlite = {};
 }
 
 /**
@@ -707,17 +726,191 @@ if (!$.pool.sqlite) {
  * @return {Object} 返回一个Sqlite类实例
  */
 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;
+    if (!scope) {
+        scope = 'sys';
+    }
+    var obj = $.pool.sqlite[scope];
+    if (!obj) {
+        $.pool.sqlite[scope] = new Sqlite(config);
+        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.logger('debug', '连接池初始化完成', {
+            min: this.config.pool_min,
+            max: this.config.pool_max,
+            current: this._pool_connections.length
+        });
+    } catch (error) {
+        this.logger('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.logger('error', '关闭空闲连接失败', err);
+                }
+            });
+
+            // 从连接池中移除
+            const conn_index = this._pool_connections.indexOf(conn);
+            if (conn_index > -1) {
+                this._pool_connections.splice(conn_index, 1);
+            }
+            this._pool_available.splice(i, 1);
+
+            this.logger('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._releasePoolConnection = 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
+ */
+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.logger('error', '关闭连接池连接失败', err);
+                }
+            });
+        } catch (error) {
+            this.logger('error', '关闭连接池连接异常', error);
+        }
+    });
+
+    this._pool_connections = [];
+    this._pool_available = [];
+    this._pool_waiting = [];
+
+    this.logger('debug', '连接池已关闭');
+};
+
 // 模块导出
 exports.Sqlite = Sqlite;
 exports.sqliteAdmin = sqliteAdmin;