mm_sqlite 1.2.2 → 1.2.3

package/db.js

@@ -2,866 +2,918 @@ const { Sql } = require('./sql');
 
 /**
  * @class 数据库操作类
- * @extends Sql
+ * @augments Sql
  */
 class DB extends Sql {
-	/**
-	 * @description 数据库管理器
-	 * @param {Object} mysql MySQL实例
-	 */
-	constructor(mysql) {
-		super(mysql.run, mysql.exec);
-		// 保存mysql实例引用
-		this._mysql = mysql;
-		// 事务中
-		this.task = 0;
-
-		// 事务SQL
-		this.task_sql = "";
-		// 表名
-		this.table = "";
-
-		/**
-		 * 获取上级
-		 * @return {Object} 返回上级管理器
-		 */
-		this.parent = function () {
-			return mysql;
-		};
-	}
+  /**
+   * @description 数据库管理器
+   * @param {object} mysql MySQL实例
+   */
+  constructor(sqlite) {
+    super(sqlite.run, sqlite.exec);
+    // 保存mysql实例引用
+    this._sqlite = sqlite;
+    // 事务中
+    this.task = 0;
+
+    // 事务SQL
+    this.task_sql = '';
+    // 表名
+    this.table = '';
+
+    /**
+     * 获取上级
+     * @returns {object} 返回上级管理器
+     */
+    this.parent = function () {
+      return sqlite;
+    };
+  }
 }
 
 /**
  * 创建超时Promise
- * @param {Number} timeout - 超时时间(毫秒)
- * @param {String} message - 超时提示信息
- * @return {Promise} 超时Promise
+ * @param {number} timeout - 超时时间(毫秒)
+ * @param {string} message - 超时提示信息
+ * @returns {Promise} 超时Promise
  */
 DB.prototype._createTimeoutPromise = function (timeout, message) {
-	return new Promise((_, reject) => {
-		setTimeout(() => {
-			reject(new Error(message));
-		}, timeout);
-	});
+  return new Promise((unused, reject) => {
+    setTimeout(() => {
+      reject(new Error(message));
+    }, timeout);
+  });
 };
 
 /**
  * 获取数据库名
- * @return {String} 数据库
+ * @returns {string} 数据库
  */
 DB.prototype.database = function () {
-	return this.parent().config.database;
+  return this.parent().config.database;
 };
 
 /**
  * 构建新管理器
- * @param {String} table 表名
- * @param {String} key 键名
- * @return {Object} 返回管理器
+ * @param {string} table 表名
+ * @param {string} key 键名
+ * @returns {object} 返回管理器
  */
 DB.prototype.new = function (table, key) {
-	var db = this.parent().db();
-	db.table = table;
-	if (key) {
-		db.key = key;
-	} else {
-		var arr = table.split("_");
-		db.key = arr[arr.length - 1] + "_id";
-	}
-	return db;
+  var db = this.parent().db();
+  db.table = table;
+  if (key) {
+    db.key = key;
+  } else {
+    var arr = table.split('_');
+    db.key = arr[arr.length - 1] + '_id';
+  }
+  return db;
 };
 
 /**
  * 获取数据库连接
- * @param {Number} timeout 超时时间(毫秒)
- * @returns {Promise<Object>} 数据库连接对象
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise<object>} 数据库连接对象
  */
 DB.prototype.getConn = async function (timeout = 15000) {
-	if (!this._mysql) {
-		throw new Error('SQLite实例未初始化');
-	}
-	try {
-		// 使用Promise.race实现超时控制
-		return await Promise.race([
-			this._mysql.getConn(),
-			this._createTimeoutPromise(timeout, '获取数据库连接超时')
-		]);
-	} catch (error) {
-		this.logger('error', '获取连接失败', error);
-		// 重新抛出异常，因为调用方需要连接对象
-		throw error;
-	}
+  if (!this._mysql) {
+    throw new Error('SQLite实例未初始化');
+  }
+  try {
+    // 使用Promise.race实现超时控制
+    return await Promise.race([
+      this._mysql.getConn(),
+      this._createTimeoutPromise(timeout, '获取数据库连接超时')
+    ]);
+  } catch (error) {
+    this.log('error', '获取连接失败', error);
+    // 重新抛出异常，因为调用方需要连接对象
+    throw error;
+  }
 };
 
 /**
- * 事务开始
- * @param {String} identifier 事务标识符
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise<Object>} 执行结果
+ * 开始事务
+ * @returns {Promise<object>}
  */
-DB.prototype.start = async function (identifier = "point_1", timeout = 15000) {
-	this.task = 1;
-	try {
-		return await this.exec("BEGIN;", [], timeout);
-	} catch (err) {
-		this.task = 0;
-		this.logger('error', '事务开始失败', err);
-		// 返回默认操作结果对象，保持返回值类型一致
-		return 0;
-	}
+DB.prototype.start = async function() {
+  this.task = 1;
+  try {
+    await this.exec('BEGIN;', [], 15000);
+    // 返回事务对象
+    return {
+      commit: async () => {
+        await this.commit({});
+      },
+      rollback: async () => {
+        await this.back({});
+      }
+    };
+  } catch (err) {
+    this.task = 0;
+    this.log('error', '开始事务失败', err);
+    // 返回null作为默认值，保持返回值类型一致
+    return null;
+  }
 };
 
 /**
- * 提交
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise<Object>} 执行结果
+ * 提交事务
+ * @param {object} transaction - 事务对象
+ * @returns {Promise<void>}
+ * @throws {TypeError} 当transaction参数无效时
  */
-DB.prototype.commit = async function (timeout = 15000) {
-	if (this.task !== 1) {
-		$.log.warn("[DB] [commit] 没有活跃的事务可提交");
-		return 0;
-	}
-	this.task = 2;
-	try {
-		const result = await this.exec("COMMIT;", [], timeout);
-		// 重置事务状态
-		this.task = 0;
-		this.task_sql = '';
-		return result;
-	} catch (err) {
-		this.logger('error', '事务提交失败', err);
-		// 尝试回滚
-		try {
-			await this.exec("ROLLBACK;", [], timeout);
-		} catch (rollbackErr) {
-			this.logger('error', '事务回滚也失败', rollbackErr);
-		}
-		this.task = 0;
-		this.task_sql = '';
-	}
+DB.prototype.commit = async function(transaction) {
+  // 参数校验
+  if (!transaction || typeof transaction !== 'object') {
+    throw new TypeError('transaction must be object');
+  }
+  
+  if (this.task !== 1) {
+    this.log('warn', '没有活跃的事务可提交');
+    return;
+  }
+  
+  try {
+    await this.exec('COMMIT;', [], 15000);
+    this.task = 0;
+  } catch (err) {
+    this.log('error', '提交事务失败', err);
+    // 尝试回滚
+    try {
+      await this.exec('ROLLBACK;', [], 15000);
+    } catch (rollbackErr) {
+      this.log('error', '事务回滚也失败', rollbackErr);
+    }
+    this.task = 0;
+    this.task_sql = '';
+  }
 };
 
 /**
  * 事务结束
  */
 DB.prototype.end = function () {
-	// 确保事务状态被重置
-	this.task = 0;
-	this.task_sql = '';
+  // 确保事务状态被重置
+  this.task = 0;
+  this.task_sql = '';
 };
 
 /**
- * 滚回
- * @param {String} identifier 事务标识符
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise<Object>} 执行结果
+ * 回滚事务
+ * @param {object} transaction - 事务对象
+ * @returns {Promise<void>}
+ * @throws {TypeError} 当transaction参数无效时
  */
-DB.prototype.back = async function (identifier = "point_1", timeout = 15000) {
-	if (this.task !== 1) {
-		$.log.warn("[DB] [back] 没有活跃的事务可回滚");
-		this.task = 0;
-		this.task_sql = '';
-		return 0;
-	}
-	this.task = 3;
-	try {
-		await this.exec("ROLLBACK;", [], timeout);
-		const result = await this.exec("COMMIT;", [], timeout);
-		// 重置事务状态
-		this.task = 0;
-		this.task_sql = '';
-		return result;
-	} catch (err) {
-		this.logger('error', '事务回滚失败', err);
-		this.task = 0;
-		this.task_sql = '';
-		return 0;
-	}
+DB.prototype.back = async function(transaction) {
+  // 参数校验
+  if (!transaction || typeof transaction !== 'object') {
+    throw new TypeError('transaction must be object');
+  }
+  
+  if (this.task !== 1) {
+    this.log('warn', '没有活跃的事务可回滚');
+    return;
+  }
+  
+  try {
+    await this.exec('ROLLBACK;', [], 15000);
+    this.task = 0;
+    this.task_sql = '';
+  } catch (err) {
+    this.log('error', '回滚事务失败', err);
+    this.task = 0;
+    this.task_sql = '';
+  }
+};
+
+/**
+ * 在事务中执行多个操作
+ * @param {Function} callback - 包含事务操作的回调函数
+ * @returns {Promise<*>}
+ * @throws {TypeError} 当callback参数无效时
+ */
+DB.prototype.transaction = async function(callback) {
+  // 参数校验
+  if (typeof callback !== 'function') {
+    throw new TypeError('callback must be function');
+  }
+  
+  try {
+    // 开始事务
+    await this.start();
+    
+    // 执行回调函数
+    const result = await callback();
+    
+    // 提交事务
+    await this.commit({});
+    
+    return result;
+  } catch (err) {
+    // 回滚事务
+    await this.back({});
+    this.log('error', '事务执行失败', err);
+    // 返回null作为默认值，保持返回值类型一致
+    return null;
+  }
 };
 
 /**
  * @description 获取所有表名
- * @param {String} table 表名关键词, 可以 *table*包含、*table后缀、table*前缀 查询
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Array} 表名数组
+ * @param {string} table 表名关键词, 可以 *table*包含、*table后缀、table*前缀 查询
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise|Array} 表名数组
  */
 DB.prototype.tables = async function (table, timeout = 15000) {
-	try {
-		const list = await this.run("SELECT `name` FROM sqlite_master WHERE type='table';", [], timeout);
-		if (table) {
-			// 简单的过滤实现
-			const filtered = [];
-			for (const item of list) {
-				const value = item.name;
-				if (value && value.includes(table)) {
-					filtered.push(item);
-				}
-			}
-			return filtered.map(item => item.name);
-		}
-		// 使用原生方法提取表名
-		return list.map(item => item.name);
-	} catch (err) {
-		this.logger('error', '获取表名失败', err);
-		return [];
-	}
+  try {
+    const list = await this.run("SELECT `name` FROM sqlite_master WHERE type='table';", [], timeout);
+    if (table) {
+      // 简单的过滤实现
+      const filtered = [];
+      for (const item of list) {
+        const value = item.name;
+        if (value && value.includes(table)) {
+          filtered.push(item);
+        }
+      }
+      return filtered.map(item => item.name);
+    }
+    // 使用原生方法提取表名
+    return list.map(item => item.name);
+  } catch (err) {
+    this.log('error', '获取表名失败', err);
+    return [];
+  }
 };
 
 /**
  * @description 获取所有表字段
- * @param {String} table 表名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Array} 字段信息列表
+ * @param {string} table 表名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise|Array} 字段信息列表
  */
-DB.prototype.fields = async function (table, timeout = 15000) {
-	try {
-		const targetTable = table || this.table;
-		if (!table) {
-			throw new TypeError('table must be specified');
-		}
-		var sql = "PRAGMA table_info(`{0}`);".replace('{0}', targetTable);
-		var list = await this.run(sql, [], timeout);
-		var len = list.length;
-		for (var i = 0; i < len; i++) {
-			list[i].pk = list[i].pk ? true : false;
-			list[i].notnull = list[i].notnull ? true : false;
-		}
-		return list;
-	} catch (err) {
-		this.logger('error', '获取字段信息失败', err);
-		return [];
-	}
+DB.prototype.fields = async function (table, field_name, timeout = 15000) {
+  try {
+    const targetTable = table || this.table;
+    if (!targetTable) {
+      throw new TypeError('table must be specified');
+    }
+    var sql = 'PRAGMA table_info(`{0}`);'.replace('{0}', targetTable);
+    var list = await this.run(sql, [], timeout);
+    var len = list.length;
+    for (var i = 0; i < len; i++) {
+      list[i].pk = list[i].pk ? true : false;
+      list[i].notnull = list[i].notnull ? true : false;
+    }
+    
+    // 如果指定了字段名，过滤结果
+    if (field_name) {
+      list = list.filter(field => field.name === field_name);
+    }
+    
+    return list;
+  } catch (err) {
+    this.log('error', '获取字段信息失败', err);
+    return [];
+  }
 };
 
 /**
  * @description 设置类型
- * @param {String} field 字段名
- * @param {String} type 类型名，常用类型 mediumint, int, varchar, datetime
- * @param {String} value 默认值
- * @param {Boolean} not_null 是否非空字段 true为非空，false为可空
- * @param {Boolean} auto 自动
- * @return {String} 返回最终类型
+ * @param {string} field 字段名
+ * @param {string} type 类型名，常用类型 mediumint, int, varchar, datetime
+ * @param {string} value 默认值
+ * @param {boolean} not_null 是否非空字段 true为非空，false为可空
+ * @param {boolean} auto 自动
+ * @returns {string} 返回最终类型
  */
 DB.prototype.setType = function (field, type, value, not_null, auto) {
-	if (!type) {
-		type = 'integer';
-	}
-	switch (type) {
-		case "str":
-		case "varchar":
-		case "string":
-			type = "varchar(255)";
-			if (not_null) {
-				type += " NOT NULL";
-			}
-			if (value) {
-				type += " DEFAULT '" + value + "'";
-			} else {
-				type += " DEFAULT ''";
-			}
-			break;
-		case "number":
-			type = "integer(11) NOT NULL";
-			if (auto) {
-				type += " autoincrement";
-			} else if (value) {
-				type += " DEFAULT " + value;
-			} else {
-				type += " DEFAULT 0";
-			}
-			break;
-		case "bool":
-		case "tinyint":
-			type = "tinyint(1) UNSIGNED NOT NULL";
-			if (value) {
-				type += " DEFAULT " + value;
-			} else {
-				type += " DEFAULT 0";
-			}
-			break;
-		case "datetime":
-			if (!value) {
-				value = "1970-01-01 00:00:00";
-			}
-			type += " DEFAULT '" + value + "'";
-			break;
-		case "timestamp":
-			if (auto) {
-				if (field.indexOf('update') !== -1 || field.indexOf('last') !== -1) {
-					type += " DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP";
-				} else {
-					type += " DEFAULT CURRENT_TIMESTAMP";
-				}
-			} else {
-				type += " DEFAULT CURRENT_TIMESTAMP";
-			}
-			break;
-		case "date":
-			if (!value) {
-				value = "1970-01-01";
-			}
-			type += " NOT NULL DEFAULT '" + value + "'";
-			break;
-		case "time":
-			if (!value) {
-				value = "00:00:00";
-			}
-			type += " NOT NULL DEFAULT '" + value + "'";
-			break;
-		case "double":
-			if (type == "double") {
-				type = "double(10, 2)"
-			}
-			type += " NOT NULL";
-			if (value) {
-				type += " DEFAULT '" + value + "'";
-			} else {
-				type += " DEFAULT 0";
-			}
-			break;
-		case "float":
-			if (type == "float") {
-				type = "float(17, 8)"
-			}
-			type += " NOT NULL";
-			if (value) {
-				type += " DEFAULT '" + value + "'";
-			} else {
-				type += " DEFAULT 0";
-			}
-			break;
-		case "longtext":
-		case "text":
-			if (type == "text") {
-				type = "text NULL"
-			} else if (type == "longtext") {
-				type = "longtext NULL"
-			}
-			break;
-		default:
-			if (type.indexOf('var') !== -1) {
-				if (not_null) {
-					type += " NOT NULL"
-				}
-				if (value) {
-					type += " DEFAULT '" + value + "'";
-				} else {
-					type += " DEFAULT ''";
-				}
-			} else {
-				type += " UNSIGNED NOT NULL";
-				if (auto) {
-					type += " autoincrement";
-				} else {
-					if (value) {
-						type += " DEFAULT '" + value + "'";
-					} else {
-						type += " DEFAULT 0";
-					}
-				}
-			}
-			break;
-	}
-	return type;
+  if (!type) {
+    type = 'integer';
+  }
+  switch (type) {
+    case 'str':
+    case 'varchar':
+    case 'string':
+      type = 'varchar(255)';
+      if (not_null) {
+        type += ' NOT NULL';
+      }
+      if (value) {
+        type += " DEFAULT '" + value + "'";
+      } else {
+        type += " DEFAULT ''";
+      }
+      break;
+    case 'number':
+      type = 'integer(11) NOT NULL';
+      if (auto) {
+        type += ' autoincrement';
+      } else if (value) {
+        type += ' DEFAULT ' + value;
+      } else {
+        type += ' DEFAULT 0';
+      }
+      break;
+    case 'bool':
+    case 'tinyint':
+      type = 'tinyint(1) UNSIGNED NOT NULL';
+      if (value) {
+        type += ' DEFAULT ' + value;
+      } else {
+        type += ' DEFAULT 0';
+      }
+      break;
+    case 'datetime':
+      if (!value) {
+        value = '1970-01-01 00:00:00';
+      }
+      type += " DEFAULT '" + value + "'";
+      break;
+    case 'timestamp':
+      if (auto) {
+        if (field.indexOf('update') !== -1 || field.indexOf('last') !== -1) {
+          type += ' DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP';
+        } else {
+          type += ' DEFAULT CURRENT_TIMESTAMP';
+        }
+      } else {
+        type += ' DEFAULT CURRENT_TIMESTAMP';
+      }
+      break;
+    case 'date':
+      if (!value) {
+        value = '1970-01-01';
+      }
+      type += " NOT NULL DEFAULT '" + value + "'";
+      break;
+    case 'time':
+      if (!value) {
+        value = '00:00:00';
+      }
+      type += " NOT NULL DEFAULT '" + value + "'";
+      break;
+    case 'double':
+      if (type == 'double') {
+        type = 'double(10, 2)';
+      }
+      type += ' NOT NULL';
+      if (value) {
+        type += " DEFAULT '" + value + "'";
+      } else {
+        type += ' DEFAULT 0';
+      }
+      break;
+    case 'float':
+      if (type == 'float') {
+        type = 'float(17, 8)';
+      }
+      type += ' NOT NULL';
+      if (value) {
+        type += " DEFAULT '" + value + "'";
+      } else {
+        type += ' DEFAULT 0';
+      }
+      break;
+    case 'longtext':
+    case 'text':
+      if (type == 'text') {
+        type = 'text NULL';
+      } else if (type == 'longtext') {
+        type = 'longtext NULL';
+      }
+      break;
+    default:
+      if (type.indexOf('var') !== -1) {
+        if (not_null) {
+          type += ' NOT NULL';
+        }
+        if (value) {
+          type += " DEFAULT '" + value + "'";
+        } else {
+          type += " DEFAULT ''";
+        }
+      } else {
+        type += ' UNSIGNED NOT NULL';
+        if (auto) {
+          type += ' autoincrement';
+        } else {
+          if (value) {
+            type += " DEFAULT '" + value + "'";
+          } else {
+            type += ' DEFAULT 0';
+          }
+        }
+      }
+      break;
+  }
+  return type;
 };
 
 /**
  * @description 创建数据表
- * @param {String} table 表名
- * @param {String} field 主键字段名
- * @param {String} type 类型名，常用类型 mediumint, int, varchar
- * @param {Boolean} auto 是否自增字段, 默认为自增字段
- * @param {String} commit 注释
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 创建成功返回1，失败返回0
+ * @param {string} table 表名
+ * @param {string} field 主键字段名
+ * @param {string} type 类型名，常用类型 mediumint, int, varchar
+ * @param {boolean} auto 是否自增字段, 默认为自增字段
+ * @param {string} commit 注释
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 创建成功返回1，失败返回0
  */
 DB.prototype.addTable = async function (table, field, type = 'int', auto = true, commit = '', timeout = 15000) {
-	try {
-		if (!table || typeof table !== 'string') {
-			throw new TypeError('table must be non-empty string');
-		}
-		if (!field) {
-			field = "id";
-		}
-		// SQLite的自增主键要求字段类型必须是INTEGER（大写且不带长度）
-		let fieldType;
-		if (auto) {
-			// 自增字段使用简单的INTEGER类型，由后面的PRIMARY KEY AUTOINCREMENT决定自增行为
-			fieldType = "INTEGER";
-		} else {
-			// 非自增字段使用正常的类型设置
-			fieldType = this.setType(field, type, null, true, auto);
-		}
-		// 根据是否自增来构造不同的SQL语句
-		let sqlTemplate;
-		if (auto) {
-			// 自增字段：使用INTEGER PRIMARY KEY AUTOINCREMENT语法
-			sqlTemplate = "CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY AUTOINCREMENT)";
-		} else {
-			// 非自增字段：使用正常的字段类型和主键定义
-			sqlTemplate = "CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY)";
-		}
-		var sql = sqlTemplate.replace('{0}', table).replace(
-			'{1}', field).replace('{2}', fieldType) + ";";
-		// SQLite不支持表级COMMENT语法，所以忽略commit参数
-		var bl = await this.exec(sql, [], timeout);
-		// 设置实例的表名属性，以便后续操作使用
-		this.table = table;
-		return bl;
-	} catch (err) {
-		this.logger('error', '创建表失败', err);
-		return 0;
-	}
+  try {
+    if (!table || typeof table !== 'string') {
+      throw new TypeError('table must be non-empty string');
+    }
+    if (!field) {
+      field = 'id';
+    }
+    // SQLite的自增主键要求字段类型必须是INTEGER（大写且不带长度）
+    let fieldType;
+    if (auto) {
+      // 自增字段使用简单的INTEGER类型，由后面的PRIMARY KEY AUTOINCREMENT决定自增行为
+      fieldType = 'INTEGER';
+    } else {
+      // 非自增字段使用正常的类型设置
+      fieldType = this.setType(field, type, null, true, auto);
+    }
+    // 根据是否自增来构造不同的SQL语句
+    let sqlTemplate;
+    if (auto) {
+      // 自增字段：使用INTEGER PRIMARY KEY AUTOINCREMENT语法
+      sqlTemplate = 'CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY AUTOINCREMENT)';
+    } else {
+      // 非自增字段：使用正常的字段类型和主键定义
+      sqlTemplate = 'CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY)';
+    }
+    var sql = sqlTemplate.replace('{0}', table).replace(
+      '{1}', field).replace('{2}', fieldType) + ';';
+    // SQLite不支持表级COMMENT语法，所以忽略commit参数
+    var bl = await this.exec(sql, [], timeout);
+    // 设置实例的表名属性，以便后续操作使用
+    this.table = table;
+    return bl;
+  } catch (err) {
+    this.log('error', '创建表失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 清空数据表
- * @param {Boolean} reset 是否重置自增ID
- * @param {String} table 表名
- * @param {Number} timeout - 超时时间(毫秒)
- * @return {Promise|Number} 清空成功返回1，失败返回0
+ * @param {boolean} reset 是否重置自增ID
+ * @param {string} table 表名
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise | number} 清空成功返回1，失败返回0
  */
-DB.prototype.clearTable = async function (reset = true, table = '', timeout = 15000) {
-	var sql = reset ? "TRUNCATE table `{0}`;" : "DELETE FROM `{0}`";
-	var bl = await this.exec(sql.replace('{0}', table || this.table), [], timeout);
-	return bl;
+DB.prototype.emptyTable = function (table, timeout = 15000) {
+  if (!table || typeof table !== 'string') {
+    throw new TypeError('table must be a valid string');
+  }
+  return this.exec('DELETE FROM `' + table + '`;', timeout);
 };
 
 /**
  * @description 添加字段
- * @param {String} field 字段名
- * @param {String} type 类型名
- * @param {String} value 默认值
- * @param {Boolean} not_null 是否非空
- * @param {Boolean} auto 是否自增
- * @param {String} comment 注释
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 添加成功返回1，失败返回0
+ * @param {string} field 字段名
+ * @param {string} type 类型名
+ * @param {string} value 默认值
+ * @param {boolean} not_null 是否非空
+ * @param {boolean} auto 是否自增
+ * @param {string} comment 注释
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 添加成功返回1，失败返回0
  */
 DB.prototype.addField = async function (field, type, value = '', not_null = true, auto = false, comment = '', timeout = 15000) {
-	try {
-		// 确保表名已设置
-		if (!this.table || !field || !type) {
-			throw new TypeError('table, field, and type must be specified');
-		}
-
-		// 在SQLite中，使用PRAGMA table_info检查表中是否已存在字段
-		var sql = "PRAGMA table_info(`{0}`)";
-		sql = sql.replace('{0}', this.table);
-		var columns = await this.run(sql, [], timeout);
-		var fieldExists = false;
-		for (var i = 0; i < columns.length; i++) {
-			if (columns[i].name === field) {
-				fieldExists = true;
-				break;
-			}
-		}
-
-		if (!fieldExists) {
-			var fieldType = this.setType(field, type, value, not_null, auto);
-			var sql = "ALTER Table `{0}` ADD `{1}` {2}";
-			sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', fieldType) + ";";
-			// SQLite不支持字段级COMMENT语法，所以忽略comment参数
-			return await this.exec(sql, [], timeout);
-		}
-		return 0;
-	} catch (err) {
-		this.logger('error', '添加字段失败', err);
-		return 0;
-	}
+  try {
+    // 确保表名已设置
+    if (!this.table || !field || !type) {
+      throw new TypeError('table, field, and type must be specified');
+    }
+
+    // 在SQLite中，使用PRAGMA table_info检查表中是否已存在字段
+    var sql = 'PRAGMA table_info(`{0}`)';
+    sql = sql.replace('{0}', this.table);
+    var columns = await this.run(sql, [], timeout);
+    var fieldExists = false;
+    for (var i = 0; i < columns.length; i++) {
+      if (columns[i].name === field) {
+        fieldExists = true;
+        break;
+      }
+    }
+
+    if (!fieldExists) {
+      var fieldType = this.setType(field, type, value, not_null, auto);
+      var sql = 'ALTER Table `{0}` ADD `{1}` {2}';
+      sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', fieldType) + ';';
+      // SQLite不支持字段级COMMENT语法，所以忽略comment参数
+      return await this.exec(sql, [], timeout);
+    }
+    return 0;
+  } catch (err) {
+    this.log('error', '添加字段失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 修改字段
- * @param {String} field 字段名
- * @param {String} type 类型名
- * @param {String} value 默认值
- * @param {Boolean} not_null 是否非空
- * @param {Boolean} auto 是否自增
- * @param {Boolean} isKey 是否主键
- * @param {String} new_name 新字段名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 修改成功返回1，失败返回0
+ * @param {string} field 字段名
+ * @param {string} type 类型名
+ * @param {string} value 默认值
+ * @param {boolean} not_null 是否非空
+ * @param {boolean} auto 是否自增
+ * @param {boolean} isKey 是否主键
+ * @param {string} new_name 新字段名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 修改成功返回1，失败返回0
  */
 DB.prototype.setField = async function (field, type, value = '', not_null = true, auto = false, isKey = false, new_name = '', timeout = 15000) {
-	try {
-		if (!field || !type || !this.table) {
-			throw new TypeError('field, type, and table must be specified');
-		}
+  try {
+    if (!field || !type || !this.table) {
+      throw new TypeError('field, type, and table must be specified');
+    }
 
-		var sql =
+    var sql =
 			"select count(*) as `count` from sqlite_master where `type` = 'table' and `name` = '{1}' and `sql` like '%{2}%'";
-		sql = sql.replace('{1}', this.table).replace('{2}', field);
-		var arr = await this.run(sql, [], timeout);
-		if (arr && arr.length > 0) {
-			if (arr[0].count == 0) {
-				return 0;
-			}
-		}
-
-		var type = this.setType(field, type, value, not_null, auto);
-		if (type.has('text')) {
-			type = type.replace('NOT NULL', '').replace("DEFAULT ''", "");
-		}
-
-		if (!new_name) {
-			new_name = field;
-		}
-
-		sql = "ALTER TABLE `{0}` ADD COLUMN `{2}` {3}";
-		sql = sql.replace('{0}', this.table).replace('{2}', new_name).replace('{3}', type);
-		if (isKey) {
-			sql += ", DROP PRIMARY KEY, ADD PRIMARY KEY (" + new_name + ") USING BTREE;"
-		} else {
-			sql += ";";
-		}
-		await this.exec(sql, timeout);
-
-		sql = "UPDATE TABLE `{0}` SET `{2}` = `{1}`;";
-		sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', new_name);
-		var ret = await this.exec(sql, timeout);
-
-		if (field !== new_name) {
-			// sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
-			// sql = sql.replace('{0}', this.table).replace('{1}', field);
-			// ret = await this.exec(sql);
-		}
-		return ret;
-	} catch (err) {
-		this.logger('error', '修改字段失败', err);
-		return 0;
-	}
+    sql = sql.replace('{1}', this.table).replace('{2}', field);
+    var arr = await this.run(sql, [], timeout);
+    if (arr && arr.length > 0) {
+      if (arr[0].count == 0) {
+        return 0;
+      }
+    }
+
+    var field_type = this.setType(field, type, value, not_null, auto);
+    if (field_type.has('text')) {
+      field_type = field_type.replace('NOT NULL', '').replace("DEFAULT ''", '');
+    }
+
+    if (!new_name) {
+      new_name = field;
+    }
+
+    sql = 'ALTER TABLE `{0}` ADD COLUMN `{2}` {3}';
+    sql = sql.replace('{0}', this.table).replace('{2}', new_name).replace('{3}', field_type);
+    if (isKey) {
+      sql += ', DROP PRIMARY KEY, ADD PRIMARY KEY (' + new_name + ') USING BTREE;';
+    } else {
+      sql += ';';
+    }
+    await this.exec(sql, timeout);
+
+    sql = 'UPDATE TABLE `{0}` SET `{2}` = `{1}`;';
+    sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', new_name);
+    var ret = await this.exec(sql, timeout);
+
+    if (field !== new_name) {
+      // sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
+      // sql = sql.replace('{0}', this.table).replace('{1}', field);
+      // ret = await this.exec(sql);
+    }
+    return ret;
+  } catch (err) {
+    this.log('error', '修改字段失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 删除字段
- * @param {String} table 表名
- * @param {String} field 字段名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 删除成功返回1，失败返回0
+ * @param {string} table 表名
+ * @param {string} field 字段名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 删除成功返回1，失败返回0
  */
 DB.prototype.delField = async function (table, field, timeout = 15000) {
-	try {
-		if (!table || !field) {
-			throw new TypeError('table and field must be specified');
-		}
-
-		var sql = "ALTER TABLE {0} DROP COLUMN {1};";
-		sql = sql.replace('{0}', table).replace('{1}', field);
-		return await this.exec(sql, [], timeout);
-	} catch (err) {
-		this.logger('error', '删除字段失败', err);
-		return 0;
-	}
+  try {
+    if (!table || !field) {
+      throw new TypeError('table and field must be specified');
+    }
+
+    var sql = 'ALTER TABLE {0} DROP COLUMN {1};';
+    sql = sql.replace('{0}', table).replace('{1}', field);
+    return await this.exec(sql, [], timeout);
+  } catch (err) {
+    this.log('error', '删除字段失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 拼接字段信息SQL
- * @param {Object} fd 字段信息
- * @return {String} sql语段
+ * @param {object} fd 字段信息
+ * @returns {string} sql语段
  */
 DB.prototype.sqlField = function (fd) {
-	var sql = "`{0}`".replace('{0}', fd.name);
-	sql += " " + fd.type;
-	if (fd.notnull) {
-		sql += " NOT NULL";
-	}
-	if (fd.auto) {
-		if (fd.dflt_value) {
-			if (fd.dflt_value === '0000-00-00 00:00:00') {
-				fd.dflt_value = 'CURRENT_TIMESTAMP';
-			}
-			sql += " DEFAULT " + fd.dflt_value;
-		}
-		sql += " " + fd.auto;
-	} else if (fd.dflt_value) {
-		if (fd.dflt_value === '0000-00-00 00:00:00') {
-			fd.dflt_value = '1970-01-01 00:00:00';
-		}
-		sql += " DEFAULT " + fd.dflt_value;
-	}
-	if (fd.note) {
-		sql += " COMMENT '" + fd.note + "'";
-	}
-	if (fd.pk) {
-		sql += " PRIMARY KEY";
-	}
-	return sql;
+  var sql = '`{0}`'.replace('{0}', fd.name);
+  sql += ' ' + fd.type;
+  if (fd.notnull) {
+    sql += ' NOT NULL';
+  }
+  if (fd.auto) {
+    if (fd.dflt_value) {
+      if (fd.dflt_value === '0000-00-00 00:00:00') {
+        fd.dflt_value = 'CURRENT_TIMESTAMP';
+      }
+      sql += ' DEFAULT ' + fd.dflt_value;
+    }
+    sql += ' ' + fd.auto;
+  } else if (fd.dflt_value) {
+    if (fd.dflt_value === '0000-00-00 00:00:00') {
+      fd.dflt_value = '1970-01-01 00:00:00';
+    }
+    sql += ' DEFAULT ' + fd.dflt_value;
+  }
+  if (fd.note) {
+    sql += " COMMENT '" + fd.note + "'";
+  }
+  if (fd.pk) {
+    sql += ' PRIMARY KEY';
+  }
+  return sql;
 };
 
 /**
  * @description 重命名字段
- * @param {String} table 表名
- * @param {String} field 字段名
- * @param {String} new_field 新字段名
- * @param {String} type 字段类型
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 重命名成功返回1，失败返回0
+ * @param {string} table 表名
+ * @param {string} field 字段名
+ * @param {string} new_field 新字段名
+ * @param {string} type 字段类型
+ * @param new_name
+ * @param unused_type
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 重命名成功返回1，失败返回0
  */
 DB.prototype.renameField = async function (table, field, new_field, type, timeout = 15000) {
-	try {
-		if (!table || !field || !new_field) {
-			throw new TypeError('table, field, and new_field must be specified');
-		}
-
-		var sql = "ALTER TABLE {0} RENAME COLUMN {1} TO {2};";
-		sql = sql.replace('{0}', table).replace('{1}', field).replace('{2}', new_field);
-		return await this.exec(sql, [], timeout);
-	} catch (err) {
-		this.logger('error', '重命名字段失败', err);
-		return 0;
-	}
+  try {
+    if (!table || !field || !new_field) {
+      throw new TypeError('table, field, and new_field must be specified');
+    }
+
+    var sql = 'ALTER TABLE {0} RENAME COLUMN {1} TO {2};';
+    sql = sql.replace('{0}', table).replace('{1}', field).replace('{2}', new_field);
+    return await this.exec(sql, [], timeout);
+  } catch (err) {
+    this.log('error', '重命名字段失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 修改字段类型
- * @param {String} table 表名
- * @param {String} field 字段名
- * @param {String} type 字段类型
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 操作结果
+ * @param {string} table 表名
+ * @param {string} field 字段名
+ * @param {string} type 字段类型
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 操作结果
  */
 DB.prototype.editField = function (table, field, type, timeout = 15000) {
-	try {
-		if (!table || !field || !type) {
-			throw new TypeError('table, field, and type must be specified');
-		}
-		return this.exec("ALTER TABLE `" + table + "` MODIFY COLUMN `" + field + "` " + type + ";", [], timeout);
-	} catch (err) {
-		this.logger('error', '修改字段类型失败', err);
-		return 0;
-	}
+  try {
+    if (!table || !field || !type) {
+      throw new TypeError('table, field, and type must be specified');
+    }
+    return this.exec('ALTER TABLE `' + table + '` MODIFY COLUMN `' + field + '` ' + type + ';', [], timeout);
+  } catch (err) {
+    this.log('error', '修改字段类型失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 删除数据表
- * @param {String} table 表名
- * @param {Number} timeout - 超时时间(毫秒)
- * @return {Promise|Number} 删除成功返回1，失败返回0
+ * @param {string} table 表名
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise | number} 删除成功返回1，失败返回0
  */
 DB.prototype.dropTable = function (table, timeout = 15000) {
-	if (!table) {
-		throw new TypeError('table must be specified');
-	}
-	return this.exec("DROP TABLE IF EXISTS `" + table + "`;", [], timeout);
+  if (!table) {
+    throw new TypeError('table must be specified');
+  }
+  return this.exec('DROP TABLE IF EXISTS `' + table + '`;', [], timeout);
 };
 
 /**
  * @description 重命名数据表
- * @param {String} table 原表名
- * @param {String} new_table 新表名
- * @param {Number} timeout - 超时时间(毫秒)
- * @return {Promise|Number} 重命名成功返回1，失败返回0
+ * @param {string} table 原表名
+ * @param {string} new_table 新表名
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise | number} 重命名成功返回1，失败返回0
  */
 DB.prototype.renameTable = function (table, new_table, timeout = 15000) {
-	if (!table || !new_table) {
-		throw new TypeError('table and new_table must be specified');
-	}
-	return this.exec("ALTER TABLE `" + table + "` RENAME TO `" + new_table + "`;", [], timeout);
+  if (!table || !new_table) {
+    throw new TypeError('table and new_table must be specified');
+  }
+  return this.exec('ALTER TABLE `' + table + '` RENAME TO `' + new_table + '`;', [], timeout);
 };
 
 /**
  * @description 清空数据表（保留表结构）
- * @param {String} table 表名
- * @param {Number} timeout - 超时时间(毫秒)
- * @return {Promise|Number} 清空成功返回1，失败返回0
+ * @param {string} table 表名
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise | number} 清空成功返回1，失败返回0
  */
 DB.prototype.emptyTable = function (table, timeout = 15000) {
-	if (!table) {
-		throw new TypeError('table must be specified');
-	}
-	return this.exec("DELETE FROM `" + table + "`;", [], timeout);
+  if (!table) {
+    throw new TypeError('table must be specified');
+  }
+  return this.exec('DELETE FROM `' + table + '`;', [], timeout);
 };
 
 /**
  * @description 检查表是否存在
- * @param {String} table 表名
- * @param {Number} timeout - 超时时间(毫秒)
- * @return {Promise|Boolean} 存在返回true，不存在返回false
+ * @param {string} table 表名
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise | boolean} 存在返回true，不存在返回false
  */
 DB.prototype.hasTable = async function (table, timeout = 15000) {
-	try {
-		if (!table) {
-			return false;
-		}
-		var list = await this.run("SELECT name FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
-		return list && list.length > 0;
-	} catch (err) {
-		this.logger('error', '检查表是否存在失败', err);
-		return false;
-	}
+  try {
+    if (!table) {
+      return false;
+    }
+    var list = await this.run("SELECT name FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
+    return list && list.length > 0;
+  } catch (err) {
+    this.log('error', '检查表是否存在失败', err);
+    return false;
+  }
 };
 
 /**
  * @description 检查字段是否存在
- * @param {String} table 表名
- * @param {String} field 字段名
- * @param {Number} timeout - 超时时间(毫秒)
- * @return {Promise|Boolean} 存在返回true，不存在返回false
+ * @param {string} table 表名
+ * @param {string} field 字段名
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise | boolean} 存在返回true，不存在返回false
  */
 DB.prototype.hasField = async function (table, field, timeout = 15000) {
-	try {
-		if (!table || !field) {
-			return false;
-		}
-		var fields = await this.fields(table, field, timeout);
-		return fields && fields.some(f => f.name === field);
-	} catch (err) {
-		this.logger('error', '检查字段是否存在失败', err);
-		return false;
-	}
+  try {
+    if (!table || !field) {
+      return false;
+    }
+    var fields = await this.fields(table, field, timeout);
+    return fields && fields.some(f => f.name === field);
+  } catch (err) {
+    this.log('error', '检查字段是否存在失败', err);
+    return false;
+  }
 };
 
 /**
  * @description 备份数据表
- * @param {String} table 原表名
- * @param {String} backup 备份表名
- * @param {Number} timeout - 超时时间(毫秒)
- * @return {Promise|Number} 备份成功返回1，失败返回0
+ * @param {string} table 原表名
+ * @param {string} backup 备份表名
+ * @param {number} timeout - 超时时间(毫秒)
+ * @returns {Promise | number} 备份成功返回1，失败返回0
  */
 DB.prototype.backupTable = function (table, backup, timeout = 60000) {
-	if (!table || !backup) {
-		throw new TypeError('table and backup must be specified');
-	}
-	var sql = "CREATE TABLE IF NOT EXISTS `" + backup + "` AS SELECT * FROM `" + table + "`;";
-	return this.exec(sql, [], timeout);
+  if (!table || !backup) {
+    throw new TypeError('table and backup must be specified');
+  }
+  var sql = 'CREATE TABLE IF NOT EXISTS `' + backup + '` AS SELECT * FROM `' + table + '`;';
+  return this.exec(sql, [], timeout);
 };
 
 /**
  * @description 获取表创建语句
- * @param {String} table 表名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|String} 创建语句
+ * @param {string} table 表名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | string} 创建语句
  */
 DB.prototype.getCreateTable = async function (table, timeout = 15000) {
-	try {
-		if (!table) {
-			throw new TypeError('table must be specified');
-		}
-		const list = await this.run("SELECT sql FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
-		if (list && list.length > 0) {
-			return list[0].sql || '';
-		}
-		return '';
-	} catch (err) {
-		this.logger('error', '获取表结构失败', err);
-		return '';
-	}
+  if (!table) {
+    throw new TypeError('table must be specified');
+  }
+  try {
+    const list = await this.run("SELECT sql FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
+    if (list && list.length > 0) {
+      return list[0].sql || '';
+    }
+    return '';
+  } catch (err) {
+    this.log('error', '获取表结构失败', err);
+    return '';
+  }
 };
 
 /**
  * @description 获取表数据的SQL插入语句
- * @param {String} table 表名
- * @param {Number} batchSize 批量处理大小
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|String} SQL插入语句
+ * @param {string} table 表名
+ * @param {number} batchSize 批量处理大小
+ * @param batch_size
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | string} SQL插入语句
  */
 DB.prototype.getTableData = async function (table, batchSize = 100, timeout = 60000) {
-	try {
-		if (!table) {
-			throw new TypeError('table must be specified');
-		}
-		// 获取表数据
-		const rows = await this.run(`SELECT * FROM \`${table}\``, [], timeout);
-		let sql = '';
-
-		if (rows && rows.length > 0) {
-			sql += `-- 表数据: ${table}\n`;
-
-			// 批量处理大数据量
-			for (let j = 0; j < rows.length; j += batchSize) {
-				const batch = rows.slice(j, j + batchSize);
-				for (const row of batch) {
-					try {
-						const rowValues = Object.values(row)
-							.map(value => {
-								if (value === null) return 'NULL';
-								if (typeof value === 'boolean') return value ? 1 : 0;
-								if (typeof value === 'number') return value;
-								if (value instanceof Date) {
-									return "'" + value.toISOString().slice(0, 19).replace('T', ' ') + "'";
-								}
-								// 处理字符串，转义特殊字符
-								if (typeof value === 'string') {
-									return "'" + value
-										.replace(/[\\']/g, '\\$&')
-										.replace(/\n/g, '\\n')
-										.replace(/\r/g, '\\r')
-										.replace(/\t/g, '\\t')
-										.replace(/\u0000/g, '\\0') + "'";
-								}
-								return "'" + String(value || '') + "'";
-							}).join(',');
-						sql += `INSERT INTO \`${table}\` VALUES (${rowValues});\n`;
-					} catch (rowErr) {
-						this.logger('error', '处理行数据失败', rowErr);
-					}
-				}
-			}
-			sql += '\n';
-		}
-		return sql;
-	} catch (err) {
-		this.logger('error', '获取表数据失败', err);
-		return '';
-	}
+  if (!table) {
+    throw new TypeError('table must be specified');
+  }
+  try {
+    // 获取表数据
+    const rows = await this.run(`SELECT * FROM \`${table}\``, [], timeout);
+    let sql = '';
+
+    if (rows && rows.length > 0) {
+      sql += `-- 表数据: ${table}\n`;
+
+      // 批量处理大数据量
+      for (let j = 0; j < rows.length; j += batch_size) {
+        const batch = rows.slice(j, j + batch_size);
+        for (const row of batch) {
+          try {
+            const row_data = Object.values(row)
+              .map(value => {
+                if (value === null) return 'NULL';
+                if (typeof value === 'boolean') return value ? 1 : 0;
+                if (typeof value === 'number') return value;
+                if (value instanceof Date) {
+                  return "'" + value.toISOString().slice(0, 19).replace('T', ' ') + "'";
+                }
+                // 处理字符串，转义特殊字符
+                if (typeof value === 'string') {
+                  return "'" + value
+                    .replace(/[\\']/g, '\\$&')
+                    .replace(/\n/g, '\\n')
+                    .replace(/\r/g, '\\r')
+                    .replace(/\t/g, '\\t')
+                    .replace(/\u0000/g, '\\0') + "'";
+                }
+                return "'" + String(value || '') + "'";
+              }).join(',');
+            sql += `INSERT INTO \`${table}\` VALUES (${row_data});\n`;
+          } catch (rowErr) {
+            this.log('error', '处理行数据失败', rowErr);
+          }
+        }
+      }
+      sql += '\n';
+    }
+    return sql;
+  } catch (err) {
+    this.log('error', '获取表数据失败', err);
+    return '';
+  }
 };
 
 /**
  * @description 备份表
- * @param {String} table 表名
- * @param {String} backup 备份表名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 操作结果
+ * @param {string} table 表名
+ * @param {string} backup 备份表名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 操作结果
  */
 DB.prototype.backup = function (table, backup, timeout = 60000) {
-	try {
-		if (!table || !backup) {
-			throw new TypeError('table and backup must be specified');
-		}
-		return this.backupTable(table, backup, timeout);
-	} catch (err) {
-		this.logger('error', '备份表失败', err);
-		return 0;
-	}
+  try {
+    if (!table || !backup) {
+      throw new TypeError('table and backup must be specified');
+    }
+    return this.backupTable(table, backup, timeout);
+  } catch (err) {
+    this.log('error', '备份表失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 创建表
- * @param {String} table 表名
- * @param {Object} model 表模型，键值对，根据值类型创建字段类型，根据键名创建字段名
- * @param {String} key 主键
- * @return {Promise|Number} 操作结果
+ * @param {string} table 表名
+ * @param {object} model 表模型，键值对，根据值类型创建字段类型，根据键名创建字段名
+ * @param {string} key 主键
+ * @param timeout
+ * @returns {Promise | number} 操作结果
  */
 DB.prototype.createTable = function (table, model, key = 'id', timeout = 15000) {
-	if (!table || !model) {
-		throw new TypeError('table, model must be specified');
-	}
-	var fields = '';
-	for (const field in model) {
-		const value = model[field];
-		let type = '';
-		if (field === key) {
-			type = 'INTEGER PRIMARY KEY AUTOINCREMENT';
-		} else if (typeof value === 'number') {
-			if (value % 1 === 0) {
-				type = 'INTEGER';
-			} else {
-				type = 'REAL';
-			}
-		} else if (typeof value === 'string') {
-			type = 'TEXT';
-		}
-		else {
-			type = 'BLOB';
-		}
-		fields += `\`${field}\` ${type}, `;
-	}
-	fields = fields.slice(0, -2);
-	var sql = `CREATE TABLE IF NOT EXISTS \`${table}\` (${fields});`;
-	return this.exec(sql, [], timeout);
-}
+  if (!table || !model) {
+    throw new TypeError('table, model must be specified');
+  }
+  var fields = '';
+  for (const field in model) {
+    const value = model[field];
+    let type = '';
+    if (field === key) {
+      type = 'INTEGER PRIMARY KEY AUTOINCREMENT';
+    } else if (typeof value === 'number') {
+      if (value % 1 === 0) {
+        type = 'INTEGER';
+      } else {
+        type = 'REAL';
+      }
+    } else if (typeof value === 'string') {
+      type = 'TEXT';
+    }
+    else {
+      type = 'BLOB';
+    }
+    fields += `\`${field}\` ${type}, `;
+  }
+  fields = fields.slice(0, -2);
+  var sql = `CREATE TABLE IF NOT EXISTS \`${table}\` (${fields});`;
+  return this.exec(sql, [], timeout);
+};
 
 module.exports = {
-	DB
+  DB
 };