mm_sqlite 1.2.7 → 1.2.8

package/backup/test_backup.sql

@@ -0,0 +1,6 @@
+-- 备份表: test_table
+-- 备份时间: 2025-12-25T16:10:47.231Z
+
+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_backup1.sql

@@ -0,0 +1,5 @@
+-- 备份表: test_table
+-- 备份时间: 2025-12-25T15:56:50.292Z
+
+INSERT INTO `test_table` (`id`, `name`, `age`) VALUES (1, '测试数据1', 25);
+INSERT INTO `test_table` (`id`, `name`, `age`) VALUES (2, '测试数据2', 30);

package/backup/test_backup2.sql

@@ -0,0 +1,7 @@
+-- 备份表: test_table
+-- 备份时间: 2025-12-25T15:56:50.301Z
+
+CREATE TABLE IF NOT EXISTS `test_table` (`id` INTEGER PRIMARY KEY, `name` TEXT, `age` INTEGER);
+
+INSERT INTO `test_table` (`id`, `name`, `age`) VALUES (1, '测试数据1', 25);
+INSERT INTO `test_table` (`id`, `name`, `age`) VALUES (2, '测试数据2', 30);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_sqlite",
-    "version": "1.2.7",
+    "version": "1.2.8",
     "description": "高性能SQLite数据库操作模块，提供与mm_mysql完全兼容的API接口，支持异步操作、事务处理和批量操作",
     "main": "index.js",
     "scripts": {

package/sql.js

@@ -548,6 +548,159 @@ Sql.prototype.toStr = function (...args) {
   return args.map(arg => String(arg)).join(' ');
 };
 
+/* ===  备份恢复函数  === */
+/**
+ * @description 备份数据库到 SQL 文件
+ * @param {string} file 备份文件路径
+ * @returns {Promise<boolean>} 备份是否成功
+ */
+Sql.prototype.backup = async function(file) {
+  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`;
+    
+    // 添加数据插入语句
+    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, sqlContent, '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 sqlContent = fs.readFileSync(file, 'utf8');
+    
+    if (!sqlContent) {
+      throw new Error('备份文件为空');
+    }
+    
+    // 解析 SQL 语句（按分号分割，但需要处理字符串中的分号）
+    const statements = this._parseSqlStatements(sqlContent);
+    
+    // 执行所有 SQL 语句
+    for (const statement of statements) {
+      if (statement.trim()) {
+        // 跳过注释行
+        if (!statement.trim().startsWith('--')) {
+          await this.exec(statement);
+        }
+      }
+    }
+    
+    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 statements = [];
+  let currentStatement = '';
+  let inString = false;
+  let stringChar = '';
+  
+  for (let i = 0; i < sql.length; i++) {
+    const char = sql[i];
+    
+    if (char === "'" || char === '"') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        // 检查是否是转义字符
+        if (i > 0 && sql[i-1] === '\\') {
+          // 转义字符，继续字符串
+        } else {
+          inString = false;
+          stringChar = '';
+        }
+      }
+    }
+    
+    if (!inString && char === ';') {
+      statements.push(currentStatement.trim());
+      currentStatement = '';
+    } else {
+      currentStatement += char;
+    }
+  }
+  
+  // 添加最后一个语句（如果没有分号结尾）
+  if (currentStatement.trim()) {
+    statements.push(currentStatement.trim());
+  }
+  
+  return statements.filter(stmt => stmt.length > 0);
+};
+
 /* ===  sql语句拼接函数  === */
 /**
  * @description 转为where语句
@@ -1463,8 +1616,6 @@ Sql.prototype.getObj = async function (query, sort, view, like, timeout = 30000)
   return null;
 };
 
-
-
 /**
  * 从SQL文件加载数据库
  * @param {string} file - SQL文件路径
@@ -1618,6 +1769,193 @@ Sql.prototype._splitSqlStatements = function (sql_content) {
   return stmts;
 };
 
+/**
+ * @description 获取创建表的 SQL 语句
+ * @returns {Promise<string>} 创建表的 SQL 语句
+ * @private
+ */
+Sql.prototype._getCreateTableSql = async function() {
+  try {
+    // 查询表结构信息（SQLite 使用 sqlite_master 表）
+    const sql = `SELECT sql FROM sqlite_master WHERE type='table' AND name='${this.table}'`;
+    const result = await this.run(sql);
+    
+    if (result && result.length > 0 && result[0].sql) {
+      // 在创建表语句中添加 IF NOT EXISTS 条件
+      let create_sql = result[0].sql;
+      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 备份数据库到 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('备份文件不存在');
+    }
+
+    // 读取 SQL 文件
+    const sql_content = fs.readFileSync(file, 'utf8');
+    
+    // 解析 SQL 语句
+    const stmts = this._parseSqlStatements(sql_content);
+    
+    // 执行每个 SQL 语句
+    for (const stmt of stmts) {
+      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 && char === '-' && next_char === '-') {
+      in_cmt = true;
+    }
+    if (in_cmt && char === '\n') {
+      in_cmt = false;
+    }
+
+    // 分割语句
+    if (!in_str && !in_cmt && char === ';') {
+      stmts.push(cur_stmt.trim());
+      cur_stmt = '';
+    } else {
+      cur_stmt += char;
+    }
+  }
+
+  // 添加最后一个语句（如果有）
+  if (cur_stmt.trim()) {
+    stmts.push(cur_stmt.trim());
+  }
+
+  return stmts;
+};
+
 module.exports = {
   Sql
 };

package/test_backup.js

@@ -0,0 +1,78 @@
+/**
+ * @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 }];
+  }
+  
+  return [];
+}
+
+async function mockExec(sql) {
+  console.log('执行更新SQL:', sql);
+  return { affectedRows: 1, insertId: 1 };
+}
+
+async function testBackupRestore() {
+  console.log('=== 测试备份恢复功能 ===');
+  
+  // 创建 SQL 实例
+  const sql = new Sql(mockRun, mockExec);
+  sql.table = 'test_table';
+  
+  const backupFile = './backup/test_backup.sql';
+  
+  try {
+    // 测试备份
+    console.log('\n1. 测试备份功能...');
+    const backupResult = await sql.backup(backupFile);
+    console.log('备份结果:', backupResult ? '成功' : '失败');
+    
+    if (backupResult) {
+      // 读取备份文件内容
+      const fs = require('fs');
+      if (fs.existsSync(backupFile)) {
+        const content = fs.readFileSync(backupFile, 'utf8');
+        console.log('备份文件内容:');
+        console.log(content);
+      }
+    }
+    
+    // 测试恢复
+    console.log('\n2. 测试恢复功能...');
+    const restoreResult = await sql.restore(backupFile);
+    console.log('恢复结果:', restoreResult ? '成功' : '失败');
+    
+    console.log('\n=== 测试完成 ===');
+    
+  } catch (error) {
+    console.error('测试出错:', error.message);
+  }
+}
+
+// 运行测试
+if (require.main === module) {
+  testBackupRestore();
+}
+
+module.exports = {
+  testBackupRestore
+};