mm_sql 1.4.0 → 1.4.2

package/README.md

@@ -1,5 +1,7 @@
 # mm_sql
 
+[中文](./README.md) | [English](./README_EN.md)
+
 一个通用的SQL帮助类，支持通过切换db_type实现对不同数据库的操作，包括MySQL和SQLite等，提供统一的API接口，支持异步操作和基础SQL执行。
 
 ## 安装
@@ -139,6 +141,10 @@ const filteredParams = sql.filter({ id: 1, name: '张三', password: '123' }, ['
 // 获取底层数据库适配器
 const dbAdapter = sql.db();
 // 可用于直接操作底层数据库接口
+db.table = "user_account";
+const user = await db.get({
+  user_id: 1
+});
 ```
 
 ### 4. 配置选项

package/admin_vs_direct_test.js

@@ -0,0 +1,162 @@
+const { mysqlAdmin } = require('../mm_mysql');
+
+/**
+ * 测试run方法对不存在的表的处理
+ * @param {Object} admin_mysql - mysqlAdmin实例
+ * @param {Object} direct_mysql - 直接Mysql实例
+ */
+async function testRunMethod(admin_mysql, direct_mysql) {
+  console.log('\n测试1: 比较对不存在的表的处理...');
+  
+  // mysqlAdmin实例测试
+  console.log('mysqlAdmin实例测试:');
+  try {
+    const result1 = await admin_mysql.run('SELECT * FROM non_existent_table_xyz');
+    console.log('  ❌ mysqlAdmin没有抛出错误，返回结果:', typeof result1, Array.isArray(result1) ? result1.length : 'N/A');
+  } catch (error) {
+    console.log('  ✅ mysqlAdmin正确抛出错误:', error.message);
+  }
+  
+  // 直接Mysql实例测试
+  console.log('直接Mysql实例测试:');
+  try {
+    const result2 = await direct_mysql.run('SELECT * FROM non_existent_table_xyz');
+    console.log('  ❌ 直接Mysql没有抛出错误，返回结果:', typeof result2, Array.isArray(result2) ? result2.length : 'N/A');
+  } catch (error) {
+    console.log('  ✅ 直接Mysql正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 比较实例类型和属性
+ * @param {Object} admin_mysql - mysqlAdmin实例
+ * @param {Object} direct_mysql - 直接Mysql实例
+ */
+function compareInstanceType(admin_mysql, direct_mysql) {
+  console.log('\n测试2: 比较实例类型和属性...');
+  console.log('mysqlAdmin实例类型:', admin_mysql.constructor.name);
+  console.log('直接Mysql实例类型:', direct_mysql.constructor.name);
+  console.log('mysqlAdmin实例 === 直接Mysql实例:', admin_mysql === direct_mysql);
+  console.log('mysqlAdmin实例类型 === 直接Mysql实例类型:', admin_mysql.constructor.name === direct_mysql.constructor.name);
+}
+
+/**
+ * 检查缓存问题
+ * @param {Object} config - 数据库配置
+ * @param {Object} admin_mysql - mysqlAdmin实例
+ */
+async function checkCache(config, admin_mysql) {
+  console.log('\n测试3: 检查缓存问题...');
+  const admin_mysql2 = mysqlAdmin('compare_test', config); // 相同scope
+  const admin_mysql3 = mysqlAdmin('compare_test2', config); // 不同scope
+  
+  console.log('相同scope实例是否相同:', admin_mysql === admin_mysql2);
+  console.log('不同scope实例是否相同:', admin_mysql === admin_mysql3);
+  
+  // 测试不同scope实例的错误处理
+  console.log('不同scope实例测试:');
+  try {
+    const result3 = await admin_mysql3.run('SELECT * FROM non_existent_table_xyz');
+    console.log('  ❌ 不同scope实例没有抛出错误，返回结果:', typeof result3, Array.isArray(result3) ? result3.length : 'N/A');
+  } catch (error) {
+    console.log('  ✅ 不同scope实例正确抛出错误:', error.message);
+  }
+}
+
+/**
+ * 比较mysqlAdmin和直接Mysql实例的错误处理行为
+ */
+async function compareAdminDirect() {
+  console.log('=== 比较mysqlAdmin和直接Mysql实例的错误处理行为 ===');
+  
+  const config = {
+    host: 'localhost',
+    port: 3306,
+    user: 'root',
+    password: 'Asd159357',
+    database: 'mm'
+  };
+  
+  try {
+    // 创建mysqlAdmin实例
+    const admin_mysql = mysqlAdmin('compare_test', config);
+    console.log('✅ mysqlAdmin实例创建成功');
+    
+    // 创建直接Mysql实例
+    const { Mysql } = require('../mm_mysql');
+    const direct_mysql = new Mysql(config);
+    console.log('✅ 直接Mysql实例创建成功');
+    
+    await testRunMethod(admin_mysql, direct_mysql);
+    compareInstanceType(admin_mysql, direct_mysql);
+    await checkCache(config, admin_mysql);
+    
+  } catch (error) {
+    console.log('❌ 实例创建失败:', error.message);
+  }
+}
+
+/**
+ * 测试mm_sql模块中的适配器行为
+ */
+async function checkSqlAdapter() {
+  console.log('\n=== 测试mm_sql模块中的适配器行为 ===');
+  
+  try {
+    const { Sql } = require('./index.js');
+    
+    // 创建mm_sql的MySQL实例
+    const mysql_sql = new Sql({
+      db_type: 'mysql',
+      dir: './db',
+      host: 'localhost',
+      user: 'root',
+      password: 'Asd159357',
+      database: 'mm'
+    });
+    
+    console.log('✅ mm_sql MySQL实例创建成功');
+    console.log('适配器类型:', mysql_sql._adapter?.constructor?.name);
+    
+    // 检查适配器是否与mysqlAdmin返回的实例相同
+    const admin_mysql = mysqlAdmin('mm_sql_test', {
+      host: 'localhost',
+      port: 3306,
+      user: 'root',
+      password: 'Asd159357',
+      database: 'mm'
+    });
+    
+    console.log('mm_sql适配器 === mysqlAdmin实例:', mysql_sql._adapter === admin_mysql);
+    console.log('mm_sql适配器类型 === mysqlAdmin实例类型:', mysql_sql._adapter?.constructor?.name === admin_mysql.constructor.name);
+    
+    // 测试mm_sql适配器的错误处理
+    console.log('\n测试mm_sql适配器的错误处理:');
+    try {
+      const result = await mysql_sql._adapter.run('SELECT * FROM non_existent_table_xyz');
+      console.log('  ❌ mm_sql适配器没有抛出错误，返回结果:', typeof result, Array.isArray(result) ? result.length : 'N/A');
+    } catch (error) {
+      console.log('  ✅ mm_sql适配器正确抛出错误:', error.message);
+    }
+    
+  } catch (error) {
+    console.log('❌ mm_sql实例创建失败:', error.message);
+  }
+}
+
+/**
+ * 主测试函数
+ */
+async function main() {
+  console.log('开始比较mysqlAdmin和直接Mysql实例的行为...\n');
+  
+  await compareAdminDirect();
+  await checkSqlAdapter();
+  
+  console.log('\n比较测试完成');
+}
+
+// 运行测试
+if (require.main === module) {
+  main().catch(console.error);
+}

package/compatibility_test.js

@@ -0,0 +1,320 @@
+const { Sql } = require('./index.js');
+
+/**
+ * MySQL和SQLite兼容性测试类
+ * @class SqlCompatibilityTest
+ */
+class SqlCompatTest {
+  /**
+   * 构造函数
+   */
+  constructor() {
+    this.passed = 0;
+    this.failed = 0;
+    this.total = 0;
+    this.mysqlSql = null;
+    this.sqliteSql = null;
+  }
+
+  /**
+   * 断言方法
+   * @param {boolean} cond - 断言条件
+   * @param {string} msg - 断言消息
+   */
+  assert(cond, msg) {
+    this.total++;
+    if (cond) {
+      this.passed++;
+      console.log(`✅ ${msg}`);
+    } else {
+      this.failed++;
+      console.log(`❌ ${msg}`);
+    }
+  }
+
+  /**
+   * 初始化MySQL和SQLite实例
+   * @returns {Promise<boolean>} 初始化是否成功
+   */
+  async init() {
+    try {
+      // 初始化MySQL实例
+      this.mysqlSql = new Sql({
+        db_type: 'mysql',
+        dir: './db',
+        host: 'localhost',
+        user: 'root',
+        password: 'Asd159357',
+        database: 'mm'
+      });
+
+      // 初始化SQLite实例
+      this.sqliteSql = new Sql({
+        db_type: 'sqlite',
+        dir: './db',
+        database: 'mm'
+      });
+
+      console.log('✅ MySQL和SQLite实例初始化成功');
+      return true;
+    } catch (error) {
+      console.error('❌ 初始化失败:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * 检查配置兼容性
+   */
+  checkConfigCompat() {
+    console.log('\n=== 测试配置方法兼容性 ===');
+    
+    // 测试setConfig方法
+    this.mysqlSql.setConfig({ size: 50 });
+    this.sqliteSql.setConfig({ size: 50 });
+    this.assert(this.mysqlSql.config.size === 50, 'MySQL setConfig方法正常');
+    this.assert(this.sqliteSql.config.size === 50, 'SQLite setConfig方法正常');
+
+    // 测试config属性访问
+    this.assert(typeof this.mysqlSql.config === 'object', 'MySQL config属性可访问');
+    this.assert(typeof this.sqliteSql.config === 'object', 'SQLite config属性可访问');
+  }
+
+  /**
+   * 检查SQL构建兼容性
+   */
+  checkSqlBuildCompat() {
+    console.log('\n=== 测试SQL构建方法兼容性 ===');
+    
+    const test_param = {
+      name: '测试用户',
+      age: 25
+    };
+    const test_tpl = {
+      name: "`name` like '%{0}%'",
+      age: '`age` = {0}'
+    };
+
+    // 测试tplQuery方法
+    const mysql_query = this.mysqlSql.tplQuery(test_param, test_tpl);
+    const sqlite_query = this.sqliteSql.tplQuery(test_param, test_tpl);
+    this.assert(typeof mysql_query === 'string', 'MySQL tplQuery方法返回字符串');
+    this.assert(typeof sqlite_query === 'string', 'SQLite tplQuery方法返回字符串');
+    this.assert(mysql_query === sqlite_query, 'MySQL和SQLite tplQuery结果一致');
+
+    // 测试tplBody方法
+    const mysql_body = this.mysqlSql.tplBody(test_param, test_tpl);
+    const sqlite_body = this.sqliteSql.tplBody(test_param, test_tpl);
+    this.assert(typeof mysql_body === 'string', 'MySQL tplBody方法返回字符串');
+    this.assert(typeof sqlite_body === 'string', 'SQLite tplBody方法返回字符串');
+    this.assert(mysql_body === sqlite_body, 'MySQL和SQLite tplBody结果一致');
+  }
+
+  /**
+   * 检查数据库操作兼容性
+   */
+  async checkDbOpCompat() {
+    console.log('\n=== 测试数据库操作兼容性 ===');
+    
+    const test_table = 'test_compatibility';
+    const create_sql = `CREATE TABLE IF NOT EXISTS ${test_table} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name VARCHAR(50) NOT NULL,
+      value INT DEFAULT 0
+    )`;
+
+    // 测试exec方法
+    try {
+      const mysql_exec = await this.mysqlSql.exec(create_sql);
+      const sqlite_exec = await this.sqliteSql.exec(create_sql);
+      this.assert(typeof mysql_exec === 'number', 'MySQL exec方法返回数字');
+      this.assert(typeof sqlite_exec === 'number', 'SQLite exec方法返回数字');
+    } catch {
+      console.log('⚠️  exec方法测试跳过（可能没有真实数据库连接）');
+    }
+
+    // 测试run方法（使用模拟数据）
+    try {
+      const select_sql = 'SELECT 1 as test_value';
+      const mysql_run = await this.mysqlSql.run(select_sql);
+      const sqlite_run = await this.sqliteSql.run(select_sql);
+      
+      // 检查返回类型
+      this.assert(Array.isArray(mysql_run) || mysql_run === null, 'MySQL run方法返回数组或null');
+      this.assert(Array.isArray(sqlite_run) || sqlite_run === null, 'SQLite run方法返回数组或null');
+    } catch {
+      console.log('⚠️  run方法测试跳过（可能没有真实数据库连接）');
+    }
+
+    // 清理测试表
+    try {
+      await this.mysqlSql.exec(`DROP TABLE IF EXISTS ${test_table}`);
+      await this.sqliteSql.exec(`DROP TABLE IF EXISTS ${test_table}`);
+    } catch {
+      // 忽略清理错误
+    }
+  }
+
+  /**
+   * 检查错误处理兼容性
+   */
+  async checkErrorCompat() {
+    console.log('\n=== 测试错误处理兼容性 ===');
+    
+    // 测试无效SQL（根据要求，run方法应该返回空数组而不是抛出错误）
+    try {
+      // 使用有效的SQL语法但无效的表名，确保通过参数验证
+      const mysql_rows = await this.mysqlSql.run('SELECT * FROM non_existent_table_xyz', []);
+      // 根据要求，run方法在错误时应该返回空数组[]
+      this.assert(Array.isArray(mysql_rows), 'MySQL run方法对无效SQL返回数组');
+      this.assert(mysql_rows.length === 0, 'MySQL run方法对无效SQL返回空数组');
+      
+      // 检查错误信息是否写入this.error
+      this.assert(this.mysqlSql.error !== null, 'MySQL错误信息写入this.error');
+      console.log('MySQL错误信息:', this.mysqlSql.error);
+    } catch (error) {
+      console.log('❌ MySQL run方法抛出了错误而不是返回空数组:', error.message);
+      this.assert(false, 'MySQL run方法应该返回空数组而不是抛出错误');
+    }
+
+    try {
+      // 使用有效的SQL语法但无效的表名，确保通过参数验证  
+      const sqlite_rows = await this.sqliteSql.run('SELECT * FROM non_existent_table_xyz', [], 30000);
+      // 根据要求，run方法在错误时应该返回空数组[]
+      this.assert(Array.isArray(sqlite_rows), 'SQLite run方法对无效SQL返回数组');
+      this.assert(sqlite_rows.length === 0, 'SQLite run方法对无效SQL返回空数组');
+      
+      // 检查错误信息是否写入this.error
+      this.assert(this.sqliteSql.error !== null, 'SQLite错误信息写入this.error');
+      console.log('SQLite错误信息:', this.sqliteSql.error);
+    } catch (error) {
+      console.log('❌ SQLite run方法抛出了错误而不是返回空数组:', error.message);
+      this.assert(false, 'SQLite run方法应该返回空数组而不是抛出错误');
+    }
+
+    // 测试参数验证
+    try {
+      await this.mysqlSql.run(123); // 无效参数类型
+      this.assert(false, 'MySQL应该对无效参数抛出TypeError');
+    } catch (error) {
+      this.assert(error instanceof TypeError, 'MySQL对无效参数正确抛出TypeError');
+    }
+
+    try {
+      await this.sqliteSql.run(123); // 无效参数类型
+      this.assert(false, 'SQLite应该对无效参数抛出TypeError');
+    } catch (error) {
+      this.assert(error instanceof TypeError, 'SQLite对无效参数正确抛出TypeError');
+    }
+  }
+
+  /**
+   * 适配器类型
+   * @returns {void}
+   */
+  type() {
+    const mysql_adapter_type = this.mysqlSql._adapter?.constructor?.name || 'Unknown';
+    const sqlite_adapter_type = this.sqliteSql._adapter?.constructor?.name || 'Unknown';
+    
+    this.assert(mysql_adapter_type === 'Mysql', 
+      `MySQL适配器类型正确: ${mysql_adapter_type}`);
+    this.assert(sqlite_adapter_type === 'SQLite', 
+      `SQLite适配器类型正确: ${sqlite_adapter_type}`);
+  }
+
+  /**
+   * 适配器方法
+   * @returns {void}
+   */
+  method() {
+    const mysql_has_run = typeof this.mysqlSql._adapter?.run === 'function';
+    const sqlite_has_run = typeof this.sqliteSql._adapter?.run === 'function';
+    const mysql_has_exec = typeof this.mysqlSql._adapter?.exec === 'function';
+    const sqlite_has_exec = typeof this.sqliteSql._adapter?.exec === 'function';
+
+    this.assert(mysql_has_run, 'MySQL适配器有run方法');
+    this.assert(sqlite_has_run, 'SQLite适配器有run方法');
+    this.assert(mysql_has_exec, 'MySQL适配器有exec方法');
+    this.assert(sqlite_has_exec, 'SQLite适配器有exec方法');
+  }
+
+  /**
+   * 适配器
+   * @returns {void}
+   */
+  adapter() {
+    console.log('\n=== 检查适配器切换 ===');
+    this.type();
+    this.method();
+  }
+
+  /**
+   * 运行所有兼容性测试
+   * @returns {Promise<void>}
+   */
+  async runAllTests() {
+    console.log('开始MySQL和SQLite兼容性测试...\n');
+
+    if (!await this.init()) {
+      console.log('❌ 初始化失败，跳过所有测试');
+      return;
+    }
+
+    try {
+      this.checkConfigCompat();
+      this.checkSqlBuildCompat();
+      await this.checkDbOpCompat();
+      await this.checkErrorCompat();
+      this.adapter();
+
+      console.log('\n=== 兼容性测试结果 ===');
+      console.log(`总计: ${this.total} 个测试`);
+      console.log(`通过: ${this.passed} 个`);
+      console.log(`失败: ${this.failed} 个`);
+      console.log(`成功率: ${((this.passed / this.total) * 100).toFixed(2)}%`);
+
+      if (this.failed === 0) {
+        console.log('\n🎉 MySQL和SQLite完全兼容！');
+      } else {
+        console.log('\n⚠️  存在兼容性问题，需要进一步检查');
+      }
+
+      return {
+        success: this.failed === 0,
+        passed: this.passed,
+        failed: this.failed,
+        total: this.total
+      };
+    } catch (error) {
+      console.error('测试执行过程中发生错误:', error);
+      return {
+        success: false,
+        passed: this.passed,
+        failed: this.failed,
+        total: this.total,
+        error: error.message
+      };
+    }
+  }
+}
+
+// 导出测试类
+module.exports = SqlCompatTest;
+
+// 如果直接运行此文件，则执行测试
+if (require.main === module) {
+  const test = new SqlCompatTest();
+  test.runAllTests().then(result => {
+    console.log('测试完成:', result);
+  }).catch(error => {
+    console.error('测试失败:', error);
+  });
+}
+
+// 如果直接运行此文件，则执行测试
+if (require.main === module) {
+  (async function() {
+    const test = new SqlCompatibilityTest();
+    await test.runAllTests();
+  })();
+}