bun-sqlite-for-rxdb 1.0.1

package/benchmarks/query-builder-benchmark.ts

@@ -0,0 +1,88 @@
+import { buildWhereClause } from '../src/query/builder';
+import type { RxJsonSchema, MangoQuerySelector, RxDocumentData } from 'rxdb';
+
+console.log("🏴‍☠️ Query Builder Performance Benchmark\n");
+
+type TestDoc = {
+  id: string;
+  name: string;
+  age: number;
+  email: string;
+  status: string;
+  _deleted: boolean;
+  _attachments: {};
+  _rev: string;
+  _meta: { lwt: number };
+};
+
+const schema: RxJsonSchema<RxDocumentData<TestDoc>> = {
+  version: 0,
+  primaryKey: 'id',
+  type: 'object',
+  properties: {
+    id: { type: 'string', maxLength: 100 },
+    name: { type: 'string' },
+    age: { type: 'number' },
+    email: { type: 'string' },
+    status: { type: 'string' },
+    _deleted: { type: 'boolean' },
+    _attachments: { type: 'object' },
+    _rev: { type: 'string' },
+    _meta: {
+      type: 'object',
+      properties: {
+        lwt: { type: 'number' }
+      },
+      required: ['lwt']
+    }
+  },
+  required: ['id', 'name', 'age', '_deleted', '_rev', '_meta']
+};
+
+const queries: MangoQuerySelector<RxDocumentData<TestDoc>>[] = [
+  { age: { $gt: 30 }, status: { $eq: 'active' } },
+  { age: { $gte: 25, $lte: 50 } },
+  { $or: [{ age: { $lt: 20 } }, { age: { $gt: 60 } }] },
+  { $and: [{ status: { $eq: 'active' } }, { age: { $gte: 18 } }] },
+  { name: { $regex: '^User' } },
+  { age: { $in: [25, 30, 35, 40] } },
+  { status: { $ne: 'deleted' } },
+  { email: { $exists: true } }
+];
+
+console.log("📊 Test: Build 100,000 queries (no cache)");
+const iterations = 100_000;
+
+const start = performance.now();
+for (let i = 0; i < iterations; i++) {
+  const query = queries[i % queries.length];
+  buildWhereClause(query, schema);
+}
+const end = performance.now();
+const totalTime = end - start;
+const avgTime = totalTime / iterations;
+
+console.log(`  Total time: ${totalTime.toFixed(2)}ms`);
+console.log(`  Average per query: ${(avgTime * 1000).toFixed(2)}µs`);
+console.log(`  Throughput: ${(iterations / (totalTime / 1000)).toFixed(0)} queries/sec\n`);
+
+console.log("📊 Analysis:");
+console.log(`  If caching saves 50% → ${(avgTime * 0.5 * 1000).toFixed(2)}µs saved per query`);
+console.log(`  For 1M queries → ${(totalTime * 0.5 / 1000).toFixed(2)}s saved`);
+console.log(`  Cache overhead: ~${(avgTime * 0.1 * 1000).toFixed(2)}µs (Map lookup)`);
+console.log(`  Net benefit: ${((avgTime * 0.5 - avgTime * 0.1) * 1000).toFixed(2)}µs per query\n`);
+
+console.log("✅ Conclusion:");
+if (avgTime < 0.01) {
+  console.log("  Query builder is VERY FAST (<10µs)");
+  console.log("  Caching overhead likely > benefit");
+  console.log("  Recommendation: SKIP caching (YAGNI)");
+} else if (avgTime < 0.1) {
+  console.log("  Query builder is FAST (<100µs)");
+  console.log("  Caching might help for repeated queries");
+  console.log("  Recommendation: Implement simple cache, measure impact");
+} else {
+  console.log("  Query builder is SLOW (>100µs)");
+  console.log("  Caching will definitely help!");
+  console.log("  Recommendation: Implement cache immediately");
+}

package/benchmarks/query-builder-consistency.ts

@@ -0,0 +1,109 @@
+import { buildWhereClause } from '../src/query/builder';
+import type { RxJsonSchema, MangoQuerySelector, RxDocumentData } from 'rxdb';
+
+console.log("🏴‍☠️ Query Builder Consistency Test (15 runs)\n");
+
+type TestDoc = {
+  id: string;
+  name: string;
+  age: number;
+  email: string;
+  status: string;
+  _deleted: boolean;
+  _attachments: {};
+  _rev: string;
+  _meta: { lwt: number };
+};
+
+const schema: RxJsonSchema<RxDocumentData<TestDoc>> = {
+  version: 0,
+  primaryKey: 'id',
+  type: 'object',
+  properties: {
+    id: { type: 'string', maxLength: 100 },
+    name: { type: 'string' },
+    age: { type: 'number' },
+    email: { type: 'string' },
+    status: { type: 'string' },
+    _deleted: { type: 'boolean' },
+    _attachments: { type: 'object' },
+    _rev: { type: 'string' },
+    _meta: {
+      type: 'object',
+      properties: {
+        lwt: { type: 'number' }
+      },
+      required: ['lwt']
+    }
+  },
+  required: ['id', 'name', 'age', '_deleted', '_rev', '_meta']
+};
+
+const queries: MangoQuerySelector<RxDocumentData<TestDoc>>[] = [
+  { age: { $gt: 30 }, status: { $eq: 'active' } },
+  { age: { $gte: 25, $lte: 50 } },
+  { $or: [{ age: { $lt: 20 } }, { age: { $gt: 60 } }] },
+  { $and: [{ status: { $eq: 'active' } }, { age: { $gte: 18 } }] },
+  { name: { $regex: '^User' } },
+  { age: { $in: [25, 30, 35, 40] } },
+  { status: { $ne: 'deleted' } },
+  { email: { $exists: true } }
+];
+
+const iterations = 100_000;
+const runs = 15;
+const times: number[] = [];
+
+console.log(`Running ${runs} iterations of ${iterations.toLocaleString()} queries each...\n`);
+
+for (let run = 0; run < runs; run++) {
+  const start = performance.now();
+  for (let i = 0; i < iterations; i++) {
+    const query = queries[i % queries.length];
+    buildWhereClause(query, schema);
+  }
+  const end = performance.now();
+  const time = end - start;
+  times.push(time);
+  
+  const avgPerQuery = (time / iterations) * 1000; // in microseconds
+  console.log(`Run ${(run + 1).toString().padStart(2)}: ${time.toFixed(2).padStart(8)}ms total | ${avgPerQuery.toFixed(2).padStart(6)}µs per query`);
+}
+
+console.log("\n📊 Statistics:");
+const avg = times.reduce((a, b) => a + b, 0) / times.length;
+const min = Math.min(...times);
+const max = Math.max(...times);
+const sorted = [...times].sort((a, b) => a - b);
+const median = sorted[Math.floor(sorted.length / 2)];
+const stdDev = Math.sqrt(times.reduce((sum, t) => sum + Math.pow(t - avg, 2), 0) / times.length);
+
+console.log(`  Average:  ${avg.toFixed(2)}ms (${(avg / iterations * 1000).toFixed(2)}µs per query)`);
+console.log(`  Median:   ${median.toFixed(2)}ms (${(median / iterations * 1000).toFixed(2)}µs per query)`);
+console.log(`  Min:      ${min.toFixed(2)}ms (${(min / iterations * 1000).toFixed(2)}µs per query)`);
+console.log(`  Max:      ${max.toFixed(2)}ms (${(max / iterations * 1000).toFixed(2)}µs per query)`);
+console.log(`  Std Dev:  ${stdDev.toFixed(2)}ms`);
+console.log(`  Variance: ${((max - min) / avg * 100).toFixed(1)}%`);
+
+console.log("\n✅ Consistency Analysis:");
+if (stdDev < avg * 0.1) {
+  console.log("  VERY CONSISTENT (std dev < 10% of average)");
+} else if (stdDev < avg * 0.2) {
+  console.log("  CONSISTENT (std dev < 20% of average)");
+} else {
+  console.log("  INCONSISTENT (std dev > 20% of average)");
+}
+
+console.log("\n🔍 Cache Detection:");
+const firstRun = times[0];
+const avgLaterRuns = times.slice(1).reduce((a, b) => a + b, 0) / (times.length - 1);
+const improvement = ((firstRun - avgLaterRuns) / firstRun * 100);
+
+if (improvement > 50) {
+  console.log(`  CACHE DETECTED! First run: ${firstRun.toFixed(2)}ms, Later runs: ${avgLaterRuns.toFixed(2)}ms`);
+  console.log(`  Improvement: ${improvement.toFixed(1)}% faster after warmup`);
+} else if (improvement > 10) {
+  console.log(`  WARMUP DETECTED: ${improvement.toFixed(1)}% faster after first run (JIT optimization)`);
+} else {
+  console.log(`  NO CACHE: Performance consistent across all runs (${improvement.toFixed(1)}% variance)`);
+}

package/benchmarks/raw-better-sqlite3-10m.ts

@@ -0,0 +1,85 @@
+import Database from "better-sqlite3";
+
+console.log("🏴‍☠️ better-sqlite3 Large-Scale Benchmark (1M docs)\n");
+
+const db = new Database("benchmark-node-1m.db");
+
+db.exec("PRAGMA journal_mode = WAL");
+db.exec("PRAGMA synchronous = 1");
+
+db.exec("DROP TABLE IF EXISTS docs");
+db.exec(`
+  CREATE TABLE docs (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    age INTEGER,
+    email TEXT,
+    status TEXT
+  )
+`);
+
+db.exec(`CREATE INDEX IF NOT EXISTS idx_age ON docs(age)`);
+db.exec(`CREATE INDEX IF NOT EXISTS idx_status ON docs(status)`);
+
+console.log("📊 Test: Bulk INSERT (1,000,000 docs in batches of 10k)");
+const insertStmt = db.prepare("INSERT INTO docs (id, name, age, email, status) VALUES (?, ?, ?, ?, ?)");
+const insertBatch = db.transaction((docs: Array<{ id: string; name: string; age: number; email: string; status: string }>) => {
+  for (const doc of docs) {
+    insertStmt.run(doc.id, doc.name, doc.age, doc.email, doc.status);
+  }
+});
+
+const totalDocs = 1_000_000;
+const batchSize = 10_000;
+const batches = totalDocs / batchSize;
+
+const insertStart = performance.now();
+for (let batch = 0; batch < batches; batch++) {
+  const docs = [];
+  for (let i = 0; i < batchSize; i++) {
+    const docId = batch * batchSize + i;
+    docs.push({
+      id: `doc${docId}`,
+      name: `User ${docId}`,
+      age: 18 + (docId % 50),
+      email: `user${docId}@example.com`,
+      status: docId % 2 === 0 ? "active" : "inactive"
+    });
+  }
+  insertBatch(docs);
+  if ((batch + 1) % 100 === 0) {
+    console.log(`  Progress: ${((batch + 1) / batches * 100).toFixed(1)}% (${(batch + 1) * batchSize} docs)`);
+  }
+}
+const insertEnd = performance.now();
+const insertTime = insertEnd - insertStart;
+console.log(`\n  Total time: ${(insertTime / 1000).toFixed(2)}s`);
+console.log(`  Throughput: ${(totalDocs / (insertTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test: SELECT by ID (10,000 random lookups)");
+const selectStmt = db.prepare("SELECT * FROM docs WHERE id = ?");
+const selectStart = performance.now();
+for (let i = 0; i < 10000; i++) {
+  const randomId = Math.floor(Math.random() * totalDocs);
+  selectStmt.get(`doc${randomId}`);
+}
+const selectEnd = performance.now();
+const selectTime = selectEnd - selectStart;
+console.log(`  Time: ${selectTime.toFixed(2)}ms`);
+console.log(`  Throughput: ${(10000 / (selectTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test: SELECT with WHERE (indexed)");
+const whereStmt = db.prepare("SELECT * FROM docs WHERE age > ? AND status = ?");
+const whereStart = performance.now();
+const results = whereStmt.all(30, "active");
+const whereEnd = performance.now();
+const whereTime = whereEnd - whereStart;
+console.log(`  Found: ${results.length} docs`);
+console.log(`  Time: ${whereTime.toFixed(2)}ms\n`);
+
+console.log("✅ Summary:");
+console.log(`  INSERT 10M: ${(insertTime / 1000).toFixed(2)}s (${(totalDocs / (insertTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  SELECT by ID: ${selectTime.toFixed(2)}ms (${(10000 / (selectTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  WHERE indexed: ${whereTime.toFixed(2)}ms`);
+
+db.close();

package/benchmarks/raw-better-sqlite3.ts

@@ -0,0 +1,86 @@
+import Database from "better-sqlite3";
+
+console.log("🏴‍☠️ better-sqlite3 Raw Performance Benchmark\n");
+
+const db = new Database(":memory:");
+
+// Enable WAL mode + optimize for speed
+db.exec("PRAGMA journal_mode = WAL");
+db.exec("PRAGMA synchronous = 1");
+
+// Create table
+db.exec(`
+  CREATE TABLE docs (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    age INTEGER,
+    email TEXT,
+    status TEXT
+  )
+`);
+
+db.exec(`CREATE INDEX idx_age ON docs(age)`);
+db.exec(`CREATE INDEX idx_status ON docs(status)`);
+
+console.log("📊 Test 1: Bulk INSERT (10,000 docs)");
+const insertStmt = db.prepare("INSERT INTO docs (id, name, age, email, status) VALUES (?, ?, ?, ?, ?)");
+const insertMany = db.transaction((docs: Array<{ id: string; name: string; age: number; email: string; status: string }>) => {
+  for (const doc of docs) {
+    insertStmt.run(doc.id, doc.name, doc.age, doc.email, doc.status);
+  }
+});
+
+const docs = [];
+for (let i = 0; i < 10000; i++) {
+  docs.push({
+    id: `doc${i}`,
+    name: `User ${i}`,
+    age: 18 + (i % 50),
+    email: `user${i}@example.com`,
+    status: i % 2 === 0 ? "active" : "inactive"
+  });
+}
+
+const insertStart = performance.now();
+insertMany(docs);
+const insertEnd = performance.now();
+const insertTime = insertEnd - insertStart;
+console.log(`  Time: ${insertTime.toFixed(2)}ms`);
+console.log(`  Throughput: ${(10000 / (insertTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test 2: SELECT by ID (1,000 lookups)");
+const selectStmt = db.prepare("SELECT * FROM docs WHERE id = ?");
+const selectStart = performance.now();
+for (let i = 0; i < 1000; i++) {
+  selectStmt.get(`doc${i}`);
+}
+const selectEnd = performance.now();
+const selectTime = selectEnd - selectStart;
+console.log(`  Time: ${selectTime.toFixed(2)}ms`);
+console.log(`  Throughput: ${(1000 / (selectTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test 3: SELECT with WHERE (indexed)");
+const whereStmt = db.prepare("SELECT * FROM docs WHERE age > ? AND status = ?");
+const whereStart = performance.now();
+const results = whereStmt.all(30, "active");
+const whereEnd = performance.now();
+const whereTime = whereEnd - whereStart;
+console.log(`  Found: ${results.length} docs`);
+console.log(`  Time: ${whereTime.toFixed(2)}ms\n`);
+
+console.log("📊 Test 4: Complex query (no index)");
+const complexStmt = db.prepare("SELECT * FROM docs WHERE name LIKE ? ORDER BY age DESC LIMIT 100");
+const complexStart = performance.now();
+const complexResults = complexStmt.all("%User 1%");
+const complexEnd = performance.now();
+const complexTime = complexEnd - complexStart;
+console.log(`  Found: ${complexResults.length} docs`);
+console.log(`  Time: ${complexTime.toFixed(2)}ms\n`);
+
+console.log("✅ Summary:");
+console.log(`  INSERT: ${insertTime.toFixed(2)}ms (${(10000 / (insertTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  SELECT by ID: ${selectTime.toFixed(2)}ms (${(1000 / (selectTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  WHERE indexed: ${whereTime.toFixed(2)}ms`);
+console.log(`  Complex query: ${complexTime.toFixed(2)}ms`);
+
+db.close();

package/benchmarks/raw-bun-sqlite-10m.ts

@@ -0,0 +1,85 @@
+import { Database } from "bun:sqlite";
+
+console.log("🏴‍☠️ Bun SQLite Large-Scale Benchmark (1M docs)\n");
+
+const db = new Database("benchmark-bun-1m.db");
+
+db.run("PRAGMA journal_mode = WAL");
+db.run("PRAGMA synchronous = 1");
+
+db.run("DROP TABLE IF EXISTS docs");
+db.run(`
+  CREATE TABLE docs (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    age INTEGER,
+    email TEXT,
+    status TEXT
+  )
+`);
+
+db.run(`CREATE INDEX IF NOT EXISTS idx_age ON docs(age)`);
+db.run(`CREATE INDEX IF NOT EXISTS idx_status ON docs(status)`);
+
+console.log("📊 Test: Bulk INSERT (1,000,000 docs in batches of 10k)");
+const insertStmt = db.prepare("INSERT INTO docs (id, name, age, email, status) VALUES (?, ?, ?, ?, ?)");
+const insertBatch = db.transaction((docs: Array<{ id: string; name: string; age: number; email: string; status: string }>) => {
+  for (const doc of docs) {
+    insertStmt.run(doc.id, doc.name, doc.age, doc.email, doc.status);
+  }
+});
+
+const totalDocs = 1_000_000;
+const batchSize = 10_000;
+const batches = totalDocs / batchSize;
+
+const insertStart = performance.now();
+for (let batch = 0; batch < batches; batch++) {
+  const docs = [];
+  for (let i = 0; i < batchSize; i++) {
+    const docId = batch * batchSize + i;
+    docs.push({
+      id: `doc${docId}`,
+      name: `User ${docId}`,
+      age: 18 + (docId % 50),
+      email: `user${docId}@example.com`,
+      status: docId % 2 === 0 ? "active" : "inactive"
+    });
+  }
+  insertBatch(docs);
+  if ((batch + 1) % 100 === 0) {
+    console.log(`  Progress: ${((batch + 1) / batches * 100).toFixed(1)}% (${(batch + 1) * batchSize} docs)`);
+  }
+}
+const insertEnd = performance.now();
+const insertTime = insertEnd - insertStart;
+console.log(`\n  Total time: ${(insertTime / 1000).toFixed(2)}s`);
+console.log(`  Throughput: ${(totalDocs / (insertTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test: SELECT by ID (10,000 random lookups)");
+const selectStmt = db.prepare("SELECT * FROM docs WHERE id = ?");
+const selectStart = performance.now();
+for (let i = 0; i < 10000; i++) {
+  const randomId = Math.floor(Math.random() * totalDocs);
+  selectStmt.get(`doc${randomId}`);
+}
+const selectEnd = performance.now();
+const selectTime = selectEnd - selectStart;
+console.log(`  Time: ${selectTime.toFixed(2)}ms`);
+console.log(`  Throughput: ${(10000 / (selectTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test: SELECT with WHERE (indexed)");
+const whereStmt = db.prepare("SELECT * FROM docs WHERE age > ? AND status = ?");
+const whereStart = performance.now();
+const results = whereStmt.all(30, "active");
+const whereEnd = performance.now();
+const whereTime = whereEnd - whereStart;
+console.log(`  Found: ${results.length} docs`);
+console.log(`  Time: ${whereTime.toFixed(2)}ms\n`);
+
+console.log("✅ Summary:");
+console.log(`  INSERT 10M: ${(insertTime / 1000).toFixed(2)}s (${(totalDocs / (insertTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  SELECT by ID: ${selectTime.toFixed(2)}ms (${(10000 / (selectTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  WHERE indexed: ${whereTime.toFixed(2)}ms`);
+
+db.close();

package/benchmarks/raw-bun-sqlite.ts

@@ -0,0 +1,86 @@
+import { Database } from "bun:sqlite";
+
+console.log("🏴‍☠️ Bun SQLite Raw Performance Benchmark\n");
+
+const db = new Database(":memory:");
+
+// Enable WAL mode + optimize for speed
+db.run("PRAGMA journal_mode = WAL");
+db.run("PRAGMA synchronous = 1");
+
+// Create table
+db.run(`
+  CREATE TABLE docs (
+    id TEXT PRIMARY KEY,
+    name TEXT,
+    age INTEGER,
+    email TEXT,
+    status TEXT
+  )
+`);
+
+db.run(`CREATE INDEX idx_age ON docs(age)`);
+db.run(`CREATE INDEX idx_status ON docs(status)`);
+
+console.log("📊 Test 1: Bulk INSERT (10,000 docs)");
+const insertStmt = db.prepare("INSERT INTO docs (id, name, age, email, status) VALUES (?, ?, ?, ?, ?)");
+const insertMany = db.transaction((docs: Array<{ id: string; name: string; age: number; email: string; status: string }>) => {
+  for (const doc of docs) {
+    insertStmt.run(doc.id, doc.name, doc.age, doc.email, doc.status);
+  }
+});
+
+const docs = [];
+for (let i = 0; i < 10000; i++) {
+  docs.push({
+    id: `doc${i}`,
+    name: `User ${i}`,
+    age: 18 + (i % 50),
+    email: `user${i}@example.com`,
+    status: i % 2 === 0 ? "active" : "inactive"
+  });
+}
+
+const insertStart = performance.now();
+insertMany(docs);
+const insertEnd = performance.now();
+const insertTime = insertEnd - insertStart;
+console.log(`  Time: ${insertTime.toFixed(2)}ms`);
+console.log(`  Throughput: ${(10000 / (insertTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test 2: SELECT by ID (1,000 lookups)");
+const selectStmt = db.prepare("SELECT * FROM docs WHERE id = ?");
+const selectStart = performance.now();
+for (let i = 0; i < 1000; i++) {
+  selectStmt.get(`doc${i}`);
+}
+const selectEnd = performance.now();
+const selectTime = selectEnd - selectStart;
+console.log(`  Time: ${selectTime.toFixed(2)}ms`);
+console.log(`  Throughput: ${(1000 / (selectTime / 1000)).toFixed(0)} docs/sec\n`);
+
+console.log("📊 Test 3: SELECT with WHERE (indexed)");
+const whereStmt = db.prepare("SELECT * FROM docs WHERE age > ? AND status = ?");
+const whereStart = performance.now();
+const results = whereStmt.all(30, "active");
+const whereEnd = performance.now();
+const whereTime = whereEnd - whereStart;
+console.log(`  Found: ${results.length} docs`);
+console.log(`  Time: ${whereTime.toFixed(2)}ms\n`);
+
+console.log("📊 Test 4: Complex query (no index)");
+const complexStmt = db.prepare("SELECT * FROM docs WHERE name LIKE ? ORDER BY age DESC LIMIT 100");
+const complexStart = performance.now();
+const complexResults = complexStmt.all("%User 1%");
+const complexEnd = performance.now();
+const complexTime = complexEnd - complexStart;
+console.log(`  Found: ${complexResults.length} docs`);
+console.log(`  Time: ${complexTime.toFixed(2)}ms\n`);
+
+console.log("✅ Summary:");
+console.log(`  INSERT: ${insertTime.toFixed(2)}ms (${(10000 / (insertTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  SELECT by ID: ${selectTime.toFixed(2)}ms (${(1000 / (selectTime / 1000)).toFixed(0)} docs/sec)`);
+console.log(`  WHERE indexed: ${whereTime.toFixed(2)}ms`);
+console.log(`  Complex query: ${complexTime.toFixed(2)}ms`);
+
+db.close();