bun-sqlite-for-rxdb 1.0.1

package/benchmarks/smart-regex-benchmark.ts

@@ -0,0 +1,148 @@
+import { getRxStorageBunSQLite } from '../src/storage';
+import type { RxDocumentData } from 'rxdb';
+
+interface BenchmarkDocType {
+	id: string;
+	name: string;
+	email: string;
+	domain: string;
+}
+
+async function benchmarkSmartRegex() {
+	console.log('🏴‍☠️ Smart Regex → LIKE Optimization Benchmark\n');
+
+	const storage = getRxStorageBunSQLite();
+	const instance = await storage.createStorageInstance<BenchmarkDocType>({
+		databaseInstanceToken: 'smart-regex-token',
+		databaseName: 'benchmark',
+		collectionName: 'users',
+		schema: {
+			version: 0,
+			primaryKey: 'id',
+			type: 'object',
+			properties: {
+				id: { type: 'string', maxLength: 100 },
+				name: { type: 'string' },
+				email: { type: 'string' },
+				domain: { type: 'string' },
+				_deleted: { type: 'boolean' },
+				_attachments: { type: 'object' },
+				_rev: { type: 'string' },
+				_meta: {
+					type: 'object',
+					properties: {
+						lwt: { type: 'number' }
+					}
+				}
+			},
+			required: ['id', 'name', 'email', 'domain', '_deleted', '_attachments', '_rev', '_meta']
+		},
+		options: {},
+		multiInstance: false,
+		devMode: false
+	});
+
+	console.log('📝 Inserting 100,000 documents...');
+	const insertStart = performance.now();
+	
+	const domains = ['gmail.com', 'yahoo.com', 'outlook.com', 'hotmail.com', 'company.com'];
+	const batchSize = 1000;
+	for (let batch = 0; batch < 100; batch++) {
+		const docs: Array<{ document: RxDocumentData<BenchmarkDocType> }> = [];
+		for (let i = 0; i < batchSize; i++) {
+			const idx = batch * batchSize + i;
+			const domain = domains[idx % domains.length];
+			const doc: any = {
+				id: `user${idx}`,
+				name: `User ${idx}`,
+				email: `user${idx}@${domain}`,
+				domain: domain,
+				_deleted: false,
+				_attachments: {},
+				_rev: '1-abc',
+				_meta: { lwt: Date.now() }
+			};
+			docs.push({ document: doc });
+		}
+		await instance.bulkWrite(docs, 'benchmark');
+	}
+	
+	const insertEnd = performance.now();
+	console.log(`✅ Inserted 100,000 documents in ${(insertEnd - insertStart).toFixed(2)}ms\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 1: Prefix pattern (^User 1) - Uses index');
+	console.log('='.repeat(60));
+	const start1 = performance.now();
+	const result1 = await instance.query({
+		query: { selector: { name: { $regex: '^User 1' } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end1 = performance.now();
+	console.log(`Found ${result1.documents.length.toLocaleString()} docs in ${(end1 - start1).toFixed(2)}ms\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 2: Suffix pattern (@gmail.com$) - No index but optimized');
+	console.log('='.repeat(60));
+	const start2 = performance.now();
+	const result2 = await instance.query({
+		query: { selector: { email: { $regex: '@gmail\\.com$' } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end2 = performance.now();
+	console.log(`Found ${result2.documents.length.toLocaleString()} docs in ${(end2 - start2).toFixed(2)}ms\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 3: Exact match (^gmail.com$) - Uses = operator');
+	console.log('='.repeat(60));
+	const start3 = performance.now();
+	const result3 = await instance.query({
+		query: { selector: { domain: { $regex: '^gmail\\.com$' } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end3 = performance.now();
+	console.log(`Found ${result3.documents.length.toLocaleString()} docs in ${(end3 - start3).toFixed(2)}ms\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 4: Contains pattern (User) - LIKE %pattern%');
+	console.log('='.repeat(60));
+	const start4 = performance.now();
+	const result4 = await instance.query({
+		query: { selector: { name: { $regex: 'User' } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end4 = performance.now();
+	console.log(`Found ${result4.documents.length.toLocaleString()} docs in ${(end4 - start4).toFixed(2)}ms\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 5: Case-insensitive (user, i flag) - LOWER() optimization');
+	console.log('='.repeat(60));
+	const start5 = performance.now();
+	const result5 = await instance.query({
+		query: { selector: { name: { $regex: 'user', $options: 'i' } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end5 = performance.now();
+	console.log(`Found ${result5.documents.length.toLocaleString()} docs in ${(end5 - start5).toFixed(2)}ms\n`);
+
+	const avgTime = ((end1 - start1) + (end2 - start2) + (end3 - start3) + (end4 - start4) + (end5 - start5)) / 5;
+
+	console.log('='.repeat(60));
+	console.log('📊 RESULTS SUMMARY (100k documents)');
+	console.log('='.repeat(60));
+	console.log(`Prefix (^):        ${(end1 - start1).toFixed(2)}ms`);
+	console.log(`Suffix ($):        ${(end2 - start2).toFixed(2)}ms`);
+	console.log(`Exact (^$):        ${(end3 - start3).toFixed(2)}ms`);
+	console.log(`Contains:          ${(end4 - start4).toFixed(2)}ms`);
+	console.log(`Case-insensitive:  ${(end5 - start5).toFixed(2)}ms`);
+	console.log(`Average:           ${avgTime.toFixed(2)}ms`);
+	console.log('='.repeat(60));
+	console.log();
+	console.log('✅ Smart regex → LIKE converter working!');
+	console.log('   All simple patterns converted to indexed LIKE queries');
+	console.log('='.repeat(60) + '\n');
+
+	await instance.close();
+}
+
+benchmarkSmartRegex().catch(console.error);

package/benchmarks/sql-vs-mingo-benchmark.ts

@@ -0,0 +1,210 @@
+import { getRxStorageBunSQLite } from '../src/storage';
+import type { RxDocumentData } from 'rxdb';
+
+interface BenchmarkDocType {
+	id: string;
+	name: string;
+	age: number;
+	email?: string;
+	status: string;
+	tags?: string[];
+}
+
+async function benchmarkAtScale(docCount: number) {
+	console.log(`\n${'='.repeat(60)}`);
+	console.log(`🏴‍☠️ SQL vs Mingo Benchmark: ${docCount.toLocaleString()} documents`);
+	console.log(`${'='.repeat(60)}\n`);
+
+	const storage = getRxStorageBunSQLite();
+	const instance = await storage.createStorageInstance<BenchmarkDocType>({
+		databaseInstanceToken: `benchmark-token-${docCount}`,
+		databaseName: 'benchmark',
+		collectionName: 'users',
+		schema: {
+			version: 0,
+			primaryKey: 'id',
+			type: 'object',
+			properties: {
+				id: { type: 'string', maxLength: 100 },
+				name: { type: 'string' },
+				age: { type: 'number' },
+				email: { type: 'string' },
+				status: { type: 'string' },
+				tags: { type: 'array', items: { type: 'string' } },
+				_deleted: { type: 'boolean' },
+				_attachments: { type: 'object' },
+				_rev: { type: 'string' },
+				_meta: {
+					type: 'object',
+					properties: {
+						lwt: { type: 'number' }
+					}
+				}
+			},
+			required: ['id', 'name', 'age', 'status', '_deleted', '_attachments', '_rev', '_meta']
+		},
+		options: {},
+		multiInstance: false,
+		devMode: false
+	});
+
+	console.log(`📝 Inserting ${docCount.toLocaleString()} documents...`);
+	const insertStart = performance.now();
+	
+	const batchSize = 1000;
+	for (let batch = 0; batch < docCount / batchSize; batch++) {
+		const docs: Array<{ document: RxDocumentData<BenchmarkDocType> }> = [];
+		for (let i = 0; i < batchSize; i++) {
+			const idx = batch * batchSize + i;
+			const doc: any = {
+				id: `user${idx}`,
+				name: `User ${idx}`,
+				age: 18 + (idx % 50),
+				status: idx % 2 === 0 ? 'active' : 'inactive',
+				_deleted: false,
+				_attachments: {},
+				_rev: '1-abc',
+				_meta: { lwt: Date.now() }
+			};
+			
+			if (idx % 3 === 0) {
+				doc.email = `user${idx}@gmail.com`;
+			} else if (idx % 3 === 1) {
+				doc.email = `user${idx}@yahoo.com`;
+			}
+			
+			if (idx % 2 === 0) {
+				doc.tags = ['active', 'premium'];
+			}
+			
+			docs.push({ document: doc });
+		}
+		await instance.bulkWrite(docs, 'benchmark');
+		if ((batch + 1) % 10 === 0) {
+			process.stdout.write(`\r   Progress: ${((batch + 1) * batchSize).toLocaleString()} / ${docCount.toLocaleString()}`);
+		}
+	}
+	
+	const insertEnd = performance.now();
+	console.log(`\n✅ Inserted ${docCount.toLocaleString()} documents in ${(insertEnd - insertStart).toFixed(2)}ms\n`);
+
+	const memBefore = process.memoryUsage();
+
+	console.log('📊 Test 1: $exists operator (email field exists)');
+	console.log('   SQL: WHERE email IS NOT NULL');
+	const start1 = performance.now();
+	const result1 = await instance.query({
+		query: { selector: { email: { $exists: true } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end1 = performance.now();
+	console.log(`   ✅ Found ${result1.documents.length.toLocaleString()} docs in ${(end1 - start1).toFixed(2)}ms\n`);
+
+	console.log('📊 Test 2: $regex operator (name starts with "User 1")');
+	console.log('   SQL: WHERE name LIKE "User 1%"');
+	const start2 = performance.now();
+	const result2 = await instance.query({
+		query: { selector: { name: { $regex: '^User 1' } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end2 = performance.now();
+	console.log(`   ✅ Found ${result2.documents.length.toLocaleString()} docs in ${(end2 - start2).toFixed(2)}ms\n`);
+
+	console.log('📊 Test 3: $gt operator (age > 50)');
+	console.log('   SQL: WHERE age > 50');
+	const start3 = performance.now();
+	const result3 = await instance.query({
+		query: { selector: { age: { $gt: 50 } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end3 = performance.now();
+	console.log(`   ✅ Found ${result3.documents.length.toLocaleString()} docs in ${(end3 - start3).toFixed(2)}ms\n`);
+
+	console.log('📊 Test 4: $in operator (status in [active, pending])');
+	console.log('   SQL: WHERE status IN ("active", "pending")');
+	const start4 = performance.now();
+	const result4 = await instance.query({
+		query: { selector: { status: { $in: ['active', 'pending'] } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end4 = performance.now();
+	console.log(`   ✅ Found ${result4.documents.length.toLocaleString()} docs in ${(end4 - start4).toFixed(2)}ms\n`);
+
+	console.log('📊 Test 5: $elemMatch operator (tags contains "premium")');
+	console.log('   Mingo: In-memory filter (no SQL translation)');
+	const start5 = performance.now();
+	const result5 = await instance.query({
+		query: { selector: { tags: { $elemMatch: { $eq: 'premium' } } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const end5 = performance.now();
+	console.log(`   ✅ Found ${result5.documents.length.toLocaleString()} docs in ${(end5 - start5).toFixed(2)}ms\n`);
+
+	const memAfter = process.memoryUsage();
+	const memDelta = {
+		rss: ((memAfter.rss - memBefore.rss) / 1024 / 1024).toFixed(2),
+		heapUsed: ((memAfter.heapUsed - memBefore.heapUsed) / 1024 / 1024).toFixed(2)
+	};
+
+	console.log(`${'='.repeat(60)}`);
+	console.log('📊 RESULTS SUMMARY');
+	console.log(`${'='.repeat(60)}`);
+	console.log(`SQL Operators ($exists, $regex, $gt, $in):`);
+	console.log(`  - $exists: ${(end1 - start1).toFixed(2)}ms`);
+	console.log(`  - $regex:  ${(end2 - start2).toFixed(2)}ms`);
+	console.log(`  - $gt:     ${(end3 - start3).toFixed(2)}ms`);
+	console.log(`  - $in:     ${(end4 - start4).toFixed(2)}ms`);
+	console.log(`  - Average: ${((end1 - start1 + end2 - start2 + end3 - start3 + end4 - start4) / 4).toFixed(2)}ms`);
+	console.log();
+	console.log(`Mingo Fallback ($elemMatch):`);
+	console.log(`  - $elemMatch: ${(end5 - start5).toFixed(2)}ms`);
+	console.log();
+	console.log(`Memory Delta:`);
+	console.log(`  - RSS: ${memDelta.rss}MB`);
+	console.log(`  - Heap: ${memDelta.heapUsed}MB`);
+	console.log(`${'='.repeat(60)}\n`);
+
+	await instance.close();
+
+	return {
+		sqlAvg: (end1 - start1 + end2 - start2 + end3 - start3 + end4 - start4) / 4,
+		mingoTime: end5 - start5,
+		memDelta
+	};
+}
+
+async function main() {
+	console.log('🏴‍☠️ SQL vs Mingo Performance Comparison');
+	console.log('Testing with bun:sqlite native driver\n');
+
+	const results10k = await benchmarkAtScale(10000);
+	const results100k = await benchmarkAtScale(100000);
+
+	console.log('\n' + '='.repeat(60));
+	console.log('🎯 FINAL VERDICT');
+	console.log('='.repeat(60));
+	console.log('\n10k documents:');
+	console.log(`  SQL avg:    ${results10k.sqlAvg.toFixed(2)}ms`);
+	console.log(`  Mingo:      ${results10k.mingoTime.toFixed(2)}ms`);
+	console.log(`  Ratio:      ${(results10k.mingoTime / results10k.sqlAvg).toFixed(2)}x`);
+	
+	console.log('\n100k documents:');
+	console.log(`  SQL avg:    ${results100k.sqlAvg.toFixed(2)}ms`);
+	console.log(`  Mingo:      ${results100k.mingoTime.toFixed(2)}ms`);
+	console.log(`  Ratio:      ${(results100k.mingoTime / results100k.sqlAvg).toFixed(2)}x`);
+
+	console.log('\n' + '='.repeat(60));
+	if (results100k.mingoTime / results100k.sqlAvg > 5) {
+		console.log('✅ VERDICT: SQL translation is WORTH IT at scale (5x+ faster)');
+		console.log('   Continue hybrid approach: SQL for simple, Mingo for complex');
+	} else if (results100k.mingoTime / results100k.sqlAvg > 2) {
+		console.log('⚠️  VERDICT: SQL is faster but not dramatically (2-5x)');
+		console.log('   Hybrid approach is reasonable, but Mingo-only is viable');
+	} else {
+		console.log('❌ VERDICT: SQL translation NOT worth the effort (<2x speedup)');
+		console.log('   Consider using Mingo everywhere for simplicity');
+	}
+	console.log('='.repeat(60) + '\n');
+}
+
+main().catch(console.error);

package/benchmarks/sql-vs-mingo-comparison.ts

@@ -0,0 +1,175 @@
+import { getRxStorageBunSQLite } from '../src/storage';
+import type { RxDocumentData } from 'rxdb';
+import { Query } from 'mingo';
+
+interface BenchmarkDocType {
+	id: string;
+	name: string;
+	age: number;
+	email?: string;
+	status: string;
+}
+
+async function sqlVsMingoComparison() {
+	console.log('🏴‍☠️ SQL vs Mingo: Head-to-Head Comparison\n');
+
+	const storage = getRxStorageBunSQLite();
+	const instance = await storage.createStorageInstance<BenchmarkDocType>({
+		databaseInstanceToken: 'sql-vs-mingo-token',
+		databaseName: 'benchmark',
+		collectionName: 'users',
+		schema: {
+			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: ['id', 'name', 'age', 'status', '_deleted', '_attachments', '_rev', '_meta']
+		},
+		options: {},
+		multiInstance: false,
+		devMode: false
+	});
+
+	console.log('📝 Inserting 100,000 documents...');
+	const insertStart = performance.now();
+	
+	const batchSize = 1000;
+	for (let batch = 0; batch < 100; batch++) {
+		const docs: Array<{ document: RxDocumentData<BenchmarkDocType> }> = [];
+		for (let i = 0; i < batchSize; i++) {
+			const idx = batch * batchSize + i;
+			const doc: any = {
+				id: `user${idx}`,
+				name: `User ${idx}`,
+				age: 18 + (idx % 50),
+				status: idx % 2 === 0 ? 'active' : 'inactive',
+				_deleted: false,
+				_attachments: {},
+				_rev: '1-abc',
+				_meta: { lwt: Date.now() }
+			};
+			
+			if (idx % 3 === 0) {
+				doc.email = `user${idx}@gmail.com`;
+			}
+			
+			docs.push({ document: doc });
+		}
+		await instance.bulkWrite(docs, 'benchmark');
+	}
+	
+	const insertEnd = performance.now();
+	console.log(`✅ Inserted 100,000 documents in ${(insertEnd - insertStart).toFixed(2)}ms\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 1: $gt operator (age > 50)');
+	console.log('='.repeat(60));
+	
+	const sqlStart1 = performance.now();
+	const sqlResult1 = await instance.query({
+		query: { selector: { age: { $gt: 50 } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const sqlEnd1 = performance.now();
+	console.log(`SQL (with indexes):  ${(sqlEnd1 - sqlStart1).toFixed(2)}ms - Found ${sqlResult1.documents.length.toLocaleString()} docs`);
+	
+	const mingoStart1 = performance.now();
+	const allDocs1 = await instance.query({
+		query: { selector: {}, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const mingoQuery1 = new Query({ age: { $gt: 50 } });
+	const mingoResult1 = allDocs1.documents.filter(doc => mingoQuery1.test(doc));
+	const mingoEnd1 = performance.now();
+	console.log(`Mingo (in-memory):   ${(mingoEnd1 - mingoStart1).toFixed(2)}ms - Found ${mingoResult1.length.toLocaleString()} docs`);
+	console.log(`Speedup: ${((mingoEnd1 - mingoStart1) / (sqlEnd1 - sqlStart1)).toFixed(2)}x faster with SQL\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 2: $eq operator (status = "active")');
+	console.log('='.repeat(60));
+	
+	const sqlStart2 = performance.now();
+	const sqlResult2 = await instance.query({
+		query: { selector: { status: { $eq: 'active' } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const sqlEnd2 = performance.now();
+	console.log(`SQL (with indexes):  ${(sqlEnd2 - sqlStart2).toFixed(2)}ms - Found ${sqlResult2.documents.length.toLocaleString()} docs`);
+	
+	const mingoStart2 = performance.now();
+	const allDocs2 = await instance.query({
+		query: { selector: {}, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const mingoQuery2 = new Query({ status: { $eq: 'active' } });
+	const mingoResult2 = allDocs2.documents.filter(doc => mingoQuery2.test(doc));
+	const mingoEnd2 = performance.now();
+	console.log(`Mingo (in-memory):   ${(mingoEnd2 - mingoStart2).toFixed(2)}ms - Found ${mingoResult2.length.toLocaleString()} docs`);
+	console.log(`Speedup: ${((mingoEnd2 - mingoStart2) / (sqlEnd2 - sqlStart2)).toFixed(2)}x faster with SQL\n`);
+
+	console.log('='.repeat(60));
+	console.log('Test 3: $in operator (status in ["active", "pending"])');
+	console.log('='.repeat(60));
+	
+	const sqlStart3 = performance.now();
+	const sqlResult3 = await instance.query({
+		query: { selector: { status: { $in: ['active', 'pending'] } }, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const sqlEnd3 = performance.now();
+	console.log(`SQL (with indexes):  ${(sqlEnd3 - sqlStart3).toFixed(2)}ms - Found ${sqlResult3.documents.length.toLocaleString()} docs`);
+	
+	const mingoStart3 = performance.now();
+	const allDocs3 = await instance.query({
+		query: { selector: {}, sort: [], skip: 0 },
+		queryPlan: { index: [], startKeys: [], endKeys: [], inclusiveStart: true, inclusiveEnd: true, sortSatisfiedByIndex: false, selectorSatisfiedByIndex: false }
+	});
+	const mingoQuery3 = new Query({ status: { $in: ['active', 'pending'] } });
+	const mingoResult3 = allDocs3.documents.filter(doc => mingoQuery3.test(doc));
+	const mingoEnd3 = performance.now();
+	console.log(`Mingo (in-memory):   ${(mingoEnd3 - mingoStart3).toFixed(2)}ms - Found ${mingoResult3.length.toLocaleString()} docs`);
+	console.log(`Speedup: ${((mingoEnd3 - mingoStart3) / (sqlEnd3 - sqlStart3)).toFixed(2)}x faster with SQL\n`);
+
+	const sqlAvg = ((sqlEnd1 - sqlStart1) + (sqlEnd2 - sqlStart2) + (sqlEnd3 - sqlStart3)) / 3;
+	const mingoAvg = ((mingoEnd1 - mingoStart1) + (mingoEnd2 - mingoStart2) + (mingoEnd3 - mingoStart3)) / 3;
+
+	console.log('='.repeat(60));
+	console.log('📊 FINAL RESULTS (100k documents)');
+	console.log('='.repeat(60));
+	console.log(`SQL (with indexes):  ${sqlAvg.toFixed(2)}ms average`);
+	console.log(`Mingo (in-memory):   ${mingoAvg.toFixed(2)}ms average`);
+	console.log(`Overall Speedup:     ${(mingoAvg / sqlAvg).toFixed(2)}x faster with SQL`);
+	console.log('='.repeat(60));
+	console.log();
+	
+	if (mingoAvg / sqlAvg > 2) {
+		console.log('✅ VERDICT: SQL with indexes is SIGNIFICANTLY faster (2x+)');
+		console.log('   Hybrid strategy VALIDATED: Use SQL for simple, Mingo for complex');
+	} else if (mingoAvg / sqlAvg > 1.5) {
+		console.log('⚠️  VERDICT: SQL is moderately faster (1.5-2x)');
+		console.log('   Hybrid strategy is reasonable but not dramatic');
+	} else {
+		console.log('❌ VERDICT: SQL and Mingo are similar (<1.5x difference)');
+		console.log('   Consider Mingo-only for simplicity');
+	}
+	console.log('='.repeat(60) + '\n');
+
+	await instance.close();
+}
+
+sqlVsMingoComparison().catch(console.error);