jsql-neo 1.2.0 → 1.3.0

package/index.js

@@ -1,22 +1,11 @@
 // © Vexify 2026 All Rights Reserved.
 /**
- * JSQL — Pure JavaScript Embedded Database
+ * JSQL-NEO — Pure JavaScript Embedded Database
+ * v1.3.0 — 窗口函数、视图、触发器、全文搜索、CSV、stats、多数据库
  *
  * @example
  * const jsql = require('jsql-neo');
  * const db = new jsql.Database('mydb.json');
- *
- * db.createTable('users', {
- *   id: { type: 'integer', primaryKey: true, autoIncrement: true },
- *   name: { type: 'string', required: true },
- *   age: { type: 'integer' }
- * });
- *
- * db.users.insert({ name: 'Alice', age: 25 });
- * db.users.insert({ name: 'Bob', age: 30 });
- *
- * const adults = db.users.find({ age: { $gte: 18 } });
- * const sorted = db.users.where({ age: { $gte: 18 } }).orderBy('age', 'desc').limit(10).get();
  */
 
 module.exports = {

package/lib/database.js

@@ -39,6 +39,9 @@ class Database {
         this._plugins = [];
         this._migrations = [];
         this._observers = [];      // 响应式观察者
+        this._views = {};           // 视图 { name: { query, table } }
+        this._triggers = {};        // 触发器 { name: { event, table, callback } }
+        this._attached = {};        // 附加数据库 { name: db }
         this._changeStream = null; // 变更流
 
         // 从文件加载
@@ -90,6 +93,310 @@ class Database {
         return Object.keys(this._tables);
     }
 
+    // ============================================================
+    // 视图
+    // ============================================================
+
+    /**
+     * 创建视图（虚拟表）
+     * @param {string} name - 视图名
+     * @param {function} queryFn - (db) => Query 实例
+     * @example
+     * db.createView('adults', db => db.users.where({ age: { $gte: 18 } }).select(['name', 'age']));
+     */
+    createView(name, queryFn) {
+        if (this._views[name]) throw new Error(`View '${name}' already exists`);
+        this._views[name] = { queryFn };
+
+        // 代理到 db 上
+        Object.defineProperty(this, name, {
+            get: () => {
+                const q = queryFn(this);
+                return {
+                    get: () => q.get(),
+                    first: () => q.first(),
+                    count: () => q.count(),
+                    sum: (f) => q.sum(f),
+                    avg: (f) => q.avg(f),
+                    min: (f) => q.min(f),
+                    max: (f) => q.max(f),
+                    _query: q
+                };
+            },
+            enumerable: true,
+            configurable: true
+        });
+    }
+
+    dropView(name) {
+        if (!this._views[name]) throw new Error(`View '${name}' does not exist`);
+        delete this._views[name];
+        delete this[name];
+    }
+
+    getViews() {
+        return Object.keys(this._views);
+    }
+
+    // ============================================================
+    // 触发器
+    // ============================================================
+
+    /**
+     * 创建触发器
+     * @param {string} name - 触发器名
+     * @param {object} options - { event: 'insert'|'update'|'remove', table: 'tableName', timing: 'before'|'after' }
+     * @param {function} callback - 触发时执行的回调
+     */
+    createTrigger(name, options, callback) {
+        if (this._triggers[name]) throw new Error(`Trigger '${name}' already exists`);
+        const table = this._tables[options.table];
+        if (!table) throw new Error(`Table '${options.table}' does not exist`);
+
+        const hookName = options.timing + options.event.charAt(0).toUpperCase() + options.event.slice(1);
+        this._triggers[name] = { event: options.event, table: options.table, callback, hookName };
+        table.on(hookName, callback);
+    }
+
+    dropTrigger(name) {
+        const trigger = this._triggers[name];
+        if (!trigger) throw new Error(`Trigger '${name}' does not exist`);
+        const table = this._tables[trigger.table];
+        if (table) table.off(trigger.hookName, trigger.callback);
+        delete this._triggers[name];
+    }
+
+    getTriggers() {
+        return Object.keys(this._triggers).map(name => ({
+            name,
+            event: this._triggers[name].event,
+            table: this._triggers[name].table
+        }));
+    }
+
+    // ============================================================
+    // CSV 导入/导出
+    // ============================================================
+
+    /**
+     * 从 CSV 文件导入数据到表
+     * @param {string} filePath - CSV 文件路径
+     * @param {string} tableName - 目标表名
+     * @param {object} options - { delimiter: ',', hasHeader: true, skipRows: 0, mapping: { csvCol: schemaCol } }
+     */
+    importCSV(filePath, tableName, options = {}) {
+        const table = this._tables[tableName];
+        if (!table) throw new Error(`Table '${tableName}' does not exist`);
+
+        const delimiter = options.delimiter || ',';
+        const hasHeader = options.hasHeader !== false;
+        const skipRows = options.skipRows || 0;
+        const mapping = options.mapping || null;
+
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split(/\r?\n/).filter(l => l.trim());
+
+        let headers = [];
+        let startRow = 0;
+
+        if (hasHeader) {
+            headers = this._parseCSVLine(lines[0], delimiter);
+            startRow = 1 + skipRows;
+        } else {
+            startRow = skipRows;
+        }
+
+        let count = 0;
+        for (let i = startRow; i < lines.length; i++) {
+            const values = this._parseCSVLine(lines[i], delimiter);
+            if (values.length === 0) continue;
+
+            const data = {};
+            if (mapping) {
+                for (const [csvCol, schemaCol] of Object.entries(mapping)) {
+                    const idx = hasHeader ? headers.indexOf(csvCol) : parseInt(csvCol);
+                    if (idx >= 0 && idx < values.length) {
+                        data[schemaCol] = this._castValue(values[idx], table._schema[schemaCol]);
+                    }
+                }
+            } else if (hasHeader) {
+                for (let j = 0; j < headers.length; j++) {
+                    if (j < values.length && table._schema[headers[j]]) {
+                        data[headers[j]] = this._castValue(values[j], table._schema[headers[j]]);
+                    }
+                }
+            }
+
+            if (Object.keys(data).length > 0) {
+                table.insert(data);
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    /**
+     * 导出表数据到 CSV 文件
+     * @param {string} filePath - 输出文件路径
+     * @param {string} tableName - 表名
+     * @param {object} query - 筛选条件（可选）
+     * @param {object} options - { delimiter: ',', fields: ['col1','col2'] }
+     */
+    exportCSV(filePath, tableName, query = {}, options = {}) {
+        const table = this._tables[tableName];
+        if (!table) throw new Error(`Table '${tableName}' does not exist`);
+
+        const delimiter = options.delimiter || ',';
+        const rows = table._applyFilter(table._rows, query);
+        const fields = options.fields || Object.keys(table._schema).filter(f => f !== '_softDelete');
+
+        const lines = [];
+        // 表头
+        lines.push(fields.map(f => this._csvEscape(f, delimiter)).join(delimiter));
+
+        // 数据行
+        for (const row of rows) {
+            lines.push(fields.map(f => {
+                const val = row[f];
+                return val === null || val === undefined ? '' : this._csvEscape(String(val), delimiter);
+            }).join(delimiter));
+        }
+
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(filePath, lines.join('\n'), 'utf8');
+        return lines.length - 1; // 返回数据行数
+    }
+
+    _parseCSVLine(line, delimiter) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (inQuotes) {
+                if (ch === '"') {
+                    if (i + 1 < line.length && line[i + 1] === '"') {
+                        current += '"';
+                        i++;
+                    } else {
+                        inQuotes = false;
+                    }
+                } else {
+                    current += ch;
+                }
+            } else {
+                if (ch === '"') {
+                    inQuotes = true;
+                } else if (ch === delimiter) {
+                    result.push(current.trim());
+                    current = '';
+                } else {
+                    current += ch;
+                }
+            }
+        }
+        result.push(current.trim());
+        return result;
+    }
+
+    _csvEscape(value, delimiter) {
+        if (value.includes(delimiter) || value.includes('"') || value.includes('\n')) {
+            return '"' + value.replace(/"/g, '""') + '"';
+        }
+        return value;
+    }
+
+    _castValue(value, schemaDef) {
+        if (!schemaDef || !value) return value;
+        switch (schemaDef.type) {
+            case 'integer': return parseInt(value, 10) || 0;
+            case 'number': return parseFloat(value) || 0;
+            case 'boolean': return value.toLowerCase() === 'true' || value === '1';
+            case 'array': try { return JSON.parse(value); } catch(e) { return [value]; }
+            case 'object': try { return JSON.parse(value); } catch(e) { return {}; }
+            default: return value;
+        }
+    }
+
+    // ============================================================
+    // 数据库统计
+    // ============================================================
+
+    /**
+     * 获取数据库统计信息
+     */
+    stats() {
+        const tableStats = {};
+        let totalRows = 0;
+        let totalIndexes = 0;
+
+        for (const [name, table] of Object.entries(this._tables)) {
+            if (name === '__meta__') continue;
+            const rowCount = table._rows.length;
+            const indexCount = Object.keys(table._indexes).length;
+            const sizeEstimate = JSON.stringify(table._rows).length;
+            tableStats[name] = {
+                rowCount,
+                indexCount,
+                sizeEstimate,
+                primaryKey: table._primaryKey,
+                columns: Object.keys(table._schema).length,
+                softDelete: table._softDelete,
+                foreignKeys: table._foreignKeys.length,
+                hooks: Object.values(table._hooks).reduce((s, a) => s + a.length, 0)
+            };
+            totalRows += rowCount;
+            totalIndexes += indexCount;
+        }
+
+        return {
+            tables: Object.keys(this._tables).filter(t => t !== '__meta__').length,
+            views: Object.keys(this._views).length,
+            triggers: Object.keys(this._triggers).length,
+            migrations: this._migrations.length,
+            plugins: this._plugins.length,
+            totalRows,
+            totalIndexes,
+            memoryMode: this._memoryMode,
+            versioning: this._versioning,
+            encrypted: !!this._encryptKey,
+            tableStats
+        };
+    }
+
+    // ============================================================
+    // 多数据库
+    // ============================================================
+
+    /**
+     * 附加另一个数据库（跨库查询）
+     * @param {string} name - 别名
+     * @param {Database} db - 另一个 Database 实例
+     */
+    attach(name, db) {
+        if (this._attached[name]) throw new Error(`Database '${name}' already attached`);
+        this._attached[name] = db;
+
+        Object.defineProperty(this, name, {
+            get: () => db,
+            enumerable: true,
+            configurable: true
+        });
+    }
+
+    detach(name) {
+        if (!this._attached[name]) throw new Error(`Database '${name}' is not attached`);
+        delete this._attached[name];
+        delete this[name];
+    }
+
+    getAttached() {
+        return Object.keys(this._attached);
+    }
+
     // ============================================================
     // 事务
     // ============================================================

package/lib/query.js

@@ -1,7 +1,7 @@
 // © Vexify 2026 All Rights Reserved.
 /**
  * JSQL Query — 链式查询构建器
- * 支持 JOIN、DISTINCT、HAVING、UNION、多字段排序、高级操作符、分页、EXPLAIN
+ * 支持 JOIN、DISTINCT、HAVING、UNION、窗口函数、缓存、CASE WHEN、toSQL
  */
 
 class Query {
@@ -19,6 +19,9 @@ class Query {
         this._joins = [];
         this._union = null;
         this._explain = false;
+        this._window = null;
+        this._cache = null;        // { ttl, result, timestamp }
+        this._caseExpr = null;     // [{ when, then }, ...] + else
     }
 
     // ============================================================
@@ -57,24 +60,12 @@ class Query {
         return this;
     }
 
-    /**
-     * 便捷分页
-     * @param {number} page - 页码（从 1 开始）
-     * @param {number} perPage - 每页数量
-     * @returns {{ rows, total, page, perPage, totalPages }}
-     */
     paginate(page = 1, perPage = 20) {
         this._limitCount = perPage;
         this._offsetCount = (page - 1) * perPage;
         const total = this._countRaw();
         const rows = this.get();
-        return {
-            rows,
-            total,
-            page,
-            perPage,
-            totalPages: Math.ceil(total / perPage)
-        };
+        return { rows, total, page, perPage, totalPages: Math.ceil(total / perPage) };
     }
 
     // ============================================================
@@ -92,6 +83,31 @@ class Query {
         return this;
     }
 
+    // ============================================================
+    // CASE WHEN
+    // ============================================================
+
+    /**
+     * CASE WHEN 表达式
+     * @example
+     * db.users.where({}).case([
+     *   { when: { age: { $lt: 18 } }, then: 'minor' },
+     *   { when: { age: { $lt: 60 } }, then: 'adult' }
+     * ], 'senior').as('ageGroup').get()
+     */
+    case(whenClauses, elseExpr) {
+        this._caseExpr = { clauses: whenClauses, else: elseExpr };
+        return this;
+    }
+
+    /**
+     * 给 CASE WHEN 结果命名
+     */
+    as(fieldName) {
+        this._caseAs = fieldName;
+        return this;
+    }
+
     // ============================================================
     // 分组 & 聚合后过滤
     // ============================================================
@@ -107,16 +123,25 @@ class Query {
     }
 
     // ============================================================
-    // JOIN
+    // 窗口函数
     // ============================================================
 
     /**
-     * INNER JOIN
-     * @param {Table} otherTable - 要 JOIN 的表
-     * @param {string} localField - 本地字段
-     * @param {string} foreignField - 对方字段
-     * @param {string} as - 别名
+     * 窗口函数
+     * @param {string} fn - 'rowNumber' | 'rank' | 'denseRank'
+     * @param {string} field - 排序字段
+     * @param {string} partitionBy - 分区字段
+     * @param {string} dir - 'asc' | 'desc'
      */
+    window(fn, field, partitionBy, dir = 'asc') {
+        this._window = { fn, field, partitionBy, dir };
+        return this;
+    }
+
+    // ============================================================
+    // JOIN
+    // ============================================================
+
     join(otherTable, localField, foreignField, as) {
         this._joins.push({ type: 'inner', table: otherTable, localField, foreignField, as });
         return this;
@@ -150,6 +175,19 @@ class Query {
         return this;
     }
 
+    // ============================================================
+    // 缓存
+    // ============================================================
+
+    /**
+     * 缓存查询结果
+     * @param {number} ttlMs - 缓存有效期（毫秒），默认 60000
+     */
+    cache(ttlMs = 60000) {
+        this._cache = { ttl: ttlMs, result: null, timestamp: 0 };
+        return this;
+    }
+
     // ============================================================
     // 执行
     // ============================================================
@@ -157,6 +195,11 @@ class Query {
     get() {
         if (this._explain) return this._getExplain();
 
+        // 缓存命中
+        if (this._cache && this._cache.result && (Date.now() - this._cache.timestamp < this._cache.ttl)) {
+            return this._cache.result;
+        }
+
         let rows = this._table._applyFilter(this._table._rows, this._conditions);
 
         // JOIN
@@ -180,12 +223,17 @@ class Query {
             rows = this._table._applyFilter(rows, this._having);
         }
 
+        // 窗口函数
+        if (this._window) {
+            rows = this._applyWindow(rows);
+        }
+
         // DISTINCT
         if (this._distinct && this._distinctField) {
             const seen = new Set();
             rows = rows.filter(r => {
                 const val = r[this._distinctField];
-                if (val === undefined) return false; // 跳过 undefined
+                if (val === undefined) return false;
                 const key = String(val);
                 if (seen.has(key)) return false;
                 seen.add(key);
@@ -206,6 +254,23 @@ class Query {
             rows = rows.slice(0, this._limitCount);
         }
 
+        // CASE WHEN
+        if (this._caseExpr) {
+            rows = rows.map(r => {
+                const row = { ...r };
+                let val = this._caseExpr.else;
+                for (const clause of this._caseExpr.clauses) {
+                    if (this._table._matchRow(row, clause.when)) {
+                        val = clause.then;
+                        break;
+                    }
+                }
+                const asField = this._caseAs || '_case';
+                row[asField] = val;
+                return row;
+            });
+        }
+
         // 字段选择
         rows = rows.map(r => ({ ...r }));
         if (this._selectFields) {
@@ -218,6 +283,12 @@ class Query {
             });
         }
 
+        // 缓存存储
+        if (this._cache) {
+            this._cache.result = rows;
+            this._cache.timestamp = Date.now();
+        }
+
         return rows;
     }
 
@@ -260,7 +331,7 @@ class Query {
     }
 
     groupStats(field) {
-        if (!this._groupBy) throw new Error('groupStats() requires groupBy() to be called first');
+        if (!this._groupBy) throw new Error('groupStats() requires groupBy()');
         const rows = this._table._applyFilter(this._table._rows, this._conditions);
         const groups = {};
 
@@ -283,7 +354,6 @@ class Query {
             g._avg = g._count > 0 ? g._sum / g._count : 0;
             delete g._rows;
         });
-
         return result;
     }
 
@@ -295,6 +365,57 @@ class Query {
         return this._table.remove(this._conditions);
     }
 
+    /**
+     * 无效缓存
+     */
+    invalidateCache() {
+        if (this._cache) {
+            this._cache.result = null;
+            this._cache.timestamp = 0;
+        }
+        return this;
+    }
+
+    // ============================================================
+    // toSQL
+    // ============================================================
+
+    /**
+     * 导出为类 SQL 字符串（调试用）
+     */
+    toSQL() {
+        const parts = ['SELECT'];
+        if (this._selectFields) {
+            parts.push(this._selectFields.join(', '));
+        } else {
+            parts.push('*');
+        }
+        parts.push('FROM', this._table._name);
+
+        if (Object.keys(this._conditions).length > 0) {
+            parts.push('WHERE', JSON.stringify(this._conditions));
+        }
+
+        if (this._groupBy) {
+            parts.push('GROUP BY', this._groupBy);
+            if (this._having) parts.push('HAVING', JSON.stringify(this._having));
+        }
+
+        if (this._orderBy.length > 0) {
+            parts.push('ORDER BY', this._orderBy.map(o => `${o.field} ${o.dir}`).join(', '));
+        }
+
+        if (this._limitCount !== null) {
+            parts.push('LIMIT', String(this._limitCount));
+        }
+
+        if (this._offsetCount > 0) {
+            parts.push('OFFSET', String(this._offsetCount));
+        }
+
+        return parts.join(' ');
+    }
+
     // ============================================================
     // 内部
     // ============================================================
@@ -319,6 +440,68 @@ class Query {
         });
     }
 
+    _applyWindow(rows) {
+        const { fn, field, partitionBy, dir } = this._window;
+
+        if (partitionBy) {
+            // 分组
+            const groups = {};
+            for (const row of rows) {
+                const key = String(row[partitionBy] ?? '__null__');
+                if (!groups[key]) groups[key] = [];
+                groups[key].push(row);
+            }
+
+            const result = [];
+            for (const group of Object.values(groups)) {
+                this._applyWindowToGroup(group, fn, field, dir);
+                result.push(...group);
+            }
+            return result;
+        }
+
+        this._applyWindowToGroup(rows, fn, field, dir);
+        return rows;
+    }
+
+    _applyWindowToGroup(rows, fn, field, dir) {
+        // 按字段排序
+        if (field) {
+            rows.sort((a, b) => {
+                const va = a[field];
+                const vb = b[field];
+                if (va < vb) return dir === 'asc' ? -1 : 1;
+                if (va > vb) return dir === 'asc' ? 1 : -1;
+                return 0;
+            });
+        }
+
+        const colName = fn === 'rowNumber' ? '_row_number' : fn === 'rank' ? '_rank' : '_dense_rank';
+        let rank = 1;
+        let denseRank = 1;
+        let prevVal = null;
+
+        for (let i = 0; i < rows.length; i++) {
+            const curVal = field ? rows[i][field] : null;
+
+            if (fn === 'rowNumber') {
+                rows[i][colName] = i + 1;
+            } else if (fn === 'rank') {
+                if (i > 0 && curVal !== prevVal) {
+                    rank = i + 1;
+                }
+                rows[i][colName] = rank;
+            } else if (fn === 'denseRank') {
+                if (i > 0 && curVal !== prevVal) {
+                    denseRank++;
+                }
+                rows[i][colName] = denseRank;
+            }
+
+            prevVal = curVal;
+        }
+    }
+
     _applyJoin(localRows, join) {
         const result = [];
         const foreignRows = join.table._rows;
@@ -346,7 +529,6 @@ class Query {
                 }
             }
         } else {
-            // inner join
             for (const lr of localRows) {
                 for (const fr of foreignRows) {
                     if (fr[join.foreignField] === lr[join.localField]) {
@@ -367,10 +549,9 @@ class Query {
         return merged;
     }
 
-    _nullRow(table, isLocal) {
+    _nullRow(table) {
         const nulls = {};
-        const schema = table._schema;
-        for (const field of Object.keys(schema)) {
+        for (const field of Object.keys(table._schema)) {
             nulls[field] = null;
         }
         return nulls;
@@ -389,7 +570,6 @@ class Query {
 
         const result = [];
         for (const g of Object.values(groups)) {
-            // 使用第一行作为基础，并添加 _group 和 _count
             const base = { ...g._rows[0] };
             base._group = g._group;
             base._count = g._count;
@@ -412,13 +592,13 @@ class Query {
             joins: this._joins.length,
             groupBy: this._groupBy,
             having: this._having,
+            window: this._window ? this._window.fn : null,
             orderBy: this._orderBy.map(o => `${o.field} ${o.dir}`),
             limit: this._limitCount,
             offset: this._offsetCount,
             estimatedCost: filtered.length * (1 + this._joins.length)
         };
 
-        // 检查索引命中
         for (const [field] of Object.entries(this._conditions)) {
             if (this._table._indexes[field]) {
                 plan.hasIndex = true;

package/lib/table.js

@@ -118,6 +118,8 @@ class Table {
             hook(data);
         }
 
+        this._db._emitChange('insert', this._name, data);
+
         return data;
     }
 
@@ -224,6 +226,7 @@ class Table {
             for (const hook of this._hooks.afterUpdate) {
                 hook(query, updates, count);
             }
+            this._db._emitChange('update', this._name, { query, updates, count });
         }
         return count;
     }
@@ -280,6 +283,7 @@ class Table {
             for (const hook of this._hooks.afterRemove) {
                 hook(query, count);
             }
+            this._db._emitChange('remove', this._name, { query, count });
         }
         return count;
     }
@@ -338,7 +342,15 @@ class Table {
     addColumn(field, definition) {
         if (this._schema[field]) throw new Error(`Column '${field}' already exists`);
         this._schema[field] = definition;
-        if (definition.default !== undefined) this._defaults[field] = definition.default;
+        if (definition.default !== undefined) {
+            this._defaults[field] = definition.default;
+            // 填充现有行的默认值
+            for (const row of this._rows) {
+                if (row[field] === undefined) {
+                    row[field] = typeof definition.default === 'function' ? definition.default() : definition.default;
+                }
+            }
+        }
         if (definition.check) this._checkConstraints.push({ field, fn: definition.check });
         if (definition.foreignKey) {
             this._foreignKeys.push({
@@ -415,6 +427,59 @@ class Table {
         };
     }
 
+    // ============================================================
+    // SELECT INTO
+    // ============================================================
+
+    /**
+     * 从查询结果创建新表
+     */
+    selectInto(newTableName, newSchema, query = {}) {
+        const rows = this._applyFilter(this._getVisibleRows(), query);
+        this._db.createTable(newTableName, newSchema);
+        const newTable = this._db._tables[newTableName];
+        for (const row of rows) {
+            newTable.insert(row);
+        }
+        return newTable;
+    }
+
+    // ============================================================
+    // 全文搜索评分
+    // ============================================================
+
+    /**
+     * 全文搜索并返回带相关性评分的排序结果
+     * @param {string} field - 搜索字段
+     * @param {string|string[]} terms - 搜索词
+     * @returns {Array} 按 _score 降序排列的结果
+     */
+    textSearch(field, terms) {
+        const searchTerms = Array.isArray(terms) ? terms : terms.split(/\s+/);
+        const rows = this._getVisibleRows();
+        const scored = [];
+
+        for (const row of rows) {
+            const value = String(row[field] || '').toLowerCase();
+            let score = 0;
+            for (const term of searchTerms) {
+                const t = term.toLowerCase();
+                const idx = value.indexOf(t);
+                if (idx !== -1) {
+                    score += 10;  // 基础命中
+                    if (idx === 0) score += 5;  // 开头匹配加分
+                    if (value === t) score += 20;  // 完全匹配加更多
+                    score += (value.length - idx) / value.length * 5;  // 靠前加权
+                }
+            }
+            if (score > 0) {
+                scored.push({ ...row, _score: score });
+            }
+        }
+
+        return scored.sort((a, b) => b._score - a._score);
+    }
+
     // ============================================================
     // 索引
     // ============================================================
@@ -471,6 +536,20 @@ class Table {
 
     _matchRow(row, query) {
         for (const [field, condition] of Object.entries(query)) {
+            // 顶层 $or / $and / $not
+            if (field === '$or') {
+                if (!Array.isArray(condition) || !condition.some(sub => this._matchRow(row, sub))) return false;
+                continue;
+            }
+            if (field === '$and') {
+                if (!Array.isArray(condition) || !condition.every(sub => this._matchRow(row, sub))) return false;
+                continue;
+            }
+            if (field === '$not') {
+                if (this._matchRow(row, condition)) return false;
+                continue;
+            }
+
             // JSON 路径: 'profile.city' 或 'data.profile.city'
             const value = this._resolvePath(row, field);
 
@@ -511,7 +590,8 @@ class Table {
             case '$nin': return Array.isArray(target) && !target.includes(value);
             case '$like':
                 if (typeof value !== 'string' || typeof target !== 'string') return false;
-                return new RegExp(target.replace(/%/g, '.*').replace(/_/g, '.'), 'i').test(value);
+                const likeRegex = target.replace(/%/g, '.*').replace(/_/g, '.');
+                return new RegExp('^' + likeRegex + '$', 'i').test(value);
             case '$regex':
                 return new RegExp(target).test(String(value));
             case '$exists':
@@ -546,6 +626,25 @@ class Table {
                 if (typeof value !== 'string') return false;
                 const terms = Array.isArray(target) ? target : [target];
                 return terms.every(t => value.toLowerCase().includes(t.toLowerCase()));
+            case '$textSearch':
+                // 高级全文搜索，带相关性评分（返回 true 即可，评分在 _textScore 中）
+                if (typeof value !== 'string') return false;
+                const searchTerms = Array.isArray(target) ? target : target.split(/\s+/);
+                const lower = value.toLowerCase();
+                return searchTerms.some(t => lower.includes(t.toLowerCase()));
+            case '$inSub':
+                // 子查询：$inSub: { table: otherTable, field: 'col', query: {} }
+                if (!target || !target.table) return false;
+                const subRows = target.table._applyFilter(target.table._rows, target.query || {});
+                return subRows.some(r => r[target.field] === value);
+            case '$notInSub':
+                if (!target || !target.table) return false;
+                const subRows2 = target.table._applyFilter(target.table._rows, target.query || {});
+                return !subRows2.some(r => r[target.field] === value);
+            case '$expr':
+                // 表达式：$expr: (value, row) => boolean
+                if (typeof target === 'function') return target(value);
+                return false;
             default:
                 return false;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jsql-neo",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "description": "JSQL — Pure JavaScript embedded database. SQL-like API, zero native dependencies, file-based or in-memory storage.",
     "main": "index.js",
     "files": [