mm_sqlite 1.3.2 → 1.3.3

package/sql.js

@@ -0,0 +1,1972 @@
+/**
+ * @fileOverview sql语句帮助类函数
+ * @author <a href="http://qww.elins.cn">邱文武</a>
+ * @version 1.2
+ */
+const SqlString = require('sqlstring');
+const { Base } = require('mm_expand');
+
+function escape(value, stringifyObjects, timeZone) {
+  return SqlString.escape(value, stringifyObjects, timeZone);
+}
+
+function escapeId(value, forbidQualified) {
+  return SqlString.escapeId(value, forbidQualified);
+}
+
+/**
+ * @class 数据库语法通用类
+ * @property {Function} filter 设置并过滤参数
+ */
+class Sql extends Base {
+  /**
+   * @description 数据库管理器
+   * @param {Function} run 查询函数
+   * @param {Function} exec 更改函数
+   */
+  constructor(run, exec) {
+    super();
+    /**
+     * 查询函数
+     */
+    this.run = run;
+    /**
+     * 更改函数 用于增删改
+     */
+    this.exec = exec;
+    /**
+     * 规避SQL注入函数
+     * @param {object} value 值
+     * @returns {string} 返回执行结果
+     */
+    this.escape = function (value) {
+      return escape(value);
+    };
+
+    /**
+     * 规避排序、SQL注入函数
+     * @param {string} key 键
+     * @returns {string} 返回执行结果
+     */
+    this.escapeId = function (key) {
+      return escapeId(key);
+    };
+
+    /**
+     * sql语句
+     */
+    this.sql = '';
+    /**
+     * 错误提示
+     */
+    this.error;
+    /**
+     * 查询结果
+     */
+    this.results = [];
+
+    /**
+     * 表名
+     */
+    this.table = '';
+    /**
+     * 显示页
+     */
+    this.page = 0;
+    /**
+     * 显示条数
+     */
+    this.size = 30;
+    /**
+     * 请求方式 add、del、set、get、import、export等，跟函数名一致
+     */
+    this.method = '';
+
+    /**
+     * 显示的字段
+     */
+    this.field = '';
+
+    /**
+     * 排序方式
+     */
+    this.orderby = '';
+
+    /**
+     * 查询分组
+     */
+    this.groupby = '';
+
+    /**
+     * 是否统计查询结果数
+     */
+    this.count_ret = 'false';
+
+    /**
+     * 过滤查询参数字典
+     */
+    this.config = {
+      /**
+       * 分隔符 用于查询时的多条件处理
+       */
+      'separator': '|',
+      /**
+       * 过滤
+       */
+      'filter': {
+        /**
+         * 表名
+         */
+        'table': 'table',
+        /**
+         * 查询的页码
+         */
+        'page': 'page',
+        /**
+         * 查询每页条数
+         */
+        'size': 'size',
+        /**
+         * 操作方式: 传入参数method=add, 支持参数 add增、del删、set改、get查，为空则为get
+         */
+        'method': 'method',
+        /**
+         * 排序
+         */
+        'orderby': 'orderby',
+        /**
+         * 查询显示的字段
+         */
+        'field': 'field',
+        /**
+         * 统计结果: 统计符合条件的结果数，只有当page等于1或0时才会统计
+         */
+        'count_ret': 'count_ret'
+      }
+    };
+
+    this.like = false;
+  }
+}
+
+/**
+ * @description 清空查询条件
+ * @returns {object} 返回当前对象
+ */
+Sql.prototype.clear = function () {
+  this.where = '';
+  this.set = '';
+  this.order = '';
+  this.view = '';
+  this.sql = '';
+  this.error = '';
+  this.like = true;
+  this.config = {};
+  this.param = {};
+  this.page = 0;
+  this.size = 0;
+  this.run = null;
+  this.exec = null;
+  return this;
+};
+
+/**
+ * @description 过滤查询参数
+ * @param {object} query 查询参数
+ */
+Sql.prototype.filter = function (query) {
+  var m = this.config.filter;
+  for (var k in m) {
+    var key = m[k];
+    if (query[key]) {
+      this[k] = query[key];
+      delete query[key];
+    }
+  }
+};
+
+/**
+ * 查询条件拼接
+ * @param {string} where 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @returns {string} 返回查询条件语句
+ */
+Sql.prototype.toQuery = function (where, sort, view) {
+  if (!view) {
+    view = '*';
+  }
+  
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `SELECT ${view} FROM \`${this.table}\``;
+  
+  if (where) {
+    sql += ' WHERE ' + where;
+  }
+  if (sort) {
+    sql += ' ORDER BY ' + sort.replace(/;/, '');
+  }
+  if (this.size && this.page) {
+    var start = this.size * (this.page - 1);
+    sql += ' limit ' + start + ',' + this.size;
+  }
+  return sql;
+};
+/* ===  传字符串参数  === */
+/**
+ * 增加数据
+ * @param {string} key 用作增加的键集合
+ * @param {string} val 用作增加的值集合
+ * @returns {Promise | object} 执行结果
+ */
+Sql.prototype.addSql = function (key, val) {
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `INSERT INTO \`${this.table}\` (${key}) VALUES (${val});`;
+  return this.exec(sql);
+};/**
+ * 删除数据
+ * @param {string} where  删除条件
+ * @returns {Promise | object} 执行结果
+ */
+Sql.prototype.delSql = function (where) {
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
+  return this.exec(sql);
+};
+/**
+ * 修改数据
+ * @param {string} where 查询条件
+ * @param {string} set 修改的键值
+ * @returns {Promise | object} 执行结果
+ */
+Sql.prototype.setSql = function (where, set) {
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
+  return this.exec(sql);
+};
+/**
+ * @description 查询数据
+ * @param {string} where 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 显示的字段
+ * @returns {Promise|Array} 查询结果数组
+ */
+Sql.prototype.getSql = function (where, sort, view) {
+  var sql = this.toQuery(where, sort, view);
+  return this.run(sql);
+};
+
+/**
+ * @description 添加或修改
+ * @param {string} where 查询条件
+ * @param {string} set 修改的键值
+ * @returns {Promise | object} 执行结果
+ */
+Sql.prototype.addOrSetSql = async function (where, set) {
+  if (!where || !set) {
+    return -1;
+  }
+  var count = await this.countSql(where);
+  if (count === 0) {
+    var arr = set.split(',');
+    var key = '';
+    var value = '';
+    for (var i = 0; i < arr.length; i++) {
+      var o = arr[i];
+      var ar = o.split('=');
+      if (ar.length === 2) {
+        key += ',' + ar[0];
+        value += ',' + ar[1];
+      }
+    }
+    return await this.addSql(key.replace(',', ''), value.replace(',', ''));
+  }
+  return await this.setSql(where, set);
+};
+
+/**
+ * @description 查询符合结果总数
+ * @param {string} where 查询条件
+ * @returns {Promise | number} 返回结果总数
+ */
+Sql.prototype.countSql = async function (where) {
+  var sql = 'SELECT count(*) count FROM `' + this.table + '`';
+  if (where) {
+    sql += ' WHERE ' + where;
+  }
+  var n = 0;
+  var arr = await this.run(sql);
+  if (arr.length) {
+    n = arr[0].count;
+  }
+  return n;
+};
+
+/**
+ * @description 查询数据并返回符合条件总数
+ * @param {string} where 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.getCountSql = async function (where, sort, view) {
+  var list = [];
+  var count = await this.countSql(where);
+  if (count > 0) {
+    list = await this.getSql(where, sort, view);
+  }
+  var ret = {
+    list: list,
+    count: count
+  };
+  return ret;
+};
+
+/**
+ * @description 统计学
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @param method
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupMathSql = async function (where, groupby, view, sort, method) {
+  if (!view) {
+    view = '*';
+  }
+  var viewStr = '';
+  if (view.indexOf(',') !== -1) {
+    var arr = view.split(',');
+    for (var i = 0; i < arr.length; i++) {
+      var str = escapeId(arr[i]);
+      viewStr += ',' + method.toUpperCase() + '(' + str + ') ' + method.toLowerCase() + '_' + str.replace(
+        /`/g, '');
+    }
+  } else {
+    viewStr = ',' + method.toUpperCase() + '(' + escapeId(view) + ') ' + method.toLowerCase() + '_' +
+            view.replace(/`/g, '');
+  }
+  var sql = 'SELECT ' + (groupby ? escapeId(groupby) : '') + viewStr + ' FROM `' + this.table + '`';
+  if (where) {
+    sql += ' WHERE ' + where;
+  }
+  if (groupby) {
+    sql += ' GROUP BY ' + escapeId(groupby);
+  }
+  if (sort) {
+    sql += ' ORDER BY ' + sort;
+  }
+  if (this.size && this.page) {
+    var start = this.size * (this.page - 1);
+    sql += ' limit ' + start + ',' + this.size;
+  }
+  return await this.run(sql);
+};
+
+
+/**
+ * @description 分组求平均值
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupAvgSql = async function (where, groupby, view, sort = '') {
+  return await this.groupMathSql(where, groupby, view, sort, 'AVG');
+};
+
+/**
+ * @description 分组合计数值
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupSumSql = async function (where, groupby, view, sort = '') {
+  return await this.groupMathSql(where, groupby, view, sort, 'SUM');
+};
+
+/**
+ * @description 分组合计不同条数
+ * @param {string} where 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param sort
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupCountSql = async function (where, groupby, view, sort = '') {
+  return await this.groupMathSql(where, groupby, view, sort, 'COUNT');
+};
+
+
+/**
+ * @description 统计学
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @param method
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupMath = async function (query, groupby, view, sort, method) {
+  var where = this.toWhere(query, this.like);
+  return await this.groupMathSql(where, groupby, view, sort, method);
+};
+
+/**
+ * @description 分组求平均值
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupAvg = async function (query, groupby, view, sort) {
+  return await this.groupMath(query, groupby, view, sort, 'AVG');
+};
+
+/**
+ * @description 分组合计数值
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param {string} sort 排序方式
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupSum = async function (query, groupby, view, sort) {
+  return await this.groupMath(query, groupby, view, sort, 'SUM');
+};
+
+/**
+ * @description 分组合计不同条数
+ * @param {object} query 查询条件
+ * @param {string} groupby 分组的字段
+ * @param {string} view 返回的字段
+ * @param sort
+ * @returns {Promise | object} 查询到的内容列表和符合条件总数
+ */
+Sql.prototype.groupCount = async function (query, groupby, view, sort) {
+  return await this.groupMath(query, groupby, view, sort, 'COUNT');
+};
+
+/* ===  聚合函数  === */
+/**
+ * @description 求和函数
+ * @param {string} field 字段名
+ * @param {object} query 查询条件
+ * @returns {number} 求和结果
+ */
+Sql.prototype.sum = async function (field, query) {
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须为字符串');
+  }
+  
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+  
+  const result = await this.groupSum(query, '', field, '');
+  const fieldKey = 'sum_' + field.replace(/`/g, '');
+  return result && result.length > 0 ? Number(result[0][fieldKey] || result[0].sum_age) : 0;
+};
+
+/**
+ * @description 最大值函数
+ * @param {string} field 字段名
+ * @param {object} query 查询条件
+ * @returns {number} 最大值结果
+ */
+Sql.prototype.max = async function (field, query) {
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须为字符串');
+  }
+  
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+  
+  const result = await this.groupMath(query, '', field, '', 'MAX');
+  const fieldKey = 'max_' + field.replace(/`/g, '');
+  return result && result.length > 0 ? Number(result[0][fieldKey] || result[0].max_age) : 0;
+};
+
+/**
+ * @description 最小值函数
+ * @param {string} field 字段名
+ * @param {object} query 查询条件
+ * @returns {number} 最小值结果
+ */
+Sql.prototype.min = async function (field, query) {
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须为字符串');
+  }
+  
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+  
+  const result = await this.groupMath(query, '', field, '', 'MIN');
+  const fieldKey = 'min_' + field.replace(/`/g, '');
+  return result && result.length > 0 ? Number(result[0][fieldKey] || result[0].min_age) : 0;
+};
+
+/**
+ * @description 平均值函数
+ * @param {string} field 字段名
+ * @param {object} query 查询条件
+ * @returns {number} 平均值结果
+ */
+Sql.prototype.avg = async function (field, query) {
+  if (!field || typeof field !== 'string') {
+    throw new TypeError('字段名必须为字符串');
+  }
+  
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+  
+  const result = await this.groupMath(query, '', field, '', 'AVG');
+  const fieldKey = 'avg_' + field.replace(/`/g, '');
+  return result && result.length > 0 ? Number(result[0][fieldKey] || result[0].avg_age) : 0;
+};
+
+/* ===  字符串操作函数  === */
+/**
+ * @description 字符串连接函数
+ * @param {...string} args 要连接的字符串参数
+ * @returns {string} 连接后的字符串
+ */
+Sql.prototype.toStr = function (...args) {
+  // 如果没有参数，返回空字符串
+  if (args.length === 0) {
+    return '';
+  }
+  
+  // 将所有参数转换为字符串并用空格连接
+  return args.map(arg => String(arg)).join(' ');
+};
+
+/* ===  备份恢复函数  === */
+/**
+ * @description 备份数据库到 SQL 文件
+ * @param {string} file 备份文件路径
+ * @returns {Promise<boolean>} 备份是否成功
+ */
+Sql.prototype.backup = async function(file) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+  
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+  
+  try {
+    // 获取所有数据
+    const data = await this.getSql('', '', '*');
+    
+    if (!data || !Array.isArray(data)) {
+      throw new Error('获取数据失败');
+    }
+
+    // 构建 SQL 语句
+    let sqlContent = '';
+    
+    // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
+    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`;
+    }
+
+    // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
+    const fs = require('fs');
+    const path = require('path');
+    
+    // 确保目录存在
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    fs.writeFileSync(file, sqlContent, 'utf8');
+    
+    return true;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '备份数据库失败', err);
+    return false;
+  }
+};
+
+/**
+ * @description 从 SQL 文件恢复数据库
+ * @param {string} file 恢复文件路径
+ * @returns {Promise<boolean>} 恢复是否成功
+ */
+Sql.prototype.restore = async function(file) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+  
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+  
+  try {
+    const fs = require('fs');
+    
+    // 检查文件是否存在
+    if (!fs.existsSync(file)) {
+      throw new Error('备份文件不存在');
+    }
+    
+    // 读取文件内容
+    const sqlContent = fs.readFileSync(file, 'utf8');
+    
+    if (!sqlContent) {
+      throw new Error('备份文件为空');
+    }
+    
+    // 解析 SQL 语句（按分号分割，但需要处理字符串中的分号）
+    const statements = this._parseSqlStatements(sqlContent);
+    
+    // 执行所有 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;
+  }
+};
+
+/**
+ * @description 解析 SQL 语句，正确处理字符串中的分号
+ * @param {string} sql SQL 内容
+ * @returns {string[]} SQL 语句数组
+ * @private
+ */
+Sql.prototype._parseSqlStatements = function(sql) {
+  const statements = [];
+  let currentStatement = '';
+  let inString = false;
+  let stringChar = '';
+  
+  for (let i = 0; i < sql.length; i++) {
+    const char = sql[i];
+    
+    if (char === "'" || char === '"') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        // 检查是否是转义字符
+        if (i > 0 && sql[i-1] === '\\') {
+          // 转义字符，继续字符串
+        } else {
+          inString = false;
+          stringChar = '';
+        }
+      }
+    }
+    
+    if (!inString && char === ';') {
+      statements.push(currentStatement.trim());
+      currentStatement = '';
+    } else {
+      currentStatement += char;
+    }
+  }
+  
+  // 添加最后一个语句（如果没有分号结尾）
+  if (currentStatement.trim()) {
+    statements.push(currentStatement.trim());
+  }
+  
+  return statements.filter(stmt => stmt.length > 0);
+};
+
+/* ===  sql语句拼接函数  === */
+/**
+ * @description 转为where语句
+ * @param {object} obj 用作拼接的对象
+ * @param {boolean} like 是否使用like匹配, 默认不使用
+ * @returns {string} where格式sql语句字符串
+ */
+Sql.prototype.toWhere = function (obj, like) {
+  var where = '';
+  if (like === undefined) {
+    like = this.like;
+  }
+  if (like) {
+    for (var k in obj) {
+      var val = obj[k];
+      if (val && typeof (val) === 'string') {
+        val = val.trim("'");
+      }
+      val = escape(val);
+      if (k.endsWith('_min')) {
+        where += ' and ' + escapeId(k.replace('_min', '')) + ' >= ' + val;
+      } else if (k.endsWith('_max')) {
+        where += ' and ' + escapeId(k.replace('_max', '')) + ' <= ' + val;
+      } else if (k.endsWith('_not')) {
+        where += ' and ' + escapeId(k.replace('_not', '')) + ' != ' + val;
+      } else if (k.endsWith('_has')) {
+        var vals = val.trim("'").split(',').map((o) => {
+          return "'" + o + "'";
+        });
+        where += ' and ' + escapeId(k.replace('_has', '')) + ' in (' + vals.join(',') + ')';
+      } else if (k.endsWith('_like')) {
+        where += ' and ' + escapeId(k.replace('_like', '')) + " LIKE '%" + val.trim("'") + "%'";
+      } else if (typeof (val) === 'string' && !/^[0-9]+$/.test(val)) {
+        where += ' and ' + escapeId(k) + " LIKE '%" + val.trim("'") + "%'";
+      } else {
+        where += ' and ' + escapeId(k) + ' = ' + val;
+      }
+    }
+  } else {
+    for (var k in obj) {
+      var val = obj[k];
+      if (val && typeof (val) === 'string') {
+        val = val.trim("'");
+      }
+      val = escape(val);
+      if (k.endsWith('_min')) {
+        where += ' and ' + escapeId(k.replace('_min', '')) + ' >= ' + val;
+      } else if (k.endsWith('_max')) {
+        where += ' and ' + escapeId(k.replace('_max', '')) + ' <= ' + val;
+      } else if (k.endsWith('_not')) {
+        where += ' and ' + escapeId(k.replace('_not', '')) + ' != ' + val;
+      } else if (k.endsWith('_has')) {
+        var vals = val.trim("'").split(',').map((o) => {
+          return "'" + o + "'";
+        });
+        where += ' and ' + escapeId(k.replace('_has', '')) + ' in (' + vals.join(',') + ')';
+      } else {
+        where += ' and ' + escapeId(k) + ' = ' + val;
+      }
+    }
+  }
+  return where.replace(' and ', '');
+};
+
+/**
+ * @description 转为set语句
+ * @param {object} obj 用作拼接的对象
+ * @returns {string} set格式sql语句字符串
+ */
+Sql.prototype.toSet = function (obj) {
+  var set = '';
+  for (var k in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, k)) continue;
+
+    var val = obj[k];
+    if (val === undefined || val === null) continue;
+
+    if (typeof val === 'string') {
+      val = val.trim("'");
+    }
+    val = escape(val);
+
+    if (k.endsWith('_add')) {
+      var k2 = escapeId(k.replace('_add', ''));
+      set += ',' + k2 + ' = ' + k2 + ' + ' + val;
+    } else if (k.endsWith('_del')) {
+      var k3 = escapeId(k.replace('_del', ''));
+      set += ',' + k3 + ' = ' + k3 + ' - ' + val;
+    } else {
+      set += ',' + escapeId(k) + ' = ' + val;
+    }
+  }
+  return set.replace(',', '');
+};
+
+/**
+ * 转添加sql语句
+ * @param {object} item 用作添加的键值
+ * @returns {string} sql语句
+ */
+Sql.prototype.toAddSql = function (item) {
+  if (!this.table || !item || typeof item !== 'object') {
+    throw new Error('表名或数据未设置');
+  }
+
+  let key = '';
+  let value = '';
+
+  for (const k in item) {
+    if (!Object.prototype.hasOwnProperty.call(item, k)) continue;
+
+    key += ',' + escapeId(k);
+    let val = item[k];
+    if (typeof val === 'string') {
+      val = val.trim("'");
+    }
+    value += ',' + escape(val);
+  }
+
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `INSERT INTO \`${this.table}\` (${key.replace(',', '')}) VALUES (${value.replace(',', '')});`;
+
+  return sql;
+};
+
+/**
+ * 转删除sql语句
+ * @param {object} query 查询键值
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {string} sql语句
+ */
+Sql.prototype.toDelSql = function (query, like) {
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+  const where = this.toWhere(query, like);
+  
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
+  
+  return sql;
+};
+
+/**
+ * 转修改sql语句
+ * @param {object} query 查询的键值集合
+ * @param {object} item 修改的键值集合
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {string} sql语句
+ */
+Sql.prototype.toSetSql = function (query, item, like) {
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+  const where = this.toWhere(query, like);
+  const set = this.toSet(item);
+  
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
+  
+  return sql;
+};
+
+/**
+ * @description 转查询sql语句
+ * @param {object} query 查询键值集合
+ * @param {string} sort 排序规则
+ * @param {string} view 显示的字段
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {string} sql语句
+ */
+Sql.prototype.toGetSql = function (query, sort, view, like) {
+  var where = this.toWhere(query, like);
+  return this.toQuery(where, sort, view);
+};
+/* ===  传入对象操作  === */
+/**
+ * @description 增加数据
+ * @param {object} body 添加的对象
+ * @returns {Promise | object} 执行结果
+ */
+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);
+
+    return bl;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '添加数据失败', err);
+    // 返回默认操作结果对象，保持返回值类型一致
+    return 0;
+  }
+};
+/**
+ * @description 删除数据
+ * @param {object} query 查询条件集合
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise | object} 执行结果
+ */
+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;
+  }
+};
+
+/**
+ * @description 修改数据
+ * @param {object} query 查询条件集合
+ * @param {object} body 修改的键值集合
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise | object} 执行结果
+ */
+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;
+  }
+};
+
+/**
+ * @description 查询数据
+ * @param {object} query 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @returns {Promise|Array} 查询结果
+ */
+Sql.prototype.get = async function (query, sort, view, like, timeout = 30000) {
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+
+  try {
+    // 使用Promise.race实现超时控制
+    const timeout_promise = new Promise((unused_resolve, reject) => {
+      setTimeout(() => reject(new Error('查询操作超时')), timeout);
+    });
+    
+    return await Promise.race([
+      (async () => {
+        // 生成SQL并执行
+        var sql = this.toGetSql(query, sort, view, like);
+        var list = await this.run(sql);
+        return list;
+      })(),
+      timeout_promise
+    ]);
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '查询数据失败', err);
+    // 返回空数组作为默认值，保持返回值类型一致
+    return [];
+  }
+};
+
+/**
+ * 添加或修改数据（存在则修改，不存在则添加）
+ * @param {object | string} where 查询条件
+ * @param {object | string} set 要设置的数据
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @returns {Promise<object>} 执行结果
+ */
+Sql.prototype.addOrSet = async function (where, set, like) {
+  if (!this.table || !where || !set) {
+    throw new Error('表名、条件或数据未设置');
+  }
+  try {
+    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 (count === 0) {
+      let key = '';
+      let value = '';
+
+      if (typeof set === 'string') {
+        const arr = set.split(',');
+        for (const o of arr) {
+          const ar = o.split('=');
+          if (ar.length === 2) {
+            key += ',' + ar[0];
+            value += ',' + ar[1];
+          }
+        }
+      } else {
+        for (const k in set) {
+          if (!Object.prototype.hasOwnProperty.call(set, k)) continue;
+
+          key += ',' + this.escapeId(k);
+          let val = set[k];
+          if (typeof val === 'string') {
+            val = val.trim("'");
+          }
+          value += ',' + this.escape(val);
+        }
+      }
+
+      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);
+      }
+
+      const bl1 = await this.setSql(where_str, set_vals);
+
+      return bl1;
+    }
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '添加或修改数据失败', err);
+    // 返回默认操作结果对象，保持返回值类型一致
+    return 0;
+  }
+};
+
+/**
+ * 统计记录数
+ * @param {object} query 查询条件
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @returns {Promise | number} 记录数
+ */
+Sql.prototype.count = async function (query, like, timeout = 30000) {
+  if (!this.table) {
+    throw new Error('表名未设置');
+  }
+
+  try {
+    // 添加超时控制
+    const timeout_promise = new Promise((unused_resolve, reject) => {
+      setTimeout(() => reject(new Error('统计操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 正确生成count SQL
+        const where = typeof query === 'string' ? query : await this.toWhere(query, like);
+        const sql = 'SELECT COUNT(*) as num FROM `' + this.table + '`' + (where ? ' WHERE ' + where : '');
+        this.sql = sql;
+        const list = await this.run(sql);
+        const total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
+
+        return total;
+      })(),
+      timeout_promise
+    ]);
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '统计记录数失败', err);
+    // 返回0作为默认统计值，保持返回值类型一致
+    return 0;
+  }
+};
+
+/**
+ * 查询数据并返回符合条件总数
+ * @param {object} query 查询条件
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @returns {Promise<number>} 记录数
+ */
+Sql.prototype.getCount = async function (query, like, timeout = 30000) {
+  return await this.count(query, like, timeout);
+};
+
+/* ===  传入数组操作  === */
+/**
+ * 添加多条数据
+ * @param {Array} list 对象数组
+ * @param {number} batch_size 批量大小，默认100
+ * @param {number} timeout 超时时间，默认60000毫秒
+ * @returns {Promise | object} 执行结果
+ */
+Sql.prototype.addList = async function (list, batch_size = 100, timeout = 60000) {
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+  try {
+    // 添加整体操作超时控制
+    const timeout_promise = new Promise((unused_resolve, reject) => {
+      setTimeout(() => reject(new Error('批量添加数据操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 如果数据量较小，直接处理
+        if (list.length <= batch_size) {
+          // 使用批量插入语法，不使用事务包装
+          this.sql = this.toBatchAddSql(list);
+          return await this.exec(this.sql);
+        }
+
+        // 分批处理大数据量
+        const total = Math.ceil(list.length / batch_size);
+        $.log.info(`开始分批添加数据，共${total}批，每批${batch_size}条`);
+
+        // 分批执行，每批一个单独的批量插入语句
+        let final_res = null;
+        for (let i = 0; i < total; i++) {
+          const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+          $.log.debug(`处理第${i + 1}/${total}批数据，${batch.length}条`);
+
+          // 生成批量插入SQL
+          const batch_sql = this.toBatchAddSql(batch);
+          this.sql = batch_sql;
+
+          // 为每批操作添加超时控制
+          final_res = await Promise.race([
+            this.exec(batch_sql),
+            new Promise((unused_resolve, reject) => {
+              setTimeout(() => reject(new Error(`第${i + 1}批数据处理超时`)), timeout / total);
+            })
+          ]);
+        }
+
+        $.log.success(`批量添加数据完成，共${list.length}条`);
+        return final_res;
+      })(),
+      timeout_promise
+    ]);
+  } catch (error) {
+    this.log('error', '批量添加数据失败', error);
+    // 返回默认操作结果对象，保持返回值类型一致
+    return 0;
+  }
+};
+
+/**
+ * 生成批量插入SQL语句
+ * @param {Array} list 数据列表
+ * @returns {string} 批量插入SQL语句
+ */
+Sql.prototype.toBatchAddSql = function (list) {
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+
+  // 获取第一个对象的键名作为列名
+  const first_obj = list[0];
+  if (!first_obj || typeof first_obj !== 'object') {
+    throw new Error('数据格式错误');
+  }
+
+  let keys = [];
+  for (const k in first_obj) {
+    if (Object.prototype.hasOwnProperty.call(first_obj, k)) {
+      keys.push(this.escapeId(k));
+    }
+  }
+
+  // 构建列名部分
+  const columns = keys.join(',');
+
+  // 构建值部分
+  const values = [];
+  for (const item of list) {
+    const values = [];
+    for (const k of keys) {
+      const key = k.replace(/`/g, '');
+      let val = item[key];
+      if (typeof val === 'string') {
+        val = val.trim("'");
+      }
+      values.push(this.escape(val));
+    }
+    values.push(`(${values.join(',')})`);
+  }
+
+  // 生成最终SQL
+  const sql = `INSERT INTO \`${this.table}\` (${columns}) VALUES ${values.join(',')}`;
+  return sql;
+};
+
+/**
+ * 删除多条数据
+ * @param {Array} list 对象数组
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} batch_size 每批处理数量，默认100
+ * @param {number} timeout 超时时间（毫秒），默认60000
+ * @returns {Promise<object>} 执行结果
+ */
+Sql.prototype.delList = async function (list, like, batch_size = 100, timeout = 60000) {
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+  try {
+    // 添加整体操作超时控制
+    const timeout_promise = new Promise((unused_resolve, reject) => {
+      setTimeout(() => reject(new Error('批量删除数据操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 如果数据量较小，直接处理
+        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 total = Math.ceil(list.length / batch_size);
+        $.log.info(`开始分批删除数据，共${total}批，每批${batch_size}条`);
+
+        // 使用事务包装整个操作以保证原子性
+        let final_res = null;
+        try {
+          // 开始事务
+          await this.exec('BEGIN;', 15000);
+
+          // 分批处理
+          for (let i = 0; i < total; i++) {
+            const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+            $.log.debug(`处理第${i + 1}/${total}批数据，${batch.length}条`);
+
+            let batch_sql = '';
+            for (const item of batch) {
+              batch_sql += this.toDelSql(item.query, like);
+            }
+
+            // 为每批操作添加超时控制
+            final_res = await Promise.race([
+              this.exec(batch_sql),
+              new Promise((unused_resolve, reject) => {
+                setTimeout(() => reject(new Error(`第${i + 1}批数据删除超时`)), timeout / total);
+              })
+            ]);
+          }
+
+          // 提交事务
+          await this.exec('COMMIT;', 15000);
+        } catch (error) {
+          // 发生错误时回滚事务
+          try {
+            await this.exec('ROLLBACK;', 15000);
+            this.log('error', '批量删除数据失败，事务已回滚', error);
+          } catch (rollback_err) {
+            this.log('error', '批量删除数据失败，事务回滚也失败', rollback_err);
+          }
+          // 记录错误日志
+          this.log('error', 'SQL语句执行失败', error);
+        }
+
+        $.log.success(`批量删除数据完成，共${list.length}条`);
+        return final_res;
+      })(),
+      timeout_promise
+    ]);
+  } catch (err) {
+    this.log('error', '批量删除数据失败', err);
+    // 返回默认操作结果对象，保持返回值类型一致
+    return 0;
+  }
+};
+/**
+ * 更新多条数据
+ * @param {Array} list 对象数组
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} batch_size 每批处理数量，默认100
+ * @param {number} timeout 超时时间（毫秒），默认60000
+ * @returns {Promise<object>} 执行结果
+ */
+Sql.prototype.setList = async function (list, like = false, batch_size = 100, timeout = 60000) {
+  if (!this.table || !Array.isArray(list) || list.length === 0) {
+    throw new Error('表名或数据列表未设置');
+  }
+  try {
+    // 添加整体操作超时控制
+    const timeout_promise = new Promise((unused_resolve, reject) => {
+      setTimeout(() => reject(new Error('批量更新数据操作超时')), timeout);
+    });
+
+    return await Promise.race([
+      (async () => {
+        // 如果数据量较小，直接处理
+        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);
+        }
+
+        // 分批处理大数据量
+        const total = Math.ceil(list.length / batch_size);
+        $.log.info(`开始分批更新数据，共${total}批，每批${batch_size}条`);
+
+        // 使用事务包装整个操作以保证原子性
+        let final_res = null;
+        try {
+          // 开始事务
+          await this.exec('BEGIN;', 15000);
+
+          // 分批处理
+          for (let i = 0; i < total; i++) {
+            const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+            $.log.debug(`处理第${i + 1}/${total}批数据，${batch.length}条`);
+
+            let batch_sql = '';
+            for (const item of batch) {
+              batch_sql += this.toSetSql(item.query, item.obj, like);
+            }
+
+            // 为每批操作添加超时控制
+            final_res = await Promise.race([
+              this.exec(batch_sql),
+              new Promise((unused_resolve, reject) => {
+                setTimeout(() => reject(new Error(`第${i + 1}批数据更新超时`)), timeout / total);
+              })
+            ]);
+          }
+
+          // 提交事务
+          await this.exec('COMMIT;', 15000);
+        } catch (error) {
+          // 发生错误时回滚事务
+          try {
+            await this.exec('ROLLBACK;', 15000);
+            this.log('error', '批量更新数据失败，事务已回滚', error);
+          } catch (rollback_err) {
+            this.log('error', '批量更新数据失败，事务回滚也失败', rollback_err);
+          }
+        }
+
+        $.log.success(`批量更新数据完成，共${list.length}条`);
+        return final_res;
+      })(),
+      timeout_promise
+    ]);
+  } catch (err) {
+    this.log('error', '批量更新数据失败', err);
+    // 返回默认操作结果对象，保持返回值类型一致
+    return 0;
+  }
+};
+
+/* 辅助类 */
+/**
+ * 判断SQL模板是否包含某些参数
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt sql模板集合
+ * @returns {boolean} 有则返回true，没有则返回false
+ */
+Sql.prototype.hasPrm = function (param_dt, sql_dt) {
+  var bl = false;
+  for (var key in sql_dt) {
+    if (Object.prototype.hasOwnProperty.call(sql_dt, key)) {
+      var value = param_dt[key];
+      if (value !== undefined && value !== null && value !== '') {
+        bl = true;
+        break;
+      }
+    }
+  }
+  return bl;
+};
+
+/**
+ * 判断某些参数是否没有SQL模板
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt sql模板集合
+ * @returns {string|undefined} 没有模板则返回名称，都有则返回undefined
+ */
+Sql.prototype.noPrm = function (param_dt, sql_dt) {
+  var name;
+  for (var key in param_dt) {
+    if (!sql_dt[key]) {
+      name = key;
+      break;
+    }
+  }
+  return name;
+};
+
+/**
+ * 过滤参数，仅保留没有sql模板的参数
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt sql模板集合
+ * @returns {object} 返回过滤后的参数集合
+ */
+Sql.prototype.filtPrm = function (param_dt, sql_dt) {
+  var dt = [];
+  for (var key in param_dt) {
+    if (!sql_dt[key]) {
+      dt.Add(key, o.Value);
+    }
+  }
+  return dt;
+};
+
+/**
+ * 通过模板拼接查询参数
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt 模板集合
+ * @returns {string} 返回拼接的查询参数
+ */
+Sql.prototype.tplQuery = function (param_dt, sql_dt) {
+  var sql = '';
+  if (sql_dt) {
+    var l = this.config.separator;
+    if (l) {
+      for (var key in param_dt) {
+        var value = param_dt[key] + '';
+        var arr = value.split(l);
+        var tpl = sql_dt[key];
+        if (tpl) {
+          if (arr.length > 1) {
+            // 如果数量大于0，则增加多条件
+            var sl = '(';
+            var len = arr.length;
+            for (var i = 0; i < len; i++) {
+              // 使用直接替换方式，避免模板替换错误
+              const escaped_val = this.escape(arr[i]);
+              sl += ' || ' + tpl.replaceAll('{0}', escaped_val);
+            }
+            sl = sl.replace(' || ', '') + ')';
+            sql += ' && ' + sl;
+          } else {
+            // 使用直接替换方式，避免模板替换错误
+            const escaped_val = this.escape(value);
+            sql += ' && ' + tpl.replaceAll('{0}', escaped_val);
+          }
+        } else {
+          if (arr.length > 1) {
+            // 如果数量大于0，则增加多条件
+            var sl = '(';
+            var len = arr.length;
+            for (var i = 0; i < len; i++) {
+              sl += ' || ' + this.escapeId(key) + ' = ' + this.escape(arr[i]);
+            }
+            sl = sl.replace(' || ', '') + ')';
+            sql += ' && ' + sl;
+          } else {
+            sql += ' && ' + this.escapeId(key) + ' = ' + this.escape(value);
+          }
+        }
+      }
+    } else {
+      for (var key in param_dt) {
+        var value = this.escape(param_dt[key]);
+        if (sql_dt[key]) {
+          // 使用直接替换方式，避免模板替换错误
+          sql += ' && ' + sql_dt[key].replaceAll('{0}', value);
+        } else {
+          sql += ' && ' + this.escapeId(key) + ' = ' + value;
+        }
+      }
+    }
+  } else {
+    // 如果没有模板，则直接拼接参数
+    var l = this.config.separator;
+    if (l) {
+      // 使用分隔数组拼接
+      for (var key in param_dt) {
+        var value = param_dt[key];
+        var arr = value.split(l);
+        if (arr.length > 1) {
+          // 如果数量大于0，则增加多条件
+          var sl = '(';
+          var len = arr.length;
+          for (var i = 0; i < len; i++) {
+            sl += ' || ' + this.escapeId(key) + ' = ' + this.escape(arr[i]);
+          }
+          sl = sl.replace(' || ', '') + ')';
+          sql += ' && ' + sl;
+        } else {
+          sql += ' && ' + this.escapeId(key) + ' = ' + this.escape(value);
+        }
+      }
+    } else {
+      // 直接拼接
+      for (var key in param_dt) {
+        sql += ' && ' + this.escapeId(key) + ' = ' + this.escape(param_dt[key]);
+      }
+    }
+  }
+  return sql.replace(' && ', '');
+};
+
+/**
+ * 通过模板拼接修改参数
+ * @param {object} param_dt 参数集合
+ * @param {object} sql_dt 模板集合
+ * @returns {string} 返回拼接的查询参数
+ */
+Sql.prototype.tplBody = function (param_dt, sql_dt) {
+  var sql = '';
+  if (!sql_dt || sql_dt.length === 0) {
+    for (var key in param_dt) {
+      sql += ' , ' + this.escapeId(key) + ' = ' + this.escape(val[key]);
+    }
+  } else {
+    for (var key in param_dt) {
+      var value = this.escape(param_dt[key]);
+      if (sql_dt[key]) {
+        // 使用直接替换方式，避免模板替换错误
+        const replaced = sql_dt[key].replace('{0}', value);
+        sql += ' , ' + replaced.replace('+ -', '- ').replace('- -', '+ ');
+      } else {
+        sql += ' , ' + this.escapeId(key) + ' = ' + value;
+      }
+    }
+  }
+  return sql.replace(' , ', '');
+};
+
+/**
+ * 构建实体模型
+ * @param {object} model 模型对象
+ * @returns {object} 返回监听操作的对象
+ */
+Sql.prototype.model = function (model) {
+  var self = this;
+  return new Proxy(model, {
+    set: function (obj, prop, value) {
+      var modified_obj = { ...obj };
+      if (typeof (value) === 'number') {
+        var n = obj[prop];
+        var cha = value - n;
+        if (cha > 0) {
+          self.setSql('`' + self.key + '`=' + obj[self.key], '`' + prop + '`=`' +
+            prop + '` + ' + cha);
+        } else if (cha < 0) {
+          self.setSql('`' + self.key + '`=' + obj[self.key], '`' + prop + '`=`' +
+            prop + '` - ' + (-cha));
+        } else {
+          self.setSql('`' + self.key + '`=' + obj[self.key], '`' + prop + '`=' +
+            value);
+        }
+      } else {
+        var query = {};
+        query[self.key] = obj[self.key];
+        var set = {};
+        set[prop] = value;
+        self.set(query, set);
+      }
+      modified_obj[prop] = value;
+      return modified_obj;
+    }
+  });
+};
+
+/**
+ * 查询单条数据
+ * @param {object} query 查询条件
+ * @param {string} sort 排序
+ * @param {string} view 返回的字段
+ * @param {boolean} like 是否使用like匹配, 为空使用默认方式
+ * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @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);
+      }
+    }
+
+    return obj;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '查询单条数据失败', err);
+  }
+  return null;
+};
+
+/**
+ * 从SQL文件加载数据库
+ * @param {string} file - SQL文件路径
+ * @returns {Promise<boolean>} 是否加载成功
+ */
+Sql.prototype.load = async function (file) {
+  try {
+    // 记录操作日志
+    if (this.config && this.config.debug) {
+      $.log.debug(`[${this.constructor.name}] [load] 开始从文件加载数据库`, {
+        file: file
+      });
+    }
+
+    // 检查文件是否存在
+    if (!file.hasFile()) {
+      throw new Error(`SQL文件不存在: ${file}`);
+    }
+
+    // 读取SQL文件内容
+    const sql_content = await $.file.readText(file);
+
+    if (!sql_content || sql_content.trim() === '') {
+      throw new Error(`SQL文件内容为空: ${file}`);
+    }
+
+    // 分割SQL语句（按分号分割，但需要注意处理字符串中的分号）
+    const sql_stmts = this._splitSqlStatements(sql_content);
+
+    // 开始事务执行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);
+        }
+      }
+
+      // 提交事务
+      await this.exec('COMMIT');
+
+      if (this.config && this.config.debug) {
+        $.log.info(`[${this.constructor.name}] [load] 数据库加载成功`, {
+          file: file,
+          stmt_num: sqlStatements.length
+        });
+      }
+
+      return true;
+    } catch (err) {
+      // 回滚事务
+      await this.exec('ROLLBACK').catch(rollback_err => {
+        this.log('error', '事务回滚失败', rollback_err);
+      });
+
+      // 记录错误日志
+      this.log('error', 'SQL语句执行失败', err);
+    }
+  } catch (error) {
+    // 记录错误日志
+    this.log('error', '数据库加载失败', error);
+  }
+};
+
+/**
+ * 分割SQL语句
+ * @private
+ * @param {string} sql_content - SQL内容
+ * @returns {Array} SQL语句数组
+ */
+Sql.prototype._splitSqlStatements = function (sql_content) {
+  const stmts = [];
+  let in_str = false;
+  let str_char = '';
+  let in_cmt = 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] : '';
+
+    // 处理注释
+    if (!in_str && !in_cmt && char === '-' && next_char === '-') {
+      in_cmt = true;
+      i++; // 跳过第二个'-'
+      continue;
+    }
+
+    if (in_cmt && char === '\n') {
+      in_cmt = false;
+      continue;
+    }
+
+    if (in_cmt) {
+      continue;
+    }
+
+    // 处理多行注释
+    if (!in_str && !in_cmt && char === '/' && next_char === '*') {
+      in_cmt = true;
+      i++; // 跳过'*'
+      continue;
+    }
+
+    if (in_cmt && char === '*' && next_char === '/') {
+      in_cmt = false;
+      i++; // 跳过'/'
+      continue;
+    }
+
+    // 处理字符串
+    if (!in_cmt && (char === "'" || char === '"') && (!in_str || str_char === char)) {
+      // 检查是否是转义的引号
+      let escaped = false;
+      for (let j = i - 1; j >= 0; j--) {
+        if (sql_content[j] === '\\') {
+          escaped = !escaped;
+        } else {
+          break;
+        }
+      }
+
+      if (!escaped) {
+        if (in_str && str_char === char) {
+          in_str = false;
+          str_char = '';
+        } else if (!in_str) {
+          in_str = true;
+          str_char = char;
+        }
+      }
+    }
+
+    // 分割语句
+    if (!in_str && !in_cmt && char === ';') {
+      stmts.push(cur_stmt.trim());
+      cur_stmt = '';
+    } else {
+      cur_stmt += char;
+    }
+  }
+
+  // 添加最后一个语句（如果有）
+  if (cur_stmt.trim()) {
+    stmts.push(cur_stmt.trim());
+  }
+
+  return stmts;
+};
+
+/**
+ * @description 获取创建表的 SQL 语句
+ * @returns {Promise<string>} 创建表的 SQL 语句
+ * @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 + ';';
+    }
+    
+    return '';
+  } catch (err) {
+    this.log('warn', '获取表结构失败，将仅备份数据', err);
+    return '';
+  }
+};
+
+/**
+ * @description 备份数据库到 SQL 文件
+ * @param {string} file 备份文件路径
+ * @param {boolean} create 是否导出创建表语句，默认为false
+ * @returns {Promise<boolean>} 备份是否成功
+ */
+Sql.prototype.backup = async function(file, create = false) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+
+  try {
+    // 获取所有数据
+    const data = await this.getSql('', '', '*');
+    
+    if (!data || !Array.isArray(data)) {
+      throw new Error('获取数据失败');
+    }
+
+    // 构建 SQL 语句
+    let sql_content = '';
+    
+    // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
+    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';
+      }
+    }
+    
+    // 添加数据插入语句
+    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');
+    
+    // 确保目录存在
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    fs.writeFileSync(file, sql_content, 'utf8');
+    
+    return true;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '备份数据库失败', err);
+    return false;
+  }
+};
+
+/**
+ * @description 从 SQL 文件恢复数据库
+ * @param {string} file 备份文件路径
+ * @returns {Promise<boolean>} 恢复是否成功
+ */
+Sql.prototype.restore = async function(file) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+
+  try {
+    const fs = require('fs');
+    
+    if (!fs.existsSync(file)) {
+      throw new Error('备份文件不存在');
+    }
+
+    // 读取 SQL 文件
+    const sql_content = fs.readFileSync(file, 'utf8');
+    
+    // 解析 SQL 语句
+    const stmts = this._parseSqlStatements(sql_content);
+    
+    // 执行每个 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;
+  }
+};
+
+/**
+ * @description 解析 SQL 语句
+ * @param {string} sql SQL 内容
+ * @returns {string[]} SQL 语句数组
+ * @private
+ */
+Sql.prototype._parseSqlStatements = function(sql) {
+  const 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] || '';
+
+    // 处理字符串
+    if (!in_cmt && (char === "'" || char === '"') && (i === 0 || sql[i - 1] !== '\\')) {
+      if (!in_str) {
+        in_str = true;
+        quote_char = char;
+      } else if (char === quote_char) {
+        in_str = false;
+        quote_char = '';
+      }
+    }
+
+    // 处理注释
+    if (!in_str && char === '-' && next_char === '-') {
+      in_cmt = true;
+    }
+    if (in_cmt && char === '\n') {
+      in_cmt = false;
+    }
+
+    // 分割语句
+    if (!in_str && !in_cmt && char === ';') {
+      stmts.push(cur_stmt.trim());
+      cur_stmt = '';
+    } else {
+      cur_stmt += char;
+    }
+  }
+
+  // 添加最后一个语句（如果有）
+  if (cur_stmt.trim()) {
+    stmts.push(cur_stmt.trim());
+  }
+
+  return stmts;
+};
+
+module.exports = {
+  Sql
+};