mm_sqlite 1.5.5 → 1.5.7

package/index.js

@@ -1,670 +1,24 @@
-const {
-  DB
-} = require('./db');
-const { Base } = require('mm_expand');
-const SQLitePool = require('./pool');
-
-
-/**
- * SQLite数据库操作类
- * @class SQLite
- * @augments Base
- */
-class SQLite extends Base {
-  /**
-   * 默认配置
-   */
-  static config = {
-    name: 'default',
-    dir: './db/'.fullname(),
-    user: 'root',
-    password: '',
-    database: 'mm',
-    charset: 'utf8mb4',
-    timezone: '+08:00',
-    connect_timeout: 5000,        // 连接超时时间
-    acquire_timeout: 5000,        // 获取连接超时时间
-    query_timeout: 10000,         // 查询超时时间
-    // 连接池配置（统一使用连接池模式）
-    pool_min: 1,                  // 最小连接数
-    pool_max: 3,                  // 最大连接数
-    pool_acquire_timeout: 5000,   // 连接池获取超时
-    pool_idle_timeout: 30000,     // 空闲超时
-    pool_reap_interval: 5000      // 回收间隔
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config - 配置对象
-   */
-  constructor(config) {
-    super(config);
-  }
-}
-
-/**
- * 预初始化数据库连接
- * @private
- */
-SQLite.prototype._preset = function () {
-  this._connection = 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._pool = new SQLitePool(this.config, this._getDbFilename.bind(this), this.log.bind(this));
-};
-
-/**
- * 获取数据库文件名
- * @returns {string} 数据库文件名
- */
-SQLite.prototype._getDbFilename = function () {
-  var file = this.config.database;
-  if (file.indexOf('.') === -1) {
-    file += '.db';
-  }
-
-  return file.fullname(this.config.dir);
-};
-
-/**
- * 打开数据库连接（统一使用连接池模式）
- * @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;
-  }
-
-  this._status = 'connecting';
-
-  try {
-    this.config.dir.addDir();
-
-    // 统一使用连接池模式
-    await this._pool.init();
-    this._last_connect_time = Date.now();
-    this._status = 'connected';
-    return true;
-  } catch (err) {
-    this._status = 'closed';
-    this.log('error', '数据库连接失败', err);
-    return false;
-  }
-};
-
-/**
- * 关闭数据库连接（统一使用连接池模式）
- * @returns {Promise<boolean>}
- */
-SQLite.prototype.close = async function () {
-  if (this._status !== 'connected') {
-    this.log('warn', '数据库连接未建立');
-    return false;
-  }
-
-  try {
-    // 统一关闭连接池
-    this._pool.close();
-    this._db = null;
-    this._open = false;
-    this._status = 'closed';
-    return true;
-  } catch (err) {
-    this.log('error', '关闭数据库连接时发生异常', err);
-    this._status = 'closed';
-    return 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);
-  }
-
-  // 统一从连接池获取连接
-  return await this._pool.getConnection(acquire_timeout);
-};
-
-/**
- * 执行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');
-  }
-
-  // 注意：同 scope 下为单例共享，this.error/this.sql 并发时以最后一次写入为准
-  this.error = null;
-  this.sql = '';
-  let conn = null;
-  const query_timeout = timeout || this.config.query_timeout || 30000;
-  let ret = [];
-  try {
-    // 获取连接
-    conn = await this.getConn(query_timeout);
-
-    // better-sqlite3 同步查询，无需 Promise 包装
-    const stmt = conn.prepare(sql);
-    ret = params.length > 0 ? stmt.all(params) : stmt.all();
-  } catch (error) {
-    console.error('SQL执行失败', error);
-    this.sql = sql;
-    this.error = {
-      code: error.code || error.errno,
-      message: error.message
-    };
-    ret = [];
-  } finally {
-    await releaseConn(conn);
-  }
-  return ret;
-};
-
-/**
- * 执行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');
-  }
-
-  // 注意：同 scope 下为单例共享，this.error/this.sql 并发时以最后一次写入为准
-  this.error = null;
-  this.sql = '';
-  let conn = null;
-  timeout = timeout || this.config.query_timeout || 30000;
-  let ret = 0;
-  try {
-    // 获取连接
-    conn = await this.getConn(timeout);
-    this.sql = sql;
-
-    const trimmed = sql.trim().toUpperCase().replace(/;+$/, '');
-    let info;
-    // 事务命令不能作为预编译语句，需用 exec() 直接执行
-    if (trimmed === 'BEGIN' || trimmed === 'BEGIN TRANSACTION' ||
-        trimmed === 'COMMIT' || trimmed === 'ROLLBACK') {
-      conn.exec(sql);
-      info = { changes: 0, lastInsertRowid: 0 };
-    } else {
-      const stmt = conn.prepare(sql);
-      info = params && params.length > 0 ? stmt.run(params) : stmt.run();
-    }
-    ret = info.lastInsertRowid || info.changes || 1;
-  } catch (error) {
-    console.error('SQL执行失败', error);
-    this.sql = sql;
-    this.error = {
-      code: error.code || error.errno,
-      message: error.message
-    };
-    ret = 0;
-  } finally {
-    await releaseConn(conn);
-  }
-  return ret;
-};
-
-/**
- * 执行多语句SQL脚本（专用于导入）
- * 逐条执行DML语句统计变更行数，其他语句使用exec执行
- * @param {string} sql - SQL脚本内容，可含多条以分号分隔的语句
- * @returns {Promise<object>} 执行结果统计对象
- * @throws {TypeError} 当sql参数无效时
- */
-SQLite.prototype.runSql = async function (sql) {
-  // 参数校验
-  if (typeof sql !== 'string' || sql.trim() === '') {
-    throw new TypeError('sql must be non-empty string');
-  }
-
-  // 注意：同 scope 下为单例共享，this.error/this.sql 并发时以最后一次写入为准
-  this.error = null;
-  this.sql = '';
-  let conn = null;
-  let ret = { success: false, statements: 0, affected_rows: 0, error: null };
-  try {
-    // 获取连接
-    conn = await this.getConn();
-    this.sql = sql;
-
-    // 拆分语句列表
-    let stmts = splitStatements(sql);
-    ret.statements = stmts.length;
-    // 逐条执行，DML语句统计变更行数
-    for (let stmt_sql of stmts) {
-      if (/^(INSERT|UPDATE|DELETE|REPLACE)\b/i.test(stmt_sql)) {
-        let info = conn.prepare(stmt_sql).run();
-        ret.affected_rows += info.changes || 0;
-      } else {
-        conn.exec(stmt_sql);
-      }
-    }
-    ret.success = true;
-  } catch (error) {
-    console.error('SQL执行失败', error);
-    this.sql = sql;
-    this.error = {
-      code: error.code || error.errno,
-      message: error.message
-    };
-    ret.error = error.message;
-  } finally {
-    await releaseConn(conn);
-  }
-  return ret;
-};
-
-/**
- * 拆分SQL脚本为语句列表
- * 去除注释后按分号分割，过滤空语句
- * @private
- * @param {string} sql - SQL脚本内容
- * @returns {Array} 语句列表
- */
-function splitStatements(sql) {
-  // 去除行注释和块注释
-  let clean_sql = sql
-    .replace(/--[^\n]*/g, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .trim();
-  let stmts = [];
-  for (let part of clean_sql.split(';')) {
-    let stmt = part.trim();
-    if (stmt !== '') {
-      stmts.push(stmt);
-    }
-  }
-  return stmts;
-}
-
-/**
- * 读取整张表的数据
- * @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');
-  }
-
-  // 检查连接状态
-  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('debug', '查询成功', { count: Array.isArray(results) ? results.length : 1 });
-  }
-
-  // 确保返回数组格式
-  return Array.isArray(results) ? results : [results];
-};
-
-/**
- * 获取数据库管理器（保持兼容性）
- * @returns {object} DB实例
- */
-SQLite.prototype.db = function () {
-  return new DB(this);
-};
-
-/**
- * 初始化数据库服务（保持兼容性）
- * @returns {Promise<void>}
- */
-SQLite.prototype.init = async function () {
-  await this.open();
-};
-
-/**
- * 获取连接池状态信息
- * @returns {object} 连接池状态对象
- */
-SQLite.prototype.getPoolStats = function () {
-  if (!this._pool || !this._pool._is_initialized) {
-    return {
-      status: 'not_initialized',
-      message: '连接池未初始化'
-    };
-  }
-
-  return {
-    status: 'healthy',
-    ...this._pool.getStats()
-  };
-};
-
-/**
- * 健康检查
- * @returns {Promise<object>} 健康检查结果
- */
-SQLite.prototype.healthCheck = async function () {
-  try {
-    if (this._status !== 'connected') {
-      return {
-        status: 'error',
-        message: '数据库连接未初始化'
-      };
-    }
-
-    // 执行简单的查询来检查连接状态
-    let result = await this.run('SELECT 1 as health_check');
-
-    if (result && result.length > 0 && result[0].health_check === 1) {
-      return {
-        status: 'healthy',
-        message: '数据库连接正常',
-        ...this.getPoolStats()
-      };
-    } else {
-      return {
-        status: 'error',
-        message: '健康检查查询失败'
-      };
-    }
-  } catch (error) {
-    this.log('error', '健康检查失败', error);
-    return {
-      status: 'error',
-      message: `健康检查失败: ${error.message}`
-    };
-  }
-};
-
-// /**
-//  * 获取数据库操作实例
-//  * @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.beginTransaction = async function () {
-  try {
-    // 检查连接状态
-    if (this._status !== 'connected') {
-      throw new Error('数据库连接未建立');
-    }
-
-    // 获取连接
-    const conn = await this.getConn();
-
-    // 标记连接为事务中
-    conn._in_transaction = true;
-
-    // 开始事务（better-sqlite3 同步执行）
-    conn.exec('BEGIN TRANSACTION');
-
-    if (this.config.debug) {
-      this.log('debug', '事务开始');
-    }
-
-    // 返回事务连接对象，包含提交和回滚方法
-    return {
-      conn,
-      commit: async () => {
-        conn.exec('COMMIT');
-        if (this.config.debug) {
-          this.log('debug', '事务提交');
-        }
-
-        // 清除事务标记并释放连接
-        conn._in_transaction = false;
-        await releaseConn(conn);
-      },
-      rollback: async () => {
-        conn.exec('ROLLBACK');
-        if (this.config.debug) {
-          this.log('debug', '事务回滚');
-        }
-        // 清除事务标记并释放连接
-        conn._in_transaction = false;
-        await releaseConn(conn);
-      },
-      exec: async (sql, params) => {
-        // 在事务中执行SQL
-        const stmt = conn.prepare(sql);
-        const info = params && params.length > 0 ? stmt.run(params) : stmt.run();
-        return info.lastInsertRowid || info.changes || 1;
-      }
-    };
-  } catch (error) {
-    this.log('error', '事务开始失败', error);
-    // 重新抛出异常，因为调用方需要事务对象
-    throw error;
-  }
-};
-
-/**
- * 在事务中执行多个操作
- * @param {Function} callback - 包含事务操作的回调函数
- * @returns {Promise<*>} 回调函数的返回值
- * @throws {TypeError} 当callback参数无效时
- */
-SQLite.prototype.transaction = async function (callback) {
-  // 参数校验
-  if (typeof callback !== 'function') {
-    throw new TypeError('callback must be function');
-  }
-
-  let trans = null;
-
-  try {
-    // 开始事务
-    trans = await this.beginTransaction();
-
-    // 执行回调函数，传入事务对象
-    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;
-};
-
-/**
- * 确保连接池对象存在
- */
-if (!$.pool) {
-  $.pool = {};
-}
-if (!$.pool.sqlite) {
-  $.pool.sqlite = {};
-}
-
-/**
- * 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;
-}
-
-/**
- * 安全释放数据库连接
- * @param {object} conn - 数据库连接对象
- * @returns {Promise<void>}
- */
-async function releaseConn(conn) {
-  if (!conn) {
-    return;
-  }
-  await conn.release();
-}
-
-// 模块导出
-exports.SQLite = SQLite;
-exports.sqliteAdmin = sqliteAdmin;
+/**
+ * mm_sqlite SQLite数据库模块
+ * @description 参考 mm_redis 结构，index.js 为薄包装，类定义在 lib/sqlite.js
+ */
+const SQLite = require('./lib/sqlite');
+const Admin = require('mm_corejs').Admin;
+
+/**
+ * SQLite 管理器实例（Admin 工厂）
+ * 支持 os.js 调用：require('mm_sqlite').admin.setServer(os) -> admin.get('os', config)
+ */
+let admin = new Admin();
+admin.setClass(SQLite);
+
+module.exports = {
+  SQLite,
+  admin,
+  sqliteAdmin(scope, config) {
+    if (!scope) {
+      scope = 'os';
+    }
+    return admin.get(scope, config);
+  }
+};