mm_mysql 2.4.1 → 2.4.2

package/sql.js

@@ -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;
+  const 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;
+  const sql = this.toDelSql(query, like);
+  this.sql = sql;
+  const 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;
+  const sql = this.toSetSql(query, body, like);
+  this.sql = sql;
+  const 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);
+  const where_str = await this._getWhereStr(where, like);
+  const count = await this.countSql(where_str);
 
-    if (count === 0) {
-      return await this._addData(set);
-    } else {
-      return await this._updateData(where_str, set);
-    }
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '添加或修改数据失败', err);
+  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) {
@@ -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 [];
+  const sql = this.toGetSql(query, sort, view, like);
+  this.sql = sql;
+  const 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);
-      }
+  // 保存当前分页设置
+  const old_page = this.page;
+  const old_size = this.size;
+
+  // 设置为只查询一条
+  this.page = 1;
+  this.size = 1;
+
+  // 使用优化后的get方法
+  const list = await this.get(query, sort, view, like, timeout);
+
+  // 恢复分页设置
+  this.page = old_page;
+  this.size = old_size;
+
+  var obj = null;
+  if (list.length > 0) {
+    obj = list[0];
+    if (this.key) {
+      obj = this.model(obj);
     }
-
-    return obj;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '查询单条数据失败', err);
   }
-  return null;
+
+  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;
+  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;
 };
 
 /**
@@ -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}条`);
+  // 分批处理大数据量
+  const 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++) {
+    const 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
+    const 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;
 };
 
 /**
@@ -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 (const 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;');
+  // 分批处理大数据量
+  const 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++) {
+      const 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 (const 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 final_res = null;
+  // 分批处理大数据量
+  const batches = Math.ceil(list.length / batch_size);
+  this.log('info', `开始分批修改数据，共${batches}批，每批${batch_size}条`);
 
-    // 使用事务包装整个操作以保证原子性
-    try {
-      // 开始事务
-      await this.exec('BEGIN;');
+  let final_res = null;
 
-      // 逐条处理记录，保持简单可靠
-      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++) {
+      const item = list[i];
+      this.log('debug', `处理第${i + 1}/${list.length}条记录`);
 
-        final_res = await this.exec(sql, [], timeout);
-      }
+      // 生成单个更新SQL
+      const 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;
 };
 
 /* 辅助类 */
@@ -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);
+  const sql_stmts = await this._readAndSplitSql(file);
+  return await this._execSqlStmts(file, sql_stmts);
 };
 
 /**
@@ -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);
+  const where_str = await this._getWhereStr(where, like);
+  const count = await this.countSql(where_str);
 
-    if (count === 0) {
-      return await this._addData(set);
-    } else {
-      return await this._updateData(where_str, set);
-    }
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '添加或修改数据失败', err);
+  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）
+  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 '';
-  } 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 = `
+  // 获取表注释
+  const tableCommentSql = `
       SELECT TABLE_COMMENT 
       FROM information_schema.TABLES 
       WHERE TABLE_SCHEMA = DATABASE() 
         AND TABLE_NAME = '${this.table}'
     `;
-    const tableCommentResult = await this.run(tableCommentSql);
+  const tableCommentResult = await this.run(tableCommentSql);
 
-    if (tableCommentResult && tableCommentResult.length > 0 && tableCommentResult[0].TABLE_COMMENT) {
-      const tableComment = tableCommentResult[0].TABLE_COMMENT;
-      if (tableComment && tableComment.trim() !== '') {
-        commentSql += `\n-- 表注释: ${tableComment}\n`;
-      }
+  if (tableCommentResult && tableCommentResult.length > 0 && tableCommentResult[0].TABLE_COMMENT) {
+    const tableComment = tableCommentResult[0].TABLE_COMMENT;
+    if (tableComment && tableComment.trim() !== '') {
+      commentSql += `\n-- 表注释: ${tableComment}\n`;
     }
+  }
 
-    // 获取列注释
-    const columnCommentSql = `
+  // 获取列注释
+  const 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);
+  const columnCommentResult = await this.run(columnCommentSql);
 
-    if (columnCommentResult && columnCommentResult.length > 0) {
-      commentSql += '\n-- 列注释:\n';
-      for (const column of columnCommentResult) {
-        commentSql += `-- ${column.COLUMN_NAME}: ${column.COLUMN_COMMENT}\n`;
-      }
+  if (columnCommentResult && columnCommentResult.length > 0) {
+    commentSql += '\n-- 列注释:\n';
+    for (const column of columnCommentResult) {
+      commentSql += `-- ${column.COLUMN_NAME}: ${column.COLUMN_COMMENT}\n`;
     }
-
-    return commentSql;
-  } catch (err) {
-    this.log('warn', '获取表注释信息失败，将仅备份表结构', err);
-    return '';
   }
+
+  return commentSql;
 };
 
 /**
@@ -1674,60 +1585,54 @@ Sql.prototype.backup = async function (file, create = false) {
     throw new TypeError('表名未设置');
   }
 
-  try {
-    // 获取所有数据
-    const data = await this.getSql('', '', '*');
+  // 获取所有数据
+  const 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) {
+    const createTableSql = await this._getCreateTableSql();
+    if (createTableSql) {
+      sqlContent += createTableSql + '\n\n';
 
-        // 添加表注释信息
-        const commentSql = await this._getTableComments();
-        if (commentSql) {
-          sqlContent += commentSql + '\n';
-        }
+      // 添加表注释信息
+      const 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 (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`;
+  }
 
-    // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
-    const fs = require('fs');
-    const path = require('path');
+  // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
+  const fs = require('fs');
+  const path = require('path');
 
-    // 确保目录存在
-    const dir = path.dirname(file);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
+  // 确保目录存在
+  const 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');
+  const 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 文件
+  const sqlContent = fs.readFileSync(file, 'utf8');
 
-    // 解析 SQL 语句
-    const statements = this._parseSqlStatements(sqlContent);
+  // 解析 SQL 语句
+  const statements = this._parseSqlStatements(sqlContent);
 
-    // 执行每个 SQL 语句
-    for (const stmt of statements) {
-      if (stmt.trim() && !stmt.startsWith('--')) {
-        await this.exec(stmt);
-      }
+  // 执行每个 SQL 语句
+  for (const 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;
 };
 
 /**
@@ -1865,54 +1764,48 @@ Sql.prototype.backup = async function (file, create = false) {
     throw new TypeError('表名未设置');
   }
 
-  try {
-    // 获取所有数据
-    const data = await this.getSql('', '', '*');
+  // 获取所有数据
+  const 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) {
+    const 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 (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`;
+  }
 
-    // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
-    const fs = require('fs');
-    const path = require('path');
+  // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
+  const fs = require('fs');
+  const path = require('path');
 
-    // 确保目录存在
-    const dir = path.dirname(file);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
+  // 确保目录存在
+  const 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('备份文件不存在');
-    }
+  const fs = require('fs');
 
-    // 读取文件内容
-    const sql_content = fs.readFileSync(file, 'utf8');
+  // 检查文件是否存在
+  if (!fs.existsSync(file)) {
+    throw new Error('备份文件不存在');
+  }
 
-    if (!sql_content) {
-      throw new Error('备份文件为空');
-    }
+  // 读取文件内容
+  const 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 语句
+  const 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 (const sql of sql_stmts) {
+      const 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）
+  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 '';
-  } catch (err) {
-    this.log('warn', '获取表结构失败，将仅备份数据', err);
-    return '';
+    return create_sql + ';';
   }
+
+  return '';
 };
 
 module.exports = {