dbx-native 0.1.2-beta → 0.2.0-beta

package/benchmarks/benchmark_sql.js

@@ -1,162 +1,162 @@
-/**
- * DBX Native (napi-rs) vs better-sqlite3 - Performance Comparison
- * USING SQL PREPARED STATEMENTS
- */
-
-const Database = require('../index.js').Database;
-const BetterSqlite3 = require('better-sqlite3');
-
-const N = 10000;
-
-function benchmarkDBX() {
-    console.log('Benchmarking DBX Native (napi-rs) with SQL...\\n');
-
-    const db = Database.openInMemory();
-
-    // INSERT with SQL prepared statement
-    const startInsert = process.hrtime.bigint();
-    const tx = db.beginTransaction();
-    for (let i = 0; i < N; i++) {
-        // SQL INSERT instead of CRUD API
-        tx.execute(`INSERT INTO bench (key, value) VALUES ('key:${i}', 'value:${i}')`).run();
-    }
-    tx.commit();
-    const endInsert = process.hrtime.bigint();
-    const insertTime = Number(endInsert - startInsert) / 1e9;
-
-    // GET
-    const startGet = process.hrtime.bigint();
-    for (let i = 0; i < N; i++) {
-        const key = Buffer.from(`key:${i}`);
-        db.get('bench', key);
-    }
-    const endGet = process.hrtime.bigint();
-    const getTime = Number(endGet - startGet) / 1e9;
-
-    // DELETE with SQL prepared statement
-    const startDelete = process.hrtime.bigint();
-    const tx2 = db.beginTransaction();
-    for (let i = 0; i < N; i++) {
-        tx2.execute(`DELETE FROM bench WHERE key = 'key:${i}'`).run();
-    }
-    tx2.commit();
-    const endDelete = process.hrtime.bigint();
-    const deleteTime = Number(endDelete - startDelete) / 1e9;
-
-    db.close();
-
-    return { insertTime, getTime, deleteTime };
-}
-
-function benchmarkSQLite() {
-    console.log('Benchmarking better-sqlite3 (In-Memory)...\\n');
-
-    const db = new BetterSqlite3(':memory:');
-    db.exec('CREATE TABLE bench (key BLOB PRIMARY KEY, value BLOB)');
-
-    // INSERT with transaction
-    const startInsert = process.hrtime.bigint();
-    const insertStmt = db.prepare('INSERT INTO bench (key, value) VALUES (?, ?)');
-    const insertMany = db.transaction((rows) => {
-        for (const row of rows) {
-            insertStmt.run(row.key, row.value);
-        }
-    });
-    const rows = [];
-    for (let i = 0; i < N; i++) {
-        rows.push({
-            key: Buffer.from(`key:${i}`),
-            value: Buffer.from(`value:${i}`)
-        });
-    }
-    insertMany(rows);
-    const endInsert = process.hrtime.bigint();
-    const insertTime = Number(endInsert - startInsert) / 1e9;
-
-    // GET
-    const startGet = process.hrtime.bigint();
-    const getStmt = db.prepare('SELECT value FROM bench WHERE key = ?');
-    for (let i = 0; i < N; i++) {
-        const key = Buffer.from(`key:${i}`);
-        getStmt.get(key);
-    }
-    const endGet = process.hrtime.bigint();
-    const getTime = Number(endGet - startGet) / 1e9;
-
-    // DELETE with transaction
-    const startDelete = process.hrtime.bigint();
-    const deleteStmt = db.prepare('DELETE FROM bench WHERE key = ?');
-    const deleteMany = db.transaction((keys) => {
-        for (const key of keys) {
-            deleteStmt.run(key);
-        }
-    });
-    const keys = [];
-    for (let i = 0; i < N; i++) {
-        keys.push(Buffer.from(`key:${i}`));
-    }
-    deleteMany(keys);
-    const endDelete = process.hrtime.bigint();
-    const deleteTime = Number(endDelete - startDelete) / 1e9;
-
-    db.close();
-
-    return { insertTime, getTime, deleteTime };
-}
-
-function printResults(name, { insertTime, getTime, deleteTime }) {
-    console.log(`${name}:`);
-    console.log(`  INSERT: ${insertTime.toFixed(4)}s (${Math.floor(N / insertTime).toLocaleString()} ops/sec)`);
-    console.log(`  GET:    ${getTime.toFixed(4)}s (${Math.floor(N / getTime).toLocaleString()} ops/sec)`);
-    console.log(`  DELETE: ${deleteTime.toFixed(4)}s (${Math.floor(N / deleteTime).toLocaleString()} ops/sec)`);
-    console.log();
-}
-
-function main() {
-    console.log('='.repeat(60));
-    console.log('DBX Native (napi-rs) vs better-sqlite3 - Performance Comparison');
-    console.log('USING SQL PREPARED STATEMENTS');
-    console.log('='.repeat(60));
-    console.log(`\\nRunning benchmarks with ${N.toLocaleString()} operations...\\n`);
-
-    // Benchmark DBX
-    const dbxResults = benchmarkDBX();
-    printResults('DBX Native (napi-rs) with SQL', dbxResults);
-
-    // Benchmark SQLite
-    const sqliteResults = benchmarkSQLite();
-    printResults('better-sqlite3 (In-Memory)', sqliteResults);
-
-    // Comparison
-    console.log('='.repeat(60));
-    console.log('Performance Comparison:');
-    console.log('='.repeat(60));
-
-    const insertRatio = sqliteResults.insertTime / dbxResults.insertTime;
-    const getRatio = sqliteResults.getTime / dbxResults.getTime;
-    const deleteRatio = sqliteResults.deleteTime / dbxResults.deleteTime;
-
-    if (insertRatio > 1) {
-        console.log(`INSERT: DBX is ${insertRatio.toFixed(2)}x faster`);
-    } else {
-        console.log(`INSERT: SQLite is ${(1 / insertRatio).toFixed(2)}x faster`);
-    }
-
-    if (getRatio > 1) {
-        console.log(`GET:    DBX is ${getRatio.toFixed(2)}x faster`);
-    } else {
-        console.log(`GET:    SQLite is ${(1 / getRatio).toFixed(2)}x faster`);
-    }
-
-    if (deleteRatio > 1) {
-        console.log(`DELETE: DBX is ${deleteRatio.toFixed(2)}x faster`);
-    } else {
-        console.log(`DELETE: SQLite is ${(1 / deleteRatio).toFixed(2)}x faster`);
-    }
-
-    console.log('\\n' + '='.repeat(60));
-    console.log('Benchmark completed!');
-    console.log('='.repeat(60));
-}
-
-main();
+/**
+ * DBX Native (napi-rs) vs better-sqlite3 - Performance Comparison
+ * USING SQL PREPARED STATEMENTS
+ */
+
+const Database = require('../index.js').Database;
+const BetterSqlite3 = require('better-sqlite3');
+
+const N = 10000;
+
+function benchmarkDBX() {
+    console.log('Benchmarking DBX Native (napi-rs) with SQL...\\n');
+
+    const db = Database.openInMemory();
+
+    // INSERT with SQL prepared statement
+    const startInsert = process.hrtime.bigint();
+    const tx = db.beginTransaction();
+    for (let i = 0; i < N; i++) {
+        // SQL INSERT instead of CRUD API
+        tx.execute(`INSERT INTO bench (key, value) VALUES ('key:${i}', 'value:${i}')`).run();
+    }
+    tx.commit();
+    const endInsert = process.hrtime.bigint();
+    const insertTime = Number(endInsert - startInsert) / 1e9;
+
+    // GET
+    const startGet = process.hrtime.bigint();
+    for (let i = 0; i < N; i++) {
+        const key = Buffer.from(`key:${i}`);
+        db.get('bench', key);
+    }
+    const endGet = process.hrtime.bigint();
+    const getTime = Number(endGet - startGet) / 1e9;
+
+    // DELETE with SQL prepared statement
+    const startDelete = process.hrtime.bigint();
+    const tx2 = db.beginTransaction();
+    for (let i = 0; i < N; i++) {
+        tx2.execute(`DELETE FROM bench WHERE key = 'key:${i}'`).run();
+    }
+    tx2.commit();
+    const endDelete = process.hrtime.bigint();
+    const deleteTime = Number(endDelete - startDelete) / 1e9;
+
+    db.close();
+
+    return { insertTime, getTime, deleteTime };
+}
+
+function benchmarkSQLite() {
+    console.log('Benchmarking better-sqlite3 (In-Memory)...\\n');
+
+    const db = new BetterSqlite3(':memory:');
+    db.exec('CREATE TABLE bench (key BLOB PRIMARY KEY, value BLOB)');
+
+    // INSERT with transaction
+    const startInsert = process.hrtime.bigint();
+    const insertStmt = db.prepare('INSERT INTO bench (key, value) VALUES (?, ?)');
+    const insertMany = db.transaction((rows) => {
+        for (const row of rows) {
+            insertStmt.run(row.key, row.value);
+        }
+    });
+    const rows = [];
+    for (let i = 0; i < N; i++) {
+        rows.push({
+            key: Buffer.from(`key:${i}`),
+            value: Buffer.from(`value:${i}`)
+        });
+    }
+    insertMany(rows);
+    const endInsert = process.hrtime.bigint();
+    const insertTime = Number(endInsert - startInsert) / 1e9;
+
+    // GET
+    const startGet = process.hrtime.bigint();
+    const getStmt = db.prepare('SELECT value FROM bench WHERE key = ?');
+    for (let i = 0; i < N; i++) {
+        const key = Buffer.from(`key:${i}`);
+        getStmt.get(key);
+    }
+    const endGet = process.hrtime.bigint();
+    const getTime = Number(endGet - startGet) / 1e9;
+
+    // DELETE with transaction
+    const startDelete = process.hrtime.bigint();
+    const deleteStmt = db.prepare('DELETE FROM bench WHERE key = ?');
+    const deleteMany = db.transaction((keys) => {
+        for (const key of keys) {
+            deleteStmt.run(key);
+        }
+    });
+    const keys = [];
+    for (let i = 0; i < N; i++) {
+        keys.push(Buffer.from(`key:${i}`));
+    }
+    deleteMany(keys);
+    const endDelete = process.hrtime.bigint();
+    const deleteTime = Number(endDelete - startDelete) / 1e9;
+
+    db.close();
+
+    return { insertTime, getTime, deleteTime };
+}
+
+function printResults(name, { insertTime, getTime, deleteTime }) {
+    console.log(`${name}:`);
+    console.log(`  INSERT: ${insertTime.toFixed(4)}s (${Math.floor(N / insertTime).toLocaleString()} ops/sec)`);
+    console.log(`  GET:    ${getTime.toFixed(4)}s (${Math.floor(N / getTime).toLocaleString()} ops/sec)`);
+    console.log(`  DELETE: ${deleteTime.toFixed(4)}s (${Math.floor(N / deleteTime).toLocaleString()} ops/sec)`);
+    console.log();
+}
+
+function main() {
+    console.log('='.repeat(60));
+    console.log('DBX Native (napi-rs) vs better-sqlite3 - Performance Comparison');
+    console.log('USING SQL PREPARED STATEMENTS');
+    console.log('='.repeat(60));
+    console.log(`\\nRunning benchmarks with ${N.toLocaleString()} operations...\\n`);
+
+    // Benchmark DBX
+    const dbxResults = benchmarkDBX();
+    printResults('DBX Native (napi-rs) with SQL', dbxResults);
+
+    // Benchmark SQLite
+    const sqliteResults = benchmarkSQLite();
+    printResults('better-sqlite3 (In-Memory)', sqliteResults);
+
+    // Comparison
+    console.log('='.repeat(60));
+    console.log('Performance Comparison:');
+    console.log('='.repeat(60));
+
+    const insertRatio = sqliteResults.insertTime / dbxResults.insertTime;
+    const getRatio = sqliteResults.getTime / dbxResults.getTime;
+    const deleteRatio = sqliteResults.deleteTime / dbxResults.deleteTime;
+
+    if (insertRatio > 1) {
+        console.log(`INSERT: DBX is ${insertRatio.toFixed(2)}x faster`);
+    } else {
+        console.log(`INSERT: SQLite is ${(1 / insertRatio).toFixed(2)}x faster`);
+    }
+
+    if (getRatio > 1) {
+        console.log(`GET:    DBX is ${getRatio.toFixed(2)}x faster`);
+    } else {
+        console.log(`GET:    SQLite is ${(1 / getRatio).toFixed(2)}x faster`);
+    }
+
+    if (deleteRatio > 1) {
+        console.log(`DELETE: DBX is ${deleteRatio.toFixed(2)}x faster`);
+    } else {
+        console.log(`DELETE: SQLite is ${(1 / deleteRatio).toFixed(2)}x faster`);
+    }
+
+    console.log('\\n' + '='.repeat(60));
+    console.log('Benchmark completed!');
+    console.log('='.repeat(60));
+}
+
+main();

package/benchmarks/ffi_benchmark.js

@@ -1,72 +1,72 @@
-/**
- * FFI Performance Benchmark for DBX Node.js Bindings
- * 
- * Measures INSERT, GET, and SCAN performance to quantify FFI overhead
- * compared to Rust Core benchmarks.
- * 
- * Run with: node benchmarks/ffi_benchmark.js
- */
-
-const Benchmark = require('benchmark');
-const { Database } = require('../');
-
-const NUM_ENTRIES = 10_000;
-
-function generateTestData() {
-    const data = [];
-    for (let i = 0; i < NUM_ENTRIES; i++) {
-        const key = Buffer.from(`key_${i.toString().padStart(8, '0')}`);
-        const value = Buffer.from(`value_${i.toString().padStart(8, '0')}_data`);
-        data.push([key, value]);
-    }
-    return data;
-}
-
-// Prepare data for GET and SCAN benchmarks
-let getDb, scanDb, testData;
-
-const suite = new Benchmark.Suite();
-
-suite
-    .add('DBX INSERT 10k', function () {
-        const db = Database.openInMemory();
-        const data = generateTestData();
-        for (const [key, value] of data) {
-            db.insert('bench', key, value);
-        }
-    })
-    .add('DBX GET 10k', {
-        onStart: function () {
-            getDb = Database.openInMemory();
-            testData = generateTestData();
-            for (const [key, value] of testData) {
-                getDb.insert('bench', key, value);
-            }
-        },
-        fn: function () {
-            for (const [key] of testData) {
-                getDb.get('bench', key);
-            }
-        }
-    })
-    .add('DBX SCAN 10k', {
-        onStart: function () {
-            scanDb = Database.openInMemory();
-            const data = generateTestData();
-            for (const [key, value] of data) {
-                scanDb.insert('bench', key, value);
-            }
-        },
-        fn: function () {
-            scanDb.scan('bench');
-        }
-    })
-    .on('cycle', function (event) {
-        console.log(String(event.target));
-        const timeMs = event.target.stats.mean * 1000;
-        console.log(`  → ${timeMs.toFixed(2)}ms per operation\n`);
-    })
-    .on('complete', function () {
-        console.log('\n=== Benchmark Complete ===');
-    })
-    .run({ 'async': false });
+/**
+ * FFI Performance Benchmark for DBX Node.js Bindings
+ * 
+ * Measures INSERT, GET, and SCAN performance to quantify FFI overhead
+ * compared to Rust Core benchmarks.
+ * 
+ * Run with: node benchmarks/ffi_benchmark.js
+ */
+
+const Benchmark = require('benchmark');
+const { Database } = require('../');
+
+const NUM_ENTRIES = 10_000;
+
+function generateTestData() {
+    const data = [];
+    for (let i = 0; i < NUM_ENTRIES; i++) {
+        const key = Buffer.from(`key_${i.toString().padStart(8, '0')}`);
+        const value = Buffer.from(`value_${i.toString().padStart(8, '0')}_data`);
+        data.push([key, value]);
+    }
+    return data;
+}
+
+// Prepare data for GET and SCAN benchmarks
+let getDb, scanDb, testData;
+
+const suite = new Benchmark.Suite();
+
+suite
+    .add('DBX INSERT 10k', function () {
+        const db = Database.openInMemory();
+        const data = generateTestData();
+        for (const [key, value] of data) {
+            db.insert('bench', key, value);
+        }
+    })
+    .add('DBX GET 10k', {
+        onStart: function () {
+            getDb = Database.openInMemory();
+            testData = generateTestData();
+            for (const [key, value] of testData) {
+                getDb.insert('bench', key, value);
+            }
+        },
+        fn: function () {
+            for (const [key] of testData) {
+                getDb.get('bench', key);
+            }
+        }
+    })
+    .add('DBX SCAN 10k', {
+        onStart: function () {
+            scanDb = Database.openInMemory();
+            const data = generateTestData();
+            for (const [key, value] of data) {
+                scanDb.insert('bench', key, value);
+            }
+        },
+        fn: function () {
+            scanDb.scan('bench');
+        }
+    })
+    .on('cycle', function (event) {
+        console.log(String(event.target));
+        const timeMs = event.target.stats.mean * 1000;
+        console.log(`  → ${timeMs.toFixed(2)}ms per operation\n`);
+    })
+    .on('complete', function () {
+        console.log('\n=== Benchmark Complete ===');
+    })
+    .run({ 'async': false });