mm_sqlite 1.2.1 → 1.2.3

package/index.js

@@ -1,513 +1,513 @@
 const sqlite3 = require('sqlite3').verbose();
 const {
-    DB
+  DB
 } = require('./db');
 const { Base } = require('mm_expand');
 
 /**
  * SQLite数据库操作类
- * @class Sqlite
- * @extends Base
+ * @class SQLite
+ * @augments Base
  */
-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;
-    }
+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_cfg = { ...SQLite.default_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;
+  }
 }
 
 /**
  * 初始化服务
  * @returns {Promise<void>}
  */
-Sqlite.prototype._initService = async function () {
-    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);
-    }
+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);
+  }
 };
 
 /**
  * 获取数据库文件名
  * @returns {string} 数据库文件名
  */
-Sqlite.prototype._getDbFilename = function () {
-    var file = this.config.database;
-    if (file.indexOf(".") === -1) {
-        file += ".db";
-    }
+SQLite.prototype._getDbFilename = function () {
+  var file = this.config.database;
+  if (file.indexOf('.') === -1) {
+    file += '.db';
+  }
 
-    return file.fullname(this.config.dir);
-}
+  return file.fullname(this.config.dir);
+};
 
 /**
  * 内部打开数据库连接
  * @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();
-            }
-        });
+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 - 超时时间(毫秒)
+ * @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.logger('warn', '数据库连接已存在或正在连接中');
+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;
+  }
+
+  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;
-    }
-
-    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.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;
-    }
+      } catch (connection_err) {
+        this.log('error', '连接过程错误详情', connection_err);
+      }
+    }
+  } catch (err) {
+    this._status = 'closed';
+    this.log('error', '数据库连接失败', err);
+    return false;
+  }
 };
 
 /**
  * 关闭数据库连接
  * @returns {Promise<boolean>}
  */
-Sqlite.prototype.close = function () {
-    if (this._status !== 'connected') {
-        this.logger('warn', '数据库连接未建立');
-        return Promise.resolve(false);
-    }
+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.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);
-        }
-    });
+  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>}
+ * @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');
-    }
-
-    timeout = timeout || this.config.acquire_timeout || this.config.connect_timeout || 20000;
-
-    if (this._status !== 'connected') {
-        await this.open(timeout);
-    }
-
-    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 (error.code && (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT')) {
-            this._handleConnectionError(error);
-        }
-        return null;
-    }
+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 {string} sql - SQL语句
  * @param {Array} params - 参数数组
- * @param {Number} timeout - 超时时间(毫秒)
- * @returns {Promise<Object>}
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise<object>}
  * @throws {TypeError} 当sql参数无效时
  */
-Sqlite.prototype.run = 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.all(sql, params || [], (error, rows) => {
-                if (error) {
-                    _this.sql = sql;
-                    _this.error = {
-                        code: error.errno,
-                        message: error.message
-                    }
-                    reject(error);
-                } else {
-                    // 保持与MySQL兼容的返回值格式，始终返回数组
-                    resolve(rows);
-                }
-            });
-        });
+SQLite.prototype.run = 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;
+  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
+          };
+          reject(error);
+        } else {
+          // 保持与MySQL兼容的返回值格式，始终返回数组
+          resolve(rows);
+        }
+      });
+    });
 
-        const timeout_promise = new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new Error(`SQL查询超时: ${timeout}ms`));
-            }, timeout);
-        });
+    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]);
+    const result = await Promise.race([query_promise, timeout_promise]);
 
-        // 连接池模式下释放连接
-        if (this._use_pool && conn) {
-            this._releasePoolConnection(conn);
-        }
+    // 连接池模式下释放连接
+    if (this._use_pool && conn) {
+      this._releasePoolConnection(conn);
+    }
 
-        return result;
-    } catch (err) {
-        this.logger('error', 'SQL执行失败', err);
+    return result;
+  } catch (err) {
+    this.log('error', 'SQL执行失败', err);
 
-        // 连接池模式下释放连接
-        if (this._use_pool && conn) {
-            this._releasePoolConnection(conn);
-        }
+    // 连接池模式下释放连接
+    if (this._use_pool && conn) {
+      this._releasePoolConnection(conn);
+    }
 
-        // 处理连接错误，触发重连
-        if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
-            this._handleConnectionError(err);
-        }
-        // 返回空数组作为默认值，保持返回值类型一致
-        return [];
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(err);
     }
+    // 返回空数组作为默认值，保持返回值类型一致
+    return [];
+  }
 };
 
 /**
  * 执行SQL语句（用于执行非查询语句如INSERT/UPDATE/DELETE）
- * @param {String} sql - SQL语句
+ * @param {string} sql - SQL语句
  * @param {Array} params - 参数数组
- * @param {Number} timeout - 超时时间(毫秒)
- * @returns {Promise<Object>}
+ * @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
-                    }
-                    reject(error);
-                    resolve(0);
-                } else {
-                    // 保持与MySQL兼容的返回值格式
-                    resolve(this.lastID || this.changes || 1);
-                }
-            });
-        });
+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
+          };
+          reject(error);
+          resolve(0);
+        } else {
+          // 保持与MySQL兼容的返回值格式
+          resolve(this.lastID || this.changes || 1);
+        }
+      });
+    });
 
-        const timeout_promise = new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new Error(`SQL执行超时: ${timeout}ms`));
-            }, timeout);
-        });
+    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]);
+    const result = await Promise.race([query_promise, timeout_promise]);
 
-        // 连接池模式下释放连接
-        if (this._use_pool && conn) {
-            this._releasePoolConnection(conn);
-        }
+    // 连接池模式下释放连接
+    if (this._use_pool && conn) {
+      this._releasePoolConnection(conn);
+    }
 
-        return result;
-    } catch (err) {
-        this.logger('error', 'SQL执行失败', err);
+    return result;
+  } catch (err) {
+    this.log('error', 'SQL执行失败', err);
 
-        // 连接池模式下释放连接
-        if (this._use_pool && conn) {
-            this._releasePoolConnection(conn);
-        }
+    // 连接池模式下释放连接
+    if (this._use_pool && conn) {
+      this._releasePoolConnection(conn);
+    }
 
-        // 处理连接错误，触发重连
-        if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
-            this._handleConnectionError(err);
-        }
-        // 返回默认操作结果对象，保持返回值类型一致
-        return 0;
+    // 处理连接错误，触发重连
+    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT')) {
+      this._handleConnectionError(err);
     }
+    // 返回默认操作结果对象，保持返回值类型一致
+    return 0;
+  }
 };
 
 /**
  * 读取整张表的数据
- * @param {String} table - 表名
- * @param {Object} condition - 查询条件
- * @param {Object} options - 选项（order_by, limit, offset等）
+ * @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');
+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('数据库连接未建立');
     }
 
-    try {
-        // 检查连接状态
-        if (this._status !== 'connected') {
-            throw new Error('数据库连接未建立');
-        }
-
-        // 构建基础SQL查询
-        let sql = `SELECT * FROM ${table}`;
-        const params = [];
+    // 构建基础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 (condition && Object.keys(condition).length > 0) {
+      const where_clauses = [];
+      for (const [field, value] of Object.entries(condition)) {
+        where_clauses.push(`${field} = ?`);
+        params.push(value);
+      }
+      sql += ` WHERE ${where_clauses.join(' AND ')}`;
+    }
 
-        // 处理分页
-        if (options && options.limit) {
-            sql += ` LIMIT ${options.limit}`;
-        }
+    // 处理排序
+    if (options && options.order_by) {
+      sql += ` ORDER BY ${options.order_by}`;
+    }
 
-        if (options && options.offset) {
-            sql += ` OFFSET ${options.offset}`;
-        }
+    // 处理分页
+    if (options && options.limit) {
+      sql += ` LIMIT ${options.limit}`;
+    }
 
-        // 记录查询日志
-        if (this.config.debug) {
-            this.logger('debug', '查询数据', { sql, params });
-        }
+    if (options && options.offset) {
+      sql += ` OFFSET ${options.offset}`;
+    }
 
-        // 执行查询
-        const results = await this.run(sql, params);
+    // 记录查询日志
+    if (this.config.debug) {
+      this.log('debug', '查询数据', { sql, params });
+    }
 
-        if (this.config.debug) {
-            this.logger('info', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
-        }
+    // 执行查询
+    const results = await this.run(sql, params);
 
-        // 确保返回数组格式
-        return Array.isArray(results) ? results : [results];
-    } catch (error) {
-        this.logger('error', '查询失败', error);
-        // 返回空数组作为默认值，保持返回值类型一致
-        return [];
+    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实例
+ * @returns {object} DB实例
  */
-Sqlite.prototype.db = function () {
-    return new DB(this);
+SQLite.prototype.db = function () {
+  return new DB(this);
 };
 
 // /**
@@ -516,7 +516,7 @@ Sqlite.prototype.db = function () {
 //  * @returns {Object} 数据库操作实例
 //  * @throws {TypeError} 当database参数无效时
 //  */
-// Sqlite.prototype.db = function (database) {
+// SQLite.prototype.db = function (database) {
 //     // 参数校验
 //     if (database !== undefined && typeof database !== 'string') {
 //         throw new TypeError('database must be string');
@@ -544,98 +544,98 @@ Sqlite.prototype.db = function () {
 
 /**
  * 开始事务
- * @returns {Promise<Object>} 事务连接对象
+ * @returns {Promise<object>} 事务连接对象
  */
-Sqlite.prototype.beginTransaction = async function () {
-    try {
-        // 检查连接状态
-        if (this._status !== 'connected') {
-            throw new Error('数据库连接未建立');
+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();
         }
+      });
+    });
 
-        // 获取连接
-        const connection = await this.getConn();
+    if (this.config.debug) {
+      this.log('debug', '事务开始');
+    }
 
-        // 开始事务
+    // 返回事务连接对象，包含提交和回滚方法
+    return {
+      conn,
+      commit: async () => {
         await new Promise((resolve, reject) => {
-            connection.run('BEGIN TRANSACTION', (error) => {
-                if (error) {
-                    reject(error);
-                } else {
-                    resolve();
-                }
-            });
+          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.logger('debug', '事务开始');
+          this.log('debug', '事务回滚');
         }
 
-        // 返回事务连接对象，包含提交和回滚方法
-        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);
-                        }
-                    });
-                });
+        // 连接池模式下释放连接
+        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.logger('error', '事务开始失败', error);
-        // 重新抛出异常，因为调用方需要事务对象
-        throw error;
-    }
+          });
+        });
+      }
+    };
+  } catch (error) {
+    this.log('error', '事务开始失败', error);
+    // 重新抛出异常，因为调用方需要事务对象
+    throw error;
+  }
 };
 
 /**
@@ -644,78 +644,78 @@ Sqlite.prototype.beginTransaction = async function () {
  * @returns {Promise<*>} 回调函数的返回值
  * @throws {TypeError} 当callback参数无效时
  */
-Sqlite.prototype.transaction = async function (callback) {
-    // 参数校验
-    if (typeof callback !== 'function') {
-        throw new TypeError('callback must be function');
-    }
+SQLite.prototype.trans = async function (callback) {
+  // 参数校验
+  if (typeof callback !== 'function') {
+    throw new TypeError('callback must be function');
+  }
 
-    let transaction = null;
+  let trans = null;
 
-    try {
-        // 开始事务
-        transaction = await this.beginTransaction();
+  try {
+    // 开始事务
+    trans = await this.beginTrans();
 
-        // 执行回调函数，传入事务对象
-        const result = await callback(transaction);
+    // 执行回调函数，传入事务对象
+    const result = await callback(trans);
 
-        // 提交事务
-        await transaction.commit();
+    // 提交事务
+    await trans.commit();
 
-        return result;
-    } catch (error) {
-        // 如果有事务，回滚
-        if (transaction) {
-            await transaction.rollback().catch(err => {
-                this.logger('error', '事务回滚失败', err);
-            });
-        }
-
-        this.logger('error', '事务执行失败', error);
-        // 重新抛出异常，因为调用方需要事务执行结果
-        throw error;
+    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} 数据库操作实例
+ * @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;
+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;
 };
 
 /**
  * 创建SQLite连接
  * @private
- * @returns {Promise<Object>} 数据库连接对象
+ * @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);
-            }
-        });
+SQLite.prototype._createConnection = function () {
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(this._getDbFilename(), (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(db);
+      }
     });
+  });
 };
 
 /**
@@ -723,186 +723,186 @@ Sqlite.prototype._createConnection = function () {
  * @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;
-    }
+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.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', '回收空闲连接');
+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>} 数据库连接
+ * @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;
-            }
+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_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;
-            }
+      // 检查是否可以创建新连接
+      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);
-        };
+      // 没有可用连接，等待一段时间后重试
+      setTimeout(tryGetConnection, 100);
+    };
 
-        tryGetConnection();
-    });
+    tryGetConnection();
+  });
 };
 
 /**
  * 释放连接回连接池
  * @private
- * @param {Object} conn - 数据库连接
+ * @param {object} conn - 数据库连接
  */
-Sqlite.prototype._releasePoolConnection = function (conn) {
-    if (this._pool_connections.includes(conn)) {
-        conn._last_used = Date.now();
-        this._pool_available.push(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);
-        }
+    // 处理等待队列
+    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);
+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._pool_connections = [];
+  this._pool_available = [];
+  this._pool_waiting = [];
 
-    this.logger('debug', '连接池已关闭');
+  this.log('debug', '连接池已关闭');
 };
 
 /**
  * 确保连接池对象存在
  */
 if (!$.pool) {
-    $.pool = {};
+  $.pool = {};
 }
 if (!$.pool.sqlite) {
-    $.pool.sqlite = {};
+  $.pool.sqlite = {};
 }
 
 /**
  * Sqlite管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {Object} config 配置参数
- * @return {Object} 返回一个Sqlite类实例
+ * @param {string} scope 作用域
+ * @param {object} config 配置参数
+ * @returns {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;
 }
 
 // 模块导出
-exports.Sqlite = Sqlite;
+exports.SQLite = SQLite;
 exports.sqliteAdmin = sqliteAdmin;