📚 Documentation: Visit our documentation site for detailed guides and API references.
A high-performance, type-safe NoSQL database for Dart and Flutter applications.
- 🚀 Performance: Optimized for speed with LSM-Tree storage
- 🔒 Type Safety: Compile-time type checking and validation
- 🔄 Reactive: Real-time data synchronization
- 📊 Query Engine: Powerful querying capabilities
- 🔄 Transactions: ACID-compliant transactions
- 📈 Scalability: Efficient handling of large datasets
- 🛠 Developer Experience: Annotation-driven code generation
- 🔄 Schema Migrations: Automatic schema version management
- ✅ Field Validation: Built-in validation with custom rules
- 🔐 Access Control: Field-level visibility control
- 🔄 Relationships: Support for one-to-many and many-to-many relationships
- 🧹 Data Management: Methods for complete database cleanup and reset
Add this to your package's pubspec.yaml file:
dependencies:
quanta_db: ^0.0.9You can install packages from the command line:
$ dart pub getimport 'package:quanta_db/quanta_db.dart';
void main() async {
// Open the database
final db = await QuantaDB.open('my_database');
// Define your model
@QuantaEntity(version: 1)
class User {
@QuantaId()
final String id;
@QuantaField(required: true)
final String name;
@QuantaIndex()
final String email;
User({required this.id, required this.name, required this.email});
}
// Insert data
final user = User(id: '1', name: 'John', email: '[email protected]');
await db.put('user:1', user);
// Query data
final queryEngine = QueryEngine(db.storage);
final users = await queryEngine.query<User>(
Query<User>().where((user) => user.name.startsWith('J'))
);
print('Users: $users');
// Close the database
await db.close();
}// Open database
final db = await QuantaDB.open('my_database');
// Put data
await db.put('key', {'name': 'value'});
// Get data
final data = await db.get('key');
// Delete data
await db.delete('key');
// Close database
await db.close();QuantaDB provides a rich set of annotations for defining your data models:
@QuantaEntity(version: 1)
class User {
@QuantaId()
final String id;
@QuantaField(required: true)
final String name;
}@QuantaIndex()
final String email;
@QuantaCompositeIndex(fields: ['firstName', 'lastName'])
final String fullName;@QuantaHasMany(targetEntity: Post, foreignKey: 'userId')
final List<Post> posts;
@QuantaManyToMany(targetEntity: Group)
final List<Group> groups;The code generator supports a comprehensive range of data types:
final String name;
final int age;
final double score;
final bool isActive;
final DateTime createdAt;final List<String> tags;
final Map<String, dynamic> metadata;
final Set<String> permissions;enum UserType { admin, user, guest }
final UserType? userType;@QuantaField(
required: true,
min: 0,
max: 120,
pattern: r'^[a-zA-Z]+$'
)
final String name;@QuantaReactive()
final DateTime lastLogin;
// Watch for changes
final queryEngine = QueryEngine(db.storage);
final stream = queryEngine.watch<User, User>(
Query<User>().where((user) => user.lastLogin != null)
);
await for (final user in stream) {
print('User logged in at: ${user.lastLogin}');
}QuantaDB is designed for speed. Here are benchmark results comparing QuantaDB's performance for 10,000 operations:
| Operation | QuantaDB | Hive | SQLite |
|---|---|---|---|
| Write | 30ms | 216ms | 3290ms |
| Read | 9ms | 8ms | 299ms |
| Batch | 15ms | 180ms | 2800ms |
| Query | 25ms | 45ms | 150ms |
| DeleteAll | O(1) | O(n) | O(n) |
As you can see, QuantaDB demonstrates significantly faster performance across all operations.
Check out the benchmark code here to run it yourself and see the details.
Existing local databases for Dart/Flutter often have external dependencies or performance limitations. QuantaDB aims to overcome these challenges by implementing a Log-Structured Merge Tree (LSM-Tree) storage engine from scratch in pure Dart, coupled with an annotation-driven code generation system for a developer-friendly experience.
Our goals include:
- Achieving competitive read and write performance.
- Providing a simple and intuitive API.
- Ensuring data durability and consistency.
- Supporting complex data models with relationships and indexing.
- Offering a reactive query system for real-time updates.
QuantaDB is built with a layered architecture to separate concerns and improve maintainability. The core of the database is the LSM-Tree storage engine.
Below is a high-level overview of the QuantaDB architecture:
- Application Layer: Provides the public API and integrates with the annotation and code generation systems.
- Core Engine Layer: Contains the central logic for query processing, LSM storage management, and transactions.
- Storage Layer: Implements the core storage components like MemTable, SSTable Manager, Bloom Filters, and Compaction.
- Platform Layer: Interacts with the underlying file system and utilizes isolate workers for background tasks.
Here's a diagram illustrating the typical data flow within QuantaDB:
- Data enters through the API.
- Queries are processed by the Query Engine.
- Write operations go through the MemTable and are eventually flushed to SSTables.
- Read operations utilize Bloom Filters and the MemTable before hitting SSTables.
- Compaction runs in the background to merge and optimize SSTables.
We welcome contributions! Please see our Contributing Guide for details.
This project is licensed under the MIT License - see the LICENSE file for details.
- Tushar Nikam - LinkedIn
View all contributors and their issues on our GitHub Issues page
Made with ❤️ by the QuantaDB Team