mm_mysql 2.3.8 → 2.4.0

package/index.js

@@ -22,7 +22,7 @@ class Mysql extends Base {
     charset: 'utf8mb4',
     timezone: '+08:00',
     connect_timeout: 15000,
-    
+
     // 连接池优化配置（针对高并发写入场景）
     connection_limit: 100,           // 减少连接数，避免资源竞争
     acquire_timeout: 30000,          // 延长获取连接超时时间
@@ -30,11 +30,6 @@ class Mysql extends Base {
     idle_timeout: 300000,            // 延长空闲连接超时时间(5分钟)
     max_idle: 30,                    // 减少最大空闲连接数
     queue_timeout: 60000,            // 队列超时时间
-    
-    // 预处理语句缓存优化配置
-    statement_cache_size: 50,        // 减少缓存大小，避免内存泄漏
-    max_prepared_statement_age: 300000, // 延长过期时间(5分钟)
-    enable_statement_pooling: true   // 启用预处理语句缓存
   };
 
   /**
@@ -45,130 +40,14 @@ class Mysql extends Base {
     super(config);
     this._pool = null;
     // 移除单连接支持，统一使用连接池
-    this._use_pool = true; // 强制使用连接池模式
-    
+
     // 错误信息
     this.error = null;
     // 最近执行的SQL语句
     this.sql = '';
-    
-    // 预处理语句缓存
-    this._prepared_stmts = new Map();
-    this._stmt_cache_size = this.config.statement_cache_size || 100;
-    this._cache_hits = 0;
-    this._cache_misses = 0;
-    
-    // 启动定期清理任务
-    this._startCleanupTask();
   }
 }
 
-/**
- * 启动预处理语句清理任务
- * @private
- */
-Mysql.prototype._startCleanupTask = function() {
-  if (this._cleanup_interval) {
-    clearInterval(this._cleanup_interval);
-  }
-  
-  this._cleanup_interval = setInterval(() => {
-    this._cleanupExpiredStatements();
-  }, 60000); // 每分钟清理一次
-};
-
-/**
- * 清理过期预处理语句
- * @private
- */
-Mysql.prototype._cleanupExpiredStatements = function() {
-  const now = Date.now();
-  const max_age = this.config.max_prepared_statement_age || 300000;
-  
-  for (const [key, statement_info] of this._prepared_stmts) {
-    if (now - statement_info.last_used > max_age) {
-      // 异步关闭语句，不阻塞主线程
-      if (statement_info.statement && typeof statement_info.statement.close === 'function') {
-        statement_info.statement.close().catch(() => {});
-      }
-      this._prepared_stmts.delete(key);
-    }
-  }
-};
-
-/**
- * 生成预处理语句缓存键
- * @private
- * @param {string} sql - SQL语句
- * @returns {string} 缓存键
- */
-Mysql.prototype._getStatementCacheKey = function(sql) {
-  // 简化SQL语句，移除多余空格和换行，提高缓存命中率
-  return sql.trim().replace(/\s+/g, ' ').toLowerCase();
-};
-
-/**
- * 缓存预处理语句
- * @private
- * @param {string} key - 缓存键
- * @param {object} statement - 预处理语句对象
- */
-Mysql.prototype._cacheStatement = function(key, statement) {
-  if (this._prepared_stmts.size >= this._stmt_cache_size) {
-    // 移除最久未使用的语句
-    const oldest_key = this._findOldestStatement();
-    if (oldest_key) {
-      const oldest_statement = this._prepared_stmts.get(oldest_key);
-      if (oldest_statement.statement && typeof oldest_statement.statement.close === 'function') {
-        oldest_statement.statement.close().catch(() => {});
-      }
-      this._prepared_stmts.delete(oldest_key);
-    }
-  }
-  
-  this._prepared_stmts.set(key, {
-    statement: statement,
-    last_used: Date.now(),
-    use_count: 0
-  });
-};
-
-/**
- * 查找最久未使用的预处理语句
- * @private
- * @returns {string} 缓存键
- */
-Mysql.prototype._findOldestStatement = function() {
-  let oldest_key = null;
-  let oldest_time = Date.now();
-  
-  for (const [key, statement_info] of this._prepared_stmts) {
-    if (statement_info.last_used < oldest_time) {
-      oldest_time = statement_info.last_used;
-      oldest_key = key;
-    }
-  }
-  
-  return oldest_key;
-};
-
-/**
- * 获取预处理语句缓存统计信息
- * @returns {object} 统计信息
- */
-Mysql.prototype.getStatementStats = function() {
-  const total = this._cache_hits + this._cache_misses;
-  const hit_rate = total > 0 ? (this._cache_hits / total) * 100 : 0;
-  
-  return {
-    cached_statements: this._prepared_stmts.size,
-    cache_hits: this._cache_hits,
-    cache_misses: this._cache_misses,
-    cache_hit_rate: hit_rate.toFixed(2) + '%',
-    max_cache_size: this._stmt_cache_size
-  };
-};
-
 /**
  * 获取MySQL2支持的配置参数
  * 根据连接类型（连接池或单连接）过滤参数，避免警告
@@ -177,7 +56,7 @@ Mysql.prototype.getStatementStats = function() {
  */
 Mysql.prototype._getValidConfig = function (is_pool = false) {
   // 基础连接参数（适用于所有连接类型）
-  const base_map = {
+  let base_map = {
     'host': 'host',
     'port': 'port',
     'user': 'user',
@@ -189,17 +68,17 @@ Mysql.prototype._getValidConfig = function (is_pool = false) {
   };
 
   // 连接池专用参数
-  const pool_map = {
+  let pool_map = {
     'connection_limit': 'connectionLimit',
     'wait_for_connections': 'waitForConnections',
     'idle_timeout': 'idleTimeout',
     'max_idle': 'maxIdle'
   };
 
-  const config = {};
+  let config = {};
 
   // 添加基础参数
-  for (const key in base_map) {
+  for (let key in base_map) {
     if (this.config[key] !== undefined) {
       config[base_map[key]] = this.config[key];
     }
@@ -207,7 +86,7 @@ Mysql.prototype._getValidConfig = function (is_pool = false) {
 
   // 如果是连接池，添加连接池专用参数
   if (is_pool) {
-    for (const key in pool_map) {
+    for (let key in pool_map) {
       if (this.config[key] !== undefined) {
         config[pool_map[key]] = this.config[key];
       }
@@ -216,7 +95,7 @@ Mysql.prototype._getValidConfig = function (is_pool = false) {
   // 如果是单连接，确保不包含任何连接池专用参数
   else {
     // 移除所有连接池专用参数，避免mysql2内部警告
-    for (const key in pool_map) {
+    for (let key in pool_map) {
       if (pool_map[key] in config) {
         delete config[pool_map[key]];
       }
@@ -231,87 +110,63 @@ Mysql.prototype._getValidConfig = function (is_pool = false) {
    * @returns {Promise<boolean>}
    * @throws {TypeError} 当配置参数无效时
    */
-  Mysql.prototype.open = async function () {
-    // 参数校验
-    if (!this.config || typeof this.config !== 'object') {
-      throw new TypeError('config must be object');
-    }
+Mysql.prototype.open = async function () {
+  // 参数校验
+  if (!this.config || typeof this.config !== 'object') {
+    throw new TypeError('config must be object');
+  }
 
-    try {
-      // 统一使用连接池模式
-      const valid_config = this._getValidConfig(true);
-      this._pool = mysql.createPool(valid_config);
-      
-      // 测试连接池连接
-      const conn = await this._pool.getConnection();
-      conn.release();
-
-      this.log('info', '数据库连接池创建成功');
-      return true;
-    } catch (error) {
-      this.log('error', '数据库连接池创建失败', error);
-      return false;
-    }
-  };
+  try {
+    // 统一使用连接池模式
+    let valid_config = this._getValidConfig(true);
+    this._pool = mysql.createPool(valid_config);
 
-/**
-   * 关闭数据库连接（统一使用连接池）
-   * @returns {Promise<boolean>}
-   */
-  Mysql.prototype.close = async function () {
-    try {
-      // 先关闭连接池，再清理预处理语句（避免连接状态问题）
-      if (this._pool) {
-        await this._pool.end();
-        this._pool = null;
-      }
-      
-      // 连接池关闭后，预处理语句会自动失效，只需清理缓存
-      if (this._prepared_stmts) {
-        // 不再尝试关闭预处理语句，直接清空缓存
-        this._prepared_stmts.clear();
-      }
+    // 测试连接池连接
+    let conn = await this._pool.getConnection();
+    conn.release();
 
-      this.log('info', '数据库连接池已关闭');
-      return true;
-    } catch (error) {
-      this.log('error', '关闭连接池失败', error);
-      return false;
-    }
-  };
+    this.log('info', '数据库连接池创建成功');
+    return true;
+  } catch (error) {
+    this.log('error', '数据库连接池创建失败', error);
+    return false;
+  }
+};
 
 /**
- * 安全释放数据库连接
- * @param {object} conn - 数据库连接对象
- * @param {boolean} is_pool_conn - 是否为连接池连接
- * @returns {Promise<void>}
+ * 关闭数据库连接（统一使用连接池）
+ * @returns {Promise<boolean>}
  */
-async function safeReleaseConn(conn, is_pool_conn) {
-  if (!conn) return;
-
+Mysql.prototype.close = async function () {
   try {
-    if (is_pool_conn && typeof conn.release === 'function') {
-      await conn.release();
+    // 先关闭连接池（避免连接状态问题）
+    if (this._pool) {
+      await this._pool.end();
+      this._pool = null;
     }
-  } catch (release_err) {
-    $.log.error('释放连接失败', release_err);
+
+    this.log('info', '数据库连接池已关闭');
+    return true;
+  } catch (error) {
+    this.log('error', '关闭连接池失败', error);
+    return false;
   }
 };
 
 /**
- * 释放连接（实例方法，简化事务使用）
+ * 安全释放数据库连接
  * @param {object} conn - 数据库连接对象
  * @returns {Promise<void>}
  */
-Mysql.prototype._releaseConn = async function(conn) {
+async function releaseConn(conn) {
   if (!conn) return;
-  
+
   try {
-    if (this._use_pool && typeof conn.release === 'function') {
+    if (typeof conn.release === 'function') {
       await conn.release();
     }
-  } catch (error) {
-    // 简化错误处理，避免频繁日志
+  } catch (release_err) {
+    $.log.error('释放连接失败', release_err);
   }
 };
 
@@ -320,24 +175,23 @@ Mysql.prototype._releaseConn = async function(conn) {
    * @returns {Promise<object>}
    * @throws {TypeError} 当连接池不存在时
    */
-  Mysql.prototype.getConn = async function () {
-    // 参数校验
-    if (!this._pool) {
-      await this.open();
-    }
+Mysql.prototype.getConn = async function () {
+  // 参数校验
+  if (!this._pool) {
+    await this.open();
+  }
 
-    try {
-      // 统一从连接池获取连接
-      const conn = await this._pool.getConnection();
-      return conn;
-    } catch (error) {
-      this.log('error', '从连接池获取连接失败', error);
-      throw error; // 重新抛出错误，让调用方处理
-    }
-  };
+  try {
+    // 统一从连接池获取连接
+    return await this._pool.getConnection();
+  } catch (error) {
+    this.log('error', '从连接池获取连接失败', error);
+    throw error; // 重新抛出错误，让调用方处理
+  }
+};
 
 /**
- * 执行SQL查询（优化版，支持预处理语句缓存）
+ * 执行SQL查询
  * @param {string} sql - SQL语句
  * @param {Array} params - 参数数组
  * @returns {Promise<object>}
@@ -353,98 +207,26 @@ Mysql.prototype.run = async function (sql, params = []) {
   }
 
   this.error = null;
+  this.sql = '';
   let conn = null;
-  let is_pool_conn = false;
-  let connection_released = false;
-
+  let ret = [];
   try {
     // 获取连接
     conn = await this.getConn();
-    is_pool_conn = this._use_pool;
-
-    // 检查是否启用预处理语句缓存
-    if (this.config.enable_statement_pooling && params.length > 0) {
-      const cache_key = this._getStatementCacheKey(sql);
-      let statement_info = this._prepared_stmts.get(cache_key);
-      
-      if (statement_info && statement_info.statement) {
-        // 使用缓存的预处理语句
-        this._cache_hits++;
-        statement_info.last_used = Date.now();
-        statement_info.use_count++;
-        
-        // 预先检查连接状态，避免不必要的错误
-        if (!conn || conn._fatalError || conn._closed) {
-          conn = await this.getConn();
-          // 连接已更新，需要重新创建预处理语句
-          this._prepared_stmts.delete(cache_key);
-          const statement = await conn.prepare(sql);
-          this._cacheStatement(cache_key, statement);
-          const [rows] = await statement.execute(params);
-          return rows;
-        }
-        
-        try {
-          const [rows] = await statement_info.statement.execute(params);
-          return rows;
-        } catch (stmt_err) {
-          // 预处理语句可能已失效（连接关闭等），重新创建
-          this.log('warn', '预处理语句执行失败，重新创建', stmt_err);
-          this._prepared_stmts.delete(cache_key);
-          
-          // 检查连接是否有效，如果无效则重新获取连接
-          if (!conn || conn._fatalError || conn._closed) {
-            conn = await this.getConn();
-          }
-          
-          // 重新创建预处理语句
-          const statement = await conn.prepare(sql);
-          this._cacheStatement(cache_key, statement);
-          
-          const [rows] = await statement.execute(params);
-          return rows;
-        }
-      } else {
-        // 创建新的预处理语句并缓存
-        this._cache_misses++;
-        const statement = await conn.prepare(sql);
-        this._cacheStatement(cache_key, statement);
-        
-        const [rows] = await statement.execute(params);
-        return rows;
-      }
-    } else {
-      // 不使用预处理语句缓存，直接查询
-      const [rows] = await conn.query(sql, params);
-      return rows;
-    }
+    this.sql = sql;
+    let [rows] = await conn.query(sql, params);
+    ret = rows;
   } catch (err) {
     this.sql = err.sql;
     this.error = {
       code: err.errno,
       message: err.sqlMessage
     };
-    // 在错误情况下也要确保连接释放
-    try {
-      await safeReleaseConn(conn, is_pool_conn);
-    } catch (release_err) {
-      this.log('error', '释放连接失败', release_err);
-    }
-    connection_released = true;
-    
-    // 重新抛出错误，让调用方处理
-    throw err;
-  } finally {
-    // 确保连接被释放，避免资源泄漏
-    if (!connection_released) {
-      try {
-        await safeReleaseConn(conn, is_pool_conn);
-      } catch (release_err) {
-        this.log('error', '释放连接失败', release_err);
-      }
-    }
   }
-  return [];
+  finally {
+    await releaseConn(conn);
+  }
+  return ret;
 };
 
 /**
@@ -463,71 +245,15 @@ Mysql.prototype.exec = async function (sql, params = []) {
     throw new TypeError('params must be array');
   }
   this.error = null;
+  this.sql = '';
   let conn = null;
-  let is_pool_conn = false;
-  let connection_released = false;
-
+  let ret = 0;
   try {
     // 获取连接
     conn = await this.getConn();
-    is_pool_conn = this._use_pool;
-
-    // 检查是否启用预处理语句缓存
-    if (this.config.enable_statement_pooling && params.length > 0) {
-      const cache_key = this._getStatementCacheKey(sql);
-      let statement_info = this._prepared_stmts.get(cache_key);
-      
-      if (statement_info && statement_info.statement) {
-        // 使用缓存的预处理语句
-        this._cache_hits++;
-        statement_info.last_used = Date.now();
-        statement_info.use_count++;
-        
-        // 预先检查连接状态，避免不必要的错误
-        if (!conn || conn._fatalError || conn._closed) {
-          conn = await this.getConn();
-          // 连接已更新，需要重新创建预处理语句
-          this._prepared_stmts.delete(cache_key);
-          const statement = await conn.prepare(sql);
-          this._cacheStatement(cache_key, statement);
-          const [result] = await statement.execute(params);
-          return result.insertId || result.affectedRows || result.changedRows || 1;
-        }
-        
-        try {
-          const [result] = await statement_info.statement.execute(params);
-          return result.insertId || result.affectedRows || result.changedRows || 1;
-        } catch (stmt_err) {
-          // 预处理语句可能已失效（连接关闭等），重新创建
-          this.log('warn', '预处理语句执行失败，重新创建', stmt_err);
-          this._prepared_stmts.delete(cache_key);
-          
-          // 检查连接是否有效，如果无效则重新获取连接
-          if (!conn || conn._fatalError || conn._closed) {
-            conn = await this.getConn();
-          }
-          
-          // 重新创建预处理语句
-          const statement = await conn.prepare(sql);
-          this._cacheStatement(cache_key, statement);
-          
-          const [result] = await statement.execute(params);
-          return result.insertId || result.affectedRows || result.changedRows || 1;
-        }
-      } else {
-        // 创建新的预处理语句并缓存
-        this._cache_misses++;
-        const statement = await conn.prepare(sql);
-        this._cacheStatement(cache_key, statement);
-        
-        const [result] = await statement.execute(params);
-        return result.insertId || result.affectedRows || result.changedRows || 1;
-      }
-    } else {
-        // 对于写入语句，直接执行（不使用预处理语句缓存）
-        const [result] = await conn.execute(sql, params);
-        return result.insertId || result.affectedRows || result.changedRows || 1;
-      }
+    this.sql = sql;
+    let [result] = await conn.execute(sql, params);
+    ret = result.insertId || result.affectedRows || result.changedRows || 1;
   } catch (error) {
     this.log('error', 'SQL执行失败', error);
     this.sql = error.sql;
@@ -535,27 +261,11 @@ Mysql.prototype.exec = async function (sql, params = []) {
       code: error.errno,
       message: error.sqlMessage
     };
-    // 在错误情况下也要确保连接释放
-    try {
-      await safeReleaseConn(conn, is_pool_conn);
-    } catch (release_err) {
-      this.log('error', '释放连接失败', release_err);
-    }
-    connection_released = true;
-    
-    // 重新抛出错误，让调用方处理
-    throw error;
-  } finally {
-    // 确保连接被释放，避免资源泄漏
-    if (!connection_released) {
-      try {
-        await safeReleaseConn(conn, is_pool_conn);
-      } catch (release_err) {
-        this.log('error', '释放连接失败', release_err);
-      }
-    }
   }
-  return 0;
+  finally {
+    await releaseConn(conn);
+  }
+  return ret;
 };
 
 /**
@@ -563,32 +273,32 @@ Mysql.prototype.exec = async function (sql, params = []) {
  * @returns {Promise<object>} 事务连接对象
  */
 Mysql.prototype.beginTransaction = async function () {
-  const conn = await this.getConn();
-  
+  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 this._releaseConn(conn);
+        await releaseConn(conn);
       },
       rollback: async () => {
         if (ended) return;
         await conn.rollback();
         ended = true;
-        await this._releaseConn(conn);
+        await releaseConn(conn);
       },
       _is_ended: () => ended
     };
   } catch (error) {
     // 如果事务开始失败，确保连接被释放
-    await this._releaseConn(conn);
+    await releaseConn(conn);
     this.log('error', '事务开始失败', error);
     throw error;
   }
@@ -605,16 +315,16 @@ Mysql.prototype.transaction = async function (callback) {
     throw new TypeError('callback must be function');
   }
 
-  const transaction = await this.beginTransaction();
-  
+  let transaction = await this.beginTransaction();
+
   try {
-    const result = await callback(transaction);
-    
+    let result = await callback(transaction);
+
     // 如果事务未结束，自动提交
     if (!transaction._is_ended()) {
       await transaction.commit();
     }
-    
+
     return result;
   } catch (error) {
     // 如果事务未结束，自动回滚
@@ -623,7 +333,7 @@ Mysql.prototype.transaction = async function (callback) {
         // 简化错误处理，避免频繁日志
       });
     }
-    
+
     throw error;
   }
 };
@@ -650,12 +360,12 @@ Mysql.prototype.read = async function (table, condition = {}, options = {}) {
 
   try {
     let sql = `SELECT * FROM ${table}`;
-    const params = [];
+    let params = [];
 
     // 处理条件
     if (Object.keys(condition).length > 0) {
-      const whereClauses = [];
-      for (const [field, value] of Object.entries(condition)) {
+      let whereClauses = [];
+      for (let [field, value] of Object.entries(condition)) {
         whereClauses.push(`${field} = ?`);
         params.push(value);
       }
@@ -715,7 +425,7 @@ Mysql.prototype.healthCheck = async function () {
     }
 
     // 执行简单的查询来检查连接状态
-    const result = await this.run('SELECT 1 as health_check');
+    let result = await this.run('SELECT 1 as health_check');
 
     if (result && result.length > 0 && result[0].health_check === 1) {
       return {
@@ -787,7 +497,7 @@ function _acquireLock(key) {
   }
 
   let release;
-  const lockPromise = $.pool.mysql._locks[key].then(() => {
+  let lockPromise = $.pool.mysql._locks[key].then(() => {
     return new Promise(resolve => {
       release = resolve;
     });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mm_mysql",
-	"version": "2.3.8",
+	"version": "2.4.0",
 	"description": "这是超级美眉mysql帮助函数模块，用于便捷操作mysql，使用await方式，可以避免嵌套函数",
 	"main": "index.js",
 	"dependencies": {