mm_sqlite 1.4.0 → 1.4.2

package/sql.js

@@ -564,46 +564,40 @@ Sql.prototype.backup = async function (file) {
     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`;
 
-    // 添加数据插入语句
-    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, sqlContent, 'utf8');
+  fs.writeFileSync(file, sqlContent, 'utf8');
 
-    return true;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '备份数据库失败', err);
-    return false;
-  }
+  return true;
 };
 
 /**
@@ -620,40 +614,34 @@ 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('备份文件不存在');
+  }
 
-    // 读取文件内容
-    const sqlContent = fs.readFileSync(file, 'utf8');
+  // 读取文件内容
+  const sqlContent = fs.readFileSync(file, 'utf8');
 
-    if (!sqlContent) {
-      throw new Error('备份文件为空');
-    }
+  if (!sqlContent) {
+    throw new Error('备份文件为空');
+  }
 
-    // 解析 SQL 语句（按分号分割，但需要处理字符串中的分号）
-    const statements = this._parseSqlStatements(sqlContent);
+  // 解析 SQL 语句（按分号分割，但需要处理字符串中的分号）
+  const statements = this._parseSqlStatements(sqlContent);
 
-    // 执行所有 SQL 语句
-    for (const statement of statements) {
-      if (statement.trim()) {
-        // 跳过注释行
-        if (!statement.trim().startsWith('--')) {
-          await this.exec(statement);
-        }
+  // 执行所有 SQL 语句
+  for (const statement of statements) {
+    if (statement.trim()) {
+      // 跳过注释行
+      if (!statement.trim().startsWith('--')) {
+        await this.exec(statement);
       }
     }
-
-    return true;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '恢复数据库失败', err);
-    return false;
   }
+
+  return true;
 };
 
 /**
@@ -870,18 +858,11 @@ Sql.prototype.add = async function (body) {
   if (!this.table || !body || typeof body !== 'object') {
     throw new Error('表名或数据未设置');
   }
-  try {
-    var sql = this.toAddSql(body);
-    this.sql = sql;
-    var bl = await this.exec(sql);
+  var sql = this.toAddSql(body);
+  this.sql = sql;
+  var bl = await this.exec(sql);
 
-    return bl;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '添加数据失败', err);
-    // 返回默认操作结果对象，保持返回值类型一致
-    return 0;
-  }
+  return bl;
 };
 /**
  * @description 删除数据
@@ -893,17 +874,10 @@ Sql.prototype.del = async function (query, like) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-  try {
-    var sql = this.toDelSql(query, like);
-    this.sql = sql;
-    var bl = await this.exec(sql);
-    return bl;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '删除数据失败', err);
-    // 返回默认操作结果对象，保持返回值类型一致
-    return 0;
-  }
+  var sql = this.toDelSql(query, like);
+  this.sql = sql;
+  var bl = await this.exec(sql);
+  return bl;
 };
 
 /**
@@ -917,17 +891,10 @@ Sql.prototype.set = async function (query, body, like) {
   if (!this.table || !body || typeof body !== 'object') {
     throw new Error('表名或数据未设置');
   }
-  try {
-    var sql = this.toSetSql(query, body, like);
-    this.sql = sql;
-    var bl = await this.exec(sql);
-    return bl;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '修改数据失败', err);
-    // 返回默认操作结果对象，保持返回值类型一致
-    return 0;
-  }
+  var sql = this.toSetSql(query, body, like);
+  this.sql = sql;
+  var bl = await this.exec(sql);
+  return bl;
 };
 
 /**
@@ -944,16 +911,9 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 5000) {
     throw new Error('表名未设置');
   }
 
-  try {
-    var sql = this.toGetSql(query, sort, view, like);
-    var list = await this.run(sql, [], timeout);
-    return list;
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '查询数据失败', err);
-    // 返回空数组作为默认值，保持返回值类型一致
-    return [];
-  }
+  var sql = this.toGetSql(query, sort, view, like);
+  var list = await this.run(sql, [], timeout);
+  return list;
 };
 
 /**
@@ -967,55 +927,48 @@ Sql.prototype.addOrSet = async function (where, set, like) {
   if (!this.table || !where || !set) {
     throw new Error('表名、条件或数据未设置');
   }
-  try {
-    let where_str;
+  let where_str;
 
-    if (typeof where === 'object') {
-      where_str = await this.toWhere(where, like);
-    } else {
-      where_str = where;
-    }
-
-    const count = await this.countSql(whereStr);
+  if (typeof where === 'object') {
+    where_str = this.toWhere(where, like);
+  } else {
+    where_str = where;
+  }
 
-    if (count === 0) {
-      let key = '';
-      let value = '';
+  const count = await this.countSql(where_str);
 
-      if (typeof set === 'string') {
-        const arr = set.split(',');
-        for (const o of arr) {
-          const ar = o.split('=');
-          if (ar.length === 2) {
-            key += ',' + ar[0];
-            value += ',' + ar[1];
-          }
-        }
-      } else {
-        for (const k in set) {
-          key += ',' + this.escapeId(k);
-          value += ',' + this.escape(set[k]);
+  if (count === 0) {
+    let key = '';
+    let value = '';
+
+    if (typeof set === 'string') {
+      const arr = set.split(',');
+      for (const o of arr) {
+        const ar = o.split('=');
+        if (ar.length === 2) {
+          key += ',' + ar[0];
+          value += ',' + ar[1];
         }
       }
-
-      const bl = await this.addSql(key.replace(',', ''), value.replace(',', ''));
-
-      return bl;
     } else {
-      let set_vals = set;
-      if (typeof set === 'object') {
-        set_vals = await this.toSet(set);
+      for (const k in set) {
+        key += ',' + this.escapeId(k);
+        value += ',' + this.escape(set[k]);
       }
+    }
 
-      const bl1 = await this.setSql(where_str, set_vals);
+    const bl = await this.addSql(key.replace(',', ''), value.replace(',', ''));
 
-      return bl1;
+    return bl;
+  } else {
+    let set_vals = set;
+    if (typeof set === 'object') {
+      set_vals = await this.toSet(set);
     }
-  } catch (err) {
-    this.error = err.message;
-    this.log('error', '添加或修改数据失败', err);
-    // 返回默认操作结果对象，保持返回值类型一致
-    return 0;
+
+    const bl1 = await this.setSql(where_str, set_vals);
+
+    return bl1;
   }
 };
 
@@ -1031,20 +984,13 @@ Sql.prototype.count = async function (query, like, timeout = 30000) {
     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;
+  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);
-    // 返回0作为默认统计值，保持返回值类型一致
-    return 0;
-  }
+  return total;
 };
 
 /**
@@ -1070,37 +1016,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);
-    }
-
-    // 分批处理大数据量
-    const total = Math.ceil(list.length / batch_size);
-    this.log('info', `开始分批添加数据，共${total}批，每批${batch_size}条`);
+  if (list.length <= batch_size) {
+    // 使用批量插入语法，不使用事务包装
+    this.sql = this.toBatchAddSql(list);
+    return await this.exec(this.sql);
+  }
 
-    // 分批执行，每批一个单独的批量插入语句
-    let final_res = null;
-    for (let i = 0; i < total; i++) {
-      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-      this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
+  // 分批处理大数据量
+  const total = Math.ceil(list.length / batch_size);
+  this.log('info', `开始分批添加数据，共${total}批，每批${batch_size}条`);
 
-      // 生成批量插入SQL
-      const batch_sql = this.toBatchAddSql(batch);
-      this.sql = batch_sql;
+  // 分批执行，每批一个单独的批量插入语句
+  let final_res = null;
+  for (let i = 0; i < total; i++) {
+    const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+    this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-      final_res = await this.exec(batch_sql);
-    }
+    // 生成批量插入SQL
+    const batch_sql = this.toBatchAddSql(batch);
+    this.sql = batch_sql;
 
-    this.log('success', `批量添加数据完成，共${list.length}条`);
-    return final_res;
-  } catch (error) {
-    this.log('error', '批量添加数据失败', error);
-    // 返回默认操作结果对象，保持返回值类型一致
-    return 0;
+    final_res = await this.exec(batch_sql);
   }
+
+  this.log('success', `批量添加数据完成，共${list.length}条`);
+  return final_res;
 };
 
 /**
@@ -1156,59 +1096,53 @@ 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, [], timeout);
+  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, [], timeout);
+  }
 
-    // 分批处理大数据量
-    const total = Math.ceil(list.length / batch_size);
-    this.log('info', `开始分批删除数据，共${total}批，每批${batch_size}条`);
-
-    // 使用事务包装整个操作以保证原子性
-    let final_res = null;
-    try {
-      // 开始事务
-      await this.exec('BEGIN;');
+  // 分批处理大数据量
+  const total = Math.ceil(list.length / batch_size);
+  this.log('info', `开始分批删除数据，共${total}批，每批${batch_size}条`);
 
-      // 分批处理
-      for (let i = 0; i < total; i++) {
-        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-        this.log('debug', `处理第${i + 1}/${total}批数据，${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, [], timeout);
-      }
+    // 分批处理
+    for (let i = 0; i < total; i++) {
+      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+      this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-      // 提交事务
-      await this.exec('COMMIT;', [], timeout);
-    } catch (error) {
-      // 发生错误时回滚事务
-      try {
-        await this.exec('ROLLBACK;', [], timeout);
-        this.log('error', '批量删除数据失败，事务已回滚', error);
-      } catch (rollback_err) {
-        this.log('error', '批量删除数据失败，事务回滚也失败', rollback_err);
+      let batch_sql = '';
+      for (const item of batch) {
+        batch_sql += this.toDelSql(item.query, like);
       }
-      // 记录错误日志
-      this.log('error', 'SQL语句执行失败', error);
+      final_res = await this.exec(batch_sql, [], timeout);
     }
 
-    this.log('success', `批量删除数据完成，共${list.length}条`);
-    return final_res;
-  } catch (err) {
-    this.log('error', '批量删除数据失败', err);
-    // 返回默认操作结果对象，保持返回值类型一致
-    return 0;
+    // 提交事务
+    await this.exec('COMMIT;', [], timeout);
+  } catch (error) {
+    // 发生错误时回滚事务
+    try {
+      await this.exec('ROLLBACK;', [], timeout);
+      this.log('error', '批量删除数据失败，事务已回滚', error);
+    } catch (rollback_err) {
+      this.log('error', '批量删除数据失败，事务回滚也失败', rollback_err);
+    }
+    // 记录错误日志
+    this.log('error', 'SQL语句执行失败', error);
   }
+
+  this.log('success', `批量删除数据完成，共${list.length}条`);
+  return final_res;
 };
 /**
  * 更新多条数据
@@ -1222,58 +1156,48 @@ 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 {
-    if (list.length <= batch_size) {
-      let sql = '';
-      for (const item of list) {
-        sql += this.toSetSql(item.query, item.obj, like);
-      }
-      this.sql = sql;
-      return await this.exec(sql, [], timeout);
+  if (list.length <= batch_size) {
+    let sql = '';
+    for (const item of list) {
+      sql += this.toSetSql(item.query, item.obj, like);
     }
+    this.sql = sql;
+    return await this.exec(sql, [], timeout);
+  }
 
-    // 分批处理大数据量
-    const total = Math.ceil(list.length / batch_size);
-    this.log('info', `开始分批更新数据，共${total}批，每批${batch_size}条`);
-
-    // 使用事务包装整个操作以保证原子性
-    let final_res = null;
-    try {
-      // 开始事务
-      await this.exec('BEGIN;');
+  // 分批处理大数据量
+  const total = Math.ceil(list.length / batch_size);
+  this.log('info', `开始分批更新数据，共${total}批，每批${batch_size}条`);
 
-      // 分批处理
-      for (let i = 0; i < total; i++) {
-        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-        this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
+  // 使用事务包装整个操作以保证原子性
+  let final_res = null;
+  try {
+    // 开始事务
+    await this.exec('BEGIN;');
 
-        let batch_sql = '';
-        for (const item of batch) {
-          batch_sql += this.toSetSql(item.query, item.obj, like);
-        }
+    // 分批处理
+    for (let i = 0; i < total; i++) {
+      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+      this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-        final_res = await this.exec(batch_sql, [], timeout);
+      let batch_sql = '';
+      for (const item of batch) {
+        batch_sql += this.toSetSql(item.query, item.obj, like);
       }
 
-      // 提交事务
-      await this.exec('COMMIT;', [], timeout);
-    } catch (error) {
-      // 发生错误时回滚事务
-      try {
-        await this.exec('ROLLBACK;', [], timeout);
-        this.log('error', '批量更新数据失败，事务已回滚', error);
-      } catch (rollback_err) {
-        this.log('error', '批量更新数据失败，事务回滚也失败', rollback_err);
-      }
+      final_res = await this.exec(batch_sql, [], timeout);
     }
 
-    this.log('success', `批量更新数据完成，共${list.length}条`);
-    return final_res;
-  } catch (err) {
-    this.log('error', '批量更新数据失败', err);
-    // 返回默认操作结果对象，保持返回值类型一致
-    return 0;
+    // 提交事务
+    await this.exec('COMMIT;', [], timeout);
+  } catch (error) {
+    // 发生错误时回滚事务
+    await this.exec('ROLLBACK;', [], timeout);
+    this.log('error', '批量更新数据失败，事务已回滚', error);
   }
+
+  this.log('success', `批量更新数据完成，共${list.length}条`);
+  return final_res;
 };
 
 /* 辅助类 */
@@ -1490,36 +1414,30 @@ Sql.prototype.model = function (model) {
  * @returns {Promise | object | null} 查询结果
  */
 Sql.prototype.getObj = async function (query, sort, view, like, timeout = 30000) {
-  try {
-    // 保存当前分页设置
-    const old_page = this.page;
-    const 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 = size;
-
-    var obj = null;
-    if (list.length > 0) {
-      obj = list[0];
-      if (this.key) {
-        obj = this.model(obj);
-      }
+  // 保存当前分页设置
+  const old_page = this.page;
+  const 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 = 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;
 };
 
 /**
@@ -1528,65 +1446,61 @@ Sql.prototype.getObj = async function (query, sort, view, like, timeout = 30000)
  * @returns {Promise<boolean>} 是否加载成功
  */
 Sql.prototype.load = async function (file) {
-  try {
-    // 记录操作日志
-    if (this.config && this.config.debug) {
-      this.log('debug', `开始从文件加载数据库`, {
-        file: file
-      });
-    }
+  // 记录操作日志
+  if (this.config && this.config.debug) {
+    this.log('debug', `开始从文件加载数据库`, {
+      file: file
+    });
+  }
 
-    // 检查文件是否存在
-    if (!file.hasFile()) {
-      throw new Error(`SQL文件不存在: ${file}`);
-    }
+  // 检查文件是否存在
+  if (!file.hasFile()) {
+    throw new Error(`SQL文件不存在: ${file}`);
+  }
 
-    // 读取SQL文件内容
-    const sql_content = await $.file.readText(file);
+  // 读取SQL文件内容
+  const sql_content = await $.file.readText(file);
 
-    if (!sql_content || sql_content.trim() === '') {
-      throw new Error(`SQL文件内容为空: ${file}`);
-    }
+  if (!sql_content || sql_content.trim() === '') {
+    throw new Error(`SQL文件内容为空: ${file}`);
+  }
 
-    // 分割SQL语句（按分号分割，但需要注意处理字符串中的分号）
-    const sql_stmts = this._splitSqlStatements(sql_content);
+  // 分割SQL语句（按分号分割，但需要注意处理字符串中的分号）
+  const sql_stmts = this._splitSqlStatements(sql_content);
 
-    // 开始事务执行SQL语句
-    await this.exec('BEGIN TRANSACTION');
+  // 开始事务执行SQL语句
+  await this.exec('BEGIN TRANSACTION');
 
-    try {
-      // 逐个执行SQL语句
-      for (const sql of sql_stmts) {
-        const trim_sql = sql.trim();
-        if (trim_sql) {
-          await this.exec(trim_sql);
-        }
+  try {
+    // 逐个执行SQL语句
+    for (const sql of sql_stmts) {
+      const trim_sql = sql.trim();
+      if (trim_sql) {
+        await this.exec(trim_sql);
       }
+    }
 
-      // 提交事务
-      await this.exec('COMMIT');
-
-      if (this.config && this.config.debug) {
-        this.log('info', `数据库加载成功`, {
-          file: file,
-          stmt_num: sql_stmts.length
-        });
-      }
+    // 提交事务
+    await this.exec('COMMIT');
 
-      return true;
-    } catch (err) {
-      // 回滚事务
-      await this.exec('ROLLBACK').catch(rollback_err => {
-        this.log('error', '事务回滚失败', rollback_err);
+    if (this.config && this.config.debug) {
+      this.log('info', `数据库加载成功`, {
+        file: file,
+        stmt_num: sql_stmts.length
       });
-
-      // 记录错误日志
-      this.log('error', 'SQL语句执行失败', err);
     }
-  } catch (error) {
+
+    return true;
+  } catch (err) {
+    // 回滚事务
+    await this.exec('ROLLBACK').catch(rollback_err => {
+      this.log('error', '事务回滚失败', rollback_err);
+    });
+
     // 记录错误日志
-    this.log('error', '数据库加载失败', error);
+    this.log('error', 'SQL语句执行失败', err);
   }
+  return false;
 };
 
 /**
@@ -1681,25 +1595,20 @@ Sql.prototype._splitSqlStatements = function (sql_content) {
  * @private
  */
 Sql.prototype._getCreateTableSql = async function () {
-  try {
-    // 查询表结构信息（SQLite 使用 sqlite_master 表）
-    const sql = `SELECT sql FROM sqlite_master WHERE type='table' AND name='${this.table}'`;
-    const result = await this.run(sql);
-
-    if (result && result.length > 0 && result[0].sql) {
-      // 在创建表语句中添加 IF NOT EXISTS 条件
-      let create_sql = result[0].sql;
-      if (create_sql.toUpperCase().startsWith('CREATE TABLE')) {
-        create_sql = create_sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS');
-      }
-      return create_sql + ';';
+  // 查询表结构信息（SQLite 使用 sqlite_master 表）
+  const sql = `SELECT sql FROM sqlite_master WHERE type='table' AND name='${this.table}'`;
+  const result = await this.run(sql);
+
+  if (result && result.length > 0 && result[0].sql) {
+    // 在创建表语句中添加 IF NOT EXISTS 条件
+    let create_sql = result[0].sql;
+    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 '';
 };
 
 /**
@@ -1717,54 +1626,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;
 };
 
 /**
@@ -1781,32 +1684,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 sql_content = fs.readFileSync(file, 'utf8');
+  // 读取 SQL 文件
+  const sql_content = fs.readFileSync(file, 'utf8');
 
-    // 解析 SQL 语句
-    const stmts = this._parseSqlStatements(sql_content);
+  // 解析 SQL 语句
+  const stmts = this._parseSqlStatements(sql_content);
 
-    // 执行每个 SQL 语句
-    for (const stmt of stmts) {
-      if (stmt.trim() && !stmt.startsWith('--')) {
-        await this.exec(stmt);
-      }
+  // 执行每个 SQL 语句
+  for (const stmt of stmts) {
+    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;
 };
 
 /**