mm_mysql 2.2.4 → 2.2.6

package/sql.js

@@ -3,1555 +3,1669 @@
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.2
  */
-const {
-	escape,
-	escapeId
-} = require('mysql2');
+const SqlString = require('sqlstring');
 const { Base } = require('mm_expand');
 
+function escape(value, stringifyObjects, timeZone) {
+  return SqlString.escape(value, stringifyObjects, timeZone);
+}
+
+function escapeId(value, forbidQualified) {
+  return SqlString.escapeId(value, forbidQualified);
+}
+
 /**
  * @class 数据库语法通用类
  * @property {Function} filter 设置并过滤参数
  */
 class Sql extends Base {
-	/**
-	 * 数据库管理器
-	 * @param {Function} run 查询函数
-	 * @param {Function} exec 更改函数
-	 */
-	constructor(run, exec) {
-		super();
-		/**
-		 * 查询函数
-		 */
-		this.run = run;
-		/**
-		 * 更改函数 用于增删改
-		 */
-		this.exec = exec;
-		/**
-		 * 规避SQL注入函数
-		 * @param {Object} value 值
-		 * @return {String} 返回执行结果
-		 */
-		this.escape = function (value) {
-			return escape(value);
-		};
-
-		/**
-		 * 规避排序、SQL注入函数
-		 * @param {String} key 键
-		 * @return {String} 返回执行结果
-		 */
-		this.escapeId = function (key) {
-			return escapeId(key);
-		};
-
-		/**
-		 * sql语句
-		 */
-		this.sql = "";
-		/**
-		 * 错误提示
-		 */
-		this.error;
-		/**
-		 * 查询结果
-		 */
-		this.results = [];
-
-		/**
-		 * 表名
-		 */
-		this.table = "";
-		/**
-		 * 显示页
-		 */
-		this.page = 0;
-		/**
-		 * 显示条数
-		 */
-		this.size = 30;
-		/**
-		 * 请求方式 add、del、set、get、import、export等，跟函数名一致
-		 */
-		this.method = "";
-
-		/**
-		 * 显示的字段
-		 */
-		this.field = "";
-
-		/**
-		 * 排序方式
-		 */
-		this.orderby = "";
-
-		/**
-		 * 查询分组
-		 */
-		this.groupby = "";
-
-		/**
-		 * 是否统计查询结果数
-		 */
-		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;
-	}
+  /**
+   * 数据库管理器
+   * @param {Function} run 查询函数
+   * @param {Function} exec 更改函数
+   */
+  constructor(run, exec) {
+    super();
+    /**
+     * 查询函数
+     */
+    this.run = run;
+    /**
+     * 更改函数 用于增删改
+     */
+    this.exec = exec;
+    /**
+     * 规避SQL注入函数
+     * @param {object} value 值
+     * @returns {string} 返回执行结果
+     */
+    this.escape = function (value) {
+      return escape(value);
+    };
+
+    /**
+     * 规避排序、SQL注入函数
+     * @param {string} key 键
+     * @returns {string} 返回执行结果
+     */
+    this.escapeId = function (key) {
+      return escapeId(key);
+    };
+
+    /**
+     * sql语句
+     */
+    this.sql = '';
+    /**
+     * 错误提示
+     */
+    this.error;
+    /**
+     * 查询结果
+     */
+    this.results = [];
+
+    /**
+     * 表名
+     */
+    this.table = '';
+    /**
+     * 显示页
+     */
+    this.page = 0;
+    /**
+     * 显示条数
+     */
+    this.size = 30;
+    /**
+     * 请求方式 add、del、set、get、import、export等，跟函数名一致
+     */
+    this.method = '';
+
+    /**
+     * 显示的字段
+     */
+    this.field = '';
+
+    /**
+     * 排序方式
+     */
+    this.orderby = '';
+
+    /**
+     * 查询分组
+     */
+    this.groupby = '';
+
+    /**
+     * 是否统计查询结果数
+     */
+    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;
+  }
 }
 
 /**
  * 清理存储的数据
  */
 Sql.prototype.clear = function () {
-	// 不重置run和exec方法引用，保留构造函数中设置的函数
-	this.sql = "";
-	this.error = null;
-	this.results = [];
-	this.table = "";
-	this.page = 0;
-	this.size = 30;
-	this.method = "";
-	this.field = "";
-	this.orderby = "";
-	this.count_ret = "false";
+  // 不重置run和exec方法引用，保留构造函数中设置的函数
+  this.sql = '';
+  this.error = null;
+  this.results = [];
+  this.table = '';
+  this.page = 0;
+  this.size = 30;
+  this.method = '';
+  this.field = '';
+  this.orderby = '';
+  this.count_ret = 'false';
 };
 
 /**
  * 过滤查询参数
- * @param {Object} query 查询参数
+ * @param {object} query 查询参数
  */
 Sql.prototype.filter = function (query) {
-	var m = this.config.filter;
-	for (var k in m) {
-		var key = m[k];
-		if (query[key]) {
-			this[k] = query[key];
-			delete query[key];
-		}
-	}
+  var m = this.config.filter;
+  for (var k in m) {
+    var key = m[k];
+    if (query[key]) {
+      this[k] = query[key];
+      delete query[key];
+    }
+  }
 };
 
 /**
  * 查询条件拼接
- * @param {String} where 查询条件
- * @param {String} sort 排序
- * @param {String} view 返回的字段
- * @return {String} 返回查询条件语句
+ * @param {string} where 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @returns {string} 返回查询条件语句
  */
 Sql.prototype.toQuery = function (where, sort, view) {
-	var sql = "SELECT {1} FROM `{0}`";
-	if (!view) {
-		view = "*";
-	}
-	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;
-	}
-	return sql;
+  var sql = 'SELECT {1} FROM `{0}`';
+  if (!view) {
+    view = '*';
+  }
+  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;
+  }
+  return sql;
 };
 /* ===  传字符串参数  === */
 /**
  * 增加数据
- * @param {String} key 用作增加的键集合
- * @param {String} val 用作增加的值集合
- * @return {Promise|Object} 执行结果
+ * @param {string} key 用作增加的键集合
+ * @param {string} val 用作增加的值集合
+ * @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);
-	return this.exec(sql);
+  var sql = 'INSERT INTO `{0}` ({1}) VALUES ({2});';
+  sql = sql.replace('{0}', this.table).replace('{1}', key).replace('{2}', val);
+  return this.exec(sql);
 };
 /**
  * 删除数据
- * @param {String} where  删除条件
- * @return {Promise|Object} 执行结果
+ * @param {string} where  删除条件
+ * @returns {Promise | object} 执行结果
  */
 Sql.prototype.delSql = function (where) {
-	var sql = "DELETE FROM `{0}` WHERE {1};";
-	sql = sql.replace("{0}", this.table).replace("{1}", where);
-	return this.exec(sql);
+  var sql = 'DELETE FROM `{0}` WHERE {1};';
+  sql = sql.replace('{0}', this.table).replace('{1}', where);
+  return this.exec(sql);
 };
 /**
  * 修改数据
- * @param {String} where 查询条件
- * @param {String} set 修改的键值
- * @return {Promise|Object} 执行结果
+ * @param {string} where 查询条件
+ * @param {string} set 修改的键值
+ * @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);
-	return this.exec(sql);
+  var sql = 'UPDATE `{0}` SET {1} WHERE {2};';
+  sql = sql.replace('{0}', this.table).replace('{1}', set).replace('{2}', where);
+  return this.exec(sql);
 };
 /**
  * 查询数据
- * @param {String} where 查询条件
- * @param {String} sort 排序
- * @param {String} view 显示的字段
- * @return {Promise|Array} 查询结果数组
+ * @param {string} where 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 显示的字段
+ * @returns {Promise|Array} 查询结果数组
  */
 Sql.prototype.getSql = function (where, sort, view) {
-	var sql = this.toQuery(where, sort, view);
-	return this.run(sql);
+  var sql = this.toQuery(where, sort, view);
+  return this.run(sql);
 };
 
 /**
  * 查询符合结果总数
- * @param {String} where 查询条件
- * @return {Promise|Number} 返回结果总数
+ * @param {string} where 查询条件
+ * @returns {Promise | number} 返回结果总数
  */
 Sql.prototype.countSql = async function (where) {
-	var sql = "SELECT count(*) count FROM `" + this.table + "`";
-	if (where) {
-		sql += ' WHERE ' + where;
-	}
-	var n = 0;
-	var arr = await this.run(sql);
-	if (arr.length) {
-		n = arr[0].count;
-	}
-	return n;
+  var sql = 'SELECT count(*) count FROM `' + this.table + '`';
+  if (where) {
+    sql += ' WHERE ' + where;
+  }
+  var n = 0;
+  var arr = await this.run(sql);
+  if (arr.length) {
+    n = arr[0].count;
+  }
+  return n;
 };
 
 /**
  * 查询数据并返回符合条件总数
- * @param {String} where 查询条件
- * @param {String} sort 排序
- * @param {String} view 返回的字段
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {string} where 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.getCountSql = async function (where, sort, view) {
-	var list = [];
-	var count = await this.countSql(where);
-	if (count > 0) {
-		list = await this.getSql(where, sort, view);
-	}
-	var ret = {
-		list: list,
-		count: count
-	};
-	return ret;
+  var list = [];
+  var count = await this.countSql(where);
+  if (count > 0) {
+    list = await this.getSql(where, sort, view);
+  }
+  var ret = {
+    list: list,
+    count: count
+  };
+  return ret;
 };
 
 /**
  * 统计学
- * @param {String} where 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @param {String} sort 排序方式
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @param method
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupMathSql = async function (where, groupby, view, sort, method) {
-	if (!view) {
-		view = "*"
-	}
-	var viewStr = "";
-	if (view.indexOf(",") !== -1) {
-		var arr = view.split(",");
-		for (var i = 0; i < arr.length; i++) {
-			var str = escapeId(arr[i]);
-			viewStr += "," + method.toUpperCase() + "(" + str + ") " + method.toLowerCase() + "_" + str.replace(
-				/`/g, "")
-		}
-	} else {
-		viewStr = "," + method.toUpperCase() + "(" + escapeId(view) + ") " + method.toLowerCase() + "_" +
-			view.replace(/`/g, "")
-	}
-	var sql = "SELECT " + (groupby ? escapeId(groupby) : "") + viewStr + " FROM `" + this.table + "`";
-	if (where) {
-		sql += ' WHERE ' + where;
-	}
-	if (groupby) {
-		sql += " GROUP BY " + escapeId(groupby);
-	}
-	if (sort) {
-		sql += " ORDER BY " + sort;
-	}
-	if (this.size && this.page) {
-		var start = this.size * (this.page - 1);
-		sql += " limit " + start + "," + this.size;
-	}
-	return await this.run(sql);
-}
+  const view_val = view || '*';
+  var view_str = '';
+  if (view_val.indexOf(',') !== -1) {
+    var arr = view_val.split(',');
+    for (var i = 0; i < arr.length; i++) {
+      var str = escapeId(arr[i]);
+      view_str += ',' + method.toUpperCase() + '(' + str + ') ' + method.toLowerCase() + '_' + str.replace(
+        /`/g, '');
+    }
+  } else {
+    view_str = ',' + method.toUpperCase() + '(' + escapeId(view_val) + ') ' + method.toLowerCase() + '_' +
+			view_val.replace(/`/g, '');
+  }
+  var sql = 'SELECT ' + (groupby ? escapeId(groupby) : '') + view_str + ' FROM `' + this.table + '`';
+  if (where) {
+    sql += ' WHERE ' + where;
+  }
+  if (groupby) {
+    sql += ' GROUP BY ' + escapeId(groupby);
+  }
+  if (sort) {
+    sql += ' ORDER BY ' + sort;
+  }
+  if (this.size && this.page) {
+    var start = this.size * (this.page - 1);
+    sql += ' limit ' + start + ',' + this.size;
+  }
+  return await this.run(sql);
+};
 
 
 /**
  * 分组求平均值
- * @param {String} where 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @param {String} sort 排序方式
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupAvgSql = async function (where, groupby, view, sort) {
-	return await this.groupMathSql(where, groupby, view, sort, "AVG");
+  return await this.groupMathSql(where, groupby, view, sort, 'AVG');
 };
 
 /**
  * 分组合计数值
- * @param {String} where 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @param {String} sort 排序方式
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupSumSql = async function (where, groupby, view, sort) {
-	return await this.groupMathSql(where, groupby, view, sort, "SUM");
+  return await this.groupMathSql(where, groupby, view, sort, 'SUM');
 };
 
 /**
  * 分组合计不同条数
- * @param {String} where 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param sort
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupCountSql = async function (where, groupby, view, sort) {
-	return await this.groupMathSql(where, groupby, view, sort, "COUNT");
+  return await this.groupMathSql(where, groupby, view, sort, 'COUNT');
 };
 
 /**
  * 统计学
- * @param {Object} query 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @param {String} sort 排序方式
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @param method
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupMath = async function (query, groupby, view, sort, method, like) {
-	var where = this.toWhere(query, like);
-	return await this.groupMathSql(where, groupby, view, sort, method);
+  var where = this.toWhere(query, like);
+  return await this.groupMathSql(where, groupby, view, sort, method);
 };
 
 /**
  * 分组求平均值
- * @param {Object} query 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @param {String} sort 排序方式
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupAvg = async function (query, groupby, view, sort) {
-	return await this.groupMath(query, groupby, view, sort, "AVG");
+  return await this.groupMath(query, groupby, view, sort, 'AVG');
 };
 
 /**
  * 分组合计数值
- * @param {Object} query 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @param {String} sort 排序方式
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupSum = async function (query, groupby, view, sort) {
-	return await this.groupMath(query, groupby, view, sort, "SUM");
+  return await this.groupMath(query, groupby, view, sort, 'SUM');
 };
 
 /**
  * 分组合计不同条数
- * @param {Object} query 查询条件
- * @param {String} groupby 分组的字段
- * @param {String} view 返回的字段
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param sort
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupCount = async function (query, groupby, view, sort) {
-	return await this.groupMath(query, groupby, view, sort, "COUNT");
+  return await this.groupMath(query, groupby, view, sort, 'COUNT');
 };
 
 /* ===  sql语句拼接函数  === */
 /**
  * 转为where语句
- * @param {Object} obj 用作拼接的对象
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {String} where格式sql语句字符串
+ * @param {object} obj 用作拼接的对象
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {string} where格式sql语句字符串
  */
 Sql.prototype.toWhere = function (obj, like) {
-	var where = "";
-	if (like === undefined) {
-		like = this.like;
-	}
-	if (like) {
-		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;
-			} else if (k.endsWith('_max')) {
-				where += " and " + escapeId(k.replace('_max', "")) + " <= " + val;
-			} else if (k.endsWith('_not')) {
-				where += " and " + escapeId(k.replace('_not', "")) + " != " + val;
-			} else if (k.endsWith('_has')) {
-				var vals = val.trim("'").split(',').map((o) => {
-					return "'" + o + "'"
-				});
-				where += " and " + escapeId(k.replace('_has', "")) + " in (" + vals.join(',') + ")";
-			} else if (k.endsWith('_like')) {
-				where += " and " + escapeId(k.replace('_like', "")) + " LIKE '%" + val.trim("'") + "%'";
-			} else if (typeof (val) === "string" && !/^[0-9]+$/.test(val)) {
-				where += " and " + escapeId(k) + " LIKE '%" + val.trim("'") + "%'";
-			} else {
-				where += " and " + escapeId(k) + " = " + val;
-			}
-		}
-	} else {
-		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;
-			} else if (k.endsWith('_max')) {
-				where += " and " + escapeId(k.replace('_max', "")) + " <= " + val;
-			} else if (k.endsWith('_not')) {
-				where += " and " + escapeId(k.replace('_not', "")) + " != " + val;
-			} else if (k.endsWith('_has')) {
-				var vals = val.trim("'").split(',').map((o) => {
-					return "'" + o + "'"
-				});
-				where += " and " + escapeId(k.replace('_has', "")) + " in (" + vals.join(',') + ")";
-			} else if (k.endsWith('_like')) {
-				where += " and " + escapeId(k.replace('_like', "")) + " LIKE '%" + val.trim("'") + "%'";
-			} else {
-				where += " and " + escapeId(k) + " = " + val;
-			}
-		}
-	}
-	return where.replace(" and ", "");
+  var where = '';
+  const use_like = like === undefined ? this.like : like;
+  if (use_like) {
+    where = this._buildLikeWhere(obj);
+  } else {
+    where = this._buildExactWhere(obj);
+  }
+  return where.replace(' and ', '');
+};
+
+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;
+    } else if (k.endsWith('_max')) {
+      where += ' and ' + escapeId(k.replace('_max', '')) + ' <= ' + val;
+    } else if (k.endsWith('_not')) {
+      where += ' and ' + escapeId(k.replace('_not', '')) + ' != ' + val;
+    } else if (k.endsWith('_has')) {
+      var vals = val.trim("'").split(',').map((o) => {
+        return "'" + o + "'";
+      });
+      where += ' and ' + escapeId(k.replace('_has', '')) + ' in (' + vals.join(',') + ')';
+    } else if (k.endsWith('_like')) {
+      where += ' and ' + escapeId(k.replace('_like', '')) + " LIKE '%" + val.trim("'") + "%'";
+    } else if (typeof (val) === 'string' && !/^[0-9]+$/.test(val)) {
+      where += ' and ' + escapeId(k) + " LIKE '%" + val.trim("'") + "%'";
+    } else {
+      where += ' and ' + escapeId(k) + ' = ' + val;
+    }
+  }
+  return where;
+};
+
+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;
+    } else if (k.endsWith('_max')) {
+      where += ' and ' + escapeId(k.replace('_max', '')) + ' <= ' + val;
+    } else if (k.endsWith('_not')) {
+      where += ' and ' + escapeId(k.replace('_not', '')) + ' != ' + val;
+    } else if (k.endsWith('_has')) {
+      var vals = val.trim("'").split(',').map((o) => {
+        return "'" + o + "'";
+      });
+      where += ' and ' + escapeId(k.replace('_has', '')) + ' in (' + vals.join(',') + ')';
+    } else if (k.endsWith('_like')) {
+      where += ' and ' + escapeId(k.replace('_like', '')) + " LIKE '%" + val.trim("'") + "%'";
+    } else {
+      where += ' and ' + escapeId(k) + ' = ' + val;
+    }
+  }
+  return where;
 };
 
 /**
  * 转为set语句
- * @param {Object} obj 用作拼接的对象
- * @return {String} set格式sql语句字符串
+ * @param {object} obj 用作拼接的对象
+ * @returns {string} set格式sql语句字符串
  */
 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')) {
-			const k2 = escapeId(k.replace('_add', ""));
-			set += "," + k2 + " = " + k2 + " + " + val;
-		} else if (k.endsWith('_del')) {
-			const k3 = escapeId(k.replace('_del', ""));
-			set += "," + k3 + " = " + k3 + " - " + val;
-		} else {
-			set += "," + escapeId(k) + " = " + val;
-		}
-	}
-
-	return set.replace(",", "");
+  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')) {
+      const k2 = escapeId(k.replace('_add', ''));
+      set += ',' + k2 + ' = ' + k2 + ' + ' + val;
+    } else if (k.endsWith('_del')) {
+      const k3 = escapeId(k.replace('_del', ''));
+      set += ',' + k3 + ' = ' + k3 + ' - ' + val;
+    } else {
+      set += ',' + escapeId(k) + ' = ' + val;
+    }
+  }
+
+  return set.replace(',', '');
 };
 
 /**
  * 转添加sql语句
- * @param {Object} item 用作添加的键值
- * @return {String} sql语句
+ * @param {object} item 用作添加的键值
+ * @returns {string} sql语句
  */
 Sql.prototype.toAddSql = function (item) {
-	if (!this.table || !item || typeof item !== 'object') {
-		throw new Error('表名或数据未设置');
-	}
-
-	let key = "";
-	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);
-	}
-
-	const sql = "INSERT INTO `{0}` ({1}) VALUES ({2});"
-		.replace("{0}", this.table)
-		.replace("{1}", key.replace(",", ""))
-		.replace("{2}", value.replace(",", ""));
-
-	return sql;
+  if (!this.table || !item || typeof item !== 'object') {
+    throw new Error('表名或数据未设置');
+  }
+
+  let key = '';
+  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);
+  }
+
+  const sql = 'INSERT INTO `{0}` ({1}) VALUES ({2});'
+    .replace('{0}', this.table)
+    .replace('{1}', key.replace(',', ''))
+    .replace('{2}', value.replace(',', ''));
+
+  return sql;
 };
 
 /**
  * 转删除sql语句
- * @param {Object} query 查询键值
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {String} sql语句
+ * @param {object} query 查询键值
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {string} sql语句
  */
 Sql.prototype.toDelSql = function (query, like) {
-	if (!this.table) {
-		throw new Error('表名未设置');
-	}
-	const where = this.toWhere(query, like);
-	const sql = "DELETE FROM `{0}` WHERE {1};"
-		.replace("{0}", this.table)
-		.replace("{1}", where);
-	return sql;
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+  const where = this.toWhere(query, like);
+  const sql = 'DELETE FROM `{0}` WHERE {1};'
+    .replace('{0}', this.table)
+    .replace('{1}', where);
+  return sql;
 };
 
 /**
  * 转修改sql语句
- * @param {Object} query 查询的键值集合
- * @param {Object} item 修改的键值集合
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {String} sql语句
+ * @param {object} query 查询的键值集合
+ * @param {object} item 修改的键值集合
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {string} sql语句
  */
 Sql.prototype.toSetSql = function (query, item, like) {
-	if (!this.table) {
-		throw new Error('表名未设置');
-	}
-	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);
-	return sql;
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+  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);
+  return sql;
 };
 
 /**
  * 转查询sql语句
- * @param {Object} query 查询键值集合
- * @param {String} sort 排序规则
- * @param {String} view 显示的字段
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {String} sql语句
+ * @param {object} query 查询键值集合
+ * @param {string} sort 排序规则
+ * @param {string} view 显示的字段
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {string} sql语句
  */
 Sql.prototype.toGetSql = function (query, sort, view, like) {
-	const where = this.toWhere(query, like);
-	return this.toQuery(where, sort, view);
+  const where = this.toWhere(query, like);
+  return this.toQuery(where, sort, view);
 };
 
 /* ===  传入对象操作  === */
 /**
  * 增加数据
- * @param {Object} body 添加的对象
- * @return {Promise|Object} 执行结果
+ * @param {object} body 添加的对象
+ * @returns {Promise | object} 执行结果
  */
 Sql.prototype.add = async function (body) {
-	if (!this.table || !body || typeof body !== 'object') {
-		throw new Error('表名或数据未设置');
-	}
-	try {
-		const sql = this.toAddSql(body);
-		this.sql = sql;
-		return await this.exec(sql);
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '添加数据失败', err);
-	}
-	return 0;
+  if (!this.table || !body || typeof body !== 'object') {
+    throw new Error('表名或数据未设置');
+  }
+  try {
+    const sql = this.toAddSql(body);
+    this.sql = sql;
+    return await this.exec(sql);
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '添加数据失败', err);
+  }
+  return 0;
 };
 
 /**
  * 删除数据
- * @param {Object} query 查询条件集合
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 执行结果
+ * @param {object} query 查询条件集合
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise | object} 执行结果
  */
 Sql.prototype.del = async function (query, like) {
-	if (!this.table) {
-		throw new Error('表名未设置');
-	}
-	try {
-		const sql = this.toDelSql(query, like);
-		this.sql = sql;
-		const bl = await this.exec(sql);
-		return bl;
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '删除数据失败', err);
-	}
-	return 0;
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+  try {
+    const sql = this.toDelSql(query, like);
+    this.sql = sql;
+    const bl = await this.exec(sql);
+    return bl;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '删除数据失败', err);
+  }
+  return 0;
 };
 
 /**
  * 修改数据
- * @param {Object} query 查询条件集合
- * @param {Object} body 修改的键值集合
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 执行结果
+ * @param {object} query 查询条件集合
+ * @param {object} body 修改的键值集合
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise | object} 执行结果
  */
 Sql.prototype.set = async function (query, body, like) {
-	if (!this.table || !body || typeof body !== 'object') {
-		throw new Error('表名或数据未设置');
-	}
-	try {
-		const sql = this.toSetSql(query, body, like);
-		this.sql = sql;
-		const bl = await this.exec(sql);
-		return bl;
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '修改数据失败', err);
-	}
-	return 0;
+  if (!this.table || !body || typeof body !== 'object') {
+    throw new Error('表名或数据未设置');
+  }
+  try {
+    const sql = this.toSetSql(query, body, like);
+    this.sql = sql;
+    const bl = await this.exec(sql);
+    return bl;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '修改数据失败', err);
+  }
+  return 0;
 };
 
 /**
  * 添加或修改
- * @param {String|Object} where 查询条件
- * @param {String|Object} set 修改的键值
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 执行结果
+ * @param {string | object} where 查询条件
+ * @param {string | object} set 修改的键值
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise | object} 执行结果
  */
 Sql.prototype.addOrSetSql = async function (where, set, like) {
-	if (!this.table || !where || !set) {
-		throw new Error('表名、条件或数据未设置');
-	}
-	try {
-		let query = where;
-		let body = set;
-		let whereStr;
-
-		if (typeof where === "object") {
-			whereStr = await this.toWhere(where, like);
-		} else {
-			whereStr = where;
-		}
-
-		const count = await this.countSql(whereStr);
-
-		if (count === 0) {
-			let key = "";
-			let value = "";
-
-			if (typeof set === "string") {
-				const arr = set.split(",");
-				for (const o of arr) {
-					const ar = o.split('=');
-					if (ar.length === 2) {
-						key += "," + ar[0];
-						value += "," + ar[1];
-					}
-				}
-			} else {
-				for (const k in set) {
-					if (!Object.prototype.hasOwnProperty.call(set, k)) continue;
-
-					key += "," + escapeId(k);
-					let val = set[k];
-					if (typeof val === "string") {
-						val = val.trim("'");
-					}
-					value += "," + escape(val);
-				}
-			}
-
-			const bl = await this.addSql(key.replace(",", ""), value.replace(",", ""));
-
-			return bl;
-		} else {
-			if (typeof set === "object") {
-				set = await this.toSet(set);
-			}
-
-			const bl1 = await this.setSql(whereStr, set);
-
-			return bl1;
-		}
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '添加或修改数据失败', err);
-	}
-	return 0;
+  if (!this.table || !where || !set) {
+    throw new Error('表名、条件或数据未设置');
+  }
+  try {
+    const where_str = await this._getWhereStr(where, like);
+    const count = await this.countSql(where_str);
+
+    if (count === 0) {
+      return await this._addData(set);
+    } else {
+      return await this._updateData(where_str, set);
+    }
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '添加或修改数据失败', err);
+  }
+  return 0;
+};
+
+Sql.prototype._getWhereStr = async function (where, like) {
+  if (typeof where === 'object') {
+    return await this.toWhere(where, like);
+  }
+  return where;
+};
+
+Sql.prototype._addData = async function (set) {
+  const { key_str, val_str } = await this._parseSetData(set);
+  return await this.addSql(key_str, val_str);
+};
+
+Sql.prototype._updateData = async function (where_str, set) {
+  let set_val = set;
+  if (typeof set === 'object') {
+    set_val = this.toSet(set);
+  }
+  return await this.setSql(where_str, set_val);
+};
+
+Sql.prototype._parseSetData = async function (set) {
+  let key_str = '';
+  let val_str = '';
+
+  if (typeof set === 'string') {
+    const arr = set.split(',');
+    for (const o of arr) {
+      const ar = o.split('=');
+      if (ar.length === 2) {
+        key_str += ',' + ar[0];
+        val_str += ',' + ar[1];
+      }
+    }
+  } 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);
+    }
+  }
+
+  return {
+    key_str: key_str.replace(',', ''),
+    val_str: val_str.replace(',', '')
+  };
 };
 
 /**
  * 查询数据
- * @param {Object} query 查询条件
- * @param {String} sort 排序
- * @param {String} view 返回的字段
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {Number} timeout 超时时间（毫秒），默认30000ms
- * @return {Promise|Array} 查询结果
+ * @param {object} query 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @returns {Promise|Array} 查询结果
  */
 Sql.prototype.get = async function (query, sort, view, like, timeout = 60000) {
-	if (!this.table) {
-		throw new Error('表名未设置');
-	}
-
-	try {
-		// 添加超时控制的Promise，增加默认超时时间
-		const timeoutPromise = new Promise((_, reject) => {
-			setTimeout(() => reject(new Error('查询操作超时')), timeout);
-		});
-
-		// 使用Promise.race实现超时控制
-		return await Promise.race([
-			(async () => {
-				// 生成SQL并执行
-				const sql = this.toGetSql(query, sort, view, like);
-				this.sql = sql;
-				const list = await this.run(sql);
-				return list;
-			})(),
-			timeoutPromise
-		]);
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '查询数据失败', err);
-	}
-	return [];
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+
+  try {
+    // 使用Promise.race实现超时控制
+    return await Promise.race([
+      (async () => {
+        // 生成SQL并执行
+        const sql = this.toGetSql(query, sort, view, like);
+        this.sql = sql;
+        const list = await this.run(sql);
+        return list;
+      })(),
+      new Promise((resolve, reject) => {
+        setTimeout(() => reject(new Error('查询操作超时')), timeout);
+      })
+    ]);
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '查询数据失败', err);
+  }
+  return [];
 };
 
 /**
  * 查询单条数据
- * @param {Object} query 查询条件
- * @param {String} sort 排序
- * @param {String} view 返回的字段
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {Number} timeout 超时时间（毫秒），默认30000ms
- * @return {Promise|Object|null} 查询结果
+ * @param {object} query 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @returns {Promise | object | null} 查询结果
  */
 Sql.prototype.getObj = async function (query, sort, view, like, timeout = 60000) {
-	try {
-		// 保存当前分页设置
-		const oldPage = this.page;
-		const oldSize = this.size;
-
-		// 设置为只查询一条
-		this.page = 1;
-		this.size = 1;
-
-		// 使用优化后的get方法
-		const list = await this.get(query, sort, view, like, timeout);
-
-		// 恢复分页设置
-		this.page = oldPage;
-		this.size = oldSize;
-
-		var obj = null;
-		if (list.length > 0) {
-			obj = list[0];
-			if (this.key) {
-				obj = this.model(obj);
-			}
-		}
-
-		return obj;
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '查询单条数据失败', err);
-	}
-	return null;
+  try {
+    // 保存当前分页设置
+    const old_page = this.page;
+    const old_size = this.size;
+
+    // 设置为只查询一条
+    this.page = 1;
+    this.size = 1;
+
+    // 使用优化后的get方法
+    const list = await this.get(query, sort, view, like, timeout);
+
+    // 恢复分页设置
+    this.page = old_page;
+    this.size = old_size;
+
+    var obj = null;
+    if (list.length > 0) {
+      obj = list[0];
+      if (this.key) {
+        obj = this.model(obj);
+      }
+    }
+
+    return obj;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '查询单条数据失败', err);
+  }
+  return null;
 };
 
 /**
  * 统计记录数
- * @param {Object} query 查询条件
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {Number} timeout 超时时间（毫秒），默认30000ms
- * @return {Promise|Number} 记录数
+ * @param {object} query 查询条件
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @returns {Promise | number} 记录数
  */
 Sql.prototype.count = async function (query, like, timeout = 60000) {
-	if (!this.table) {
-		throw new Error('表名未设置');
-	}
-
-	try {
-		// 添加超时控制
-		const timeoutPromise = new Promise((_, reject) => {
-			setTimeout(() => reject(new Error('统计操作超时')), timeout);
-		});
-
-		return await Promise.race([
-			(async () => {
-				// 正确生成count SQL
-				const where = typeof query === 'string' ? query : await this.toWhere(query, like);
-				const sql = "SELECT COUNT(*) as num FROM `" + this.table + "`" + (where ? " WHERE " + where : "");
-				this.sql = sql;
-				const list = await this.run(sql);
-				const total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
-				return total;
-			})(),
-			timeoutPromise
-		]);
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '统计数据失败', err);
-	}
-	return 0;
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+
+  try {
+    // 添加超时控制
+    const timeout_promise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error('统计操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 正确生成count SQL
+        const where = typeof query === 'string' ? query : await this.toWhere(query, like);
+        const sql = 'SELECT COUNT(*) as num FROM `' + this.table + '`' + (where ? ' WHERE ' + where : '');
+        this.sql = sql;
+        const list = await this.run(sql);
+        const total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
+        return total;
+      })(),
+      timeout_promise
+    ]);
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '统计数据失败', err);
+  }
+  return 0;
 };
 
 /**
  * 统计记录数(别名)
- * @param {Object} query 查询条件
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {Number} timeout 超时时间（毫秒），默认30000ms
- * @return {Promise|Number} 记录数
+ * @param {object} query 查询条件
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @returns {Promise | number} 记录数
  */
 Sql.prototype.getCount = async function (query, like, timeout = 30000) {
-	return await this.count(query, like, timeout);
+  return await this.count(query, like, timeout);
 };
 
 /* ===  传入数组操作  === */
 /**
  * 添加多条数据
  * @param {Array} list 对象数组
- * @param {Boolean} lock 是否锁定
- * @param {Number} batchSize 每批处理数量，默认100
- * @param {Number} timeout 超时时间（毫秒），默认60000
- * @return {Promise<Object>} 执行结果
+ * @param {boolean} lock 是否锁定
+ * @param {number} batchSize 每批处理数量，默认100
+ * @param {number} timeout 超时时间（毫秒），默认60000
+ * @returns {Promise<object>} 执行结果
  */
-Sql.prototype.addList = async function (list, lock = true, batchSize = 100, timeout = 60000) {
-	if (!this.table || !Array.isArray(list) || list.length === 0) {
-		throw new Error('表名或数据列表未设置');
-	}
-	try {
-		// 添加整体操作超时控制
-		const timeoutPromise = new Promise((_, reject) => {
-			setTimeout(() => reject(new Error('批量添加数据操作超时')), timeout);
-		});
-
-		return await Promise.race([
-			(async () => {
-				// 如果数据量较小，直接处理
-				if (list.length <= batchSize) {
-					// 使用批量插入语法，不使用事务包装
-					this.sql = this.toBatchAddSql(list);
-					return await this.exec(this.sql);
-				}
-
-				// 分批处理大数据量
-				const totalBatches = Math.ceil(list.length / batchSize);
-				this.logger('info', `开始分批添加数据，共${totalBatches}批，每批${batchSize}条`);
-
-				// 分批执行，每批一个单独的批量插入语句
-				let finalResult = null;
-				for (let i = 0; i < totalBatches; i++) {
-					const batch = list.slice(i * batchSize, (i + 1) * batchSize);
-					this.logger('debug', `处理第${i + 1}/${totalBatches}批数据，${batch.length}条`);
-
-					// 生成批量插入SQL
-					const batchSql = this.toBatchAddSql(batch);
-					this.sql = batchSql;
-
-					// 为每批操作添加超时控制
-					finalResult = await Promise.race([
-						this.exec(batchSql),
-						new Promise((_, reject) => {
-							setTimeout(() => reject(new Error(`第${i + 1}批数据处理超时`)), timeout / totalBatches);
-						})
-					]);
-				}
-
-				this.logger('info', `批量添加数据完成，共${list.length}条`);
-				return finalResult;
-			})(),
-			timeoutPromise
-		]);
-	} catch (error) {
-		this.logger('error', '批量添加数据失败', error);
-	}
-	return 0;
+Sql.prototype.addList = async function (list, batchSize = 100, timeout = 60000) {
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+  try {
+    // 添加整体操作超时控制
+    const timeout_promise = new Promise((resolve, reject) => {
+      setTimeout(() => reject(new Error('批量添加数据操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 如果数据量较小，直接处理
+        if (list.length <= batchSize) {
+          // 使用批量插入语法，不使用事务包装
+          this.sql = this.toBatchAddSql(list);
+          return await this.exec(this.sql);
+        }
+
+        // 分批处理大数据量
+        const batches = Math.ceil(list.length / batchSize);
+        this.log('info', `开始分批添加数据，共${batches}批，每批${batchSize}条`);
+
+        // 分批执行，每批一个单独的批量插入语句
+        let final_res = null;
+        for (let i = 0; i < batches; i++) {
+          const batch = list.slice(i * batchSize, (i + 1) * batchSize);
+          this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
+
+          // 生成批量插入SQL
+          const batch_sql = this.toBatchAddSql(batch);
+          this.sql = batch_sql;
+
+          // 为每批操作添加超时控制
+          final_res = await Promise.race([
+            this.exec(batch_sql),
+            new Promise((_, reject) => {
+              setTimeout(() => reject(new Error(`第${i + 1}批数据处理超时`)), timeout / batches);
+            })
+          ]);
+        }
+
+        this.log('info', `批量添加数据完成，共${list.length}条`);
+        return final_res;
+      })(),
+      timeout_promise
+    ]);
+  } catch (error) {
+    this.log('error', '批量添加数据失败', error);
+  }
+  return 0;
 };
 
 /**
  * 生成批量插入SQL语句
  * @param {Array} list 数据列表
- * @return {String} 批量插入SQL语句
+ * @returns {string} 批量插入SQL语句
  */
 Sql.prototype.toBatchAddSql = function (list) {
-	if (!this.table || !Array.isArray(list) || list.length === 0) {
-		throw new Error('表名或数据列表未设置');
-	}
-
-	// 获取第一个对象的键名作为列名
-	const firstItem = list[0];
-	if (!firstItem || typeof firstItem !== 'object') {
-		throw new Error('数据格式错误');
-	}
-
-	let keys = [];
-	for (const k in firstItem) {
-		if (Object.prototype.hasOwnProperty.call(firstItem, k)) {
-			keys.push(this.escapeId(k));
-		}
-	}
-
-	// 构建列名部分
-	const columns = keys.join(',');
-
-	// 构建值部分
-	const valuesList = [];
-	for (const item of list) {
-		const values = [];
-		for (const k of keys) {
-			const unescapedKey = k.replace(/`/g, '');
-			let val = item[unescapedKey];
-			if (typeof val === "string") {
-				val = val.trim("'");
-			}
-			values.push(this.escape(val));
-		}
-		valuesList.push(`(${values.join(',')})`);
-	}
-
-	// 生成最终SQL
-	const sql = `INSERT INTO \`${this.table}\` (${columns}) VALUES ${valuesList.join(',')}`;
-	return sql;
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+
+  const first_obj = list[0];
+  if (!first_obj || typeof first_obj !== 'object') {
+    throw new Error('数据格式错误');
+  }
+
+  const keys = this._getKeys(first_obj);
+  const columns = keys.join(',');
+  const val_list = this._buildValueList(list, keys);
+
+  return `INSERT INTO \`${this.table}\` (${columns}) VALUES ${val_list.join(',')}`;
+};
+
+Sql.prototype._getKeys = function (obj) {
+  const keys = [];
+  for (const k in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, k)) {
+      keys.push(this.escapeId(k));
+    }
+  }
+  return keys;
+};
+
+Sql.prototype._buildValueList = function (list, keys) {
+  const val_list = [];
+  for (const item of list) {
+    const values = [];
+    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(',')})`);
+  }
+  return val_list;
 };
 
 /**
  * 删除多条数据
  * @param {Array} list 对象数组
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {Number} batchSize 每批处理数量，默认100
- * @param {Number} timeout 超时时间（毫秒），默认60000
- * @return {Promise<Object>} 执行结果
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} batchSize 每批处理数量，默认100
+ * @param {number} timeout 超时时间（毫秒），默认60000
+ * @returns {Promise<object>} 执行结果
  */
 Sql.prototype.delList = async function (list, like, batchSize = 100, timeout = 60000) {
-	if (!this.table || !Array.isArray(list) || list.length === 0) {
-		throw new Error('表名或数据列表未设置');
-	}
-	try {
-		// 添加整体操作超时控制
-		const timeoutPromise = new Promise((_, reject) => {
-			setTimeout(() => reject(new Error('批量删除数据操作超时')), timeout);
-		});
-
-		return await Promise.race([
-			(async () => {
-				// 如果数据量较小，直接处理
-				if (list.length <= batchSize) {
-					let sql = "";
-					for (const item of list) {
-						sql += this.toDelSql(item.query, like);
-					}
-					this.sql = sql;
-					return await this.exec(sql);
-				}
-
-				// 分批处理大数据量
-				const totalBatches = Math.ceil(list.length / batchSize);
-				this.logger('info', `开始分批删除数据，共${totalBatches}批，每批${batchSize}条`);
-
-				// 使用事务包装整个操作以保证原子性
-				let finalResult = null;
-				try {
-					// 开始事务
-					await this.exec("BEGIN;", 15000);
-
-					// 分批处理
-					for (let i = 0; i < totalBatches; i++) {
-						const batch = list.slice(i * batchSize, (i + 1) * batchSize);
-						this.logger('debug', `处理第${i + 1}/${totalBatches}批数据，${batch.length}条`);
-
-						let batchSql = "";
-						for (const item of batch) {
-							batchSql += this.toDelSql(item.query, like);
-						}
-
-						// 为每批操作添加超时控制
-						finalResult = await Promise.race([
-							this.exec(batchSql),
-							new Promise((_, reject) => {
-								setTimeout(() => reject(new Error(`第${i + 1}批数据删除超时`)), timeout / totalBatches);
-							})
-						]);
-					}
-
-					// 提交事务
-					await this.exec("COMMIT;", 15000);
-				} catch (error) {
-					// 发生错误时回滚事务
-					try {
-						await this.exec("ROLLBACK;", 15000);
-						this.logger('error', '批量删除数据失败，事务已回滚', error);
-					} catch (rollbackError) {
-						this.logger('error', '批量删除数据失败，事务回滚也失败', rollbackError);
-					}
-				}
-
-				this.logger('info', `批量删除数据完成，共${list.length}条`);
-				return finalResult;
-			})(),
-			timeoutPromise
-		]);
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '批量删除数据失败', err);
-	}
-	return 0;
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+  try {
+    // 添加整体操作超时控制
+    const timeout_promise = new Promise((resolve, reject) => {
+      setTimeout(() => reject(new Error('批量删除数据操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 如果数据量较小，直接处理
+        if (list.length <= batchSize) {
+          let sql = '';
+          for (const item of list) {
+            sql += this.toDelSql(item.query, like);
+          }
+          this.sql = sql;
+          return await this.exec(sql);
+        }
+
+        // 分批处理大数据量
+        const batches = Math.ceil(list.length / batchSize);
+        this.log('info', `开始分批删除数据，共${batches}批，每批${batchSize}条`);
+
+        // 使用事务包装整个操作以保证原子性
+        let final_res = null;
+        try {
+          // 开始事务
+          await this.exec('BEGIN;', 15000);
+
+          // 分批处理
+          for (let i = 0; i < batches; i++) {
+            const batch = list.slice(i * batchSize, (i + 1) * batchSize);
+            this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
+
+            let batch_sql = '';
+            for (const item of batch) {
+              batch_sql += this.toDelSql(item.query, like);
+            }
+
+            // 为每批操作添加超时控制
+            final_res = await Promise.race([
+              this.exec(batch_sql),
+              new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`第${i + 1}批数据删除超时`)), timeout / batches);
+              })
+            ]);
+          }
+
+          // 提交事务
+          await this.exec('COMMIT;', 15000);
+        } catch (error) {
+          // 发生错误时回滚事务
+          try {
+            await this.exec('ROLLBACK;', 15000);
+            this.log('error', '批量删除数据失败，事务已回滚', error);
+          } catch (rollbackError) {
+            this.log('error', '批量删除数据失败，事务回滚也失败', rollbackError);
+          }
+        }
+
+        this.log('info', `批量删除数据完成，共${list.length}条`);
+        return final_res;
+      })(),
+      timeoutPromise
+    ]);
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '批量删除数据失败', err);
+  }
+  return 0;
 };
 
 /**
  * 修改多条数据
  * @param {Array} list 对象数组
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {Number} batchSize 每批处理数量，默认100
- * @param {Number} timeout 超时时间（毫秒），默认60000
- * @return {Promise<Object>} 执行结果
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} batchSize 每批处理数量，默认100
+ * @param {number} timeout 超时时间（毫秒），默认60000
+ * @returns {Promise<object>} 执行结果
  */
 Sql.prototype.setList = async function (list, like = false, batchSize = 100, timeout = 60000) {
-	if (!this.table || !Array.isArray(list) || list.length === 0) {
-		throw new Error('表名或数据列表未设置');
-	}
-	try {
-		// 添加整体操作超时控制
-		const timeoutPromise = new Promise((_, reject) => {
-			setTimeout(() => reject(new Error('批量修改数据操作超时')), timeout);
-		});
-
-		return await Promise.race([
-			(async () => {
-				// 分批处理大数据量
-				const totalBatches = Math.ceil(list.length / batchSize);
-				this.logger('info', `开始分批修改数据，共${totalBatches}批，每批${batchSize}条`);
-
-				let finalResult = null;
-
-				// 逐条处理记录，保持简单可靠
-				for (let i = 0; i < list.length; i++) {
-					const item = list[i];
-					this.logger('debug', `处理第${i + 1}/${list.length}条记录`);
-
-					// 生成单个更新SQL
-					const sql = this.toSetSql(item.query, item.item, like);
-					this.sql = sql;
-
-					// 为每条操作添加超时控制
-					finalResult = await Promise.race([
-						this.exec(sql),
-						new Promise((_, reject) => {
-							setTimeout(() => reject(new Error(`第${i + 1}条数据修改超时`)), 5000); // 固定超时时间
-						})
-					]);
-				}
-
-				return finalResult;
-			})(),
-			timeoutPromise
-		]);
-	} catch (error) {
-		this.error = error.message;
-		this.logger('error', '批量修改数据失败', error);
-	}
-	return 0;
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+  try {
+    // 添加整体操作超时控制
+    const timeout_promise = new Promise((resolve, reject) => {
+      setTimeout(() => reject(new Error('批量修改数据操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 分批处理大数据量
+        const batches = Math.ceil(list.length / batchSize);
+        this.log('info', `开始分批修改数据，共${batches}批，每批${batchSize}条`);
+
+        let final_res = null;
+
+        // 逐条处理记录，保持简单可靠
+        for (let i = 0; i < list.length; i++) {
+          const item = list[i];
+          this.log('debug', `处理第${i + 1}/${list.length}条记录`);
+
+          // 生成单个更新SQL
+          const sql = this.toSetSql(item.query, item.item, like);
+          this.sql = sql;
+
+          // 为每条操作添加超时控制
+          final_res = await Promise.race([
+            this.exec(sql),
+            new Promise((_, reject) => {
+              setTimeout(() => reject(new Error(`第${i + 1}条数据修改超时`)), 5000); // 固定超时时间
+            })
+          ]);
+        }
+
+        return final_res;
+      })(),
+      timeoutPromise
+    ]);
+  } catch (error) {
+    this.error = error.message;
+    this.log('error', '批量修改数据失败', error);
+  }
+  return 0;
 };
 
 /* 辅助类 */
 /**
  * 判断SQL模板是否包含某些参数
- * @param {Object} paramDt 参数集合
- * @param {Object} sqlDt sql模板集合
- * @return {Boolean} 有则返回true，没有则返回false
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt sql模板集合
+ * @returns {boolean} 有则返回true，没有则返回false
  */
-Sql.prototype.hasParam = function (paramDt, sqlDt) {
-	if (!paramDt || !sqlDt) {
-		return false;
-	}
-	for (const key in sqlDt) {
-		if (!Object.prototype.hasOwnProperty.call(sqlDt, key)) continue;
-		const value = paramDt[key];
-		if (value !== undefined && value !== null && value !== "") {
-			return true;
-		}
-	}
-	return false;
+Sql.prototype.has = function (param_dt, sql_dt) {
+  if (!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;
+    }
+  }
+  return false;
 };
 
 /**
  * 判断某些参数是否没有SQL模板
- * @param {Object} paramDt 参数集合
- * @param {Object} sqlDt sql模板集合
- * @return {String|undefined} 没有模板则返回名称，都有则返回undefined
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt sql模板集合
+ * @returns {string | undefined} 没有模板则返回名称，都有则返回undefined
  */
-Sql.prototype.notParam = function (paramDt, sqlDt) {
-	if (!paramDt || !sqlDt) {
-		return undefined;
-	}
-	for (const key in paramDt) {
-		if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-		if (!sqlDt[key]) {
-			return key;
-		}
-	}
-	return undefined;
+Sql.prototype.not = function (param_dt, sql_dt) {
+  if (!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;
+    }
+  }
+  return undefined;
 };
 
 /**
  * 过滤参数，仅保留没有sql模板的参数
- * @param {Object} paramDt 参数集合
- * @param {Object} sqlDt sql模板集合
- * @return {Object} 返回过滤后的参数集合
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt sql模板集合
+ * @returns {object} 返回过滤后的参数集合
  */
-Sql.prototype.filterParam = function (paramDt, sqlDt) {
-	const dt = {};
-	if (!paramDt || !sqlDt) {
-		return dt;
-	}
-	for (const key in paramDt) {
-		if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-		if (!sqlDt[key]) {
-			dt[key] = paramDt[key];
-		}
-	}
-	return dt;
+Sql.prototype.filterParams = function (param_dt, sql_dt) {
+  const dt = {};
+  if (!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];
+    }
+  }
+  return dt;
+};
+
+/**
+ * 处理带模板的查询条件（有分隔符）
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt 模板集合
+ * @param {string} l 分隔符
+ * @returns {string} 拼接的查询条件
+ */
+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];
+
+    if (tpl) {
+      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("'")));
+        }
+        conds.push('(' + sub_conds.join(' || ') + ')');
+      } else {
+        const clean_val = typeof value === 'string' ? value.trim("'") : value;
+        conds.push(tpl.replaceAll('{0}', escape(clean_val).trim("'")));
+      }
+    } else {
+      if (arr.length > 1) {
+        const sub_conds = [];
+        for (const val of arr) {
+          sub_conds.push(escapeId(key) + ' = ' + escape(val));
+        }
+        conds.push('(' + sub_conds.join(' || ') + ')');
+      } else {
+        const clean_val = typeof value === 'string' ? value.trim("'") : value;
+        conds.push(escapeId(key) + ' = ' + escape(clean_val));
+      }
+    }
+  }
+  return conds.join(' && ');
+};
+
+/**
+ * 处理带模板的查询条件（无分隔符）
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt 模板集合
+ * @returns {string} 拼接的查询条件
+ */
+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);
+    if (sql_dt[key]) {
+      conds.push(sql_dt[key].replaceAll('{0}', value.trim("'")));
+    } else {
+      conds.push(escapeId(key) + ' = ' + value);
+    }
+  }
+  return conds.join(' && ');
+};
+
+/**
+ * 处理无模板的查询条件（有分隔符）
+ * @param {object} param_dt 参数集合
+ * @param {string} l 分隔符
+ * @returns {string} 拼接的查询条件
+ */
+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) {
+      const sub_conds = [];
+      for (const val of arr) {
+        sub_conds.push(escapeId(key) + ' = ' + escape(val));
+      }
+      conds.push('(' + sub_conds.join(' || ') + ')');
+    } else {
+      conds.push(escapeId(key) + ' = ' + escape(value));
+    }
+  }
+  return conds.join(' && ');
+};
+
+/**
+ * 处理无模板的查询条件（无分隔符）
+ * @param {object} param_dt 参数集合
+ * @returns {string} 拼接的查询条件
+ */
+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(' && ');
 };
 
 /**
  * 通过模板拼接查询参数
- * @param {Object} paramDt 参数集合
- * @param {Object} sqlDt 模板集合
- * @return {String} 返回拼接的查询参数
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt 模板集合
+ * @returns {string} 返回拼接的查询参数
  */
-Sql.prototype.tplQuery = function (paramDt, sqlDt) {
-	let sql = "";
-	if (!paramDt) {
-		return sql;
-	}
-	const l = this.config.separator;
-	if (sqlDt) {
-		if (l) {
-			const conditions = [];
-			for (const key in paramDt) {
-				if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-
-				let value = String(paramDt[key]);
-				const arr = value.split(l);
-				const tpl = sqlDt[key];
-
-				if (tpl) {
-					if (arr.length > 1) {
-						// 如果数量大于0，则增加多条件
-						let subConditions = [];
-						for (const val of arr) {
-							const cleanVal = typeof val === "string" ? val.trim("'") : val;
-							subConditions.push(tpl.replaceAll("{0}", escape(cleanVal).trim("'")));
-						}
-						conditions.push("(" + subConditions.join(" || ") + ")");
-					} else {
-						const cleanVal = typeof value === "string" ? value.trim("'") : value;
-						conditions.push(tpl.replaceAll("{0}", escape(cleanVal).trim("'")));
-					}
-				} else {
-					if (arr.length > 1) {
-						// 如果数量大于0，则增加多条件
-						let subConditions = [];
-						for (const val of arr) {
-							subConditions.push(escapeId(key) + " = " + escape(val));
-						}
-						conditions.push("(" + subConditions.join(" || ") + ")");
-					} else {
-						const cleanVal = typeof value === "string" ? value.trim("'") : value;
-						conditions.push(escapeId(key) + " = " + escape(cleanVal));
-					}
-				}
-			}
-			sql = conditions.join(" && ");
-		} else {
-			const conditions = [];
-			for (const key in paramDt) {
-				if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-				let value = paramDt[key];
-				if (typeof value === "string") {
-					value = value.trim("'");
-				}
-				value = escape(value);
-				if (sqlDt[key]) {
-					conditions.push(sqlDt[key].replaceAll("{0}", value.trim("'")));
-				} else {
-					conditions.push(escapeId(key) + " = " + value);
-				}
-			}
-			sql = conditions.join(" && ");
-		}
-	} else {
-		// 如果没有模板，则直接拼接参数
-		if (l) {
-			// 使用分隔数组拼接
-			const conditions = [];
-			for (const key in paramDt) {
-				if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-				const value = paramDt[key];
-				const arr = String(value).split(l);
-				if (arr.length > 1) {
-					// 如果数量大于0，则增加多条件
-					let subConditions = [];
-					for (const val of arr) {
-						subConditions.push(escapeId(key) + " = " + escape(val));
-					}
-					conditions.push("(" + subConditions.join(" || ") + ")");
-				} else {
-					conditions.push(escapeId(key) + " = " + escape(value));
-				}
-			}
-			sql = conditions.join(" && ");
-		} else {
-			// 直接拼接
-			const conditions = [];
-			for (const key in paramDt) {
-				if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-				conditions.push(escapeId(key) + " = " + escape(paramDt[key]));
-			}
-			sql = conditions.join(" && ");
-		}
-	}
-	return sql;
+Sql.prototype.tplQuery = function (param_dt, sql_dt) {
+  let sql = '';
+  if (!param_dt) {
+    return sql;
+  }
+  const l = this.config.separator;
+  if (sql_dt) {
+    if (l) {
+      sql = this._tplQueryWithSep(param_dt, sql_dt, l);
+    } else {
+      sql = this._tplQueryNoSep(param_dt, sql_dt);
+    }
+  } else {
+    if (l) {
+      sql = this._noTplQueryWithSep(param_dt, l);
+    } else {
+      sql = this._noTplQueryNoSep(param_dt);
+    }
+  }
+  return sql;
 };
 
 /**
  * 通过模板拼接修改参数
- * @param {Object} paramDt 参数集合
- * @param {Object} sqlDt 模板集合
- * @return {String} 返回拼接的查询参数
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt 模板集合
+ * @returns {string} 返回拼接的查询参数
  */
-Sql.prototype.tplBody = function (paramDt, sqlDt) {
-	if (!paramDt) {
-		return "";
-	}
-	const parts = [];
-	if (!sqlDt || Object.keys(sqlDt).length === 0) {
-		for (const key in paramDt) {
-			if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-			parts.push(" " + escapeId(key) + " = " + escape(paramDt[key]));
-		}
-	} else {
-		for (const key in paramDt) {
-			if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
-			const value = escape(paramDt[key]);
-			if (sqlDt[key]) {
-				parts.push(" " + sqlDt[key].replace("{0}", value).replace(/\+ -/g, "- ").replace(/- -/g, "+ "));
-			} else {
-				parts.push(" " + escapeId(key) + " = " + value);
-			}
-		}
-	}
-	return parts.join(",").replace(", ", "");
+Sql.prototype.tplBody = function (param_dt, sql_dt) {
+  if (!param_dt) {
+    return '';
+  }
+  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]);
+      if (sql_dt[key]) {
+        parts.push(' ' + sql_dt[key].replace('{0}', value).replace(/\+ -/g, '- ').replace(/- -/g, '+ '));
+      } else {
+        parts.push(' ' + escapeId(key) + ' = ' + value);
+      }
+    }
+  }
+  return parts.join(',').replace(', ', '');
 };
 
 /**
  * 从SQL文件加载数据库结构和数据
- * @param {String} file - SQL文件路径
+ * @param {string} file - SQL文件路径
  * @returns {Promise<boolean>} 是否加载成功
  */
 Sql.prototype.load = async function (file) {
-	try {
-		// 记录操作日志
-		if (this.config && this.config.debug) {
-			this.logger('debug', `开始从文件加载数据库`, {
-				file: file
-			});
-		}
-
-		// 检查文件是否存在
-		if (!file.hasFile()) {
-			throw new Error(`SQL文件不存在: ${file}`);
-		}
-
-		// 读取SQL文件内容
-		const sqlContent = await $.file.readText(file);
-
-		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 && this.config.debug) {
-				this.logger('info', `数据库加载成功`, {
-					file: file,
-					statementCount: sqlStatements.length
-				});
-			}
-
-			return true;
-		} catch (err) {
-			// 回滚事务
-			await this.exec('ROLLBACK').catch(rollbackErr => {
-				this.logger('error', '事务回滚失败', rollbackErr);
-			});
-
-			this.logger('error', '数据库加载失败', err);
-		}
-	} catch (error) {
-		// 记录错误日志
-		this.logger('error', '数据库加载失败', error);
-	}
-	return false;
+  try {
+    await this._logLoadStart(file);
+    await this._validateFile(file);
+    const sql_stmts = await this._readAndSplitSql(file);
+    return await this._execSqlStmts(file, sql_stmts);
+  } catch (error) {
+    this.log('error', '数据库加载失败', error);
+  }
+  return false;
+};
+
+/**
+ * 记录加载开始日志
+ * @param {string} file - SQL文件路径
+ * @returns {Promise<void>}
+ */
+Sql.prototype._logLoadStart = async function (file) {
+  if (this.config && this.config.debug) {
+    this.log('debug', `开始从文件加载数据库`, {
+      file: file
+    });
+  }
+};
+
+/**
+ * 验证SQL文件
+ * @param {string} file - SQL文件路径
+ * @returns {Promise<void>}
+ */
+Sql.prototype._validateFile = async function (file) {
+  if (!file.hasFile()) {
+    throw new Error(`SQL文件不存在: ${file}`);
+  }
+};
+
+/**
+ * 读取并分割SQL文件
+ * @param {string} file - SQL文件路径
+ * @returns {Promise<string[]>} SQL语句数组
+ */
+Sql.prototype._readAndSplitSql = async function (file) {
+  const sql_content = await $.file.readText(file);
+  if (!sql_content || sql_content.trim() === '') {
+    throw new Error(`SQL文件内容为空: ${file}`);
+  }
+  return this._splitSqlStatements(sql_content);
+};
+
+/**
+ * 执行SQL语句
+ * @param {string} file - SQL文件路径
+ * @param {string[]} sql_stmts - SQL语句数组
+ * @returns {Promise<boolean>} 是否执行成功
+ */
+Sql.prototype._execSqlStmts = async function (file, sql_stmts) {
+  await this.exec('START TRANSACTION');
+  try {
+    await this._executeStatements(sql_stmts);
+    await this.exec('COMMIT');
+    await this._logLoadSuccess(file, sql_stmts.length);
+    return true;
+  } catch (err) {
+    await this._handleTxError(err);
+    return false;
+  }
+};
+
+/**
+ * 执行SQL语句数组
+ * @param {string[]} sql_stmts - SQL语句数组
+ * @returns {Promise<void>}
+ */
+Sql.prototype._executeStatements = async function (sql_stmts) {
+  for (const sql of sql_stmts) {
+    const trimmed_sql = sql.trim();
+    if (trimmed_sql) {
+      await this.exec(trimmed_sql);
+    }
+  }
+};
+
+/**
+ * 记录加载成功日志
+ * @param {string} file - SQL文件路径
+ * @param {number} count - SQL语句数量
+ * @returns {Promise<void>}
+ */
+Sql.prototype._logLoadSuccess = async function (file, count) {
+  if (this.config && this.config.debug) {
+    this.log('info', `数据库加载成功`, {
+      file: file,
+      count: count
+    });
+  }
+};
+
+/**
+ * 处理事务错误
+ * @param {Error} err - 错误对象
+ * @returns {Promise<void>}
+ */
+Sql.prototype._handleTxError = async function (err) {
+  await this.exec('ROLLBACK').catch(rollback_err => {
+    this.log('error', '事务回滚失败', rollback_err);
+  });
+  this.log('error', '数据库加载失败', err);
+};
+
+/**
+ * 处理单行注释
+ * @private
+ * @param {string} char 当前字符
+ * @param {string} next_char 下一个字符
+ * @param {boolean} in_str 是否在字符串中
+ * @param {boolean} in_comment 是否在注释中
+ * @returns {object} 处理结果
+ */
+Sql.prototype._handleLineComment = function (char, next_char, in_str, in_comment) {
+  if (!in_str && !in_comment && char === '-' && next_char === '-') {
+    return { in_comment: true, skip: 1 };
+  }
+  if (in_comment && char === '\n') {
+    return { in_comment: false, skip: 0 };
+  }
+  return { in_comment: in_comment, skip: 0 };
+};
+
+/**
+ * 处理多行注释
+ * @private
+ * @param {string} char 当前字符
+ * @param {string} next_char 下一个字符
+ * @param {boolean} in_str 是否在字符串中
+ * @param {boolean} in_comment 是否在注释中
+ * @returns {object} 处理结果
+ */
+Sql.prototype._handleBlockComment = function (char, next_char, in_str, in_comment) {
+  if (!in_str && !in_comment && char === '/' && next_char === '*') {
+    return { in_comment: true, skip: 1 };
+  }
+  if (in_comment && char === '*' && next_char === '/') {
+    return { in_comment: false, skip: 1 };
+  }
+  return { in_comment: in_comment, skip: 0 };
+};
+
+/**
+ * 处理字符串
+ * @private
+ * @param {string} char 当前字符
+ * @param {string} sql_content SQL内容
+ * @param {number} i 当前索引
+ * @param {boolean} in_str 是否在字符串中
+ * @param {string} str_char 字符串字符
+ * @param {boolean} in_comment 是否在注释中
+ * @returns {object} 处理结果
+ */
+Sql.prototype._handleString = function (char, sql_content, i, in_str, str_char, in_comment) {
+  if (!in_comment && (char === "'" || char === '"') && (!in_str || str_char === char)) {
+    // 检查是否是转义的引号
+    let escaped = false;
+    for (let j = i - 1; j >= 0; j--) {
+      if (sql_content[j] === '\\') {
+        escaped = !escaped;
+      } else {
+        break;
+      }
+    }
+
+    if (!escaped) {
+      if (in_str && str_char === char) {
+        return { in_str: false, str_char: '' };
+      } else if (!in_str) {
+        return { in_str: true, str_char: char };
+      }
+    }
+  }
+  return { in_str: in_str, str_char: str_char };
 };
 
 /**
  * 分割SQL语句
  * @private
- * @param {String} sqlContent - SQL内容
+ * @param {string} sql_content - SQL内容
  * @returns {Array} SQL语句数组
  */
-Sql.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;
+Sql.prototype._splitSqlStatements = function (sql_content) {
+  const stmts = [];
+  let in_str = false;
+  let str_char = '';
+  let in_comment = false;
+  let cur_stmt = '';
+
+  for (let i = 0; i < sql_content.length; i++) {
+    const char = sql_content[i];
+    const next_char = i + 1 < sql_content.length ? sql_content[i + 1] : '';
+
+    // 处理注释
+    const line_comment = this._handleLineComment(char, next_char, in_str, in_comment);
+    if (line_comment.skip > 0) {
+      i += line_comment.skip;
+      in_comment = line_comment.in_comment;
+      continue;
+    }
+    in_comment = line_comment.in_comment;
+
+    const block_comment = this._handleBlockComment(char, next_char, in_str, in_comment);
+    if (block_comment.skip > 0) {
+      i += block_comment.skip;
+      in_comment = block_comment.in_comment;
+      continue;
+    }
+    in_comment = block_comment.in_comment;
+
+    if (in_comment) {
+      continue;
+    }
+
+    // 处理字符串
+    const str_res = this._handleString(char, sql_content, i, in_str, str_char, in_comment);
+    in_str = str_res.in_str;
+    str_char = str_res.str_char;
+
+    // 分割语句
+    if (!in_str && !in_comment && char === ';') {
+      stmts.push(cur_stmt.trim());
+      cur_stmt = '';
+    } else {
+      cur_stmt += char;
+    }
+  }
+
+  // 添加最后一个语句（如果有）
+  if (cur_stmt.trim()) {
+    stmts.push(cur_stmt.trim());
+  }
+
+  return stmts;
 };
 
 /**
  * 模型监听函数
- * @param {Object} model - 模型对象
- * @return {Object} 返回监听操作的对象
+ * @param {object} model - 模型对象
+ * @returns {object} 返回监听操作的对象
  */
 Sql.prototype.model = function (model) {
-	const _this = this;
-	return new Proxy(model || {}, {
-		set: function (obj, prop, value) {
-			if (_this.key && prop !== 'length' && !prop.toString().startsWith('__')) {
-				const query = {};
-				const arr = _this.key.split(',');
-				for (const key of arr) {
-					query[key] = obj[key];
-				}
-
-				if (typeof value === "number") {
-					const n = obj[prop] || 0;
-					const cha = value - n;
-					const where = _this.toWhere(query);
-					if (cha > 0) {
-						_this.setSql(where, "`" + prop + "` = `" + prop + "` + " + cha);
-					} else if (cha < 0) {
-						_this.setSql(where, "`" + prop + "` = `" + prop + "` - " + (-cha));
-					} else {
-						_this.setSql(where, "`" + prop + "` = " + value);
-					}
-				} else {
-					const set = {};
-					set[prop] = value;
-					_this.set(query, set, false).catch(err => {
-						this.logger('error', '模型数据更新失败', err);
-					});
-				}
-			}
-			obj[prop] = value;
-			return true;
-		}
-	});
+  const self = this;
+  return new Proxy(model || {}, {
+    set: function (obj, prop, value) {
+      if (self.key && prop !== 'length' && !prop.toString().startsWith('__')) {
+        const query = {};
+        const arr = self.key.split(',');
+        for (const key of arr) {
+          query[key] = obj[key];
+        }
+
+        if (typeof value === 'number') {
+          const n = obj[prop] || 0;
+          const cha = value - n;
+          const where = self.toWhere(query);
+          if (cha > 0) {
+            self.setSql(where, '`' + prop + '` = `' + prop + '` + ' + cha);
+          } else if (cha < 0) {
+            self.setSql(where, '`' + prop + '` = `' + prop + '` - ' + (-cha));
+          } else {
+            self.setSql(where, '`' + prop + '` = ' + value);
+          }
+        } else {
+          const set = {};
+          set[prop] = value;
+          self.set(query, set, false).catch(err => {
+            self.log('error', '模型数据更新失败', err);
+          });
+        }
+      }
+      const new_obj = { ...obj};
+      new_obj[prop] = value;
+      return true;
+    }
+  });
 };
 
 /**
  * 添加或修改数据（存在则修改，不存在则添加）
- * @param {Object|String} where 查询条件
- * @param {Object|String} set 要设置的数据
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise<Object>} 执行结果
+ * @param {object | string} where 查询条件
+ * @param {object | string} set 要设置的数据
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise<object>} 执行结果
  */
 Sql.prototype.addOrSet = async function (where, set, like) {
-	if (!this.table || !where || !set) {
-		throw new Error('表名、条件或数据未设置');
-	}
-	try {
-		let query = where;
-		let body = set;
-		let whereStr;
-
-		if (typeof where === "object") {
-			whereStr = await this.toWhere(where, like);
-		} else {
-			whereStr = where;
-		}
-
-		const count = await this.countSql(whereStr);
-
-		if (count === 0) {
-			let key = "";
-			let value = "";
-
-			if (typeof set === "string") {
-				const arr = set.split(",");
-				for (const o of arr) {
-					const ar = o.split('=');
-					if (ar.length === 2) {
-						key += "," + ar[0];
-						value += "," + ar[1];
-					}
-				}
-			} else {
-				for (const k in set) {
-					if (!Object.prototype.hasOwnProperty.call(set, k)) continue;
-
-					key += "," + escapeId(k);
-					let val = set[k];
-					if (typeof val === "string") {
-						val = val.trim("'");
-					}
-					value += "," + escape(val);
-				}
-			}
-
-			const bl = await this.addSql(key.replace(",", ""), value.replace(",", ""));
-			return bl;
-		} else {
-			if (typeof set === "object") {
-				set = await this.toSet(set);
-			}
-
-			const bl1 = await this.setSql(whereStr, set);
-
-			return bl1;
-		}
-	} catch (err) {
-		this.error = err.message;
-		this.logger('error', '添加或修改数据失败', err);
-	}
-	return 0;
+  if (!this.table || !where || !set) {
+    throw new Error('表名、条件或数据未设置');
+  }
+  try {
+    const where_str = await this._getWhereStr(where, like);
+    const count = await this.countSql(where_str);
+
+    if (count === 0) {
+      return await this._addData(set);
+    } else {
+      return await this._updateData(where_str, set);
+    }
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '添加或修改数据失败', err);
+  }
+  return 0;
 };
 
 module.exports = {
-	Sql
+  Sql
 };