mm_mysql 2.2.7 → 2.2.8

package/backup/test_mysql_backup1.sql

@@ -0,0 +1,6 @@
+-- 备份表: test_table
+-- 备份时间: 2025-12-25T16:36:48.438Z
+
+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);

package/backup/test_mysql_backup2.sql

@@ -0,0 +1,13 @@
+-- 备份表: test_table
+-- 备份时间: 2025-12-25T16:36:48.450Z
+
+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);

package/backup/test_mysql_backup_with_comments.sql

@@ -0,0 +1,13 @@
+-- 备份表: test_table
+-- 备份时间: 2025-12-25T16:34:30.386Z
+
+CREATE TABLE IF NOT EXISTS `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='测试用户表';
+
+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);

package/package.json

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

package/sql.js

@@ -1666,6 +1666,443 @@ Sql.prototype.addOrSet = async function (where, set, like) {
   return 0;
 };
 
+/**
+ * @description 获取创建表的 SQL 语句
+ * @returns {Promise<string>} 创建表的 SQL 语句
+ * @private
+ */
+Sql.prototype._getCreateTableSql = async function() {
+  try {
+    // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
+    const sql = `SHOW CREATE TABLE \`${this.table}\``;
+    const result = await this.run(sql);
+    
+    if (result && result.length > 0 && result[0]['Create Table']) {
+      // 在创建表语句中添加 IF NOT EXISTS 条件
+      let create_sql = result[0]['Create Table'];
+      if (create_sql.toUpperCase().startsWith('CREATE TABLE')) {
+        create_sql = create_sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS');
+      }
+      return create_sql + ';';
+    }
+    
+    return '';
+  } catch (err) {
+    this.log('warn', '获取表结构失败，将仅备份数据', err);
+    return '';
+  }
+};
+
+/**
+ * @description 获取表的注释信息
+ * @returns {Promise<string>} 注释信息 SQL 语句
+ * @private
+ */
+Sql.prototype._getTableComments = async function() {
+  try {
+    let commentSql = '';
+    
+    // 获取表注释
+    const tableCommentSql = `
+      SELECT TABLE_COMMENT 
+      FROM information_schema.TABLES 
+      WHERE TABLE_SCHEMA = DATABASE() 
+        AND TABLE_NAME = '${this.table}'
+    `;
+    const tableCommentResult = await this.run(tableCommentSql);
+    
+    if (tableCommentResult && tableCommentResult.length > 0 && tableCommentResult[0].TABLE_COMMENT) {
+      const tableComment = tableCommentResult[0].TABLE_COMMENT;
+      if (tableComment && tableComment.trim() !== '') {
+        commentSql += `\n-- 表注释: ${tableComment}\n`;
+      }
+    }
+    
+    // 获取列注释
+    const columnCommentSql = `
+      SELECT COLUMN_NAME, COLUMN_COMMENT
+      FROM information_schema.COLUMNS 
+      WHERE TABLE_SCHEMA = DATABASE() 
+        AND TABLE_NAME = '${this.table}'
+        AND COLUMN_COMMENT IS NOT NULL 
+        AND COLUMN_COMMENT != ''
+      ORDER BY ORDINAL_POSITION
+    `;
+    const columnCommentResult = await this.run(columnCommentSql);
+    
+    if (columnCommentResult && columnCommentResult.length > 0) {
+      commentSql += '\n-- 列注释:\n';
+      for (const column of columnCommentResult) {
+        commentSql += `-- ${column.COLUMN_NAME}: ${column.COLUMN_COMMENT}\n`;
+      }
+    }
+    
+    return commentSql;
+  } catch (err) {
+    this.log('warn', '获取表注释信息失败，将仅备份表结构', err);
+    return '';
+  }
+};
+
+/**
+ * @description 备份数据库到 SQL 文件
+ * @param {string} file 备份文件路径
+ * @param {boolean} create 是否导出创建表语句，默认为false
+ * @returns {Promise<boolean>} 备份是否成功
+ */
+Sql.prototype.backup = async function(file, create = false) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+
+  try {
+    // 获取所有数据
+    const data = await this.getSql('', '', '*');
+    
+    if (!data || !Array.isArray(data)) {
+      throw new Error('获取数据失败');
+    }
+
+    // 构建 SQL 语句
+    let sqlContent = '';
+    
+    // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
+    sqlContent += `-- 备份表: ${this.table}\n`;
+    sqlContent += `-- 备份时间: ${new Date().toISOString()}\n\n`;
+    
+    // 如果create为true，添加创建表语句
+    if (create) {
+      const createTableSql = await this._getCreateTableSql();
+      if (createTableSql) {
+        sqlContent += createTableSql + '\n\n';
+        
+        // 添加表注释信息
+        const commentSql = await this._getTableComments();
+        if (commentSql) {
+          sqlContent += commentSql + '\n';
+        }
+      }
+    }
+    
+    // 添加数据插入语句
+    for (const row of data) {
+      const keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
+      const values = Object.values(row).map(value => this.escape(value)).join(', ');
+      sqlContent += `INSERT INTO \`${this.table}\` (${keys}) VALUES (${values});\n`;
+    }
+
+    // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
+    const fs = require('fs');
+    const path = require('path');
+    
+    // 确保目录存在
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    fs.writeFileSync(file, sql_content, 'utf8');
+    
+    return true;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '备份数据库失败', err);
+    return false;
+  }
+};
+
+/**
+ * @description 从 SQL 文件恢复数据库
+ * @param {string} file 备份文件路径
+ * @returns {Promise<boolean>} 恢复是否成功
+ */
+Sql.prototype.restore = async function(file) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+
+  try {
+    const fs = require('fs');
+    
+    if (!fs.existsSync(file)) {
+      throw new Error('备份文件不存在');
+    }
+
+    // 读取 SQL 文件
+    const sqlContent = fs.readFileSync(file, 'utf8');
+    
+    // 解析 SQL 语句
+    const statements = this._parseSqlStatements(sqlContent);
+    
+    // 执行每个 SQL 语句
+    for (const stmt of statements) {
+      if (stmt.trim() && !stmt.startsWith('--')) {
+        await this.exec(stmt);
+      }
+    }
+    
+    return true;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '恢复数据库失败', err);
+    return false;
+  }
+};
+
+/**
+ * @description 解析 SQL 语句
+ * @param {string} sql SQL 内容
+ * @returns {string[]} SQL 语句数组
+ * @private
+ */
+Sql.prototype._parseSqlStatements = function(sql) {
+  const stmts = [];
+  let cur_stmt = '';
+  let in_str = false;
+  let in_cmt = false;
+  let quote_char = '';
+
+  for (let i = 0; i < sql.length; i++) {
+    const char = sql[i];
+    const next_char = sql[i + 1] || '';
+
+    // 处理字符串
+    if (!in_cmt && (char === "'" || char === '"') && (i === 0 || sql[i - 1] !== '\\')) {
+      if (!in_str) {
+        in_str = true;
+        quote_char = char;
+      } else if (char === quote_char) {
+        in_str = false;
+        quote_char = '';
+      }
+    }
+
+    // 处理单行注释
+    if (!in_str && !in_cmt && char === '-' && next_char === '-') {
+      in_cmt = true;
+      i++; // 跳过第二个'-'
+      continue;
+    }
+    
+    if (in_cmt && char === '\n') {
+      in_cmt = false;
+      continue;
+    }
+
+    // 处理多行注释开始
+    if (!in_str && !in_cmt && char === '/' && next_char === '*') {
+      in_cmt = true;
+      i++; // 跳过'*'
+      continue;
+    }
+
+    // 处理多行注释结束
+    if (in_cmt && char === '*' && next_char === '/') {
+      in_cmt = false;
+      i++; // 跳过'/'字符
+      continue;
+    }
+
+    // 跳过注释内容
+    if (in_cmt) {
+      continue;
+    }
+
+    // 分割语句
+    if (!in_str && !in_cmt && char === ';') {
+      if (cur_stmt.trim()) {
+        stmts.push(cur_stmt.trim());
+      }
+      cur_stmt = '';
+    } else {
+      cur_stmt += char;
+    }
+  }
+
+  // 添加最后一个语句（如果有）
+  if (cur_stmt.trim()) {
+    stmts.push(cur_stmt.trim());
+  }
+
+  return stmts;
+};
+
+/**
+ * @description 备份数据库到 SQL 文件
+ * @param {string} file 备份文件路径
+ * @param {boolean} create 是否导出创建表语句，默认为false
+ * @returns {Promise<boolean>} 备份是否成功
+ */
+Sql.prototype.backup = async function(file, create = false) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+
+  try {
+    // 获取所有数据
+    const data = await this.getSql('', '', '*');
+    
+    if (!data || !Array.isArray(data)) {
+      throw new Error('获取数据失败');
+    }
+
+    // 构建 SQL 语句
+    let sql_content = '';
+    
+    // 添加表结构（简化版，实际应用中可能需要更复杂的表结构导出）
+    sql_content += `-- 备份表: ${this.table}\n`;
+    sql_content += `-- 备份时间: ${new Date().toISOString()}\n\n`;
+    
+    // 如果create为true，添加创建表语句
+    if (create) {
+      const create_table_sql = await this._getCreateTableSql();
+      if (create_table_sql) {
+        sql_content += create_table_sql + '\n\n';
+      }
+    }
+    
+    // 添加数据插入语句
+    for (const row of data) {
+      const keys = Object.keys(row).map(key => this.escapeId(key)).join(', ');
+      const values = Object.values(row).map(value => this.escape(value)).join(', ');
+      sql_content += `INSERT INTO \`${this.table}\` (${keys}) VALUES (${values});\n`;
+    }
+
+    // 写入文件（这里需要文件系统模块，实际使用时需要引入 fs）
+    const fs = require('fs');
+    const path = require('path');
+    
+    // 确保目录存在
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    fs.writeFileSync(file, sql_content, 'utf8');
+    
+    return true;
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '备份数据库失败', err);
+    return false;
+  }
+};
+
+/**
+ * @description 从 SQL 文件恢复数据库
+ * @param {string} file 恢复文件路径
+ * @returns {Promise<boolean>} 恢复是否成功
+ */
+Sql.prototype.restore = async function(file) {
+  if (!file || typeof file !== 'string') {
+    throw new TypeError('文件路径必须为字符串');
+  }
+
+  if (!this.table) {
+    throw new TypeError('表名未设置');
+  }
+
+  try {
+    const fs = require('fs');
+    
+    // 检查文件是否存在
+    if (!fs.existsSync(file)) {
+      throw new Error('备份文件不存在');
+    }
+
+    // 读取文件内容
+    const sql_content = fs.readFileSync(file, 'utf8');
+    
+    if (!sql_content) {
+      throw new Error('备份文件为空');
+    }
+
+    // 解析 SQL 语句
+    const sql_stmts = this._parseSqlStatements(sql_content);
+    
+    if (!sql_stmts || sql_stmts.length === 0) {
+      throw new Error('未找到有效的 SQL 语句');
+    }
+
+    // 开始事务
+    await this.exec('START TRANSACTION');
+
+    try {
+      // 逐个执行SQL语句
+      for (const sql of sql_stmts) {
+        const trim_sql = sql.trim();
+        if (trim_sql) {
+          await this.exec(trim_sql);
+        }
+      }
+
+      // 提交事务
+      await this.exec('COMMIT');
+
+      if (this.config && this.config.debug) {
+        this.log('info', '数据库恢复成功', {
+          file: file,
+          stmt_num: sql_stmts.length
+        });
+      }
+
+      return true;
+    } catch (err) {
+      // 回滚事务
+      await this.exec('ROLLBACK').catch(rollback_err => {
+        this.log('error', '事务回滚失败', rollback_err);
+      });
+
+      // 记录错误日志
+      this.log('error', 'SQL语句执行失败', err);
+      throw err;
+    }
+  } catch (err) {
+    this.error = err.message;
+    this.log('error', '数据库恢复失败', err);
+    return false;
+  }
+};
+
+/**
+ * @description 获取创建表的 SQL 语句
+ * @returns {Promise<string>} 创建表的 SQL 语句
+ * @private
+ */
+Sql.prototype._getCreateTableSql = async function() {
+  try {
+    // 查询表结构信息（MySQL 使用 SHOW CREATE TABLE）
+    const sql = `SHOW CREATE TABLE \`${this.table}\``;
+    const result = await this.run(sql);
+    
+    if (result && result.length > 0 && result[0]['Create Table']) {
+      // 在创建表语句中添加 IF NOT EXISTS 条件
+      let create_sql = result[0]['Create Table'];
+      if (create_sql.toUpperCase().startsWith('CREATE TABLE')) {
+        create_sql = create_sql.replace('CREATE TABLE', 'CREATE TABLE IF NOT EXISTS');
+      }
+      return create_sql + ';';
+    }
+    
+    return '';
+  } catch (err) {
+    this.log('warn', '获取表结构失败，将仅备份数据', err);
+    return '';
+  }
+};
+
 module.exports = {
   Sql
 };

package/test_backup.js

@@ -0,0 +1,101 @@
+/**
+ * @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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,76 @@
+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);