mm_mysql 2.2.4 → 2.2.6

package/db.js

@@ -1,145 +1,145 @@
 const {
-	Sql
+  Sql
 } = require('./sql');
 
 /**
  * @class 数据库操作类
- * @extends Sql
+ * @augments Sql
  */
 class DB extends Sql {
-	/**
-	 * @description 数据库管理器
-	 * @param {Object} mysql - MySQL实例
-	 */
-	constructor(mysql) {
-		// 正确绑定run和exec方法的上下文
-		super(
-			mysql.run,
-			mysql.exec
-		);
-		// 保存mysql实例引用
-		this._mysql = mysql;
-		// 事务中
-		this.task = 0;
-
-		// 事务SQL
-		this.task_sql = "";
-
-		/**
-		 * 获取上级
-		 * @return {Object} 返回上级管理器
-		 */
-		this.parent = function () {
-			return mysql;
-		};
-	}
+  /**
+   * @description 数据库管理器
+   * @param {object} mysql - MySQL实例
+   */
+  constructor(mysql) {
+    // 正确绑定run和exec方法的上下文
+    super(
+      mysql.run,
+      mysql.exec
+    );
+    // 保存mysql实例引用
+    this._mysql = mysql;
+    // 事务中
+    this.task = 0;
+
+    // 事务SQL
+    this.task_sql = '';
+
+    /**
+     * 获取上级
+     * @returns {object} 返回上级管理器
+     */
+    this.parent = function () {
+      return mysql;
+    };
+  }
 }
 
 /**
  * 创建超时Promise
  * @private
- * @param {Number} timeout - 超时时间(毫秒)
- * @param {String} message - 错误信息
+ * @param {number} timeout - 超时时间(毫秒)
+ * @param {string} message - 错误信息
  * @returns {Promise<Error>}
  */
 DB.prototype._createTimeoutPromise = function (timeout, message) {
-	return new Promise((_, reject) => {
-		setTimeout(() => {
-			reject(new Error(message));
-		}, timeout);
-	});
+  return new Promise((_, 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) {
-	const db = this.parent().db();
-	db.table = table;
-	if (key) {
-		db.key = key;
-	} else {
-		const arr = table.split("_");
-		db.key = arr[arr.length - 1] + "_id";
-	}
-	return db;
+  const db = this.parent().db();
+  db.table = table;
+  if (key) {
+    db.key = key;
+  } else {
+    const arr = table.split('_');
+    db.key = arr[arr.length - 1] + '_id';
+  }
+  return db;
 };
 
 /**
  * 获取数据库连接
- * @returns {Promise<Object>}
+ * @returns {Promise<object>}
  */
 DB.prototype.getConn = async function() {
-    try {
-        return await this._mysql.getConn();
-    } catch (error) {
-        this.logger('error', '获取连接失败', error);
-        // 返回null作为默认值，保持返回值类型一致
-        return null;
-    }
+  try {
+    return await this._mysql.getConn();
+  } catch (error) {
+    this.log('error', '获取连接失败', error);
+    // 返回null作为默认值，保持返回值类型一致
+    return null;
+  }
 };
 
 /**
  * 开始事务
- * @returns {Promise<Object>}
+ * @returns {Promise<object>}
  */
 DB.prototype.start = async function() {
-    try {
-        return await this._mysql.beginTransaction();
-    } catch (error) {
-        this.logger('error', '开始事务失败', error);
-        // 返回null作为默认值，保持返回值类型一致
-        return null;
-    }
+  try {
+    return await this._mysql.beginTransaction();
+  } catch (error) {
+    this.log('error', '开始事务失败', error);
+    // 返回null作为默认值，保持返回值类型一致
+    return null;
+  }
 };
 
 /**
  * 提交事务
- * @param {Object} transaction - 事务对象
+ * @param {object} transaction - 事务对象
  * @returns {Promise<void>}
  * @throws {TypeError} 当transaction参数无效时
  */
 DB.prototype.commit = async function(transaction) {
-    // 参数校验
-    if (!transaction || typeof transaction !== 'object') {
-        throw new TypeError('transaction must be object');
-    }
+  // 参数校验
+  if (!transaction || typeof transaction !== 'object') {
+    throw new TypeError('transaction must be object');
+  }
     
-    try {
-        await transaction.commit();
-    } catch (error) {
-        this.logger('error', '提交事务失败', error);
-    }
+  try {
+    await transaction.commit();
+  } catch (error) {
+    this.log('error', '提交事务失败', error);
+  }
 };
 
 /**
  * 回滚事务
- * @param {Object} transaction - 事务对象
+ * @param {object} transaction - 事务对象
  * @returns {Promise<void>}
  * @throws {TypeError} 当transaction参数无效时
  */
 DB.prototype.back = async function(transaction) {
-    // 参数校验
-    if (!transaction || typeof transaction !== 'object') {
-        throw new TypeError('transaction must be object');
-    }
+  // 参数校验
+  if (!transaction || typeof transaction !== 'object') {
+    throw new TypeError('transaction must be object');
+  }
     
-    try {
-        await transaction.rollback();
-    } catch (error) {
-        this.logger('error', '回滚事务失败', error);
-    }
+  try {
+    await transaction.rollback();
+  } catch (error) {
+    this.log('error', '回滚事务失败', error);
+  }
 };
 
 /**
@@ -149,522 +149,523 @@ DB.prototype.back = async function(transaction) {
  * @throws {TypeError} 当callback参数无效时
  */
 DB.prototype.transaction = async function(callback) {
-    // 参数校验
-    if (typeof callback !== 'function') {
-        throw new TypeError('callback must be function');
-    }
+  // 参数校验
+  if (typeof callback !== 'function') {
+    throw new TypeError('callback must be function');
+  }
     
-    try {
-        return await this._mysql.transaction(callback);
-    } catch (error) {
-        this.logger('error', '事务执行失败', error);
-        // 返回null作为默认值，保持返回值类型一致
-        return null;
-    }
+  try {
+    return await this._mysql.transaction(callback);
+  } catch (error) {
+    this.log('error', '事务执行失败', error);
+    // 返回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("show tables", [], timeout);
-		const key = 'Tables_in_' + this.database();
-		if (table) {
-			// 简单的过滤实现
-			const filtered = [];
-			for (const item of list) {
-				const value = item[key];
-				if (value && value.includes(table)) {
-					filtered.push(item);
-				}
-			}
-			return filtered.map(item => item[key]);
-		}
-		// 使用原生方法提取表名
-		return list.map(item => item[key]);
-	} catch (err) {
-		this.logger('error', '获取表名失败', err);
-		return [];
-	}
+  try {
+    const list = await this.run('show tables', [], timeout);
+    const key = 'Tables_in_' + this.database();
+    if (table) {
+      // 简单的过滤实现
+      const filtered = [];
+      for (const item of list) {
+        const value = item[key];
+        if (value && value.includes(table)) {
+          filtered.push(item);
+        }
+      }
+      return filtered.map(item => item[key]);
+    }
+    // 使用原生方法提取表名
+    return list.map(item => item[key]);
+  } catch (err) {
+    this.log('error', '获取表名失败', err);
+    return [];
+  }
 };
 
 /**
  * @description 获取所有表字段
- * @param {String} table 表名
- * @param {String} field_name 字段名，可选
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Array} 字段信息列表
+ * @param {string} table 表名
+ * @param {string} field_name 字段名，可选
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise|Array} 字段信息列表
  */
 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');
-		}
-		const field = 'COLUMN_NAME as `name`,ORDINAL_POSITION as `cid`,COLUMN_DEFAULT as `dflt_value`,IS_NULLABLE as `notnull`,COLUMN_TYPE as `type`,COLUMN_KEY as `pk`,EXTRA as `auto`,COLUMN_COMMENT as `note`';
-		let sql = "select " + field + " from information_schema.COLUMNS where `table_name` = '" + targetTable +
+  try {
+    const targetTable = table || this.table;
+    if (!targetTable) {
+      throw new TypeError('table must be specified');
+    }
+    const field = 'COLUMN_NAME as `name`,ORDINAL_POSITION as `cid`,COLUMN_DEFAULT as `dflt_value`,IS_NULLABLE as `notnull`,COLUMN_TYPE as `type`,COLUMN_KEY as `pk`,EXTRA as `auto`,COLUMN_COMMENT as `note`';
+    let sql = 'select ' + field + " from information_schema.COLUMNS where `table_name` = '" + targetTable +
 			"' and `table_schema` = '" + this.database() + "'";
-		if (field_name) {
-			sql += " AND COLUMN_NAME='" + field_name + "'";
-		}
-		const list = await this.run(sql, [], timeout);
-		const len = list.length;
-		for (let i = 0; i < len; i++) {
-			list[i].pk = !!list[i].pk;
-			list[i].notnull = list[i].notnull === 'NO';
-		}
-		return list;
-	} catch (err) {
-		this.logger('error', '获取字段信息失败', err);
-		return [];
-	}
+    if (field_name) {
+      sql += " AND COLUMN_NAME='" + field_name + "'";
+    }
+    const list = await this.run(sql, [], timeout);
+    const len = list.length;
+    for (let i = 0; i < len; i++) {
+      list[i].pk = !!list[i].pk;
+      list[i].notnull = list[i].notnull === 'NO';
+    }
+    return list;
+  } catch (err) {
+    this.log('error', '获取字段信息失败', err);
+    return [];
+  }
 };
 
 /**
  * @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 a valid string');
-		}
-		if (!field) {
-			field = "id";
-		}
-		// 构建完整的字段定义
-		let fieldDef = `\`${field}\` ${type}(11)`;
-		fieldDef += " NOT NULL";
-		if (auto) {
-			fieldDef += " AUTO_INCREMENT";
-		}
-		if (commit) {
-			fieldDef += " COMMENT '" + commit + "'";
-		}
-		fieldDef += " PRIMARY KEY";
-
-		let sql = "CREATE TABLE IF NOT EXISTS \`" + table + "\` (" + fieldDef + ")";
-		sql += " ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;";
-
-		// 执行SQL并设置表名
-		const result = await this.exec(sql, timeout);
-		// 设置实例的表名属性，以便后续操作使用
-		this.table = table;
-		return result;
-	} catch (err) {
-		this.logger('error', '创建表失败', err);
-		return 0;
-	}
+  try {
+    if (!table || typeof table !== 'string') {
+      throw new TypeError('table must be a valid string');
+    }
+    if (!field) {
+      field = 'id';
+    }
+    // 构建完整的字段定义
+    let fieldDef = `\`${field}\` ${type}(11)`;
+    fieldDef += ' NOT NULL';
+    if (auto) {
+      fieldDef += ' AUTO_INCREMENT';
+    }
+    if (commit) {
+      fieldDef += " COMMENT '" + commit + "'";
+    }
+    fieldDef += ' PRIMARY KEY';
+
+    let sql = 'CREATE TABLE IF NOT EXISTS \`' + table + '\` (' + fieldDef + ')';
+    sql += ' ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;';
+
+    // 执行SQL并设置表名
+    const result = await this.exec(sql, timeout);
+    // 设置实例的表名属性，以便后续操作使用
+    this.table = table;
+    return result;
+  } catch (err) {
+    this.log('error', '创建表失败', err);
+    return 0;
+  }
 };
 
 /**
  * @description 删除表
- * @param {String} table 表名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 操作结果
+ * @param {string} table 表名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 操作结果
  */
 DB.prototype.dropTable = function (table, timeout = 15000) {
-	if (!table || typeof table !== 'string') {
-		throw new TypeError('table must be a valid string');
-	}
-	return this.exec("DROP TABLE IF EXISTS \`" + table + "\`;", timeout);
+  if (!table || typeof table !== 'string') {
+    throw new TypeError('table must be a valid string');
+  }
+  return this.exec('DROP TABLE IF EXISTS \`' + table + '\`;', timeout);
 };
 
 /**
  * @description 修改表名
- * @param {String} table 旧表名
- * @param {String} new_table 新表名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 操作结果
+ * @param {string} table 旧表名
+ * @param {string} new_table 新表名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 操作结果
  */
 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("RENAME TABLE \`" + table + "\` TO \`" + new_table + "\`;", timeout);
+  if (!table || !new_table) {
+    throw new TypeError('table and new_table must be specified');
+  }
+  return this.exec('RENAME TABLE \`' + table + '\` TO \`' + new_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');
-		}
-
-		// 构建字段定义
-		let fieldDef = `\`${field}\` ${type}`;
-
-		// 添加非空约束
-		if (not_null) {
-			fieldDef += " NOT NULL";
-		}
-
-		// 添加自增属性
-		if (auto) {
-			fieldDef += " AUTO_INCREMENT";
-		}
-
-		// 添加默认值
-		if (value !== undefined && value !== null && value !== '') {
-			if (typeof value === 'string') {
-				fieldDef += " DEFAULT '" + value + "'";
-			} else {
-				fieldDef += " DEFAULT " + value;
-			}
-		}
-
-		// 添加注释
-		if (comment) {
-			fieldDef += " COMMENT '" + comment + "'";
-		}
-
-		// 使用ADD COLUMN而不是CHANGE COLUMN
-		const sql = `ALTER TABLE \`${this.table}\` ADD COLUMN ${fieldDef};`;
-		const result = await this.exec(sql, timeout);
-		return result
-	} catch (err) {
-		this.logger('error', '添加字段失败', err);
-		return 0;
-	}
+  try {
+    // 确保表名已设置
+    if (!this.table || !field || !type) {
+      throw new TypeError('table, field, and type must be specified');
+    }
+
+    // 构建字段定义
+    let fieldDef = `\`${field}\` ${type}`;
+
+    // 添加非空约束
+    if (not_null) {
+      fieldDef += ' NOT NULL';
+    }
+
+    // 添加自增属性
+    if (auto) {
+      fieldDef += ' AUTO_INCREMENT';
+    }
+
+    // 添加默认值
+    if (value !== undefined && value !== null && value !== '') {
+      if (typeof value === 'string') {
+        fieldDef += " DEFAULT '" + value + "'";
+      } else {
+        fieldDef += ' DEFAULT ' + value;
+      }
+    }
+
+    // 添加注释
+    if (comment) {
+      fieldDef += " COMMENT '" + comment + "'";
+    }
+
+    // 使用ADD COLUMN而不是CHANGE COLUMN
+    const sql = `ALTER TABLE \`${this.table}\` ADD COLUMN ${fieldDef};`;
+    const result = await this.exec(sql, timeout);
+    return result;
+  } 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');
-		}
-		const targetName = new_name || field;
-		let fieldDef = `\`${targetName}\` ${type}`;
-		if (not_null) {
-			fieldDef += " NOT NULL";
-		}
-		if (auto) {
-			fieldDef += " AUTO_INCREMENT";
-		}
-		if (value !== undefined && value !== null && value !== '') {
-			if (typeof value === 'string') {
-				fieldDef += " DEFAULT '" + value + "'";
-			} else {
-				fieldDef += " DEFAULT " + value;
-			}
-		}
-		let sql = `ALTER TABLE \`${this.table}\` CHANGE COLUMN \`${field}\` ${fieldDef}`;
-		if (isKey) {
-			sql += ", ADD PRIMARY KEY (\`" + targetName + "\`)";
-		}
-		sql += ";";
-		const result = await this.exec(sql, timeout);
-		return result;
-	} catch (err) {
-		this.logger('error', '修改字段失败', err);
-		return 0;
-	}
+  try {
+    if (!field || !type || !this.table) {
+      throw new TypeError('field, type, and table must be specified');
+    }
+    const targetName = new_name || field;
+    let fieldDef = `\`${targetName}\` ${type}`;
+    if (not_null) {
+      fieldDef += ' NOT NULL';
+    }
+    if (auto) {
+      fieldDef += ' AUTO_INCREMENT';
+    }
+    if (value !== undefined && value !== null && value !== '') {
+      if (typeof value === 'string') {
+        fieldDef += " DEFAULT '" + value + "'";
+      } else {
+        fieldDef += ' DEFAULT ' + value;
+      }
+    }
+    let sql = `ALTER TABLE \`${this.table}\` CHANGE COLUMN \`${field}\` ${fieldDef}`;
+    if (isKey) {
+      sql += ', ADD PRIMARY KEY (\`' + targetName + '\`)';
+    }
+    sql += ';';
+    const result = await this.exec(sql, timeout);
+    return result;
+  } 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) {
-	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);
+  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);
 };
 
 /**
  * @description 删除字段
- * @param {String} table 表名
- * @param {String} field 字段名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 操作结果
+ * @param {string} table 表名
+ * @param {string} field 字段名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 操作结果
  */
 DB.prototype.delField = function (table, field, timeout = 15000) {
-	if (!table || !field) {
-		throw new TypeError('table and field must be specified');
-	}
-	return this.exec("ALTER TABLE \`" + table + "\` DROP COLUMN \`" + field + "\`;", timeout);
+  if (!table || !field) {
+    throw new TypeError('table and field must be specified');
+  }
+  return this.exec('ALTER TABLE \`' + table + '\` DROP COLUMN \`' + field + '\`;', timeout);
 };
 
 /**
  * @description 修改字段名
- * @param {String} table 表名
- * @param {String} field 旧字段名
- * @param {String} new_field 新字段名
- * @param {String} type 字段类型
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 操作结果
+ * @param {string} table 表名
+ * @param {string} field 旧字段名
+ * @param {string} new_field 新字段名
+ * @param {string} type 字段类型
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 操作结果
  */
 DB.prototype.renameField = function (table, field, new_field, type, timeout = 15000) {
-	if (!table || !field || !new_field) {
-		throw new TypeError('table, field, and new_field must be specified');
-	}
-	return this.exec("ALTER TABLE \`" + table + "\` CHANGE \`" + field + "\` \`" + new_field + "\` " + type + ";", timeout);
+  if (!table || !field || !new_field) {
+    throw new TypeError('table, field, and new_field must be specified');
+  }
+  return this.exec('ALTER TABLE \`' + table + '\` CHANGE \`' + field + '\` \`' + new_field + '\` ' + type + ';', 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) {
-	if (!table) {
-		throw new TypeError('table must be specified');
-	}
-	try {
-		const list = await this.run("SHOW CREATE TABLE \`" + table + "\`;", [], timeout);
-		if (list && list.length > 0) {
-			return list[0]["Create Table"] || list[0]["create table"];
-		}
-		return '';
-	} catch (err) {
-		this.logger('error', '获取表结构失败', err);
-		return '';
-	}
+  if (!table) {
+    throw new TypeError('table must be specified');
+  }
+  try {
+    const list = await this.run('SHOW CREATE TABLE \`' + table + '\`;', [], timeout);
+    if (list && list.length > 0) {
+      return list[0]['Create Table'] || list[0]['create table'];
+    }
+    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 {number} timeout 超时时间(毫秒)
+ * @returns {Promise | string} SQL插入语句
  */
 DB.prototype.getTableData = async function (table, batchSize = 100, timeout = 60000) {
-	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 += 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 += 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.log('error', '处理行数据失败', rowErr);
+          }
+        }
+      }
+      sql += '\n';
+    }
+    return sql;
+  } catch (err) {
+    this.log('error', '获取表数据失败', err);
+    return '';
+  }
 };
 
 /**
  * @description 清空表数据
- * @param {String} table 表名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Number} 操作结果
+ * @param {string} table 表名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | number} 操作结果
  */
 DB.prototype.emptyTable = function (table, timeout = 15000) {
-	if (!table || typeof table !== 'string') {
-		throw new TypeError('table must be a valid string');
-	}
-	return this.exec("TRUNCATE TABLE \`" + table + "\`;", timeout);
+  if (!table || typeof table !== 'string') {
+    throw new TypeError('table must be a valid string');
+  }
+  return this.exec('TRUNCATE TABLE \`' + table + '\`;', timeout);
 };
 
 /**
  * @description 检查表是否存在
- * @param {String} table 表名
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise|Boolean} 是否存在
+ * @param {string} table 表名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | boolean} 是否存在
  */
 DB.prototype.hasTable = async function (table, timeout = 15000) {
-	if (!table || typeof table !== 'string') {
-		return false;
-	}
-	try {
-		const list = await this.run("SHOW TABLES LIKE '" + table + "'", [], timeout);
-		return list && list.length > 0;
-	} catch (err) {
-		this.logger('error', '检查表是否存在失败', err);
-		return false;
-	}
+  if (!table || typeof table !== 'string') {
+    return false;
+  }
+  try {
+    const list = await this.run("SHOW TABLES LIKE '" + 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} 是否存在
+ * @param {string} table 表名
+ * @param {string} field 字段名
+ * @param {number} timeout 超时时间(毫秒)
+ * @returns {Promise | boolean} 是否存在
  */
 DB.prototype.hasField = async function (table, field, timeout = 15000) {
-	if (!table || !field) {
-		return false;
-	}
-	try {
-		const list = await this.fields(table, field, timeout);
-		return list && list.length > 0;
-	} catch (err) {
-		this.logger('error', '检查字段是否存在失败', err);
-		return false;
-	}
+  if (!table || !field) {
+    return false;
+  }
+  try {
+    const list = await this.fields(table, field, timeout);
+    return list && list.length > 0;
+  } catch (err) {
+    this.log('error', '检查字段是否存在失败', err);
+    return false;
+  }
 };
 
 /**
  * @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.backupTable = function (table, backup, timeout = 60000) {
-	if (!table || !backup) {
-		throw new TypeError('table and backup must be specified');
-	}
-	return this.exec("CREATE TABLE \`" + backup + "\` LIKE \`" + table + "\`; INSERT INTO \`" + backup + "\` SELECT * FROM \`" + table + "\`;", timeout);
+  if (!table || !backup) {
+    throw new TypeError('table and backup must be specified');
+  }
+  return this.exec('CREATE TABLE \`' + backup + '\` LIKE \`' + table + '\`; INSERT INTO \`' + backup + '\` SELECT * FROM \`' + table + '\`;', timeout);
 };
 
 
 /**
  * @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 || !model.fields) {
-		throw new TypeError('table, model, and model.fields must be specified');
-	}
-	var fields = '';
-	for (const field in model.fields) {
-		const value = model.fields[field];
-		let type = '';
-		if (field === key) {
-			type = 'INT AUTO_INCREMENT PRIMARY KEY';
-		} else if (typeof value === 'number') {
-			if (value % 1 === 0) {
-				// 判断是否时间戳（10位或13位数字）
-				const now = Date.now();
-				const isTimestamp = (value >= 1000000000 && value <= now * 1.1); // 10位或13位时间戳
-				if (isTimestamp) {
-					type = 'DATETIME';
-				} else {
-					type = 'INT';
-				}
-			} else {
-				type = 'FLOAT';
-			}
-		} else if (typeof value === 'string') {
-			type = 'TEXT';
-			if (value.length <= 255) {
-				// 正则判断是否日期时间型
-				if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)) {
-					type = 'DATETIME';
-				}
-				// 正则判断是否日期型
-				else if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-					type = 'DATE';
-				}
-				// 正则判断是否时间型
-				else if (/^\d{2}:\d{2}:\d{2}$/.test(value)) {
-					type = 'TIME';
-				}
-				// 正则判断是否JSON字符串
-				else if (/^[{[]/.test(value) && /[}]]$/.test(value)) {
-					type = 'TEXT';
-				}
-				// 正则判断是否html
-				else if (/^<[a-z][\s\S]*>/i.test(value)) {
-					type = 'TEXT';
-				}
-				// 正则判断是否xml
-				else if (/^<\?xml[\s\S]*\?>/.test(value)) {
-					type = 'TEXT';
-				}
-				else {
-					type = 'VARCHAR(255)';
-				}
-			}
-		}
-		else if (typeof value === 'boolean') {
-			type = 'tinyint(1)';
-		}
-		else if (value instanceof Date) {
-			// 判断是否Date对象，类型为datetime
-			type = 'DATETIME';
-		}
-		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 = 'INT AUTO_INCREMENT PRIMARY KEY';
+    } else if (typeof value === 'number') {
+      if (value % 1 === 0) {
+        // 判断是否时间戳（10位或13位数字）
+        const now = Date.now();
+        const isTimestamp = (value >= 1000000000 && value <= now * 1.1); // 10位或13位时间戳
+        if (isTimestamp) {
+          type = 'DATETIME';
+        } else {
+          type = 'INT';
+        }
+      } else {
+        type = 'FLOAT';
+      }
+    } else if (typeof value === 'string') {
+      type = 'TEXT';
+      if (value.length <= 255) {
+        // 正则判断是否日期时间型
+        if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)) {
+          type = 'DATETIME';
+        }
+        // 正则判断是否日期型
+        else if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+          type = 'DATE';
+        }
+        // 正则判断是否时间型
+        else if (/^\d{2}:\d{2}:\d{2}$/.test(value)) {
+          type = 'TIME';
+        }
+        // 正则判断是否JSON字符串
+        else if (/^[{[]/.test(value) && /[}]]$/.test(value)) {
+          type = 'TEXT';
+        }
+        // 正则判断是否html
+        else if (/^<[a-z][\s\S]*>/i.test(value)) {
+          type = 'TEXT';
+        }
+        // 正则判断是否xml
+        else if (/^<\?xml[\s\S]*\?>/.test(value)) {
+          type = 'TEXT';
+        }
+        else {
+          type = 'VARCHAR(255)';
+        }
+      }
+    }
+    else if (typeof value === 'boolean') {
+      type = 'tinyint(1)';
+    }
+    else if (value instanceof Date) {
+      // 判断是否Date对象，类型为datetime
+      type = 'DATETIME';
+    }
+    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
 };