mm_mysql 2.3.1 → 2.3.3

package/index.js

@@ -13,6 +13,7 @@ class Mysql extends Base {
    * 默认配置（优化版，统一使用连接池）
    */
   static config = {
+    name: 'default',
     host: '127.0.0.1',
     port: 3306,
     user: 'root',
@@ -41,7 +42,7 @@ class Mysql extends Base {
    * @param {object} config - 配置对象
    */
   constructor(config = {}) {
-    super({ ...Mysql.config, ...config});
+    super(config);
     this._pool = null;
     // 移除单连接支持，统一使用连接池
     this._use_pool = true; // 强制使用连接池模式
@@ -285,7 +286,7 @@ Mysql.prototype._getValidConfig = function (is_pool = false) {
  * @param {boolean} is_pool_conn - 是否为连接池连接
  * @returns {Promise<void>}
  */
-async function safeReleaseConnection(conn, is_pool_conn) {
+async function safeReleaseConn(conn, is_pool_conn) {
   if (!conn) return;
 
   try {
@@ -297,6 +298,23 @@ async function safeReleaseConnection(conn, is_pool_conn) {
   }
 };
 
+/**
+ * 释放连接（实例方法，简化事务使用）
+ * @param {object} conn - 数据库连接对象
+ * @returns {Promise<void>}
+ */
+Mysql.prototype._releaseConn = async function(conn) {
+  if (!conn) return;
+  
+  try {
+    if (this._use_pool && typeof conn.release === 'function') {
+      await conn.release();
+    }
+  } catch (error) {
+    // 简化错误处理，避免频繁日志
+  }
+};
+
 /**
    * 获取数据库连接（统一使用连接池）
    * @returns {Promise<object>}
@@ -408,7 +426,7 @@ Mysql.prototype.run = async function (sql, params = []) {
     };
     // 在错误情况下也要确保连接释放
     try {
-      await safeReleaseConnection(conn, is_pool_conn);
+      await safeReleaseConn(conn, is_pool_conn);
     } catch (release_err) {
       this.log('error', '释放连接失败', release_err);
     }
@@ -420,7 +438,7 @@ Mysql.prototype.run = async function (sql, params = []) {
     // 确保连接被释放，避免资源泄漏
     if (!connection_released) {
       try {
-        await safeReleaseConnection(conn, is_pool_conn);
+        await safeReleaseConn(conn, is_pool_conn);
       } catch (release_err) {
         this.log('error', '释放连接失败', release_err);
       }
@@ -519,7 +537,7 @@ Mysql.prototype.exec = async function (sql, params = []) {
     };
     // 在错误情况下也要确保连接释放
     try {
-      await safeReleaseConnection(conn, is_pool_conn);
+      await safeReleaseConn(conn, is_pool_conn);
     } catch (release_err) {
       this.log('error', '释放连接失败', release_err);
     }
@@ -531,7 +549,7 @@ Mysql.prototype.exec = async function (sql, params = []) {
     // 确保连接被释放，避免资源泄漏
     if (!connection_released) {
       try {
-        await safeReleaseConnection(conn, is_pool_conn);
+        await safeReleaseConn(conn, is_pool_conn);
       } catch (release_err) {
         this.log('error', '释放连接失败', release_err);
       }
@@ -541,98 +559,72 @@ Mysql.prototype.exec = async function (sql, params = []) {
 };
 
 /**
- * 开始事务（改进版）
+ * 开始事务（优化版）
  * @returns {Promise<object>} 事务连接对象
  */
 Mysql.prototype.beginTransaction = async function () {
-  let conn = null;
-  let transaction_committed = false;
-  let transaction_rolled_back = false;
-
+  const conn = await this.getConn();
+  
   try {
-    conn = await this.getConn();
     await conn.beginTransaction();
-
+    
+    let ended = false;
+    
     return {
       connection: conn,
       commit: async () => {
-        if (transaction_committed || transaction_rolled_back) {
-          this.log('warn', '事务已结束，无需重复提交');
-          return;
-        }
+        if (ended) return;
         await conn.commit();
-        transaction_committed = true;
-        try {
-          await safeReleaseConnection(conn, this._usePool);
-        } catch (release_err) {
-          this.log('error', '提交时释放连接失败', release_err);
-        }
+        ended = true;
+        await this._releaseConn(conn);
       },
       rollback: async () => {
-        if (transaction_committed || transaction_rolled_back) {
-          this.log('warn', '事务已结束，无需重复回滚');
-          return;
-        }
+        if (ended) return;
         await conn.rollback();
-        transaction_rolled_back = true;
-        try {
-          await safeReleaseConnection(conn, this._usePool);
-        } catch (release_err) {
-          this.log('error', '回滚时释放连接失败', release_err);
-        }
+        ended = true;
+        await this._releaseConn(conn);
       },
-      _is_ended: () => transaction_committed || transaction_rolled_back
+      _is_ended: () => ended
     };
   } catch (error) {
     // 如果事务开始失败，确保连接被释放
-    try {
-      await safeReleaseConnection(conn, this._usePool);
-    } catch (release_err) {
-      this.log('error', '释放连接失败', release_err);
-    }
+    await this._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 = null;
-  let transaction_executed = false;
-
+  const transaction = await this.beginTransaction();
+  
   try {
-    transaction = await this.beginTransaction();
     const result = await callback(transaction);
-
-    // 检查事务是否已由用户手动提交/回滚
-    if (transaction._is_ended && !transaction._is_ended()) {
+    
+    // 如果事务未结束，自动提交
+    if (!transaction._is_ended()) {
       await transaction.commit();
     }
-
-    transaction_executed = true;
+    
     return result;
   } catch (error) {
-    if (transaction && !transaction_executed) {
-      // 只有在事务未成功执行的情况下才回滚
-      if (transaction._is_ended && !transaction._is_ended()) {
-        await transaction.rollback().catch(err => {
-          this.log('error', '事务回滚失败', err);
-        });
-      }
+    // 如果事务未结束，自动回滚
+    if (!transaction._is_ended()) {
+      await transaction.rollback().catch(() => {
+        // 简化错误处理，避免频繁日志
+      });
     }
-
-    this.log('error', '事务执行失败', error);
-    throw error; // 重新抛出错误，让调用方知道事务失败
+    
+    throw error;
   }
 };
 

package/package.json

@@ -1,11 +1,12 @@
 {
 	"name": "mm_mysql",
-	"version": "2.3.1",
+	"version": "2.3.3",
 	"description": "这是超级美眉mysql帮助函数模块，用于便捷操作mysql，使用await方式，可以避免嵌套函数",
 	"main": "index.js",
 	"dependencies": {
-		"mm_expand": "^2.0.0",
-		"mysql2": "^3.16.0"
+		"mm_expand": "^2.0.2",
+		"mysql2": "^3.20.0",
+		"sqlstring": "^2.3.3"
 	},
 	"scripts": {
 		"start": "node index.js",
@@ -35,8 +36,8 @@
 		"node": ">=12.0.0"
 	},
 	"devDependencies": {
-		"eslint": "^9.39.2",
-		"eslint-plugin-jsdoc": "^61.5.0",
-		"mm_eslint": "^1.1.1"
+		"eslint": "^10.1.0",
+		"eslint-plugin-jsdoc": "^62.9.0",
+		"mm_eslint": "^1.7.1"
 	}
-}
+}

package/sql.js

@@ -19,6 +19,48 @@ function escapeId(value, forbidQualified) {
  * @property {Function} filter 设置并过滤参数
  */
 class Sql extends Base {
+  /**
+   * 过滤查询参数字典
+   */
+  static config = {
+    /**
+     * 分隔符 用于查询时的多条件处理
+     */
+    'separator': '|',
+    /**
+     * 过滤
+     */
+    'filter': {
+      /**
+       * 表名
+       */
+      'table': 'table',
+      /**
+       * 查询的页码
+       */
+      'page': 'page',
+      /**
+       * 查询每页条数
+       */
+      'size': 'size',
+      /**
+       * 操作方式: 传入参数method=add, 支持参数 add增、del删、set改、get查，为空则为get
+       */
+      'method': 'method',
+      /**
+       * 排序
+       */
+      'orderby': 'orderby',
+      /**
+       * 查询显示的字段
+       */
+      'field': 'field',
+      /**
+       * 统计结果: 统计符合条件的结果数，只有当page等于1或0时才会统计
+       */
+      'count_ret': 'count_ret'
+    }
+  };
   /**
    * 数据库管理器
    * @param {Function} run 查询函数
@@ -102,49 +144,6 @@ class Sql extends Base {
      */
     this.count_ret = 'false';
 
-    /**
-     * 过滤查询参数字典
-     */
-    this.config = {
-      /**
-       * 分隔符 用于查询时的多条件处理
-       */
-      'separator': '|',
-      /**
-       * 过滤
-       */
-      'filter': {
-        /**
-         * 表名
-         */
-        'table': 'table',
-        /**
-         * 查询的页码
-         */
-        'page': 'page',
-        /**
-         * 查询每页条数
-         */
-        'size': 'size',
-        /**
-         * 操作方式: 传入参数method=add, 支持参数 add增、del删、set改、get查，为空则为get
-         */
-        'method': 'method',
-        /**
-         * 排序
-         */
-        'orderby': 'orderby',
-        /**
-         * 查询显示的字段
-         */
-        'field': 'field',
-        /**
-         * 统计结果: 统计符合条件的结果数，只有当page等于1或0时才会统计
-         */
-        'count_ret': 'count_ret'
-      }
-    };
-
     this.like = false;
   }
 }
@@ -189,17 +188,19 @@ Sql.prototype.filter = function (query) {
  * @returns {string} 返回查询条件语句
  */
 Sql.prototype.toQuery = function (where, sort, view) {
-  var sql = 'SELECT {1} FROM `{0}`';
   if (!view) {
     view = '*';
   }
+
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `SELECT ${view} FROM \`${this.table}\``;
+
   if (where) {
     sql += ' WHERE ' + where;
   }
   if (sort) {
     sql += ' ORDER BY ' + sort.replace(/;/, '');
   }
-  sql = sql.replace('{0}', this.table).replace('{1}', view);
   if (this.size && this.page) {
     var start = this.size * (this.page - 1);
     sql += ' limit ' + start + ',' + this.size;
@@ -214,8 +215,8 @@ Sql.prototype.toQuery = function (where, sort, view) {
  * @returns {Promise | object} 执行结果
  */
 Sql.prototype.addSql = function (key, val) {
-  var sql = 'INSERT INTO `{0}` ({1}) VALUES ({2});';
-  sql = sql.replace('{0}', this.table).replace('{1}', key).replace('{2}', val);
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `INSERT INTO \`${this.table}\` (${key}) VALUES (${val});`;
   return this.exec(sql);
 };
 /**
@@ -224,8 +225,8 @@ Sql.prototype.addSql = function (key, val) {
  * @returns {Promise | object} 执行结果
  */
 Sql.prototype.delSql = function (where) {
-  var sql = 'DELETE FROM `{0}` WHERE {1};';
-  sql = sql.replace('{0}', this.table).replace('{1}', where);
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
   return this.exec(sql);
 };
 /**
@@ -235,10 +236,11 @@ Sql.prototype.delSql = function (where) {
  * @returns {Promise | object} 执行结果
  */
 Sql.prototype.setSql = function (where, set) {
-  var sql = 'UPDATE `{0}` SET {1} WHERE {2};';
-  sql = sql.replace('{0}', this.table).replace('{1}', set).replace('{2}', where);
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
   return this.exec(sql);
 };
+
 /**
  * 查询数据
  * @param {string} where 查询条件
@@ -295,7 +297,7 @@ Sql.prototype.getCountSql = async function (where, sort, view) {
  * @param {string} groupby 分组的字段
  * @param {string} view 返回的字段
  * @param {string} sort 排序方式
- * @param method
+ * @param {string} method 统计方法
  * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupMathSql = async function (where, groupby, view, sort, method) {
@@ -310,7 +312,7 @@ Sql.prototype.groupMathSql = async function (where, groupby, view, sort, method)
     }
   } else {
     view_str = ',' + method.toUpperCase() + '(' + escapeId(view_val) + ') ' + method.toLowerCase() + '_' +
-			view_val.replace(/`/g, '');
+      view_val.replace(/`/g, '');
   }
   var sql = 'SELECT ' + (groupby ? escapeId(groupby) : '') + view_str + ' FROM `' + this.table + '`';
   if (where) {
@@ -439,9 +441,7 @@ Sql.prototype._buildLikeWhere = function (obj) {
   var where = '';
   for (var k in obj) {
     var val = obj[k];
-    if (val && typeof (val) === 'string') {
-      val = val.trim("'");
-    }
+    // 先转义再处理字符串，避免转义字符被错误处理
     val = escape(val);
     if (k.endsWith('_min')) {
       where += ' and ' + escapeId(k.replace('_min', '')) + ' >= ' + val;
@@ -451,7 +451,7 @@ Sql.prototype._buildLikeWhere = function (obj) {
       where += ' and ' + escapeId(k.replace('_not', '')) + ' != ' + val;
     } else if (k.endsWith('_has')) {
       var vals = val.trim("'").split(',').map((o) => {
-        return "'" + o + "'";
+        return escape(o);
       });
       where += ' and ' + escapeId(k.replace('_has', '')) + ' in (' + vals.join(',') + ')';
     } else if (k.endsWith('_like')) {
@@ -469,9 +469,7 @@ Sql.prototype._buildExactWhere = function (obj) {
   var where = '';
   for (var k in obj) {
     var val = obj[k];
-    if (val && typeof (val) === 'string') {
-      val = val.trim("'");
-    }
+    // 先转义再处理字符串，避免转义字符被错误处理
     val = escape(val);
     if (k.endsWith('_min')) {
       where += ' and ' + escapeId(k.replace('_min', '')) + ' >= ' + val;
@@ -481,7 +479,7 @@ Sql.prototype._buildExactWhere = function (obj) {
       where += ' and ' + escapeId(k.replace('_not', '')) + ' != ' + val;
     } else if (k.endsWith('_has')) {
       var vals = val.trim("'").split(',').map((o) => {
-        return "'" + o + "'";
+        return escape(o);
       });
       where += ' and ' + escapeId(k.replace('_has', '')) + ' in (' + vals.join(',') + ')';
     } else if (k.endsWith('_like')) {
@@ -501,14 +499,11 @@ Sql.prototype._buildExactWhere = function (obj) {
 Sql.prototype.toSet = function (obj) {
   var set = '';
   for (const k in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, k)) continue;
 
     let val = obj[k];
     if (val === undefined || val === null) continue;
 
-    if (typeof val === 'string') {
-      val = val.trim("'");
-    }
+    // 先转义再处理字符串，避免转义字符被错误处理
     val = escape(val);
 
     if (k.endsWith('_add')) {
@@ -539,20 +534,12 @@ Sql.prototype.toAddSql = function (item) {
   let value = '';
 
   for (const k in item) {
-    if (!Object.prototype.hasOwnProperty.call(item, k)) continue;
-
     key += ',' + escapeId(k);
-    let val = item[k];
-    if (typeof val === 'string') {
-      val = val.trim("'");
-    }
-    value += ',' + escape(val);
+    value += ',' + escape(item[k]);
   }
 
-  const sql = 'INSERT INTO `{0}` ({1}) VALUES ({2});'
-    .replace('{0}', this.table)
-    .replace('{1}', key.replace(',', ''))
-    .replace('{2}', value.replace(',', ''));
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `INSERT INTO \`${this.table}\` (${key.replace(',', '')}) VALUES (${value.replace(',', '')});`;
 
   return sql;
 };
@@ -568,9 +555,10 @@ Sql.prototype.toDelSql = function (query, like) {
     throw new Error('表名未设置');
   }
   const where = this.toWhere(query, like);
-  const sql = 'DELETE FROM `{0}` WHERE {1};'
-    .replace('{0}', this.table)
-    .replace('{1}', where);
+
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
+
   return sql;
 };
 
@@ -587,10 +575,10 @@ Sql.prototype.toSetSql = function (query, item, like) {
   }
   const where = this.toWhere(query, like);
   const set = this.toSet(item);
-  const sql = 'UPDATE `{0}` SET {1} WHERE {2};'
-    .replace('{0}', this.table)
-    .replace('{1}', set)
-    .replace('{2}', where);
+
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
+
   return sql;
 };
 
@@ -735,13 +723,8 @@ Sql.prototype._parseSetData = async function (set) {
     }
   } else {
     for (const k in set) {
-      if (!Object.prototype.hasOwnProperty.call(set, k)) continue;
-
       key_str += ',' + escapeId(k);
       let val = set[k];
-      if (typeof val === 'string') {
-        val = val.trim("'");
-      }
       val_str += ',' + escape(val);
     }
   }
@@ -758,10 +741,10 @@ Sql.prototype._parseSetData = async function (set) {
  * @param {string} sort 排序
  * @param {string} view 返回的字段
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @param {number} timeout 超时时间（毫秒），默认20000ms
  * @returns {Promise|Array} 查询结果
  */
-Sql.prototype.get = async function (query, sort, view, like, timeout = 60000) {
+Sql.prototype.get = async function (query, sort, view, like, timeout = 20000) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
@@ -793,10 +776,10 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 60000) {
  * @param {string} sort 排序
  * @param {string} view 返回的字段
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @param {number} timeout 超时时间（毫秒），默认20000ms
  * @returns {Promise | object | null} 查询结果
  */
-Sql.prototype.getObj = async function (query, sort, view, like, timeout = 60000) {
+Sql.prototype.getObj = async function (query, sort, view, like, timeout = 20000) {
   try {
     // 保存当前分页设置
     const old_page = this.page;
@@ -833,10 +816,10 @@ Sql.prototype.getObj = async function (query, sort, view, like, timeout = 60000)
  * 统计记录数
  * @param {object} query 查询条件
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @param {number} timeout 超时时间（毫秒），默认20000ms
  * @returns {Promise | number} 记录数
  */
-Sql.prototype.count = async function (query, like, timeout = 60000) {
+Sql.prototype.count = async function (query, like, timeout = 20000) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
@@ -964,9 +947,7 @@ Sql.prototype.toBatchAddSql = function (list) {
 Sql.prototype._getKeys = function (obj) {
   const keys = [];
   for (const k in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, k)) {
-      keys.push(this.escapeId(k));
-    }
+    keys.push(this.escapeId(k));
   }
   return keys;
 };
@@ -978,9 +959,6 @@ Sql.prototype._buildValueList = function (list, keys) {
     for (const k of keys) {
       const key = k.replace(/`/g, '');
       let val = item[key];
-      if (typeof val === 'string') {
-        val = val.trim("'");
-      }
       values.push(this.escape(val));
     }
     val_list.push(`(${values.join(',')})`);
@@ -1138,7 +1116,6 @@ Sql.prototype.has = function (param_dt, sql_dt) {
     return false;
   }
   for (const key in sql_dt) {
-    if (!Object.prototype.hasOwnProperty.call(sql_dt, key)) continue;
     const value = param_dt[key];
     if (value !== undefined && value !== null && value !== '') {
       return true;
@@ -1158,7 +1135,6 @@ Sql.prototype.not = function (param_dt, sql_dt) {
     return undefined;
   }
   for (const key in param_dt) {
-    if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
     if (!sql_dt[key]) {
       return key;
     }
@@ -1178,7 +1154,6 @@ Sql.prototype.filterParams = function (param_dt, sql_dt) {
     return dt;
   }
   for (const key in param_dt) {
-    if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
     if (!sql_dt[key]) {
       dt[key] = param_dt[key];
     }
@@ -1196,8 +1171,6 @@ Sql.prototype.filterParams = function (param_dt, sql_dt) {
 Sql.prototype._tplQueryWithSep = function (param_dt, sql_dt, l) {
   const conds = [];
   for (const key in param_dt) {
-    if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
-
     let value = String(param_dt[key]);
     const arr = value.split(l);
     const tpl = sql_dt[key];
@@ -1206,13 +1179,13 @@ Sql.prototype._tplQueryWithSep = function (param_dt, sql_dt, l) {
       if (arr.length > 1) {
         const sub_conds = [];
         for (const val of arr) {
-          const clean_val = typeof val === 'string' ? val.trim("'") : val;
-          sub_conds.push(tpl.replaceAll('{0}', escape(clean_val).trim("'")));
+          // 使用直接替换方式，避免模板替换错误
+          sub_conds.push(tpl.replaceAll('{0}', escape(val).trim("'")));
         }
         conds.push('(' + sub_conds.join(' || ') + ')');
       } else {
-        const clean_val = typeof value === 'string' ? value.trim("'") : value;
-        conds.push(tpl.replaceAll('{0}', escape(clean_val).trim("'")));
+        // 使用直接替换方式，避免模板替换错误
+        conds.push(tpl.replaceAll('{0}', escape(value).trim("'")));
       }
     } else {
       if (arr.length > 1) {
@@ -1222,8 +1195,7 @@ Sql.prototype._tplQueryWithSep = function (param_dt, sql_dt, l) {
         }
         conds.push('(' + sub_conds.join(' || ') + ')');
       } else {
-        const clean_val = typeof value === 'string' ? value.trim("'") : value;
-        conds.push(escapeId(key) + ' = ' + escape(clean_val));
+        conds.push(escapeId(key) + ' = ' + escape(value));
       }
     }
   }
@@ -1239,13 +1211,9 @@ Sql.prototype._tplQueryWithSep = function (param_dt, sql_dt, l) {
 Sql.prototype._tplQueryNoSep = function (param_dt, sql_dt) {
   const conds = [];
   for (const key in param_dt) {
-    if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
-    let value = param_dt[key];
-    if (typeof value === 'string') {
-      value = value.trim("'");
-    }
-    value = escape(value);
+    value = escape(param_dt[key]);
     if (sql_dt[key]) {
+      // 使用直接替换方式，避免模板替换错误
       conds.push(sql_dt[key].replaceAll('{0}', value.trim("'")));
     } else {
       conds.push(escapeId(key) + ' = ' + value);
@@ -1263,7 +1231,6 @@ Sql.prototype._tplQueryNoSep = function (param_dt, sql_dt) {
 Sql.prototype._noTplQueryWithSep = function (param_dt, l) {
   const conds = [];
   for (const key in param_dt) {
-    if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
     const value = param_dt[key];
     const arr = String(value).split(l);
     if (arr.length > 1) {
@@ -1287,7 +1254,6 @@ Sql.prototype._noTplQueryWithSep = function (param_dt, l) {
 Sql.prototype._noTplQueryNoSep = function (param_dt) {
   const conds = [];
   for (const key in param_dt) {
-    if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
     conds.push(escapeId(key) + ' = ' + escape(param_dt[key]));
   }
   return conds.join(' && ');
@@ -1334,15 +1300,15 @@ Sql.prototype.tplBody = function (param_dt, sql_dt) {
   const parts = [];
   if (!sql_dt || Object.keys(sql_dt).length === 0) {
     for (const key in param_dt) {
-      if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
       parts.push(' ' + escapeId(key) + ' = ' + escape(param_dt[key]));
     }
   } else {
     for (const key in param_dt) {
-      if (!Object.prototype.hasOwnProperty.call(param_dt, key)) continue;
-      const value = escape(param_dt[key]);
+      let value = escape(param_dt[key]);
       if (sql_dt[key]) {
-        parts.push(' ' + sql_dt[key].replace('{0}', value).replace(/\+ -/g, '- ').replace(/- -/g, '+ '));
+        // 使用直接替换方式，避免模板替换错误
+        const replaced = sql_dt[key].replaceAll('{0}', value.trim("'"));
+        parts.push(' ' + replaced.replace(/\+ -/g, '- ').replace(/- -/g, '+ '));
       } else {
         parts.push(' ' + escapeId(key) + ' = ' + value);
       }
@@ -1632,7 +1598,7 @@ Sql.prototype.model = function (model) {
           });
         }
       }
-      const new_obj = { ...obj};
+      const new_obj = { ...obj };
       new_obj[prop] = value;
       return true;
     }
@@ -1671,12 +1637,12 @@ Sql.prototype.addOrSet = async function (where, set, like) {
  * @returns {Promise<string>} 创建表的 SQL 语句
  * @private
  */
-Sql.prototype._getCreateTableSql = async function() {
+Sql.prototype._getCreateTableSql = async function () {
   try {
     // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
     const sql = `SHOW CREATE TABLE \`${this.table}\``;
     const result = await this.run(sql);
-    
+
     if (result && result.length > 0 && result[0]['Create Table']) {
       // 在创建表语句中添加 IF NOT EXISTS 条件
       let create_sql = result[0]['Create Table'];
@@ -1685,7 +1651,7 @@ Sql.prototype._getCreateTableSql = async function() {
       }
       return create_sql + ';';
     }
-    
+
     return '';
   } catch (err) {
     this.log('warn', '获取表结构失败，将仅备份数据', err);
@@ -1698,10 +1664,10 @@ Sql.prototype._getCreateTableSql = async function() {
  * @returns {Promise<string>} 注释信息 SQL 语句
  * @private
  */
-Sql.prototype._getTableComments = async function() {
+Sql.prototype._getTableComments = async function () {
   try {
     let commentSql = '';
-    
+
     // 获取表注释
     const tableCommentSql = `
       SELECT TABLE_COMMENT 
@@ -1710,14 +1676,14 @@ Sql.prototype._getTableComments = async function() {
         AND TABLE_NAME = '${this.table}'
     `;
     const tableCommentResult = await this.run(tableCommentSql);
-    
+
     if (tableCommentResult && tableCommentResult.length > 0 && tableCommentResult[0].TABLE_COMMENT) {
       const tableComment = tableCommentResult[0].TABLE_COMMENT;
       if (tableComment && tableComment.trim() !== '') {
         commentSql += `\n-- 表注释: ${tableComment}\n`;
       }
     }
-    
+
     // 获取列注释
     const columnCommentSql = `
       SELECT COLUMN_NAME, COLUMN_COMMENT
@@ -1729,14 +1695,14 @@ Sql.prototype._getTableComments = async function() {
       ORDER BY ORDINAL_POSITION
     `;
     const columnCommentResult = await this.run(columnCommentSql);
-    
+
     if (columnCommentResult && columnCommentResult.length > 0) {
       commentSql += '\n-- 列注释:\n';
       for (const column of columnCommentResult) {
         commentSql += `-- ${column.COLUMN_NAME}: ${column.COLUMN_COMMENT}\n`;
       }
     }
-    
+
     return commentSql;
   } catch (err) {
     this.log('warn', '获取表注释信息失败，将仅备份表结构', err);
@@ -1750,7 +1716,7 @@ Sql.prototype._getTableComments = async function() {
  * @param {boolean} create 是否导出创建表语句，默认为false
  * @returns {Promise<boolean>} 备份是否成功
  */
-Sql.prototype.backup = async function(file, create = false) {
+Sql.prototype.backup = async function (file, create = false) {
   if (!file || typeof file !== 'string') {
     throw new TypeError('文件路径必须为字符串');
   }
@@ -1762,24 +1728,24 @@ Sql.prototype.backup = async function(file, create = false) {
   try {
     // 获取所有数据
     const data = await this.getSql('', '', '*');
-    
+
     if (!data || !Array.isArray(data)) {
       throw new Error('获取数据失败');
     }
 
     // 构建 SQL 语句
     let sqlContent = '';
-    
+
     // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
     sqlContent += `-- 备份表: ${this.table}\n`;
     sqlContent += `-- 备份时间: ${new Date().toISOString()}\n\n`;
-    
+
     // 如果create为true，添加创建表语句
     if (create) {
       const createTableSql = await this._getCreateTableSql();
       if (createTableSql) {
         sqlContent += createTableSql + '\n\n';
-        
+
         // 添加表注释信息
         const commentSql = await this._getTableComments();
         if (commentSql) {
@@ -1787,7 +1753,7 @@ Sql.prototype.backup = async function(file, create = false) {
         }
       }
     }
-    
+
     // 添加数据插入语句
     for (const row of data) {
       const keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
@@ -1798,15 +1764,15 @@ Sql.prototype.backup = async function(file, create = false) {
     // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
     const fs = require('fs');
     const path = require('path');
-    
+
     // 确保目录存在
     const dir = path.dirname(file);
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
     }
-    
+
     fs.writeFileSync(file, sql_content, 'utf8');
-    
+
     return true;
   } catch (err) {
     this.error = err.message;
@@ -1820,7 +1786,7 @@ Sql.prototype.backup = async function(file, create = false) {
  * @param {string} file 备份文件路径
  * @returns {Promise<boolean>} 恢复是否成功
  */
-Sql.prototype.restore = async function(file) {
+Sql.prototype.restore = async function (file) {
   if (!file || typeof file !== 'string') {
     throw new TypeError('文件路径必须为字符串');
   }
@@ -1831,24 +1797,24 @@ Sql.prototype.restore = async function(file) {
 
   try {
     const fs = require('fs');
-    
+
     if (!fs.existsSync(file)) {
       throw new Error('备份文件不存在');
     }
 
     // 读取 SQL 文件
     const sqlContent = fs.readFileSync(file, 'utf8');
-    
+
     // 解析 SQL 语句
     const statements = this._parseSqlStatements(sqlContent);
-    
+
     // 执行每个 SQL 语句
     for (const stmt of statements) {
       if (stmt.trim() && !stmt.startsWith('--')) {
         await this.exec(stmt);
       }
     }
-    
+
     return true;
   } catch (err) {
     this.error = err.message;
@@ -1863,7 +1829,7 @@ Sql.prototype.restore = async function(file) {
  * @returns {string[]} SQL 语句数组
  * @private
  */
-Sql.prototype._parseSqlStatements = function(sql) {
+Sql.prototype._parseSqlStatements = function (sql) {
   const stmts = [];
   let cur_stmt = '';
   let in_str = false;
@@ -1891,7 +1857,7 @@ Sql.prototype._parseSqlStatements = function(sql) {
       i++; // 跳过第二个'-'
       continue;
     }
-    
+
     if (in_cmt && char === '\n') {
       in_cmt = false;
       continue;
@@ -1941,7 +1907,7 @@ Sql.prototype._parseSqlStatements = function(sql) {
  * @param {boolean} create 是否导出创建表语句，默认为false
  * @returns {Promise<boolean>} 备份是否成功
  */
-Sql.prototype.backup = async function(file, create = false) {
+Sql.prototype.backup = async function (file, create = false) {
   if (!file || typeof file !== 'string') {
     throw new TypeError('文件路径必须为字符串');
   }
@@ -1953,18 +1919,18 @@ Sql.prototype.backup = async function(file, create = false) {
   try {
     // 获取所有数据
     const data = await this.getSql('', '', '*');
-    
+
     if (!data || !Array.isArray(data)) {
       throw new Error('获取数据失败');
     }
 
     // 构建 SQL 语句
     let sql_content = '';
-    
+
     // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
     sql_content += `-- 备份表: ${this.table}\n`;
     sql_content += `-- 备份时间: ${new Date().toISOString()}\n\n`;
-    
+
     // 如果create为true，添加创建表语句
     if (create) {
       const create_table_sql = await this._getCreateTableSql();
@@ -1972,7 +1938,7 @@ Sql.prototype.backup = async function(file, create = false) {
         sql_content += create_table_sql + '\n\n';
       }
     }
-    
+
     // 添加数据插入语句
     for (const row of data) {
       const keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
@@ -1983,15 +1949,15 @@ Sql.prototype.backup = async function(file, create = false) {
     // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
     const fs = require('fs');
     const path = require('path');
-    
+
     // 确保目录存在
     const dir = path.dirname(file);
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
     }
-    
+
     fs.writeFileSync(file, sql_content, 'utf8');
-    
+
     return true;
   } catch (err) {
     this.error = err.message;
@@ -2005,7 +1971,7 @@ Sql.prototype.backup = async function(file, create = false) {
  * @param {string} file 恢复文件路径
  * @returns {Promise<boolean>} 恢复是否成功
  */
-Sql.prototype.restore = async function(file) {
+Sql.prototype.restore = async function (file) {
   if (!file || typeof file !== 'string') {
     throw new TypeError('文件路径必须为字符串');
   }
@@ -2016,7 +1982,7 @@ Sql.prototype.restore = async function(file) {
 
   try {
     const fs = require('fs');
-    
+
     // 检查文件是否存在
     if (!fs.existsSync(file)) {
       throw new Error('备份文件不存在');
@@ -2024,14 +1990,14 @@ Sql.prototype.restore = async function(file) {
 
     // 读取文件内容
     const sql_content = fs.readFileSync(file, 'utf8');
-    
+
     if (!sql_content) {
       throw new Error('备份文件为空');
     }
 
     // 解析 SQL 语句
     const sql_stmts = this._parseSqlStatements(sql_content);
-    
+
     if (!sql_stmts || sql_stmts.length === 0) {
       throw new Error('未找到有效的 SQL 语句');
     }
@@ -2081,12 +2047,12 @@ Sql.prototype.restore = async function(file) {
  * @returns {Promise<string>} 创建表的 SQL 语句
  * @private
  */
-Sql.prototype._getCreateTableSql = async function() {
+Sql.prototype._getCreateTableSql = async function () {
   try {
     // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
     const sql = `SHOW CREATE TABLE \`${this.table}\``;
     const result = await this.run(sql);
-    
+
     if (result && result.length > 0 && result[0]['Create Table']) {
       // 在创建表语句中添加 IF NOT EXISTS 条件
       let create_sql = result[0]['Create Table'];
@@ -2095,7 +2061,7 @@ Sql.prototype._getCreateTableSql = async function() {
       }
       return create_sql + ';';
     }
-    
+
     return '';
   } catch (err) {
     this.log('warn', '获取表结构失败，将仅备份数据', err);

package/test.js

@@ -17,13 +17,15 @@ class TestMysql {
    * @param {object} config - 数据库配置
    */
   constructor(config) {
-    this.config = {host: '127.0.0.1',
+    this.config = {
+      host: '127.0.0.1',
       port: 3306,
       user: 'root',
       password: 'Asd159357',
       database: '', // 先不指定数据库，连接成功后再创建
       debug: true,
-      connection_limit: 5, ...config || {}};
+      ...config || {}
+    };
         
     this._mysql = null;
     this._test_results = [];
@@ -474,6 +476,81 @@ TestMysql.prototype.testTrans = async function() {
   }
 };
 
+/**
+ * 真实事务性能测试
+ * @returns {Promise<boolean>} 性能测试是否成功
+ */
+TestMysql.prototype.testRealTransaction = async function() {
+  try {
+    const start_time = Date.now();
+    
+    // 真实的事务操作测试
+    const result = await this._mysql.transaction(async (tx) => {
+      // 插入测试数据
+      const insert_sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
+      await tx.connection.execute(insert_sql, ['事务测试用户', 'trans_test@example.com', 25]);
+      
+      // 查询验证
+      const query_sql = `SELECT * FROM ${this._test_table_name} WHERE name = ?`;
+      const rows = await tx.connection.execute(query_sql, ['事务测试用户']);
+      
+      // 删除测试数据
+      const delete_sql = `DELETE FROM ${this._test_table_name} WHERE name = ?`;
+      await tx.connection.execute(delete_sql, ['事务测试用户']);
+      
+      return { count: rows.length };
+    });
+    
+    const duration = Date.now() - start_time;
+    this._recordResult('真实事务测试', true, `事务执行耗时: ${duration}ms`);
+    return true;
+  } catch (error) {
+    this._recordResult('真实事务测试', false, error.message);
+    return false;
+  }
+};
+
+/**
+ * 批量事务性能测试
+ * @returns {Promise<boolean>} 批量测试是否成功
+ */
+TestMysql.prototype.testBatchTransaction = async function() {
+  try {
+    const start_time = Date.now();
+    
+    // 批量插入测试
+    const result = await this._mysql.transaction(async (tx) => {
+      const insert_sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
+      
+      // 批量插入5条记录
+      for (let i = 0; i < 5; i++) {
+        await tx.connection.execute(insert_sql, [
+          `批量用户${i}`, 
+          `batch${i}@example.com`, 
+          20 + i
+        ]);
+      }
+      
+      // 验证插入结果
+      const count_sql = `SELECT COUNT(*) as count FROM ${this._test_table_name} WHERE name LIKE '批量用户%'`;
+      const count_result = await tx.connection.execute(count_sql);
+      
+      // 清理测试数据
+      const delete_sql = `DELETE FROM ${this._test_table_name} WHERE name LIKE '批量用户%'`;
+      await tx.connection.execute(delete_sql);
+      
+      return { inserted_count: count_result[0].count };
+    });
+    
+    const duration = Date.now() - start_time;
+    this._recordResult('批量事务测试', true, `批量事务执行耗时: ${duration}ms`);
+    return true;
+  } catch (error) {
+    this._recordResult('批量事务测试', false, error.message);
+    return false;
+  }
+};
+
 /**
  * 测试连接池功能
  * @returns {Promise<boolean>} 连接池测试是否成功
@@ -576,6 +653,8 @@ TestMysql.prototype.runAllTests = async function() {
     { name: '更新测试', method: 'testUpdate' },
     { name: '删除测试', method: 'testDelete' },
     { name: '事务测试', method: 'testTrans' },
+    { name: '真实事务测试', method: 'testRealTransaction' },
+    { name: '批量事务测试', method: 'testBatchTransaction' },
     { name: '连接池测试', method: 'testConnPool' },
     { name: '错误处理测试', method: 'testErrorHandling' }
   ];
@@ -691,7 +770,7 @@ if (require.main === module) {
     debug: process.env.DEBUG === 'true',
     connection_limit: parseInt(process.env.DB_CONNECTION_LIMIT) || 5
   };
-    
+
   console.log('使用配置:', {
     ...test_config,
     password: '***' // 隐藏密码