jsql-neo 6.0.0-beta2 → 6.0.0

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL. PostgreSQL. MongoDB. Redis. SQL. TypeScript. The browser. **And it fits in one npm package.**
 
-> **v5.6.0** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo)
+> **v6.0.0** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)
@@ -232,7 +232,7 @@ npm install && npm run build                 # option 3: from source
 Verify:
 
 ```bash
-node -e "console.log(require('jsql-neo/package.json').version)"   # 5.6.0
+node -e "console.log(require('jsql-neo/package.json').version)"   # 6.0.0
 ```
 
 ### 30-second demo
@@ -1457,7 +1457,7 @@ jsql mod --engine wasm        # switch engine (restart required)
 
 ```bash
 $ jsql version
-jsql-neo v5.6.0
+jsql-neo v6.0.0
 engine: native (napi) | wasm | js
 node: v22.0.0  platform: linux x64
 ```
@@ -1478,7 +1478,7 @@ jsql tui --memory -q                      # memory mode, quiet
 jsql tui --prompt 'db> ' --no-color
 ```
 
-The status bar shows: `db=<name> dialect=<d> mode=<tui|batch> ver=5.6.0`.
+The status bar shows: `db=<name> dialect=<d> mode=<tui|batch> ver=6.0.0`.
 
 ### Keyboard shortcuts
 
@@ -4042,7 +4042,7 @@ Data dir: /root/.jsql-neo/data
 
 ```bash
 $ jsql version
-jsql-neo v5.6.0
+jsql-neo v6.0.0
 engine: native (napi) | wasm | js
 node: v22.0.0
 platform: linux x64
@@ -5119,7 +5119,7 @@ Apache License
 
 *JSQL-NEO — One engine to rule them all. MySQL. PostgreSQL. MongoDB. Redis. SQL. TypeScript. The browser.*
 
-*文档版本：v5.6.0 · 最后更新：2026-08-12*
+*文档版本：v6.0.0 · 最后更新：2026-09-26*
 
 ---
 
@@ -6889,7 +6889,7 @@ Usage: jsql version
 
 输出版本与环境信息：
 
-  jsql-neo v5.6.0
+  jsql-neo v6.0.0
   engine: native (napi) | wasm | js
   node: v22.0.0
   platform: linux x64

package/index.d.ts

@@ -85,7 +85,7 @@ declare namespace JSQLNeo {
 
   export class JSQL {
     constructor(opts?: JSQLOptions);
-    use(plugin: JSQLPlugin | ((db: JSQL) => void)): this;
+    use(plugin: JSQLPlugin | string | ((db: JSQL) => void), opts?: Record<string, unknown>): this;
     on(event: JSQLHook, fn: (...args: any[]) => unknown): this;
     onEvent(fn: (event: string, data: unknown) => void): this;
     start(): Promise<void>;
@@ -113,6 +113,15 @@ declare namespace JSQLNeo {
      * @returns 单条语句返回单个结果对象（含 columns/rows），多条返回数组。
      */
     query(sql: string, paramsOrOpts?: unknown[] | Record<string, unknown>, opts?: Record<string, unknown>): Promise<any>;
+    exists(table: string, filter?: Record<string, unknown>): Promise<boolean>;
+    prepare(sql: string): PreparedStatement;
+  }
+
+  export interface PreparedStatement {
+    sql: string;
+    all(...params: unknown[]): Promise<any>;
+    get(...params: unknown[]): Promise<Record<string, unknown> | null>;
+    run(...params: unknown[]): Promise<any>;
   }
 
   export class NativeJSQL extends JSQL {}
@@ -309,6 +318,9 @@ declare namespace JSQLNeo {
     createTable(name: string, schema: Schema): Promise<unknown>;
     insert(table: string, data: Record<string, unknown>): Promise<unknown>;
     find(table: string, filter?: Record<string, unknown>): Promise<Row[]>;
+    exists(table: string, filter?: Record<string, unknown>): boolean;
+    prepare(sql: string): PreparedStatement;
+    query(sql: string, paramsOrOpts?: unknown[] | SQLOptions, opts?: SQLOptions): Promise<SQLResult>;
     update(table: string, filter: Record<string, unknown>, data: Record<string, unknown>): Promise<number>;
     remove(table: string, filter: Record<string, unknown>): Promise<number>;
     findOne(table: string, filter?: Record<string, unknown>): Promise<Row | null>;
@@ -316,12 +328,14 @@ declare namespace JSQLNeo {
     getTables(): Promise<string[]>;
     dropTable(name: string): Promise<void>;
     getTableSchema(name: string): Promise<Schema | null>;
+    use(plugin: JSQLPlugin | string | ((db: Database) => void), opts?: Record<string, unknown>): this;
   }
 
   export class Table {
     constructor(name: string, schema: Schema, db?: unknown);
     insert(data: Record<string, unknown>): Promise<unknown>;
     find(filter?: Record<string, unknown>): Promise<Row[]>;
+    exists(filter?: Record<string, unknown>): boolean;
     updateById(id: number | string, data: Record<string, unknown>): Promise<unknown>;
     removeById(id: number | string): Promise<unknown>;
     count(): Promise<number>;
@@ -329,15 +343,27 @@ declare namespace JSQLNeo {
 
   export class Query {
     constructor(table: unknown);
+    where(conditions: Record<string, unknown>): this;
+    orderBy(field: string, dir?: 'asc' | 'desc'): this;
+    limit(n: number): this;
+    offset(n: number): this;
+    get(): Row[];
+    first(): Row | null;
+    exists(): boolean;
+    count(): number;
     exec(): Promise<Row[]>;
     then(resolve: (rows: Row[]) => unknown, reject?: (err: Error) => unknown): Promise<unknown>;
   }
 
   export class BTree {
-    constructor(order?: number);
+    constructor(order?: number, unique?: boolean);
     insert(key: unknown, value: unknown): void;
-    find(key: unknown): unknown;
-    range(min: unknown, max: unknown): unknown[];
+    search(key: unknown): number[];
+    searchMany(keys: unknown[]): number[];
+    prefix(prefix: string): number[];
+    range(min: unknown, max: unknown): number[];
+    greaterThan(min: unknown): number[];
+    lessThan(max: unknown): number[];
   }
 
   export class Cache {

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.0.0-beta1 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.0.0 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/btree.js

@@ -50,20 +50,27 @@ class BTree {
         this._size++;
     }
 
+    _lowerBound(keys, key) {
+        let lo = 0, hi = keys.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (keys[mid] < key) lo = mid + 1;
+            else hi = mid;
+        }
+        return lo;
+    }
+
     _insertNonFull(node, key, rowIndex) {
         if (node.leaf) {
-            // 查找插入位置
-            let i = node.keys.length - 1;
-            while (i >= 0 && key < node.keys[i]) i--;
-            i++;
+            const i = this._lowerBound(node.keys, key);
 
-            if (i > 0 && node.keys[i - 1] === key) {
+            if (i < node.keys.length && node.keys[i] === key) {
                 if (this._unique) {
                     this._size--;
                     return;
                 }
-                if (!node.values[i - 1].includes(rowIndex)) {
-                    node.values[i - 1].push(rowIndex);
+                if (!node.values[i].includes(rowIndex)) {
+                    node.values[i].push(rowIndex);
                 }
                 this._size--;
                 return;
@@ -119,8 +126,7 @@ class BTree {
      * （分隔键副本可能在左子树作为最大值，或在右子树作为最小值）。
      */
     _route(node, key) {
-        let i = 0;
-        while (i < node.keys.length && key > node.keys[i]) i++;
+        let i = this._lowerBound(node.keys, key);
         if (i < node.keys.length && node.keys[i] === key) {
             return this._getMax(node.children[i]).key === key ? i : i + 1;
         }
@@ -134,8 +140,43 @@ class BTree {
     search(key) {
         let node = this._root;
         while (!node.leaf) node = node.children[this._route(node, key)];
-        const i = node.keys.indexOf(key);
-        return i === -1 ? [] : node.values[i];
+        const i = this._lowerBound(node.keys, key);
+        return (i < node.keys.length && node.keys[i] === key) ? node.values[i] : [];
+    }
+
+    searchMany(keys) {
+        if (!keys || keys.length === 0) return [];
+        const out = [];
+        const seen = new Set();
+        for (let i = 0; i < keys.length; i++) {
+            const hits = this.search(keys[i]);
+            for (let j = 0; j < hits.length; j++) {
+                const idx = hits[j];
+                if (!seen.has(idx)) {
+                    seen.add(idx);
+                    out.push(idx);
+                }
+            }
+        }
+        return out;
+    }
+
+    prefix(prefix) {
+        if (prefix === undefined || prefix === null) return [];
+        const p = String(prefix);
+        const result = [];
+        let node = this._findLeaf(p);
+        while (node) {
+            for (let i = 0; i < node.keys.length; i++) {
+                const k = node.keys[i];
+                const s = k === undefined || k === null ? '' : String(k);
+                if (s < p) continue;
+                if (!s.startsWith(p)) return result;
+                result.push(...node.values[i]);
+            }
+            node = node.next;
+        }
+        return result;
     }
 
     /**
@@ -173,6 +214,18 @@ class BTree {
         return result;
     }
 
+    greaterThanEqual(min) {
+        const result = [];
+        let node = this._findLeaf(min);
+        while (node) {
+            for (let i = 0; i < node.keys.length; i++) {
+                if (node.keys[i] >= min) result.push(...node.values[i]);
+            }
+            node = node.next;
+        }
+        return result;
+    }
+
     /**
      * 小于查询（严格开区间，不含 max 本身）
      */
@@ -190,12 +243,24 @@ class BTree {
         return result;
     }
 
+    lessThanEqual(max) {
+        const result = [];
+        let node = this._root;
+        while (!node.leaf) node = node.children[0];
+        while (node) {
+            for (let i = 0; i < node.keys.length; i++) {
+                if (node.keys[i] <= max) result.push(...node.values[i]);
+                else return result;
+            }
+            node = node.next;
+        }
+        return result;
+    }
+
     _findLeaf(key) {
         let node = this._root;
         while (!node.leaf) {
-            let i = 0;
-            while (i < node.keys.length && key > node.keys[i]) i++;
-            node = node.children[i];
+            node = node.children[this._lowerBound(node.keys, key)];
         }
         return node;
     }
@@ -216,8 +281,8 @@ class BTree {
 
     _removeFromNode(node, key, rowIndex) {
         if (node.leaf) {
-            const i = node.keys.indexOf(key);
-            if (i === -1) return false;
+            const i = this._lowerBound(node.keys, key);
+            if (i >= node.keys.length || node.keys[i] !== key) return false;
             if (!node.values[i].includes(rowIndex)) return false;
             const vals = node.values[i].filter(v => v !== rowIndex);
             if (vals.length === 0) {

package/lib/database.js

@@ -435,6 +435,17 @@ class Database {
         if (!name || name.length > 64 || name === '.' || name === '..' || /[\x00-\x1f/\\]|\.\./.test(name)) {
             throw createError('ER_BAD_TABLE_NAME', name);
         }
+        if (typeof schema === 'string') {
+            const parsed = {};
+            for (const seg of schema.split(',')) {
+                const trimmed = seg.trim();
+                if (!trimmed) continue;
+                const parts = trimmed.split(/\s+/);
+                const field = parts.shift();
+                parsed[field] = parts.join(' ').toLowerCase().trim() || 'string';
+            }
+            schema = parsed;
+        }
         if (!this._runHooks('beforeCreateTable', [name, schema])) throw createError('ER_PLUGIN_ABORT', 'createTable aborted by plugin');
         if (this._tables[name] || (this._dirMode && this._meta.tables[name])) {
             throw createError('ER_TABLE_EXISTS_ERROR', name);
@@ -1076,10 +1087,11 @@ class Database {
 
     /**
      * 注册插件
-     * @param {object|function} plugin - { name, version, install(db, ctx), hooks, api, onEvent } 或函数 (作为 install)
+     * @param {object|function|string} plugin - { name, version, install(db, ctx), hooks, api, onEvent }、函数或内置插件名
+     * @param {object} [opts] - 传给内置插件工厂的配置，例如 db.use('timestamps', { createdField: 'created_at' })
      */
-    use(plugin) {
-        return applyPlugin(this, plugin);
+    use(plugin, opts) {
+        return applyPlugin(this, plugin, opts);
     }
 
     _buildCtx(plugin) {
@@ -1212,7 +1224,7 @@ class Database {
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeFind', [tableName, { filter, opts }])) return [];
         const { limit, offset = 0 } = opts;
-        let rows = table._applyFilter(table._rows, filter || {});
+        let rows = table._applyFilterOptimized(table._rows, filter || {});
         if (limit > 0) rows = rows.slice(offset, offset + limit);
         else if (offset > 0) rows = rows.slice(offset);
         this._touchTable(tableName);
@@ -1220,6 +1232,25 @@ class Database {
         return rows;
     }
 
+    exists(tableName, filter = {}) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        this._touchTable(tableName);
+        return table.exists(filter);
+    }
+
+    async query(sql, paramsOrOpts, opts) {
+        const { executeSQL } = require('./sql');
+        if (!this._runHooks('beforeQuery', [sql, paramsOrOpts, opts])) return null;
+        const result = await executeSQL(this, sql, paramsOrOpts, opts);
+        this._runHooks('afterQuery', [sql, paramsOrOpts, opts, result]);
+        return result;
+    }
+
+    prepare(sql) {
+        return require('./prepared').createPrepared(this, sql);
+    }
+
     findById(tableName, id) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);

package/lib/mongo_server.js

@@ -322,7 +322,7 @@ class MongoServer {
           localTime: new Date(), logicalSessionTimeoutMinutes: 30, connectionId: 1,
         };
       case 'ping': return { ok: 1 };
-      case 'buildInfo': return { ok: 1, version: '5.6.0-jsql-neo', gitVersion: 'jsql-neo', versionArray: [5, 6, 0, 0] };
+      case 'buildInfo': return { ok: 1, version: '6.0.0-jsql-neo', gitVersion: 'jsql-neo', versionArray: [6, 0, 0, 0] };
       case 'getParameter': return { ok: 1 };
       case 'endSessions': return { ok: 1 };
       case 'listDatabases':

package/lib/native_client.js

@@ -499,11 +499,15 @@ class JSQL {
     this._buffer[table].push(arr[0]);
     this._bufferSize++;
     const flushed = await this._flush();
-    return flushed && flushed[table] ? flushed[table] : null;
+    const result = flushed && flushed[table] ? flushed[table] : null;
+    this._emit('insert', { table, count: arr.length, ids: result });
+    this._runHooks('afterInsert', [table, filtered, result]);
+    return result;
   }
 
   async createTable(name, schema) {
     await this._flush();
+    if (typeof schema === 'string') schema = parseSchemaString(schema);
     if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
     const r = safeParse(native.jsqlCreateTable(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
@@ -656,6 +660,15 @@ class JSQL {
     return result;
   }
 
+  async exists(table, filter = {}) {
+    const rows = await this.find(table, filter, { limit: 1 });
+    return Array.isArray(rows) && rows.length > 0;
+  }
+
+  prepare(sql) {
+    return require('./prepared').createPrepared(this, sql);
+  }
+
   async stop() {
     this._flushOpsNow();
     await this._flush();

package/lib/pg_server.js

@@ -762,7 +762,7 @@ class PgServer {
     this.auth = options.auth || null;           // { user: { password, databases: [...] } }
     this.noAuth = options.noAuth === true;
     this.dataDir = options.dataDir || null;
-    this.version = '5.1.3';
+    this.version = require('../package.json').version;
     this._server = null;
     this._sockets = new Set();
     this._connSeq = 0;

package/lib/plugin.js

@@ -159,7 +159,7 @@ function buildPluginContext(engine, plugin) {
     /** 主动触发一个钩子（含自定义钩子） */
     hook(hookName, ...args) { return engine.runHook(hookName, ...args); },
     /** 组合：加载另一个插件 */
-    use(other) { return engine.use(other); },
+    use(other, opts) { return engine.use(other, opts); },
     /** 表清单（同步） */
     tables() {
       if (engine._tableNames) return Array.from(engine._tableNames);
@@ -191,7 +191,7 @@ function buildPluginContext(engine, plugin) {
 
 /**
  * 把一个插件应用到引擎：登记钩子、调用 install、挂载事件与 API。
- * 引擎的 `use()` 只需 `return applyPlugin(this, plugin)`。
+ * 引擎的 `use()` 只需 `return applyPlugin(this, plugin, opts)`。
  * @returns {object} engine（便于链式调用）
  */
 function applyPlugin(engine, plugin, opts) {

package/lib/plugins/timestamps.js

@@ -2,7 +2,8 @@
  * timestamps —— 自动维护创建/更新时间戳。
  *
  * 在插入时补全 createdAt / updatedAt（已存在则不覆盖 createdAt），
- * 更新时刷新 updatedAt。所有引擎通用，钩子内只原地修改数据、不回调引擎。
+ * 更新时刷新 updatedAt。建表时若 schema 未声明这两个字段，会原地补上，
+ * 以便 native / WASM 引擎按 schema 列持久化。钩子内只原地修改数据、不回调引擎。
  *
  * @example
  * db.use(require('jsql-neo/lib/plugins').timestamps());
@@ -22,9 +23,22 @@ function createTimestamps(opts = {}) {
     if (row[updatedField] === undefined || opts.overwriteUpdated) row[updatedField] = t;
   };
 
+  const stampDef = { type: 'string' };
+
+  const ensureStampFields = (schema) => {
+    if (!schema) return;
+    if (typeof schema === 'string') return;
+    if (typeof schema !== 'object') return;
+    if (schema[createdField] === undefined) schema[createdField] = { ...stampDef };
+    if (schema[updatedField] === undefined) schema[updatedField] = { ...stampDef };
+  };
+
   return definePlugin('timestamps', {
     config: { createdField, updatedField },
     hooks: {
+      beforeCreateTable(_name, schema) {
+        ensureStampFields(schema);
+      },
       beforeInsert(_table, rows) {
         if (Array.isArray(rows)) rows.forEach(r => stampRow(r, true));
         else stampRow(rows, true);

package/lib/prepared.js

@@ -0,0 +1,37 @@
+/**
+ * Shared prepared-statement helper for JS / native / WASM engines.
+ * parse once, bind on each run. Compatible with executeSQL placeholder rules.
+ */
+
+function createPrepared(engine, sql) {
+  if (typeof sql !== 'string' || sql.length === 0) {
+    throw new Error('prepare() requires a SQL string');
+  }
+  const bound = {
+    sql,
+    async all(...params) {
+      const values = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
+      return engine.query(sql, values);
+    },
+    async get(...params) {
+      const r = await bound.all(...params);
+      if (!r) return null;
+      if (Array.isArray(r.raw) && r.raw.length > 0) return r.raw[0];
+      if (Array.isArray(r.rows) && r.rows.length > 0) {
+        if (r.columns && Array.isArray(r.rows[0])) {
+          const obj = {};
+          for (let i = 0; i < r.columns.length; i++) obj[r.columns[i]] = r.rows[0][i];
+          return obj;
+        }
+        return r.rows[0];
+      }
+      return null;
+    },
+    async run(...params) {
+      return bound.all(...params);
+    }
+  };
+  return bound;
+}
+
+module.exports = { createPrepared };

package/lib/query.js

@@ -25,6 +25,7 @@ class Query {
         this._cache = null;        // { ttl, result, timestamp }
         this._caseExpr = null;     // [{ when, then }, ...] + else
         this._optimizerHints = {}; // { useHashJoin: true }
+        this._forUpdate = false;
     }
 
     // ============================================================
@@ -302,8 +303,6 @@ class Query {
             });
         }
 
-        // 字段选择
-        rows = rows.map(r => ({ ...r }));
         if (this._selectFields) {
             rows = rows.map(r => {
                 const obj = {};
@@ -312,6 +311,12 @@ class Query {
                 }
                 return obj;
             });
+        } else if (this._caseExpr) {
+            // CASE already cloned
+        } else {
+            const copy = new Array(rows.length);
+            for (let i = 0; i < rows.length; i++) copy[i] = { ...rows[i] };
+            rows = copy;
         }
 
         // 缓存存储
@@ -329,6 +334,14 @@ class Query {
         return rows.length > 0 ? rows[0] : null;
     }
 
+    exists() {
+        const prev = this._limitCount;
+        this._limitCount = 1;
+        const rows = this.get();
+        this._limitCount = prev;
+        return rows.length > 0;
+    }
+
     count() {
         return this._countRaw();
     }
@@ -533,10 +546,16 @@ class Query {
                 }
             }
         } else if (join.type === 'right') {
+            const localMap = new Map();
+            for (const lr of localRows) {
+                const key = lr[join.localField];
+                if (key === undefined || key === null) continue;
+                if (!localMap.has(key)) localMap.set(key, []);
+                localMap.get(key).push(lr);
+            }
             for (const fr of foreignTable._rows) {
-                const key = fr[join.foreignField];
-                const matches = localRows.filter(lr => lr[join.localField] === key);
-                if (matches.length === 0) {
+                const matches = localMap.get(fr[join.foreignField]);
+                if (!matches || matches.length === 0) {
                     result.push(this._rightNullRow(localRows, fr, join));
                 } else {
                     for (const lr of matches) {

package/lib/table.js

@@ -347,8 +347,17 @@ class Table {
     }
 
     findOne(query = {}) {
-        const rows = this.find(query);
-        return rows.length > 0 ? rows[0] : null;
+        let rows = this._getVisibleRows();
+        if (Object.keys(query).length > 0) {
+            rows = this._applyFilterOptimized(rows, query);
+        }
+        return rows.length > 0 ? { ...rows[0] } : null;
+    }
+
+    exists(query = {}) {
+        if (Object.keys(query).length === 0) return this._getVisibleRows().length > 0;
+        const rows = this._applyFilterOptimized(this._getVisibleRows(), query);
+        return rows.length > 0;
     }
 
     findById(id) {
@@ -853,39 +862,77 @@ class Table {
     // 内部: 过滤器（B-Tree 加速）
     // ============================================================
 
+    _rowsFromIndices(indices) {
+        const subset = [];
+        for (let i = 0; i < indices.length; i++) {
+            const row = this._rows[indices[i]];
+            if (row) subset.push(row);
+        }
+        return subset;
+    }
+
+    _likePrefix(pattern) {
+        if (typeof pattern !== 'string' || pattern.length === 0) return null;
+        if (pattern[0] === '%' || pattern[0] === '_') return null;
+        let end = pattern.length;
+        for (let i = 0; i < pattern.length; i++) {
+            const c = pattern[i];
+            if (c === '%' || c === '_') { end = i; break; }
+        }
+        return end > 0 ? pattern.slice(0, end) : null;
+    }
+
     _applyFilterOptimized(rows, query) {
         this._ensureBTrees();
-        // 尝试用 B-Tree 加速
         for (const [field, condition] of Object.entries(query)) {
             if (field === '$or' || field === '$and' || field === '$not') continue;
-            // 等值查询用 B-Tree
             if (typeof condition !== 'object' || condition === null || Array.isArray(condition) || condition instanceof RegExp) {
                 if (this._btrees[field]) {
                     const indices = this._btrees[field].search(condition);
-                    if (indices.length > 0) {
-                        const subset = indices.map(i => this._rows[i]).filter(r => r);
-                        return this._applyFilter(subset, query);
-                    }
-                    return [];
+                    if (indices.length === 0) return [];
+                    return this._applyFilter(this._rowsFromIndices(indices), query);
                 }
                 if (this._indexes[field] && this._indexes[field].has(condition)) {
-                    const indices = this._indexes[field].get(condition);
-                    const subset = indices.map(i => this._rows[i]).filter(r => r);
-                    return this._applyFilter(subset, query);
+                    return this._applyFilter(this._rowsFromIndices(this._indexes[field].get(condition)), query);
                 }
                 if (this._indexes[field]) return [];
             }
-            // 范围查询用 B-Tree
             if (condition && typeof condition === 'object') {
-                if (condition.$gt !== undefined && condition.$lt !== undefined && this._btrees[field]) {
-                    const indices = this._btrees[field].range(condition.$gt, condition.$lt);
-                    const subset = indices.map(i => this._rows[i]).filter(r => r);
-                    return this._applyFilter(subset, query);
+                if (this._btrees[field] && Array.isArray(condition.$in) && condition.$in.length > 0) {
+                    const indices = this._btrees[field].searchMany(condition.$in);
+                    if (indices.length === 0) return [];
+                    return this._applyFilter(this._rowsFromIndices(indices), query);
+                }
+                if (this._btrees[field] && typeof condition.$like === 'string') {
+                    const prefix = this._likePrefix(condition.$like);
+                    if (prefix) {
+                        const indices = this._btrees[field].prefix(prefix);
+                        if (indices.length === 0) return [];
+                        return this._applyFilter(this._rowsFromIndices(indices), query);
+                    }
                 }
-                if (condition.$gte !== undefined && condition.$lte !== undefined && this._btrees[field]) {
-                    const indices = this._btrees[field].range(condition.$gte, condition.$lte);
-                    const subset = indices.map(i => this._rows[i]).filter(r => r);
-                    return this._applyFilter(subset, query);
+                if (this._btrees[field] && (condition.$gt !== undefined || condition.$gte !== undefined ||
+                    condition.$lt !== undefined || condition.$lte !== undefined || condition.$between)) {
+                    let min, max, exclusiveMin = false, exclusiveMax = false;
+                    if (condition.$between && Array.isArray(condition.$between) && condition.$between.length === 2) {
+                        min = condition.$between[0];
+                        max = condition.$between[1];
+                    } else {
+                        if (condition.$gte !== undefined) min = condition.$gte;
+                        else if (condition.$gt !== undefined) { min = condition.$gt; exclusiveMin = true; }
+                        if (condition.$lte !== undefined) max = condition.$lte;
+                        else if (condition.$lt !== undefined) { max = condition.$lt; exclusiveMax = true; }
+                    }
+                    if (min === undefined && max === undefined) continue;
+                    let indices;
+                    if (min !== undefined && max !== undefined) {
+                        indices = this._btrees[field].range(min, max);
+                    } else if (min !== undefined) {
+                        indices = exclusiveMin ? this._btrees[field].greaterThan(min) : this._btrees[field].greaterThanEqual(min);
+                    } else {
+                        indices = exclusiveMax ? this._btrees[field].lessThan(max) : this._btrees[field].lessThanEqual(max);
+                    }
+                    return this._applyFilter(this._rowsFromIndices(indices), query);
                 }
             }
         }

package/lib/wasm_client.js

@@ -484,7 +484,10 @@ class JSQL {
     this._buffer[table].push(arr[0]);
     this._bufferSize++;
     const flushed = await this._flush();
-    return flushed && flushed[table] ? flushed[table] : null;
+    const result = flushed && flushed[table] ? flushed[table] : null;
+    this._emit('insert', { table, count: arr.length, ids: result });
+    this._runHooks('afterInsert', [table, arr, result]);
+    return result;
   }
 
   async insertMany(table, data) {
@@ -493,6 +496,7 @@ class JSQL {
 
   async createTable(name, schema) {
     await this._flush();
+    if (typeof schema === 'string') schema = parseSchemaString(schema);
     if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
     const r = safeJsonParse(wasmBindings.jsql_create_table(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
@@ -692,6 +696,15 @@ class JSQL {
     return result;
   }
 
+  async exists(table, filter = {}) {
+    const rows = await this.find(table, filter, { limit: 1 });
+    return Array.isArray(rows) && rows.length > 0;
+  }
+
+  prepare(sql) {
+    return require('./prepared').createPrepared(this, sql);
+  }
+
   async stop() {
     await this._flush();
     this._runHooks('onStop', []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.0.0-beta2",
+  "version": "6.0.0",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -45,7 +45,7 @@
   ],
   "scripts": {
     "postinstall": "node postinstall.js",
-    "test": "node test/smoke.js && node test/sql-parser.test.js",
+    "test": "node test/smoke.js && node test/sql-parser.test.js && node test/query-opt.test.js",
     "test:parser": "node test/sql-parser.test.js",
     "test:btree": "node test/btree.test.js",
     "test:native": "node test/native.test.js",

package/test/btree.test.js

@@ -58,6 +58,22 @@ function validate(bt) {
   ok('non-unique remove value keeps key until last', n.search('a').length === 0 && n.size === 1);
 }
 
+/* ---- 二分查找 / IN / 前缀 ---- */
+{
+  const bt = new BTree(16);
+  for (let i = 0; i < 200; i++) bt.insert(i, i);
+  ok('binary search mid', JSON.stringify(bt.search(123)) === '[123]');
+  ok('searchMany unique', JSON.stringify(bt.searchMany([0, 199, 50, 50]).sort((a, b) => a - b)) === '[0,50,199]');
+  ok('greaterThanEqual last two', JSON.stringify(bt.greaterThanEqual(198).sort((a, b) => a - b)) === '[198,199]');
+  ok('lessThanEqual first two', JSON.stringify(bt.lessThanEqual(1).sort((a, b) => a - b)) === '[0,1]');
+}
+
+{
+  const bt = new BTree(8);
+  ['alpha', 'alpine', 'beta', 'alpine'].forEach((k, i) => bt.insert(k, i));
+  ok('prefix alp', JSON.stringify(bt.prefix('alp').sort((a, b) => a - b)) === '[0,1,3]');
+}
+
 /* ---- 多值键删除只影响目标 rowIndex（size 对照 distinct keys） ---- */
 {
   const bt = new BTree(8);

package/test/query-opt.test.js

@@ -0,0 +1,109 @@
+/*
+ * Query / B-Tree / exists / prepare 回归
+ *   node test/query-opt.test.js
+ */
+const Database = require('../lib/database');
+const BTree = require('../lib/btree');
+
+let passed = 0, failed = 0;
+function ok(name, cond, extra) {
+  if (cond) { passed++; }
+  else { failed++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra) : ''); }
+}
+
+{
+  const bt = new BTree(8);
+  for (let i = 0; i < 80; i++) bt.insert(i, i);
+  ok('search hit', JSON.stringify(bt.search(42)) === '[42]');
+  ok('search miss', bt.search(999).length === 0);
+  ok('searchMany', JSON.stringify(bt.searchMany([1, 5, 999, 5]).sort((a, b) => a - b)) === '[1,5]');
+  ok('prefix numeric-as-string', bt.prefix('7').length > 0);
+  ok('gte/gt', bt.greaterThanEqual(78).length === 2 && bt.greaterThan(78).length === 1);
+  ok('lte/lt', bt.lessThanEqual(1).length === 2 && bt.lessThan(1).length === 1);
+}
+
+{
+  const bt = new BTree(8);
+  ['alice', 'albert', 'bob', 'carol', 'art'].forEach((n, i) => bt.insert(n, i));
+  const hits = bt.prefix('al').sort((a, b) => a - b);
+  ok('string prefix al', JSON.stringify(hits) === '[0,1]');
+  ok('string prefix z', bt.prefix('z').length === 0);
+}
+
+{
+  const db = new Database(':memory:');
+  db.createTable('users', {
+    id: { type: 'integer', primaryKey: true, autoIncrement: true },
+    name: { type: 'string', unique: true },
+    age: { type: 'integer' }
+  });
+  db.users.insertMany([
+    { name: 'alice', age: 20 },
+    { name: 'albert', age: 30 },
+    { name: 'bob', age: 40 },
+    { name: 'carol', age: 50 }
+  ]);
+
+  ok('table.exists true', db.users.exists({ name: 'bob' }) === true);
+  ok('table.exists false', db.users.exists({ name: 'zack' }) === false);
+  ok('db.exists true', db.exists('users', { age: { $gte: 50 } }) === true);
+  ok('db.exists false', db.exists('users', { age: { $gt: 90 } }) === false);
+  ok('query.exists', db.users.where({ age: { $lt: 25 } }).exists() === true);
+
+  const inRows = db.users.find({ name: { $in: ['alice', 'carol', 'nope'] } });
+  ok('$in via btree', inRows.length === 2 && inRows.every(r => r.name === 'alice' || r.name === 'carol'));
+
+  const likeRows = db.users.find({ name: { $like: 'al%' } });
+  ok('$like prefix via btree', likeRows.length === 2 && likeRows.every(r => r.name.startsWith('al')));
+
+  const rangeRows = db.users.find({ age: { $gte: 30, $lte: 40 } });
+  ok('range via btree', rangeRows.length === 2);
+
+  const one = db.users.findOne({ name: 'bob' });
+  ok('findOne no full clone', one && one.name === 'bob' && one.age === 40);
+}
+
+(async () => {
+  const db = new Database(':memory:');
+  db.createTable('users', {
+    id: { type: 'integer', primaryKey: true, autoIncrement: true },
+    name: { type: 'string' },
+    age: { type: 'integer' }
+  });
+  db.users.insertMany([
+    { name: 'alice', age: 20 },
+    { name: 'bob', age: 40 }
+  ]);
+
+  const stmt = db.prepare('SELECT name, age FROM users WHERE age > ? ORDER BY age ASC');
+  const r = await stmt.all([25]);
+  ok('prepare.all columns', r && Array.isArray(r.columns) && r.columns.includes('name'));
+  ok('prepare.all rows', r && r.rows && r.rows.length === 1 && (r.rows[0][0] === 'bob' || r.rows[0].name === 'bob'), r && r.rows);
+
+  const first = await stmt.get(10);
+  ok('prepare.get', first && (first.name === 'alice' || first[0] === 'alice'), first);
+
+  const empty = await db.prepare('SELECT name FROM users WHERE name = ?').get('nope');
+  ok('prepare.get empty', empty === null);
+
+  {
+    const pdb = new Database(':memory:');
+    pdb.use('timestamps', { createdField: 'created_at', updatedField: 'updated_at' });
+    pdb.createTable('notes', { id: { type: 'integer', primaryKey: true, autoIncrement: true }, title: { type: 'string' } });
+    const schema = pdb.getTableSchema('notes');
+    ok('use opts timestamps fields', !!(schema && schema.created_at && schema.updated_at), schema);
+    pdb.insert('notes', { title: 'hello' });
+    const row = pdb.notes.findOne({ title: 'hello' });
+    ok('timestamps stamped', !!(row && row.created_at && row.updated_at), row);
+
+    let afterInsertHits = 0;
+    pdb.on('afterInsert', () => { afterInsertHits++; });
+    pdb.insert('notes', { title: 'one' });
+    ok('single-row afterInsert', afterInsertHits === 1, afterInsertHits);
+    pdb.insert('notes', [{ title: 'a' }, { title: 'b' }]);
+    ok('batch afterInsert', afterInsertHits === 2, afterInsertHits);
+  }
+
+  console.log(failed === 0 ? `\nALL ${passed} QUERY-OPT TESTS PASSED` : `\n${failed} FAILURES (${passed} passed)`);
+  process.exit(failed === 0 ? 0 : 1);
+})().catch(e => { console.error('FATAL', e); process.exit(1); });

package/wasm/browser.mjs

@@ -174,10 +174,16 @@ export class JSQL {
     }
   }
 
-  use(plugin) {
+  use(plugin, opts) {
+    if (typeof plugin === 'string') {
+      throw new Error('use: builtin plugin names require the Node plugin runtime; pass a plugin object');
+    }
     if (typeof plugin === 'function') {
       plugin = { install: plugin };
     }
+    if (opts && plugin && typeof plugin === 'object') {
+      plugin.config = Object.assign({}, plugin.config || {}, opts);
+    }
     if (plugin.hooks) {
       for (const [event, fn] of Object.entries(plugin.hooks)) {
         if (this._hooks[event]) {
@@ -377,7 +383,10 @@ export class JSQL {
     this._buffer[table].push(arr[0]);
     this._bufferSize++;
     const flushed = await this._flush();
-    return flushed && flushed[table] ? flushed[table] : null;
+    const result = flushed && flushed[table] ? flushed[table] : null;
+    this._emit('insert', { table, count: arr.length, ids: result });
+    this._runHooks('afterInsert', [table, arr, result]);
+    return result;
   }
 
   async insertMany(table, data) {
@@ -386,6 +395,7 @@ export class JSQL {
 
   async createTable(name, schema) {
     await this._flush();
+    if (typeof schema === 'string') schema = parseSchemaString(schema);
     if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
     const r = safeJsonParse(jsql_create_table(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');

package/wasm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo-wasm",
-  "version": "5.6.0",
+  "version": "6.0.0",
   "files": [
     "jsql_neo_wasm_bg.wasm",
     "jsql_neo_wasm.js",