mm_sqlite 1.0.5 → 1.0.7

package/db.js

@@ -7,198 +7,872 @@ const Sql = require('./sql');
 class DB extends Sql {
 	/**
 	 * @description 数据库管理器
-	 * @param {String} database 数据库名称
-	 * @param {Object} run 查询函数
-	 * @param {Object} exec 更改函数
+	 * @param {Object} mysql MySQL实例
 	 */
-	constructor(database, run, exec) {
-		super(run, exec);
+	constructor(mysql) {
+		super(mysql.run, mysql.exec);
+		// 保存mysql实例引用
+		this._mysql = mysql;
+		// 事务中
+		this.task = 0;
 
-		// 数据库名
-		this.database = database;
+		// 事务SQL
+		this.task_sql = "";
+
+		/**
+		 * 获取上级
+		 * @return {Object} 返回上级管理器
+		 */
+		this.parent = function() {
+			return mysql;
+		};
 	}
 }
 
 /**
- * @description 批量添加数据
- * @param {Array} list 添加的对象组
- * @property {Promise|Number} 返回成功数 
+ * 创建超时Promise
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @param {String} message - 超时提示信息
+ * @return {Promise} 超时Promise
+ */
+DB.prototype._createTimeoutPromise = function(timeout, message) {
+	return new Promise((_, reject) => {
+		setTimeout(() => {
+			reject(new Error(message));
+		}, timeout);
+	});
+};
+
+/**
+ * 获取数据库名
+ * @return {String} 数据库
+ */
+DB.prototype.database = function() {
+	return this.parent().config.database;
+};
+
+/**
+ * 构建新管理器
+ * @param {String} table 表名
+ * @param {String} key 键名
+ * @return {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;
+};
+
+/**
+ * 执行SQL查询
+ * @param {string} sql SQL语句
+ * @param {Array} params 参数数组
+ * @param {Number} timeout 超时时间(毫秒)
+ * @returns {Promise<Object>} 查询结果
  */
-DB.prototype.addList = async function(list) {
-	var bl_num = 0;
-	var len = list.length;
-	for (var i = 0; i < len; i++) {
-		var bl = await this.addObj(list[i]);
-		if(bl)
-		{
-			bl_num += 1;
+DB.prototype.run = async function(sql, params = [], timeout = 30000) {
+	if (!this._mysql) {
+		throw new Error('SQLite实例未初始化');
+	}
+	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;
+	}
+};
+
+/**
+ * 执行SQL命令
+ * @param {string} sql SQL语句
+ * @param {Number} timeout 超时时间(毫秒)
+ * @returns {Promise<Object>} 执行结果
+ */
+DB.prototype.exec = async function(sql, timeout = 30000) {
+	if (!this._mysql) {
+		throw new Error('SQLite实例未初始化');
+	}
+	try {
+		// 使用Promise.race实现超时控制
+		return await Promise.race([
+			this._mysql.exec(sql),
+			this._createTimeoutPromise(timeout, `命令执行超时: ${sql.substring(0, 100)}...`)
+		]);
+	} catch (error) {
+		$.log.error(`[DB] [exec] 命令执行失败`, {
+			error: error.message,
+			sql: sql.substring(0, 200)
+		});
+		throw error;
+	}
+};
+
+/**
+ * 获取数据库连接
+ * @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) {
+		$.log.error(`[DB] [getConn] 获取连接失败`, {
+			error: error.message
+		});
+		throw error;
+	}
+};
+
+/**
+ * 事务开始
+ * @param {String} identifier 事务标识符
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {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;
+		$.log.error(`[DB] [start] 事务开始失败: ${err.message}`);
+		throw err;
+	}
+};
+
+/**
+ * 提交
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {Promise<Object>} 执行结果
+ */
+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.end = function() {
+	// 确保事务状态被重置
+	this.task = 0;
+	this.task_sql = '';
+};
+
+/**
+ * 滚回
+ * @param {String} identifier 事务标识符
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {Promise<Object>} 执行结果
+ */
+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) {
+		$.log.error(`[DB] [back] 事务回滚失败: ${err.message}`);
+		this.task = 0;
+		this.task_sql = '';
+		throw err;
 	}
-	return bl_num;
 };
 
 /**
  * @description 获取所有表名
- * @param {String} table 表名关键词
+ * @param {String} table 表名关键词, 可以 *table*包含、*table后缀、table*前缀 查询
+ * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Array} 表名数组
  */
-DB.prototype.tables = async function(table) {
-	var list = await this.run("SELECT `name` FROM sqlite_master WHERE type='table';");
-	if (table) {
-		list = list.search(table, 'name');
+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) {
+		$.log.error(`[DB] [tables] 获取表名失败: ${err.message}`);
+		return [];
 	}
-	return list.getArr('name');
 };
 
 /**
  * @description 获取所有表字段
  * @param {String} table 表名
+ * @param {String} field_name 字段名，可选
+ * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Array} 字段信息列表
  */
-DB.prototype.fields = async function(table) {
-	if (!table) {
-		table = this.table;
-	}
-	var sql = "PRAGMA table_info(`{0}`);".replace('{0}', table);
-	var list = await this.run(sql);
-	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;
+DB.prototype.fields = async function(table, field_name, timeout = 15000) {
+	try {
+		const targetTable = table || this.table;
+		if (!targetTable) {
+			$.log.error("[DB] [fields] 未指定表名");
+			return [];
+		}
+		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) {
+		$.log.error(`[DB] [fields] 获取字段信息失败: ${err.message}`);
+		return [];
 	}
-	return list;
 };
 
 /**
  * @description 设置类型
- * @param {String} type 类型名, 常用类型 mediumint, int, varchar
- * @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 自动
+ * @return {String} 返回最终类型
  */
-DB.prototype.setType = function(type, auto) {
+DB.prototype.setType = function(field, type, value, not_null, auto) {
 	if (!type) {
-		type = 'int';
+		type = 'integer';
 	}
 	switch (type) {
 		case "str":
 		case "varchar":
 		case "string":
-			type = "varchar(255) NOT NULL";
+			type = "varchar(255)";
+			if (not_null) {
+				type += " NOT NULL";
+			}
+			if (value) {
+				type += " DEFAULT '" + value + "'";
+			} else {
+				type += " DEFAULT ''";
+			}
 			break;
-		case "int":
 		case "number":
-			type = "integer NOT NULL";
-			if (auto || auto === undefined) {
+			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) NOT NULL";
+			type = "tinyint(1) UNSIGNED NOT NULL";
+			if (value) {
+				type += " DEFAULT " + value;
+			} else {
+				type += " DEFAULT 0";
+			}
 			break;
-		default:
+		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 (type.indexOf('int') !== -1) {
-				if (auto || auto === undefined) {
+			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  类型名 (string) 常用类型 mediumint, int, varchar
- * @param {Boolean} auto 是否自增字段, 默认为自增字段 
- * @return {Promise|Boolean} 执行结果
+ * @param {String} type 类型名，常用类型 mediumint, int, varchar
+ * @param {Boolean} auto 是否自增字段, 默认为自增字段
+ * @param {String} commit 注释
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {Promise|Number} 创建成功返回1，失败返回0
  */
-DB.prototype.addTable = async function(table, field, type, auto) {
-	if (!field) {
-		field = "id";
+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;
+		}
+		if (!field) {
+			field = "id";
+		}
+		var sql = "CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2})".replace('{0}', table).replace(
+			'{1}', field).replace('{2}', this.setType(field, type, null, true, auto) + ' PRIMARY KEY');
+		if (commit) {
+			sql += " COMMENT = '" + commit + "';"
+		} else {
+			sql += ";"
+		}
+		var bl = await this.exec(sql, timeout);
+		// 设置实例的表名属性，以便后续操作使用
+		this.table = table;
+		return bl && bl.affectedRows !== undefined ? 1 : 0;
+	} catch (err) {
+		$.log.error(`[DB] [addTable] 创建表失败: ${err.message}`);
+		return 0;
 	}
-	var te = this.setType(type, auto).replace('NULL', 'NULL PRIMARY KEY');
-	var sql = "CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2});".replace('{0}', table).replace('{1}',
-		field).replace('{2}', te);
-	return await this.exec(sql);
 };
 
 /**
- * @description 创建数据表
+ * @description 清空数据表
+ * @param {Boolean} reset 是否重置自增ID
+ * @param {String} table 表名
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @return {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;
+};
+
+/**
+ * @description 添加字段
  * @param {String} field 字段名
- * @param {String} type  类型名 (string) 常用类型 mediumint, int, float, double, varchar, tinyint, text, date, datetime, time
- * @param {String|Number} isKey 默认值
- * @param {Boolean} isKey 是否主键
- * @return {Promise|Boolean} 添加成功返回true, 失败返回false
- */
-DB.prototype.field_add = async function(field, type, value, isKey) {
-	var sql =
-		"select count(*) as `count` from sqlite_master where `type` = 'table' and `name` = '{0}' and `sql` like '%`{1}`%'";
-	sql = sql.replace('{0}', this.table).replace('{1}', field);
-	var arr = await this.run(sql);
-	if (arr && arr.length > 0) {
-		if (arr[0].count == 0) {
-			var type = this.setType(type, false);
-			if (value !== undefined) {
-				if (typeof(value) == 'string') {
-					type += " DEFAULT '" + value + "'";
-				} else {
-					type += " DEFAULT " + value;
+ * @param {String} type 类型名
+ * @param {String} value 默认值
+ * @param {Boolean} not_null 是否非空
+ * @param {Boolean} auto 是否自增
+ * @param {String} comment 注释
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {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) {
+			$.log.error("[DB] [addField] 表名、字段名或类型未指定");
+			return 0;
+		}
+		
+		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) {
+				var type = 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}', type);
+				if (comment) {
+					sql += " COMMENT '" + comment + "'";
 				}
-			} else if (type.has('varchar') || type.has('text')) {
-				type = type.replace('NOT NULL', '');
-			} else if (type.has('dateTime')) {
-				type += " DEFAULT '1970-01-01 00:00:00'";
-			} else if (type.has('date')) {
-				type += " DEFAULT '1970-01-01'";
-			} else if (type.has('time')) {
-				type += " DEFAULT '00:00:00'";
-			} else {
-				type += " DEFAULT 0";
+				sql += ";";
+				return await this.exec(sql, timeout);
 			}
-			var sql = "ALTER Table `{0}` ADD `{1}` {2}".replace('{0}', this.table).replace('{1}', field).replace('{2}',
-				type);
-			if (isKey) {
-				sql += ", ADD PRIMARY KEY (`{0}`)".replace('{0}', field);
+		}
+		return 0;
+	} catch (err) {
+		$.log.error(`[DB] [addField] 添加字段失败: ${err.message}`);
+		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
+ */
+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;
+		}
+		
+		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;
 			}
-			return await this.exec(sql);
 		}
+
+		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) {
+		$.log.error(`[DB] [setField] 修改字段失败: ${err.message}`);
+		return 0;
 	}
-	return false;
 };
 
 /**
  * @description 删除字段
+ * @param {String} table 表名
  * @param {String} field 字段名
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {Promise|Number} 删除成功返回1，失败返回0
  */
-DB.prototype.field_del = async function(field) {
-	var arr = await this.fields();
-	if (arr && arr.length > 0 && arr.has({
-			'name': field
-		})) {
-		var fields = ',' + arr.getArr('name').toStr(',') + ',';
-		fields = fields.replace(',' + field + ',', ',').trim(',');
-		await this.exec("drop table `mm_temp`");
-		var sql = "create table `mm_temp` as select {0} from `{1}` where 1 = 1;".replace('{0}', fields).replace('{1}',
-			this.table);
-		var bl = await this.exec(sql);
-		if (bl) {
-			bl = await this.exec("drop table `{0}`".replace('{0}', this.table));
-			if (bl) {
-				bl = await this.exec("alter table `mm_temp` rename to `{0}`;".replace('{0}', this.table));
-				if (bl) {
-					this.error = undefined;
-				}
+DB.prototype.delField = async function(table, field, timeout = 15000) {
+	try {
+		if (!table || !field) {
+			$.log.error("[DB] [delField] 参数不完整");
+			return 0;
+		}
+		
+		var sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
+		sql = sql.replace('{0}', table).replace('{1}', field);
+		return await this.exec(sql, timeout);
+	} catch (err) {
+		$.log.error(`[DB] [delField] 删除字段失败: ${err.message}`);
+		return 0;
+	}
+};
+
+/**
+ * @description 拼接字段信息SQL
+ * @param {Object} fd 字段信息
+ * @return {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';
 			}
-		} else {
+			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
+ */
+DB.prototype.renameField = async function(table, field, new_field, type, timeout = 15000) {
+	try {
+		if (!table || !field || !new_field) {
+			$.log.error("[DB] [renameField] 参数不完整");
+			return 0;
+		}
+		
+		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) {
+		$.log.error(`[DB] [renameField] 重命名字段失败: ${err.message}`);
+		return 0;
+	}
+};
+
+/**
+ * @description 修改字段类型
+ * @param {String} table 表名
+ * @param {String} field 字段名
+ * @param {String} type 字段类型
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {Promise|Number} 操作结果
+ */
+DB.prototype.editField = function(table, field, type, timeout = 15000) {
+	try {
+		if (!table || !field || !type) {
+			$.log.error("[DB] [editField] 参数不完整");
+			return 0;
+		}
+		return this.exec("ALTER TABLE `" + table + "` MODIFY COLUMN `" + field + "` " + type + ";", timeout);
+	} catch (err) {
+		$.log.error(`[DB] [editField] 修改字段类型失败: ${err.message}`);
+		return 0;
+	}
+};
 
+/**
+ * @description 删除数据表
+ * @param {String} table 表名
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @return {Promise|Number} 删除成功返回1，失败返回0
+ */
+DB.prototype.dropTable = function(table, timeout = 15000) {
+	if (!table) {
+		$.log.error("[DB] [dropTable] 表名无效");
+		return 0;
+	}
+	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
+ */
+DB.prototype.renameTable = function(table, new_table, timeout = 15000) {
+	if (!table || !new_table) {
+		$.log.error("[DB] [renameTable] 表名参数不完整");
+		return 0;
+	}
+	return this.exec("ALTER TABLE `" + table + "` RENAME TO `" + new_table + "`;", [], timeout);
+};
+
+/**
+ * @description 清空数据表（保留表结构）
+ * @param {String} table 表名
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @return {Promise|Number} 清空成功返回1，失败返回0
+ */
+DB.prototype.emptyTable = function(table, timeout = 15000) {
+	if (!table) {
+		$.log.error("[DB] [emptyTable] 表名无效");
+		return 0;
+	}
+	return this.exec("DELETE FROM `" + table + "`;", [], timeout);
+};
+
+/**
+ * @description 检查表是否存在
+ * @param {String} table 表名
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @return {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) {
+		$.log.error(`[DB] [hasTable] 检查表是否存在失败: ${err.message}`);
+		return false;
+	}
+};
+
+/**
+ * @description 检查字段是否存在
+ * @param {String} table 表名
+ * @param {String} field 字段名
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @return {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) {
+		$.log.error(`[DB] [hasField] 检查字段是否存在失败: ${err.message}`);
+		return false;
+	}
+};
+
+/**
+ * @description 备份数据表
+ * @param {String} table 原表名
+ * @param {String} backup 备份表名
+ * @param {Number} timeout - 超时时间(毫秒)
+ * @return {Promise|Number} 备份成功返回1，失败返回0
+ */
+DB.prototype.backupTable = function(table, backup, timeout = 60000) {
+	if (!table || !backup) {
+		$.log.error("[DB] [backupTable] 参数不完整");
+		return 0;
+	}
+	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} 创建语句
+ */
+DB.prototype.getCreateTable = async function(table, timeout = 15000) {
+	try {
+		if (!table) {
+			$.log.error("[DB] [getCreateTable] 表名不能为空");
+			return '';
+		}
+		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) {
+		$.log.error(`[DB] [getCreateTable] 获取表结构失败: ${err.message}`);
+		return '';
+	}
+};
+
+/**
+ * @description 获取表数据的SQL插入语句
+ * @param {String} table 表名
+ * @param {Number} batchSize 批量处理大小
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {Promise|String} SQL插入语句
+ */
+DB.prototype.getTableData = async function(table, batchSize = 100, timeout = 60000) {
+	try {
+		if (!table) {
+			$.log.error("[DB] [getTableData] 表名不能为空");
+			return '';
+		}
+		// 获取表数据
+		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) {
+							$.log.error(`[DB] [getTableData] 处理行数据失败: ${rowErr.message}`);
+						}
+					}
+				}
+				sql += '\n';
+		}
+		return sql;
+	} catch (err) {
+		$.log.error(`[DB] [getTableData] 获取表数据失败: ${err.message}`);
+		return '';
+	}
+};
+
+/**
+ * @description 备份表
+ * @param {String} table 表名
+ * @param {String} backup 备份表名
+ * @param {Number} timeout 超时时间(毫秒)
+ * @return {Promise|Number} 操作结果
+ */
+DB.prototype.backup = function(table, backup, timeout = 60000) {
+	try {
+		if (!table || !backup) {
+			$.log.error("[DB] [backup] 参数不完整");
+			return 0;
 		}
-		return bl;
+		return this.backupTable(table, backup, timeout);
+	} catch (err) {
+		$.log.error(`[DB] [backup] 备份表失败: ${err.message}`);
+		return 0;
 	}
-	return false;
 };
 
-exports.DB = DB;
+module.exports = DB;