mm_mysql 2.2.9 → 2.3.0

package/index.js

@@ -10,12 +10,7 @@ const { DB } = require('./db');
  */
 class Mysql extends Base {
   /**
-   * 默认配置
-   * MySQL2支持的连接池配置参数：
-   * - host, port, user, password, database
-   * - charset, timezone, connect_timeout
-   * - connection_limit, acquire_timeout, wait_for_connections
-   * - queueLimit参数在MySQL2中可能不被支持，已移除
+   * 默认配置（优化版，统一使用连接池）
    */
   static config = {
     host: '127.0.0.1',
@@ -25,28 +20,154 @@ class Mysql extends Base {
     database: '',
     charset: 'utf8mb4',
     timezone: '+08:00',
-    connect_timeout: 20000,
-    connection_limit: 500,
-    acquire_timeout: 20000,
-    wait_for_connections: true
+    connect_timeout: 15000,
+    
+    // 连接池优化配置（针对高并发写入场景）
+    connection_limit: 100,           // 减少连接数，避免资源竞争
+    acquire_timeout: 30000,          // 延长获取连接超时时间
+    wait_for_connections: true,      // 保持连接等待机制
+    idle_timeout: 300000,            // 延长空闲连接超时时间(5分钟)
+    max_idle: 30,                    // 减少最大空闲连接数
+    queue_timeout: 60000,            // 队列超时时间
+    
+    // 预处理语句缓存优化配置
+    statement_cache_size: 50,        // 减少缓存大小，避免内存泄漏
+    max_prepared_statement_age: 300000, // 延长过期时间(5分钟)
+    enable_statement_pooling: true   // 启用预处理语句缓存
   };
 
   /**
-   * 构造函数
+   * 构造函数（统一使用连接池）
    * @param {object} config - 配置对象
    */
   constructor(config = {}) {
     super({ ...Mysql.config, ...config});
     this._pool = null;
-    this._connection = null;
-    this._usePool = this.config.connection_limit > 1;
+    // 移除单连接支持，统一使用连接池
+    this._use_pool = true; // 强制使用连接池模式
+    
     // 错误信息
     this.error = null;
     // 最近执行的SQL语句
     this.sql = '';
+    
+    // 预处理语句缓存
+    this._prepared_stmts = new Map();
+    this._stmt_cache_size = this.config.statement_cache_size || 100;
+    this._cache_hits = 0;
+    this._cache_misses = 0;
+    
+    // 启动定期清理任务
+    this._startCleanupTask();
   }
 }
 
+/**
+ * 启动预处理语句清理任务
+ * @private
+ */
+Mysql.prototype._startCleanupTask = function() {
+  if (this._cleanup_interval) {
+    clearInterval(this._cleanup_interval);
+  }
+  
+  this._cleanup_interval = setInterval(() => {
+    this._cleanupExpiredStatements();
+  }, 60000); // 每分钟清理一次
+};
+
+/**
+ * 清理过期预处理语句
+ * @private
+ */
+Mysql.prototype._cleanupExpiredStatements = function() {
+  const now = Date.now();
+  const max_age = this.config.max_prepared_statement_age || 300000;
+  
+  for (const [key, statement_info] of this._prepared_stmts) {
+    if (now - statement_info.last_used > max_age) {
+      // 异步关闭语句，不阻塞主线程
+      if (statement_info.statement && typeof statement_info.statement.close === 'function') {
+        statement_info.statement.close().catch(() => {});
+      }
+      this._prepared_stmts.delete(key);
+    }
+  }
+};
+
+/**
+ * 生成预处理语句缓存键
+ * @private
+ * @param {string} sql - SQL语句
+ * @returns {string} 缓存键
+ */
+Mysql.prototype._getStatementCacheKey = function(sql) {
+  // 简化SQL语句，移除多余空格和换行，提高缓存命中率
+  return sql.trim().replace(/\s+/g, ' ').toLowerCase();
+};
+
+/**
+ * 缓存预处理语句
+ * @private
+ * @param {string} key - 缓存键
+ * @param {object} statement - 预处理语句对象
+ */
+Mysql.prototype._cacheStatement = function(key, statement) {
+  if (this._prepared_stmts.size >= this._stmt_cache_size) {
+    // 移除最久未使用的语句
+    const oldest_key = this._findOldestStatement();
+    if (oldest_key) {
+      const oldest_statement = this._prepared_stmts.get(oldest_key);
+      if (oldest_statement.statement && typeof oldest_statement.statement.close === 'function') {
+        oldest_statement.statement.close().catch(() => {});
+      }
+      this._prepared_stmts.delete(oldest_key);
+    }
+  }
+  
+  this._prepared_stmts.set(key, {
+    statement: statement,
+    last_used: Date.now(),
+    use_count: 0
+  });
+};
+
+/**
+ * 查找最久未使用的预处理语句
+ * @private
+ * @returns {string} 缓存键
+ */
+Mysql.prototype._findOldestStatement = function() {
+  let oldest_key = null;
+  let oldest_time = Date.now();
+  
+  for (const [key, statement_info] of this._prepared_stmts) {
+    if (statement_info.last_used < oldest_time) {
+      oldest_time = statement_info.last_used;
+      oldest_key = key;
+    }
+  }
+  
+  return oldest_key;
+};
+
+/**
+ * 获取预处理语句缓存统计信息
+ * @returns {object} 统计信息
+ */
+Mysql.prototype.getStatementStats = function() {
+  const total = this._cache_hits + this._cache_misses;
+  const hit_rate = total > 0 ? (this._cache_hits / total) * 100 : 0;
+  
+  return {
+    cached_statements: this._prepared_stmts.size,
+    cache_hits: this._cache_hits,
+    cache_misses: this._cache_misses,
+    cache_hit_rate: hit_rate.toFixed(2) + '%',
+    max_cache_size: this._stmt_cache_size
+  };
+};
+
 /**
  * 获取MySQL2支持的配置参数
  * 根据连接类型（连接池或单连接）过滤参数，避免警告
@@ -105,59 +226,58 @@ Mysql.prototype._getValidConfig = function (is_pool = false) {
 };
 
 /**
- * 打开数据库连接
- * @returns {Promise<boolean>}
- * @throws {TypeError} 当配置参数无效时
- */
-Mysql.prototype.open = async function () {
-  // 参数校验
-  if (!this.config || typeof this.config !== 'object') {
-    throw new TypeError('config must be object');
-  }
+   * 打开数据库连接（统一使用连接池）
+   * @returns {Promise<boolean>}
+   * @throws {TypeError} 当配置参数无效时
+   */
+  Mysql.prototype.open = async function () {
+    // 参数校验
+    if (!this.config || typeof this.config !== 'object') {
+      throw new TypeError('config must be object');
+    }
 
-  try {
-    if (this._usePool) {
-      // 根据连接类型获取对应的配置参数
-      const valid_config = this._getValidConfig(this._usePool);
+    try {
+      // 统一使用连接池模式
+      const valid_config = this._getValidConfig(true);
       this._pool = mysql.createPool(valid_config);
+      
       // 测试连接池连接
       const conn = await this._pool.getConnection();
       conn.release();
-    } else {
-      const valid_config = this._getValidConfig(this._usePool);
-      this._connection = await mysql.createConnection(valid_config);
-    }
 
-    this.log('info', '数据库连接成功');
-    return true;
-  } catch (error) {
-    this.log('error', '数据库连接失败', error);
-    return false;
-  }
-};
+      this.log('info', '数据库连接池创建成功');
+      return true;
+    } catch (error) {
+      this.log('error', '数据库连接池创建失败', error);
+      return false;
+    }
+  };
 
 /**
- * 关闭数据库连接
- * @returns {Promise<boolean>}
- */
-Mysql.prototype.close = async function () {
-  try {
-    if (this._pool) {
-      await this._pool.end();
-      this._pool = null;
-    }
-    if (this._connection) {
-      await this._connection.end();
-      this._connection = null;
-    }
+   * 关闭数据库连接（统一使用连接池）
+   * @returns {Promise<boolean>}
+   */
+  Mysql.prototype.close = async function () {
+    try {
+      // 先关闭连接池，再清理预处理语句（避免连接状态问题）
+      if (this._pool) {
+        await this._pool.end();
+        this._pool = null;
+      }
+      
+      // 连接池关闭后，预处理语句会自动失效，只需清理缓存
+      if (this._prepared_stmts) {
+        // 不再尝试关闭预处理语句，直接清空缓存
+        this._prepared_stmts.clear();
+      }
 
-    this.log('info', '数据库连接已关闭');
-    return true;
-  } catch (error) {
-    this.log('error', '关闭连接失败', error);
-    return false;
-  }
-};
+      this.log('info', '数据库连接池已关闭');
+      return true;
+    } catch (error) {
+      this.log('error', '关闭连接池失败', error);
+      return false;
+    }
+  };
 
 /**
  * 安全释放数据库连接
@@ -178,31 +298,28 @@ async function safeReleaseConnection(conn, is_pool_conn) {
 };
 
 /**
- * 获取数据库连接（改进版）
- * @returns {Promise<object>}
- * @throws {TypeError} 当连接池或连接不存在时
- */
-Mysql.prototype.getConn = async function () {
-  // 参数校验
-  if (!this._pool && !this._connection) {
-    await this.open();
-  }
+   * 获取数据库连接（统一使用连接池）
+   * @returns {Promise<object>}
+   * @throws {TypeError} 当连接池不存在时
+   */
+  Mysql.prototype.getConn = async function () {
+    // 参数校验
+    if (!this._pool) {
+      await this.open();
+    }
 
-  try {
-    if (this._usePool) {
+    try {
+      // 统一从连接池获取连接
       const conn = await this._pool.getConnection();
       return conn;
-    } else {
-      return this._connection;
+    } catch (error) {
+      this.log('error', '从连接池获取连接失败', error);
+      throw error; // 重新抛出错误，让调用方处理
     }
-  } catch (error) {
-    this.log('error', '获取连接失败', error);
-  }
-  return null;
-};
+  };
 
 /**
- * 执行SQL查询（改进版）
+ * 执行SQL查询（优化版，支持预处理语句缓存）
  * @param {string} sql - SQL语句
  * @param {Array} params - 参数数组
  * @returns {Promise<object>}
@@ -225,11 +342,64 @@ Mysql.prototype.run = async function (sql, params = []) {
   try {
     // 获取连接
     conn = await this.getConn();
-    is_pool_conn = this._usePool;
-
-    // 直接使用mysql2的query方法
-    const [rows] = await conn.query(sql, params);
-    return rows;
+    is_pool_conn = this._use_pool;
+
+    // 检查是否启用预处理语句缓存
+    if (this.config.enable_statement_pooling && params.length > 0) {
+      const cache_key = this._getStatementCacheKey(sql);
+      let statement_info = this._prepared_stmts.get(cache_key);
+      
+      if (statement_info && statement_info.statement) {
+        // 使用缓存的预处理语句
+        this._cache_hits++;
+        statement_info.last_used = Date.now();
+        statement_info.use_count++;
+        
+        // 预先检查连接状态，避免不必要的错误
+        if (!conn || conn._fatalError || conn._closed) {
+          conn = await this.getConn();
+          // 连接已更新，需要重新创建预处理语句
+          this._prepared_stmts.delete(cache_key);
+          const statement = await conn.prepare(sql);
+          this._cacheStatement(cache_key, statement);
+          const [rows] = await statement.execute(params);
+          return rows;
+        }
+        
+        try {
+          const [rows] = await statement_info.statement.execute(params);
+          return rows;
+        } catch (stmt_err) {
+          // 预处理语句可能已失效（连接关闭等），重新创建
+          this.log('warn', '预处理语句执行失败，重新创建', stmt_err);
+          this._prepared_stmts.delete(cache_key);
+          
+          // 检查连接是否有效，如果无效则重新获取连接
+          if (!conn || conn._fatalError || conn._closed) {
+            conn = await this.getConn();
+          }
+          
+          // 重新创建预处理语句
+          const statement = await conn.prepare(sql);
+          this._cacheStatement(cache_key, statement);
+          
+          const [rows] = await statement.execute(params);
+          return rows;
+        }
+      } else {
+        // 创建新的预处理语句并缓存
+        this._cache_misses++;
+        const statement = await conn.prepare(sql);
+        this._cacheStatement(cache_key, statement);
+        
+        const [rows] = await statement.execute(params);
+        return rows;
+      }
+    } else {
+      // 不使用预处理语句缓存，直接查询
+      const [rows] = await conn.query(sql, params);
+      return rows;
+    }
   } catch (err) {
     this.sql = err.sql;
     this.error = {
@@ -243,6 +413,9 @@ Mysql.prototype.run = async function (sql, params = []) {
       this.log('error', '释放连接失败', release_err);
     }
     connection_released = true;
+    
+    // 重新抛出错误，让调用方处理
+    throw err;
   } finally {
     // 确保连接被释放，避免资源泄漏
     if (!connection_released) {
@@ -257,7 +430,7 @@ Mysql.prototype.run = async function (sql, params = []) {
 };
 
 /**
- * 执行SQL语句（改进版）
+ * 执行SQL语句（优化版，支持预处理语句缓存）
  * @param {string} sql - SQL语句
  * @param {Array} params - 参数数组
  * @returns {Promise<object>}
@@ -279,11 +452,64 @@ Mysql.prototype.exec = async function (sql, params = []) {
   try {
     // 获取连接
     conn = await this.getConn();
-    is_pool_conn = this._usePool;
-
-    // 直接使用mysql2的execute方法
-    const [result] = await conn.execute(sql, params);
-    return result.insertId || result.affectedRows || result.changedRows || 1;
+    is_pool_conn = this._use_pool;
+
+    // 检查是否启用预处理语句缓存
+    if (this.config.enable_statement_pooling && params.length > 0) {
+      const cache_key = this._getStatementCacheKey(sql);
+      let statement_info = this._prepared_stmts.get(cache_key);
+      
+      if (statement_info && statement_info.statement) {
+        // 使用缓存的预处理语句
+        this._cache_hits++;
+        statement_info.last_used = Date.now();
+        statement_info.use_count++;
+        
+        // 预先检查连接状态，避免不必要的错误
+        if (!conn || conn._fatalError || conn._closed) {
+          conn = await this.getConn();
+          // 连接已更新，需要重新创建预处理语句
+          this._prepared_stmts.delete(cache_key);
+          const statement = await conn.prepare(sql);
+          this._cacheStatement(cache_key, statement);
+          const [result] = await statement.execute(params);
+          return result.insertId || result.affectedRows || result.changedRows || 1;
+        }
+        
+        try {
+          const [result] = await statement_info.statement.execute(params);
+          return result.insertId || result.affectedRows || result.changedRows || 1;
+        } catch (stmt_err) {
+          // 预处理语句可能已失效（连接关闭等），重新创建
+          this.log('warn', '预处理语句执行失败，重新创建', stmt_err);
+          this._prepared_stmts.delete(cache_key);
+          
+          // 检查连接是否有效，如果无效则重新获取连接
+          if (!conn || conn._fatalError || conn._closed) {
+            conn = await this.getConn();
+          }
+          
+          // 重新创建预处理语句
+          const statement = await conn.prepare(sql);
+          this._cacheStatement(cache_key, statement);
+          
+          const [result] = await statement.execute(params);
+          return result.insertId || result.affectedRows || result.changedRows || 1;
+        }
+      } else {
+        // 创建新的预处理语句并缓存
+        this._cache_misses++;
+        const statement = await conn.prepare(sql);
+        this._cacheStatement(cache_key, statement);
+        
+        const [result] = await statement.execute(params);
+        return result.insertId || result.affectedRows || result.changedRows || 1;
+      }
+    } else {
+        // 对于写入语句，直接执行（不使用预处理语句缓存）
+        const [result] = await conn.execute(sql, params);
+        return result.insertId || result.affectedRows || result.changedRows || 1;
+      }
   } catch (error) {
     this.log('error', 'SQL执行失败', error);
     this.sql = error.sql;
@@ -298,6 +524,9 @@ Mysql.prototype.exec = async function (sql, params = []) {
       this.log('error', '释放连接失败', release_err);
     }
     connection_released = true;
+    
+    // 重新抛出错误，让调用方处理
+    throw error;
   } finally {
     // 确保连接被释放，避免资源泄漏
     if (!connection_released) {

package/package.json

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

package/test_backup.js

@@ -1,101 +0,0 @@
-/**
- * @fileOverview 备份恢复功能测试脚本
- * @version 1.0
- */
-
-const {Sql} = require('./sql');
-
-
-// 模拟数据库操作函数
-async function mockRun(sql) {
-  console.log('执行查询SQL:', sql);
-  
-  // 模拟返回数据
-  if (sql.includes('SELECT')) {
-    return [
-      { id: 1, name: '张三', age: 25 },
-      { id: 2, name: '李四', age: 30 },
-      { id: 3, name: '王五', age: 28 }
-    ];
-  }
-  
-  if (sql.includes('count')) {
-    return [{ count: 3 }];
-  }
-  
-  // 模拟SHOW CREATE TABLE查询
-  if (sql.includes('SHOW CREATE TABLE')) {
-    return [{
-      'Create Table': 'CREATE TABLE `test_table` (\n  `id` int(11) NOT NULL AUTO_INCREMENT,\n  `name` varchar(50) NOT NULL,\n  `age` int(11) DEFAULT NULL,\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4'
-    }];
-  }
-  
-  return [];
-}
-
-async function mockExec(sql) {
-  console.log('执行更新SQL:', sql);
-  return { affectedRows: 1, insertId: 1 };
-}
-
-async function testBackupRestore() {
-  console.log('=== 测试MySQL备份恢复功能 ===');
-  
-  // 创建 SQL 实例
-  const sql = new Sql(mockRun, mockExec);
-  sql.table = 'test_table';
-  
-  const backupFile1 = './backup/test_mysql_backup1.sql';
-  const backupFile2 = './backup/test_mysql_backup2.sql';
-  
-  try {
-    // 测试不带创建表语句的备份
-    console.log('\n1. 测试不带创建表语句的备份...');
-    const backupResult1 = await sql.backup(backupFile1);
-    console.log('备份结果:', backupResult1 ? '成功' : '失败');
-    
-    if (backupResult1) {
-      // 读取备份文件内容
-      const fs = require('fs');
-      if (fs.existsSync(backupFile1)) {
-        const content = fs.readFileSync(backupFile1, 'utf8');
-        console.log('备份文件内容:');
-        console.log(content);
-      }
-    }
-    
-    // 测试带创建表语句的备份
-    console.log('\n2. 测试带创建表语句的备份...');
-    const backupResult2 = await sql.backup(backupFile2, true);
-    console.log('备份结果:', backupResult2 ? '成功' : '失败');
-    
-    if (backupResult2) {
-      // 读取备份文件内容
-      const fs = require('fs');
-      if (fs.existsSync(backupFile2)) {
-        const content = fs.readFileSync(backupFile2, 'utf8');
-        console.log('备份文件内容:');
-        console.log(content);
-      }
-    }
-    
-    // 测试恢复
-    console.log('\n3. 测试恢复功能...');
-    const restoreResult = await sql.restore(backupFile2);
-    console.log('恢复结果:', restoreResult ? '成功' : '失败');
-    
-    console.log('\n=== 测试完成 ===');
-    
-  } catch (error) {
-    console.error('测试出错:', error.message);
-  }
-}
-
-// 运行测试
-if (require.main === module) {
-  testBackupRestore();
-}
-
-module.exports = {
-  testBackupRestore
-};

package/test_backup_with_comments.js

@@ -1,97 +0,0 @@
-const { Sql } = require('./sql');
-
-// 创建模拟的数据库操作函数，包含注释信息
-const mockRun = function(sql) {
-  console.log('执行查询SQL:', sql);
-  
-  // 模拟查询结果
-  if (sql.includes('SHOW CREATE TABLE')) {
-    return [{
-      'Create Table': `CREATE TABLE \`test_table\` (
-  \`id\` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
-  \`name\` varchar(50) NOT NULL COMMENT '用户姓名',
-  \`age\` int(11) DEFAULT NULL COMMENT '用户年龄',
-  PRIMARY KEY (\`id\`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='测试用户表'`
-    }];
-  }
-  
-  // 模拟表注释查询
-  if (sql.includes('information_schema.TABLES')) {
-    return [{
-      TABLE_COMMENT: '测试用户表'
-    }];
-  }
-  
-  // 模拟列注释查询
-  if (sql.includes('information_schema.COLUMNS')) {
-    return [
-      { COLUMN_NAME: 'id', COLUMN_COMMENT: '主键ID' },
-      { COLUMN_NAME: 'name', COLUMN_COMMENT: '用户姓名' },
-      { COLUMN_NAME: 'age', COLUMN_COMMENT: '用户年龄' }
-    ];
-  }
-  
-  // 模拟数据查询
-  if (sql.includes('SELECT * FROM')) {
-    return [
-      { id: 1, name: '张三', age: 25 },
-      { id: 2, name: '李四', age: 30 },
-      { id: 3, name: '王五', age: 28 }
-    ];
-  }
-  
-  return [];
-};
-
-const mockExec = function(sql) {
-  console.log('执行更新SQL:', sql);
-  return { affectedRows: 1 };
-};
-
-async function testBackupWithComments() {
-  console.log('=== 测试MySQL备份恢复功能（包含注释） ===');
-  
-  // 创建 SQL 实例
-  const sql = new Sql(mockRun, mockExec);
-  sql.table = 'test_table';
-  
-  const backupFile = './backup/test_mysql_backup_with_comments.sql';
-  
-  try {
-    // 测试带创建表语句和注释的备份
-    console.log('\n1. 测试带创建表语句和注释的备份...');
-    const backupResult = await sql.backup(backupFile, true);
-    console.log('备份结果:', backupResult ? '成功' : '失败');
-    
-    if (backupResult) {
-      // 读取备份文件内容
-      const fs = require('fs');
-      if (fs.existsSync(backupFile)) {
-        const content = fs.readFileSync(backupFile, 'utf8');
-        console.log('备份文件内容:');
-        console.log(content);
-        
-        // 检查是否包含注释信息
-        if (content.includes("COMMENT '主键ID'") && content.includes("COMMENT '用户姓名'") && 
-            content.includes("COMMENT '用户年龄'") && content.includes("COMMENT='测试用户表'")) {
-          console.log('✅ 备份文件成功包含注释信息');
-        } else {
-          console.log('❌ 备份文件未包含注释信息');
-        }
-      }
-    }
-    
-    // 测试恢复功能
-    console.log('\n2. 测试恢复功能...');
-    const restoreResult = await sql.restore(backupFile);
-    console.log('恢复结果:', restoreResult ? '成功' : '失败');
-    
-    console.log('\n=== 测试完成 ===');
-    
-  } catch (error) {
-    console.error('测试出错:', error.message);
-  }
-}
-
-testBackupWithComments().catch(console.error);

package/test_parser.js

@@ -1,76 +0,0 @@
-const { Sql } = require('./sql');
-
-// 创建模拟的数据库操作函数
-const mockRun = function(sql) {
-  console.log('执行查询SQL:', sql);
-  // 模拟查询结果
-  if (sql.includes('SHOW CREATE TABLE')) {
-    return [{
-      'Create Table': `CREATE TABLE \`test_table\` (
-  \`id\` int(11) NOT NULL AUTO_INCREMENT,
-  \`name\` varchar(50) NOT NULL,
-  \`age\` int(11) DEFAULT NULL,
-  PRIMARY KEY (\`id\`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`
-    }];
-  }
-  return [];
-};
-
-const mockExec = function(sql) {
-  console.log('执行更新SQL:', sql);
-  return { affectedRows: 1 };
-};
-
-async function testSqlParser() {
-  console.log('=== 测试SQL解析器注释处理功能 ===');
-  
-  // 创建 SQL 实例
-  const sql = new Sql(mockRun, mockExec);
-  
-  // 测试包含各种注释的SQL内容
-  const testSql = `
--- 这是一个单行注释
-/* 这是一个多行注释
-   可以跨多行 */
-CREATE TABLE IF NOT EXISTS \`test_table\` (
-  \`id\` int(11) NOT NULL AUTO_INCREMENT,
-  \`name\` varchar(50) NOT NULL,
-  \`age\` int(11) DEFAULT NULL,
-  PRIMARY KEY (\`id\`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
--- 另一个单行注释
-INSERT INTO \`test_table\` (\`id\`, \`name\`, \`age\`) VALUES (1, '张三', 25);
-/* 另一个多行注释 */
-INSERT INTO \`test_table\` (\`id\`, \`name\`, \`age\`) VALUES (2, '李四', 30);
-
--- 包含字符串的测试
-INSERT INTO \`test_table\` (\`id\`, \`name\`, \`age\`) VALUES (3, '王--五', 28);
-INSERT INTO \`test_table\` (\`id\`, \`name\`, \`age\`) VALUES (4, '李/*四*/', 35);
-`;
-
-  console.log('原始SQL内容:');
-  console.log(testSql);
-  console.log('\n解析后的SQL语句:');
-  
-  const statements = sql._parseSqlStatements(testSql);
-  statements.forEach((stmt, index) => {
-    console.log(`\n语句 ${index + 1}:`);
-    console.log(stmt);
-  });
-  
-  console.log('\n=== 解析完成 ===');
-  console.log(`共解析出 ${statements.length} 个有效语句`);
-  
-  // 验证解析结果
-  const expectedStatements = 5; // 应该解析出5个有效语句
-  if (statements.length === expectedStatements) {
-    console.log('✅ SQL解析器注释处理功能正常');
-  } else {
-    console.log('❌ SQL解析器注释处理功能异常');
-    console.log(`期望解析出 ${expectedStatements} 个语句，实际解析出 ${statements.length} 个`);
-  }
-}
-
-testSqlParser().catch(console.error);