mm_mysql 2.4.1 → 2.4.3

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,7 +428,7 @@ 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 {
@@ -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,10 +507,10 @@ 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;
@@ -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,15 +605,9 @@ 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.log('error', '添加数据失败', err);
-  }
-  return 0;
+  let sql = this.toAddSql(body);
+  this.sql = sql;
+  return await this.exec(sql);
 };
 
 /**
@@ -626,16 +620,10 @@ 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.log('error', '删除数据失败', err);
-  }
-  return 0;
+  let sql = this.toDelSql(query, like);
+  this.sql = sql;
+  let bl = await this.exec(sql);
+  return bl;
 };
 
 /**
@@ -649,16 +637,10 @@ 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.log('error', '修改数据失败', err);
-  }
-  return 0;
+  let sql = this.toSetSql(query, body, like);
+  this.sql = sql;
+  let bl = await this.exec(sql);
+  return bl;
 };
 
 /**
@@ -672,20 +654,14 @@ Sql.prototype.addOrSetSql = async function (where, set, like) {
   if (!this.table || !where || !set) {
     throw new Error('表名、条件或数据未设置');
   }
-  try {
-    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);
-    } else {
-      return await this._updateData(where_str, set);
-    }
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '添加或修改数据失败', err);
+  if (count === 0) {
+    return await this._addData(set);
+  } else {
+    return await this._updateData(where_str, set);
   }
-  return 0;
 };
 
 Sql.prototype._getWhereStr = async function (where, like) {
@@ -696,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);
 };
 
@@ -713,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);
@@ -749,16 +725,10 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 20000) {
     throw new Error('表名未设置');
   }
 
-  try {
-    const sql = this.toGetSql(query, sort, view, like);
-    this.sql = sql;
-    const list = await this.run(sql);
-    return list;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '查询数据失败', err);
-  }
-  return [];
+  let sql = this.toGetSql(query, sort, view, like);
+  this.sql = sql;
+  let list = await this.run(sql);
+  return list;
 };
 
 /**
@@ -771,36 +741,30 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 20000) {
  * @returns {Promise | object | null} 查询结果
  */
 Sql.prototype.getObj = async function (query, sort, view, like, timeout = 20000) {
-  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);
-      }
+  // 保存当前分页设置
+  let old_page = this.page;
+  let old_size = this.size;
+
+  // 设置为只查询一条
+  this.page = 1;
+  this.size = 1;
+
+  // 使用优化后的get方法
+  let 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;
+
+  return obj;
 };
 
 /**
@@ -814,19 +778,12 @@ Sql.prototype.count = async function (query, like, timeout = 20000) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-
-  try {
-    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;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '统计数据失败', err);
-  }
-  return 0;
+  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;
+  let list = await this.run(sql);
+  let total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
+  return total;
 };
 
 /**
@@ -853,36 +810,31 @@ Sql.prototype.addList = async function (list, batch_size = 100, timeout = 60000)
   if (!this.table || !Array.isArray(list) || list.length === 0) {
     throw new Error('表名或数据列表未设置');
   }
-  try {
-    // 如果数据量较小，
-    if (list.length <= batch_size) {
-      // 使用批量插入语法，不使用事务包装
-      this.sql = this.toBatchAddSql(list);
-      return await this.exec(this.sql, [], timeout);
-    }
-
-    // 分批处理大数据量
-    const batches = Math.ceil(list.length / batch_size);
-    this.log('info', `开始分批添加数据，共${batches}批，每批${batch_size}条`);
+  // 如果数据量较小，
+  if (list.length <= batch_size) {
+    // 使用批量插入语法，不使用事务包装
+    this.sql = this.toBatchAddSql(list);
+    return await this.exec(this.sql, [], timeout);
+  }
 
-    // 分批执行，每批一个单独的批量插入语句
-    let final_res = null;
-    for (let i = 0; i < batches; i++) {
-      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-      this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
+  // 分批处理大数据量
+  let batches = Math.ceil(list.length / batch_size);
+  this.log('info', `开始分批添加数据，共${batches}批，每批${batch_size}条`);
 
-      // 生成批量插入SQL
-      const batch_sql = this.toBatchAddSql(batch);
-      this.sql = batch_sql;
-      final_res = await this.exec(batch_sql);
-    }
+  // 分批执行，每批一个单独的批量插入语句
+  let final_res = null;
+  for (let i = 0; i < batches; i++) {
+    let batch = list.slice(i * batch_size, (i + 1) * batch_size);
+    this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
 
-    this.log('info', `批量添加数据完成，共${list.length}条`);
-    return final_res;
-  } catch (error) {
-    this.log('error', '批量添加数据失败', error);
+    // 生成批量插入SQL
+    let batch_sql = this.toBatchAddSql(batch);
+    this.sql = batch_sql;
+    final_res = await this.exec(batch_sql);
   }
-  return 0;
+
+  this.log('info', `批量添加数据完成，共${list.length}条`);
+  return final_res;
 };
 
 /**
@@ -895,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));
     }
@@ -941,59 +893,49 @@ Sql.prototype.delList = async function (list, like, batch_size = 100, timeout =
   if (!this.table || !Array.isArray(list) || list.length === 0) {
     throw new Error('表名或数据列表未设置');
   }
-  try {
-    // 如果数据量较小，直接处理
-    if (list.length <= batch_size) {
-      let sql = '';
-      for (const item of list) {
-        sql += this.toDelSql(item.query, like);
-      }
-      this.sql = sql;
-      return await this.exec(sql);
+  // 如果数据量较小，直接处理
+  if (list.length <= batch_size) {
+    let sql = '';
+    for (let item of list) {
+      sql += this.toDelSql(item.query, like);
     }
+    this.sql = sql;
+    return await this.exec(sql);
+  }
 
-    // 分批处理大数据量
-    const batches = Math.ceil(list.length / batch_size);
-    this.log('info', `开始分批删除数据，共${batches}批，每批${batch_size}条`);
-
-    // 使用事务包装整个操作以保证原子性
-    let final_res = null;
-    try {
-      // 开始事务
-      await this.exec('BEGIN;');
+  // 分批处理大数据量
+  let batches = Math.ceil(list.length / batch_size);
+  this.log('info', `开始分批删除数据，共${batches}批，每批${batch_size}条`);
 
-      // 分批处理exec删除语句
-      for (let i = 0; i < batches; i++) {
-        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-        this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
+  // 使用事务包装整个操作以保证原子性
+  let final_res = null;
+  try {
+    // 开始事务
+    await this.exec('BEGIN;');
 
-        let batch_sql = '';
-        for (const item of batch) {
-          batch_sql += this.toDelSql(item.query, like);
-        }
-        final_res = await this.exec(batch_sql);
-      }
+    // 分批处理exec删除语句
+    for (let i = 0; i < batches; i++) {
+      let batch = list.slice(i * batch_size, (i + 1) * batch_size);
+      this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
 
-      // 提交事务
-      await this.exec('COMMIT;');
-    } catch (error) {
-      // 发生错误时回滚事务
-      try {
-        await this.exec('ROLLBACK;', [], timeout);
-        this.log('error', '批量删除数据失败，事务已回滚', error);
-      } catch (rollbackError) {
-        this.log('error', '批量删除数据失败，事务回滚也失败', rollbackError);
+      let batch_sql = '';
+      for (let item of batch) {
+        batch_sql += this.toDelSql(item.query, like);
       }
-      throw error; // 重新抛出错误
+      final_res = await this.exec(batch_sql);
     }
 
-    this.log('info', `批量删除数据完成，共${list.length}条`);
-    return final_res;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '批量删除数据失败', err);
+    // 提交事务
+    await this.exec('COMMIT;');
+  } catch (error) {
+    // 发生错误时回滚事务
+    await this.exec('ROLLBACK;', [], timeout);
+    this.log('error', '批量删除数据失败，事务已回滚', error);
+    throw error; // 重新抛出错误
   }
-  return 0;
+
+  this.log('info', `批量删除数据完成，共${list.length}条`);
+  return final_res;
 };
 
 /**
@@ -1008,49 +950,38 @@ Sql.prototype.setList = async function (list, like = false, batch_size = 100, ti
   if (!this.table || !Array.isArray(list) || list.length === 0) {
     throw new Error('表名或数据列表未设置');
   }
-  try {
-    // 分批处理大数据量
-    const batches = Math.ceil(list.length / batch_size);
-    this.log('info', `开始分批修改数据，共${batches}批，每批${batch_size}条`);
+  // 分批处理大数据量
+  let batches = Math.ceil(list.length / batch_size);
+  this.log('info', `开始分批修改数据，共${batches}批，每批${batch_size}条`);
 
-    let final_res = null;
+  let final_res = null;
 
-    // 使用事务包装整个操作以保证原子性
-    try {
-      // 开始事务
-      await this.exec('BEGIN;');
-
-      // 逐条处理记录，保持简单可靠
-      for (let i = 0; i < list.length; i++) {
-        const item = list[i];
-        this.log('debug', `处理第${i + 1}/${list.length}条记录`);
+  // 使用事务包装整个操作以保证原子性
+  try {
+    // 开始事务
+    await this.exec('BEGIN;');
 
-        // 生成单个更新SQL
-        const sql = this.toSetSql(item.query, item.item, like);
-        this.sql = sql;
+    // 逐条处理记录，保持简单可靠
+    for (let i = 0; i < list.length; i++) {
+      let item = list[i];
+      this.log('debug', `处理第${i + 1}/${list.length}条记录`);
 
-        final_res = await this.exec(sql, [], timeout);
-      }
+      // 生成单个更新SQL
+      let sql = this.toSetSql(item.query, item.item, like);
+      this.sql = sql;
 
-      // 提交事务
-      await this.exec('COMMIT;');
-    } catch (error) {
-      // 发生错误时回滚事务
-      try {
-        await this.exec('ROLLBACK;', [], timeout);
-        this.log('error', '批量修改数据失败，事务已回滚', error);
-      } catch (rollbackError) {
-        this.log('error', '批量修改数据失败，事务回滚也失败', rollbackError);
-      }
-      throw error; // 重新抛出错误
+      final_res = await this.exec(sql, [], timeout);
     }
 
-    return final_res;
+    // 提交事务
+    await this.exec('COMMIT;');
   } catch (error) {
-    this.error = error.message;
-    this.log('error', '批量修改数据失败', error);
+    await this.exec('ROLLBACK;', [], timeout);
+    this.log('error', '批量修改数据失败，事务已回滚', error);
+    throw error; // 重新抛出错误
   }
-  return 0;
+
+  return final_res;
 };
 
 /* 辅助类 */
@@ -1064,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;
     }
@@ -1083,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;
     }
@@ -1098,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];
     }
@@ -1118,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("'")));
         }
@@ -1138,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(' || ') + ')');
@@ -1158,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]) {
       // 使用直接替换方式，避免模板替换错误
@@ -1178,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(' || ') + ')');
@@ -1201,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(' && ');
@@ -1219,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);
@@ -1246,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);
@@ -1272,15 +1203,11 @@ Sql.prototype.tplBody = function (param_dt, sql_dt) {
  * @returns {Promise<boolean>} 是否加载成功
  */
 Sql.prototype.load = async function (file) {
-  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;
+
+  await this._logLoadStart(file);
+  await this._validateFile(file);
+  let sql_stmts = await this._readAndSplitSql(file);
+  return await this._execSqlStmts(file, sql_stmts);
 };
 
 /**
@@ -1313,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}`);
   }
@@ -1345,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);
     }
@@ -1459,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;
@@ -1478,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;
@@ -1491,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;
 
@@ -1518,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) {
@@ -1540,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;
     }
@@ -1565,20 +1492,14 @@ Sql.prototype.addOrSet = async function (where, set, like) {
   if (!this.table || !where || !set) {
     throw new Error('表名、条件或数据未设置');
   }
-  try {
-    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);
-    } else {
-      return await this._updateData(where_str, set);
-    }
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '添加或修改数据失败', err);
+  if (count === 0) {
+    return await this._addData(set);
+  } else {
+    return await this._updateData(where_str, set);
   }
-  return 0;
 };
 
 /**
@@ -1587,25 +1508,20 @@ Sql.prototype.addOrSet = async function (where, set, like) {
  * @private
  */
 Sql.prototype._getCreateTableSql = async function () {
-  try {
-    // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
-    const sql = `SHOW CREATE TABLE \`${this.table}\``;
-    const result = await this.run(sql);
-
-    if (result && result.length > 0 && result[0]['Create Table']) {
-      // 在创建表语句中添加 IF NOT EXISTS 条件
-      let create_sql = result[0]['Create Table'];
-      if (create_sql.toUpperCase().startsWith('CREATE TABLE')) {
-        create_sql = create_sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS');
-      }
-      return create_sql + ';';
+  // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
+  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 条件
+    let create_sql = result[0]['Create Table'];
+    if (create_sql.toUpperCase().startsWith('CREATE TABLE')) {
+      create_sql = create_sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS');
     }
-
-    return '';
-  } catch (err) {
-    this.log('warn', '获取表结构失败，将仅备份数据', err);
-    return '';
+    return create_sql + ';';
   }
+
+  return '';
 };
 
 /**
@@ -1614,27 +1530,26 @@ Sql.prototype._getCreateTableSql = async function () {
  * @private
  */
 Sql.prototype._getTableComments = async function () {
-  try {
-    let commentSql = '';
+  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;
-      if (tableComment && tableComment.trim() !== '') {
-        commentSql += `\n-- 表注释: ${tableComment}\n`;
-      }
+  if (tableCommentResult && tableCommentResult.length > 0 && 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() 
@@ -1643,20 +1558,16 @@ 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) {
-        commentSql += `-- ${column.COLUMN_NAME}: ${column.COLUMN_COMMENT}\n`;
-      }
+  if (columnCommentResult && columnCommentResult.length > 0) {
+    commentSql += '\n-- 列注释:\n';
+    for (let column of columnCommentResult) {
+      commentSql += `-- ${column.COLUMN_NAME}: ${column.COLUMN_COMMENT}\n`;
     }
-
-    return commentSql;
-  } catch (err) {
-    this.log('warn', '获取表注释信息失败，将仅备份表结构', err);
-    return '';
   }
+
+  return commentSql;
 };
 
 /**
@@ -1674,60 +1585,54 @@ Sql.prototype.backup = async function (file, create = false) {
     throw new TypeError('表名未设置');
   }
 
-  try {
-    // 获取所有数据
-    const data = await this.getSql('', '', '*');
+  // 获取所有数据
+  let data = await this.getSql('', '', '*');
 
-    if (!data || !Array.isArray(data)) {
-      throw new Error('获取数据失败');
-    }
+  if (!data || !Array.isArray(data)) {
+    throw new Error('获取数据失败');
+  }
 
-    // 构建 SQL 语句
-    let sqlContent = '';
+  // 构建 SQL 语句
+  let sqlContent = '';
 
-    // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
-    sqlContent += `-- 备份表: ${this.table}\n`;
-    sqlContent += `-- 备份时间: ${new Date().toISOString()}\n\n`;
+  // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
+  sqlContent += `-- 备份表: ${this.table}\n`;
+  sqlContent += `-- 备份时间: ${new Date().toISOString()}\n\n`;
 
-    // 如果create为true，添加创建表语句
-    if (create) {
-      const createTableSql = await this._getCreateTableSql();
-      if (createTableSql) {
-        sqlContent += createTableSql + '\n\n';
+  // 如果create为true，添加创建表语句
+  if (create) {
+    let createTableSql = await this._getCreateTableSql();
+    if (createTableSql) {
+      sqlContent += createTableSql + '\n\n';
 
-        // 添加表注释信息
-        const commentSql = await this._getTableComments();
-        if (commentSql) {
-          sqlContent += commentSql + '\n';
-        }
+      // 添加表注释信息
+      let commentSql = await this._getTableComments();
+      if (commentSql) {
+        sqlContent += commentSql + '\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(', ');
-      sqlContent += `INSERT INTO \`${this.table}\` (${keys}) VALUES (${values});\n`;
-    }
+  // 添加数据插入语句
+  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');
+  // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
+  let fs = require('fs');
+  let path = require('path');
 
-    // 确保目录存在
-    const dir = path.dirname(file);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
+  // 确保目录存在
+  let dir = path.dirname(file);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
 
-    fs.writeFileSync(file, sql_content, 'utf8');
+  fs.writeFileSync(file, sql_content, 'utf8');
 
-    return true;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '备份数据库失败', err);
-    return false;
-  }
+  return true;
 };
 
 /**
@@ -1744,32 +1649,26 @@ Sql.prototype.restore = async function (file) {
     throw new TypeError('表名未设置');
   }
 
-  try {
-    const fs = require('fs');
+  let fs = require('fs');
 
-    if (!fs.existsSync(file)) {
-      throw new Error('备份文件不存在');
-    }
+  if (!fs.existsSync(file)) {
+    throw new Error('备份文件不存在');
+  }
 
-    // 读取 SQL 文件
-    const sqlContent = fs.readFileSync(file, 'utf8');
+  // 读取 SQL 文件
+  let sqlContent = fs.readFileSync(file, 'utf8');
 
-    // 解析 SQL 语句
-    const statements = this._parseSqlStatements(sqlContent);
+  // 解析 SQL 语句
+  let statements = this._parseSqlStatements(sqlContent);
 
-    // 执行每个 SQL 语句
-    for (const stmt of statements) {
-      if (stmt.trim() && !stmt.startsWith('--')) {
-        await this.exec(stmt);
-      }
+  // 执行每个 SQL 语句
+  for (let stmt of statements) {
+    if (stmt.trim() && !stmt.startsWith('--')) {
+      await this.exec(stmt);
     }
-
-    return true;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '恢复数据库失败', err);
-    return false;
   }
+
+  return true;
 };
 
 /**
@@ -1779,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] !== '\\')) {
@@ -1865,54 +1764,48 @@ Sql.prototype.backup = async function (file, create = false) {
     throw new TypeError('表名未设置');
   }
 
-  try {
-    // 获取所有数据
-    const data = await this.getSql('', '', '*');
+  // 获取所有数据
+  let data = await this.getSql('', '', '*');
 
-    if (!data || !Array.isArray(data)) {
-      throw new Error('获取数据失败');
-    }
+  if (!data || !Array.isArray(data)) {
+    throw new Error('获取数据失败');
+  }
 
-    // 构建 SQL 语句
-    let sql_content = '';
+  // 构建 SQL 语句
+  let sql_content = '';
 
-    // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
-    sql_content += `-- 备份表: ${this.table}\n`;
-    sql_content += `-- 备份时间: ${new Date().toISOString()}\n\n`;
+  // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
+  sql_content += `-- 备份表: ${this.table}\n`;
+  sql_content += `-- 备份时间: ${new Date().toISOString()}\n\n`;
 
-    // 如果create为true，添加创建表语句
-    if (create) {
-      const create_table_sql = await this._getCreateTableSql();
-      if (create_table_sql) {
-        sql_content += create_table_sql + '\n\n';
-      }
+  // 如果create为true，添加创建表语句
+  if (create) {
+    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(', ');
-      sql_content += `INSERT INTO \`${this.table}\` (${keys}) VALUES (${values});\n`;
-    }
+  // 添加数据插入语句
+  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');
+  // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
+  let fs = require('fs');
+  let path = require('path');
 
-    // 确保目录存在
-    const dir = path.dirname(file);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
+  // 确保目录存在
+  let dir = path.dirname(file);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
 
-    fs.writeFileSync(file, sql_content, 'utf8');
+  fs.writeFileSync(file, sql_content, 'utf8');
 
-    return true;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '备份数据库失败', err);
-    return false;
-  }
+  return true;
 };
 
 /**
@@ -1929,65 +1822,59 @@ Sql.prototype.restore = async function (file) {
     throw new TypeError('表名未设置');
   }
 
-  try {
-    const fs = require('fs');
-
-    // 检查文件是否存在
-    if (!fs.existsSync(file)) {
-      throw new Error('备份文件不存在');
-    }
+  let fs = require('fs');
 
-    // 读取文件内容
-    const sql_content = fs.readFileSync(file, 'utf8');
+  // 检查文件是否存在
+  if (!fs.existsSync(file)) {
+    throw new Error('备份文件不存在');
+  }
 
-    if (!sql_content) {
-      throw new Error('备份文件为空');
-    }
+  // 读取文件内容
+  let sql_content = fs.readFileSync(file, 'utf8');
 
-    // 解析 SQL 语句
-    const sql_stmts = this._parseSqlStatements(sql_content);
+  if (!sql_content) {
+    throw new Error('备份文件为空');
+  }
 
-    if (!sql_stmts || sql_stmts.length === 0) {
-      throw new Error('未找到有效的 SQL 语句');
-    }
+  // 解析 SQL 语句
+  let sql_stmts = this._parseSqlStatements(sql_content);
 
-    // 开始事务
-    await this.exec('START TRANSACTION');
-
-    try {
-      // 逐个执行SQL语句
-      for (const sql of sql_stmts) {
-        const trim_sql = sql.trim();
-        if (trim_sql) {
-          await this.exec(trim_sql);
-        }
-      }
+  if (!sql_stmts || sql_stmts.length === 0) {
+    throw new Error('未找到有效的 SQL 语句');
+  }
 
-      // 提交事务
-      await this.exec('COMMIT');
+  // 开始事务
+  await this.exec('START TRANSACTION');
 
-      if (this.config && this.config.debug) {
-        this.log('info', '数据库恢复成功', {
-          file: file,
-          stmt_num: sql_stmts.length
-        });
+  try {
+    // 逐个执行SQL语句
+    for (let sql of sql_stmts) {
+      let trim_sql = sql.trim();
+      if (trim_sql) {
+        await this.exec(trim_sql);
       }
+    }
 
-      return true;
-    } catch (err) {
-      // 回滚事务
-      await this.exec('ROLLBACK').catch(rollback_err => {
-        this.log('error', '事务回滚失败', rollback_err);
-      });
+    // 提交事务
+    await this.exec('COMMIT');
 
-      // 记录错误日志
-      this.log('error', 'SQL语句执行失败', err);
-      throw err;
+    if (this.config && this.config.debug) {
+      this.log('info', '数据库恢复成功', {
+        file: file,
+        stmt_num: sql_stmts.length
+      });
     }
+
+    return true;
   } catch (err) {
-    this.error = err.message;
-    this.log('error', '数据库恢复失败', err);
-    return false;
+    // 回滚事务
+    await this.exec('ROLLBACK').catch(rollback_err => {
+      this.log('error', '事务回滚失败', rollback_err);
+    });
+
+    // 记录错误日志
+    this.log('error', 'SQL语句执行失败', err);
+    throw err;
   }
 };
 
@@ -1997,25 +1884,20 @@ Sql.prototype.restore = async function (file) {
  * @private
  */
 Sql.prototype._getCreateTableSql = async function () {
-  try {
-    // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
-    const sql = `SHOW CREATE TABLE \`${this.table}\``;
-    const result = await this.run(sql);
-
-    if (result && result.length > 0 && result[0]['Create Table']) {
-      // 在创建表语句中添加 IF NOT EXISTS 条件
-      let create_sql = result[0]['Create Table'];
-      if (create_sql.toUpperCase().startsWith('CREATE TABLE')) {
-        create_sql = create_sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS');
-      }
-      return create_sql + ';';
+  // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
+  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 条件
+    let create_sql = result[0]['Create Table'];
+    if (create_sql.toUpperCase().startsWith('CREATE TABLE')) {
+      create_sql = create_sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS');
     }
-
-    return '';
-  } catch (err) {
-    this.log('warn', '获取表结构失败，将仅备份数据', err);
-    return '';
+    return create_sql + ';';
   }
+
+  return '';
 };
 
 module.exports = {