mm_mysql 2.1.0 → 2.2.0

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❌ 部分测试失败，请检查数据库配置和连接');

package/test_create_table.js

@@ -0,0 +1,193 @@
+const { Mysql } = require('./index');
+
+/**
+ * 测试 createTable 方法功能
+ */
+async function testCreateTable() {
+    console.log('开始测试 createTable 方法...');
+    
+    let mysql = null;
+    const testDatabase = 'test_mm_mysql';
+    const testTable = 'test_users';
+    
+    try {
+        // 初始化 MySQL 连接
+        mysql = new Mysql({
+            host: '127.0.0.1',
+            port: 3306,
+            user: 'root',
+            password: 'Asd159357',
+            database: testDatabase,
+            connectionLimit: 1
+        });
+        
+        // 打开连接
+        await mysql.open();
+        console.log('✅ 数据库连接成功');
+        
+        // 获取 DB 实例
+        const db = mysql.db();
+        
+        // 定义测试表模型
+        const userModel = {
+            fields: {
+                id: 0,               // 主键，会被自动设置为 INT AUTO_INCREMENT PRIMARY KEY
+                username: 'admin',   // 字符串，长度 <= 255，会被设置为 VARCHAR(255)
+                email: 'test@example.com',  // 字符串，会被设置为 VARCHAR(255)
+                age: 25,             // 整数，会被设置为 INT
+                salary: 5000.50,     // 浮点数，会被设置为 FLOAT
+                active: true,        // boolean 类型，会被设置为 INT
+                birth_date: '1990-01-01',  // date 类型，会被设置为 DATE
+                bio: 'This is a very long bio about the user that exceeds 255 characters in length. ' + 
+                     'This is necessary to test the text type functionality in the createTable method. ' + 
+                     'By making this string longer than 255 characters, we can ensure that the field ' + 
+                     'is created as a TEXT type instead of a VARCHAR(255).',  // 字符串，长度 > 255，会被设置为 TEXT
+                created_at: '2023-10-25 10:30:00',  // 日期时间字符串，会被设置为 DATETIME
+                login_time: new Date(),  // Date 对象，会被设置为 DATETIME
+                last_active: Date.now()  // 时间戳，会被设置为 DATETIME
+            }
+        };
+        
+        // 创建表
+        console.log('开始创建测试表...');
+        const createResult = await db.createTable(testTable, userModel, 'id', 15000);
+        
+        if (createResult && createResult.affectedRows !== undefined) {
+            console.log('✅ 测试表创建成功');
+            console.log('   影响行数:', createResult.affectedRows);
+        } else {
+            console.log('⚠️  表可能已存在（CREATE TABLE IF NOT EXISTS）');
+        }
+        
+        // 验证表是否存在
+        console.log('\n验证表结构...');
+        const tableExistsSql = `SHOW TABLES LIKE '${testTable}'`;
+        const tables = await mysql.run(tableExistsSql);
+        
+        if (tables.length > 0) {
+            console.log('✅ 测试表确实存在');
+        } else {
+            throw new Error('测试表不存在');
+        }
+        
+        // 查看表结构
+        const describeSql = `DESCRIBE ${testTable}`;
+        const tableStructure = await mysql.run(describeSql);
+        
+        console.log('\n表结构:');
+        tableStructure.forEach(row => {
+            console.log(`   ${row.Field}: ${row.Type} ${row.Null} ${row.Key} ${row.Default} ${row.Extra}`);
+        });
+        
+        // 验证字段类型是否正确
+        const fieldTypes = {
+            id: 'int',
+            username: 'varchar(255)',
+            email: 'varchar(255)',
+            age: 'int',
+            salary: 'float',
+            active: 'int',  // MySQL 中 boolean 会被转换为 tinyint 或 int
+            birth_date: 'date',
+            bio: 'text',
+            created_at: 'datetime',
+            login_time: 'datetime',  // Date 对象会被设置为 DATETIME
+            last_active: 'datetime'  // 时间戳会被设置为 DATETIME
+        };
+        
+        let allFieldsCorrect = true;
+        tableStructure.forEach(row => {
+            const expectedType = fieldTypes[row.Field];
+            if (expectedType && !row.Type.toLowerCase().includes(expectedType)) {
+                console.log(`❌ 字段 ${row.Field} 类型不正确，预期: ${expectedType}，实际: ${row.Type}`);
+                allFieldsCorrect = false;
+            }
+        });
+        
+        if (allFieldsCorrect) {
+            console.log('✅ 所有字段类型符合预期');
+        }
+        
+        // 测试插入数据
+        console.log('\n测试插入数据...');
+        const currentTime = new Date();
+        const insertSql = `INSERT INTO ${testTable} (username, email, age, salary, active, birth_date, bio, created_at, login_time, last_active) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+        const insertResult = await mysql.exec(insertSql, ['testuser', 'testuser@example.com', 30, 6000.75, true, '1995-05-15', 'Test user bio', '2023-10-25 11:00:00', currentTime, currentTime]);
+        
+        if (insertResult.insertId) {
+            console.log('✅ 数据插入成功，插入ID:', insertResult.insertId);
+        } else {
+            throw new Error('数据插入失败');
+        }
+        
+        // 测试查询数据
+        console.log('\n测试查询数据...');
+        const selectSql = `SELECT * FROM ${testTable} WHERE id = ?`;
+        const user = await mysql.run(selectSql, [insertResult.insertId]);
+        
+        if (user && user.length > 0) {
+            console.log('✅ 数据查询成功');
+            console.log('   查询结果:', user[0]);
+        } else {
+            throw new Error('数据查询失败');
+        }
+        
+        // 测试使用自定义主键
+        console.log('\n测试使用自定义主键...');
+        const customKeyTable = 'test_custom_key';
+        const customModel = {
+            fields: {
+                user_id: 'u001',     // 自定义主键，会被设置为 INT AUTO_INCREMENT PRIMARY KEY
+                name: 'test',        // 字符串
+                value: 100,          // 整数
+                is_active: true,     // boolean 类型
+                join_date: '2023-01-01'  // date 类型
+            }
+        };
+        
+        const customCreateResult = await db.createTable(customKeyTable, customModel, 'user_id', 15000);
+        if (customCreateResult || customCreateResult === 0) {
+            console.log('✅ 使用自定义主键创建表成功');
+            
+            // 验证自定义主键表结构
+            const customDescribeSql = `DESCRIBE ${customKeyTable}`;
+            const customStructure = await mysql.run(customDescribeSql);
+            const customKeyField = customStructure.find(field => field.Field === 'user_id');
+            
+            if (customKeyField && customKeyField.Key === 'PRI') {
+                console.log('✅ 自定义主键设置正确');
+            } else {
+                console.log('⚠️  自定义主键可能未设置为 PRIMARY KEY');
+            }
+        }
+        
+        // 清理测试表
+        console.log('\n清理测试环境...');
+        await mysql.exec(`DROP TABLE IF EXISTS ${testTable}`);
+        await mysql.exec(`DROP TABLE IF EXISTS ${customKeyTable}`);
+        console.log('✅ 测试表已删除');
+        
+        console.log('\n🎉 所有测试通过！createTable 方法功能正常');
+        
+    } catch (error) {
+        console.error('❌ 测试失败:', error.message);
+        console.error('错误详情:', error);
+        return false;
+    } finally {
+        // 关闭连接
+        if (mysql) {
+            try {
+                await mysql.close();
+                console.log('✅ 数据库连接已关闭');
+            } catch (closeError) {
+                console.error('⚠️  关闭数据库连接失败:', closeError.message);
+            }
+        }
+    }
+    
+    return true;
+}
+
+// 运行测试
+testCreateTable().then(success => {
+    process.exit(success ? 0 : 1);
+});