mm_sqlite 1.0.8 → 1.1.1

package/db.js

@@ -85,7 +85,7 @@ DB.prototype.run = async function(sql, params = [], timeout = 30000) {
 	try {
 		// 使用Promise.race实现超时控制
 		return await Promise.race([
-			this._mysql.run(sql, params),
+			this._mysql.run(sql, params, timeout),
 			this._createTimeoutPromise(timeout, `查询执行超时: ${sql.substring(0, 100)}...`)
 		]);
 	} catch (error) {
@@ -101,23 +101,25 @@ DB.prototype.run = async function(sql, params = [], timeout = 30000) {
 /**
  * 执行SQL命令
  * @param {string} sql SQL语句
+ * @param {Array} params 参数数组
  * @param {Number} timeout 超时时间(毫秒)
  * @returns {Promise<Object>} 执行结果
  */
-DB.prototype.exec = async function(sql, timeout = 30000) {
+DB.prototype.exec = async function(sql, params = [], timeout = 30000) {
 	if (!this._mysql) {
 		throw new Error('SQLite实例未初始化');
 	}
 	try {
 		// 使用Promise.race实现超时控制
 		return await Promise.race([
-			this._mysql.exec(sql),
+			this._mysql.exec(sql, params, timeout),
 			this._createTimeoutPromise(timeout, `命令执行超时: ${sql.substring(0, 100)}...`)
 		]);
 	} catch (error) {
 		$.log.error(`[DB] [exec] 命令执行失败`, {
 			error: error.message,
-			sql: sql.substring(0, 200)
+			sql: sql.substring(0, 200),
+			params: JSON.stringify(params.slice(0, 5))
 		});
 		throw error;
 	}
@@ -155,7 +157,7 @@ DB.prototype.getConn = async function(timeout = 15000) {
 DB.prototype.start = async function(identifier = "point_1", timeout = 15000) {
 	this.task = 1;
 	try {
-		return await this.exec("BEGIN;", timeout);
+		return await this.exec("BEGIN;", [], timeout);
 	} catch (err) {
 		this.task = 0;
 		$.log.error(`[DB] [start] 事务开始失败: ${err.message}`);
@@ -175,7 +177,7 @@ DB.prototype.commit = async function(timeout = 15000) {
 	}
 	this.task = 2;
 	try {
-		const result = await this.exec("COMMIT;", timeout);
+		const result = await this.exec("COMMIT;", [], timeout);
 		// 重置事务状态
 		this.task = 0;
 		this.task_sql = '';
@@ -184,7 +186,7 @@ DB.prototype.commit = async function(timeout = 15000) {
 		$.log.error(`[DB] [commit] 事务提交失败: ${err.message}`);
 		// 尝试回滚
 		try {
-			await this.exec("ROLLBACK;", timeout);
+			await this.exec("ROLLBACK;", [], timeout);
 		} catch (rollbackErr) {
 			$.log.error(`[DB] [commit] 事务回滚也失败: ${rollbackErr.message}`);
 		}
@@ -218,8 +220,8 @@ DB.prototype.back = async function(identifier = "point_1", timeout = 15000) {
 	}
 	this.task = 3;
 	try {
-		await this.exec("ROLLBACK;", timeout);
-		const result = await this.exec("COMMIT;", timeout);
+		await this.exec("ROLLBACK;", [], timeout);
+		const result = await this.exec("COMMIT;", [], timeout);
 		// 重置事务状态
 		this.task = 0;
 		this.task_sql = '';
@@ -458,13 +460,9 @@ DB.prototype.addTable = async function(table, field, type = 'int', auto = true,
 			sqlTemplate = "CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY)";
 		}
 		var sql = sqlTemplate.replace('{0}', table).replace(
-			'{1}', field).replace('{2}', fieldType);
-		if (commit) {
-			sql += " COMMENT = '" + commit + "';"
-		} else {
-			sql += ";"
-		}
-		var bl = await this.exec(sql, timeout);
+			'{1}', field).replace('{2}', fieldType) + ";";
+		// SQLite不支持表级COMMENT语法，所以忽略commit参数
+		var bl = await this.exec(sql, [], timeout);
 		// 设置实例的表名属性，以便后续操作使用
 		this.table = table;
 		return bl && bl.affectedRows !== undefined ? 1 : 0;
@@ -506,22 +504,25 @@ DB.prototype.addField = async function(field, type, value = '', not_null = true,
 			return 0;
 		}
 		
-		var sql =
-			"select count(*) as `count` from sqlite_master where `type` = 'table' and `name` = '{1}' and `sql` like '%{2}%'";
-		sql = sql.replace('{1}', this.table).replace('{2}', field);
-		var arr = await this.run(sql, [], timeout);
-		if (arr && arr.length > 0) {
-			if (arr[0].count == 0) {
-				var type = this.setType(field, type, value, not_null, auto);
-				var sql = "ALTER Table `{0}` ADD `{1}` {2}";
-				sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', type);
-				if (comment) {
-					sql += " COMMENT '" + comment + "'";
-				}
-				sql += ";";
-				return await this.exec(sql, timeout);
+		// 在SQLite中，使用PRAGMA table_info检查表中是否已存在字段
+		var sql = "PRAGMA table_info(`{0}`)";
+		sql = sql.replace('{0}', this.table);
+		var columns = await this.run(sql, [], timeout);
+		var fieldExists = false;
+		for (var i = 0; i < columns.length; i++) {
+			if (columns[i].name === field) {
+				fieldExists = true;
+				break;
 			}
 		}
+		
+		if (!fieldExists) {
+			var fieldType = this.setType(field, type, value, not_null, auto);
+			var sql = "ALTER Table `{0}` ADD `{1}` {2}";
+			sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', fieldType) + ";";
+			// SQLite不支持字段级COMMENT语法，所以忽略comment参数
+			return await this.exec(sql, [], timeout);
+		}
 		return 0;
 	} catch (err) {
 		$.log.error(`[DB] [addField] 添加字段失败: ${err.message}`);
@@ -606,9 +607,9 @@ DB.prototype.delField = async function(table, field, timeout = 15000) {
 			return 0;
 		}
 		
-		var sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
+		var sql = "ALTER TABLE {0} DROP COLUMN {1};";
 		sql = sql.replace('{0}', table).replace('{1}', field);
-		return await this.exec(sql, timeout);
+		return await this.exec(sql, [], timeout);
 	} catch (err) {
 		$.log.error(`[DB] [delField] 删除字段失败: ${err.message}`);
 		return 0;
@@ -665,9 +666,9 @@ DB.prototype.renameField = async function(table, field, new_field, type, timeout
 			return 0;
 		}
 		
-		var sql = "ALTER TABLE `{0}` RENAME COLUMN `{1}` TO `{2}`;";
+		var sql = "ALTER TABLE {0} RENAME COLUMN {1} TO {2};";
 		sql = sql.replace('{0}', table).replace('{1}', field).replace('{2}', new_field);
-		return await this.exec(sql, timeout);
+		return await this.exec(sql, [], timeout);
 	} catch (err) {
 		$.log.error(`[DB] [renameField] 重命名字段失败: ${err.message}`);
 		return 0;
@@ -688,7 +689,7 @@ DB.prototype.editField = function(table, field, type, timeout = 15000) {
 			$.log.error("[DB] [editField] 参数不完整");
 			return 0;
 		}
-		return this.exec("ALTER TABLE `" + table + "` MODIFY COLUMN `" + field + "` " + type + ";", timeout);
+		return this.exec("ALTER TABLE `" + table + "` MODIFY COLUMN `" + field + "` " + type + ";", [], timeout);
 	} catch (err) {
 		$.log.error(`[DB] [editField] 修改字段类型失败: ${err.message}`);
 		return 0;

package/index.js

@@ -378,14 +378,8 @@ Sqlite.prototype.run = async function(sql, params, timeout) {
         if (error) {
           reject(error);
         } else {
-          // 保持与MySQL兼容的返回值格式
-          // 如果是SELECT查询且只有一行结果，返回第一行
-          // 否则返回完整结果数组
-          if (sql.trim().toUpperCase().startsWith('SELECT') && rows.length === 1) {
-            resolve(rows[0]);
-          } else {
-            resolve(rows);
-          }
+          // 保持与MySQL兼容的返回值格式，始终返回数组
+          resolve(rows);
         }
       });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_sqlite",
-    "version": "1.0.8",
+    "version": "1.1.1",
     "description": "高性能SQLite数据库操作模块，提供与mm_mysql完全兼容的API接口，支持异步操作、事务处理和批量操作",
     "main": "index.js",
     "scripts": {
@@ -36,7 +36,7 @@
         "node": ">=14.0.0"
     },
     "dependencies": {
-        "mm_logs": "^1.5.2",
+        "mm_logs": "^1.5.4",
         "sqlite3": "^5.1.7",
         "sqlstring": "^2.3.3"
     }

package/test_db_methods.js

@@ -0,0 +1,262 @@
+// 测试db.js中的所有方法
+const { Sqlite } = require('./index');
+const path = require('path');
+
+async function testDbMethods() {
+    let sql;
+    try {
+        console.log('=== 开始测试 mm_sqlite/db.js 中的方法 ===\n');
+        
+        // 初始化SQLite实例
+        sql = new Sqlite({
+            database: './db/test_db_methods.db'
+        });
+        
+        await sql.open();
+        console.log('✓ 数据库连接成功');
+        
+        // 获取数据库操作实例
+        const db = sql.db();
+        const test_table = 'test_db_methods';
+        const backup_table = 'test_db_methods_backup';
+        
+        // 清理测试环境
+        console.log('\n=== 1. 清理测试环境 ===');
+        await db.dropTable(test_table);
+        await db.dropTable(backup_table);
+        console.log('✓ 测试环境清理完成');
+        
+        // 2. 测试表操作方法
+        console.log('\n=== 2. 测试表操作方法 ===');
+        
+        // 测试addTable
+        console.log('测试addTable()方法...');
+        const createResult = await db.addTable(test_table, 'id', 'int', true, '测试表');
+        console.log('✓ 表创建结果:', createResult);
+        
+        // 测试hasTable
+        console.log('测试hasTable()方法...');
+        const hasTableResult = await db.hasTable(test_table);
+        console.log('✓ 表是否存在:', hasTableResult);
+        
+        // 测试tables
+        console.log('测试tables()方法...');
+        const tablesResult = await db.tables();
+        console.log('✓ 表列表:', tablesResult);
+        
+        // 3. 测试字段操作方法
+        console.log('\n=== 3. 测试字段操作方法 ===');
+        
+        // 设置表名
+        db.table = test_table;
+        
+        // 测试addField
+        console.log('测试addField()方法...');
+        const addFieldResult1 = await db.addField('username', 'varchar', '', true, false, '用户名');
+        console.log('✓ 添加username字段结果:', addFieldResult1);
+        
+        // 测试addField（添加email字段）
+        console.log('测试addField()方法（添加email字段）...');
+        const addFieldResult2 = await db.addField('email', 'varchar', '', true, false, '邮箱');
+        console.log('✓ 添加email字段结果:', addFieldResult2);
+        
+        // 测试addField（添加age字段）
+        console.log('测试addField()方法（添加age字段）...');
+        const addFieldResult3 = await db.addField('age', 'int', 0, true, false, '年龄');
+        console.log('✓ 添加age字段结果:', addFieldResult3);
+        
+        // 测试setField
+        console.log('测试setField()方法...');
+        const setFieldResult = await db.setField('email', 'varchar', '', true, false, '电子邮箱');
+        console.log('✓ 修改email字段结果:', setFieldResult);
+        
+        // 测试addField（添加temp字段用于后续delField测试）
+        console.log('测试addField()方法（添加temp字段）...');
+        await db.addField('temp', 'int', 0, false, false, '临时字段');
+        console.log('✓ 添加temp字段结果: 成功');
+        
+        // 测试fields
+        console.log('测试fields()方法...');
+        const fieldsResult = await db.fields();
+        console.log('✓ 字段信息:', fieldsResult.map(f => f.name));
+        
+        // 测试hasField
+        console.log('测试hasField()方法...');
+        const hasFieldResult = await db.hasField(test_table, 'username');
+        console.log('✓ username字段是否存在:', hasFieldResult);
+        
+        // 测试delField
+        console.log('测试delField()方法...');
+        const delFieldResult = await db.delField(test_table, 'temp');
+        console.log('✓ 删除temp字段结果:', delFieldResult);
+        
+        // 测试renameField
+        console.log('测试renameField()方法...');
+        try {
+            // 先检查当前字段
+            const fieldsBefore = await db.fields();
+            console.log('  - 重命名前字段:', fieldsBefore.map(f => f.name));
+            
+            const renameFieldResult = await db.renameField(test_table, 'age', 'user_age');
+            console.log('  - 重命名age字段结果:', renameFieldResult);
+            
+            // 检查重命名后字段
+            const fieldsAfter = await db.fields();
+            console.log('  - 重命名后字段:', fieldsAfter.map(f => f.name));
+            
+            // 只有当user_age字段存在时，才尝试重命名回age字段
+            const hasUserAgeField = fieldsAfter.some(f => f.name === 'user_age');
+            if (hasUserAgeField) {
+                // 重命名回age字段，保持后续测试一致
+                await db.renameField(test_table, 'user_age', 'age');
+                console.log('  - 重命名user_age字段回age结果: 成功');
+                
+                // 再次检查字段
+                const fieldsFinal = await db.fields();
+                console.log('  - 最终字段:', fieldsFinal.map(f => f.name));
+            } else {
+                console.warn('  - user_age字段不存在，跳过重命名回age字段');
+            }
+            
+            console.log('✓ renameField方法测试完成');
+        } catch (error) {
+            console.warn('⚠️  renameField()方法测试失败:', error.message);
+            console.log('⚠️  renameField()方法测试跳过');
+        }
+        
+        // 4. 测试数据操作方法
+        console.log('\n=== 4. 测试数据操作方法 ===');
+        
+        // 测试add（插入数据）
+        console.log('测试add()方法...');
+        const addResult = await db.add({
+            username: 'test_user',
+            email: 'test@example.com',
+            age: 25
+        });
+        console.log('✓ 插入数据结果:', addResult);
+        
+        // 测试get（查询单条数据）
+        console.log('测试get()方法...');
+        const getResult = await db.get({ id: 1 });
+        console.log('✓ 查询单条数据结果:', getResult[0]);
+        
+        // 测试get（查询多条数据）
+        console.log('测试get()方法（查询多条数据）...');
+        const listResult = await db.get();
+        console.log('✓ 查询多条数据结果:', listResult.length);
+        
+        // 测试set（更新数据）
+        console.log('测试set()方法...');
+        const setResult = await db.set({ id: 1 }, { age: 26 });
+        console.log('✓ 更新数据结果:', setResult);
+        
+        // 测试set（另一种查询条件更新方式）
+        console.log('测试set()方法（使用where属性）...');
+        db.where = { id: 1 };
+        const setResult2 = await db.set(db.where, { age: 27 });
+        console.log('✓ set方法（使用where属性）更新结果:', setResult2);
+        
+        // 测试del（删除数据）
+        console.log('测试del()方法...');
+        const delResult = await db.del({ id: 1 });
+        console.log('✓ 删除数据结果:', delResult);
+        
+        // 5. 测试事务操作方法
+        console.log('\n=== 5. 测试事务操作方法 ===');
+        
+        // 重新插入一条数据用于事务测试
+        await db.add({
+            username: 'transaction_test',
+            email: 'transaction@example.com',
+            age: 30
+        });
+        
+        try {
+            // 测试start（开始事务）
+            console.log('  - 事务开始');
+            await db.start();
+            
+            // 在事务中插入数据
+            await db.add({
+                username: 'transaction_user',
+                email: 'user@example.com',
+                age: 35
+            });
+            console.log('  - 事务中插入数据成功');
+            
+            // 测试commit（提交事务）
+            await db.commit();
+            console.log('  - 事务提交成功');
+            
+            // 验证事务提交结果
+            const transactionResult = await db.get();
+            console.log('  - 事务后数据总数:', transactionResult.length);
+            
+        } catch (error) {
+            // 测试back（回滚事务）
+            await db.back();
+            console.log('  - 事务回滚');
+            throw error;
+        } finally {
+            // 测试end（结束事务）
+            db.end();
+        }
+        console.log('✓ 事务操作完成');
+        
+        // 6. 测试其他方法
+        console.log('\n=== 6. 测试其他方法 ===');
+        
+        // 测试getCreateTable
+        console.log('测试getCreateTable()方法...');
+        const createTableResult = await db.getCreateTable(test_table);
+        console.log('✓ 表创建语句:', createTableResult);
+        
+        // 测试backupTable
+        console.log('测试backupTable()方法...');
+        const backupResult = await db.backupTable(test_table, backup_table);
+        console.log('✓ 表备份结果:', backupResult);
+        
+        // 测试hasTable（备份表）
+        console.log('测试hasTable()方法（备份表）...');
+        const hasBackupTableResult = await db.hasTable(backup_table);
+        console.log('✓ 备份表是否存在:', hasBackupTableResult);
+        
+        // 测试emptyTable
+        console.log('测试emptyTable()方法...');
+        const emptyResult = await db.emptyTable(test_table);
+        console.log('✓ 清空表结果:', emptyResult);
+        
+        // 7. 清理测试环境
+        console.log('\n=== 7. 清理测试环境 ===');
+        await db.dropTable(test_table);
+        await db.dropTable(backup_table);
+        console.log('✓ 测试环境清理完成');
+        
+        // 关闭数据库连接
+        console.log('\n=== 8. 关闭数据库连接 ===');
+        await sql.close();
+        console.log('✓ 数据库连接关闭成功');
+        
+        console.log('\n' + '='.repeat(50));
+        console.log('所有测试完成！db.js方法测试通过');
+        console.log('='.repeat(50));
+        
+    } catch (error) {
+        console.error('\n测试失败:', error.message);
+        // 关闭数据库连接
+        try {
+            if (sql) await sql.close();
+        } catch (closeError) {
+            console.error('关闭数据库连接失败:', closeError.message);
+        }
+        process.exit(1);
+    }
+}
+
+// 运行测试
+testDbMethods();
+
+setTimeout(() => {
+    process.exit(0);
+}, 5000);