Performance Optimization Guide

This guide provides strategies for optimizing the performance of NebulaDB in your applications.

Understanding NebulaDB Performance

NebulaDB is designed to be fast by default, with in-memory operations and efficient data structures. However, as your data grows or your application becomes more complex, you may need to optimize for specific use cases.

Key Performance Factors

1. Data Size: The number of documents in a collection
2. Query Complexity: The complexity of your queries
3. Indexing: Whether appropriate indexes are in place
4. Adapter Choice: The storage adapter being used
5. Plugin Overhead: The number and complexity of plugins

Measuring Performance

Before optimizing, establish a baseline by measuring current performance:

// Measure query performance
console.time('Query');
const results = await collection.find({ /* your query */ });
console.timeEnd('Query');

// Measure insert performance
console.time('Insert');
await collection.insert({ /* your document */ });
console.timeEnd('Insert');

// Measure update performance
console.time('Update');
await collection.update({ /* query */ }, { /* update */ });
console.timeEnd('Update');

For more comprehensive benchmarking, use the benchmarking tools in the benchmarks directory.

Optimization Strategies

1. Use Indexes

Indexes are the most effective way to improve query performance:

// Create an index on frequently queried fields
collection.createIndex({ name: 'email_idx', fields: ['email'], type: 'unique' });

// Create a compound index for queries that filter on multiple fields
collection.createIndex({ name: 'user_location_idx', fields: ['country', 'city'], type: 'compound' });

• Index fields that are frequently used in queries
• For compound indexes, order fields from most selective to least selective
• Don't over-index - each index adds overhead to write operations

2. Optimize Query Patterns

// GOOD: Specific query that can use an index
await users.find({ email: 'user@example.com' });

// AVOID: Complex queries that can't use indexes efficiently
await users.find({ $or: [{ name: { $regex: '^A' } }, { age: { $gt: 30 } }] });

• Use equality conditions when possible
• Limit the use of complex logical operators like $or
• Avoid regular expressions when possible
• Use projection to limit the fields returned

3. Batch Operations

// Instead of this
for (const item of items) { await collection.insert(item); }

// Do this
const promises = items.map(item => collection.insert(item));
await Promise.all(promises);

4. Choose the Right Adapter

• MemoryAdapter: Fastest, but no persistence
• LocalStorageAdapter: Fast for small datasets, limited storage
• IndexedDBAdapter: Good for larger browser datasets
• FileSystemAdapter: Good for Node.js applications
• SQLiteAdapter: Better for larger datasets with complex queries
• RedisAdapter: Good for high-throughput applications

5. Minimize Plugin Overhead

• Only use plugins you need
• Configure plugins appropriately
• Place performance-critical plugins (like caching) early in the plugin chain

6. Pagination for Large Result Sets

async function getPage(collection, query, page, pageSize) {
  const allDocs = await collection.find(query);
  const start = (page - 1) * pageSize;
  return allDocs.slice(start, start + pageSize);
}
const page1 = await getPage(users, { active: true }, 1, 10);

7. Subscription Optimization

• Be specific with subscription queries
• Limit the number of active subscriptions
• Unsubscribe when no longer needed

8. Memory Management

• Consider using a persistent adapter for large datasets
• Implement pagination for large result sets
• Use projection to limit returned fields
• Release references to large objects when no longer needed

Case Studies

Case Study 1: Optimizing a Todo App

Before: 1,000 todos, no indexes, full collection scan — ~50ms queries

After: Index on completed + dueDate — ~5ms queries (10x improvement)

Case Study 2: Large Dataset Management

Before: 100,000 records, MemoryAdapter, all data loaded at once — high memory

After: Switched to SQLiteAdapter, pagination, indexes — 80% less memory, 60% faster loads

Conclusion

Performance optimization is an iterative process. Start with the simplest optimizations (like adding indexes) and measure the impact before moving to more complex strategies. Remember that premature optimization can lead to unnecessary complexity.