mm_mysql 2.5.6 → 2.6.0

package/lib/mysql.js

@@ -0,0 +1,536 @@
+const mysql = require('mysql2/promise');
+const { Base } = require('mm_mod');
+const { DB } = require('./db');
+const makeQueryError = require('./query_error');
+
+/**
+ * 优化版MySQL数据库操作类
+ * 保持必要功能，简化过度封装，直接使用mysql2模块
+ * @class Mysql
+ * @augments Base
+ */
+class Mysql extends Base {
+  /**
+   * 默认配置（优化版，统一使用连接池）
+   */
+  static config = {
+    name: 'default',
+    host: '127.0.0.1',
+    port: 3306,
+    user: 'root',
+    password: 'Asd159357',
+    database: '',
+    charset: 'utf8mb4',
+    timezone: '+08:00',
+    connect_timeout: 15000,
+
+    // 连接池优化配置（针对高并发写入场景）
+    connection_limit: 100,           // 减少连接数，避免资源竞争
+    acquire_timeout: 30000,          // 延长获取连接超时时间
+    wait_for_connections: true,      // 保持连接等待机制
+    idle_timeout: 300000,            // 延长空闲连接超时时间(5分钟)
+    max_idle: 30,                    // 减少最大空闲连接数
+    queue_timeout: 60000,            // 队列超时时间
+  };
+
+  /**
+   * 构造函数（统一使用连接池）
+   * @param {object} config - 配置对象
+   */
+  constructor(config = {}) {
+    super(config);
+    this._pool = null;
+    // 移除单连接支持，统一使用连接池
+
+    // 错误信息（注意：同 scope 下为单例共享，并发时以最后一次写入为准）
+    this.error = null;
+    // 最近执行的SQL语句
+    this.sql = '';
+  }
+}
+
+/**
+ * 获取MySQL2支持的配置参数
+ * 根据连接类型（连接池或单连接）过滤参数，避免警告
+ * @param {boolean} is_pool - 是否为连接池配置
+ * @returns {object} 过滤后的配置对象
+ */
+Mysql.prototype._getValidConfig = function (is_pool = false) {
+  // 基础连接参数（适用于所有连接类型）
+  let base_map = {
+    'host': 'host',
+    'port': 'port',
+    'user': 'user',
+    'password': 'password',
+    'database': 'database',
+    'charset': 'charset',
+    'timezone': 'timezone',
+    'connect_timeout': 'connectTimeout'
+  };
+
+  // 连接池专用参数
+  let pool_map = {
+    'connection_limit': 'connectionLimit',
+    'wait_for_connections': 'waitForConnections',
+    'idle_timeout': 'idleTimeout',
+    'max_idle': 'maxIdle'
+  };
+
+  let config = {};
+
+  // 添加基础参数
+  for (let key in base_map) {
+    if (this.config[key] !== undefined) {
+      config[base_map[key]] = this.config[key];
+    }
+  }
+
+  // 如果是连接池，添加连接池专用参数
+  if (is_pool) {
+    for (let key in pool_map) {
+      if (this.config[key] !== undefined) {
+        config[pool_map[key]] = this.config[key];
+      }
+    }
+  }
+  // 如果是单连接，确保不包含任何连接池专用参数
+  else {
+    // 移除所有连接池专用参数，避免mysql2内部警告
+    for (let key in pool_map) {
+      if (pool_map[key] in config) {
+        delete config[pool_map[key]];
+      }
+    }
+  }
+
+  return config;
+};
+
+/**
+   * 打开数据库连接（统一使用连接池）
+   * @returns {Promise<boolean>}
+   * @throws {TypeError} 当配置参数无效时
+   */
+Mysql.prototype.open = async function () {
+  // 参数校验
+  if (!this.config || typeof this.config !== 'object') {
+    throw new TypeError('config must be object');
+  }
+
+  try {
+    // 统一使用连接池模式
+    let valid_config = this._getValidConfig(true);
+    this._pool = mysql.createPool(valid_config);
+
+    // 测试连接池连接
+    let conn = await this._pool.getConnection();
+    conn.release();
+    return true;
+  } catch (error) {
+    this.log('error', '数据库连接池创建失败', error);
+    return false;
+  }
+};
+
+/**
+ * 关闭数据库连接（统一使用连接池）
+ * @returns {Promise<boolean>}
+ */
+Mysql.prototype.close = async function () {
+  if (!this._pool) {
+    return true;
+  }
+  try {
+    await this._pool.end();
+    this._pool = null;
+    this.log('info', '数据库连接池已关闭');
+    return true;
+  } catch (error) {
+    this.log('error', '关闭连接池失败', error);
+    return false;
+  }
+};
+
+/**
+   * 获取数据库连接（统一使用连接池）
+   * @returns {Promise<object>}
+   * @throws {TypeError} 当连接池不存在时
+   */
+Mysql.prototype.getConn = async function () {
+  // 连接池不存在则创建
+  if (!this._pool) {
+    await this.open();
+  }
+  // 连接池可能已被外部关闭，检测并重建
+  if (this._pool._closed) {
+    await this.open();
+  }
+
+  return await this._pool.getConnection();
+};
+
+/**
+ * 执行SQL查询
+ * @param {string} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @returns {Promise<object>}
+ * @throws {TypeError} 当sql参数无效时
+ */
+Mysql.prototype.run = async function (sql, params = []) {
+  // 参数校验
+  if (typeof sql !== 'string' || sql.trim() === '') {
+    throw new TypeError('sql must be non-empty string');
+  }
+  if (!Array.isArray(params)) {
+    throw new TypeError('params must be array');
+  }
+
+  this.error = null;
+  this.sql = '';
+  let conn = null;
+  let ret = [];
+  try {
+    conn = await this.getConn();
+    this.sql = sql;
+    let [rows] = await conn.query(sql, params);
+    ret = rows;
+  } catch (err) {
+    // D-12：查询失败不能吞成空数组——「没数据」和「查询炸了」在业务层必须可区分
+    this.sql = err.sql || sql;
+    this.error = {
+      code: err.errno || err.code,
+      message: err.sqlMessage || err.message
+    };
+    throw makeQueryError(err, sql, params);
+  }
+  finally {
+    await releaseConn(conn);
+  }
+  return ret;
+};
+
+
+/**
+ * 执行SQL语句（优化版，支持预处理语句缓存）
+ * @param {string} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @returns {Promise<object>}
+ * @throws {TypeError} 当sql参数无效时
+ */
+Mysql.prototype.exec = async function (sql, params = []) {
+  // 参数校验
+  if (typeof sql !== 'string' || sql.trim() === '') {
+    throw new TypeError('sql must be non-empty string');
+  }
+  if (!Array.isArray(params)) {
+    throw new TypeError('params must be array');
+  }
+  this.error = null;
+  this.sql = '';
+  let conn = null;
+  let ret = 0;
+  try {
+    conn = await this.getConn();
+    this.sql = sql;
+    let [result] = await conn.execute(sql, params);
+    ret = result.insertId || result.affectedRows || result.changedRows || 1;
+  } catch (error) {
+    // 写操作失败同样上浮：返回 0 会被当成「没有行受影响」正常结果
+    this.sql = error.sql || sql;
+    this.error = {
+      code: error.errno || error.code,
+      message: error.sqlMessage || error.message
+    };
+    throw makeQueryError(error, sql, params);
+  }
+  finally {
+    await releaseConn(conn);
+  }
+  return ret;
+};
+
+/**
+ * 执行多语句SQL脚本（专用于导入）
+ * 通过独立连接执行，不影响连接池默认配置
+ * @param {string} sql - SQL脚本内容，可含多条以分号分隔的语句
+ * @returns {Promise<object>} 执行结果统计对象
+ * @throws {TypeError} 当sql参数无效时
+ */
+Mysql.prototype.runSql = async function (sql) {
+  // 参数校验
+  if (typeof sql !== 'string' || sql.trim() === '') {
+    throw new TypeError('sql must be non-empty string');
+  }
+
+  let conn = null;
+  let ret = { success: false, statements: 0, affected_rows: 0, error: null };
+  try {
+    // 创建专用连接，仅导入连接开启多语句支持
+    let valid_config = this._getValidConfig(false);
+    valid_config.multipleStatements = true;
+    conn = await mysql.createConnection(valid_config);
+
+    // 执行整段SQL脚本
+    let [results] = await conn.query(sql);
+    // 统计语句数和受影响行数
+    if (Array.isArray(results)) {
+      ret.statements = results.length;
+      for (let item of results) {
+        ret.affected_rows += item.affectedRows || 0;
+      }
+    } else {
+      ret.statements = 1;
+      ret.affected_rows = results.affectedRows || 0;
+    }
+    ret.success = true;
+  } catch (error) {
+    this.error = {
+      code: error.errno,
+      message: error.sqlMessage || error.message
+    };
+    this.sql = error.sql || sql;
+    ret.error = this.error.message;
+  } finally {
+    if (conn) {
+      try {
+        await conn.end();
+      } catch (end_error) {
+        this.log('error', '关闭导入连接失败', end_error);
+      }
+    }
+  }
+  return ret;
+};
+
+/**
+ * 开始事务（优化版）
+ * @returns {Promise<object>} 事务连接对象
+ */
+Mysql.prototype.beginTransaction = async function () {
+  let conn = await this.getConn();
+
+  try {
+    await conn.beginTransaction();
+
+    let ended = false;
+
+    return {
+      connection: conn,
+      commit: async () => {
+        if (ended) return;
+        await conn.commit();
+        ended = true;
+        await releaseConn(conn);
+      },
+      rollback: async () => {
+        if (ended) return;
+        await conn.rollback();
+        ended = true;
+        await releaseConn(conn);
+      },
+      _is_ended: () => ended
+    };
+  } catch (error) {
+    // 如果事务开始失败，确保连接被释放
+    await releaseConn(conn);
+    this.log('error', '事务开始失败', error);
+    throw error;
+  }
+};
+
+/**
+ * 在事务中执行多个操作（优化版）
+ * @param {Function} callback - 包含事务操作的回调函数
+ * @returns {Promise<*>} 回调函数的返回值
+ * @throws {TypeError} 当callback参数无效时
+ */
+Mysql.prototype.transaction = async function (callback) {
+  if (typeof callback !== 'function') {
+    throw new TypeError('callback must be function');
+  }
+
+  let transaction = await this.beginTransaction();
+
+  try {
+    let result = await callback(transaction);
+
+    // 如果事务未结束，自动提交
+    if (!transaction._is_ended()) {
+      await transaction.commit();
+    }
+
+    return result;
+  } catch (error) {
+    // 如果事务未结束，自动回滚
+    if (!transaction._is_ended()) {
+      await transaction.rollback().catch(() => {
+        // 简化错误处理，避免频繁日志
+      });
+    }
+
+    throw error;
+  }
+};
+
+/**
+ * 读取整张表的数据（改进版）
+ * @param {string} table - 表名
+ * @param {object} condition - 查询条件
+ * @param {object} options - 选项（orderBy, limit, offset等）
+ * @returns {Promise<Array>}
+ * @throws {TypeError} 当table参数无效时
+ */
+Mysql.prototype.read = async function (table, condition = {}, options = {}) {
+  // 参数校验
+  if (typeof table !== 'string' || table.trim() === '') {
+    throw new TypeError('table must be non-empty string');
+  }
+  if (condition && typeof condition !== 'object') {
+    throw new TypeError('condition must be object');
+  }
+  if (options && typeof options !== 'object') {
+    throw new TypeError('options must be object');
+  }
+
+  try {
+    let sql = `SELECT * FROM ${table}`;
+    let params = [];
+
+    // 处理条件
+    if (Object.keys(condition).length > 0) {
+      let whereClauses = [];
+      for (let [field, value] of Object.entries(condition)) {
+        whereClauses.push(`${field} = ?`);
+        params.push(value);
+      }
+      sql += ` WHERE ${whereClauses.join(' AND ')}`;
+    }
+
+    // 处理排序
+    if (options.orderBy) {
+      sql += ` ORDER BY ${options.orderBy}`;
+    }
+
+    // 处理分页
+    if (options.limit) {
+      sql += ` LIMIT ${options.limit}`;
+    }
+
+    if (options.offset) {
+      sql += ` OFFSET ${options.offset}`;
+    }
+
+    // 执行查询
+    return await this.run(sql, params);
+  } catch (error) {
+    this.log('error', '查询失败', error);
+    throw error; // 重新抛出错误，让调用方知道查询失败
+  }
+};
+
+/**
+ * 获取连接池状态信息
+ * @returns {object} 连接池状态对象
+ */
+Mysql.prototype.getPoolStats = function () {
+  if (!this._pool) {
+    return {
+      status: 'not_initialized',
+      message: '连接池未初始化'
+    };
+  }
+
+  return {
+    status: 'healthy'
+  };
+};
+
+/**
+ * 健康检查
+ * @returns {Promise<object>} 健康检查结果
+ */
+Mysql.prototype.healthCheck = async function () {
+  try {
+    if (!this._pool) {
+      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}`
+    };
+  }
+};
+
+/**
+ * 获取数据库管理器（保持兼容性）
+ * @returns {object} DB实例
+ */
+Mysql.prototype.db = function () {
+  return new DB(this);
+};
+
+/**
+ * 获取表管理器（语法糖，等同于 db().new(name, key)）
+ * @param {string} name 表名
+ * @param {string} key 主键字段名
+ * @returns {object} DB表管理器实例
+ */
+Mysql.prototype.table = function (name, key) {
+  if (typeof name !== 'string' || name.trim() === '') {
+    throw new TypeError('name must be non-empty string');
+  }
+  var db = this.db();
+  db.table = name;
+  if (key) {
+    db.key = key;
+  }
+  return db;
+};
+
+/**
+ * 初始化钩子（由 Lifecycle.init 模板方法调用，保证状态机流转到 inited）
+ * @returns {Promise<void>}
+ */
+Mysql.prototype.onInit = async function () {
+  await this.open();
+};
+
+/**
+ * 安全释放数据库连接
+ * @param {object} conn - 数据库连接对象
+ * @returns {Promise<void>}
+ */
+async function releaseConn(conn) {
+  if (!conn) return;
+
+  try {
+    if (typeof conn.release === 'function') {
+      await conn.release();
+    }
+  } catch (release_err) {
+    console.error('释放连接失败', release_err);
+  }
+};
+
+module.exports = Mysql;

package/lib/query_error.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * 构造带上下文的数据层错误
+ *
+ * 独立函数而非实例方法：DB 包装层以 `super(sqlite.run, sqlite.exec)` 传递未绑定的方法引用，
+ * 调用时 this 指向 DB 实例而不是 SQLite 实例，任何 this.xxx 辅助方法都会失效。
+ * 用模块级函数可同时覆盖「SQLite 直接被调用」与「经 DB 包装调用」两条路径。
+ *
+ * @param {Error} cause 驱动抛出的原始异常
+ * @param {string} sql 出错的 SQL
+ * @param {Array} params 绑定参数
+ * @returns {Error} 携带 code / sql / params / cause 的错误对象
+ */
+module.exports = function makeQueryError(cause, sql, params) {
+  const error = new Error(`SQL执行失败: ${cause.message || cause}`);
+  error.code = cause.code || cause.errno;
+  error.sql = sql;
+  error.params = params;
+  error.cause = cause;
+  return error;
+};

package/{sql.js → lib/sql.js}

@@ -4,7 +4,8 @@
  * @version 1.2
  */
 const SqlString = require('sqlstring');
-const { Base } = require('mm_expand');
+const { Base } = require('mm_mod');
+const { loadText, hasFile } = require('mm_helper');
 
 function escape(value, stringifyObjects, timeZone) {
   return SqlString.escape(value, stringifyObjects, timeZone);
@@ -236,6 +237,10 @@ Sql.prototype.delSql = function (where) {
  * @returns {Promise | object} 执行结果
  */
 Sql.prototype.setSql = function (where, set) {
+  // 空 SET 会拼出非法 SQL，按“无变更”处理
+  if (!set) {
+    return 0;
+  }
   // 使用直接拼接的方式，避免模板替换错误
   var sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
   return this.exec(sql);
@@ -645,6 +650,12 @@ Sql.prototype.set = async function (query, body, like) {
   if (!this.table || !body || typeof body !== 'object') {
     throw new Error('表名或数据未设置');
   }
+  // 待更新字段全为 undefined/null 时 toSet 会得到空串，
+  // 此时执行会产生 `UPDATE t SET  WHERE ...` 的非法 SQL，直接按“无变更”返回 0
+  if (!this.toSet(body)) {
+    this.sql = '';
+    return 0;
+  }
   let sql = this.toSetSql(query, body, like);
   this.sql = sql;
   let bl = await this.exec(sql);
@@ -1233,7 +1244,6 @@ Sql.prototype.tplBody = function (param_dt, sql_dt) {
  * @returns {Promise<boolean>} 是否加载成功
  */
 Sql.prototype.load = async function (file) {
-
   await this._logLoadStart(file);
   await this._validateFile(file);
   let sql_stmts = await this._readAndSplitSql(file);
@@ -1259,7 +1269,7 @@ Sql.prototype._logLoadStart = async function (file) {
  * @returns {Promise<void>}
  */
 Sql.prototype._validateFile = async function (file) {
-  if (!file.hasFile()) {
+  if (!hasFile(file)) {
     throw new Error(`SQL文件不存在: ${file}`);
   }
 };
@@ -1270,7 +1280,7 @@ Sql.prototype._validateFile = async function (file) {
  * @returns {Promise<string[]>} SQL语句数组
  */
 Sql.prototype._readAndSplitSql = async function (file) {
-  let sql_content = await $.file.readText(file);
+  let sql_content = loadText(file);
   if (!sql_content || sql_content.trim() === '') {
     throw new Error(`SQL文件内容为空: ${file}`);
   }

package/lib/tools/index.js

@@ -0,0 +1,16 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+/** 模块能力层：懒加载工具实现，避免模块入口被 require 时加载全部实现 */
+module.exports = new Proxy({}, {
+  get(_t, key) {
+    if (typeof key !== 'string') return undefined;
+    if (!fs.existsSync(path.join(__dirname, key, 'index.js'))) return undefined;
+    return require('./' + key);
+  },
+  has(_t, key) {
+    return typeof key === 'string' && fs.existsSync(path.join(__dirname, key, 'index.js'));
+  },
+  ownKeys() { return fs.readdirSync(__dirname, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name); },
+  getOwnPropertyDescriptor(_t, key) { return this.has(_t, key) ? { enumerable: true, configurable: true } : undefined; }
+});