mm_sqlite 1.1.4 → 1.1.5

package/sql_builder.js

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