mm_mysql 2.0.4 → 2.0.6

package/index.js

@@ -1,1072 +1,359 @@
-/**
- * MySQL数据库操作类
- * @class Mysql
- * @extends BaseService
- */
-// 添加模块导入检查
-let mysql = require('mysql2/promise');
-const { BaseService } = require('mm_base_service');
-const { DB } = require('./db');
-class Mysql extends BaseService {
-  /**
-   * 默认配置
-   */
-  static default_config = {
-    host: '127.0.0.1',
-    port: 3306,
-    user: 'root',
-    password: '',
-    database: '',
-    charset: 'utf8mb4',
-    timezone: '+08:00',
-    connectTimeout: 20000,  // mysql2原生支持的连接超时
-    acquireTimeout: 20000,  // 自定义获取连接超时
-    queryTimeout: 20000,    // 自定义查询超时
-    connectionLimit: 10,
-    queueLimit: 0,
-    enableKeepAlive: true,
-    keepAliveInitialDelay: 10000,
-    enableReconnect: true,
-    reconnectInterval: 1000,
-    maxReconnectAttempts: 5,  // 最大重连次数
-    waitForConnections: true  // 确保连接池等待连接可用
-  };
-
-  /**
-   * 构造函数
-   * @param {Object} config - 配置对象
-   */
-  constructor(config = {}) {
-    // 修复配置合并问题 - 手动合并配置以确保用户配置优先级
-    const mergedConfig = { ...Mysql.default_config, ...config };
-    super(mergedConfig);
-
-    // 确保this.config包含合并后的配置
-    this.config = { ...Mysql.default_config, ...config };
-
-    // 初始化状态
-    this._connection = null; // 单个连接
-    this._pool = null; // 连接池
-    this._status = 'closed'; // closed, connecting, connected
-    this._lastConnectTime = 0;
-    this._reconnecting = false;
-    this._isInited = false;
-    this._isDestroyed = false;
-  }
-}
-
-/**
- * 开始事务
- * @returns {Promise<Object>} 事务连接对象
- */
-Mysql.prototype.beginTransaction = async function () {
-  try {
-    // 检查连接状态
-    if (this._status !== 'connected') {
-      throw new Error('数据库连接未建立');
-    }
-
-    // 获取连接
-    const connection = await this.getConn();
-
-    // 开始事务
-    await connection.beginTransaction();
-
-    if (this.config.debug) {
-      $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务开始`);
-    }
-
-    // 返回事务连接对象，包含提交和回滚方法
-    return {
-      connection,
-      commit: async () => {
-        await connection.commit();
-        if (this.config.debug) {
-          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务提交`);
-        }
-        // 如果使用连接池，释放连接
-        if (this.config.usePool) {
-          connection.release();
-        }
-      },
-      rollback: async () => {
-        await connection.rollback();
-        if (this.config.debug) {
-          $.log.debug(`[${this.constructor.name}] [beginTransaction] 事务回滚`);
-        }
-        // 如果使用连接池，释放连接
-        if (this.config.usePool) {
-          connection.release();
-        }
-      },
-      exec: async (sql, params = []) => {
-        // 在事务中执行SQL，直接实现超时控制
-        const timeout = this.config.queryTimeout || 20000;
-        const queryPromise = connection.query(sql, params);
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(new Error(`事务查询超时: ${timeout}ms`));
-          }, timeout);
-        });
-
-        const result = await Promise.race([queryPromise, timeoutPromise]);
-        return result[0];
-      }
-    };
-  } catch (error) {
-    $.log.error(`[${this.constructor.name}] [beginTransaction] 事务开始失败`, { error: error.message });
-    throw error;
-  }
-};
-
-/**
- * 在事务中执行多个操作
- * @param {Function} callback - 包含事务操作的回调函数
- * @returns {Promise<*>} 回调函数的返回值
- */
-Mysql.prototype.transaction = async function (callback) {
-  let transaction = null;
-
-  try {
-    // 开始事务
-    transaction = await this.beginTransaction();
-
-    // 执行回调函数，传入事务对象
-    const result = await callback(transaction);
-
-    // 提交事务
-    await transaction.commit();
-
-    return result;
-  } catch (error) {
-    // 如果有事务，回滚
-    if (transaction) {
-      await transaction.rollback().catch(err => {
-        $.log.error(`[${this.constructor.name}] [transaction] 事务回滚失败`, { error: err.message });
-      });
-    }
-
-    $.log.error(`[${this.constructor.name}] [transaction] 事务执行失败`, { error: error.message });
-    throw error;
-  }
-};
-Mysql.prototype._initService = async function () {
-  if (this._isInited) {
-    $.log.warn('MySQL服务已初始化');
-    return;
-  }
-
-  try {
-    $.log.debug('[Mysql] [_initService]', '初始化MySQL服务', { config: this.config });
-    this._isInited = true;
-    $.log.debug('[Mysql] [_initService]', 'MySQL服务初始化完成');
-  } catch (error) {
-    $.log.error('[Mysql] [_initService]', 'MySQL服务初始化失败', { error: error.message });
-    throw error;
-  }
-};
-
-/**
- * 打开数据库连接
- * @param {Number} timeout - 超时时间(毫秒)
- * @returns {Promise<boolean>}
- */
-Mysql.prototype.open = async function (timeout = null) {
-  if (this._status === 'connected' || this._status === 'connecting') {
-    $.log.warn('数据库连接已存在或正在连接中');
-    return true;
-  }
-
-  timeout = timeout || this.config.connectTimeout || 10000;
-  this._status = 'connecting';
-
-  try {
-    $.log.debug(`[${this.constructor.name}] [open]`, '开始创建数据库连接', {
-      host: this.config.host,
-      port: this.config.port,
-      database: this.config.database,
-      user: this.config.user,
-      timeout: timeout
-    });
-
-    // 创建连接或连接池
-    const connectionPromise = this._openInternal();
-    // 直接在方法内部实现超时控制
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`数据库连接超时(${timeout}ms)`));
-      }, timeout);
-    });
-
-    try {
-      await Promise.race([connectionPromise, timeoutPromise]);
-
-      this._lastConnectTime = Date.now();
-      this._status = 'connected';
-      $.log.info(`[${this.constructor.name}] [open]`, '数据库连接成功', {
-        host: this.config.host,
-        port: this.config.port,
-        database: this.config.database
-      });
-      return true;
-    } catch (connectionErr) {
-      // 捕获连接过程中的具体错误
-      $.log.error(`[${this.constructor.name}] [open]`, '连接过程错误详情', {
-        error: connectionErr.message,
-        code: connectionErr.code,
-        syscall: connectionErr.syscall,
-        address: connectionErr.address,
-        port: connectionErr.port,
-        stack: connectionErr.stack
-      });
-      throw connectionErr;
-    }
-  } catch (err) {
-    this._status = 'closed';
-    $.log.error(`[${this.constructor.name}] [open]`, '数据库连接失败', {
-      error: err.message,
-      host: this.config.host,
-      port: this.config.port,
-      database: this.config.database
-    });
-    throw err;
-  }
-};
-
-/**
- * 内部连接方法
- * @private
- * @returns {Promise<void>}
- */
-Mysql.prototype._openInternal = function () {
-  return new Promise((resolve, reject) => {
-    // 检查mysql模块是否可用
-    if (!mysql) {
-      const error = new Error('mysql2模块不可用，请先安装依赖: npm install');
-      $.log.error(`[${this.constructor.name}] [_openInternal] 错误:`, error.message);
-      return reject(error);
-    }
-
-    // 配置对象 - 尽量使用mysql2原生支持的配置项
-    const mysqlConfig = {
-      host: this.config.host,
-      port: this.config.port,
-      user: this.config.user,
-      password: this.config.password,
-      database: this.config.database,
-      charset: this.config.charset || 'utf8mb4',
-      timezone: this.config.timezone || '+08:00',
-      connectTimeout: this.config.connectTimeout || 10000,
-      enableKeepAlive: this.config.enableKeepAlive !== false,
-      keepAliveInitialDelay: this.config.keepAliveInitialDelay || 10000,
-      waitForConnections: true
-    };
-
-    // 输出连接配置（隐藏密码）
-    const logConfig = { ...mysqlConfig };
-    logConfig.password = '***';
-    $.log.debug(`[${this.constructor.name}] [_openInternal] 连接配置:`, JSON.stringify(logConfig, null, 2));
-
-    if (this.config.connectionLimit > 1) {
-      // 使用连接池 - 直接使用mysql2原生连接池功能
-      $.log.debug(`[${this.constructor.name}] [_openInternal] 创建连接池`);
-      try {
-        this._pool = mysql.createPool({
-          ...mysqlConfig,
-          connectionLimit: this.config.connectionLimit || 10,
-          queueLimit: this.config.queueLimit || 0,
-          waitForConnections: true
-        });
-
-        // 验证连接池
-        $.log.debug(`[${this.constructor.name}] [_openInternal] 验证连接池连接...`);
-        this._pool.getConnection()
-          .then(conn => {
-            $.log.debug(`[${this.constructor.name}] [_openInternal] 连接池连接验证成功`);
-            conn.release();
-            resolve();
-          })
-          .catch(err => {
-            $.log.error(`[${this.constructor.name}] [_openInternal] 连接池验证失败详情:`, {
-              message: err.message,
-              code: err.code,
-              errno: err.errno,
-              syscall: err.syscall,
-              address: err.address,
-              port: err.port
-            });
-            reject(err);
-          });
-      } catch (poolError) {
-        $.log.error(`[${this.constructor.name}] [_openInternal] 创建连接池失败:`, poolError.message);
-        reject(poolError);
-      }
-    } else {
-      // 使用单个连接
-      $.log.debug(`[${this.constructor.name}] [_openInternal] 创建单个连接`);
-      try {
-        mysql.createConnection(mysqlConfig)
-          .then(conn => {
-            $.log.debug(`[${this.constructor.name}] [_openInternal] 单个连接创建成功`);
-            this._connection = conn;
-            resolve();
-          })
-          .catch(err => {
-            $.log.error(`[${this.constructor.name}] [_openInternal] 单个连接创建失败详情:`, {
-              message: err.message,
-              code: err.code,
-              errno: err.errno,
-              syscall: err.syscall,
-              address: err.address,
-              port: err.port
-            });
-            reject(err);
-          });
-      } catch (connError) {
-        $.log.error(`[${this.constructor.name}] [_openInternal] 创建连接失败:`, connError.message);
-        reject(connError);
-      }
-    }
-  });
-};
-
-/**
- * 关闭数据库连接
- * @returns {Promise<boolean>}
- */
-Mysql.prototype.close = function () {
-  if (this._status !== 'connected') {
-    $.log.warn('数据库连接未建立');
-    return Promise.resolve(false);
-  }
-
-  return new Promise((resolve) => {
-    try {
-      if (this._pool) {
-        $.log.debug('关闭连接池');
-        this._pool.end(err => {
-          if (err) {
-            $.log.error('关闭连接池失败', { error: err.message });
-          } else {
-            $.log.info('连接池已关闭');
-          }
-          this._pool = null;
-          this._status = 'closed';
-          resolve(!err);
-        });
-      } else if (this._connection) {
-        $.log.debug('关闭单个连接');
-        this._connection.end(err => {
-          if (err) {
-            $.log.error('关闭连接失败', { error: err.message });
-          } else {
-            $.log.info('连接已关闭');
-          }
-          this._connection = null;
-          this._status = 'closed';
-          resolve(!err);
-        });
-      } else {
-        this._status = 'closed';
-        resolve(true);
-      }
-    } catch (err) {
-      $.log.error('关闭数据库连接时发生异常', { error: err.message });
-      this._status = 'closed';
-      resolve(false);
-    }
-  });
-};
-
-/**
- * 获取数据库连接
- * @param {Number} timeout - 超时时间(毫秒)
- * @returns {Promise<Object>}
- */
-Mysql.prototype.getConn = async function (timeout = null) {
-  // 确定最终超时时间，优先使用传入参数，其次是配置，最后是默认值
-  timeout = timeout || this.config.acquireTimeout || this.config.connectTimeout || 20000;
-
-  // 记录实际使用的超时时间
-  $.log.debug(`[${this.constructor.name}] [getConn] 使用超时时间: ${timeout}ms`);
-
-  if (this._status !== 'connected') {
-    throw new Error('数据库连接未建立');
-  }
-
-  try {
-    // 先检查连接池状态（如果存在）
-    if (this._pool && typeof this._pool._closed !== 'undefined' && this._pool._closed) {
-      $.log.warn('连接池已关闭，尝试重新连接');
-      await this.close();
-      await this.open();
-    }
-
-    // 直接在方法内部实现超时控制
-    const connectionPromise = this._getConnectionInternal();
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`获取数据库连接超时(${timeout}ms)`));
-      }, timeout);
-    });
-
-    const conn = await Promise.race([connectionPromise, timeoutPromise]);
-
-    $.log.debug(`[${this.constructor.name}] [getConn] 成功获取数据库连接`);
-
-    // 处理连接错误
-    conn.on('error', (err) => {
-      if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT' || err.code === 'PROTOCOL_CONNECTION_LOST' ||
-        err.code === 'POOL_CLOSED' || err.code === 'CONNECTION_TIMED_OUT')) {
-        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' || error.code === 'PROTOCOL_CONNECTION_LOST' ||
-      error.code === 'POOL_CLOSED' || error.code === 'CONNECTION_TIMED_OUT')) {
-      this._handleConnectionError(error);
-    }
-
-    throw error;
-  }
-};
-
-/**
- * 内部获取连接方法
- * @private
- * @returns {Promise<Object>}
- */
-Mysql.prototype._getConnectionInternal = function () {
-  return new Promise((resolve, reject) => {
-    if (this._pool) {
-      // 从连接池获取连接
-      this._pool.getConnection()
-        .then(conn => {
-          // 设置连接的超时处理
-          conn.on('error', (err) => {
-            $.log.error('数据库连接发生错误', { error: err.message });
-            if (this.config.enableReconnect) {
-              this._handleConnectionError(err);
-            }
-          });
-          resolve(conn);
-        })
-        .catch(err => {
-          reject(err);
-        });
-    } else if (this._connection) {
-      // 返回单个连接
-      resolve(this._connection);
-    } else {
-      reject(new Error('无可用连接'));
-    }
-  });
-};
-
-/**
- * 处理连接错误
- * @private
- * @param {Error} err - 错误对象
- */
-Mysql.prototype._handleConnectionError = function (err) {
-  if (this._reconnecting) {
-    $.log.debug('重连已在进行中');
-    return;
-  }
-
-  if (this.config.enableReconnect) {
-    $.log.info('开始自动重连...');
-    this._reconnect(this.config.maxReconnectAttempts || 3)
-      .catch(reconnectErr => {
-        $.log.error('重连失败', { error: reconnectErr.message });
-        this._status = 'closed';
-      });
-  } else {
-    $.log.warn('自动重连已禁用');
-    this._status = 'closed';
-  }
-};
-
-/**
- * 重新连接数据库
- * @private
- * @param {Number} maxRetries - 最大重试次数
- * @returns {Promise<boolean>}
- */
-Mysql.prototype._reconnect = async function (maxRetries = 3) {
-  if (this._reconnecting) {
-    $.log.warn('重连已在进行中');
-    return false;
-  }
-
-  this._reconnecting = true;
-  let retryCount = 0;
-
-  try {
-    // 先关闭现有连接
-    if (this._status === 'connected') {
-      await this.close();
-    }
-
-    while (retryCount < maxRetries) {
-      retryCount++;
-      $.log.info(`第${retryCount}/${maxRetries}次尝试重连`);
-
-      try {
-        // 使用配置中的超时时间，优先使用connectTimeout，其次是acquireTimeout，最后是默认值20000ms
-        const reconnectTimeout = this.config.connectTimeout || this.config.acquireTimeout || 20000;
-        $.log.debug(`重连超时设置为: ${reconnectTimeout}ms`);
-        await this.open(reconnectTimeout);
-        $.log.info('重连成功');
-        return true;
-      } catch (err) {
-        $.log.error(`重连失败(${retryCount}/${maxRetries})`, { error: err.message });
-
-        if (retryCount < maxRetries) {
-          // 等待一段时间后重试
-          const waitTime = this.config.reconnectInterval || 1000;
-          $.log.debug(`等待${waitTime}ms后重试`);
-          await this._sleep(waitTime);
-        }
-      }
-    }
-
-    $.log.error(`达到最大重试次数(${maxRetries})，重连失败`);
-    throw new Error(`重连失败：达到最大重试次数(${maxRetries})`);
-  } finally {
-    this._reconnecting = false;
-  }
-};
-
-/**
- * 执行SQL查询
- * @param {String} sql - SQL语句
- * @param {Array} params - 参数数组
- * @param {Number} timeout - 超时时间(毫秒)
- * @returns {Promise<Object>}
- */
-Mysql.prototype.run = async function (sql, params = [], timeout = null) {
-  let conn = null;
-  let isPoolConn = false;
-  timeout = timeout || this.config.queryTimeout || 30000;
-
-  try {
-    // 获取连接
-    conn = await this.getConn(timeout);
-    isPoolConn = !!this._pool;
-
-    // 直接在方法内部实现超时控制
-    const queryPromise = conn.query(sql, params);
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`SQL查询超时: ${timeout}ms`));
-      }, timeout);
-    });
-
-    const [rows] = await Promise.race([queryPromise, timeoutPromise]);
-
-    // 返回查询结果的第一行或整个结果集，与之前版本兼容
-    return rows;
-  } catch (err) {
-    $.log.error('[Mysql] [run]', 'SQL执行失败', {
-      error: err.message,
-      sql: typeof sql === 'string' ? sql.substring(0, 200) : sql,
-      params: params
-    });
-
-    // 处理连接错误，触发重连
-    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT' || err.code === 'PROTOCOL_CONNECTION_LOST')) {
-      this._handleConnectionError(err);
-    }
-
-    throw err;
-  } finally {
-    // 释放连接
-    if (conn && isPoolConn) {
-      try {
-        conn.release();
-      } catch (releaseErr) {
-        $.log.error('释放连接失败', { error: releaseErr.message });
-      }
-    }
-  }
-};
-
-/**
- * 执行SQL语句（用于执行非查询语句如INSERT/UPDATE/DELETE）
- * @param {String} sql - SQL语句
- * @param {Array} params - 参数数组
- * @param {Number} timeout - 超时时间(毫秒)
- * @returns {Promise<Object>}
- */
-Mysql.prototype.exec = async function (sql, params = [], timeout = null) {
-  let conn = null;
-  let isPoolConn = false;
-  timeout = timeout || this.config.queryTimeout || 30000;
-
-  try {
-    // 获取连接
-    conn = await this.getConn(timeout);
-    isPoolConn = !!this._pool;
-
-    // 直接在方法内部实现超时控制
-    const queryPromise = conn.query(sql, params);
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`SQL执行超时: ${timeout}ms`));
-      }, timeout);
-    });
-
-    const [rows] = await Promise.race([queryPromise, timeoutPromise]);
-
-    // 返回与mm_sqlite兼容的格式
-    return {
-      affectedRows: rows.affectedRows || 0,
-      insertId: rows.insertId || 0,
-      changedRows: rows.changedRows || 0
-    };
-  } catch (err) {
-    $.log.error('[Mysql] [exec]', 'SQL执行失败', {
-      error: err.message,
-      sql: sql.substring(0, 200),
-      params: params
-    });
-
-    // 处理连接错误，触发重连
-    if (err.code && (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT' || err.code === 'PROTOCOL_CONNECTION_LOST')) {
-      this._handleConnectionError(err);
-    }
-
-    throw err;
-  } finally {
-    // 释放连接（如果是从连接池获取的）
-    if (conn && isPoolConn) {
-      try {
-        conn.release();
-      } catch (releaseErr) {
-        $.log.error('释放连接失败', { error: releaseErr.message });
-      }
-    }
-  }
-};
-
-/**
- * 读取整张表的数据
- * @param {String} table - 表名
- * @param {Object} condition - 查询条件
- * @param {Object} options - 选项（orderBy, limit, offset等）
- * @returns {Promise<Array>}
- */
-Mysql.prototype.read = async function (table, condition = {}, options = {}) {
-  try {
-    // 检查连接状态
-    if (this._status !== 'connected') {
-      throw new Error('数据库连接未建立');
-    }
-
-    // 构建基础SQL查询
-    let sql = `SELECT * FROM ${table}`;
-    const params = [];
-
-    // 处理条件
-    if (Object.keys(condition).length > 0) {
-      const whereClauses = [];
-      for (const [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}`;
-    }
-
-    // 记录查询日志
-    if (this.config.debug) {
-      $.log.debug(`[${this.constructor.name}] [read] 查询数据`, { sql, params });
-    }
-
-    // 执行查询，使用run方法获取数组格式的结果
-    const results = await this.run(sql, params);
-
-    if (this.config.debug) {
-      $.log.info(`[${this.constructor.name}] [read] 查询成功`, { count: results.length });
-    }
-
-    return results;
-  } catch (error) {
-    // 记录错误日志
-    $.log.error(`[${this.constructor.name}] [read] 查询失败`, {
-      error: error.message,
-      table: table,
-      condition: condition
-    });
-
-    // 抛出错误
-    throw error;
-  }
-};
-
-/**
- * 保存数据库结构到SQL文件
- * @param {String} file - 输出文件路径
- * @param {Array} tables - 要保存的表名数组，空数组表示保存所有表
- * @returns {Promise<boolean>}
- */
-Mysql.prototype.save = async function (file, tables = []) {
-  try {
-    let sqlContent = '';
-
-    // 获取所有表名
-    const allTablesResult = await this.run('SHOW TABLES');
-    let tableNames = [];
-
-    if (allTablesResult && allTablesResult.length > 0) {
-      const tableKey = Object.keys(allTablesResult[0])[0];
-      tableNames = allTablesResult.map(row => row[tableKey]);
-    }
-
-    // 过滤要保存的表
-    const tablesToSave = tables.length > 0
-      ? tableNames.filter(name => tables.includes(name))
-      : tableNames;
-
-    // 导出每个表的结构
-    for (const tableName of tablesToSave) {
-      const createSqlResult = await this.run(`SHOW CREATE TABLE \`${tableName}\``);
-      if (createSqlResult && createSqlResult.length > 0) {
-        const createSql = createSqlResult[0]['Create Table'];
-        sqlContent += `\n\n-- Table structure for \`${tableName}\`\n`;
-        sqlContent += createSql + ';\n';
-      }
-    }
-
-    // 确保目录存在
-    file.addDir();
-    file.saveText(sqlContent);
-    $.log.info(`成功导出数据库结构到: ${file}`);
-    return true;
-  } catch (err) {
-    $.log.error(`导出数据库结构失败: ${file}`, { error: err.message });
-    throw err;
-  }
-};
-
-/**
- * 从SQL文件加载数据库结构和数据
- * @param {String} file - SQL文件路径
- * @returns {Promise<boolean>} 是否加载成功
- */
-Mysql.prototype.load = async function (file) {
-  try {
-    // 记录操作日志
-    if (this.config.debug) {
-      $.log.debug(`[${this.constructor.name}] [load] 开始从文件加载数据库`, { 
-        file: file
-      });
-    }
-    
-    // 检查文件是否存在
-    if (!file.hasFile()) {
-      throw new Error(`SQL文件不存在: ${file}`);
-    }
-    
-    // 读取SQL文件内容
-    const sqlContent = file.readText();
-    
-    if (!sqlContent || sqlContent.trim() === '') {
-      throw new Error(`SQL文件内容为空: ${file}`);
-    }
-    
-    // 分割SQL语句（按分号分割，但需要注意处理字符串中的分号）
-    const sqlStatements = this._splitSqlStatements(sqlContent);
-    
-    // 开始事务执行SQL语句
-    await this.exec('START TRANSACTION');
-    
-    try {
-      // 逐个执行SQL语句
-      for (const sql of sqlStatements) {
-        const trimmedSql = sql.trim();
-        if (trimmedSql) {
-          await this.exec(trimmedSql);
-        }
-      }
-      
-      // 提交事务
-      await this.exec('COMMIT');
-      
-      if (this.config.debug) {
-        $.log.info(`[${this.constructor.name}] [load] 数据库加载成功`, { 
-          file: file,
-          statementCount: sqlStatements.length
-        });
-      }
-      
-      return true;
-    } catch (err) {
-      // 回滚事务
-      await this.exec('ROLLBACK').catch(rollbackErr => {
-        $.log.error(`[${this.constructor.name}] [load] 事务回滚失败`, {
-          error: rollbackErr.message
-        });
-      });
-      
-      throw err;
-    }
-  } catch (error) {
-    // 记录错误日志
-    $.log.error(`[${this.constructor.name}] [load] 数据库加载失败`, {
-      error: error.message,
-      file: file
-    });
-    
-    // 抛出错误
-    throw error;
-  }
-};
-
-/**
- * 分割SQL语句
- * @private
- * @param {String} sqlContent - SQL内容
- * @returns {Array} SQL语句数组
- */
-Mysql.prototype._splitSqlStatements = function(sqlContent) {
-  const statements = [];
-  let inString = false;
-  let stringChar = '';
-  let inComment = false;
-  let currentStatement = '';
-  
-  for (let i = 0; i < sqlContent.length; i++) {
-    const char = sqlContent[i];
-    const nextChar = i + 1 < sqlContent.length ? sqlContent[i + 1] : '';
-    
-    // 处理注释
-    if (!inString && !inComment && char === '-' && nextChar === '-') {
-      inComment = true;
-      i++; // 跳过第二个'-'
-      continue;
-    }
-    
-    if (inComment && char === '\n') {
-      inComment = false;
-      continue;
-    }
-    
-    if (inComment) {
-      continue;
-    }
-    
-    // 处理多行注释
-    if (!inString && !inComment && char === '/' && nextChar === '*') {
-      inComment = true;
-      i++; // 跳过'*'
-      continue;
-    }
-    
-    if (inComment && char === '*' && nextChar === '/') {
-      inComment = false;
-      i++; // 跳过'/'
-      continue;
-    }
-    
-    // 处理字符串
-    if (!inComment && (char === "'" || char === '"') && (!inString || stringChar === char)) {
-      // 检查是否是转义的引号
-      let escaped = false;
-      for (let j = i - 1; j >= 0; j--) {
-        if (sqlContent[j] === '\\') {
-          escaped = !escaped;
-        } else {
-          break;
-        }
-      }
-      
-      if (!escaped) {
-        if (inString && stringChar === char) {
-          inString = false;
-          stringChar = '';
-        } else if (!inString) {
-          inString = true;
-          stringChar = char;
-        }
-      }
-    }
-    
-    // 分割语句
-    if (!inString && !inComment && char === ';') {
-      statements.push(currentStatement.trim());
-      currentStatement = '';
-    } else {
-      currentStatement += char;
-    }
-  }
-  
-  // 添加最后一个语句（如果有）
-  if (currentStatement.trim()) {
-    statements.push(currentStatement.trim());
-  }
-  
-  return statements;
-};
-
-/**
- * 获取DB实例（用于高级操作）
- * @returns {Object} 包含exec、add、set、get、del等方法的数据库操作对象
- */
-Mysql.prototype.db = function () {
-  return new DB(this);
-};
-
-/**
- * 睡眠指定时间（工具方法）
- * @private
- * @param {Number} ms - 毫秒数
- * @returns {Promise<void>}
- */
-Mysql.prototype._sleep = function (ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-};
-
-/**
- * @description 销毁MySQL服务，关闭连接池
- * @async
- * @returns {Promise<void>}
- */
-Mysql.prototype.destroy = async function () {
-  if (this._isDestroyed) {
-    $.log.warn('MySQL服务已销毁');
-    return;
-  }
-
-  try {
-    $.log.debug('[Mysql] [destroy]', '开始销毁MySQL服务');
-
-    // 关闭数据库连接
-    if (this._status === 'connected') {
-      await this.close();
-    }
-
-    // 重置状态
-    this._isDestroyed = true;
-    this._isInited = false;
-    this._connection = null;
-    this._pool = null;
-    this._status = 'closed';
-
-    $.log.debug('[Mysql] [destroy]', 'MySQL服务销毁完成');
-  } catch (error) {
-    $.log.error('[Mysql] [destroy]', 'MySQL服务销毁失败', { error: error.message });
-    throw error;
-  }
-};
-
-/**
- * 睡眠指定时间（工具方法）
- * @private
- * @param {Number} ms - 毫秒数
- * @returns {Promise<void>}
- */
-Mysql.prototype._sleep = function (ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-};
-
-/**
- * SQL语法转换方法（与mm_sqlite保持兼容）
- * @param {String} sql - 原始SQL语句
- * @returns {String} 转换后的SQL语句
- */
-Mysql.prototype._convertSqlSyntax = function (sql) {
-  // MySQL不需要特殊的语法转换，直接返回原SQL
-  // 此方法主要用于保持与mm_sqlite的接口兼容性
-  return sql;
-};
-
-/**
- * 获取数据库路径（与mm_sqlite保持兼容）
- * @returns {String} 数据库连接信息
- */
-Mysql.prototype._getDatabasePath = function () {
-  // MySQL不需要文件路径，返回连接信息用于兼容性
-  return `${this.config.host}:${this.config.port}/${this.config.database}`;
-};
-
-/**
- * 初始化MySQL服务
- * @async
- * @returns {Promise<void>}
- */
-Mysql.prototype.init = async function () {
-  if (this._isInited) {
-    $.log.warn('MySQL服务已初始化');
-    return;
-  }
-
-  try {
-    $.log.debug('[Mysql] [init]', '初始化MySQL服务');
-    await this._initService();
-    await this.open();
-    $.log.debug('[Mysql] [init]', 'MySQL服务初始化完成');
-  } catch (error) {
-    $.log.error('[Mysql] [init]', 'MySQL服务初始化失败', { error: error.message });
-    throw error;
-  }
-};
-
-/**
- * 导出模块
- */
-exports.Mysql = Mysql;
-
-/**
- * 确保连接池对象存在
- */
-if (!$.pool) {
-  $.pool = {};
-}
-if (!$.pool.mysql) {
-  $.pool.mysql = {};
-}
-
-/**
- * @description Mysql管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {Object} config 配置参数
- * @return {Object} 返回一个Mysql类实例
- */
-function mysql_admin(scope, config) {
-  if (!scope) {
-    scope = 'sys';
-  }
-  var obj = $.pool.mysql[scope];
-  if (!obj) {
-    $.pool.mysql[scope] = new Mysql(config);
-    obj = $.pool.mysql[scope];
-  }
-  return obj;
-}
-
-/**
- * @module 导出Mysql管理器
- */
+const mysql = require('mysql2/promise');
+const { BaseService } = require('mm_base_service');
+const { DB } = require('./db');
+/**
+ * 优化版MySQL数据库操作类
+ * 保持必要功能，简化过度封装，直接使用mysql2模块
+ * @class Mysql
+ * @extends BaseService
+ */
+class Mysql extends BaseService {
+    /**
+     * 默认配置
+     */
+    static default_config = {
+        host: '127.0.0.1',
+        port: 3306,
+        user: 'root',
+        password: '',
+        database: '',
+        charset: 'utf8mb4',
+        timezone: '+08:00',
+        connectTimeout: 20000,
+        connectionLimit: 10,
+        queueLimit: 0
+    };
+
+    /**
+     * 构造函数
+     * @param {Object} config - 配置对象
+     */
+    constructor(config = {}) {
+        const mergedConfig = Object.assign({}, Mysql.default_config, config);
+        super(mergedConfig);
+        
+        this.config = mergedConfig;
+        this._pool = null;
+        this._connection = null;
+        this._usePool = this.config.connectionLimit > 1;
+    }
+}
+
+/**
+ * 打开数据库连接
+ * @returns {Promise<boolean>}
+ */
+Mysql.prototype.open = async function() {
+    try {
+        if (this._usePool) {
+            this._pool = mysql.createPool(this.config);
+            // 测试连接池连接
+            const conn = await this._pool.getConnection();
+            conn.release();
+        } else {
+            this._connection = await mysql.createConnection(this.config);
+        }
+        
+        $.log.info(`[${this.constructor.name}] [open] 数据库连接成功`);
+        return true;
+    } catch (error) {
+        $.log.error(`[${this.constructor.name}] [open] 数据库连接失败`, {
+            error: error.message
+        });
+        throw error;
+    }
+};
+
+/**
+ * 关闭数据库连接
+ * @returns {Promise<boolean>}
+ */
+Mysql.prototype.close = async function() {
+    try {
+        if (this._pool) {
+            await this._pool.end();
+            this._pool = null;
+        }
+        if (this._connection) {
+            await this._connection.end();
+            this._connection = null;
+        }
+        
+        $.log.info(`[${this.constructor.name}] [close] 数据库连接已关闭`);
+        return true;
+    } catch (error) {
+        $.log.error(`[${this.constructor.name}] [close] 关闭连接失败`, {
+            error: error.message
+        });
+        throw error;
+    }
+};
+
+/**
+ * 获取数据库连接（保持兼容性）
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
+ */
+Mysql.prototype.getConn = async function(timeout = null) {
+    try {
+        if (this._usePool) {
+            return await this._pool.getConnection();
+        } else {
+            return this._connection;
+        }
+    } catch (error) {
+        $.log.error(`[${this.constructor.name}] [getConn] 获取连接失败`, {
+            error: error.message
+        });
+        throw error;
+    }
+};
+
+/**
+ * 执行SQL查询（保持兼容性）
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
+ */
+Mysql.prototype.run = async function(sql, params = [], timeout = null) {
+    let conn = null;
+    let isPoolConn = false;
+    
+    try {
+        // 获取连接
+        conn = await this.getConn();
+        isPoolConn = this._usePool;
+        
+        // 直接使用mysql2的query方法
+        const [rows] = await conn.query(sql, params);
+        return rows;
+    } catch (error) {
+        $.log.error(`[${this.constructor.name}] [run] SQL执行失败`, {
+            error: error.message,
+            sql: typeof sql === 'string' ? sql.substring(0, 200) : sql,
+            params: params
+        });
+        throw error;
+    } finally {
+        // 释放连接
+        if (conn && isPoolConn) {
+            try {
+                conn.release();
+            } catch (releaseErr) {
+                $.log.error('释放连接失败', {
+                    error: releaseErr.message
+                });
+            }
+        }
+    }
+};
+
+/**
+ * 执行SQL语句（保持兼容性）
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @returns {Promise<Object>}
+ */
+Mysql.prototype.exec = async function(sql, params = [], timeout = null) {
+    let conn = null;
+    let isPoolConn = false;
+    
+    try {
+        // 获取连接
+        conn = await this.getConn();
+        isPoolConn = this._usePool;
+        
+        // 直接使用mysql2的execute方法
+        const [result] = await conn.execute(sql, params);
+        
+        // 返回与mm_sqlite兼容的格式
+        return {
+            affectedRows: result.affectedRows || 0,
+            insertId: result.insertId || 0,
+            changedRows: result.changedRows || 0
+        };
+    } catch (error) {
+        $.log.error(`[${this.constructor.name}] [exec] SQL执行失败`, {
+            error: error.message,
+            sql: sql.substring(0, 200),
+            params: params
+        });
+        throw error;
+    } finally {
+        // 释放连接
+        if (conn && isPoolConn) {
+            try {
+                conn.release();
+            } catch (releaseErr) {
+                $.log.error('释放连接失败', {
+                    error: releaseErr.message
+                });
+            }
+        }
+    }
+};
+
+/**
+ * 开始事务（保持兼容性）
+ * @returns {Promise<Object>} 事务连接对象
+ */
+Mysql.prototype.beginTransaction = async function() {
+    try {
+        const conn = await this.getConn();
+        await conn.beginTransaction();
+        
+        return {
+            connection: conn,
+            commit: async () => {
+                await conn.commit();
+                if (this._usePool) {
+                    conn.release();
+                }
+            },
+            rollback: async () => {
+                await conn.rollback();
+                if (this._usePool) {
+                    conn.release();
+                }
+            }
+        };
+    } catch (error) {
+        $.log.error(`[${this.constructor.name}] [beginTransaction] 事务开始失败`, {
+            error: error.message
+        });
+        throw error;
+    }
+};
+
+/**
+ * 在事务中执行多个操作（保持兼容性）
+ * @param {Function} callback - 包含事务操作的回调函数
+ * @returns {Promise<*>} 回调函数的返回值
+ */
+Mysql.prototype.transaction = async function(callback) {
+    let transaction = null;
+    
+    try {
+        transaction = await this.beginTransaction();
+        const result = await callback(transaction);
+        await transaction.commit();
+        return result;
+    } catch (error) {
+        if (transaction) {
+            await transaction.rollback().catch(err => {
+                $.log.error(`[${this.constructor.name}] [transaction] 事务回滚失败`, {
+                    error: err.message
+                });
+            });
+        }
+        
+        $.log.error(`[${this.constructor.name}] [transaction] 事务执行失败`, {
+            error: error.message
+        });
+        throw error;
+    }
+};
+
+/**
+ * 读取整张表的数据（保持兼容性）
+ * @param {String} table - 表名
+ * @param {Object} condition - 查询条件
+ * @param {Object} options - 选项（orderBy, limit, offset等）
+ * @returns {Promise<Array>}
+ */
+Mysql.prototype.read = async function(table, condition = {}, options = {}) {
+    try {
+        let sql = `SELECT * FROM ${table}`;
+        const params = [];
+        
+        // 处理条件
+        if (Object.keys(condition).length > 0) {
+            const whereClauses = [];
+            for (const [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) {
+        $.log.error(`[${this.constructor.name}] [read] 查询失败`, {
+            error: error.message,
+            table: table,
+            condition: condition
+        });
+        throw error;
+    }
+};
+
+/**
+ * 获取数据库管理器（保持兼容性）
+ * @returns {Object} DB实例
+ */
+Mysql.prototype.db = function() {
+    return new DB(this);
+};
+
+/**
+ * 初始化MySQL服务（保持兼容性）
+ * @returns {Promise<void>}
+ */
+Mysql.prototype.init = async function() {
+    await this.open();
+};
+
+/**
+ * 导出模块
+ */
+exports.Mysql = Mysql;
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+	$.pool = {};
+}
+if (!$.pool.mysql) {
+	$.pool.mysql = {};
+}
+
+/**
+ * @description Mysql管理器，用于创建缓存
+ * @param {String} scope 作用域
+ * @param {Object} config 配置参数
+ * @return {Object} 返回一个Mysql类实例
+ */
+function mysql_admin(scope, config) {
+	if (!scope) {
+		scope = 'sys';
+	}
+	var obj = $.pool.mysql[scope];
+	if (!obj) {
+		$.pool.mysql[scope] = new Mysql(config);
+		obj = $.pool.mysql[scope];
+	}
+	return obj;
+}
+
+/**
+ * @module 导出Mysql管理器
+ */
 exports.mysql_admin = mysql_admin;