mm_sqlite 1.0.5 → 1.0.7

package/sql.json

@@ -0,0 +1,56 @@
+{
+    "name": "user_account",
+    "title": "用户信息",
+    "table": "user_account",
+    "key": "user_id",
+    "orderby_default": "`user_id` desc",
+    "field_default": "`user_id`,`state`,`vip`,`gm`,`mc`,`referee_id`,`create_time`,`login_time`,`invite_code`,`phone`,`phone_state`,`username`,`nickname`,`email`,`email_state`,`user_group`,`user_admin`,`login_ip`,`signature`,`avatar`,`friends`,`admin_group`",
+    "method": "get",
+    "query": {
+        "state_min": "`state` >= '{0}'",
+        "state_max": "`state` <= '{0}'",
+        "vip_min": "`vip` >= '{0}'",
+        "vip_max": "`vip` <= '{0}'",
+        "gm_min": "`gm` >= '{0}'",
+        "gm_max": "`gm` <= '{0}'",
+        "mc_min": "`mc` >= '{0}'",
+        "mc_max": "`mc` <= '{0}'",
+        "create_time_min": "`create_time` >= '{0}'",
+        "create_time_max": "`create_time` <= '{0}'",
+        "login_time_min": "`login_time` >= '{0}'",
+        "login_time_max": "`login_time` <= '{0}'",
+        "salt": "`salt` like '%{0}%'",
+        "invite_code": "`invite_code` like '%{0}%'",
+        "phone": "`phone` like '%{0}%'",
+        "username": "`username` like '%{0}%'",
+        "nickname": "`nickname` like '%{0}%'",
+        "password": "`password` like '%{0}%'",
+        "email": "`email` like '%{0}%'",
+        "user_group": "`user_group` like '%{0}%'",
+        "user_admin": "`user_admin` like '%{0}%'",
+        "login_ip": "`login_ip` like '%{0}%'",
+        "signature": "`signature` like '%{0}%'",
+        "avatar": "`avatar` like '%{0}%'",
+        "friends": "`friends` like '%{0}%'",
+        "admin_group": "`admin_group` like '%{0}%'"
+    },
+    "query_default": {
+        "user_id": "`user_id` = {user_id}"
+    },
+    "update": {
+        "state_add": "`state` = `state` + '{0}'",
+        "vip_add": "`vip` = `vip` + '{0}'",
+        "gm_add": "`gm` = `gm` + '{0}'",
+        "mc_add": "`mc` = `mc` + '{0}'"
+    },
+    "filter": {
+        "table": "table",
+        "page": "page",
+        "size": "size",
+        "method": "method",
+        "orderby": "orderby",
+        "field": "field",
+        "count_ret": "count_ret",
+        "user_id": "user_id"
+    }
+}

package/sql_builder.js

@@ -0,0 +1,375 @@
+/**
+ * SQL构建器类 - 提供与mm_mysql兼容的链式SQL构建接口
+ */
+
+/**
+ * SQL构建器类
+ */
+class SqlBuilder {
+    /**
+     * 构造函数
+     * @param {Object} sqlite - Sqlite实例
+     */
+    constructor(sqlite) {
+        this.sqlite = sqlite;
+        this.tableName = '';
+        this.fields = '*'; 
+        this.whereConditions = [];
+        this.orderByField = '';
+        this.orderDirection = 'ASC';
+        this.limitValue = null;
+        this.offsetValue = null;
+        this.groupByField = '';
+        this.havingCondition = '';
+        this.joinClauses = [];
+        this.insertData = null;
+        this.updateData = null;
+        this.deleteFlag = false;
+        this.transaction = null;
+    }
+
+    /**
+     * 设置表名
+     * @param {String} table - 表名
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    table(table) {
+        this.tableName = table;
+        return this;
+    }
+
+    /**
+     * 设置查询字段
+     * @param {String|Array} fields - 查询字段
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    select(fields = '*') {
+        this.fields = fields;
+        return this;
+    }
+
+    /**
+     * 设置查询条件
+     * @param {String|Object} conditions - 查询条件
+     * @param {*} value - 条件值
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    where(conditions, value = null) {
+        if (typeof conditions === 'object') {
+            // 对象形式的条件
+            for (const key in conditions) {
+                this.whereConditions.push(`${key} = ?`);
+            }
+        } else if (typeof conditions === 'string') {
+            // 字符串形式的条件
+            if (value !== null) {
+                this.whereConditions.push(`${conditions} = ?`);
+            } else {
+                this.whereConditions.push(conditions);
+            }
+        }
+        return this;
+    }
+
+    /**
+     * 设置OR查询条件
+     * @param {String|Object} conditions - 查询条件
+     * @param {*} value - 条件值
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    orWhere(conditions, value = null) {
+        // 简化实现，实际应该支持OR逻辑
+        return this.where(conditions, value);
+    }
+
+    /**
+     * 设置LIKE查询
+     * @param {String} field - 字段名
+     * @param {String} value - 查询值
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    like(field, value) {
+        this.whereConditions.push(`${field} LIKE ?`);
+        return this;
+    }
+
+    /**
+     * 设置IN查询
+     * @param {String} field - 字段名
+     * @param {Array} values - 值数组
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    in(field, values) {
+        const placeholders = values.map(() => '?').join(',');
+        this.whereConditions.push(`${field} IN (${placeholders})`);
+        return this;
+    }
+
+    /**
+     * 设置排序
+     * @param {String} field - 排序字段
+     * @param {String} direction - 排序方向
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    orderBy(field, direction = 'ASC') {
+        this.orderByField = field;
+        this.orderDirection = direction.toUpperCase();
+        return this;
+    }
+
+    /**
+     * 设置分组
+     * @param {String} field - 分组字段
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    groupBy(field) {
+        this.groupByField = field;
+        return this;
+    }
+
+    /**
+     * 设置HAVING条件
+     * @param {String} condition - HAVING条件
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    having(condition) {
+        this.havingCondition = condition;
+        return this;
+    }
+
+    /**
+     * 设置限制数量
+     * @param {Number} limit - 限制数量
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    limit(limit) {
+        this.limitValue = limit;
+        return this;
+    }
+
+    /**
+     * 设置偏移量
+     * @param {Number} offset - 偏移量
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    offset(offset) {
+        this.offsetValue = offset;
+        return this;
+    }
+
+    /**
+     * 设置插入数据
+     * @param {Object} data - 插入数据
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    insert(data) {
+        this.insertData = data;
+        return this;
+    }
+
+    /**
+     * 设置更新数据
+     * @param {Object} data - 更新数据
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    update(data) {
+        this.updateData = data;
+        return this;
+    }
+
+    /**
+     * 设置删除操作
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    delete() {
+        this.deleteFlag = true;
+        return this;
+    }
+
+    /**
+     * 设置JOIN操作
+     * @param {String} table - 连接表名
+     * @param {String} condition - 连接条件
+     * @param {String} type - 连接类型
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    join(table, condition, type = 'INNER') {
+        this.joinClauses.push({
+            table,
+            condition,
+            type: type.toUpperCase()
+        });
+        return this;
+    }
+
+    /**
+     * 设置事务
+     * @param {Object} transaction - 事务对象
+     * @returns {SqlBuilder} 返回自身实例
+     */
+    setTransaction(transaction) {
+        this.transaction = transaction;
+        return this;
+    }
+
+    /**
+     * 构建SELECT SQL语句
+     * @returns {String} SQL语句
+     */
+    _buildSelectSql() {
+        let sql = 'SELECT ';
+        
+        // 处理字段
+        if (Array.isArray(this.fields)) {
+            sql += this.fields.join(', ');
+        } else {
+            sql += this.fields;
+        }
+        
+        sql += ` FROM ${this.tableName}`;
+        
+        // 处理JOIN
+        for (const join of this.joinClauses) {
+            sql += ` ${join.type} JOIN ${join.table} ON ${join.condition}`;
+        }
+        
+        // 处理WHERE条件
+        if (this.whereConditions.length > 0) {
+            sql += ' WHERE ' + this.whereConditions.join(' AND ');
+        }
+        
+        // 处理GROUP BY
+        if (this.groupByField) {
+            sql += ` GROUP BY ${this.groupByField}`;
+        }
+        
+        // 处理HAVING
+        if (this.havingCondition) {
+            sql += ` HAVING ${this.havingCondition}`;
+        }
+        
+        // 处理ORDER BY
+        if (this.orderByField) {
+            sql += ` ORDER BY ${this.orderByField} ${this.orderDirection}`;
+        }
+        
+        // 处理LIMIT和OFFSET
+        if (this.limitValue !== null) {
+            sql += ` LIMIT ${this.limitValue}`;
+            if (this.offsetValue !== null) {
+                sql += ` OFFSET ${this.offsetValue}`;
+            }
+        }
+        
+        return sql;
+    }
+
+    /**
+     * 构建INSERT SQL语句
+     * @returns {String} SQL语句
+     */
+    _buildInsertSql() {
+        if (!this.insertData) {
+            throw new Error('No insert data provided');
+        }
+        
+        const keys = Object.keys(this.insertData);
+        const values = Object.values(this.insertData);
+        const placeholders = keys.map(() => '?').join(', ');
+        
+        return `INSERT INTO ${this.tableName} (${keys.join(', ')}) VALUES (${placeholders})`;
+    }
+
+    /**
+     * 构建UPDATE SQL语句
+     * @returns {String} SQL语句
+     */
+    _buildUpdateSql() {
+        if (!this.updateData) {
+            throw new Error('No update data provided');
+        }
+        
+        const setClause = Object.keys(this.updateData)
+            .map(key => `${key} = ?`)
+            .join(', ');
+        
+        let sql = `UPDATE ${this.tableName} SET ${setClause}`;
+        
+        if (this.whereConditions.length > 0) {
+            sql += ' WHERE ' + this.whereConditions.join(' AND ');
+        }
+        
+        return sql;
+    }
+
+    /**
+     * 构建DELETE SQL语句
+     * @returns {String} SQL语句
+     */
+    _buildDeleteSql() {
+        let sql = `DELETE FROM ${this.tableName}`;
+        
+        if (this.whereConditions.length > 0) {
+            sql += ' WHERE ' + this.whereConditions.join(' AND ');
+        }
+        
+        return sql;
+    }
+
+    /**
+     * 执行查询并返回结果
+     * @returns {Promise<Array>} 查询结果
+     */
+    async get() {
+        const sql = this._buildSelectSql();
+        return await this.sqlite.run(sql);
+    }
+
+    /**
+     * 获取第一条记录
+     * @returns {Promise<Object>} 第一条记录
+     */
+    async first() {
+        this.limit(1);
+        const results = await this.get();
+        return results.length > 0 ? results[0] : null;
+    }
+
+    /**
+     * 统计记录数量
+     * @returns {Promise<Number>} 记录数量
+     */
+    async count() {
+        const originalFields = this.fields;
+        this.fields = 'COUNT(*) as count';
+        const results = await this.get();
+        this.fields = originalFields;
+        return results[0].count;
+    }
+
+    /**
+     * 执行插入操作
+     * @returns {Promise<Object>} 插入结果
+     */
+    async exec() {
+        if (this.insertData) {
+            const sql = this._buildInsertSql();
+            return await this.sqlite.exec(sql, Object.values(this.insertData));
+        } else if (this.updateData) {
+            const sql = this._buildUpdateSql();
+            const params = Object.values(this.updateData);
+            return await this.sqlite.exec(sql, params);
+        } else if (this.deleteFlag) {
+            const sql = this._buildDeleteSql();
+            return await this.sqlite.exec(sql);
+        } else {
+            throw new Error('No operation specified');
+        }
+    }
+}
+
+// 导出SqlBuilder类
+module.exports = { SqlBuilder };
+
+// 兼容CommonJS和ES6模块导出
+exports.SqlBuilder = SqlBuilder;

package/test.js

@@ -1,142 +1,81 @@
 const Sqlite = require('./index.js').Sqlite;
 
-console.log('开始测试');
-// // 测试Sqlite
-// async function test() {
-// 	var sql = new Sqlite();
-// 	sql.open();
-// 	var db = sql.db();
-// 	db.table = "test3";
-
-// 	var bl;
-// 	bl = await db.addTable('test3', 'uid', 'int');
-// 	console.log("添加表：" + bl);
-
-// 	// bl = await db.field_del('uid', 'int');
-// 	// console.log("删除字段：" + bl, db.error);
-// 	// bl = await db.field_add('uid', 'int', true);
-// 	// console.log("添加字段：" + bl, db.error);
-// 	bl = await db.field_add('name', 'str');
-// 	console.log("添加字段：" + bl, db.error);
-// 	bl = await db.field_add('password', 'str');
-// 	console.log("添加字段：" + bl, db.error);
-// 	bl = await db.field_add('username', 'str');
-// 	console.log("添加字段：" + bl, db.error);
-
-// 	var addArr = [];
-// 	for (var i = 1; i <= 9; i++) {
-// 		var add = {
-// 			name: "test" + i,
-// 			username: "t" + i,
-// 			password: "a" + i
-// 		};
-// 		addArr.push(add);
-// 	}
-// 	// db.addObj({
-// 	// 	name: "test",
-// 	// 	username: "t",
-// 	// 	password: "a"
-// 	// });
-// 	var ret = await db.addList(addArr);
-// 	console.log("添加：" + JSON.stringify(ret), db.error);
-// 	if(!ret)
-// 	{
-// 		console.log(db.sql);
-// 	}
-
-// 	var setArr = [];
-// 	for (var i = 1; i <= addArr.length; i++) {
-// 		setArr.push({
-// 			query: {
-// 				name: "test" + i
-// 			},
-// 			item: {
-// 				username: "username" + i,
-// 				password: "password" + i
-// 			}
-// 		});
-// 	}
-// 	ret = await db.setList(setArr);
-// 	console.log("修改：" + JSON.stringify(ret), db.error);
-
-// 	var delArr = [];
-// 	for (var i = 1; i <= addArr.length; i++) {
-// 		if (i % 2 == 0) {
-// 			delArr.push({
-// 				query: {
-// 					username: "username" + i
-// 				}
-// 			});
-// 		}
-// 	}
-// 	ret = await db.delList(delArr);
-// 	console.log("删除：" + JSON.stringify(ret), db.error);
-
-
-
-// 	// ret = await db.get({ username: "username1" });
-// 	// console.log("获取：" + JSON.stringify(ret,true), db.error);
-// }
-
-// test();
-
-/**
- * 测试通过对象操作数据库
- */
-async function testFM() {
-	var sql = new Sqlite();
-	sql.open();
-	var db = sql.db();
-	db.table = "test3";
-
-	db.key = 'uid';
-	var obj = await db.getObj({});
-	console.log("获取：" + JSON.stringify(obj), db.error);
-
-	obj.username = "张三";
-	obj = await db.getObj({});
-	console.log("获取：" + JSON.stringify(obj), db.error);
-}
-
-testFM();
-
-/**
- * 测试新建数据库和表，如果已存在则只打开，不会再创建
- */
-async function testNew() {
+// 全面测试函数
+async function runAllTests() {
+	$.log.info('开始全面测试mm_sqlite模块...');
 	var sql = new Sqlite();
-	sql.setConfig({
-		host: __dirname + '/db',
-		database: 'test'
-	})
-	sql.open();
-	var db = sql.db();
-	var bl;
-	bl = await db.addTable('test6', 'uid', 'int');
-	console.log('创建：' + (bl == 1));
-	console.log(await db.tables());
+	await sql.open();
+	
+	var test_table = 'test_mm_sqlite';
+	
+	try {
+		// 1. 测试表创建
+		$.log.info('1. 测试表创建...');
+		let create_sql = `CREATE TABLE IF NOT EXISTS ${test_table} (
+			uid INTEGER PRIMARY KEY AUTOINCREMENT,
+			username VARCHAR(50) NOT NULL,
+			age INTEGER DEFAULT 0,
+			created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+		)`;
+		let create_result = await sql.run(create_sql);
+		$.log.info('表创建结果:', create_result);
+		
+		// 2. 测试数据插入
+		$.log.info('2. 测试数据插入...');
+		let insert_sql = `INSERT INTO ${test_table} (username, age) VALUES (?, ?)`;
+		let insert_result = await sql.run(insert_sql, ['test_user_1', 25]);
+		$.log.info('插入结果:', insert_result);
+		
+		// 3. 测试查询 - 使用exec方法并安全处理返回结果
+		$.log.info('3. 测试查询...');
+		let query_sql = `SELECT * FROM ${test_table}`;
+		let query_result = await sql.exec(query_sql);
+		$.log.info('查询结果类型:', typeof query_result);
+		$.log.info('查询结果:', query_result);
+		
+		// 4. 测试更新
+		$.log.info('4. 测试更新...');
+		let update_sql = `UPDATE ${test_table} SET age = ? WHERE username = ?`;
+		let update_result = await sql.run(update_sql, [26, 'test_user_1']);
+		$.log.info('更新结果:', update_result);
+		
+		// 5. 测试删除
+		$.log.info('5. 测试删除...');
+		let delete_sql = `DELETE FROM ${test_table} WHERE username = ?`;
+		let delete_result = await sql.run(delete_sql, ['test_user_1']);
+		$.log.info('删除结果:', delete_result);
+		
+		// 6. 测试事务
+		$.log.info('6. 测试事务...');
+		let transaction_result = await sql.transaction(async () => {
+			await sql.run(`INSERT INTO ${test_table} (username, age) VALUES (?, ?)`, ['transaction_user', 40]);
+			return await sql.run(`DELETE FROM ${test_table} WHERE username = ?`, ['transaction_user']);
+		});
+		$.log.info('事务结果:', transaction_result);
+		
+		// 7. 测试表列表 - 安全处理exec返回结果
+		$.log.info('7. 测试表列表...');
+		let tables_sql = `SELECT name FROM sqlite_master WHERE type='table'`;
+		let tables_result = await sql.exec(tables_sql);
+		$.log.info('表列表类型:', typeof tables_result);
+		$.log.info('表列表:', tables_result);
+		
+		// 8. 清理测试表
+		$.log.info('8. 清理测试表...');
+		let drop_result = await sql.run(`DROP TABLE IF EXISTS ${test_table}`);
+		$.log.info('删除表结果:', drop_result);
+		
+		$.log.info('所有测试完成！mm_sqlite模块功能正常。');
+		return true;
+	} catch (error) {
+		$.log.error('测试过程中发生错误:', error);
+		return false;
+	} finally {
+		await sql.close();
+	}
 }
-testNew();
 
-// 
-// async function testTable() {
-// var sql = new Sqlite();
-// sql.open();
-// var db = sql.db();
-// db.table = "test9";
-// var bl;
-// 	bl = await db.addTable('test6', 'uid', 'int');
-// 	console.log("添加表" + bl, db.error);
-// 	var arr = await db.tables('t*');
-// 	console.log("获取表" + JSON.stringify(arr), db.error);
-// 	var list = await db.fields('test');
-// 	console.log("获取字段信息" + JSON.stringify(list), db.error);
-// 	
-// 	db.table = 'test';
-// 	bl = await db.field_del('set6');
-// 	console.log("删除字段" + bl, db.error);
-// 	bl = await db.field_add('set6', 'str');
-// 	console.log("添加字段" + bl, db.error);
-// }
-// 
-// testTable();
+// 运行测试
+(async function() {
+	await runAllTests();
+})();