mm_mysql 2.4.2 → 2.4.4

package/index.js

@@ -124,8 +124,6 @@ Mysql.prototype.open = async function () {
     // 测试连接池连接
     let conn = await this._pool.getConnection();
     conn.release();
-
-    this.log('info', '数据库连接池创建成功');
     return true;
   } catch (error) {
     this.log('error', '数据库连接池创建失败', error);
@@ -195,6 +193,7 @@ Mysql.prototype.run = async function (sql, params = []) {
     let [rows] = await conn.query(sql, params);
     ret = rows;
   } catch (err) {
+    console.error('SQL执行失败', err);
     this.sql = err.sql;
     this.error = {
       code: err.errno,
@@ -233,7 +232,7 @@ Mysql.prototype.exec = async function (sql, params = []) {
     let [result] = await conn.execute(sql, params);
     ret = result.insertId || result.affectedRows || result.changedRows || 1;
   } catch (error) {
-    this.log('error', 'SQL执行失败', error);
+    console.error('SQL执行失败', error);
     this.sql = error.sql;
     this.error = {
       code: error.errno,

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "mm_mysql",
-	"version": "2.4.2",
+	"version": "2.4.4",
 	"description": "这是超级美眉mysql帮助函数模块，用于便捷操作mysql，使用await方式，可以避免嵌套函数",
 	"main": "index.js",
 	"dependencies": {
-		"mm_expand": "^2.3.1",
+		"mm_expand": "^2.3.4",
 		"mysql2": "^3.22.3",
 		"sqlstring": "^2.3.3"
 	},
@@ -36,8 +36,8 @@
 		"node": ">=12.0.0"
 	},
 	"devDependencies": {
-		"eslint": "^10.2.1",
-		"eslint-plugin-jsdoc": "^62.9.0",
+		"eslint": "^10.4.0",
+		"eslint-plugin-jsdoc": "^63.0.0",
 		"mm_eslint": "^1.7.1"
 	}
 }

package/sql.js

@@ -301,7 +301,7 @@ Sql.prototype.getCountSql = async function (where, sort, view) {
  * @returns {Promise | object} 查询到的内容列表和符合条件总数
  */
 Sql.prototype.groupMathSql = async function (where, groupby, view, sort, method) {
-  const view_val = view || '*';
+  let view_val = view || '*';
   var view_str = '';
   if (view_val.indexOf(',') !== -1) {
     var arr = view_val.split(',');
@@ -428,13 +428,13 @@ Sql.prototype.groupCount = async function (query, groupby, view, sort) {
  */
 Sql.prototype.toWhere = function (obj, like) {
   var where = '';
-  const use_like = like === undefined ? this.like : like;
+  let use_like = like === undefined ? this.like : like;
   if (use_like) {
     where = this._buildLikeWhere(obj);
   } else {
     where = this._buildExactWhere(obj);
   }
-  return where.replace(' and ', '');
+  return where.replace(/^ and /, '');
 };
 
 Sql.prototype._buildLikeWhere = function (obj) {
@@ -498,7 +498,7 @@ Sql.prototype._buildExactWhere = function (obj) {
  */
 Sql.prototype.toSet = function (obj) {
   var set = '';
-  for (const k in obj) {
+  for (let k in obj) {
 
     let val = obj[k];
     if (val === undefined || val === null) continue;
@@ -507,17 +507,17 @@ Sql.prototype.toSet = function (obj) {
     val = escape(val);
 
     if (k.endsWith('_add')) {
-      const k2 = escapeId(k.replace('_add', ''));
+      let k2 = escapeId(k.replace('_add', ''));
       set += ',' + k2 + ' = ' + k2 + ' + ' + val;
     } else if (k.endsWith('_del')) {
-      const k3 = escapeId(k.replace('_del', ''));
+      let k3 = escapeId(k.replace('_del', ''));
       set += ',' + k3 + ' = ' + k3 + ' - ' + val;
     } else {
       set += ',' + escapeId(k) + ' = ' + val;
     }
   }
 
-  return set.replace(',', '');
+  return set.replace(/^,/, '');
 };
 
 /**
@@ -533,13 +533,13 @@ Sql.prototype.toAddSql = function (item) {
   let key = '';
   let value = '';
 
-  for (const k in item) {
+  for (let k in item) {
     key += ',' + escapeId(k);
     value += ',' + escape(item[k]);
   }
 
   // 使用直接拼接的方式，避免模板替换错误
-  const sql = `INSERT INTO \`${this.table}\` (${key.replace(',', '')}) VALUES (${value.replace(',', '')});`;
+  let sql = `INSERT INTO \`${this.table}\` (${key.replace(',', '')}) VALUES (${value.replace(',', '')});`;
 
   return sql;
 };
@@ -554,10 +554,10 @@ Sql.prototype.toDelSql = function (query, like) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-  const where = this.toWhere(query, like);
+  let where = this.toWhere(query, like);
 
   // 使用直接拼接的方式，避免模板替换错误
-  const sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
+  let sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
 
   return sql;
 };
@@ -573,11 +573,11 @@ Sql.prototype.toSetSql = function (query, item, like) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-  const where = this.toWhere(query, like);
-  const set = this.toSet(item);
+  let where = this.toWhere(query, like);
+  let set = this.toSet(item);
 
   // 使用直接拼接的方式，避免模板替换错误
-  const sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
+  let sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
 
   return sql;
 };
@@ -591,7 +591,7 @@ Sql.prototype.toSetSql = function (query, item, like) {
  * @returns {string} sql语句
  */
 Sql.prototype.toGetSql = function (query, sort, view, like) {
-  const where = this.toWhere(query, like);
+  let where = this.toWhere(query, like);
   return this.toQuery(where, sort, view);
 };
 
@@ -605,7 +605,7 @@ Sql.prototype.add = async function (body) {
   if (!this.table || !body || typeof body !== 'object') {
     throw new Error('表名或数据未设置');
   }
-  const sql = this.toAddSql(body);
+  let sql = this.toAddSql(body);
   this.sql = sql;
   return await this.exec(sql);
 };
@@ -620,9 +620,9 @@ Sql.prototype.del = async function (query, like) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-  const sql = this.toDelSql(query, like);
+  let sql = this.toDelSql(query, like);
   this.sql = sql;
-  const bl = await this.exec(sql);
+  let bl = await this.exec(sql);
   return bl;
 };
 
@@ -637,9 +637,9 @@ Sql.prototype.set = async function (query, body, like) {
   if (!this.table || !body || typeof body !== 'object') {
     throw new Error('表名或数据未设置');
   }
-  const sql = this.toSetSql(query, body, like);
+  let sql = this.toSetSql(query, body, like);
   this.sql = sql;
-  const bl = await this.exec(sql);
+  let bl = await this.exec(sql);
   return bl;
 };
 
@@ -654,8 +654,8 @@ Sql.prototype.addOrSetSql = async function (where, set, like) {
   if (!this.table || !where || !set) {
     throw new Error('表名、条件或数据未设置');
   }
-  const where_str = await this._getWhereStr(where, like);
-  const count = await this.countSql(where_str);
+  let where_str = await this._getWhereStr(where, like);
+  let count = await this.countSql(where_str);
 
   if (count === 0) {
     return await this._addData(set);
@@ -672,7 +672,7 @@ Sql.prototype._getWhereStr = async function (where, like) {
 };
 
 Sql.prototype._addData = async function (set) {
-  const { key_str, val_str } = await this._parseSetData(set);
+  let { key_str, val_str } = await this._parseSetData(set);
   return await this.addSql(key_str, val_str);
 };
 
@@ -689,16 +689,16 @@ Sql.prototype._parseSetData = async function (set) {
   let val_str = '';
 
   if (typeof set === 'string') {
-    const arr = set.split(',');
-    for (const o of arr) {
-      const ar = o.split('=');
+    let arr = set.split(',');
+    for (let o of arr) {
+      let ar = o.split('=');
       if (ar.length === 2) {
         key_str += ',' + ar[0];
         val_str += ',' + ar[1];
       }
     }
   } else {
-    for (const k in set) {
+    for (let k in set) {
       key_str += ',' + escapeId(k);
       let val = set[k];
       val_str += ',' + escape(val);
@@ -725,9 +725,9 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 20000) {
     throw new Error('表名未设置');
   }
 
-  const sql = this.toGetSql(query, sort, view, like);
+  let sql = this.toGetSql(query, sort, view, like);
   this.sql = sql;
-  const list = await this.run(sql);
+  let list = await this.run(sql);
   return list;
 };
 
@@ -742,15 +742,15 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 20000) {
  */
 Sql.prototype.getObj = async function (query, sort, view, like, timeout = 20000) {
   // 保存当前分页设置
-  const old_page = this.page;
-  const old_size = this.size;
+  let old_page = this.page;
+  let old_size = this.size;
 
   // 设置为只查询一条
   this.page = 1;
   this.size = 1;
 
   // 使用优化后的get方法
-  const list = await this.get(query, sort, view, like, timeout);
+  let list = await this.get(query, sort, view, like, timeout);
 
   // 恢复分页设置
   this.page = old_page;
@@ -778,11 +778,11 @@ Sql.prototype.count = async function (query, like, timeout = 20000) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-  const where = typeof query === 'string' ? query : await this.toWhere(query, like);
-  const sql = 'SELECT COUNT(*) as num FROM `' + this.table + '`' + (where ? ' WHERE ' + where : '');
+  let where = typeof query === 'string' ? query : await this.toWhere(query, like);
+  let 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;
+  let list = await this.run(sql);
+  let total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
   return total;
 };
 
@@ -818,17 +818,17 @@ Sql.prototype.addList = async function (list, batch_size = 100, timeout = 60000)
   }
 
   // 分批处理大数据量
-  const batches = Math.ceil(list.length / batch_size);
+  let batches = Math.ceil(list.length / batch_size);
   this.log('info', `开始分批添加数据，共${batches}批，每批${batch_size}条`);
 
   // 分批执行，每批一个单独的批量插入语句
   let final_res = null;
   for (let i = 0; i < batches; i++) {
-    const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+    let batch = list.slice(i * batch_size, (i + 1) * batch_size);
     this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
 
     // 生成批量插入SQL
-    const batch_sql = this.toBatchAddSql(batch);
+    let batch_sql = this.toBatchAddSql(batch);
     this.sql = batch_sql;
     final_res = await this.exec(batch_sql);
   }
@@ -847,32 +847,32 @@ Sql.prototype.toBatchAddSql = function (list) {
     throw new Error('表名或数据列表未设置');
   }
 
-  const first_obj = list[0];
+  let 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);
+  let keys = this._getKeys(first_obj);
+  let columns = keys.join(',');
+  let 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) {
+  let keys = [];
+  for (let k in obj) {
     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_list = [];
+  for (let item of list) {
+    let values = [];
+    for (let k of keys) {
+      let key = k.replace(/`/g, '');
       let val = item[key];
       values.push(this.escape(val));
     }
@@ -896,7 +896,7 @@ Sql.prototype.delList = async function (list, like, batch_size = 100, timeout =
   // 如果数据量较小，直接处理
   if (list.length <= batch_size) {
     let sql = '';
-    for (const item of list) {
+    for (let item of list) {
       sql += this.toDelSql(item.query, like);
     }
     this.sql = sql;
@@ -904,7 +904,7 @@ Sql.prototype.delList = async function (list, like, batch_size = 100, timeout =
   }
 
   // 分批处理大数据量
-  const batches = Math.ceil(list.length / batch_size);
+  let batches = Math.ceil(list.length / batch_size);
   this.log('info', `开始分批删除数据，共${batches}批，每批${batch_size}条`);
 
   // 使用事务包装整个操作以保证原子性
@@ -915,11 +915,11 @@ Sql.prototype.delList = async function (list, like, batch_size = 100, timeout =
 
     // 分批处理exec删除语句
     for (let i = 0; i < batches; i++) {
-      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+      let batch = list.slice(i * batch_size, (i + 1) * batch_size);
       this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
 
       let batch_sql = '';
-      for (const item of batch) {
+      for (let item of batch) {
         batch_sql += this.toDelSql(item.query, like);
       }
       final_res = await this.exec(batch_sql);
@@ -951,7 +951,7 @@ Sql.prototype.setList = async function (list, like = false, batch_size = 100, ti
     throw new Error('表名或数据列表未设置');
   }
   // 分批处理大数据量
-  const batches = Math.ceil(list.length / batch_size);
+  let batches = Math.ceil(list.length / batch_size);
   this.log('info', `开始分批修改数据，共${batches}批，每批${batch_size}条`);
 
   let final_res = null;
@@ -963,11 +963,11 @@ Sql.prototype.setList = async function (list, like = false, batch_size = 100, ti
 
     // 逐条处理记录，保持简单可靠
     for (let i = 0; i < list.length; i++) {
-      const item = list[i];
+      let item = list[i];
       this.log('debug', `处理第${i + 1}/${list.length}条记录`);
 
       // 生成单个更新SQL
-      const sql = this.toSetSql(item.query, item.item, like);
+      let sql = this.toSetSql(item.query, item.item, like);
       this.sql = sql;
 
       final_res = await this.exec(sql, [], timeout);
@@ -995,8 +995,8 @@ Sql.prototype.has = function (param_dt, sql_dt) {
   if (!param_dt || !sql_dt) {
     return false;
   }
-  for (const key in sql_dt) {
-    const value = param_dt[key];
+  for (let key in sql_dt) {
+    let value = param_dt[key];
     if (value !== undefined && value !== null && value !== '') {
       return true;
     }
@@ -1014,7 +1014,7 @@ Sql.prototype.not = function (param_dt, sql_dt) {
   if (!param_dt || !sql_dt) {
     return undefined;
   }
-  for (const key in param_dt) {
+  for (let key in param_dt) {
     if (!sql_dt[key]) {
       return key;
     }
@@ -1029,11 +1029,11 @@ Sql.prototype.not = function (param_dt, sql_dt) {
  * @returns {object} 返回过滤后的参数集合
  */
 Sql.prototype.filterParams = function (param_dt, sql_dt) {
-  const dt = {};
+  let dt = {};
   if (!param_dt || !sql_dt) {
     return dt;
   }
-  for (const key in param_dt) {
+  for (let key in param_dt) {
     if (!sql_dt[key]) {
       dt[key] = param_dt[key];
     }
@@ -1049,16 +1049,16 @@ Sql.prototype.filterParams = function (param_dt, sql_dt) {
  * @returns {string} 拼接的查询条件
  */
 Sql.prototype._tplQueryWithSep = function (param_dt, sql_dt, l) {
-  const conds = [];
-  for (const key in param_dt) {
+  let conds = [];
+  for (let key in param_dt) {
     let value = String(param_dt[key]);
-    const arr = value.split(l);
-    const tpl = sql_dt[key];
+    let arr = value.split(l);
+    let tpl = sql_dt[key];
 
     if (tpl) {
       if (arr.length > 1) {
-        const sub_conds = [];
-        for (const val of arr) {
+        let sub_conds = [];
+        for (let val of arr) {
           // 使用直接替换方式，避免模板替换错误
           sub_conds.push(tpl.replaceAll('{0}', escape(val).trim("'")));
         }
@@ -1069,8 +1069,8 @@ Sql.prototype._tplQueryWithSep = function (param_dt, sql_dt, l) {
       }
     } else {
       if (arr.length > 1) {
-        const sub_conds = [];
-        for (const val of arr) {
+        let sub_conds = [];
+        for (let val of arr) {
           sub_conds.push(escapeId(key) + ' = ' + escape(val));
         }
         conds.push('(' + sub_conds.join(' || ') + ')');
@@ -1089,8 +1089,8 @@ Sql.prototype._tplQueryWithSep = function (param_dt, sql_dt, l) {
  * @returns {string} 拼接的查询条件
  */
 Sql.prototype._tplQueryNoSep = function (param_dt, sql_dt) {
-  const conds = [];
-  for (const key in param_dt) {
+  let conds = [];
+  for (let key in param_dt) {
     value = escape(param_dt[key]);
     if (sql_dt[key]) {
       // 使用直接替换方式，避免模板替换错误
@@ -1109,13 +1109,13 @@ Sql.prototype._tplQueryNoSep = function (param_dt, sql_dt) {
  * @returns {string} 拼接的查询条件
  */
 Sql.prototype._noTplQueryWithSep = function (param_dt, l) {
-  const conds = [];
-  for (const key in param_dt) {
-    const value = param_dt[key];
-    const arr = String(value).split(l);
+  let conds = [];
+  for (let key in param_dt) {
+    let value = param_dt[key];
+    let arr = String(value).split(l);
     if (arr.length > 1) {
-      const sub_conds = [];
-      for (const val of arr) {
+      let sub_conds = [];
+      for (let val of arr) {
         sub_conds.push(escapeId(key) + ' = ' + escape(val));
       }
       conds.push('(' + sub_conds.join(' || ') + ')');
@@ -1132,8 +1132,8 @@ Sql.prototype._noTplQueryWithSep = function (param_dt, l) {
  * @returns {string} 拼接的查询条件
  */
 Sql.prototype._noTplQueryNoSep = function (param_dt) {
-  const conds = [];
-  for (const key in param_dt) {
+  let conds = [];
+  for (let key in param_dt) {
     conds.push(escapeId(key) + ' = ' + escape(param_dt[key]));
   }
   return conds.join(' && ');
@@ -1150,7 +1150,7 @@ Sql.prototype.tplQuery = function (param_dt, sql_dt) {
   if (!param_dt) {
     return sql;
   }
-  const l = this.config.separator;
+  let l = this.config.separator;
   if (sql_dt) {
     if (l) {
       sql = this._tplQueryWithSep(param_dt, sql_dt, l);
@@ -1177,17 +1177,17 @@ Sql.prototype.tplBody = function (param_dt, sql_dt) {
   if (!param_dt) {
     return '';
   }
-  const parts = [];
+  let parts = [];
   if (!sql_dt || Object.keys(sql_dt).length === 0) {
-    for (const key in param_dt) {
+    for (let key in param_dt) {
       parts.push(' ' + escapeId(key) + ' = ' + escape(param_dt[key]));
     }
   } else {
-    for (const key in param_dt) {
+    for (let key in param_dt) {
       let value = escape(param_dt[key]);
       if (sql_dt[key]) {
         // 使用直接替换方式，避免模板替换错误
-        const replaced = sql_dt[key].replaceAll('{0}', value.trim("'"));
+        let replaced = sql_dt[key].replaceAll('{0}', value.trim("'"));
         parts.push(' ' + replaced.replace(/\+ -/g, '- ').replace(/- -/g, '+ '));
       } else {
         parts.push(' ' + escapeId(key) + ' = ' + value);
@@ -1206,7 +1206,7 @@ Sql.prototype.load = async function (file) {
 
   await this._logLoadStart(file);
   await this._validateFile(file);
-  const sql_stmts = await this._readAndSplitSql(file);
+  let sql_stmts = await this._readAndSplitSql(file);
   return await this._execSqlStmts(file, sql_stmts);
 };
 
@@ -1240,7 +1240,7 @@ Sql.prototype._validateFile = async function (file) {
  * @returns {Promise<string[]>} SQL语句数组
  */
 Sql.prototype._readAndSplitSql = async function (file) {
-  const sql_content = await $.file.readText(file);
+  let sql_content = await $.file.readText(file);
   if (!sql_content || sql_content.trim() === '') {
     throw new Error(`SQL文件内容为空: ${file}`);
   }
@@ -1272,8 +1272,8 @@ Sql.prototype._execSqlStmts = async function (file, sql_stmts) {
  * @returns {Promise<void>}
  */
 Sql.prototype._executeStatements = async function (sql_stmts) {
-  for (const sql of sql_stmts) {
-    const trimmed_sql = sql.trim();
+  for (let sql of sql_stmts) {
+    let trimmed_sql = sql.trim();
     if (trimmed_sql) {
       await this.exec(trimmed_sql);
     }
@@ -1386,18 +1386,18 @@ Sql.prototype._handleString = function (char, sql_content, i, in_str, str_char,
  * @returns {Array} SQL语句数组
  */
 Sql.prototype._splitSqlStatements = function (sql_content) {
-  const stmts = [];
+  let 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] : '';
+    let char = sql_content[i];
+    let next_char = i + 1 < sql_content.length ? sql_content[i + 1] : '';
 
     // 处理注释
-    const line_comment = this._handleLineComment(char, next_char, in_str, in_comment);
+    let 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;
@@ -1405,7 +1405,7 @@ Sql.prototype._splitSqlStatements = function (sql_content) {
     }
     in_comment = line_comment.in_comment;
 
-    const block_comment = this._handleBlockComment(char, next_char, in_str, in_comment);
+    let 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;
@@ -1418,7 +1418,7 @@ Sql.prototype._splitSqlStatements = function (sql_content) {
     }
 
     // 处理字符串
-    const str_res = this._handleString(char, sql_content, i, in_str, str_char, in_comment);
+    let 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;
 
@@ -1445,20 +1445,20 @@ Sql.prototype._splitSqlStatements = function (sql_content) {
  * @returns {object} 返回监听操作的对象
  */
 Sql.prototype.model = function (model) {
-  const self = this;
+  let 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) {
+        let query = {};
+        let arr = self.key.split(',');
+        for (let 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);
+          let n = obj[prop] || 0;
+          let cha = value - n;
+          let where = self.toWhere(query);
           if (cha > 0) {
             self.setSql(where, '`' + prop + '` = `' + prop + '` + ' + cha);
           } else if (cha < 0) {
@@ -1467,14 +1467,14 @@ Sql.prototype.model = function (model) {
             self.setSql(where, '`' + prop + '` = ' + value);
           }
         } else {
-          const set = {};
+          let set = {};
           set[prop] = value;
           self.set(query, set, false).catch(err => {
             self.log('error', '模型数据更新失败', err);
           });
         }
       }
-      const new_obj = { ...obj };
+      let new_obj = { ...obj };
       new_obj[prop] = value;
       return true;
     }
@@ -1492,8 +1492,8 @@ Sql.prototype.addOrSet = async function (where, set, like) {
   if (!this.table || !where || !set) {
     throw new Error('表名、条件或数据未设置');
   }
-  const where_str = await this._getWhereStr(where, like);
-  const count = await this.countSql(where_str);
+  let where_str = await this._getWhereStr(where, like);
+  let count = await this.countSql(where_str);
 
   if (count === 0) {
     return await this._addData(set);
@@ -1509,8 +1509,8 @@ Sql.prototype.addOrSet = async function (where, set, like) {
  */
 Sql.prototype._getCreateTableSql = async function () {
   // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
-  const sql = `SHOW CREATE TABLE \`${this.table}\``;
-  const result = await this.run(sql);
+  let sql = `SHOW CREATE TABLE \`${this.table}\``;
+  let result = await this.run(sql);
 
   if (result && result.length > 0 && result[0]['Create Table']) {
     // 在创建表语句中添加 IF NOT EXISTS 条件
@@ -1533,23 +1533,23 @@ Sql.prototype._getTableComments = async function () {
   let commentSql = '';
 
   // 获取表注释
-  const tableCommentSql = `
+  let tableCommentSql = `
       SELECT TABLE_COMMENT 
       FROM information_schema.TABLES 
       WHERE TABLE_SCHEMA = DATABASE() 
         AND TABLE_NAME = '${this.table}'
     `;
-  const tableCommentResult = await this.run(tableCommentSql);
+  let tableCommentResult = await this.run(tableCommentSql);
 
   if (tableCommentResult && tableCommentResult.length > 0 && tableCommentResult[0].TABLE_COMMENT) {
-    const tableComment = tableCommentResult[0].TABLE_COMMENT;
+    let tableComment = tableCommentResult[0].TABLE_COMMENT;
     if (tableComment && tableComment.trim() !== '') {
       commentSql += `\n-- 表注释: ${tableComment}\n`;
     }
   }
 
   // 获取列注释
-  const columnCommentSql = `
+  let columnCommentSql = `
       SELECT COLUMN_NAME, COLUMN_COMMENT
       FROM information_schema.COLUMNS 
       WHERE TABLE_SCHEMA = DATABASE() 
@@ -1558,11 +1558,11 @@ Sql.prototype._getTableComments = async function () {
         AND COLUMN_COMMENT != ''
       ORDER BY ORDINAL_POSITION
     `;
-  const columnCommentResult = await this.run(columnCommentSql);
+  let columnCommentResult = await this.run(columnCommentSql);
 
   if (columnCommentResult && columnCommentResult.length > 0) {
     commentSql += '\n-- 列注释:\n';
-    for (const column of columnCommentResult) {
+    for (let column of columnCommentResult) {
       commentSql += `-- ${column.COLUMN_NAME}: ${column.COLUMN_COMMENT}\n`;
     }
   }
@@ -1586,7 +1586,7 @@ Sql.prototype.backup = async function (file, create = false) {
   }
 
   // 获取所有数据
-  const data = await this.getSql('', '', '*');
+  let data = await this.getSql('', '', '*');
 
   if (!data || !Array.isArray(data)) {
     throw new Error('获取数据失败');
@@ -1601,12 +1601,12 @@ Sql.prototype.backup = async function (file, create = false) {
 
   // 如果create为true，添加创建表语句
   if (create) {
-    const createTableSql = await this._getCreateTableSql();
+    let createTableSql = await this._getCreateTableSql();
     if (createTableSql) {
       sqlContent += createTableSql + '\n\n';
 
       // 添加表注释信息
-      const commentSql = await this._getTableComments();
+      let commentSql = await this._getTableComments();
       if (commentSql) {
         sqlContent += commentSql + '\n';
       }
@@ -1614,18 +1614,18 @@ Sql.prototype.backup = async function (file, create = false) {
   }
 
   // 添加数据插入语句
-  for (const row of data) {
-    const keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
-    const values = Object.values(row).map(value => this.escape(value)).join(', ');
+  for (let row of data) {
+    let keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
+    let values = Object.values(row).map(value => this.escape(value)).join(', ');
     sqlContent += `INSERT INTO \`${this.table}\` (${keys}) VALUES (${values});\n`;
   }
 
   // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
-  const fs = require('fs');
-  const path = require('path');
+  let fs = require('fs');
+  let path = require('path');
 
   // 确保目录存在
-  const dir = path.dirname(file);
+  let dir = path.dirname(file);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -1649,20 +1649,20 @@ Sql.prototype.restore = async function (file) {
     throw new TypeError('表名未设置');
   }
 
-  const fs = require('fs');
+  let fs = require('fs');
 
   if (!fs.existsSync(file)) {
     throw new Error('备份文件不存在');
   }
 
   // 读取 SQL 文件
-  const sqlContent = fs.readFileSync(file, 'utf8');
+  let sqlContent = fs.readFileSync(file, 'utf8');
 
   // 解析 SQL 语句
-  const statements = this._parseSqlStatements(sqlContent);
+  let statements = this._parseSqlStatements(sqlContent);
 
   // 执行每个 SQL 语句
-  for (const stmt of statements) {
+  for (let stmt of statements) {
     if (stmt.trim() && !stmt.startsWith('--')) {
       await this.exec(stmt);
     }
@@ -1678,15 +1678,15 @@ Sql.prototype.restore = async function (file) {
  * @private
  */
 Sql.prototype._parseSqlStatements = function (sql) {
-  const stmts = [];
+  let stmts = [];
   let cur_stmt = '';
   let in_str = false;
   let in_cmt = false;
   let quote_char = '';
 
   for (let i = 0; i < sql.length; i++) {
-    const char = sql[i];
-    const next_char = sql[i + 1] || '';
+    let char = sql[i];
+    let next_char = sql[i + 1] || '';
 
     // 处理字符串
     if (!in_cmt && (char === "'" || char === '"') && (i === 0 || sql[i - 1] !== '\\')) {
@@ -1765,7 +1765,7 @@ Sql.prototype.backup = async function (file, create = false) {
   }
 
   // 获取所有数据
-  const data = await this.getSql('', '', '*');
+  let data = await this.getSql('', '', '*');
 
   if (!data || !Array.isArray(data)) {
     throw new Error('获取数据失败');
@@ -1780,25 +1780,25 @@ Sql.prototype.backup = async function (file, create = false) {
 
   // 如果create为true，添加创建表语句
   if (create) {
-    const create_table_sql = await this._getCreateTableSql();
+    let create_table_sql = await this._getCreateTableSql();
     if (create_table_sql) {
       sql_content += create_table_sql + '\n\n';
     }
   }
 
   // 添加数据插入语句
-  for (const row of data) {
-    const keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
-    const values = Object.values(row).map(value => this.escape(value)).join(', ');
+  for (let row of data) {
+    let keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
+    let values = Object.values(row).map(value => this.escape(value)).join(', ');
     sql_content += `INSERT INTO \`${this.table}\` (${keys}) VALUES (${values});\n`;
   }
 
   // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
-  const fs = require('fs');
-  const path = require('path');
+  let fs = require('fs');
+  let path = require('path');
 
   // 确保目录存在
-  const dir = path.dirname(file);
+  let dir = path.dirname(file);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -1822,7 +1822,7 @@ Sql.prototype.restore = async function (file) {
     throw new TypeError('表名未设置');
   }
 
-  const fs = require('fs');
+  let fs = require('fs');
 
   // 检查文件是否存在
   if (!fs.existsSync(file)) {
@@ -1830,14 +1830,14 @@ Sql.prototype.restore = async function (file) {
   }
 
   // 读取文件内容
-  const sql_content = fs.readFileSync(file, 'utf8');
+  let sql_content = fs.readFileSync(file, 'utf8');
 
   if (!sql_content) {
     throw new Error('备份文件为空');
   }
 
   // 解析 SQL 语句
-  const sql_stmts = this._parseSqlStatements(sql_content);
+  let sql_stmts = this._parseSqlStatements(sql_content);
 
   if (!sql_stmts || sql_stmts.length === 0) {
     throw new Error('未找到有效的 SQL 语句');
@@ -1848,8 +1848,8 @@ Sql.prototype.restore = async function (file) {
 
   try {
     // 逐个执行SQL语句
-    for (const sql of sql_stmts) {
-      const trim_sql = sql.trim();
+    for (let sql of sql_stmts) {
+      let trim_sql = sql.trim();
       if (trim_sql) {
         await this.exec(trim_sql);
       }
@@ -1885,8 +1885,8 @@ Sql.prototype.restore = async function (file) {
  */
 Sql.prototype._getCreateTableSql = async function () {
   // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
-  const sql = `SHOW CREATE TABLE \`${this.table}\``;
-  const result = await this.run(sql);
+  let sql = `SHOW CREATE TABLE \`${this.table}\``;
+  let result = await this.run(sql);
 
   if (result && result.length > 0 && result[0]['Create Table']) {
     // 在创建表语句中添加 IF NOT EXISTS 条件

package/test2.js

@@ -0,0 +1,381 @@
+/**
+ * MySQL错误处理测试文件
+ * @file test2.js
+ * @description 测试Mysql类的错误日志输出功能
+ */
+
+const { Mysql } = require('./index.js');
+
+/**
+ * 错误测试类
+ * @class ErrorTestMysql
+ */
+class ErrorTestMysql {
+  /**
+   * 构造函数
+   * @param {object} config - 数据库配置
+   */
+  constructor(config) {
+    this.config = {
+      host: '127.0.0.1',
+      port: 3306,
+      user: 'root',
+      password: 'Asd159357',
+      database: 'test_db',
+      debug: true,
+      ...config || {}
+    };
+    
+    this._mysql = null;
+    this._test_results = [];
+  }
+
+  /**
+   * 初始化测试
+   * @returns {Promise<boolean>}
+   */
+  async _init() {
+    try {
+      this._mysql = new Mysql(this.config);
+      await this._mysql.open();
+      console.log('=== 错误处理测试初始化完成 ===');
+      return true;
+    } catch (error) {
+      console.error('初始化失败:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * 记录测试结果
+   * @param {string} test_name - 测试名称
+   * @param {boolean} success - 是否成功
+   * @param {string} message - 测试信息
+   */
+  _recordResult(test_name, success, message) {
+    this._test_results.push({
+      test_name,
+      success,
+      message,
+      timestamp: new Date().toISOString()
+    });
+    
+    const status = success ? '✓' : '✗';
+    console.log(`${status} ${test_name}: ${message}`);
+  }
+
+  /**
+   * 测试无效表查询错误
+   * @returns {Promise<boolean>}
+   */
+  async testInvalidTable() {
+    try {
+      console.log('\n--- 测试1: 查询不存在的表 ---');
+      
+      // 执行无效SQL
+      const invalid_sql = 'SELECT * FROM non_existent_table_xyz';
+      const result = await this._mysql.run(invalid_sql);
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('无效表查询', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('无效表查询', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('无效表查询', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试无效SQL语法错误
+   * @returns {Promise<boolean>}
+   */
+  async testInvalidSyntax() {
+    try {
+      console.log('\n--- 测试2: 无效SQL语法 ---');
+      
+      // 执行语法错误的SQL
+      const invalid_sql = 'SELECT FROM test_users';
+      const result = await this._mysql.run(invalid_sql);
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('无效SQL语法', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('无效SQL语法', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('无效SQL语法', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试exec方法错误处理
+   * @returns {Promise<boolean>}
+   */
+  async testExecError() {
+    try {
+      console.log('\n--- 测试3: exec方法错误处理 ---');
+      
+      // 执行无效INSERT语句
+      const invalid_sql = 'INSERT INTO non_existent_table (name) VALUES (?)';
+      const result = await this._mysql.exec(invalid_sql, ['test']);
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('exec方法错误', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('exec方法错误', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('exec方法错误', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试DB类错误处理
+   * @returns {Promise<boolean>}
+   */
+  async testDbClassError() {
+    try {
+      console.log('\n--- 测试4: DB类错误处理 ---');
+      
+      // 获取DB实例并尝试操作不存在的表
+      const db = this._mysql.db().new('non_existent_table_db', 'id');
+      
+      // 尝试获取数据
+      const result = await db.get({ id: 1 });
+      
+      // 检查错误信息
+      if (this._mysql.error) {
+        console.log('错误信息:', this._mysql.error);
+        this._recordResult('DB类错误', true, `成功捕获错误: ${this._mysql.error.message}`);
+        return true;
+      } else {
+        this._recordResult('DB类错误', false, '未捕获到预期的错误');
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('DB类错误', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 测试连接失败错误（使用错误配置）
+   * @returns {Promise<boolean>}
+   */
+  async testConnectionError() {
+    try {
+      console.log('\n--- 测试5: 连接失败错误 ---');
+      
+      // 使用错误配置创建连接
+      const bad_config = {
+        host: '127.0.0.1',
+        port: 3307, // 错误端口
+        user: 'root',
+        password: 'wrong_password',
+        database: 'test_db',
+        debug: true
+      };
+      
+      const bad_mysql = new Mysql(bad_config);
+      const result = await bad_mysql.open();
+      
+      // 连接应该失败
+      if (result === false) {
+        console.log('连接失败（预期行为）');
+        this._recordResult('连接失败错误', true, '成功检测到连接失败');
+        return true;
+      } else {
+        this._recordResult('连接失败错误', false, '连接意外成功，测试失败');
+        await bad_mysql.close();
+        return false;
+      }
+    } catch (error) {
+      console.log('捕获到异常:', error.message);
+      this._recordResult('连接失败错误', true, `成功捕获连接异常: ${error.message}`);
+      return true;
+    }
+  }
+
+  /**
+   * 测试参数验证错误
+   * @returns {Promise<boolean>}
+   */
+  async testParameterValidation() {
+    try {
+      console.log('\n--- 测试6: 参数验证错误 ---');
+      
+      // 测试无效参数类型
+      let error_count = 0;
+      
+      try {
+        await this._mysql.run(null);
+      } catch (error) {
+        console.log('参数验证错误1:', error.message);
+        error_count++;
+      }
+      
+      try {
+        await this._mysql.run('SELECT 1', 'invalid');
+      } catch (error) {
+        console.log('参数验证错误2:', error.message);
+        error_count++;
+      }
+      
+      if (error_count === 2) {
+        this._recordResult('参数验证错误', true, '成功捕获2个参数验证错误');
+        return true;
+      } else {
+        this._recordResult('参数验证错误', false, `只捕获到 ${error_count} 个错误，预期2个`);
+        return false;
+      }
+    } catch (error) {
+      this._recordResult('参数验证错误', false, `异常错误: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 运行所有错误测试
+   * @returns {Promise<object>}
+   */
+  async runAllTests() {
+    console.log('\n=== 开始运行MySQL错误处理测试 ===\n');
+    
+    // 初始化测试
+    const init_success = await this._init();
+    if (!init_success) {
+      console.log('测试初始化失败');
+      return this._getTestSummary();
+    }
+    
+    // 定义测试用例
+    const test_cases = [
+      { name: '无效表查询', method: 'testInvalidTable' },
+      { name: '无效SQL语法', method: 'testInvalidSyntax' },
+      { name: 'exec方法错误', method: 'testExecError' },
+      { name: 'DB类错误', method: 'testDbClassError' },
+      { name: '连接失败错误', method: 'testConnectionError' },
+      { name: '参数验证错误', method: 'testParameterValidation' }
+    ];
+    
+    // 执行测试
+    for (const test_case of test_cases) {
+      try {
+        console.log(`执行测试: ${test_case.name}`);
+        await this[test_case.method]();
+      } catch (error) {
+        console.error(`测试异常: ${test_case.name}`, error);
+        this._recordResult(test_case.name, false, `测试执行异常: ${error.message}`);
+      }
+    }
+    
+    // 关闭连接
+    if (this._mysql) {
+      await this._mysql.close();
+    }
+    
+    return this._getTestSummary();
+  }
+
+  /**
+   * 获取测试摘要
+   * @returns {object}
+   */
+  _getTestSummary() {
+    const total = this._test_results.length;
+    const passed = this._test_results.filter(r => r.success).length;
+    const failed = total - passed;
+    
+    console.log('\n=== 测试结果摘要 ===');
+    console.log(`总测试数: ${total}`);
+    console.log(`通过: ${passed}`);
+    console.log(`失败: ${failed}`);
+    console.log(`通过率: ${((passed / total) * 100).toFixed(1)}%`);
+    
+    // 显示失败的测试
+    const failed_tests = this._test_results.filter(r => !r.success);
+    if (failed_tests.length > 0) {
+      console.log('\n失败的测试:');
+      failed_tests.forEach(test => {
+        console.log(`  ✗ ${test.test_name}: ${test.message}`);
+      });
+    }
+    
+    return {
+      total,
+      passed,
+      failed,
+      results: this._test_results
+    };
+  }
+
+  /**
+   * 主测试函数
+   * @returns {Promise<void>}
+   */
+  async main() {
+    try {
+      const summary = await this.runAllTests();
+      
+      if (summary.failed > 0) {
+        console.log('\n❌ 部分测试失败');
+        process.exit(1);
+      } else {
+        console.log('\n✅ 所有测试通过！');
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error('测试执行异常:', error);
+      process.exit(1);
+    }
+  }
+}
+
+// 模块导出
+exports.ErrorTestMysql = ErrorTestMysql;
+
+/**
+ * 快速测试函数
+ * @param {object} config - 数据库配置
+ */
+const quick_test = async function(config) {
+  const tester = new ErrorTestMysql(config);
+  await tester.main();
+};
+
+// 如果直接运行此文件，执行测试
+if (require.main === module) {
+  const test_config = {
+    host: process.env.DB_HOST || '127.0.0.1',
+    port: parseInt(process.env.DB_PORT) || 3306,
+    user: process.env.DB_USER || 'root',
+    password: process.env.DB_PASSWORD || 'Asd159357',
+    database: process.env.DB_NAME || 'test_db',
+    debug: process.env.DEBUG === 'true'
+  };
+
+  console.log('使用配置:', {
+    ...test_config,
+    password: '***'
+  });
+  
+  quick_test(test_config);
+}
+
+exports.quick_test = quick_test;