mm_mysql 2.0.1 → 2.0.3

package/sql.js

@@ -33,7 +33,7 @@ class Sql {
 		 * @param {Object} value 值
 		 * @return {String} 返回执行结果
 		 */
-		this.escape = function(value) {
+		this.escape = function (value) {
 			return escape(value);
 		};
 
@@ -42,7 +42,7 @@ class Sql {
 		 * @param {String} key 键
 		 * @return {String} 返回执行结果
 		 */
-		this.escapeId = function(key) {
+		this.escapeId = function (key) {
 			return escapeId(key);
 		};
 
@@ -146,7 +146,7 @@ class Sql {
 /**
  * 清理存储的数据
  */
-Sql.prototype.clear = async function() {
+Sql.prototype.clear = async function () {
 	this.run = run;
 	this.exec = exec;
 	this.sql = "";
@@ -165,7 +165,7 @@ Sql.prototype.clear = async function() {
  * 过滤查询参数
  * @param {Object} query 查询参数
  */
-Sql.prototype.filter = function(query) {
+Sql.prototype.filter = function (query) {
 	var m = this.config.filter;
 	for (var k in m) {
 		var key = m[k];
@@ -183,7 +183,7 @@ Sql.prototype.filter = function(query) {
  * @param {String} view 返回的字段
  * @return {String} 返回查询条件语句
  */
-Sql.prototype.toQuery = function(where, sort, view) {
+Sql.prototype.toQuery = function (where, sort, view) {
 	var sql = "SELECT {1} FROM `{0}`";
 	if (!view) {
 		view = "*";
@@ -208,7 +208,7 @@ Sql.prototype.toQuery = function(where, sort, view) {
  * @param {String} val 用作增加的值集合
  * @return {Promise|Object} 执行结果
  */
-Sql.prototype.addSql = function(key, val) {
+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);
@@ -218,7 +218,7 @@ Sql.prototype.addSql = function(key, val) {
  * @param {String} where  删除条件
  * @return {Promise|Object} 执行结果
  */
-Sql.prototype.delSql = function(where) {
+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);
@@ -229,7 +229,7 @@ Sql.prototype.delSql = function(where) {
  * @param {String} set 修改的键值
  * @return {Promise|Object} 执行结果
  */
-Sql.prototype.setSql = function(where, set) {
+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);
@@ -241,7 +241,7 @@ Sql.prototype.setSql = function(where, set) {
  * @param {String} view 显示的字段
  * @return {Promise|Array} 查询结果数组
  */
-Sql.prototype.getSql = function(where, sort, view) {
+Sql.prototype.getSql = function (where, sort, view) {
 	var sql = this.toQuery(where, sort, view);
 	return this.run(sql);
 };
@@ -251,7 +251,7 @@ Sql.prototype.getSql = function(where, sort, view) {
  * @param {String} where 查询条件
  * @return {Promise|Number} 返回结果总数
  */
-Sql.prototype.countSql = async function(where) {
+Sql.prototype.countSql = async function (where) {
 	var sql = "SELECT count(*) count FROM `" + this.table + "`";
 	if (where) {
 		sql += ' WHERE ' + where;
@@ -271,7 +271,7 @@ Sql.prototype.countSql = async function(where) {
  * @param {String} view 返回的字段
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.getCountSql = async function(where, sort, view) {
+Sql.prototype.getCountSql = async function (where, sort, view) {
 	var list = [];
 	var count = await this.countSql(where);
 	if (count > 0) {
@@ -292,7 +292,7 @@ Sql.prototype.getCountSql = async function(where, sort, view) {
  * @param {String} sort 排序方式
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupMathSql = async function(where, groupby, view, sort, method) {
+Sql.prototype.groupMathSql = async function (where, groupby, view, sort, method) {
 	if (!view) {
 		view = "*"
 	}
@@ -334,7 +334,7 @@ Sql.prototype.groupMathSql = async function(where, groupby, view, sort, method)
  * @param {String} sort 排序方式
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupAvgSql = async function(where, groupby, view, sort) {
+Sql.prototype.groupAvgSql = async function (where, groupby, view, sort) {
 	return await this.groupMathSql(where, groupby, view, sort, "AVG");
 };
 
@@ -346,7 +346,7 @@ Sql.prototype.groupAvgSql = async function(where, groupby, view, sort) {
  * @param {String} sort 排序方式
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupSumSql = async function(where, groupby, view, sort) {
+Sql.prototype.groupSumSql = async function (where, groupby, view, sort) {
 	return await this.groupMathSql(where, groupby, view, sort, "SUM");
 };
 
@@ -357,7 +357,7 @@ Sql.prototype.groupSumSql = async function(where, groupby, view, sort) {
  * @param {String} view 返回的字段
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupCountSql = async function(where, groupby, view, sort) {
+Sql.prototype.groupCountSql = async function (where, groupby, view, sort) {
 	return await this.groupMathSql(where, groupby, view, sort, "COUNT");
 };
 
@@ -370,7 +370,7 @@ Sql.prototype.groupCountSql = async function(where, groupby, view, sort) {
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupMath = async function(query, groupby, view, sort, method, like) {
+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);
 };
@@ -383,7 +383,7 @@ Sql.prototype.groupMath = async function(query, groupby, view, sort, method, lik
  * @param {String} sort 排序方式
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupAvg = async function(query, groupby, view, sort) {
+Sql.prototype.groupAvg = async function (query, groupby, view, sort) {
 	return await this.groupMath(query, groupby, view, sort, "AVG");
 };
 
@@ -395,7 +395,7 @@ Sql.prototype.groupAvg = async function(query, groupby, view, sort) {
  * @param {String} sort 排序方式
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupSum = async function(query, groupby, view, sort) {
+Sql.prototype.groupSum = async function (query, groupby, view, sort) {
 	return await this.groupMath(query, groupby, view, sort, "SUM");
 };
 
@@ -406,7 +406,7 @@ Sql.prototype.groupSum = async function(query, groupby, view, sort) {
  * @param {String} view 返回的字段
  * @return {Promise|Object} 查询到的内容列表和符合条件总数
  */
-Sql.prototype.groupCount = async function(query, groupby, view, sort) {
+Sql.prototype.groupCount = async function (query, groupby, view, sort) {
 	return await this.groupMath(query, groupby, view, sort, "COUNT");
 };
 
@@ -417,7 +417,7 @@ Sql.prototype.groupCount = async function(query, groupby, view, sort) {
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {String} where格式sql语句字符串
  */
-Sql.prototype.toWhere = function(obj, like) {
+Sql.prototype.toWhere = function (obj, like) {
 	var where = "";
 	if (like === undefined) {
 		like = this.like;
@@ -425,7 +425,7 @@ Sql.prototype.toWhere = function(obj, like) {
 	if (like) {
 		for (var k in obj) {
 			var val = obj[k];
-			if (val && typeof(val) === "string") {
+			if (val && typeof (val) === "string") {
 				val = val.trim("'");
 			}
 			val = escape(val);
@@ -442,7 +442,7 @@ Sql.prototype.toWhere = function(obj, like) {
 				where += " and " + escapeId(k.replace('_has', "")) + " in (" + vals.join(',') + ")";
 			} else if (k.endWith('_like')) {
 				where += " and " + escapeId(k.replace('_like', "")) + " LIKE '%" + val.trim("'") + "%'";
-			} else if (typeof(val) === "string" && !/^[0-9]+$/.test(val)) {
+			} else if (typeof (val) === "string" && !/^[0-9]+$/.test(val)) {
 				where += " and " + escapeId(k) + " LIKE '%" + val.trim("'") + "%'";
 			} else {
 				where += " and " + escapeId(k) + " = " + val;
@@ -451,7 +451,7 @@ Sql.prototype.toWhere = function(obj, like) {
 	} else {
 		for (var k in obj) {
 			var val = obj[k];
-			if (val && typeof(val) === "string") {
+			if (val && typeof (val) === "string") {
 				val = val.trim("'");
 			}
 			val = escape(val);
@@ -481,24 +481,30 @@ Sql.prototype.toWhere = function(obj, like) {
  * @param {Object} obj 用作拼接的对象
  * @return {String} set格式sql语句字符串
  */
-Sql.prototype.toSet = function(obj) {
+Sql.prototype.toSet = function (obj) {
 	var set = "";
-	for (var k in obj) {
-		var val = obj[k];
-		if (val && typeof(val) == "string") {
+	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.endWith('_add')) {
-			var k2 = escapeId(k.replace('_add', ""));
+			const k2 = escapeId(k.replace('_add', ""));
 			set += "," + k2 + " = " + k2 + " + " + val;
 		} else if (k.endWith('_del')) {
-			var k3 = escapeId(k.replace('_del', ""));
+			const k3 = escapeId(k.replace('_del', ""));
 			set += "," + k3 + " = " + k3 + " - " + val;
 		} else {
 			set += "," + escapeId(k) + " = " + val;
 		}
 	}
+
 	return set.replace(",", "");
 };
 
@@ -507,20 +513,31 @@ Sql.prototype.toSet = function(obj) {
  * @param {Object} item 用作添加的键值
  * @return {String} sql语句
  */
-Sql.prototype.toAddSql = function(item) {
-	var key = "";
-	var value = "";
-	for (var k in item) {
+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);
-		var val = item[k];
-		if (val && typeof(val) == "string") {
+		let val = item[k];
+		if (typeof val === "string") {
 			val = val.trim("'");
 		}
 		value += "," + escape(val);
 	}
-	var sql = "INSERT INTO `{0}` ({1}) VALUES ({2});";
-	return sql.replace("{0}", this.table).replace("{1}", key.replace(",", "")).replace("{2}", value.replace(",",
-		""));
+
+	const sql = "INSERT INTO `{0}` ({1}) VALUES ({2});"
+		.replace("{0}", this.table)
+		.replace("{1}", key.replace(",", ""))
+		.replace("{2}", value.replace(",", ""));
+
+	return sql;
 };
 
 /**
@@ -529,10 +546,15 @@ Sql.prototype.toAddSql = function(item) {
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {String} sql语句
  */
-Sql.prototype.toDelSql = function(query, like) {
-	var where = this.toWhere(query, like);
-	var sql = "DELETE FROM `{0}` WHERE {1};";
-	return sql.replace("{0}", this.table).replace("{1}", where);
+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;
 };
 
 /**
@@ -542,11 +564,17 @@ Sql.prototype.toDelSql = function(query, like) {
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {String} sql语句
  */
-Sql.prototype.toSetSql = function(query, item, like) {
-	var where = this.toWhere(query, like);
-	var set = this.toSet(item);
-	var sql = "UPDATE `{0}` SET {1} WHERE {2};";
-	return sql.replace("{0}", this.table).replace("{1}", set).replace("{2}", where);
+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;
 };
 
 /**
@@ -557,30 +585,42 @@ Sql.prototype.toSetSql = function(query, item, like) {
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {String} sql语句
  */
-Sql.prototype.toGetSql = function(query, sort, view, like) {
-	var where = this.toWhere(query, like);
-	var sql = this.toQuery(where, sort, view);
-	return sql;
+Sql.prototype.toGetSql = function (query, sort, view, like) {
+	const where = this.toWhere(query, like);
+	return this.toQuery(where, sort, view);
 };
+
 /* ===  传入对象操作  === */
 /**
  * 增加数据
  * @param {Object} body 添加的对象
  * @return {Promise|Object} 执行结果
  */
-Sql.prototype.add = async function(body) {
-	await $.eventer.run("mysql_add_before:" + this.table, {
-		body
-	});
-	var sql = this.toAddSql(body);
-	var bl = await this.exec(sql);
-	await $.eventer.run("mysql_add_after:" + this.table, {
-		body,
-		sql: this.sql,
-		error: this.error,
-		bl
-	});
-	return bl
+Sql.prototype.add = async function (body) {
+	if (!this.table || !body || typeof body !== 'object') {
+		throw new Error('表名或数据未设置');
+	}
+	try {
+		// 触发前置事件
+		if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+			await $.eventer.run("mysql_add_before:" + this.table, { body });
+		}
+
+		const sql = this.toAddSql(body);
+		this.sql = sql;
+		const bl = await this.exec(sql);
+
+		// 触发后置事件
+		if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+			await $.eventer.run("mysql_add_after:" + this.table, { body, sql: this.sql, error: this.error, bl });
+		}
+
+		return bl;
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`添加数据失败: ${err.message}`);
+		throw err;
+	}
 };
 
 /**
@@ -589,21 +629,31 @@ Sql.prototype.add = async function(body) {
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {Promise|Object} 执行结果
  */
-Sql.prototype.del = async function(query, like) {
-	await $.eventer.run("mysql_del_before:" + this.table, {
-		query,
-		like
-	});
-	var sql = this.toDelSql(query, like);
-	var bl = await this.exec(sql);
-	await $.eventer.run("mysql_del_after:" + this.table, {
-		query,
-		like,
-		sql: this.sql,
-		error: this.error,
-		bl
-	});
-	return bl
+Sql.prototype.del = async function (query, like) {
+	if (!this.table) {
+		throw new Error('表名未设置');
+	}
+	try {
+		// 触发前置事件
+		if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+			await $.eventer.run("mysql_del_before:" + this.table, { query, like });
+		}
+
+		const sql = this.toDelSql(query, like);
+		this.sql = sql;
+		const bl = await this.exec(sql);
+
+		// 触发后置事件
+		if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+			await $.eventer.run("mysql_del_after:" + this.table, { query, like, sql: this.sql, error: this.error, bl });
+		}
+
+		return bl;
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`删除数据失败: ${err.message}`);
+		throw err;
+	}
 };
 
 /**
@@ -613,111 +663,120 @@ Sql.prototype.del = async function(query, like) {
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {Promise|Object} 执行结果
  */
-Sql.prototype.set = async function(query, body, like) {
-	await $.eventer.run("mysql_set_before:" + this.table, {
-		query,
-		body,
-		like,
-		page: this.page,
-		size: this.size
-	});
-	var sql = this.toSetSql(query, body, like);
-	var bl = await this.exec(sql);
-	await $.eventer.run("mysql_set_after:" + this.table, {
-		query,
-		body,
-		like,
-		page: this.page,
-		size: this.size,
-		sql: this.sql,
-		error: this.error,
-		bl
-	});
-	return bl
+Sql.prototype.set = async function (query, body, like) {
+	if (!this.table || !body || typeof body !== 'object') {
+		throw new Error('表名或数据未设置');
+	}
+	try {
+		// 触发前置事件
+		if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+			await $.eventer.run("mysql_set_before:" + this.table, { query, body, like, page: this.page, size: this.size });
+		}
+
+		const sql = this.toSetSql(query, body, like);
+		this.sql = sql;
+		const bl = await this.exec(sql);
+
+		// 触发后置事件
+		if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+			await $.eventer.run("mysql_set_after:" + this.table, { query, body, like, page: this.page, size: this.size, sql: this.sql, error: this.error, bl });
+		}
+
+		return bl;
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`修改数据失败: ${err.message}`);
+		throw err;
+	}
 };
 
 /**
  * 添加或修改
- * @param {String} where 查询条件
- * @param {String} set 修改的键值
+ * @param {String|Object} where 查询条件
+ * @param {String|Object} set 修改的键值
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
  * @return {Promise|Object} 执行结果
  */
-Sql.prototype.addOrSetSql = async function(where, set, like) {
-	if (!where || !set) {
-		return -1;
-	}
-	var query = where;
-	var body = set;
-	if (typeof(where) === "object") {
-		where = await this.toWhere(where, like);
+Sql.prototype.addOrSetSql = async function (where, set, like) {
+	if (!this.table || !where || !set) {
+		throw new Error('表名、条件或数据未设置');
 	}
-	var count = await this.countSql(where);
-	if (count === 0) {
-		var key = "";
-		var value = "";
-		if (typeof(set) === "string") {
-			var arr = set.split(",");
-			for (var i = 0; i < arr.length; i++) {
-				var o = arr[i];
-				var ar = o.split('=');
-				if (ar.length === 2) {
-					key += "," + ar[0];
-					value += "," + ar[1];
+	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 {
+				// 触发前置事件
+				if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof body === "object") {
+					await $.eventer.run("mysql_add_before:" + this.table, { body });
+				}
+
+				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(",", ""));
+
+			// 触发后置事件
+			if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof body === "object") {
+				await $.eventer.run("mysql_add_after:" + this.table, { body, sql: this.sql, error: this.error, bl });
+			}
+
+			return bl;
 		} else {
-			if (typeof(body) === "object") {
-				await $.eventer.run("mysql_add_before:" + this.table, {
-					body
-				});
+			// 触发前置事件
+			if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof set === "object") {
+				await $.eventer.run("mysql_set_before:" + this.table, { query, body, like, page: this.page, size: this.size, sql: this.sql });
 			}
-			for (var k in set) {
-				key += "," + escapeId(k);
-				var val = set[k];
-				if (val && typeof(val) === "string") {
-					val = val.trim("'");
-				}
-				value += "," + escape(val);
+
+			if (typeof set === "object") {
+				set = await this.toSet(set);
 			}
-		}
-		var bl = await this.addSql(key.replace(",", ""), value.replace(",", ""));
-		if (typeof(body) === "object") {
-			await $.eventer.run("mysql_add_after:" + this.table, {
-				body,
-				sql: this.sql,
-				error: this.error,
-				bl
-			});
-		}
-		return bl
-	}
 
-	if (typeof(set) === "object") {
-		await $.eventer.run("mysql_set_before:" + this.table, {
-			query,
-			body,
-			like,
-			page: this.page,
-			size: this.size,
-			sql: this.sql
-		});
-		set = await this.toSet(set);
-	}
-	var bl1 = await this.setSql(where, set);
-	if (typeof(body) === "object") {
-		await $.eventer.run("mysql_set_after:" + this.table, {
-			query,
-			body,
-			like,
-			page: this.page,
-			size: this.size,
-			sql: this.sql,
-			error: this.error,
-			bl: bl1
-		});
+			const bl1 = await this.setSql(whereStr, set);
+
+			// 触发后置事件
+			if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof body === "object") {
+				await $.eventer.run("mysql_set_after:" + this.table, { query, body, like, page: this.page, size: this.size, sql: this.sql, error: this.error, bl: bl1 });
+			}
+
+			return bl1;
+		}
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`添加或修改数据失败: ${err.message}`);
+		throw err;
 	}
-	return bl1
 };
 
 /**
@@ -726,129 +785,201 @@ Sql.prototype.addOrSetSql = async function(where, set, like) {
  * @param {String} sort 排序
  * @param {String} view 返回的字段
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {Number} timeout 超时时间（毫秒），默认30000ms
  * @return {Promise|Array} 查询结果
  */
-Sql.prototype.get = async function(query, sort, view, like) {
-	await $.eventer.run("mysql_get_before:" + this.table, {
-		query,
-		sort,
-		view,
-		like,
-		page: this.page,
-		size: this.size
-	});
-	var sql = this.toGetSql(query, sort, view, like);
-	var list = await this.run(sql);
-	await $.eventer.run("mysql_get_after:" + this.table, {
-		query,
-		sort,
-		view,
-		like,
-		page: this.page,
-		size: this.size,
-		sql: this.sql,
-		error: this.error,
-		list
-	});
-	return list
+Sql.prototype.get = async function (query, sort, view, like, timeout = 30000) {
+	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 () => {
+				// 安全触发事件，避免事件系统问题影响核心功能
+				if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+					try {
+						// 添加超时保护的事件触发
+						await Promise.race([
+							$.eventer.run("mysql_get_before:" + this.table, {
+								query,
+								sort,
+								view,
+								like,
+								page: this.page,
+								size: this.size
+							}),
+							new Promise((_, reject) => setTimeout(() => reject(new Error('事件处理超时')), 5000))
+						]);
+					} catch (eventError) {
+						$.log.warn(`事件处理失败，但不影响查询: ${eventError.message}`);
+					}
+				}
+
+				// 生成SQL并执行
+				const sql = this.toGetSql(query, sort, view, like);
+				this.sql = sql;
+				const list = await this.run(sql);
+
+				// 安全触发后置事件
+				if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+					try {
+						// 添加超时保护的事件触发
+						await Promise.race([
+							$.eventer.run("mysql_get_after:" + this.table, {
+								query,
+								sort,
+								view,
+								like,
+								page: this.page,
+								size: this.size,
+								sql: this.sql,
+								error: this.error,
+								list
+							}),
+							new Promise((_, reject) => setTimeout(() => reject(new Error('事件处理超时')), 5000))
+						]);
+					} catch (eventError) {
+						$.log.warn(`事件处理失败，但不影响查询返回: ${eventError.message}`);
+					}
+				}
+
+				return list;
+			})(),
+			timeoutPromise
+		]);
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`查询数据失败: ${err.message}`, { sql: this.sql });
+		throw err;
+	}
 };
 
 /**
- * 查询一条数据
+ * 查询单条数据
  * @param {Object} query 查询条件
  * @param {String} sort 排序
  * @param {String} view 返回的字段
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Array} 查询结果
+ * @param {Number} timeout 超时时间（毫秒），默认30000ms
+ * @return {Promise|Object|null} 查询结果
  */
-Sql.prototype.getObj = async function(query, sort, view, like) {
-	await $.eventer.run("mysql_getObj_before:" + this.table, {
-		query,
-		sort,
-		view,
-		like
-	});
+Sql.prototype.getObj = async function (query, sort, view, like, timeout = 30000) {
+	try {
+		// 保存当前分页设置
+		const oldPage = this.page;
+		const oldSize = this.size;
 
-	this.page = 1;
-	this.size = 1;
-	var key = this.key;
-	if (key) {
-		if (view && view.indexOf(key) === -1 && view.indexOf('*') === -1) {
-			view += "," + escapeId(key);
-		}
-	}
-	var sql = this.toGetSql(query, sort, view, like);
-	var list = await this.run(sql);
-
-	var obj = null;
-	if (list.length > 0) {
-		obj = list[0];
-		if (key) {
-			obj = this.model(obj);
+		// 设置为只查询一条
+		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);
+			}
 		}
-	}
 
-	await $.eventer.run("mysql_getObj_after:" + this.table, {
-		query,
-		sort,
-		view,
-		like,
-		sql: this.sql,
-		error: this.error,
-		obj
-	});
-	return obj;
+		return obj;
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`查询单条数据失败: ${err.message}`, { sql: this.sql });
+		throw err;
+	}
 };
 
 /**
- * 添加或修改
- * @param {Object} query 查询条件集合
- * @param {Object} set 修改的键值
+ * 统计记录数
+ * @param {Object} query 查询条件
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 执行结果
+ * @param {Number} timeout 超时时间（毫秒），默认30000ms
+ * @return {Promise|Number} 记录数
  */
-Sql.prototype.addOrSet = async function(query, set, like) {
-	await $.eventer.run("mysql_addOrSet_before:" + this.table, {
-		query,
-		set,
-		like,
-		page: this.page,
-		size: this.size
-	});
-	var bl = await this.addOrSetSql(query, set, like);
-	await $.eventer.run("mysql_addOrSet_after:" + this.table, {
-		query,
-		set,
-		like,
-		page: this.page,
-		size: this.size,
-		sql: this.sql,
-		error: this.error,
-		bl
-	});
-	return bl
-};
+Sql.prototype.count = async function (query, like, timeout = 30000) {
+	if (!this.table) {
+		throw new Error('表名未设置');
+	}
 
-/**
- * 查询符合结果总数
- * @param {Object} query 查询条件集合
- * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Number} 查询结果
- */
-Sql.prototype.count = function(query, like) {
-	return this.countSql(this.toWhere(query, like));
+	try {
+		// 添加超时控制
+		const timeoutPromise = new Promise((_, reject) => {
+			setTimeout(() => reject(new Error('统计操作超时')), timeout);
+		});
+
+		return await Promise.race([
+			(async () => {
+				// 安全触发事件
+				if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+					try {
+						await Promise.race([
+							$.eventer.run("mysql_count_before:" + this.table, { query, like }),
+							new Promise((_, reject) => setTimeout(() => reject(new Error('事件处理超时')), 5000))
+						]);
+					} catch (eventError) {
+						$.log.warn(`事件处理失败，但不影响统计: ${eventError.message}`);
+					}
+				}
+
+				// 正确生成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;
+
+				// 安全触发事件
+				if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function') {
+					try {
+						await Promise.race([
+							$.eventer.run("mysql_count_after:" + this.table, {
+								query,
+								like,
+								sql: this.sql,
+								error: this.error,
+								total
+							}),
+							new Promise((_, reject) => setTimeout(() => reject(new Error('事件处理超时')), 5000))
+						]);
+					} catch (eventError) {
+						$.log.warn(`事件处理失败，但不影响统计返回: ${eventError.message}`);
+					}
+				}
+
+				return total;
+			})(),
+			timeoutPromise
+		]);
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`统计数据失败: ${err.message}`, { sql: this.sql });
+		throw err;
+	}
 };
 
 /**
- * 查询数据并返回符合条件总数
+ * 统计记录数(别名)
  * @param {Object} query 查询条件
- * @param {String} sort 排序
- * @param {String} view 返回的字段
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 查询到的内容列表和符合条件总数
+ * @param {Number} timeout 超时时间（毫秒），默认30000ms
+ * @return {Promise|Number} 记录数
  */
-Sql.prototype.getCount = async function(query, sort, view, like) {
-	return this.getCountSql(this.toWhere(query, like), sort, view);
+Sql.prototype.getCount = async function (query, like, timeout = 30000) {
+	return await this.count(query, like, timeout);
 };
 
 /* ===  传入数组操作  === */
@@ -856,44 +987,250 @@ Sql.prototype.getCount = async function(query, sort, view, like) {
  * 添加多条数据
  * @param {Array} list 对象数组
  * @param {Boolean} lock 是否锁定
- * @return {Promise|Object} 执行结果
+ * @param {Number} batchSize 每批处理数量，默认100
+ * @param {Number} timeout 超时时间（毫秒），默认60000
+ * @return {Promise<Object>} 执行结果
  */
-Sql.prototype.addList = function(list, lock = true) {
-	var sql = lock ? "BEGIN;\r\n" : "\r\n";
-	var len = list.length;
-	for (var i = 0; i < len; i++) {
-		sql += this.toAddSql(list[i]) + "\r\n";
+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);
+				$.log.info(`开始分批添加数据，共${totalBatches}批，每批${batchSize}条`);
+
+				// 分批执行，每批一个单独的批量插入语句
+				let finalResult = null;
+				for (let i = 0; i < totalBatches; i++) {
+					const batch = list.slice(i * batchSize, (i + 1) * batchSize);
+					$.log.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);
+						})
+					]);
+				}
+
+				$.log.success(`批量添加数据完成，共${list.length}条`);
+				return finalResult;
+			})(),
+			timeoutPromise
+		]);
+	} catch (error) {
+		$.log.error(`[${this.constructor.name}] [addList]`, '批量添加数据失败', {
+			error: error.message,
+			table: this.table,
+			list_length: list.length
+		});
+		throw error;
 	}
-	sql += lock ? "COMMIT;" : "";
-	return this.exec(sql);
 };
+
+/**
+ * 生成批量插入SQL语句
+ * @param {Array} list 数据列表
+ * @return {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;
+};
+
 /**
  * 删除多条数据
  * @param {Array} list 对象数组
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 执行结果
+ * @param {Number} batchSize 每批处理数量，默认100
+ * @param {Number} timeout 超时时间（毫秒），默认60000
+ * @return {Promise<Object>} 执行结果
  */
-Sql.prototype.delList = function(list, like) {
-	var sql = "";
-	var len = list.length;
-	for (var i = 0; i < len; i++) {
-		sql += this.toDelSql(list[i].query, like);
+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);
+				$.log.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);
+						$.log.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);
+						$.log.error(`批量删除数据失败，事务已回滚: ${error.message}`);
+					} catch (rollbackError) {
+						$.log.error(`批量删除数据失败，事务回滚也失败: ${rollbackError.message}`);
+					}
+					throw error;
+				}
+
+				$.log.success(`批量删除数据完成，共${list.length}条`);
+				return finalResult;
+			})(),
+			timeoutPromise
+		]);
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`批量删除数据失败: ${err.message}`);
+		throw err;
 	}
-	return this.exec(sql);
 };
+
 /**
  * 修改多条数据
  * @param {Array} list 对象数组
  * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
- * @return {Promise|Object} 执行结果
+ * @param {Number} batchSize 每批处理数量，默认100
+ * @param {Number} timeout 超时时间（毫秒），默认60000
+ * @return {Promise<Object>} 执行结果
  */
-Sql.prototype.setList = function(list, like) {
-	var sql = "";
-	var len = list.length;
-	for (var i = 0; i < len; i++) {
-		sql += this.toSetSql(list[i].query, list[i].item, like);
+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);
+				$.log.info(`开始分批修改数据，共${totalBatches}批，每批${batchSize}条`);
+
+				let finalResult = null;
+
+				// 逐条处理记录，保持简单可靠
+				for (let i = 0; i < list.length; i++) {
+					const item = list[i];
+					$.log.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;
+		$.log.error(`批量修改数据失败: ${error.message}`);
+		throw error;
 	}
-	return this.exec(sql);
 };
 
 /* 辅助类 */
@@ -901,35 +1238,39 @@ Sql.prototype.setList = function(list, like) {
  * 判断SQL模板是否包含某些参数
  * @param {Object} paramDt 参数集合
  * @param {Object} sqlDt sql模板集合
- * @return {Bool} 有则返回true，没有则返回false
+ * @return {Boolean} 有则返回true，没有则返回false
  */
-Sql.prototype.has_param = function(paramDt, sqlDt) {
-	var bl = false;
-	for (var key in sqlDt) {
-		var value = paramDt[key];
+Sql.prototype.has_param = 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 !== "") {
-			bl = true;
-			break;
+			return true;
 		}
 	}
-	return bl;
+	return false;
 };
 
 /**
  * 判断某些参数是否没有SQL模板
  * @param {Object} paramDt 参数集合
  * @param {Object} sqlDt sql模板集合
- * @return {Bool} 没有模板则返回名称，都有则返回undefined
+ * @return {String|undefined} 没有模板则返回名称，都有则返回undefined
  */
-Sql.prototype.not_param = function(paramDt, sqlDt) {
-	var name;
-	for (var key in paramDt) {
+Sql.prototype.not_param = function (paramDt, sqlDt) {
+	if (!paramDt || !sqlDt) {
+		return undefined;
+	}
+	for (const key in paramDt) {
+		if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
 		if (!sqlDt[key]) {
-			name = key;
-			break;
+			return key;
 		}
 	}
-	return name;
+	return undefined;
 };
 
 /**
@@ -938,11 +1279,15 @@ Sql.prototype.not_param = function(paramDt, sqlDt) {
  * @param {Object} sqlDt sql模板集合
  * @return {Object} 返回过滤后的参数集合
  */
-Sql.prototype.filter_param = function(paramDt, sqlDt) {
-	var dt = [];
-	for (var key in paramDt) {
+Sql.prototype.filter_param = 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.Add(key, o.Value);
+			dt[key] = paramDt[key];
 		}
 	}
 	return dt;
@@ -954,100 +1299,99 @@ Sql.prototype.filter_param = function(paramDt, sqlDt) {
  * @param {Object} sqlDt 模板集合
  * @return {String} 返回拼接的查询参数
  */
-Sql.prototype.tpl_query = function(paramDt, sqlDt) {
-	var sql = "";
+Sql.prototype.tpl_query = function (paramDt, sqlDt) {
+	let sql = "";
+	if (!paramDt) {
+		return sql;
+	}
+	const l = this.config.separator;
 	if (sqlDt) {
-		var l = this.config.separator;
 		if (l) {
-			for (var key in paramDt) {
-				var value = paramDt[key] + "";
-				var arr = value.split(l);
-				var tpl = sqlDt[key];
+			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，则增加多条件
-						var sl = "(";
-						var len = arr.length;
-						for (var i = 0; i < len; i++) {
-							var val = arr[i];
-							if (val && typeof(val) == "string") {
-								val = val.trim("'");
-							}
-							sl += " || " + tpl.replaceAll("{0}", escape(val).trim("'"));
+						let subConditions = [];
+						for (const val of arr) {
+							const cleanVal = typeof val === "string" ? val.trim("'") : val;
+							subConditions.push(tpl.replaceAll("{0}", escape(cleanVal).trim("'")));
 						}
-						sl = sl.replace(" || ", "") + ")";
-						sql += " && " + sl;
+						conditions.push("(" + subConditions.join(" || ") + ")");
 					} else {
-						if (value && typeof(value) == "string") {
-							value = value.trim("'");
-						}
-						sql += " && " + tpl.replaceAll("{0}", escape(value).trim("'"));
+						const cleanVal = typeof value === "string" ? value.trim("'") : value;
+						conditions.push(tpl.replaceAll("{0}", escape(cleanVal).trim("'")));
 					}
 				} else {
 					if (arr.length > 1) {
 						// 如果数量大于0，则增加多条件
-						var sl = "(";
-						var len = arr.length;
-						for (var i = 0; i < len; i++) {
-							var val = arr[i];
-							if (val && typeof(val) == "string") {
-								val = val.trim("'");
-							}
-							sl += " || " + escapeId(key) + " = " + escape(val);
+						let subConditions = [];
+						for (const val of arr) {
+							subConditions.push(escapeId(key) + " = " + escape(val));
 						}
-						sl = sl.replace(" || ", "") + ")";
-						sql += " && " + sl;
+						conditions.push("(" + subConditions.join(" || ") + ")");
 					} else {
-						if (value && typeof(value) == "string") {
-							value = value.trim("'");
-						}
-						sql += " && " + escapeId(key) + " = " + escape(value);
+						const cleanVal = typeof value === "string" ? value.trim("'") : value;
+						conditions.push(escapeId(key) + " = " + escape(cleanVal));
 					}
 				}
 			}
+			sql = conditions.join(" && ");
 		} else {
-			for (var key in paramDt) {
-				var value = paramDt[key];
-				if (value && typeof(value) == "string") {
+			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]) {
-					sql += " && " + sqlDt[key].replaceAll("{0}", value.trim("'"));
+					conditions.push(sqlDt[key].replaceAll("{0}", value.trim("'")));
 				} else {
-					sql += " && " + escapeId(key) + " = " + value;
+					conditions.push(escapeId(key) + " = " + value);
 				}
 			}
+			sql = conditions.join(" && ");
 		}
 	} else {
 		// 如果没有模板，则直接拼接参数
-		var l = this.config.separator;
 		if (l) {
 			// 使用分隔数组拼接
-			for (var key in paramDt) {
-				var value = paramDt[key];
-				var arr = value.split(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，则增加多条件
-					var sl = "(";
-					var len = arr.length;
-					for (var i = 0; i < len; i++) {
-						sl += " || " + escapeId(key) + " = " + escape(arr[i]);
+					let subConditions = [];
+					for (const val of arr) {
+						subConditions.push(escapeId(key) + " = " + escape(val));
 					}
-					sl = sl.replace(" || ", "") + ")";
-					sql += " && " + sl;
+					conditions.push("(" + subConditions.join(" || ") + ")");
 				} else {
-					sql += " && " + escapeId(key) + " = " + escape(value);
+					conditions.push(escapeId(key) + " = " + escape(value));
 				}
 			}
+			sql = conditions.join(" && ");
 		} else {
 			// 直接拼接
-			for (var key in paramDt) {
-				sql += " && " + escapeId(key) + " = " + escape(paramDt[key]);
+			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.replace(" && ", "");
+	return sql;
 };
 
 /**
@@ -1056,63 +1400,227 @@ Sql.prototype.tpl_query = function(paramDt, sqlDt) {
  * @param {Object} sqlDt 模板集合
  * @return {String} 返回拼接的查询参数
  */
-Sql.prototype.tpl_body = function(paramDt, sqlDt) {
-	var sql = "";
-	if (!sqlDt || sqlDt.length === 0) {
-		for (var key in paramDt) {
-			sql += ", " + escapeId(key) + " = " + escape(val[key]);
+Sql.prototype.tpl_body = 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 (var key in paramDt) {
-			var value = escape(paramDt[key]);
+		for (const key in paramDt) {
+			if (!Object.prototype.hasOwnProperty.call(paramDt, key)) continue;
+			const value = escape(paramDt[key]);
 			if (sqlDt[key]) {
-				sql += ", " + sqlDt[key].replace("{0}", value).replace('+ -', '- ').replace('- -', '+ ');
+				parts.push(" " + sqlDt[key].replace("{0}", value).replace(/\+ -/g, "- ").replace(/- -/g, "+ "));
 			} else {
-				sql += ", " + escapeId(key) + " = " + value;
+				parts.push(" " + escapeId(key) + " = " + value);
 			}
 		}
 	}
-	return sql.replace(", ", "");
+	return parts.join(",").replace(", ", "");
 };
 
 /**
- * 构建实体模型
- * @param {Object} obj 模型对象
+ * 从SQL文件加载数据库结构和数据
+ * @param {String} file - SQL文件路径
+ * @returns {Promise<boolean>} 是否加载成功
+ */
+Sql.prototype.load = async function (file) {
+  try {
+    // 记录操作日志
+    if (this.config && this.config.debug) {
+      $.log.debug(`[${this.constructor.name}] [load] 开始从文件加载数据库`, { 
+        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) {
+        $.log.info(`[${this.constructor.name}] [load] 数据库加载成功`, { 
+          file: file,
+          statementCount: sqlStatements.length
+        });
+      }
+      
+      return true;
+    } catch (err) {
+      // 回滚事务
+      await this.exec('ROLLBACK').catch(rollbackErr => {
+        $.log.error(`[${this.constructor.name}] [load] 事务回滚失败`, {
+          error: rollbackErr.message
+        });
+      });
+      
+      throw err;
+    }
+  } catch (error) {
+    // 记录错误日志
+    $.log.error(`[${this.constructor.name}] [load] 数据库加载失败`, {
+      error: error.message,
+      file: file
+    });
+    
+    // 抛出错误
+    throw error;
+  }
+};
+
+/**
+ * 分割SQL语句
+ * @private
+ * @param {String} sqlContent - SQL内容
+ * @returns {Array} SQL语句数组
+ */
+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;
+};
+
+/**
+ * 模型监听函数
+ * @param {Object} model - 模型对象
  * @return {Object} 返回监听操作的对象
  */
-Sql.prototype.model = function(model) {
-	var _this = this;
-	return new Proxy(model, {
-		set: function(obj, prop, value) {
-			if (_this.key) {
-				var query = {};
-				var arr = _this.key.split(',');
-				for (var i = 0; i < arr.length; i++) {
-					var key = arr[i];
+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") {
-					var n = obj[prop];
-					var cha = value - n;
-					var where = _this.toWhere(query);
+
+				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);
+						_this.setSql(where, "`" + prop + "` = `" + prop + "` + " + cha);
 					} else if (cha < 0) {
-						_this.setSql(where, "`" + prop + "` = `" +
-							prop + "` - " + (-cha));
+						_this.setSql(where, "`" + prop + "` = `" + prop + "` - " + (-cha));
 					} else {
-						_this.setSql(where, "`" + prop + "` = " +
-							value);
+						_this.setSql(where, "`" + prop + "` = " + value);
 					}
 				} else {
-					var set = {};
+					const set = {};
 					set[prop] = value;
-					_this.set(query, set, false);
+					_this.set(query, set, false).catch(err => {
+						$.log.error(`模型数据更新失败: ${err.message}`);
+					});
 				}
 			}
 			obj[prop] = value;
-			return obj;
+			return true;
 		}
 	});
 };