mm_mysql 2.1.1 → 2.2.1

package/db.js

@@ -1,4 +1,6 @@
-const Sql = require('./sql');
+const {
+	Sql
+} = require('./sql');
 
 /**
  * @class 数据库操作类
@@ -10,7 +12,11 @@ class DB extends Sql {
 	 * @param {Object} mysql - MySQL实例
 	 */
 	constructor(mysql) {
-		super(mysql.run, mysql.exec);
+		// 正确绑定run和exec方法的上下文
+		super(
+			mysql.run ? mysql.run.bind(mysql) : null,
+			mysql.exec ? mysql.exec.bind(mysql) : null
+		);
 		// 保存mysql实例引用
 		this._mysql = mysql;
 		// 事务中
@@ -23,7 +29,7 @@ class DB extends Sql {
 		 * 获取上级
 		 * @return {Object} 返回上级管理器
 		 */
-		this.parent = function() {
+		this.parent = function () {
 			return mysql;
 		};
 	}
@@ -36,7 +42,7 @@ class DB extends Sql {
  * @param {String} message - 错误信息
  * @returns {Promise<Error>}
  */
-DB.prototype._createTimeoutPromise = function(timeout, message) {
+DB.prototype._createTimeoutPromise = function (timeout, message) {
 	return new Promise((_, reject) => {
 		setTimeout(() => {
 			reject(new Error(message));
@@ -48,7 +54,7 @@ DB.prototype._createTimeoutPromise = function(timeout, message) {
  * 获取数据库名
  * @return {String} 数据库
  */
-DB.prototype.database = function() {
+DB.prototype.database = function () {
 	return this.parent().config.database;
 };
 
@@ -58,7 +64,7 @@ DB.prototype.database = function() {
  * @param {String} key 键名
  * @return {Object} 返回管理器
  */
-DB.prototype.new = function(table, key) {
+DB.prototype.new = function (table, key) {
 	const db = this.parent().db();
 	db.table = table;
 	if (key) {
@@ -72,157 +78,139 @@ DB.prototype.new = function(table, key) {
 
 /**
  * 执行SQL查询
- * @param {string} sql SQL语句
- * @param {Array} params 参数数组
- * @param {Number} timeout 超时时间(毫秒)
- * @returns {Promise<Object>} 查询结果
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @returns {Promise<Array>}
+ * @throws {TypeError} 当sql参数无效时
  */
-DB.prototype.run = async function(sql, params = [], timeout = 30000) {
-	if (!this._mysql) {
-		throw new Error('MySQL实例未初始化');
-	}
-	try {
-		// 使用Promise.race实现超时控制
-		return await Promise.race([
-			this._mysql.run(sql, params),
-			this._createTimeoutPromise(timeout, `查询执行超时: ${sql.substring(0, 100)}...`)
-		]);
-	} catch (error) {
-		$.log.error(`[DB] [run] 查询执行失败`, {
-			error: error.message,
-			sql: sql.substring(0, 200),
-			params: JSON.stringify(params.slice(0, 5))
-		});
-		throw error;
-	}
+DB.prototype.run = async function(sql, params = []) {
+    // 参数校验
+    if (typeof sql !== 'string' || sql.trim() === '') {
+        throw new TypeError('sql must be non-empty string');
+    }
+    if (!Array.isArray(params)) {
+        throw new TypeError('params must be array');
+    }
+    
+    try {
+        return await this._mysql.run(sql, params);
+    } catch (error) {
+        this.logger('error', 'SQL执行失败', error);
+        // 返回空数组作为默认值，保持返回值类型一致
+        return [];
+    }
 };
 
 /**
- * 执行SQL命令
- * @param {string} sql SQL语句
- * @param {Number} timeout 超时时间(毫秒)
- * @returns {Promise<Object>} 执行结果
+ * 执行SQL语句
+ * @param {String} sql - SQL语句
+ * @param {Array} params - 参数数组
+ * @returns {Promise<Object>}
+ * @throws {TypeError} 当sql参数无效时
  */
-DB.prototype.exec = async function(sql, timeout = 60000) {
-	if (!this._mysql) {
-		throw new Error('MySQL实例未初始化');
-	}
-	try {
-		// 增加超时时间到60秒，避免连接超时问题
-		return await this._mysql.exec(sql, []);
-	} catch (error) {
-		$.log.error(`[DB] [exec] 命令执行失败`, {
-			error: error.message,
-			sql: sql.substring(0, 200)
-		});
-		throw error;
-	}
+DB.prototype.exec = async function(sql, params = []) {
+    // 参数校验
+    if (typeof sql !== 'string' || sql.trim() === '') {
+        throw new TypeError('sql must be non-empty string');
+    }
+    if (!Array.isArray(params)) {
+        throw new TypeError('params must be array');
+    }
+    
+    try {
+        return await this._mysql.exec(sql, params);
+    } catch (error) {
+        this.logger('error', 'SQL执行失败', error);
+        // 返回空数组作为默认值，保持返回值类型一致
+        return 0;
+    }
 };
 
 /**
  * 获取数据库连接
- * @param {Number} timeout 超时时间(毫秒)
- * @returns {Promise<Object>} 数据库连接对象
+ * @returns {Promise<Object>}
  */
-DB.prototype.getConn = async function(timeout = 60000) {
-	if (!this._mysql) {
-		throw new Error('MySQL实例未初始化');
-	}
-	try {
-		// 增加超时时间到60秒，直接调用mysql实例的getConn方法
-		return await this._mysql.getConn();
-	} catch (error) {
-		$.log.error(`[DB] [getConn] 获取连接失败`, {
-			error: error.message
-		});
-		throw error;
-	}
+DB.prototype.getConn = async function() {
+    try {
+        return await this._mysql.getConn();
+    } catch (error) {
+        this.logger('error', '获取连接失败', error);
+        // 返回null作为默认值，保持返回值类型一致
+        return null;
+    }
 };
 
 /**
- * 事务开始
- * @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("SET AUTOCOMMIT=0;BEGIN;", timeout);
-	} catch (err) {
-		this.task = 0;
-		$.log.error(`[DB] [start] 事务开始失败: ${err.message}`);
-		throw err;
-	}
+DB.prototype.start = async function() {
+    try {
+        return await this._mysql.beginTransaction();
+    } catch (error) {
+        this.logger('error', '开始事务失败', error);
+        // 返回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) {
-		$.log.error(`[DB] [commit] 事务提交失败: ${err.message}`);
-		// 尝试回滚
-		try {
-			await this.exec("ROLLBACK;", timeout);
-		} catch (rollbackErr) {
-			$.log.error(`[DB] [commit] 事务回滚也失败: ${rollbackErr.message}`);
-		}
-		this.task = 0;
-		this.task_sql = '';
-		throw err;
-	}
+DB.prototype.commit = async function(transaction) {
+    // 参数校验
+    if (!transaction || typeof transaction !== 'object') {
+        throw new TypeError('transaction must be object');
+    }
+    
+    try {
+        await transaction.commit();
+    } catch (error) {
+        this.logger('error', '提交事务失败', error);
+    }
 };
 
 /**
- * 事务结束
+ * 回滚事务
+ * @param {Object} transaction - 事务对象
+ * @returns {Promise<void>}
+ * @throws {TypeError} 当transaction参数无效时
  */
-DB.prototype.end = function() {
-	// 确保事务状态被重置
-	this.task = 0;
-	this.task_sql = '';
+DB.prototype.back = async function(transaction) {
+    // 参数校验
+    if (!transaction || typeof transaction !== 'object') {
+        throw new TypeError('transaction must be object');
+    }
+    
+    try {
+        await transaction.rollback();
+    } catch (error) {
+        this.logger('error', '回滚事务失败', error);
+    }
 };
 
 /**
- * 滚回
- * @param {String} identifier 事务标识符
- * @param {Number} timeout 超时时间(毫秒)
- * @return {Promise<Object>} 执行结果
+ * 在事务中执行多个操作
+ * @param {Function} callback - 包含事务操作的回调函数
+ * @returns {Promise<*>}
+ * @throws {TypeError} 当callback参数无效时
  */
-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("SET AUTOCOMMIT=1;", timeout);
-		// 重置事务状态
-		this.task = 0;
-		this.task_sql = '';
-		return result;
-	} catch (err) {
-		$.log.error(`[DB] [back] 事务回滚失败: ${err.message}`);
-		this.task = 0;
-		this.task_sql = '';
-		throw err;
-	}
+DB.prototype.transaction = async function(callback) {
+    // 参数校验
+    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;
+    }
 };
 
 /**
@@ -231,7 +219,7 @@ DB.prototype.back = async function(identifier = "point_1", timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Array} 表名数组
  */
-DB.prototype.tables = async function(table, timeout = 15000) {
+DB.prototype.tables = async function (table, timeout = 15000) {
 	try {
 		const list = await this.run("show tables", [], timeout);
 		const key = 'Tables_in_' + this.database();
@@ -249,7 +237,7 @@ DB.prototype.tables = async function(table, timeout = 15000) {
 		// 使用原生方法提取表名
 		return list.map(item => item[key]);
 	} catch (err) {
-		$.log.error(`[DB] [tables] 获取表名失败: ${err.message}`);
+		this.logger('error', '获取表名失败', err);
 		return [];
 	}
 };
@@ -261,12 +249,11 @@ DB.prototype.tables = async function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Array} 字段信息列表
  */
-DB.prototype.fields = async function(table, field_name, timeout = 15000) {
+DB.prototype.fields = async function (table, field_name, timeout = 15000) {
 	try {
 		const targetTable = table || this.table;
 		if (!targetTable) {
-			$.log.error("[DB] [fields] 未指定表名");
-			return [];
+			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 +
@@ -282,7 +269,7 @@ DB.prototype.fields = async function(table, field_name, timeout = 15000) {
 		}
 		return list;
 	} catch (err) {
-		$.log.error(`[DB] [fields] 获取字段信息失败: ${err.message}`);
+		this.logger('error', '获取字段信息失败', err);
 		return [];
 	}
 };
@@ -297,11 +284,10 @@ DB.prototype.fields = async function(table, field_name, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 创建成功返回1，失败返回0
  */
-DB.prototype.addTable = async function(table, field, type = 'int', auto = true, commit = '', timeout = 15000) {
+DB.prototype.addTable = async function (table, field, type = 'int', auto = true, commit = '', timeout = 15000) {
 	try {
 		if (!table || typeof table !== 'string') {
-			$.log.error("[DB] [addTable] 表名无效");
-			return 0;
+			throw new TypeError('table must be a valid string');
 		}
 		if (!field) {
 			field = "id";
@@ -316,17 +302,17 @@ DB.prototype.addTable = async function(table, field, type = 'int', auto = true,
 			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 && result.affectedRows !== undefined ? 1 : 0;
+		return result;
 	} catch (err) {
-		$.log.error(`[DB] [addTable] 创建表失败: ${err.message}`);
+		this.logger('error', '创建表失败', err);
 		return 0;
 	}
 };
@@ -337,10 +323,9 @@ DB.prototype.addTable = async function(table, field, type = 'int', auto = true,
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.dropTable = function(table, timeout = 15000) {
+DB.prototype.dropTable = function (table, timeout = 15000) {
 	if (!table || typeof table !== 'string') {
-		$.log.error("[DB] [dropTable] 表名无效");
-		return 0;
+		throw new TypeError('table must be a valid string');
 	}
 	return this.exec("DROP TABLE IF EXISTS \`" + table + "\`;", timeout);
 };
@@ -352,10 +337,9 @@ DB.prototype.dropTable = function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.renameTable = function(table, new_table, timeout = 15000) {
+DB.prototype.renameTable = function (table, new_table, timeout = 15000) {
 	if (!table || !new_table) {
-		$.log.error("[DB] [renameTable] 表名参数不完整");
-		return 0;
+		throw new TypeError('table and new_table must be specified');
 	}
 	return this.exec("RENAME TABLE \`" + table + "\` TO \`" + new_table + "\`;", timeout);
 };
@@ -371,27 +355,26 @@ DB.prototype.renameTable = function(table, new_table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 添加成功返回1，失败返回0
  */
-DB.prototype.addField = async function(field, type, value = '', not_null = true, auto = false, comment = '', timeout = 15000) {
+DB.prototype.addField = async function (field, type, value = '', not_null = true, auto = false, comment = '', timeout = 15000) {
 	try {
 		// 确保表名已设置
 		if (!this.table || !field || !type) {
-			$.log.error("[DB] [addField] 表名、字段名或类型未指定");
-			return 0;
+			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') {
@@ -400,18 +383,18 @@ DB.prototype.addField = async function(field, type, value = '', not_null = true,
 				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 && result.affectedRows !== undefined ? 1 : 0;
+		return result
 	} catch (err) {
-		$.log.error(`[DB] [addField] 添加字段失败: ${err.message}`);
+		this.logger('error', '添加字段失败', err);
 		return 0;
 	}
 };
@@ -428,11 +411,10 @@ DB.prototype.addField = async function(field, type, value = '', not_null = true,
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 修改成功返回1，失败返回0
  */
-DB.prototype.setField = async function(field, type, value = '', not_null = true, auto = false, isKey = false, new_name = '', timeout = 15000) {
+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) {
-			$.log.error("[DB] [setField] 参数不完整或表名未设置");
-			return 0;
+			throw new TypeError('field, type, and table must be specified');
 		}
 		const targetName = new_name || field;
 		let fieldDef = `\`${targetName}\` ${type}`;
@@ -455,9 +437,9 @@ DB.prototype.setField = async function(field, type, value = '', not_null = true,
 		}
 		sql += ";";
 		const result = await this.exec(sql, timeout);
-		return result && result.affectedRows !== undefined ? 1 : 0;
+		return result;
 	} catch (err) {
-		$.log.error(`[DB] [setField] 修改字段失败: ${err.message}`);
+		this.logger('error', '修改字段失败', err);
 		return 0;
 	}
 };
@@ -470,10 +452,9 @@ DB.prototype.setField = async function(field, type, value = '', not_null = true,
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.editField = function(table, field, type, timeout = 15000) {
+DB.prototype.editField = function (table, field, type, timeout = 15000) {
 	if (!table || !field || !type) {
-		$.log.error("[DB] [editField] 参数不完整");
-		return 0;
+		throw new TypeError('table, field, and type must be specified');
 	}
 	return this.exec("ALTER TABLE \`" + table + "\` MODIFY COLUMN \`" + field + "\` " + type + ";", timeout);
 };
@@ -485,10 +466,9 @@ DB.prototype.editField = function(table, field, type, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.delField = function(table, field, timeout = 15000) {
+DB.prototype.delField = function (table, field, timeout = 15000) {
 	if (!table || !field) {
-		$.log.error("[DB] [delField] 参数不完整");
-		return 0;
+		throw new TypeError('table and field must be specified');
 	}
 	return this.exec("ALTER TABLE \`" + table + "\` DROP COLUMN \`" + field + "\`;", timeout);
 };
@@ -502,10 +482,9 @@ DB.prototype.delField = function(table, field, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.renameField = function(table, field, new_field, type, timeout = 15000) {
+DB.prototype.renameField = function (table, field, new_field, type, timeout = 15000) {
 	if (!table || !field || !new_field) {
-		$.log.error("[DB] [renameField] 参数不完整");
-		return 0;
+		throw new TypeError('table, field, and new_field must be specified');
 	}
 	return this.exec("ALTER TABLE \`" + table + "\` CHANGE \`" + field + "\` \`" + new_field + "\` " + type + ";", timeout);
 };
@@ -516,10 +495,9 @@ DB.prototype.renameField = function(table, field, new_field, type, timeout = 150
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|String} 创建语句
  */
-DB.prototype.getCreateTable = async function(table, timeout = 15000) {
+DB.prototype.getCreateTable = async function (table, timeout = 15000) {
 	if (!table) {
-		$.log.error("[DB] [getCreateTable] 表名不能为空");
-		return '';
+		throw new TypeError('table must be specified');
 	}
 	try {
 		const list = await this.run("SHOW CREATE TABLE \`" + table + "\`;", [], timeout);
@@ -528,7 +506,7 @@ DB.prototype.getCreateTable = async function(table, timeout = 15000) {
 		}
 		return '';
 	} catch (err) {
-		$.log.error(`[DB] [getCreateTable] 获取表结构失败: ${err.message}`);
+		this.logger('error', '获取表结构失败', err);
 		return '';
 	}
 };
@@ -540,19 +518,18 @@ DB.prototype.getCreateTable = async function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|String} SQL插入语句
  */
-DB.prototype.getTableData = async function(table, batchSize = 100, timeout = 60000) {
+DB.prototype.getTableData = async function (table, batchSize = 100, timeout = 60000) {
 	if (!table) {
-		$.log.error("[DB] [getTableData] 表名不能为空");
-		return '';
+		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);
@@ -579,15 +556,15 @@ DB.prototype.getTableData = async function(table, batchSize = 100, timeout = 600
 							}).join(',');
 						sql += `INSERT INTO \`${table}\` VALUES (${rowValues});\n`;
 					} catch (rowErr) {
-						$.log.error(`[DB] [getTableData] 处理行数据失败: ${rowErr.message}`);
-					}
+					this.logger('error', '处理行数据失败', rowErr);
+				}
 				}
 			}
 			sql += '\n';
 		}
 		return sql;
 	} catch (err) {
-		$.log.error(`[DB] [getTableData] 获取表数据失败: ${err.message}`);
+		this.logger('error', '获取表数据失败', err);
 		return '';
 	}
 };
@@ -598,10 +575,9 @@ DB.prototype.getTableData = async function(table, batchSize = 100, timeout = 600
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.emptyTable = function(table, timeout = 15000) {
+DB.prototype.emptyTable = function (table, timeout = 15000) {
 	if (!table || typeof table !== 'string') {
-		$.log.error("[DB] [emptyTable] 表名无效");
-		return 0;
+		throw new TypeError('table must be a valid string');
 	}
 	return this.exec("TRUNCATE TABLE \`" + table + "\`;", timeout);
 };
@@ -612,7 +588,7 @@ DB.prototype.emptyTable = function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Boolean} 是否存在
  */
-DB.prototype.hasTable = async function(table, timeout = 15000) {
+DB.prototype.hasTable = async function (table, timeout = 15000) {
 	if (!table || typeof table !== 'string') {
 		return false;
 	}
@@ -620,7 +596,7 @@ DB.prototype.hasTable = async function(table, timeout = 15000) {
 		const list = await this.run("SHOW TABLES LIKE '" + table + "'", [], timeout);
 		return list && list.length > 0;
 	} catch (err) {
-		$.log.error(`[DB] [hasTable] 检查表是否存在失败: ${err.message}`);
+		this.logger('error', '检查表是否存在失败', err);
 		return false;
 	}
 };
@@ -632,7 +608,7 @@ DB.prototype.hasTable = async function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Boolean} 是否存在
  */
-DB.prototype.hasField = async function(table, field, timeout = 15000) {
+DB.prototype.hasField = async function (table, field, timeout = 15000) {
 	if (!table || !field) {
 		return false;
 	}
@@ -640,7 +616,7 @@ DB.prototype.hasField = async function(table, field, timeout = 15000) {
 		const list = await this.fields(table, field, timeout);
 		return list && list.length > 0;
 	} catch (err) {
-		$.log.error(`[DB] [hasField] 检查字段是否存在失败: ${err.message}`);
+		this.logger('error', '检查字段是否存在失败', err);
 		return false;
 	}
 };
@@ -652,14 +628,93 @@ DB.prototype.hasField = async function(table, field, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.backupTable = function(table, backup, timeout = 60000) {
+DB.prototype.backupTable = function (table, backup, timeout = 60000) {
 	if (!table || !backup) {
-		$.log.error("[DB] [backupTable] 参数不完整");
-		return 0;
+		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} 操作结果
+ */
+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);
+}
+
 module.exports = {
 	DB
-};
+};