In 2019 we first introduced the ObjectBox database v0.1 for Flutter/Dart. Our team has loved the engagement and feedback we’ve received from the developer community since, and we’re thrilled to announce the first stable version 1.0 for ObjectBox Dart/Flutter today.
With this release we bring you the fast and easy to use ObjectBox database for Dart objects: optimized for high performance on mobile and desktop devices. ObjectBox persists your Dart objects (null safe, of course) and comes with relations, queries, transactions, and Data Sync. For a feature list and more, please also check the pub.dev page.
ObjectBox by Example
For those of you new to ObjectBox, here is how you can use it (or check the docs if you want to dive deep right away). By annotating a class with @Entity you tell ObjectBox that you want to persist its objects, which is done putting the object in a Box:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | @Entity() class Person { int id = 0; String firstName; String lastName; Person(this.firstName, this.lastName); } // Open a Store once and keep it open to get type specific Boxes final store = Store(getObjectBoxModel()); final box = store.box<Person>(); // let’s put a new Person in the database var person = Person("Marty", "McFly"); final id = box.put(person); |
What’s new with the 1.0?
Version 1.0 delivers a stabilized API and adds new essential features like async writes and query streams. We’ve also extended support for Flutter desktop. Let’s look at queries and how they can be used depending on the use case:
| 1 2 3 4 5 6 7 8 9 10 11 12 | // find all people whose name starts with "Mc"; 1. Query variant Query<Person> query = box.query(Person_.firstName.startsWith("Mc")).build(); List<Person> people = query.find(); // 2. variant: "watch" the DB for any changes in the entity, then rerun the query Stream<Query<Person>> watchedQuery = query.watch(); // You can then .listen(), or for example add the query to a StreamBuilder to show on UI. _controller.addStream(watchedQuery.map((Query<Person> q) => q.find())); // 3. variant: stream data from (non-trivial) queries: Stream<User> resultStream = box.query().build().stream(); await stream.forEach((Person person) => print(‘${person.firstName} ${person.lastName}’)); |
There are two new approaches to do async puts for asynchronous database writes: putAsync() returns a Future to check if the call was successful.
| 1 2 3 4 | Future<int> idFuture = box.putAsync(person); ... final id = await idFuture; userBox.get(id); // after the Future completed, the object is stored in the database |
Or you can use a background queue if you don’t need individual Futures, the following code inserts 100 objects and only waits once:
| 1 2 3 4 5 6 | for (int i = 0; i < 100; i++) { box.putQueued(Person(...)); } store.awaitAsyncSubmitted(); // after `awaitAsync*`: objects are inserted expect(box.count(), equals(100)); |
If you are interested in further improvements we made to 1.0, please check out the full changelog.
Dart Flutter Database Benchmarks
ObjectBox Dart v1.0 also comes with considerable optimizations bringing a new level of database performance to Flutter apps. ObjectBox enables data-heavy apps that were not possible on Flutter before. Consider this a first sneak-peek; stay tuned for detailed performance benchmarks to be released including queries (hint: they are really fast) along with updated benchmarking code.
What we tested
We looked at some two popular approaches: sqflite, a SQLite wrapper for Flutter (no Dart Native support), and Hive, a key-value store with Class-adapters which seems still popular although its creator abandoned it for architectural shortcomings (it has memory problems and does not support queries). In the previous benchmark we’ve also had a look at Firestore, but being an online-only database it was thousands of times slower than the rest so we’ve left it to rest this time around. Check our previous benchmark if you’re interested.
To get an overview of the databases, we tested CRUD operations (create, read, update, delete). Each test was run multiple times and executed manually outside of the measured time. Data preparation and evaluation were also done outside of the measured time.
Looking at the results, we can see ObjectBox performing significantly faster than sqflite across the board, with up to 100 time speed-up in case of create & update operations. Compared to Hive, the results are a little closer in some cases (read) though ObjectBox still comes out on top in all the metrics. Considering that Hive keeps all Dart objects in memory (!) while ObjectBox does not, should give you a good impression of how fast object persistence with ObjectBox is.
ObjectBox Database for Flutter/Dart Highlights
For those of you new to ObjectBox, here’s a quick summary of what our super-fast embedded database offers, out of the box:
- automatic schema migration: adding new classes or fields just works
- type-safe APIs, e.g. no interface{} arguments
- embedded edge database – no server needed, store all data directly on the device
- no ORM, no SQL
- relations: to-one, to-many (eager and lazy fetching)
- robust query support, including indexes for scalable lookups
- Support for implicit (automatic) and explicit (user defined)
- transactions: ACID compliant with superfast bulk/batch operations
- low memory usage
- runs across operating systems: 64-bit Linux, macOS, Windows, small 32-bit ARM-based Linux devices (e.g. Raspberry Pi)
- Data Sync: an efficient and easy way to synchronize data between your app and the cloud
Getting Started with ObjectBox for Flutter/Dart Today
ObjectBox is free to use and you can get started right now with the Flutter database on GitHub, via the docs, pub.dev, or this getting-started video tutorial, or getting-started article.
We ❤️ your Feedback
Now it’s your turn: let us know what you love, what you don’t, what do you want to see next? Share your feedback with us, or check out GitHub and up-vote the features you’d like to see next in ObjectBox.