mm_mysql 2.2.4 → 2.2.6

package/test.js

@@ -6,104 +6,101 @@
 
 // 引入依赖
 const { Mysql } = require('./index.js');
-const { Sql } = require('../mm_sql/index.js');
 
 /**
  * 测试类
  * @class TestMysql
  */
 class TestMysql {
-    /**
-     * 构造函数
-     * @param {Object} config - 数据库配置
-     */
-    constructor(config) {
-        this.config = Object.assign({
-            host: '127.0.0.1',
-            port: 3306,
-            user: 'root',
-            password: 'Asd159357',
-            database: '', // 先不指定数据库，连接成功后再创建
-            debug: true,
-            connection_limit: 5
-        }, config || {});
-        
-        this._mysql = null;
-        this._test_results = [];
-        this._test_table_name = 'test_users';
-    }
+  /**
+   * 构造函数
+   * @param {object} config - 数据库配置
+   */
+  constructor(config) {
+    this.config = {host: '127.0.0.1',
+      port: 3306,
+      user: 'root',
+      password: 'Asd159357',
+      database: '', // 先不指定数据库，连接成功后再创建
+      debug: true,
+      connection_limit: 5, ...config || {}};
+        
+    this._mysql = null;
+    this._test_results = [];
+    this._test_table_name = 'test_users';
+  }
 }
 
 /**
  * 初始化测试环境（优化版）
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 初始化是否成功
  */
 TestMysql.prototype._init = async function() {
-    try {
-        console.log('=== 初始化测试环境（优化版） ===');
+  try {
+    console.log('=== 初始化测试环境（优化版） ===');
         
-        // 直接使用指定数据库，避免重复连接
-        if (!this.config.database) {
-            this.config.database = 'test_db';
-        }
+    // 直接使用指定数据库，避免重复连接
+    if (!this.config.database) {
+      this.config.database = 'test_db';
+    }
         
-        // 创建Mysql实例
-        this._mysql = new Mysql(this.config);
+    // 创建Mysql实例
+    this._mysql = new Mysql(this.config);
         
-        // 连接数据库
-        await this._mysql.open();
+    // 连接数据库
+    await this._mysql.open();
         
-        // 创建测试数据库（如果不存在）
-        await this._createTestDatabase();
+    // 创建测试数据库（如果不存在）
+    await this._createTestDatabase();
         
-        // 创建测试表
-        await this._createTestTable();
+    // 创建测试表
+    await this._createTestTable();
         
-        console.log('测试环境初始化完成');
-        return true;
-    } catch (error) {
-        console.error('初始化测试环境失败:', error.message);
-        return false;
-    }
+    console.log('测试环境初始化完成');
+    return true;
+  } catch (error) {
+    console.error('初始化测试环境失败:', error.message);
+    return false;
+  }
 };
 
 /**
  * 创建测试数据库（优化版）
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 数据库创建是否成功
  */
 TestMysql.prototype._createTestDatabase = async function() {
-    try {
-        // 检查数据库是否已存在，避免重复创建
-        const check_db_sql = `SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?`;
-        const existing_dbs = await this._mysql.run(check_db_sql, [this.config.database]);
-        
-        if (existing_dbs.length === 0) {
-            const create_db_sql = `CREATE DATABASE ${this.config.database}`;
-            await this._mysql.exec(create_db_sql);
-            console.log('测试数据库创建成功');
-        } else {
-            console.log('测试数据库已存在，跳过创建');
-        }
-        
-        return true;
-    } catch (error) {
-        console.error('创建测试数据库失败:', error.message);
-        return false;
+  try {
+    // 检查数据库是否已存在，避免重复创建
+    const check_db_sql = `SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?`;
+    const existing_dbs = await this._mysql.run(check_db_sql, [this.config.database]);
+        
+    if (existing_dbs.length === 0) {
+      const create_db_sql = `CREATE DATABASE ${this.config.database}`;
+      await this._mysql.exec(create_db_sql);
+      console.log('测试数据库创建成功');
+    } else {
+      console.log('测试数据库已存在，跳过创建');
     }
+        
+    return true;
+  } catch (error) {
+    console.error('创建测试数据库失败:', error.message);
+    return false;
+  }
 };
 
 /**
  * 创建测试表（优化版）
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 测试表创建是否成功
  */
 TestMysql.prototype._createTestTable = async function() {
-    try {
-        // 检查表是否已存在
-        const check_table_sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`;
-        const existing_tables = await this._mysql.run(check_table_sql, [this.config.database, 'test_users']);
+  try {
+    // 检查表是否已存在
+    const check_table_sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`;
+    const existing_tables = await this._mysql.run(check_table_sql, [this.config.database, 'test_users']);
         
-        if (existing_tables.length === 0) {
-            const sql = `
+    if (existing_tables.length === 0) {
+      const sql = `
                 CREATE TABLE ${this._test_table_name} (
                     id INT AUTO_INCREMENT PRIMARY KEY,
                     name VARCHAR(100) NOT NULL,
@@ -113,562 +110,561 @@ TestMysql.prototype._createTestTable = async function() {
                     updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
                 )
             `;
-            await this._mysql.exec(sql);
-            console.log('测试表创建成功');
-        } else {
-            console.log('测试表已存在，跳过创建');
-        }
-        
-        return true;
-    } catch (error) {
-        console.error('创建测试表失败:', error.message);
-        return false;
+      await this._mysql.exec(sql);
+      console.log('测试表创建成功');
+    } else {
+      console.log('测试表已存在，跳过创建');
     }
+        
+    return true;
+  } catch (error) {
+    console.error('创建测试表失败:', error.message);
+    return false;
+  }
 };
 
 /**
  * 预加载测试数据
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 数据预加载是否成功
  */
 TestMysql.prototype._preloadTestData = async function() {
-    try {
-        console.log('=== 预加载测试数据 ===');
-        
-        // 清空现有数据
-        await this._mysql.exec('TRUNCATE TABLE test_users');
-        
-        // 批量插入测试数据 - 使用多个VALUES子句
-        const insert_sql = `INSERT INTO test_users (name, age, email) VALUES (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?)`;
-        const test_data = [
-            '张三', 25, 'zhangsan@example.com',
-            '李四', 30, 'lisi@example.com',
-            '王五', 28, 'wangwu@example.com',
-            '赵六', 35, 'zhaoliu@example.com',
-            '钱七', 22, 'qianqi@example.com'
-        ];
-        
-        await this._mysql.exec(insert_sql, test_data);
-        console.log('测试数据预加载完成');
-        return true;
-    } catch (error) {
-        console.error('预加载测试数据失败:', error.message);
-        return false;
-    }
+  try {
+    console.log('=== 预加载测试数据 ===');
+        
+    // 清空现有数据
+    await this._mysql.exec('TRUNCATE TABLE test_users');
+        
+    // 批量插入测试数据 - 使用多个VALUES子句
+    const insert_sql = `INSERT INTO test_users (name, age, email) VALUES (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?)`;
+    const data = [
+      '张三', 25, 'zhangsan@example.com',
+      '李四', 30, 'lisi@example.com',
+      '王五', 28, 'wangwu@example.com',
+      '赵六', 35, 'zhaoliu@example.com',
+      '钱七', 22, 'qianqi@example.com'
+    ];
+        
+    await this._mysql.exec(insert_sql, data);
+    console.log('测试数据预加载完成');
+    return true;
+  } catch (error) {
+    console.error('预加载测试数据失败:', error.message);
+    return false;
+  }
 };
 
 /**
  * 清理测试数据
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 清理是否成功
  */
 TestMysql.prototype._cleanup = async function() {
-    try {
-        const sql = `DROP TABLE IF EXISTS ${this._test_table_name}`;
-        await this._mysql.exec(sql);
-        console.log('测试数据清理完成');
-        return true;
-    } catch (error) {
-        console.error('清理测试数据失败:', error.message);
-        return false;
-    }
+  try {
+    const sql = `DROP TABLE IF EXISTS ${this._test_table_name}`;
+    await this._mysql.exec(sql);
+    console.log('测试数据清理完成');
+    return true;
+  } catch (error) {
+    console.error('清理测试数据失败:', error.message);
+    return false;
+  }
 };
 
 /**
  * 记录测试结果
- * @param {String} test_name - 测试名称
- * @param {Boolean} success - 是否成功
- * @param {String} message - 测试信息
+ * @param {string} test_name - 测试名称
+ * @param {boolean} success - 是否成功
+ * @param {string} message - 测试信息
  */
 TestMysql.prototype._recordResult = function(test_name, success, message) {
-    this._test_results.push({
-        test_name,
-        success,
-        message,
-        timestamp: new Date().toISOString()
-    });
+  this._test_results.push({
+    test_name,
+    success,
+    message,
+    timestamp: new Date().toISOString()
+  });
     
-    const status = success ? '✓' : '✗';
-    console.log(`${status} ${test_name}: ${message}`);
+  const status = success ? '✓' : '✗';
+  console.log(`${status} ${test_name}: ${message}`);
 };
 
 /**
- * 测试连接功能
- * @returns {Promise<boolean>}
+ * 连接测试
+ * @returns {Promise<boolean>} 连接测试是否成功
  */
-TestMysql.prototype.testConnection = async function() {
-    try {
-        // 测试获取连接
-        const conn = await this._mysql.getConn();
-        if (!conn) {
-            throw new Error('获取连接失败');
-        }
-        
-        // 测试连接是否可用
-        const [result] = await conn.execute('SELECT 1 as test_value');
-        if (!result || !Array.isArray(result) || result.length === 0) {
-            throw new Error('连接测试查询失败');
-        }
+TestMysql.prototype.testConn = async function() {
+  try {
+    // 测试获取连接
+    const conn = await this._mysql.getConn();
+    if (!conn) {
+      throw new Error('获取连接失败');
+    }
         
-        // 如果是连接池连接，需要释放
-        if (this._mysql._pool) {
-            conn.release();
-        }
+    // 测试连接是否可用
+    const [result] = await conn.execute('SELECT 1 as test_value');
+    if (!result || !Array.isArray(result) || result.length === 0) {
+      throw new Error('连接测试查询失败');
+    }
         
-        this._recordResult('连接测试', true, '数据库连接正常');
-        return true;
-    } catch (error) {
-        this._recordResult('连接测试', false, error.message);
-        return false;
+    // 如果是连接池连接，需要释放
+    if (this._mysql._pool) {
+      conn.release();
     }
+        
+    this._recordResult('连接测试', true, '数据库连接正常');
+    return true;
+  } catch (error) {
+    this._recordResult('连接测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试插入功能（优化版）
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 插入测试是否成功
  */
 TestMysql.prototype.testInsert = async function() {
-    try {
-        console.log('\n--- 插入测试（优化版） ---');
-        
-        // 使用预加载的数据进行查询验证，避免重复插入
-        const query_sql = `SELECT COUNT(*) as count FROM ${this._test_table_name}`;
-        const count_result = await this._mysql.run(query_sql);
-        
-        if (count_result && count_result[0].count > 0) {
-            console.log('插入测试通过（使用预加载数据验证）');
-            this._recordResult('插入测试', true, `数据插入验证成功，当前记录数: ${count_result[0].count}`);
-            return true;
-        } else {
-            throw new Error('预加载数据验证失败');
-        }
-    } catch (error) {
-        console.error('插入测试失败:', error.message);
-        this._recordResult('插入测试', false, error.message);
-        return false;
+  try {
+    console.log('\n--- 插入测试（优化版） ---');
+        
+    // 使用预加载的数据进行查询验证，避免重复插入
+    const query_sql = `SELECT COUNT(*) as count FROM ${this._test_table_name}`;
+    const count = await this._mysql.run(query_sql);
+        
+    if (count && count[0].count > 0) {
+      console.log('插入测试通过（使用预加载数据验证）');
+      this._recordResult('插入测试', true, `数据插入验证成功，当前记录数: ${count[0].count}`);
+      return true;
+    } else {
+      throw new Error('预加载数据验证失败');
     }
+  } catch (error) {
+    console.error('插入测试失败:', error.message);
+    this._recordResult('插入测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试查询功能
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 查询测试是否成功
  */
 TestMysql.prototype.testQuery = async function() {
-    try {
-        // 查询所有数据
-        const sql = `SELECT * FROM ${this._test_table_name}`;
-        const results = await this._mysql.run(sql);
-        
-        if (!Array.isArray(results)) {
-            throw new Error('查询结果格式异常');
-        }
+  try {
+    // 查询所有数据
+    const sql = `SELECT * FROM ${this._test_table_name}`;
+    const results = await this._mysql.run(sql);
         
-        this._recordResult('查询测试', true, `查询到 ${results.length} 条记录`);
-        return true;
-    } catch (error) {
-        this._recordResult('查询测试', false, error.message);
-        return false;
+    if (!Array.isArray(results)) {
+      throw new Error('查询结果格式异常');
     }
+        
+    this._recordResult('查询测试', true, `查询到 ${results.length} 条记录`);
+    return true;
+  } catch (error) {
+    this._recordResult('查询测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试条件查询
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 条件查询测试是否成功
  */
-TestMysql.prototype.testConditionalQuery = async function() {
-    try {
-        // 使用预加载数据中的特定名称进行查询
-        const sql = `SELECT * FROM ${this._test_table_name} WHERE name = ?`;
-        const results = await this._mysql.run(sql, ['张三']);
-        
-        if (!Array.isArray(results)) {
-            throw new Error('条件查询结果格式异常');
-        }
-        
-        this._recordResult('条件查询测试', true, `查询到 ${results.length} 条匹配记录`);
-        return true;
-    } catch (error) {
-        this._recordResult('条件查询测试', false, error.message);
-        return false;
+TestMysql.prototype.testCondQuery = async function() {
+  try {
+    // 使用预加载数据中的特定名称进行查询
+    const sql = `SELECT * FROM ${this._test_table_name} WHERE name = ?`;
+    const results = await this._mysql.run(sql, ['张三']);
+        
+    if (!Array.isArray(results)) {
+      throw new Error('条件查询结果格式异常');
     }
+        
+    this._recordResult('条件查询测试', true, `查询到 ${results.length} 条匹配记录`);
+    return true;
+  } catch (error) {
+    this._recordResult('条件查询测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试更新功能
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 更新测试是否成功
  */
 TestMysql.prototype.testUpdate = async function() {
-    try {
-        // 先插入独立的测试数据用于更新测试
-        const test_user_name = '更新测试用户';
-        const insert_sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
-        const insert_result = await this._mysql.exec(insert_sql, [test_user_name, 'update_test@example.com', 25]);
-        
-        if (insert_result < 1) {
-            throw new Error('插入测试数据失败');
-        }
-        
-        // 更新独立的测试数据
-        const update_sql = `UPDATE ${this._test_table_name} SET age = ? WHERE name = ?`;
-        const result = await this._mysql.exec(update_sql, [30, test_user_name]);
+  try {
+    // 先插入独立的测试数据用于更新测试
+    const test_user_name = '更新测试用户';
+    const insert_sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
+    const res = await this._mysql.exec(insert_sql, [test_user_name, 'update_test@example.com', 25]);
+        
+    if (res < 1) {
+      throw new Error('插入测试数据失败');
+    }
         
-        if (result < 1) {
-            throw new Error('更新数据失败');
-        }
+    // 更新独立的测试数据
+    const update_sql = `UPDATE ${this._test_table_name} SET age = ? WHERE name = ?`;
+    const result = await this._mysql.exec(update_sql, [30, test_user_name]);
         
-        this._recordResult('更新测试', true, `更新了 ${result} 条记录`);
-        return true;
-    } catch (error) {
-        this._recordResult('更新测试', false, error.message);
-        return false;
+    if (result < 1) {
+      throw new Error('更新数据失败');
     }
+        
+    this._recordResult('更新测试', true, `更新了 ${result} 条记录`);
+    return true;
+  } catch (error) {
+    this._recordResult('更新测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试删除功能
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 删除测试是否成功
  */
 TestMysql.prototype.testDelete = async function() {
-    try {
-        // 先插入独立的测试数据用于删除测试
-        const test_user_name = '删除测试用户';
-        const insert_sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
-        const insert_result = await this._mysql.exec(insert_sql, [test_user_name, 'delete_test@example.com', 25]);
-        
-        if (insert_result < 1) {
-            throw new Error('插入测试数据失败');
-        }
+  try {
+    // 先插入独立的测试数据用于删除测试
+    const test_user_name = '删除测试用户';
+    const insert_sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
+    const res = await this._mysql.exec(insert_sql, [test_user_name, 'delete_test@example.com', 25]);
+        
+    if (res < 1) {
+      throw new Error('插入测试数据失败');
+    }
         
-        // 删除独立的测试数据
-        const delete_sql = `DELETE FROM ${this._test_table_name} WHERE name = ?`;
-        const result = await this._mysql.exec(delete_sql, [test_user_name]);
+    // 删除独立的测试数据
+    const delete_sql = `DELETE FROM ${this._test_table_name} WHERE name = ?`;
+    const result = await this._mysql.exec(delete_sql, [test_user_name]);
         
-        if (result < 1) {
-            throw new Error('删除数据失败');
-        }
-        
-        this._recordResult('删除测试', true, `删除了 ${result} 条记录`);
-        return true;
-    } catch (error) {
-        this._recordResult('删除测试', false, error.message);
-        return false;
+    if (result < 1) {
+      throw new Error('删除数据失败');
     }
+        
+    this._recordResult('删除测试', true, `删除了 ${result} 条记录`);
+    return true;
+  } catch (error) {
+    this._recordResult('删除测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试DB类功能
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} DB类测试是否成功
  */
 TestMysql.prototype.testDbClass = async function() {
-    try {
-        // 获取DB实例
-        const db = this._mysql.db().new(this._test_table_name, 'id');
+  try {
+    // 获取DB实例
+    const db = this._mysql.db().new(this._test_table_name, 'id');
         
-        if (!db) {
-            throw new Error('获取DB实例失败');
-        }
+    if (!db) {
+      throw new Error('获取DB实例失败');
+    }
         
-        // 使用独立的测试数据，避免影响预加载数据
-        const test_user_name = 'DB独立测试用户';
-        
-        // 测试DB类的add方法
-        const add_result = await db.add({
-            name: test_user_name,
-            email: 'db_test@example.com',
-            age: 30
-        });
-        if (add_result < 1) {
-            throw new Error('DB.add()方法测试失败');
-        }
+    // 使用独立的测试数据，避免影响预加载数据
+    const test_user_name = 'DB独立测试用户';
         
-        // 测试DB类的get方法
-        const get_result = await db.get({ name: test_user_name });
-        if (get_result.length < 1) {
-            throw new Error('DB.get()方法测试失败');
-        }
+    // 测试DB类的add方法
+    const id = await db.add({
+      name: test_user_name,
+      email: 'db_test@example.com',
+      age: 30
+    });
+    if (id < 1) {
+      throw new Error('DB.add()方法测试失败');
+    }
         
-        // 测试DB类的set方法
-        const set_result = await db.set({ id: add_result }, { age: 31 });
+    // 测试DB类的get方法
+    const user = await db.get({ name: test_user_name });
+    if (user.length < 1) {
+      throw new Error('DB.get()方法测试失败');
+    }
         
-        if (set_result < 1) {
-            throw new Error('DB.set()方法测试失败');
-        }
+    // 测试DB类的set方法
+    const updated = await db.set({ id: id }, { age: 31 });
         
-        // 测试DB类的del方法
-        const del_result = await db.del({ id: add_result });
+    if (updated < 1) {
+      throw new Error('DB.set()方法测试失败');
+    }
         
-        if (del_result < 1) {
-            throw new Error('DB.del()方法测试失败');
-        }
+    // 测试DB类的del方法
+    const deleted = await db.del({ id: id });
         
-        this._recordResult('DB类测试', true, 'DB类方法测试通过');
-        return true;
-    } catch (error) {
-        this._recordResult('DB类测试', false, error.message);
-        return false;
+    if (deleted < 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>}
+ * @returns {Promise<boolean>} Sql类测试是否成功
  */
 TestMysql.prototype.testSqlClass = async function() {
-    try {
-        console.log('\n--- Sql类测试（优化版） ---');
+  try {
+    console.log('\n--- Sql类测试（优化版） ---');
         
-        // 直接使用mysql2的escape函数测试SQL转义功能，避免创建新的数据库连接
-        const mysql2 = require('mysql2');
+    // 直接使用mysql2的escape函数测试SQL转义功能，避免创建新的数据库连接
+    const mysql2 = require('mysql2');
         
-        // 测试escape方法
-        const escaped_value = mysql2.escape("test'value");
-        console.log('escape结果:', escaped_value);
+    // 测试escape方法
+    const escaped = mysql2.escape("test'value");
+    console.log('escape结果:', escaped);
         
-        // 测试toAddSql方法逻辑（手动实现）
-        const test_data = { name: 'Sql测试用户', age: 30, email: 'sql_test@example.com' };
-        let keys = '';
-        let values = '';
+    // 测试toAddSql方法逻辑（手动实现）
+    const data = { name: 'Sql测试用户', age: 30, email: 'sql_test@example.com' };
+    let keys = '';
+    let values = '';
         
-        for (const key in test_data) {
-            keys += `, \`${key}\``;
-            values += `, ${mysql2.escape(test_data[key])}`;
-        }
+    for (const key in data) {
+      keys += `, \`${key}\``;
+      values += `, ${mysql2.escape(data[key])}`;
+    }
         
-        const add_sql = `INSERT INTO test_users (${keys.replace(', ', '')}) VALUES (${values.replace(', ', '')})`;
-        console.log('toAddSql结果:', add_sql);
+    const add_sql = `INSERT INTO test_users (${keys.replace(', ', '')}) VALUES (${values.replace(', ', '')})`;
+    console.log('toAddSql结果:', add_sql);
         
-        // 测试toGetSql方法逻辑（手动实现）
-        const get_sql = `SELECT * FROM test_users WHERE id = ${mysql2.escape(1)}`;
-        console.log('toGetSql结果:', get_sql);
+    // 测试toGetSql方法逻辑（手动实现）
+    const get_sql = `SELECT * FROM test_users WHERE id = ${mysql2.escape(1)}`;
+    console.log('toGetSql结果:', get_sql);
         
-        // 使用预加载的数据进行查询，避免重复插入
-        const query_result = await this._mysql.run(get_sql);
-        console.log('查询结果:', query_result);
+    // 使用预加载的数据进行查询，避免重复插入
+    const rows = await this._mysql.run(get_sql);
+    console.log('查询结果:', rows);
         
-        this._recordResult('Sql类测试', true, 'Sql类方法逻辑测试通过');
-        return true;
-    } catch (error) {
-        console.error('Sql类测试失败:', error.message);
-        this._recordResult('Sql类测试', false, error.message);
-        return false;
-    }
+    this._recordResult('Sql类测试', true, 'Sql类方法逻辑测试通过');
+    return true;
+  } catch (error) {
+    console.error('Sql类测试失败:', error.message);
+    this._recordResult('Sql类测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试事务功能
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 事务测试是否成功
  */
-TestMysql.prototype.testTransaction = async function() {
-    try {
-        // 测试事务基本功能 - 不执行实际SQL操作
-        const result = await this._mysql.transaction(async (tx) => {
-            // 简单的事务测试，只验证事务对象存在
-            if (tx && tx.commit && tx.rollback) {
-                return { success: true, message: '事务对象正确创建' };
-            } else {
-                throw new Error('事务对象缺少必要方法');
-            }
-        });
-        
-        console.log("事务测试结果", result);
-        this._recordResult('事务测试', true, '事务执行成功');
-        return true;
-    } catch (error) {
-        this._recordResult('事务测试', false, error.message);
-        return false;
-    }
+TestMysql.prototype.testTrans = async function() {
+  try {
+    // 测试事务基本功能 - 不执行实际SQL操作
+    const result = await this._mysql.transaction(async (tx) => {
+      // 简单的事务测试，只验证事务对象存在
+      if (tx && tx.commit && tx.rollback) {
+        return { success: true, message: '事务对象正确创建' };
+      } else {
+        throw new Error('事务对象缺少必要方法');
+      }
+    });
+        
+    console.log('事务测试结果', result);
+    this._recordResult('事务测试', true, '事务执行成功');
+    return true;
+  } catch (error) {
+    this._recordResult('事务测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试连接池功能
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 连接池测试是否成功
  */
-TestMysql.prototype.testConnectionPool = async function() {
-    try {
-        if (!this._mysql._pool) {
-            this._recordResult('连接池测试', true, '连接池未启用（单连接模式）');
-            return true;
-        }
+TestMysql.prototype.testConnPool = async function() {
+  try {
+    if (!this._mysql._pool) {
+      this._recordResult('连接池测试', true, '连接池未启用（单连接模式）');
+      return true;
+    }
         
-        // 使用更安全的方式测试连接池 - 顺序获取和释放连接
-        const connections = [];
-        
-        // 顺序获取连接，避免并发问题
-        for (let i = 0; i < 2; i++) {
-            const conn = await this._mysql.getConn();
-            if (conn) {
-                connections.push(conn);
-                // 立即释放连接，避免资源占用
-                if (conn.release) {
-                    conn.release();
-                }
-            }
+    // 使用更安全的方式测试连接池 - 顺序获取和释放连接
+    const conns = [];
+        
+    // 顺序获取连接，避免并发问题
+    for (let i = 0; i < 2; i++) {
+      const conn = await this._mysql.getConn();
+      if (conn) {
+        conns.push(conn);
+        // 立即释放连接，避免资源占用
+        if (conn.release) {
+          conn.release();
         }
-        
-        this._recordResult('连接池测试', true, `顺序获取 ${connections.length} 个连接成功`);
-        return true;
-    } catch (error) {
-        this._recordResult('连接池测试', false, error.message);
-        return false;
+      }
     }
+        
+    this._recordResult('连接池测试', true, `顺序获取 ${conns.length} 个连接成功`);
+    return true;
+  } catch (error) {
+    this._recordResult('连接池测试', false, error.message);
+    return false;
+  }
 };
 
 /**
  * 测试错误处理
- * @returns {Promise<boolean>}
+ * @returns {Promise<boolean>} 错误处理测试是否成功
  */
 TestMysql.prototype.testErrorHandling = async function() {
+  try {
+    // 测试无效SQL - 使用更安全的错误测试方式
+    const invalid_sql = 'SELECT * FROM non_existent_table';
+        
+    // 临时禁用错误输出
+    const debug = this._mysql._debug;
+    this._mysql._debug = false;
+        
+    // 使用try-catch捕获可能的异常
     try {
-        // 测试无效SQL - 使用更安全的错误测试方式
-        const invalid_sql = 'SELECT * FROM non_existent_table';
-        
-        // 临时禁用错误输出
-        const originalDebug = this._mysql._debug;
-        this._mysql._debug = false;
-        
-        // 使用try-catch捕获可能的异常
-        let result;
-        try {
-            result = await this._mysql.run(invalid_sql);
-        } catch (error) {
-            // 预期中的错误，继续处理
-            result = null;
-        }
+      await this._mysql.run(invalid_sql);
+    } catch {
+      // 预期中的错误，继续处理
+    }
         
-        // 恢复调试设置
-        this._mysql._debug = originalDebug;
+    // 恢复调试设置
+    this._mysql._debug = debug;
         
-        // 检查是否设置了错误信息
-        if (this._mysql.error && this._mysql.error.code) {
-            this._recordResult('错误处理测试', true, `正确捕获SQL错误: ${this._mysql.error.message}`);
-            return true;
-        } else {
-            this._recordResult('错误处理测试', false, '未正确捕获SQL错误');
-            return false;
-        }
-    } catch (error) {
-        this._recordResult('错误处理测试', false, `发生非预期错误: ${error.message}`);
-        return false;
+    // 检查是否设置了错误信息
+    if (this._mysql.error && this._mysql.error.code) {
+      this._recordResult('错误处理测试', true, `正确捕获SQL错误: ${this._mysql.error.message}`);
+      return true;
+    } else {
+      this._recordResult('错误处理测试', false, '未正确捕获SQL错误');
+      return false;
     }
+  } catch (error) {
+    this._recordResult('错误处理测试', false, `发生非预期错误: ${error.message}`);
+    return false;
+  }
 };
 
 /**
  * 运行所有测试（优化版）
- * @returns {Promise<Object>}
+ * @returns {Promise<object>} 测试结果汇总
  */
 TestMysql.prototype.runAllTests = async function() {
-    console.log('\n=== 开始运行MySQL功能测试（优化版） ===\n');
+  console.log('\n=== 开始运行MySQL功能测试（优化版） ===\n');
     
-    // 记录开始时间
-    const start_time = Date.now();
+  // 记录开始时间
+  const start_time = Date.now();
     
-    // 初始化测试环境
-    const init_success = await this._init();
-    if (!init_success) {
-        console.log('测试环境初始化失败，跳过所有测试');
-        return this._getTestSummary();
-    }
+  // 初始化测试环境
+  const init_success = await this._init();
+  if (!init_success) {
+    console.log('测试环境初始化失败，跳过所有测试');
+    return this._getTestSummary();
+  }
     
-    // 预插入测试数据，避免每个测试单独插入
-    await this._preloadTestData();
+  // 预插入测试数据，避免每个测试单独插入
+  await this._preloadTestData();
     
-    // 定义测试用例（重新排序，将耗时较少的测试放在前面）
-    const test_cases = [
-        { name: '连接测试', method: 'testConnection' },
-        { name: '查询测试', method: 'testQuery' },
-        { name: '条件查询测试', method: 'testConditionalQuery' },
-        { name: '插入测试', method: 'testInsert' },
-        { name: 'DB类测试', method: 'testDbClass' },
-        { name: 'Sql类测试', method: 'testSqlClass' },
-        { name: '更新测试', method: 'testUpdate' },
-        { name: '删除测试', method: 'testDelete' },
-        { name: '事务测试', method: 'testTransaction' },
-        { name: '连接池测试', method: 'testConnectionPool' },
-        { name: '错误处理测试', method: 'testErrorHandling' }
-    ];
+  // 定义测试用例（重新排序，将耗时较少的测试放在前面）
+  const test_cases = [
+    { name: '连接测试', method: 'testConn' },
+    { name: '查询测试', method: 'testQuery' },
+    { name: '条件查询测试', method: 'testCondQuery' },
+    { name: '插入测试', method: 'testInsert' },
+    { name: 'DB类测试', method: 'testDbClass' },
+    { name: 'Sql类测试', method: 'testSqlClass' },
+    { name: '更新测试', method: 'testUpdate' },
+    { name: '删除测试', method: 'testDelete' },
+    { name: '事务测试', method: 'testTrans' },
+    { name: '连接池测试', method: 'testConnPool' },
+    { name: '错误处理测试', method: 'testErrorHandling' }
+  ];
     
-    // 顺序执行测试用例（移除延迟，提高测试速度）
-    for (const test_case of test_cases) {
-        try {
-            console.log(`执行测试: ${test_case.name}`);
-            await this[test_case.method]();
-            console.log(`测试完成: ${test_case.name}`);
-        } catch (error) {
-            console.error(`测试异常: ${test_case.name}`, error);
-            this._recordResult(test_case.name, false, `测试执行异常: ${error.message}`);
-        }
+  // 顺序执行测试用例（移除延迟，提高测试速度）
+  for (const test_case of test_cases) {
+    try {
+      console.log(`执行测试: ${test_case.name}`);
+      await this[test_case.method]();
+      console.log(`测试完成: ${test_case.name}`);
+    } catch (error) {
+      console.error(`测试异常: ${test_case.name}`, error);
+      this._recordResult(test_case.name, false, `测试执行异常: ${error.message}`);
     }
+  }
     
-    // 清理测试环境
-    await this._cleanup();
+  // 清理测试环境
+  await this._cleanup();
     
-    // 关闭数据库连接
-    if (this._mysql) {
-        await this._mysql.close();
-    }
+  // 关闭数据库连接
+  if (this._mysql) {
+    await this._mysql.close();
+  }
     
-    const total_time = Date.now() - start_time;
-    console.log(`\n=== 测试完成，总耗时: ${total_time}ms ===\n`);
-    return this._getTestSummary();
+  const time = Date.now() - start_time;
+  console.log(`\n=== 测试完成，总耗时: ${time}ms ===\n`);
+  return this._getTestSummary();
 };
 
 /**
  * 获取测试摘要
- * @returns {Object}
+ * @returns {object} 测试结果摘要信息
  */
 TestMysql.prototype._getTestSummary = function() {
-    const total = this._test_results.length;
-    const passed = this._test_results.filter(r => r.success).length;
-    const failed = total - passed;
+  const total = this._test_results.length;
+  const passed = this._test_results.filter(r => r.success).length;
+  const failed = total - passed;
     
-    console.log(`测试摘要:`);
-    console.log(`总测试数: ${total}`);
-    console.log(`通过: ${passed}`);
-    console.log(`失败: ${failed}`);
-    console.log(`通过率: ${((passed / total) * 100).toFixed(1)}%`);
+  console.log(`测试摘要:`);
+  console.log(`总测试数: ${total}`);
+  console.log(`通过: ${passed}`);
+  console.log(`失败: ${failed}`);
+  console.log(`通过率: ${((passed / total) * 100).toFixed(1)}%`);
     
-    // 显示失败的测试
-    const failed_tests = this._test_results.filter(r => !r.success);
-    if (failed_tests.length > 0) {
-        console.log('\n失败的测试:');
-        failed_tests.forEach(test => {
-            console.log(`  ✗ ${test.test_name}: ${test.message}`);
-        });
-    }
+  // 显示失败的测试
+  const failed_tests = this._test_results.filter(r => !r.success);
+  if (failed_tests.length > 0) {
+    console.log('\n失败的测试:');
+    failed_tests.forEach(test => {
+      console.log(`  ✗ ${test.test_name}: ${test.message}`);
+    });
+  }
     
-    return {
-        total,
-        passed,
-        failed,
-        results: this._test_results
-    };
+  return {
+    total,
+    passed,
+    failed,
+    results: this._test_results
+  };
 };
 
 /**
  * 休眠函数
- * @param {Number} ms - 毫秒数
- * @returns {Promise}
+ * @param {number} ms - 毫秒数
+ * @returns {Promise<void>} 休眠完成的Promise
  */
 TestMysql.prototype._sleep = function(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise(resolve => setTimeout(resolve, ms));
 };
 
 /**
  * 主测试函数
+ * @returns {Promise<void>}
  */
 TestMysql.prototype.main = async function() {
-    try {
-        const summary = await this.runAllTests();
-        
-        if (summary.failed > 0) {
-            console.log('\n❌ 部分测试失败，请检查数据库配置和连接');
-            process.exit(1);
-        } else {
-            console.log('\n✅ 所有测试通过！');
-            process.exit(0);
-        }
-    } catch (error) {
-        console.error('测试执行异常:', error);
-        process.exit(1);
+  try {
+    const summary = await this.runAllTests();
+        
+    if (summary.failed > 0) {
+      console.log('\n❌ 部分测试失败，请检查数据库配置和连接');
+      process.exit(1);
+    } else {
+      console.log('\n✅ 所有测试通过！');
+      process.exit(0);
     }
+  } catch (error) {
+    console.error('测试执行异常:', error);
+    process.exit(1);
+  }
 };
 
 // 模块导出
@@ -676,32 +672,32 @@ exports.TestMysql = TestMysql;
 
 /**
  * 快速测试函数
- * @param {Object} config - 数据库配置
+ * @param {object} config - 数据库配置
  */
 const quick_test = async function(config) {
-    const tester = new TestMysql(config);
-    await tester.main();
+  const tester = new TestMysql(config);
+  await tester.main();
 };
 
 // 如果直接运行此文件，执行测试
 if (require.main === module) {
-    // 从环境变量或默认配置获取数据库连接信息
-    const test_config = {
-        host: process.env.DB_HOST || '127.0.0.1',
-        port: parseInt(process.env.DB_PORT) || 3306,
-        user: process.env.DB_USER || 'root',
-        password: process.env.DB_PASSWORD || 'Asd159357',
-        database: process.env.DB_NAME || 'test_db',
-        debug: process.env.DEBUG === 'true',
-        connection_limit: parseInt(process.env.DB_CONNECTION_LIMIT) || 5
-    };
+  // 从环境变量或默认配置获取数据库连接信息
+  const test_config = {
+    host: process.env.DB_HOST || '127.0.0.1',
+    port: parseInt(process.env.DB_PORT) || 3306,
+    user: process.env.DB_USER || 'root',
+    password: process.env.DB_PASSWORD || 'Asd159357',
+    database: process.env.DB_NAME || 'test_db',
+    debug: process.env.DEBUG === 'true',
+    connection_limit: parseInt(process.env.DB_CONNECTION_LIMIT) || 5
+  };
     
-    console.log('使用配置:', {
-        ...test_config,
-        password: '***' // 隐藏密码
-    });
+  console.log('使用配置:', {
+    ...test_config,
+    password: '***' // 隐藏密码
+  });
     
-    quick_test(test_config);
+  quick_test(test_config);
 }
 
 // 导出快速测试函数