sqlite-js

.envrc

@@ -0,0 +1,3 @@
+layout node
+use node
+[ -f .env ] && dotenv

.github/workflows/test.yaml

@@ -0,0 +1,31 @@
+# Ensures packages test correctly
+name: Test Packages
+
+on:
+  push:
+
+jobs:
+  test:
+    name: Test Packages
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+
+      - name: Setup NodeJS
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: '.node-version'
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build
+        run: pnpm build
+
+      - name: Test
+        run: pnpm test

.gitignore

@@ -1,3 +1,6 @@
 node_modules/
 test-db/
 *.db
+lib/
+tsconfig.tsbuildinfo
+benchmarks/db

.node-version

@@ -0,0 +1 @@
+v22.5.1

.prettierignore

@@ -0,0 +1,3 @@
+node_modules/
+lib/
+pnpm-lock.yaml

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "none",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true
+}

README.md

@@ -0,0 +1,21 @@
+# sqlite-js
+
+Universal SQLite APIs for JavaScript.
+
+## @sqlite-js/driver
+
+This is a universal driver API and utilities for implementing drivers.
+
+The APIs here are low-level, and should not be used directly in most use cases.
+
+### @sqlite-js/driver/node
+
+This is a driver implementation for NodeJS based on the experimental `node:sqlite` package.
+
+## @sqlite-js/better-sqlite3-driver
+
+This is a driver implementation for NodeJS implementation based `better-sqlite3`.
+
+## @sqlite-js/api
+
+This contains a higher-level API, including transaction support.

benchmarks/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "benchmarks",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "start": "NODE_OPTIONS=\"--experimental-sqlite --disable-warning=ExperimentalWarning\" node lib/index.js"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.0.0",
+    "prando": "^6.0.1",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7",
+    "@sqlite-js/driver": "workspace:^",
+    "@sqlite-js/better-sqlite3-driver": "workspace:^",
+    "@sqlite-js/api": "workspace:^"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  }
+}

benchmarks/src/Benchmark.ts

@@ -0,0 +1,108 @@
+import { BenchmarkResults } from './BenchmarkResults.js';
+
+export abstract class Benchmark {
+  abstract name: string;
+
+  async runAll(): Promise<BenchmarkResults> {
+    let results = new BenchmarkResults(this.name);
+    let droppedFrames = 0;
+    let last = performance.now();
+    var timer = setInterval(() => {
+      const now = performance.now();
+      const diff = now - last;
+      last = now;
+      if (diff >= 16) {
+        droppedFrames += Math.floor(diff / 16);
+      }
+    }, 1);
+
+    await this.setUp();
+
+    await results.record('Test 1: 1000 INSERTs', this.test1.bind(this));
+    await results.record(
+      'Test 2: 25000 INSERTs in a transaction',
+      this.test2.bind(this)
+    );
+    await results.record(
+      'Test 3: 25000 INSERTs into an indexed table',
+      this.test3.bind(this)
+    );
+    await results.record(
+      'Test 4: 100 SELECTs without an index',
+      this.test4.bind(this)
+    );
+    await results.record(
+      'Test 5: 100 SELECTs on a string comparison',
+      this.test5.bind(this)
+    );
+    await results.record(
+      'Test 7: 5000 SELECTs with an index',
+      this.test7.bind(this)
+    );
+    await results.record(
+      'Test 8: 1000 UPDATEs without an index',
+      this.test8.bind(this)
+    );
+    await results.record(
+      'Test 9: 25000 UPDATEs with an index',
+      this.test9.bind(this)
+    );
+    await results.record(
+      'Test 10: 25000 text UPDATEs with an index',
+      this.test10.bind(this)
+    );
+    await results.record(
+      'Test 11: INSERTs from a SELECT',
+      this.test11.bind(this)
+    );
+    await results.record(
+      'Test 12: DELETE without an index',
+      this.test12.bind(this)
+    );
+    await results.record(
+      'Test 13: DELETE with an index',
+      this.test13.bind(this)
+    );
+    await results.record(
+      'Test 14: A big INSERT after a big DELETE',
+      this.test14.bind(this)
+    );
+    await results.record(
+      'Test 15: A big DELETE followed by many small INSERTs',
+      this.test15.bind(this)
+    );
+    await results.record('Test 16: Clear table', this.test16.bind(this));
+
+    await this.tearDown();
+
+    clearInterval(timer);
+
+    const diff = performance.now() - last;
+    if (diff >= 16) {
+      droppedFrames += Math.floor(diff / 16);
+    }
+
+    console.log(`Dropped frames: ${droppedFrames} (diff ${diff})`);
+    return results;
+  }
+
+  abstract setUp(): Promise<void>;
+
+  abstract test1(): Promise<void>;
+  abstract test2(): Promise<void>;
+  abstract test3(): Promise<void>;
+  abstract test4(): Promise<void>;
+  abstract test5(): Promise<void>;
+  abstract test7(): Promise<void>;
+  abstract test8(): Promise<void>;
+  abstract test9(): Promise<void>;
+  abstract test10(): Promise<void>;
+  abstract test11(): Promise<void>;
+  abstract test12(): Promise<void>;
+  abstract test13(): Promise<void>;
+  abstract test14(): Promise<void>;
+  abstract test15(): Promise<void>;
+  abstract test16(): Promise<void>;
+
+  abstract tearDown(): Promise<void>;
+}

benchmarks/src/BenchmarkResults.ts

@@ -0,0 +1,43 @@
+export class BenchmarkResults {
+  suite: string;
+
+  results: BenchmarkResult[] = [];
+
+  constructor(suite: string) {
+    this.suite = suite;
+  }
+
+  async record(name: string, callback: () => Promise<void>) {
+    const start = performance.now();
+    await callback();
+    const end = performance.now();
+    const elapsed = end - start;
+    this.results.push(new BenchmarkResult(name, elapsed));
+    console.log(`${name} :: ${Math.round(elapsed)}ms`);
+    // yield the event loop
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+
+  toString() {
+    return this.results.map((r) => r.toString()).join('\n');
+  }
+
+  toCsv() {
+    return this.results.map((r) => r.toCsv()).join('\n');
+  }
+}
+
+export class BenchmarkResult {
+  constructor(
+    public test: string,
+    public duration: number
+  ) {}
+
+  toString() {
+    return `${this.test}: ${this.duration / 1000.0}s`;
+  }
+
+  toCsv() {
+    return `${this.test},${this.duration}`;
+  }
+}