jsql-neo 3.4.3 → 3.4.6

package/README.md

@@ -1,11 +1,22 @@
-# JSQL-NEO v3.1.0
+# JSQL-NEO v3.4.3
 
-Rust-powered embedded database. Runs via **WASM** (zero native deps) or as a standalone **HTTP server**.
+Rust-powered embedded database with **three engines** in one npm package.
 
-## Quick Start (WASM — no server needed)
+## Engines
+
+| Engine | Entry | Use Case | Speed |
+|--------|-------|----------|-------|
+| **WASM** (Rust → wasm-pack) | `JSQL` | Zero native deps, Node.js | 1.4M rows/sec insert |
+| **HTTP** (Rust actix-web) | `HttpJSQL` | Multi-process / remote | 340K rows/sec insert |
+| **Pure JS** (Database class) | `Database` | Local JSON file, SQLite-like | 617K rows/sec insert |
+
+## Quick Start
+
+### WASM (no server, zero deps)
 
 ```js
 const { JSQL } = require('jsql-neo');
+
 const db = new JSQL();
 await db.start();
 
@@ -16,26 +27,94 @@ await db.createTable('users', {
 
 const [id] = await db.insert('users', { name: 'Alice', age: 30 });
 const user = await db.findById('users', id);
-console.log(user);
+// → { id: 1, fields: { name: 'Alice', age: 30 }, created_at: '...', updated_at: '...' }
+
+await db.stop();
 ```
 
-## HTTP Server
+### Pure JS (local file, SQLite-like)
+
+```js
+const { Database } = require('jsql-neo');
+
+const db = new Database('/tmp/mydb.json');
+const users = db.createTable('users', {
+  id:   { type: 'integer', autoIncrement: true, primaryKey: true },
+  name: { type: 'string', length: 32 },
+  age:  { type: 'integer' }
+});
+
+const ids = users.insertMany([{ name: 'Alice', age: 30 }, { name: 'Bob', age: 25 }]);
+users.updateById(ids[0], { age: 31 });
+const user = users.findById(ids[0]);
+db.save();
+```
+
+### HTTP Server
 
 ```bash
-# Start the server
 JSQL_DATA_DIR=/tmp/jsql-neo npx jsql-neo
+```
 
-# Connect from JS
+```js
 const { HttpJSQL } = require('jsql-neo');
+
 const db = new HttpJSQL({ host: '127.0.0.1', port: 6379 });
+await db.start();
+
+await db.createTable('users', { name: { type: 'string' }, age: { type: 'integer' } });
+const [id] = await db.insert('users', { name: 'Alice', age: 30 });
+const user = await db.findById('users', id);
+
+await db.stop();
+```
+
+## API
+
+| Method | WASM | HTTP | Pure JS | Description |
+|--------|------|------|---------|-------------|
+| `createTable(name, schema)` | ✅ | ✅ | ✅ | Define table with typed fields |
+| `insert(table, data)` | ✅ | ✅ | ✅ | Insert row(s), returns IDs |
+| `findById(table, id)` | ✅ | ✅ | ✅ | O(1) PK lookup |
+| `find(table, filter?)` | ✅ | ✅ | ✅ | Filtered query with B-Tree index |
+| `count(table)` | ✅ | ✅ | ✅ | Row count |
+| `updateById(table, id, data)` | ✅ | ✅ | ✅ | O(1) PK update |
+| `removeById(table, id)` | ✅ | ✅ | ✅ | O(1) PK delete |
+| `dropTable(name)` | ✅ | ✅ | ✅ | Remove table |
+
+All engines share the same async API for CRUD operations.
+
+## Performance (Pure JS, 100K rows)
+
+| Operation | Time | Rate |
+|-----------|------|------|
+| Insert 100K | 128 ms | 781K rows/sec |
+| findById × 10,000 | 3 ms | 0.3 μs each |
+| updateById × 10,000 | 82 ms | 8.2 μs each (O(1) hash index) |
+| count × 100 | 0 ms | — |
+| findAll × 5 | 16 ms | — |
+| Filtered query × 100 | 407 ms | — |
+
+## Schema Field Options
+
+```js
+{
+  type: 'string' | 'integer' | 'float' | 'boolean',
+  primaryKey: true,       // PK field (auto-indexed)
+  autoIncrement: true,    // Auto-generate integer PK
+  length: 32,             // Max string length
+  default: 'value',       // Default value
+  nullable: true          // Allow null
+}
 ```
 
 ## Features
 
-- In-memory or persistent (WAL + snapshot) storage
-- B-Tree indexing + HashMap O(1) PK lookups
-- Strings Pool for memory-efficient string storage
+- Three engines: WASM (native Rust), HTTP (actix-web), Pure JS (local JSON)
+- O(1) primary key hash index (`FxHashMap` / `Map`)
+- B-Tree indexing for range queries
+- WAL + snapshot crash recovery (HTTP engine)
+- Strings Pool for memory-efficient storage
 - Batch insert / update / delete
 - Cursor-based pagination
-- Transaction support
-- WASM — zero native dependencies, runs in Node.js and browsers
+- Transaction support (HTTP engine)

package/lib/wasm_client.js

@@ -5,9 +5,90 @@ function safeJsonParse(str) {
   try { return JSON.parse(str); } catch { return str; }
 }
 
+const textEncoder = new TextEncoder();
+
+function encodeBatch(rows) {
+  if (rows.length === 0) return new Uint8Array(0);
+  const fieldNames = Object.keys(rows[0]);
+  const nFields = fieldNames.length;
+
+  const nameBytes = fieldNames.map(n => textEncoder.encode(n));
+  let size = 1;
+  for (const nb of nameBytes) size += 1 + nb.length;
+  size += 4;
+
+  const strBufs = [];
+  for (let ri = 0; ri < rows.length; ri++) {
+    const row = rows[ri];
+    for (let fi = 0; fi < nFields; fi++) {
+      const val = row[fieldNames[fi]];
+      if (val === null || val === undefined) {
+        size += 1;
+        strBufs.push(null);
+      } else if (typeof val === 'number') {
+        size += 9;
+        strBufs.push(null);
+      } else if (typeof val === 'string') {
+        const b = textEncoder.encode(val);
+        strBufs.push(b);
+        size += 1 + 4 + b.length;
+      } else {
+        size += 2;
+        strBufs.push(val ? 1 : 0);
+      }
+    }
+  }
+
+  const buf = new Uint8Array(size);
+  const dv = new DataView(buf.buffer, 0, size);
+  let off = 0;
+
+  buf[off++] = nFields;
+  for (const nb of nameBytes) {
+    buf[off++] = nb.length;
+    buf.set(nb, off);
+    off += nb.length;
+  }
+
+  dv.setUint32(off, rows.length, true);
+  off += 4;
+
+  let si = 0;
+  for (const row of rows) {
+    for (let fi = 0; fi < nFields; fi++) {
+      const val = row[fieldNames[fi]];
+      const item = strBufs[si++];
+      if (val === null || val === undefined) {
+        buf[off++] = 0;
+      } else if (typeof val === 'number') {
+        if (Number.isInteger(val)) {
+          buf[off++] = 1;
+          dv.setBigInt64(off, BigInt(val), true);
+          off += 8;
+        } else {
+          buf[off++] = 2;
+          dv.setFloat64(off, val, true);
+          off += 8;
+        }
+      } else if (typeof val === 'string') {
+        buf[off++] = 3;
+        dv.setUint32(off, item.length, true);
+        off += 4;
+        buf.set(item, off);
+        off += item.length;
+      } else {
+        buf[off++] = 4;
+        buf[off++] = item;
+      }
+    }
+  }
+
+  return buf;
+}
+
 class JSQL {
   constructor(opts = {}) {
-    this._flushThreshold = opts.flushThreshold || 2000;
+    this._flushThreshold = opts.flushThreshold || 5000;
     this._buffer = {};
     this._bufferSize = 0;
   }
@@ -15,7 +96,8 @@ class JSQL {
   async start() {}
 
   async _insertBatch(table, rows) {
-    const r = safeJsonParse(wasmBindings.jsql_insert(table, JSON.stringify(rows)));
+    const bin = encodeBatch(rows);
+    const r = safeJsonParse(wasmBindings.jsql_insert_buf(table, bin));
     if (r && r.error) throw new Error(r.error);
     return r;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jsql-neo",
-    "version": "3.4.3",
+    "version": "3.4.6",
     "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
     "main": "index.js",
     "files": [

package/wasm/jsql_neo_wasm.d.ts

@@ -15,6 +15,8 @@ export function jsql_insert(table: string, data_json: string): string;
 
 export function jsql_insert_buf(table: string, data: Uint8Array): string;
 
+export function jsql_insert_buf_count(table: string, data: Uint8Array): string;
+
 export function jsql_remove_by_id(table: string, id: bigint): string;
 
 export function jsql_update_by_id(table: string, id: bigint, data_json: string): string;

package/wasm/jsql_neo_wasm.js

@@ -155,6 +155,29 @@ function jsql_insert_buf(table, data) {
 }
 exports.jsql_insert_buf = jsql_insert_buf;
 
+/**
+ * @param {string} table
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function jsql_insert_buf_count(table, data) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jsql_insert_buf_count(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.jsql_insert_buf_count = jsql_insert_buf_count;
+
 /**
  * @param {string} table
  * @param {bigint} id

package/wasm/jsql_neo_wasm_bg.wasm.d.ts

@@ -8,6 +8,7 @@ export const jsql_find: (a: number, b: number, c: number, d: number, e: number,
 export const jsql_find_by_id: (a: number, b: number, c: bigint) => [number, number];
 export const jsql_insert: (a: number, b: number, c: number, d: number) => [number, number];
 export const jsql_insert_buf: (a: number, b: number, c: number, d: number) => [number, number];
+export const jsql_insert_buf_count: (a: number, b: number, c: number, d: number) => [number, number];
 export const jsql_remove_by_id: (a: number, b: number, c: bigint) => [number, number];
 export const jsql_update_by_id: (a: number, b: number, c: bigint, d: number, e: number) => [number, number];
 export const __wbindgen_malloc: (a: number, b: number) => number;