mm_mysql 2.1.0 → 2.1.1

package/README.md

@@ -1,6 +1,10 @@
 # mm_mysql
 这是超级美眉mysql帮助函数模块，用于便捷操作mysql，使用await方式，可以避免嵌套函数
 
+[![npm version](https://badge.fury.io/js/mm_mysql.svg)](https://www.npmjs.com/package/mm_mysql)
+[![GitHub issues](https://img.shields.io/github/issues/qiuwenwu91/mm_mysql.svg)](https://gitee.com/qiuwenwu91/mm_mysql/issues)
+[![GitHub license](https://img.shields.io/github/license/qiuwenwu91/mm_mysql.svg)](https://github.com/qiuwenwu91/mm_mysql/blob/main/LICENSE)
+
 ## 安装
 
 ```bash
@@ -21,18 +25,16 @@ const mysql = new Mysql({
   database: "your_database"
 });
 
-// 初始化并打开连接
-await mysql.init();
+// 打开连接（不需要调用init()方法）
 await mysql.open();
 
-// 获取数据库管理器
-const db = mysql.db();
+// 获取数据库管理器并设置表名
+const db = mysql.db().new('users', 'id');
 
 // 执行操作...
 
 // 使用完后关闭连接
 await mysql.close();
-await mysql.destroy();
 ```
 
 ## API文档
@@ -72,95 +74,89 @@ const config = {
 - `config` {Object} 配置对象
 - 返回：{Mysql} 实例本身
 
-##### init()
-初始化服务
-- 返回：{Promise} 初始化结果
-
-##### open(reset)
+##### open()
 打开数据库连接
-- `reset` {Boolean} 是否重置连接
-- 返回：{Promise} 连接结果
+- 返回：{Promise<boolean>} 连接结果
 
 ##### close()
 关闭数据库连接
-- 返回：{Promise} 关闭结果
-
-##### destroy()
-销毁服务，释放资源
-- 返回：{Promise} 销毁结果
+- 返回：{Promise<boolean>} 关闭结果
 
-##### run(sql, params)
+##### run(sql, params, timeout)
 执行查询SQL语句
 - `sql` {String} SQL语句
-- `params` {Array} 参数数组
-- 返回：{Promise|Array} 查询结果数组
+- `params` {Array} 参数数组（可选）
+- `timeout` {Number} 超时时间（毫秒，可选）
+- 返回：{Promise<Array>} 查询结果数组
 
-##### exec(sql, params)
+##### exec(sql, params, timeout)
 执行非查询SQL语句（增删改）
 - `sql` {String} SQL语句
-- `params` {Array} 参数数组
-- 返回：{Promise|Number} 影响的行数
+- `params` {Array} 参数数组（可选）
+- `timeout` {Number} 超时时间（毫秒，可选）
+- 返回：{Promise<Object>} 执行结果对象，包含affectedRows和insertId等信息
 
 ##### read(table, where, options)
 读取表数据
 - `table` {String} 表名
 - `where` {Object} 查询条件
 - `options` {Object} 选项配置
-- 返回：{Promise|Array} 查询结果
-
-##### save(file)
-保存数据库结构到SQL文件
-- `file` {Object} 文件对象（需实现hasFile、readText等方法）
-- 返回：{Promise} 保存结果
-
-##### load(file)
-从SQL文件加载数据库结构和数据
-- `file` {Object} 文件对象（需实现hasFile、readText等方法）
-- 返回：{Promise} 加载结果
+- 返回：{Promise<Array>} 查询结果
 
 ##### db()
 获取数据库管理器
 - 返回：{DB} 数据库管理器实例
 
+##### beginTransaction()
+开始事务
+- 返回：{Promise<Object>} 事务连接对象
+
+##### transaction(callback)
+执行事务
+- `callback` {Function} 事务回调函数，接收事务连接作为参数
+- 返回：{Promise<any>} 回调函数的返回结果
+
 ### DB类方法
 
-#### add(table, data)
-添加数据
+#### new(table, key)
+创建数据库表管理器
 - `table` {String} 表名
-- `data` {Object} 数据对象
-- 返回：{Promise|Number} 新增的ID或影响行数
+- `key` {String} 主键名（可选，默认为{table}_id）
+- 返回：{DB} 数据库表管理器实例
 
-#### set(table, where, data)
-修改数据
-- `table` {String} 表名
-- `where` {Object} 条件对象
+#### add(data)
+添加数据
 - `data` {Object} 数据对象
-- 返回：{Promise|Number} 影响行数
+- 返回：{Promise<Number>} 插入的ID
 
-#### get(table, where, options)
-查询数据
-- `table` {String} 表名
-- `where` {Object} 条件对象
-- `options` {Object} 选项（fields, order, group, limit等）
-- 返回：{Promise|Array} 查询结果数组
+#### get(where, options)
+获取数据
+- `where` {Object} 条件对象（可选）
+- `options` {Object} 选项配置（可选）
+- 返回：{Promise<Array>} 查询结果
+
+#### set(data, where)
+更新数据
+- `data` {Object} 数据对象
+- `where` {Object} 条件对象（可选）
+- 返回：{Promise<Number>} 影响行数
 
-#### del(table, where)
+#### del(where)
 删除数据
-- `table` {String} 表名
-- `where` {Object} 条件对象
-- 返回：{Promise|Number} 影响行数
+- `where` {Object} 条件对象（可选）
+- 返回：{Promise<Number>} 影响行数
 
 #### exec(sql, params)
 执行SQL语句
 - `sql` {String} SQL语句
 - `params` {Array} 参数数组
-- 返回：{Promise|Object} 执行结果
+- 返回：{Promise<Object>} 执行结果
 
 #### run(sql, params)
 执行查询SQL语句
 - `sql` {String} SQL语句
 - `params` {Array} 参数数组
-- 返回：{Promise|Array} 查询结果
+- 返回：{Promise<Array>} 查询结果
 
 ### 事务操作
 
@@ -182,7 +178,7 @@ const config = {
 const { Mysql } = require('mm_mysql');
 
 async function main() {
-  const db = new Mysql({
+  const mysql = new Mysql({
     host: "localhost",
     user: "root",
     password: "123456",
@@ -190,20 +186,21 @@ async function main() {
     debug: true
   });
   
-  await db.init();
-  await db.open();
+  await mysql.open();
   
   // 执行查询
-  const users = await db.run('SELECT * FROM users WHERE age > ?', [20]);
+  const users = await mysql.run('SELECT * FROM users WHERE age > ?', [20]);
   console.log(users);
   
   // 添加数据
-  const insertId = await db.exec('INSERT INTO users (name, age) VALUES (?, ?)', ['张三', 25]);
+  const result = await mysql.exec('INSERT INTO users (name, age) VALUES (?, ?)', ['张三', 25]);
+  console.log('Inserted ID:', result.insertId);
+  console.log('Affected rows:', result.affectedRows);
   
   // 使用db管理器
-  const dbManager = db.db();
-  dbManager.table = 'users';
-  const result = await dbManager.add({name: '李四', age: 26});
+  const db = mysql.db().new('users', 'id');
+  const newId = await db.add({name: '李四', age: 26});
+  console.log('New user ID:', newId);
   
   await db.close();
   await db.destroy();
@@ -212,47 +209,92 @@ async function main() {
 main().catch(console.error);
 ```
 
-#### 数据库结构导入导出
+#### 使用DB类的完整示例
+
+```javascript
+const { Mysql } = require('mm_mysql');
+
+async function dbClassExample() {
+  const mysql = new Mysql({
+    host: "localhost",
+    user: "root",
+    password: "123456",
+    database: "test"
+  });
+  
+  await mysql.open();
+  
+  try {
+    // 创建DB实例
+    const db = mysql.db().new('users', 'id');
+    
+    // 添加数据
+    const newId = await db.add({name: '王五', age: 30, email: 'wangwu@example.com'});
+    console.log('New user ID:', newId);
+    
+    // 获取数据
+    const user = await db.get({id: newId});
+    console.log('User:', user);
+    
+    // 更新数据
+    const updatedRows = await db.set({age: 31, email: 'wangwu_updated@example.com'}, {id: newId});
+    console.log('Updated rows:', updatedRows);
+    
+    // 删除数据
+    const deletedRows = await db.del({id: newId});
+    console.log('Deleted rows:', deletedRows);
+    
+  } finally {
+    await mysql.close();
+  }
+}
+
+dbClassExample().catch(console.error);
+```
+
+#### 事务操作示例
 
 ```javascript
 const { Mysql } = require('mm_mysql');
 
-async function exportAndImport() {
-  const db = new Mysql({
+async function transactionExample() {
+  const mysql = new Mysql({
     host: "localhost",
     user: "root",
     password: "123456",
     database: "test"
   });
   
-  await db.init();
-  await db.open();
+  await mysql.open();
   
   try {
-    // 创建文件对象（需实现相应接口）
-    const file = { /* 文件对象实现 */ };
+    // 使用transaction方法执行事务
+    const result = await mysql.transaction(async (conn) => {
+      // 在事务中执行多个操作
+      const insertResult1 = await conn.exec('INSERT INTO users (name, age) VALUES (?, ?)', ['赵六', 35]);
+      const insertResult2 = await conn.exec('INSERT INTO users (name, age) VALUES (?, ?)', ['孙七', 40]);
+      
+      // 如果都成功，返回结果
+      return { user1: insertResult1.insertId, user2: insertResult2.insertId };
+    });
     
-    // 导出数据库结构到文件
-    await db.save(file);
-    console.log('数据库结构已导出');
+    console.log('Transaction succeeded:', result);
     
-    // 从文件导入数据库结构
-    await db.load(file);
-    console.log('数据库结构已导入');
+  } catch (error) {
+    console.error('Transaction failed:', error);
   } finally {
-    await db.close();
-    await db.destroy();
+    await mysql.close();
   }
 }
 
-exportAndImport().catch(console.error);
+transactionExample().catch(console.error);
 ```
 
 ## 注意事项
 
 1. 使用前请确保已正确配置数据库连接信息
 2. 建议使用try-catch处理可能出现的错误
-3. 在程序结束时调用close()和destroy()关闭数据库连接并释放资源
+3. 在程序结束时调用close()关闭数据库连接
 4. 使用事务时，记得正确处理事务的提交和回滚
 5. 查询条件支持多种格式：
    - `_min`: 大于等于

package/db.js

@@ -103,16 +103,13 @@ DB.prototype.run = async function(sql, params = [], timeout = 30000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @returns {Promise<Object>} 执行结果
  */
-DB.prototype.exec = async function(sql, timeout = 30000) {
+DB.prototype.exec = async function(sql, timeout = 60000) {
 	if (!this._mysql) {
 		throw new Error('MySQL实例未初始化');
 	}
 	try {
-		// 使用Promise.race实现超时控制
-		return await Promise.race([
-			this._mysql.exec(sql),
-			this._createTimeoutPromise(timeout, `命令执行超时: ${sql.substring(0, 100)}...`)
-		]);
+		// 增加超时时间到60秒，避免连接超时问题
+		return await this._mysql.exec(sql, []);
 	} catch (error) {
 		$.log.error(`[DB] [exec] 命令执行失败`, {
 			error: error.message,
@@ -127,16 +124,13 @@ DB.prototype.exec = async function(sql, timeout = 30000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @returns {Promise<Object>} 数据库连接对象
  */
-DB.prototype.getConn = async function(timeout = 30000) {
+DB.prototype.getConn = async function(timeout = 60000) {
 	if (!this._mysql) {
 		throw new Error('MySQL实例未初始化');
 	}
 	try {
-		// 使用Promise.race实现超时控制
-		return await Promise.race([
-			this._mysql.getConn(),
-			this._createTimeoutPromise(timeout, '获取数据库连接超时')
-		]);
+		// 增加超时时间到60秒，直接调用mysql实例的getConn方法
+		return await this._mysql.getConn();
 	} catch (error) {
 		$.log.error(`[DB] [getConn] 获取连接失败`, {
 			error: error.message
@@ -377,11 +371,11 @@ DB.prototype.renameTable = function(table, new_table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 添加成功返回1，失败返回0
  */
-DB.prototype.field_add = 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] [field_add] 表名、字段名或类型未指定");
+			$.log.error("[DB] [addField] 表名、字段名或类型未指定");
 			return 0;
 		}
 		
@@ -417,7 +411,7 @@ DB.prototype.field_add = async function(field, type, value = '', not_null = true
 		const result = await this.exec(sql, timeout);
 		return result && result.affectedRows !== undefined ? 1 : 0;
 	} catch (err) {
-		$.log.error(`[DB] [field_add] 添加字段失败: ${err.message}`);
+		$.log.error(`[DB] [addField] 添加字段失败: ${err.message}`);
 		return 0;
 	}
 };
@@ -434,10 +428,10 @@ DB.prototype.field_add = async function(field, type, value = '', not_null = true
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 修改成功返回1，失败返回0
  */
-DB.prototype.field_set = 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] [field_set] 参数不完整或表名未设置");
+			$.log.error("[DB] [setField] 参数不完整或表名未设置");
 			return 0;
 		}
 		const targetName = new_name || field;
@@ -463,7 +457,7 @@ DB.prototype.field_set = async function(field, type, value = '', not_null = true
 		const result = await this.exec(sql, timeout);
 		return result && result.affectedRows !== undefined ? 1 : 0;
 	} catch (err) {
-		$.log.error(`[DB] [field_set] 修改字段失败: ${err.message}`);
+		$.log.error(`[DB] [setField] 修改字段失败: ${err.message}`);
 		return 0;
 	}
 };
@@ -476,9 +470,9 @@ DB.prototype.field_set = async function(field, type, value = '', not_null = true
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.field_edit = function(table, field, type, timeout = 15000) {
+DB.prototype.editField = function(table, field, type, timeout = 15000) {
 	if (!table || !field || !type) {
-		$.log.error("[DB] [field_edit] 参数不完整");
+		$.log.error("[DB] [editField] 参数不完整");
 		return 0;
 	}
 	return this.exec("ALTER TABLE \`" + table + "\` MODIFY COLUMN \`" + field + "\` " + type + ";", timeout);
@@ -491,9 +485,9 @@ DB.prototype.field_edit = function(table, field, type, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.field_del = function(table, field, timeout = 15000) {
+DB.prototype.delField = function(table, field, timeout = 15000) {
 	if (!table || !field) {
-		$.log.error("[DB] [field_del] 参数不完整");
+		$.log.error("[DB] [delField] 参数不完整");
 		return 0;
 	}
 	return this.exec("ALTER TABLE \`" + table + "\` DROP COLUMN \`" + field + "\`;", timeout);
@@ -508,9 +502,9 @@ DB.prototype.field_del = function(table, field, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.field_rename = 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] [field_rename] 参数不完整");
+		$.log.error("[DB] [renameField] 参数不完整");
 		return 0;
 	}
 	return this.exec("ALTER TABLE \`" + table + "\` CHANGE \`" + field + "\` \`" + new_field + "\` " + type + ";", timeout);

package/index.js

@@ -1,6 +1,7 @@
 const mysql = require('mysql2/promise');
 const { BaseService } = require('mm_base_service');
 const { DB } = require('./db');
+
 /**
  * 优化版MySQL数据库操作类
  * 保持必要功能，简化过度封装，直接使用mysql2模块
@@ -372,7 +373,7 @@ if (!$.pool.mysql) {
  * @param {Object} config 配置参数
  * @return {Object} 返回一个Mysql类实例
  */
-function mysql_admin(scope, config) {
+function mysqlAdmin(scope, config) {
 	if (!scope) {
 		scope = 'sys';
 	}
@@ -387,4 +388,4 @@ function mysql_admin(scope, config) {
 /**
  * @module 导出Mysql管理器
  */
-exports.mysql_admin = mysql_admin;
+exports.mysqlAdmin = mysqlAdmin;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mm_mysql",
-	"version": "2.1.0",
+	"version": "2.1.1",
 	"description": "这是超级美眉mysql帮助函数模块，用于便捷操作mysql，使用await方式，可以避免嵌套函数",
 	"main": "index.js",
 	"dependencies": {

package/sql.js

@@ -146,11 +146,10 @@ class Sql {
 /**
  * 清理存储的数据
  */
-Sql.prototype.clear = async function () {
-	this.run = run;
-	this.exec = exec;
+Sql.prototype.clear = function () {
+	// 不重置run和exec方法引用，保留构造函数中设置的函数
 	this.sql = "";
-	this.error;
+	this.error = null;
 	this.results = [];
 	this.table = "";
 	this.page = 0;
@@ -788,13 +787,13 @@ Sql.prototype.addOrSetSql = async function (where, set, like) {
  * @param {Number} timeout 超时时间（毫秒），默认30000ms
  * @return {Promise|Array} 查询结果
  */
-Sql.prototype.get = async function (query, sort, view, like, timeout = 30000) {
+Sql.prototype.get = async function (query, sort, view, like, timeout = 60000) {
 	if (!this.table) {
 		throw new Error('表名未设置');
 	}
 
 	try {
-		// 添加超时控制的Promise
+		// 添加超时控制的Promise，增加默认超时时间
 		const timeoutPromise = new Promise((_, reject) => {
 			setTimeout(() => reject(new Error('查询操作超时')), timeout);
 		});
@@ -870,7 +869,7 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 30000) {
  * @param {Number} timeout 超时时间（毫秒），默认30000ms
  * @return {Promise|Object|null} 查询结果
  */
-Sql.prototype.getObj = async function (query, sort, view, like, timeout = 30000) {
+Sql.prototype.getObj = async function (query, sort, view, like, timeout = 60000) {
 	try {
 		// 保存当前分页设置
 		const oldPage = this.page;
@@ -910,7 +909,7 @@ Sql.prototype.getObj = async function (query, sort, view, like, timeout = 30000)
  * @param {Number} timeout 超时时间（毫秒），默认30000ms
  * @return {Promise|Number} 记录数
  */
-Sql.prototype.count = async function (query, like, timeout = 30000) {
+Sql.prototype.count = async function (query, like, timeout = 60000) {
 	if (!this.table) {
 		throw new Error('表名未设置');
 	}
@@ -1240,7 +1239,7 @@ Sql.prototype.setList = async function (list, like = false, batchSize = 100, tim
  * @param {Object} sqlDt sql模板集合
  * @return {Boolean} 有则返回true，没有则返回false
  */
-Sql.prototype.has_param = function (paramDt, sqlDt) {
+Sql.prototype.hasParam = function (paramDt, sqlDt) {
 	if (!paramDt || !sqlDt) {
 		return false;
 	}
@@ -1260,7 +1259,7 @@ Sql.prototype.has_param = function (paramDt, sqlDt) {
  * @param {Object} sqlDt sql模板集合
  * @return {String|undefined} 没有模板则返回名称，都有则返回undefined
  */
-Sql.prototype.not_param = function (paramDt, sqlDt) {
+Sql.prototype.notParam = function (paramDt, sqlDt) {
 	if (!paramDt || !sqlDt) {
 		return undefined;
 	}
@@ -1279,7 +1278,7 @@ Sql.prototype.not_param = function (paramDt, sqlDt) {
  * @param {Object} sqlDt sql模板集合
  * @return {Object} 返回过滤后的参数集合
  */
-Sql.prototype.filter_param = function (paramDt, sqlDt) {
+Sql.prototype.filterParam = function (paramDt, sqlDt) {
 	const dt = {};
 	if (!paramDt || !sqlDt) {
 		return dt;
@@ -1299,7 +1298,7 @@ Sql.prototype.filter_param = function (paramDt, sqlDt) {
  * @param {Object} sqlDt 模板集合
  * @return {String} 返回拼接的查询参数
  */
-Sql.prototype.tpl_query = function (paramDt, sqlDt) {
+Sql.prototype.tplQuery = function (paramDt, sqlDt) {
 	let sql = "";
 	if (!paramDt) {
 		return sql;
@@ -1400,7 +1399,7 @@ Sql.prototype.tpl_query = function (paramDt, sqlDt) {
  * @param {Object} sqlDt 模板集合
  * @return {String} 返回拼接的查询参数
  */
-Sql.prototype.tpl_body = function (paramDt, sqlDt) {
+Sql.prototype.tplBody = function (paramDt, sqlDt) {
 	if (!paramDt) {
 		return "";
 	}

package/test.js

@@ -48,7 +48,7 @@ TestMysql.prototype._init = async function() {
         await this._mysql.open();
         
         // 创建测试数据库
-        await this._create_test_database();
+        await this._createTestDatabase();
         
         // 重新连接指定数据库
         await this._mysql.close();
@@ -57,7 +57,7 @@ TestMysql.prototype._init = async function() {
         await this._mysql.open();
         
         // 创建测试表
-        await this._create_test_table();
+        await this._createTestTable();
         
         console.log('测试环境初始化完成');
         return true;
@@ -71,7 +71,7 @@ TestMysql.prototype._init = async function() {
  * 创建测试数据库
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype._create_test_database = async function() {
+TestMysql.prototype._createTestDatabase = async function() {
     try {
         const create_db_sql = `CREATE DATABASE IF NOT EXISTS test_db`;
         await this._mysql.exec(create_db_sql);
@@ -87,7 +87,7 @@ TestMysql.prototype._create_test_database = async function() {
  * 创建测试表
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype._create_test_table = async function() {
+TestMysql.prototype._createTestTable = async function() {
     try {
         const sql = `
             CREATE TABLE IF NOT EXISTS ${this._test_table_name} (
@@ -131,7 +131,7 @@ TestMysql.prototype._cleanup = async function() {
  * @param {Boolean} success - 是否成功
  * @param {String} message - 测试信息
  */
-TestMysql.prototype._record_result = function(test_name, success, message) {
+TestMysql.prototype._recordResult = function(test_name, success, message) {
     this._test_results.push({
         test_name,
         success,
@@ -147,7 +147,7 @@ TestMysql.prototype._record_result = function(test_name, success, message) {
  * 测试连接功能
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_connection = async function() {
+TestMysql.prototype.testConnection = async function() {
     try {
         // 测试获取连接
         const conn = await this._mysql.getConn();
@@ -166,10 +166,10 @@ TestMysql.prototype.test_connection = async function() {
             conn.release();
         }
         
-        this._record_result('连接测试', true, '数据库连接正常');
+        this._recordResult('连接测试', true, '数据库连接正常');
         return true;
     } catch (error) {
-        this._record_result('连接测试', false, error.message);
+        this._recordResult('连接测试', false, error.message);
         return false;
     }
 };
@@ -178,7 +178,7 @@ TestMysql.prototype.test_connection = async function() {
  * 测试插入功能
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_insert = async function() {
+TestMysql.prototype.testInsert = async function() {
     try {
         const test_data = {
             name: '测试用户',
@@ -193,10 +193,10 @@ TestMysql.prototype.test_insert = async function() {
             throw new Error('插入数据失败');
         }
         
-        this._record_result('插入测试', true, `插入成功，ID: ${result.insertId}`);
+        this._recordResult('插入测试', true, `插入成功，ID: ${result.insertId}`);
         return true;
     } catch (error) {
-        this._record_result('插入测试', false, error.message);
+        this._recordResult('插入测试', false, error.message);
         return false;
     }
 };
@@ -205,7 +205,7 @@ TestMysql.prototype.test_insert = async function() {
  * 测试查询功能
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_query = async function() {
+TestMysql.prototype.testQuery = async function() {
     try {
         // 查询所有数据
         const sql = `SELECT * FROM ${this._test_table_name}`;
@@ -215,10 +215,10 @@ TestMysql.prototype.test_query = async function() {
             throw new Error('查询结果格式异常');
         }
         
-        this._record_result('查询测试', true, `查询到 ${results.length} 条记录`);
+        this._recordResult('查询测试', true, `查询到 ${results.length} 条记录`);
         return true;
     } catch (error) {
-        this._record_result('查询测试', false, error.message);
+        this._recordResult('查询测试', false, error.message);
         return false;
     }
 };
@@ -227,7 +227,7 @@ TestMysql.prototype.test_query = async function() {
  * 测试条件查询
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_conditional_query = async function() {
+TestMysql.prototype.testConditionalQuery = async function() {
     try {
         const sql = `SELECT * FROM ${this._test_table_name} WHERE name = ?`;
         const results = await this._mysql.run(sql, ['测试用户']);
@@ -236,10 +236,10 @@ TestMysql.prototype.test_conditional_query = async function() {
             throw new Error('条件查询结果格式异常');
         }
         
-        this._record_result('条件查询测试', true, `查询到 ${results.length} 条匹配记录`);
+        this._recordResult('条件查询测试', true, `查询到 ${results.length} 条匹配记录`);
         return true;
     } catch (error) {
-        this._record_result('条件查询测试', false, error.message);
+        this._recordResult('条件查询测试', false, error.message);
         return false;
     }
 };
@@ -248,7 +248,7 @@ TestMysql.prototype.test_conditional_query = async function() {
  * 测试更新功能
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_update = async function() {
+TestMysql.prototype.testUpdate = async function() {
     try {
         const sql = `UPDATE ${this._test_table_name} SET age = ? WHERE name = ?`;
         const result = await this._mysql.exec(sql, [30, '测试用户']);
@@ -257,10 +257,10 @@ TestMysql.prototype.test_update = async function() {
             throw new Error('更新数据失败');
         }
         
-        this._record_result('更新测试', true, `更新了 ${result.affectedRows} 条记录`);
+        this._recordResult('更新测试', true, `更新了 ${result.affectedRows} 条记录`);
         return true;
     } catch (error) {
-        this._record_result('更新测试', false, error.message);
+        this._recordResult('更新测试', false, error.message);
         return false;
     }
 };
@@ -269,7 +269,7 @@ TestMysql.prototype.test_update = async function() {
  * 测试删除功能
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_delete = async function() {
+TestMysql.prototype.testDelete = async function() {
     try {
         const sql = `DELETE FROM ${this._test_table_name} WHERE name = ?`;
         const result = await this._mysql.exec(sql, ['测试用户']);
@@ -278,10 +278,109 @@ TestMysql.prototype.test_delete = async function() {
             throw new Error('删除数据失败');
         }
         
-        this._record_result('删除测试', true, `删除了 ${result.affectedRows} 条记录`);
+        this._recordResult('删除测试', true, `删除了 ${result.affectedRows} 条记录`);
         return true;
     } catch (error) {
-        this._record_result('删除测试', false, error.message);
+        this._recordResult('删除测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试DB类功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.testDbClass = async function() {
+    try {
+        // 获取DB实例
+        const db = this._mysql.db().new(this._test_table_name, 'id');
+        
+        if (!db) {
+            throw new Error('获取DB实例失败');
+        }
+        
+        // 测试DB类的add方法
+        const add_result = await db.add({
+            name: 'DB测试用户',
+            email: 'db_test@example.com',
+            age: 30
+        });
+        
+        if (!add_result || add_result.insertId <= 0) {
+            throw new Error('DB.add()方法测试失败');
+        }
+        
+        // 测试DB类的get方法
+        const get_result = await db.get({ name: 'DB测试用户' });
+        
+        if (!get_result || get_result.length !== 1) {
+            throw new Error('DB.get()方法测试失败');
+        }
+        
+        // 测试DB类的set方法
+        const set_result = await db.set({ id: add_result.insertId }, { age: 31 });
+        
+        if (!set_result || set_result.affectedRows !== 1) {
+            throw new Error('DB.set()方法测试失败');
+        }
+        
+        // 测试DB类的del方法
+        const del_result = await db.del({ id: add_result.insertId });
+        
+        if (!del_result || del_result.affectedRows !== 1) {
+            throw new Error('DB.del()方法测试失败');
+        }
+        
+        this._recordResult('DB类测试', true, 'DB类方法测试通过');
+        return true;
+    } catch (error) {
+        this._recordResult('DB类测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试Sql类功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.testSqlClass = async function() {
+    try {
+        // 获取DB实例（Sql类的子类）
+        const db = this._mysql.db().new(this._test_table_name, 'id');
+        
+        if (!db) {
+            throw new Error('获取Sql实例失败');
+        }
+        
+        // 测试Sql类的addSql方法
+        const add_sql = db.toAddSql({
+            name: 'Sql测试用户',
+            email: 'sql_test@example.com',
+            age: 28
+        });
+        
+        if (!add_sql || typeof add_sql !== 'string') {
+            throw new Error('Sql.toAddSql()方法测试失败');
+        }
+        
+        // 测试Sql类的getSql方法
+        const get_sql = db.toGetSql({ name: 'Sql测试用户' });
+        
+        if (!get_sql || typeof get_sql !== 'string') {
+            throw new Error('Sql.toGetSql()方法测试失败');
+        }
+        
+        // 测试Sql类的escape方法
+        const escaped_value = db.escape("test' OR '1'='1");
+        
+        if (!escaped_value || escaped_value === "test' OR '1'='1") {
+            throw new Error('Sql.escape()方法测试失败');
+        }
+        
+        this._recordResult('Sql类测试', true, 'Sql类方法测试通过');
+        return true;
+    } catch (error) {
+        this._recordResult('Sql类测试', false, error.message);
         return false;
     }
 };
@@ -290,7 +389,7 @@ TestMysql.prototype.test_delete = async function() {
  * 测试事务功能
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_transaction = async function() {
+TestMysql.prototype.testTransaction = async function() {
     try {
         const result = await this._mysql.transaction(async (tx) => {
             // 在事务中插入数据 - 使用Mysql类的exec方法
@@ -304,10 +403,10 @@ TestMysql.prototype.test_transaction = async function() {
             return results;
         });
         
-        this._record_result('事务测试', true, '事务执行成功');
+        this._recordResult('事务测试', true, '事务执行成功');
         return true;
     } catch (error) {
-        this._record_result('事务测试', false, error.message);
+        this._recordResult('事务测试', false, error.message);
         return false;
     }
 };
@@ -316,10 +415,10 @@ TestMysql.prototype.test_transaction = async function() {
  * 测试连接池功能
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_connection_pool = async function() {
+TestMysql.prototype.testConnectionPool = async function() {
     try {
         if (!this._mysql._pool) {
-            this._record_result('连接池测试', true, '连接池未启用（单连接模式）');
+            this._recordResult('连接池测试', true, '连接池未启用（单连接模式）');
             return true;
         }
         
@@ -338,10 +437,10 @@ TestMysql.prototype.test_connection_pool = async function() {
             }
         });
         
-        this._record_result('连接池测试', true, `并发获取 ${connections.length} 个连接成功`);
+        this._recordResult('连接池测试', true, `并发获取 ${connections.length} 个连接成功`);
         return true;
     } catch (error) {
-        this._record_result('连接池测试', false, error.message);
+        this._recordResult('连接池测试', false, error.message);
         return false;
     }
 };
@@ -350,20 +449,20 @@ TestMysql.prototype.test_connection_pool = async function() {
  * 测试错误处理
  * @returns {Promise<boolean>}
  */
-TestMysql.prototype.test_error_handling = async function() {
+TestMysql.prototype.testErrorHandling = async function() {
     try {
         // 测试无效SQL
         const invalid_sql = 'SELECT * FROM non_existent_table';
         await this._mysql.run(invalid_sql);
         
-        this._record_result('错误处理测试', false, '应该抛出错误但未抛出');
+        this._recordResult('错误处理测试', false, '应该抛出错误但未抛出');
         return false;
     } catch (error) {
         if (error.code && error.code.startsWith('ER_')) {
-            this._record_result('错误处理测试', true, `正确捕获SQL错误: ${error.message}`);
+            this._recordResult('错误处理测试', true, `正确捕获SQL错误: ${error.message}`);
             return true;
         } else {
-            this._record_result('错误处理测试', false, `捕获到非预期错误: ${error.message}`);
+            this._recordResult('错误处理测试', false, `捕获到非预期错误: ${error.message}`);
             return false;
         }
     }
@@ -373,27 +472,29 @@ TestMysql.prototype.test_error_handling = async function() {
  * 运行所有测试
  * @returns {Promise<Object>}
  */
-TestMysql.prototype.run_all_tests = async function() {
+TestMysql.prototype.runAllTests = async function() {
     console.log('\n=== 开始运行MySQL功能测试 ===\n');
     
     // 初始化测试环境
     const init_success = await this._init();
     if (!init_success) {
         console.log('测试环境初始化失败，跳过所有测试');
-        return this._get_test_summary();
+        return this._getTestSummary();
     }
     
     // 定义测试用例
     const test_cases = [
-        { name: '连接测试', method: 'test_connection' },
-        { name: '插入测试', method: 'test_insert' },
-        { name: '查询测试', method: 'test_query' },
-        { name: '条件查询测试', method: 'test_conditional_query' },
-        { name: '更新测试', method: 'test_update' },
-        { name: '删除测试', method: 'test_delete' },
-        { name: '事务测试', method: 'test_transaction' },
-        { name: '连接池测试', method: 'test_connection_pool' },
-        { name: '错误处理测试', method: 'test_error_handling' }
+        { name: '连接测试', method: 'testConnection' },
+        { name: '插入测试', method: 'testInsert' },
+        { name: '查询测试', method: 'testQuery' },
+        { name: '条件查询测试', method: 'testConditionalQuery' },
+        { name: '更新测试', method: 'testUpdate' },
+        { name: '删除测试', method: 'testDelete' },
+        { name: 'DB类测试', method: 'testDbClass' },
+        { name: 'Sql类测试', method: 'testSqlClass' },
+        { name: '事务测试', method: 'testTransaction' },
+        { name: '连接池测试', method: 'testConnectionPool' },
+        { name: '错误处理测试', method: 'testErrorHandling' }
     ];
     
     // 顺序执行测试用例
@@ -401,7 +502,7 @@ TestMysql.prototype.run_all_tests = async function() {
         try {
             await this[test_case.method]();
         } catch (error) {
-            this._record_result(test_case.name, false, `测试执行异常: ${error.message}`);
+            this._recordResult(test_case.name, false, `测试执行异常: ${error.message}`);
         }
         
         // 添加短暂延迟，避免数据库压力
@@ -417,14 +518,14 @@ TestMysql.prototype.run_all_tests = async function() {
     }
     
     console.log('\n=== 测试完成 ===\n');
-    return this._get_test_summary();
+    return this._getTestSummary();
 };
 
 /**
  * 获取测试摘要
  * @returns {Object}
  */
-TestMysql.prototype._get_test_summary = function() {
+TestMysql.prototype._getTestSummary = function() {
     const total = this._test_results.length;
     const passed = this._test_results.filter(r => r.success).length;
     const failed = total - passed;
@@ -466,7 +567,7 @@ TestMysql.prototype._sleep = function(ms) {
  */
 TestMysql.prototype.main = async function() {
     try {
-        const summary = await this.run_all_tests();
+        const summary = await this.runAllTests();
         
         if (summary.failed > 0) {
             console.log('\n❌ 部分测试失败，请检查数据库配置和连接');