mm_mysql 2.0.3 → 2.0.5

package/package.json

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

package/sql.js

@@ -1625,4 +1625,93 @@ Sql.prototype.model = function (model) {
 	});
 };
 
+/**
+ * 添加或修改数据（存在则修改，不存在则添加）
+ * @param {Object|String} where 查询条件
+ * @param {Object|String} set 要设置的数据
+ * @param {Boolean} like 是否使用like匹配, 为空使用默认方式
+ * @return {Promise<Object>} 执行结果
+ */
+Sql.prototype.addOrSet = async function(where, set, like) {
+	if (!this.table || !where || !set) {
+		throw new Error('表名、条件或数据未设置');
+	}
+	try {
+		let query = where;
+		let body = set;
+		let whereStr;
+
+		if (typeof where === "object") {
+			whereStr = await this.toWhere(where, like);
+		} else {
+			whereStr = where;
+		}
+
+		const count = await this.countSql(whereStr);
+
+		if (count === 0) {
+			let key = "";
+			let value = "";
+
+			if (typeof set === "string") {
+				const arr = set.split(",");
+				for (const o of arr) {
+					const ar = o.split('=');
+					if (ar.length === 2) {
+						key += "," + ar[0];
+						value += "," + ar[1];
+					}
+				}
+			} else {
+				// 触发前置事件
+				if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof body === "object") {
+					await $.eventer.run("mysql_add_before:" + this.table, { body });
+				}
+
+				for (const k in set) {
+					if (!Object.prototype.hasOwnProperty.call(set, k)) continue;
+
+					key += "," + escapeId(k);
+					let val = set[k];
+					if (typeof val === "string") {
+						val = val.trim("'");
+					}
+					value += "," + escape(val);
+				}
+			}
+
+			const bl = await this.addSql(key.replace(",", ""), value.replace(",", ""));
+
+			// 触发后置事件
+			if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof body === "object") {
+				await $.eventer.run("mysql_add_after:" + this.table, { body, sql: this.sql, error: this.error, bl });
+			}
+
+			return bl;
+		} else {
+			// 触发前置事件
+			if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof set === "object") {
+				await $.eventer.run("mysql_set_before:" + this.table, { query, body, like, page: this.page, size: this.size, sql: this.sql });
+			}
+
+			if (typeof set === "object") {
+				set = await this.toSet(set);
+			}
+
+			const bl1 = await this.setSql(whereStr, set);
+
+			// 触发后置事件
+			if (typeof $.eventer === 'object' && typeof $.eventer.run === 'function' && typeof body === "object") {
+				await $.eventer.run("mysql_set_after:" + this.table, { query, body, like, page: this.page, size: this.size, sql: this.sql, error: this.error, bl: bl1 });
+			}
+
+			return bl1;
+		}
+	} catch (err) {
+		this.error = err.message;
+		$.log.error(`添加或修改数据失败: ${err.message}`);
+		throw err;
+	}
+};
+
 module.exports = Sql;

package/test.js

@@ -0,0 +1,518 @@
+/**
+ * MySQL数据库操作类测试文件
+ * @file test.js
+ * @description 测试Mysql类的各项功能
+ */
+
+// 引入依赖
+const { Mysql } = require('./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: '',
+            database: '', // 先不指定数据库，连接成功后再创建
+            debug: true,
+            connectionLimit: 5
+        }, config || {});
+        
+        this._mysql = null;
+        this._test_results = [];
+        this._test_table_name = 'test_users';
+    }
+}
+
+/**
+ * 初始化测试环境
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype._init = async function() {
+    try {
+        console.log('=== 初始化测试环境 ===');
+        
+        // 创建Mysql实例（先不指定数据库）
+        this._mysql = new Mysql(this.config);
+        
+        // 连接数据库
+        await this._mysql.open();
+        
+        // 创建测试数据库
+        await this._create_test_database();
+        
+        // 重新连接指定数据库
+        await this._mysql.close();
+        this.config.database = 'test_db';
+        this._mysql = new Mysql(this.config);
+        await this._mysql.open();
+        
+        // 创建测试表
+        await this._create_test_table();
+        
+        console.log('测试环境初始化完成');
+        return true;
+    } catch (error) {
+        console.error('初始化测试环境失败:', error.message);
+        return false;
+    }
+};
+
+/**
+ * 创建测试数据库
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype._create_test_database = async function() {
+    try {
+        const create_db_sql = `CREATE DATABASE IF NOT EXISTS test_db`;
+        await this._mysql.exec(create_db_sql);
+        console.log('测试数据库创建成功');
+        return true;
+    } catch (error) {
+        console.error('创建测试数据库失败:', error.message);
+        return false;
+    }
+};
+
+/**
+ * 创建测试表
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype._create_test_table = async function() {
+    try {
+        const sql = `
+            CREATE TABLE IF NOT EXISTS ${this._test_table_name} (
+                id INT AUTO_INCREMENT PRIMARY KEY,
+                name VARCHAR(100) NOT NULL,
+                email VARCHAR(100) UNIQUE NOT NULL,
+                age INT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+            )
+        `;
+        
+        await this._mysql.exec(sql);
+        console.log('测试表创建成功');
+        return true;
+    } catch (error) {
+        console.error('创建测试表失败:', error.message);
+        return false;
+    }
+};
+
+/**
+ * 清理测试数据
+ * @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;
+    }
+};
+
+/**
+ * 记录测试结果
+ * @param {String} test_name - 测试名称
+ * @param {Boolean} success - 是否成功
+ * @param {String} message - 测试信息
+ */
+TestMysql.prototype._record_result = function(test_name, success, message) {
+    this._test_results.push({
+        test_name,
+        success,
+        message,
+        timestamp: new Date().toISOString()
+    });
+    
+    const status = success ? '✓' : '✗';
+    console.log(`${status} ${test_name}: ${message}`);
+};
+
+/**
+ * 测试连接功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_connection = 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('连接测试查询失败');
+        }
+        
+        // 如果是连接池连接，需要释放
+        if (this._mysql._pool) {
+            conn.release();
+        }
+        
+        this._record_result('连接测试', true, '数据库连接正常');
+        return true;
+    } catch (error) {
+        this._record_result('连接测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试插入功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_insert = async function() {
+    try {
+        const test_data = {
+            name: '测试用户',
+            email: 'test@example.com',
+            age: 25
+        };
+        
+        const sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
+        const result = await this._mysql.exec(sql, [test_data.name, test_data.email, test_data.age]);
+        
+        if (result.affectedRows !== 1) {
+            throw new Error('插入数据失败');
+        }
+        
+        this._record_result('插入测试', true, `插入成功，ID: ${result.insertId}`);
+        return true;
+    } catch (error) {
+        this._record_result('插入测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试查询功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_query = 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('查询结果格式异常');
+        }
+        
+        this._record_result('查询测试', true, `查询到 ${results.length} 条记录`);
+        return true;
+    } catch (error) {
+        this._record_result('查询测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试条件查询
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_conditional_query = 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._record_result('条件查询测试', true, `查询到 ${results.length} 条匹配记录`);
+        return true;
+    } catch (error) {
+        this._record_result('条件查询测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试更新功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_update = async function() {
+    try {
+        const sql = `UPDATE ${this._test_table_name} SET age = ? WHERE name = ?`;
+        const result = await this._mysql.exec(sql, [30, '测试用户']);
+        
+        if (result.affectedRows < 1) {
+            throw new Error('更新数据失败');
+        }
+        
+        this._record_result('更新测试', true, `更新了 ${result.affectedRows} 条记录`);
+        return true;
+    } catch (error) {
+        this._record_result('更新测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试删除功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_delete = async function() {
+    try {
+        const sql = `DELETE FROM ${this._test_table_name} WHERE name = ?`;
+        const result = await this._mysql.exec(sql, ['测试用户']);
+        
+        if (result.affectedRows < 1) {
+            throw new Error('删除数据失败');
+        }
+        
+        this._record_result('删除测试', true, `删除了 ${result.affectedRows} 条记录`);
+        return true;
+    } catch (error) {
+        this._record_result('删除测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试事务功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_transaction = async function() {
+    try {
+        const result = await this._mysql.transaction(async (tx) => {
+            // 在事务中插入数据 - 使用Mysql类的exec方法
+            const insert_sql = `INSERT INTO ${this._test_table_name} (name, email, age) VALUES (?, ?, ?)`;
+            const insert_result = await this._mysql.exec(insert_sql, ['事务用户', 'tx@example.com', 28]);
+            
+            // 在事务中查询数据 - 使用Mysql类的run方法
+            const query_sql = `SELECT * FROM ${this._test_table_name} WHERE email = ?`;
+            const results = await this._mysql.run(query_sql, ['tx@example.com']);
+            
+            return results;
+        });
+        
+        this._record_result('事务测试', true, '事务执行成功');
+        return true;
+    } catch (error) {
+        this._record_result('事务测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试连接池功能
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_connection_pool = async function() {
+    try {
+        if (!this._mysql._pool) {
+            this._record_result('连接池测试', true, '连接池未启用（单连接模式）');
+            return true;
+        }
+        
+        // 测试并发获取连接
+        const promises = [];
+        for (let i = 0; i < 3; i++) {
+            promises.push(this._mysql.getConn());
+        }
+        
+        const connections = await Promise.all(promises);
+        
+        // 释放所有连接
+        connections.forEach(conn => {
+            if (conn.release) {
+                conn.release();
+            }
+        });
+        
+        this._record_result('连接池测试', true, `并发获取 ${connections.length} 个连接成功`);
+        return true;
+    } catch (error) {
+        this._record_result('连接池测试', false, error.message);
+        return false;
+    }
+};
+
+/**
+ * 测试错误处理
+ * @returns {Promise<boolean>}
+ */
+TestMysql.prototype.test_error_handling = async function() {
+    try {
+        // 测试无效SQL
+        const invalid_sql = 'SELECT * FROM non_existent_table';
+        await this._mysql.run(invalid_sql);
+        
+        this._record_result('错误处理测试', false, '应该抛出错误但未抛出');
+        return false;
+    } catch (error) {
+        if (error.code && error.code.startsWith('ER_')) {
+            this._record_result('错误处理测试', true, `正确捕获SQL错误: ${error.message}`);
+            return true;
+        } else {
+            this._record_result('错误处理测试', false, `捕获到非预期错误: ${error.message}`);
+            return false;
+        }
+    }
+};
+
+/**
+ * 运行所有测试
+ * @returns {Promise<Object>}
+ */
+TestMysql.prototype.run_all_tests = async function() {
+    console.log('\n=== 开始运行MySQL功能测试 ===\n');
+    
+    // 初始化测试环境
+    const init_success = await this._init();
+    if (!init_success) {
+        console.log('测试环境初始化失败，跳过所有测试');
+        return this._get_test_summary();
+    }
+    
+    // 定义测试用例
+    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' }
+    ];
+    
+    // 顺序执行测试用例
+    for (const test_case of test_cases) {
+        try {
+            await this[test_case.method]();
+        } catch (error) {
+            this._record_result(test_case.name, false, `测试执行异常: ${error.message}`);
+        }
+        
+        // 添加短暂延迟，避免数据库压力
+        await this._sleep(100);
+    }
+    
+    // 清理测试环境
+    await this._cleanup();
+    
+    // 关闭数据库连接
+    if (this._mysql) {
+        await this._mysql.close();
+    }
+    
+    console.log('\n=== 测试完成 ===\n');
+    return this._get_test_summary();
+};
+
+/**
+ * 获取测试摘要
+ * @returns {Object}
+ */
+TestMysql.prototype._get_test_summary = function() {
+    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)}%`);
+    
+    // 显示失败的测试
+    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
+    };
+};
+
+/**
+ * 休眠函数
+ * @param {Number} ms - 毫秒数
+ * @returns {Promise}
+ */
+TestMysql.prototype._sleep = function(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+/**
+ * 主测试函数
+ */
+TestMysql.prototype.main = async function() {
+    try {
+        const summary = await this.run_all_tests();
+        
+        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);
+    }
+};
+
+// 模块导出
+exports.TestMysql = TestMysql;
+
+/**
+ * 快速测试函数
+ * @param {Object} config - 数据库配置
+ */
+const quick_test = async function(config) {
+    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',
+        connectionLimit: parseInt(process.env.DB_CONNECTION_LIMIT) || 5
+    };
+    
+    console.log('使用配置:', {
+        ...test_config,
+        password: '***' // 隐藏密码
+    });
+    
+    quick_test(test_config);
+}
+
+// 导出快速测试函数
+exports.quick_test = quick_test;