mm_sql 1.4.1 → 1.4.2

package/comprehensive_test.js

@@ -0,0 +1,304 @@
+const { Sql } = require('./index.js');
+
+/**
+ * 全面测试Sql类
+ */
+class SqlTest {
+  constructor() {
+    console.log('全面测试Sql类开始...');
+    this.sql = null;
+    this.count = 0;
+    this.pass = 0;
+    this.fails = [];
+  }
+
+  /**
+   * 记录测试结果
+   * @param {string} name - 测试名称
+   * @param {boolean} result - 测试结果
+   * @param {string} error - 错误信息
+   */
+  _recordResult(name, result, error = '') {
+    this.count++;
+    if (result) {
+      this.pass++;
+      console.log(`✅ ${name} - 通过`);
+    } else {
+      this.fails.push({ name, error });
+      console.log(`❌ ${name} - 失败: ${error}`);
+    }
+  }
+
+  /**
+   * 初始化Sql实例
+   * @returns {Promise<boolean>} 初始化结果
+   */
+  async init() {
+    try {
+      this.sql = new Sql({
+        db_type: 'sqlite',
+        dir: './db',
+        host: 'localhost',
+        user: 'root',
+        password: 'Asd159357',
+        database: 'mm'
+      });
+      return true;
+    } catch (error) {
+      console.error('初始化失败:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * 测试构造函数和配置
+   */
+  testConfig() {
+    console.log('\n=== 测试构造函数和配置 ===');
+    
+    // 测试默认配置
+    try {
+      const default_sql = new Sql();
+      this._recordResult('默认构造函数', default_sql.config !== undefined);
+    } catch (error) {
+      this._recordResult('默认构造函数', false, error.message);
+    }
+
+    // 测试自定义配置
+    try {
+      const custom_sql = new Sql({ db_type: 'sqlite', database: 'test_db' });
+      const result = custom_sql.config.db_type === 'sqlite' && custom_sql.config.database === 'test_db';
+      this._recordResult('自定义配置', result);
+    } catch (error) {
+      this._recordResult('自定义配置', false, error.message);
+    }
+
+    // 测试setConfig方法
+    try {
+      this.sql.setConfig({ size: 100, timeout: 5000 });
+      const result = this.sql.config.size === 100 && this.sql.config.timeout === 5000;
+      this._recordResult('setConfig方法', result);
+    } catch (error) {
+      this._recordResult('setConfig方法', false, error.message);
+    }
+  }
+
+  /**
+   * 测试模板方法
+   */
+  testTpl() {
+    console.log('\n=== 测试模板查询方法 ===');
+    
+    // 测试tplQuery基本功能
+    try {
+      const param = { name: '张三', age: 25 };
+      const sql_tpl = { name: "`name` like '%{0}%'", age: '`age` = {0}' };
+      const result = this.sql.tplQuery(param, sql_tpl);
+      const expected = "`name` like '%张三%' AND `age` = 25";
+      this._recordResult('tplQuery基本功能', result === expected);
+    } catch (error) {
+      this._recordResult('tplQuery基本功能', false, error.message);
+    }
+
+    // 测试tplQuery空参数
+    try {
+      const result = this.sql.tplQuery({}, {});
+      this._recordResult('tplQuery空参数', result === '');
+    } catch (error) {
+      this._recordResult('tplQuery空参数', false, error.message);
+    }
+
+    // 测试tplBody基本功能
+    try {
+      const param = { name: '李四', email: 'lisi@example.com' };
+      const sql_tpl = { name: "`name` = '{0}'" };
+      const result = this.sql.tplBody(param, sql_tpl);
+      const expected = "`name` = '李四' , `email` = 'lisi@example.com'";
+      this._recordResult('tplBody基本功能', result === expected);
+    } catch (error) {
+      this._recordResult('tplBody基本功能', false, error.message);
+    }
+
+    // 测试filter方法
+    try {
+      const param = { name: '王五', age: 30, unused: 'test' };
+      const arr = ['name', 'age'];
+      const result = this.sql.filter(param, arr);
+      const expected = { name: '王五', age: 30 };
+      this._recordResult('filter方法', JSON.stringify(result) === JSON.stringify(expected));
+    } catch (error) {
+      this._recordResult('filter方法', false, error.message);
+    }
+  }
+
+  /**
+   * 测试连接方法
+   */
+  testConn() {
+    console.log('\n=== 测试数据库连接方法 ===');
+    
+    // 测试open方法
+    try {
+      const result = this.sql.open();
+      this._recordResult('open方法', result !== undefined);
+    } catch (error) {
+      this._recordResult('open方法', false, error.message);
+    }
+
+    // 测试close方法
+    try {
+      const result = this.sql.close();
+      this._recordResult('close方法', result !== undefined);
+    } catch (error) {
+      this._recordResult('close方法', false, error.message);
+    }
+
+    // 测试db方法
+    try {
+      const db = this.sql.db();
+      this._recordResult('db方法', db !== null && typeof db === 'object');
+    } catch (error) {
+      this._recordResult('db方法', false, error.message);
+    }
+  }
+
+  /**
+   * 测试执行方法
+   */
+  async testExec() {
+    console.log('\n=== 测试SQL执行方法 ===');
+    
+    // 测试run方法存在性
+    try {
+      const result = typeof this.sql.run === 'function';
+      this._recordResult('run方法存在性', result);
+    } catch (error) {
+      this._recordResult('run方法存在性', false, error.message);
+    }
+
+    // 测试exec方法存在性
+    try {
+      const result = typeof this.sql.exec === 'function';
+      this._recordResult('exec方法存在性', result);
+    } catch (error) {
+      this._recordResult('exec方法存在性', false, error.message);
+    }
+
+    // 测试数据库操作
+    try {
+      const db = this.sql.db();
+      if (db) {
+        // 创建测试表
+        await db.createTable('test_table', {
+          id: 1,
+          name: '',
+          value: 0
+        }, 'id');
+        
+        // 查询字段
+        const fields = await db.fields('test_table');
+        const has_fields = Array.isArray(fields) && fields.length > 0;
+        this._recordResult('数据库字段查询', has_fields);
+
+        // 设置表名并查询
+        const db_inst = db;
+        db_inst.table = 'test_table';
+        const result = await db_inst.get({ id: '1' });
+        this._recordResult('数据库查询操作', Array.isArray(result));
+      } else {
+        this._recordResult('数据库操作', false, 'db方法返回null');
+      }
+    } catch (error) {
+      this._recordResult('数据库操作', false, error.message);
+    }
+  }
+
+  /**
+   * 测试边界条件
+   */
+  testEdge() {
+    console.log('\n=== 测试边界条件和错误处理 ===');
+    
+    // 测试无效参数处理
+    try {
+      this.sql.tplQuery(null, {});
+      this._recordResult('tplQuery无效参数', false, '应该抛出异常');
+    } catch {
+      this._recordResult('tplQuery无效参数', true);
+    }
+
+    // 测试空模板
+    try {
+      const result = this.sql.tplQuery({ name: 'test' }, null);
+      this._recordResult('tplQuery空模板', result === "`name` = 'test'");
+    } catch (error) {
+      this._recordResult('tplQuery空模板', false, error.message);
+    }
+
+    // 测试filter空数组
+    try {
+      const result = this.sql.filter({ name: 'test', age: 20 }, []);
+      this._recordResult('filter空数组', JSON.stringify(result) === '{}');
+    } catch (error) {
+      this._recordResult('filter空数组', false, error.message);
+    }
+
+    // 测试filter不存在的字段
+    try {
+      const result = this.sql.filter({ name: 'test' }, ['name', 'nonexistent']);
+      const expected = { name: 'test' };
+      this._recordResult('filter不存在的字段', JSON.stringify(result) === JSON.stringify(expected));
+    } catch (error) {
+      this._recordResult('filter不存在的字段', false, error.message);
+    }
+  }
+
+  /**
+   * 运行所有测试
+   * @returns {Promise<boolean>} 测试结果
+   */
+  async runAll() {
+    if (!await this.init()) {
+      console.error('初始化失败，无法继续测试');
+      return false;
+    }
+
+    // 运行所有测试组
+    this.testConfig();
+    this.testTpl();
+    this.testConn();
+    await this.testExec();
+    this.testEdge();
+
+    // 输出测试总结
+    console.log('\n' + '='.repeat(50));
+    console.log('测试总结:');
+    console.log(`总测试数: ${this.count}`);
+    console.log(`通过数: ${this.pass}`);
+    console.log(`失败数: ${this.fails.length}`);
+    
+    if (this.fails.length > 0) {
+      console.log('\n失败的测试:');
+      this.fails.forEach(test => {
+        console.log(`  - ${test.name}: ${test.error}`);
+      });
+    }
+
+    const rate = (this.pass / this.count * 100).toFixed(2);
+    console.log(`\n测试通过率: ${rate}%`);
+
+    return this.fails.length === 0;
+  }
+}
+
+// 运行全面测试
+const test = new SqlTest();
+test.runAll().then(success => {
+  if (success) {
+    console.log('\n🎉 所有测试通过！');
+  } else {
+    console.log('\n⚠️ 部分测试失败，请检查代码');
+  }
+}).catch(error => {
+  console.error('测试执行出错:', error);
+});

package/debug_error_test.js

@@ -0,0 +1,127 @@
+const { Sql } = require('./index.js');
+
+/**
+ * 调试MySQL错误传播
+ */
+async function debugMysqlError() {
+  console.log('=== 调试MySQL错误传播 ===');
+  
+  try {
+    // 创建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);
+    
+    // 测试1: 直接调用适配器的run方法
+    console.log('\n测试1: 直接调用适配器run方法...');
+    try {
+      await mysql_sql._adapter.run('SELECT * FROM non_existent_table_xyz');
+      console.log('❌ 适配器应该对无效SQL抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ 适配器正确抛出错误:', error.message);
+    }
+    
+    // 测试2: 通过mm_sql的run方法调用
+    console.log('\n测试2: 通过mm_sql的run方法调用...');
+    try {
+      await mysql_sql.run('SELECT * FROM non_existent_table_xyz');
+      console.log('❌ mm_sql应该对无效SQL抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ mm_sql正确抛出错误:', error.message);
+    }
+    
+    // 测试3: 测试参数验证
+    console.log('\n测试3: 测试参数验证...');
+    try {
+      await mysqlSql.run(123); // 无效参数类型
+      console.log('❌ mm_sql应该对无效参数抛出TypeError，但没有抛出');
+    } catch (error) {
+      if (error instanceof TypeError) {
+        console.log('✅ mm_sql正确抛出TypeError:', error.message);
+      } else {
+        console.log('❌ mm_sql抛出错误但不是TypeError:', error.message);
+      }
+    }
+    
+  } catch (error) {
+    console.log('❌ mm_sql实例创建失败:', error.message);
+  }
+}
+
+/**
+ * 调试SQLite错误传播
+ */
+async function debugSqliteError() {
+  console.log('\n=== 调试SQLite错误传播 ===');
+  
+  try {
+    // 创建mm_sql的SQLite实例
+    const sqlite_sql = new Sql({
+      db_type: 'sqlite',
+      dir: './db',
+      database: 'mm'
+    });
+    
+    console.log('✅ mm_sql SQLite实例创建成功');
+    console.log('适配器类型:', sqlite_sql._adapter?.constructor?.name);
+    
+    // 测试1: 直接调用适配器的run方法
+    console.log('\n测试1: 直接调用适配器run方法...');
+    try {
+      await sqlite_sql._adapter.run('SELECT * FROM non_existent_table_xyz');
+      console.log('❌ 适配器应该对无效SQL抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ 适配器正确抛出错误:', error.message);
+    }
+    
+    // 测试2: 通过mm_sql的run方法调用
+    console.log('\n测试2: 通过mm_sql的run方法调用...');
+    try {
+      await sqlite_sql.run('SELECT * FROM non_existent_table_xyz');
+      console.log('❌ mm_sql应该对无效SQL抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ mm_sql正确抛出错误:', error.message);
+    }
+    
+    // 测试3: 测试参数验证
+    console.log('\n测试3: 测试参数验证...');
+    try {
+      await sqlite_sql.run(123); // 无效参数类型
+      console.log('❌ mm_sql应该对无效参数抛出TypeError，但没有抛出');
+    } catch (error) {
+      if (error instanceof TypeError) {
+        console.log('✅ mm_sql正确抛出TypeError:', error.message);
+      } else {
+        console.log('❌ mm_sql抛出错误但不是TypeError:', error.message);
+      }
+    }
+    
+  } catch (error) {
+    console.log('❌ mm_sql实例创建失败:', error.message);
+  }
+}
+
+/**
+ * 主测试函数
+ */
+async function main() {
+  console.log('开始调试mm_sql模块错误传播问题...\n');
+  
+  await debugMysqlError();
+  await debugSqliteError();
+  
+  console.log('\n调试完成');
+}
+
+// 运行测试
+if (require.main === module) {
+  main().catch(console.error);
+}

package/debug_test.js

@@ -0,0 +1,35 @@
+const { Sql } = require('./index.js');
+
+// 创建Sql实例
+const sql = new Sql({
+  db_type: 'sqlite',
+  dir: './db',
+  host: 'localhost',
+  user: 'root',
+  password: 'Asd159357',
+  database: 'mm'
+});
+
+console.log('=== 调试tplQuery基本功能 ===');
+const param = { name: '张三', age: 25 };
+const sql_tpl = { name: "`name` like '%{0}%'", age: '`age` = {0}' };
+const result = sql.tplQuery(param, sql_tpl);
+const expected = "`name` like '%张三%' AND `age` = 25";
+
+console.log('参数:', param);
+console.log('模板:', sql_tpl);
+console.log('实际输出:', result);
+console.log('期望输出:', expected);
+console.log('是否匹配:', result === expected);
+
+console.log('\n=== 调试tplBody基本功能 ===');
+const param_body = { name: '李四', email: 'lisi@example.com' };
+const sql_tpl_body = { name: '`name` = {0}' };
+const res_body = sql.tplBody(param_body, sql_tpl_body);
+const exp_body = "`name` = '李四' , `email` = 'lisi@example.com'";
+
+console.log('参数:', param_body);
+console.log('模板:', sql_tpl_body);
+console.log('实际输出:', res_body);
+console.log('期望输出:', exp_body);
+console.log('是否匹配:', res_body === exp_body);

package/debug_test2.js

@@ -0,0 +1,45 @@
+const { Sql } = require('./index.js');
+
+// 创建Sql实例
+const sql = new Sql({
+  db_type: 'sqlite',
+  dir: './db',
+  host: 'localhost',
+  user: 'root',
+  password: 'Asd159357',
+  database: 'mm'
+});
+
+console.log('=== 详细调试tplQuery基本功能 ===');
+const param = { name: '张三', age: 25 };
+const sql_tpl = { name: "`name` like '%{0}%'", age: '`age` = {0}' };
+const result = sql.tplQuery(param, sql_tpl);
+const expected = "`name` like '%张三%' AND `age` = 25";
+
+console.log('实际输出长度:', result.length);
+console.log('期望输出长度:', expected.length);
+console.log('实际输出字符:');
+for (let i = 0; i < result.length; i++) {
+  console.log(`  ${i}: '${result[i]}' (${result.charCodeAt(i)})`);
+}
+console.log('期望输出字符:');
+for (let i = 0; i < expected.length; i++) {
+  console.log(`  ${i}: '${expected[i]}' (${expected.charCodeAt(i)})`);
+}
+
+console.log('\n=== 详细调试tplBody基本功能 ===');
+const param_body = { name: '李四', email: 'lisi@example.com' };
+const sql_tpl_body = { name: '`name` = {0}' };
+const res_body = sql.tplBody(param_body, sql_tpl_body);
+const exp_body = "`name` = '李四' , `email` = 'lisi@example.com'";
+
+console.log('实际输出长度:', res_body.length);
+console.log('期望输出长度:', exp_body.length);
+console.log('实际输出字符:');
+for (let i = 0; i < res_body.length; i++) {
+  console.log(`  ${i}: '${res_body[i]}' (${res_body.charCodeAt(i)})`);
+}
+console.log('期望输出字符:');
+for (let i = 0; i < exp_body.length; i++) {
+  console.log(`  ${i}: '${exp_body[i]}' (${exp_body.charCodeAt(i)})`);
+}

package/debug_test3.js

@@ -0,0 +1,54 @@
+// 模板替换调试
+
+console.log('=== 详细调试tplBody模板替换 ===');
+const param = { name: '李四', email: 'lisi@example.com' };
+const sql_tpl = { name: '`name` = {0}' };
+
+console.log('参数:', param);
+console.log('模板:', sql_tpl);
+
+// 手动模拟模板替换
+const template = sql_tpl || {};
+const segments = [];
+
+for (const key in param) {
+  if (template[key]) {
+    // 替换占位符{0}为参数值
+    const seg = template[key].replace(/\{0\}/g, param[key]);
+    console.log(`模板替换 ${key}: "${template[key]}" -> "${seg}"`);
+    segments.push(seg);
+  }
+  else {
+    const seg = '`' + key + "` = '" + param[key] + "'";
+    console.log(`默认处理 ${key}: "${seg}"`);
+    segments.push(seg);
+  }
+}
+
+const result = segments.join(' , ');
+console.log('最终结果:', result);
+
+// 期望的结果应该是：`name` = '李四' , `email` = 'lisi@example.com'
+// 但实际是：`name` = 李四 , `email` = 'lisi@example.com'
+// 问题在于模板替换时没有添加单引号
+
+console.log('\n=== 修复方案 ===');
+// 正确的模板应该包含单引号
+const right_tpl = { name: "`name` = '{0}'" };
+const right_seg = [];
+
+for (const key in param) {
+  if (right_tpl[key]) {
+    const seg = right_tpl[key].replace(/\{0\}/g, param[key]);
+    console.log(`正确模板替换 ${key}: "${right_tpl[key]}" -> "${seg}"`);
+    right_seg.push(seg);
+  }
+  else {
+    const seg = '`' + key + "` = '" + param[key] + "'";
+    console.log(`默认处理 ${key}: "${seg}"`);
+    right_seg.push(seg);
+  }
+}
+
+const right_res = right_seg.join(' , ');
+console.log('正确结果:', right_res);

package/detailed_error_test.js

@@ -0,0 +1,133 @@
+const { mysqlAdmin } = require('../mm_mysql');
+
+/**
+ * 详细测试MySQL错误处理
+ */
+async function mysqlErrorTest() {
+  console.log('=== 详细测试MySQL错误处理 ===');
+  
+  try {
+    // 创建mysqlAdmin实例
+    const mysql = mysqlAdmin('detailed_test', {
+      host: 'localhost',
+      port: 3306,
+      user: 'root',
+      password: 'Asd159357',
+      database: 'mm'
+    });
+    
+    console.log('✅ MySQL实例创建成功');
+    
+    // 测试1: 语法错误的SQL
+    console.log('\n测试1: 语法错误的SQL...');
+    try {
+      await mysql.run('SELECT * FROM'); // 语法错误
+      console.log('❌ MySQL应该对语法错误SQL抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ MySQL正确抛出语法错误:', error.message);
+    }
+    
+    // 测试2: 不存在的表（语法正确但表不存在）
+    console.log('\n测试2: 不存在的表...');
+    try {
+      const result = await mysql.run('SELECT * FROM non_existent_table_xyz');
+      console.log('MySQL返回结果:', result);
+      console.log('结果类型:', typeof result);
+      console.log('结果长度:', Array.isArray(result) ? result.length : 'N/A');
+      
+      if (Array.isArray(result) && result.length === 0) {
+        console.log('⚠️ MySQL对不存在的表返回空数组而不是抛出错误');
+      } else {
+        console.log('❌ MySQL应该对不存在的表抛出错误，但没有抛出');
+      }
+    } catch (error) {
+      console.log('✅ MySQL正确抛出表不存在错误:', error.message);
+    }
+    
+    // 测试3: 不存在的数据库
+    console.log('\n测试3: 不存在的数据库...');
+    try {
+      await mysql.run('SELECT * FROM non_existent_db.non_existent_table');
+      console.log('❌ MySQL应该对不存在的数据库抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ MySQL正确抛出数据库不存在错误:', error.message);
+    }
+    
+    // 测试4: 权限错误
+    console.log('\n测试4: 权限错误...');
+    try {
+      await mysql.run('DROP TABLE IF EXISTS important_system_table');
+      console.log('❌ MySQL应该对权限错误抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ MySQL正确抛出权限错误:', error.message);
+    }
+    
+  } catch (error) {
+    console.log('❌ MySQL实例创建失败:', error.message);
+  }
+}
+
+/**
+ * 测试SQLite错误处理
+ */
+async function sqliteErrorTest() {
+  console.log('\n=== 详细测试SQLite错误处理 ===');
+  
+  try {
+    const { sqliteAdmin } = require('../mm_sqlite');
+    
+    // 创建sqliteAdmin实例
+    const sqlite = sqliteAdmin('detailed_test', {
+      dir: './db',
+      database: 'mm'
+    });
+    
+    console.log('✅ SQLite实例创建成功');
+    
+    // 测试1: 语法错误的SQL
+    console.log('\n测试1: 语法错误的SQL...');
+    try {
+      await sqlite.run('SELECT * FROM'); // 语法错误
+      console.log('❌ SQLite应该对语法错误SQL抛出错误，但没有抛出');
+    } catch (error) {
+      console.log('✅ SQLite正确抛出语法错误:', error.message);
+    }
+    
+    // 测试2: 不存在的表（语法正确但表不存在）
+    console.log('\n测试2: 不存在的表...');
+    try {
+      const result = await sqlite.run('SELECT * FROM non_existent_table_xyz');
+      console.log('SQLite返回结果:', result);
+      console.log('结果类型:', typeof result);
+      console.log('结果长度:', Array.isArray(result) ? result.length : 'N/A');
+      
+      if (Array.isArray(result) && result.length === 0) {
+        console.log('⚠️ SQLite对不存在的表返回空数组而不是抛出错误');
+      } else {
+        console.log('❌ SQLite应该对不存在的表抛出错误，但没有抛出');
+      }
+    } catch (error) {
+      console.log('✅ SQLite正确抛出表不存在错误:', error.message);
+    }
+    
+  } catch (error) {
+    console.log('❌ SQLite实例创建失败:', error.message);
+  }
+}
+
+/**
+ * 主测试函数
+ */
+async function main() {
+  console.log('开始详细测试数据库错误处理...\n');
+  
+  await detailedMysqlErrorTest();
+  await detailedSqliteErrorTest();
+  
+  console.log('\n详细测试完成');
+}
+
+// 运行测试
+if (require.main === module) {
+  main().catch(console.error);
+}