Release Archives - ObjectBox

Vector Database Release for Flutter / Dart + Python

by Anna | Jun 13, 2023 | AI, Release, vector database

The Flutter / Dart and Python binding of our database now enable “vector types”. In both languages these are more commonly referred to as “lists” and now you are able to efficiently store lists of numeric types, i.e. integers and floating point numbers (aka “vectors / vector embeddings”). Native support for that is crucial for data intensive applications, especially in the field of AI.

What are Vector embeddings? Multi-dimensional vectors are a central building block for AI applications. And accordingly, the ability to store vectors to add long-term memory to your AI applications (e.g. via vector databases) is gaining importance. This is what the ObjectBox database now supports natively.

Dart example code

Let’s assume some shapes that use a palette of RGB colors. This allows the shape to reference colors by their index. An entity for this might look like this:

@Entity()
class Shape {
    @Id()
    int id = 0;

    // An array of RGB color values that are used by this shape.
    Int32List? palette;
}

@Entity()

class Shape {

@Id()

int id = 0;

// An array of RGB color values that are used by this shape.

Int32List? palette;

}

Python example code

Python is the number one programming language for AI. So let’s assume having an Image class that contains an URL to point to the content (e.g. JPEG/PNG images) and additionally a vector embedding. The latter are supplied by a ML model and contain a list of 32-bit floating points.

@Entity(id=1, uid=1)
class ImageEmbedding:
    id = Id(id=1, uid=1001)

    # Link to the actual image, e.g. on Cloud storage
    url = Property(str, id=2, uid=1002)

    # The vector embedding for this image (created via some ML model)
    embedding = Property(list, type=PropertyType.floatVector, id=3, uid=1003)

@Entity(id=1, uid=1)

class ImageEmbedding:

id = Id(id=1, uid=1001)

# Link to the actual image, e.g. on Cloud storage

url = Property(str, id=2, uid=1002)

# The vector embedding for this image (created via some ML model)

embedding = Property(list, type=PropertyType.floatVector, id=3, uid=1003)

There is more…

The support for vector types is not the only new feature. E.g. ObjectBox Flutter database comes with several fixes and our Python database binding now also supports date types. For details, please check the changelog for Dart DB vector release or Python DB vector release.

Vector types (aka arrays) added with ObjectBox Java 3.6 release

by Vivien | Jun 1, 2023 | AI, Edge Database, Release, vector database

Vector embeddings (multi-dimensional vectors) are a central building block for AI applications. And accordingly, the ability to store vectors to add long-term memory to your AI applications (e.g. via vector databases) is gaining importance. Sounds fancy, but for the basic use cases, this simply boils down to “arrays of floats” for developers. And this is exactly what ObjectBox database now supports natively. If you want to use vectors on the edge, e.g. in a mobile app or on an embedded device, when offline, independent from an Internet connection, removing the unknown latency, try it…

See the release notes for all new features this release brings.

Code Examples

Let’s start with a simple example: let’s assume some shapes that use a palette of RGB colors. An entity for this might look like this:

@Entity
public class Shape {

    @Id
    public long id;

    // An array of RGB color values that are used by this shape.
  public int[ ] palette;
}

@Entity

public class Shape {

@Id

public long id;

// An array of RGB color values that are used by this shape.

public int[ ] palette;

}

We can now create a query to find all shapes that use a certain color:

// Find all shapes that use red in their palette
try (Query&lt;Shape&gt; query = store.boxFor(Shape.class)
        .query(Shape_.palette.equal(0xFF0000 /* red */))
        .build()) {
        query.findIds();
}

// Find all shapes that use red in their palette

try (Query<Shape> query = store.boxFor(Shape.class)

.query(Shape_.palette.equal(0xFF0000 /* red */))

.build()) {

query.findIds();

}

Another typical use case is the embedding of certain types of data, like text, audio or images, as vector coordinates. To store such a vector embedding, in the following example we store the floating point coordinates that were computed by a machine learning model for an image together with a reference to the actual image:

@Entity
public class ImageEmbedding {

    @Id
    public long id;

    // Link to the actual image, e.g. on Cloud storage
    public String url;

    // The coordinates computed for this image (vector embedding)
    public float[] coordinates;

}

@Entity

public class ImageEmbedding {

@Id

public long id;

// Link to the actual image, e.g. on Cloud storage

public String url;

// The coordinates computed for this image (vector embedding)

public float[] coordinates;

}

Ready to go?

To update to this release, change the version of objectbox-gradle-plugin to 3.6.0.

To add ObjectBox database to your JVM or Android project read our Getting Started guide.
As always, we look forward to your feedback on GitHub or via our anonymous feedback form and hope you have a great time building apps with ObjectBox! ❤️

New async APIs in ObjectBox database 2.0.0 for Flutter/Dart

by Anna | Mar 21, 2023 | Release

ObjectBox Flutter database reached 2.0 today – with new async APIs.

This release has major improvements when using ObjectBox with asynchronous programming in Dart. Notably, the Box API has added async variants of methods to get and put one or more objects.

Let’s take the example from the package README and make it async:

// Put a new object into the box
var person = Person(name: "Joe Green");
final id = await box.putAsync(person);

// Get the object back from the box
person = await box.getAsync(id)!;

// Update the object
person.name = "Joe Black";
await box.putAsync(person);

// Remove the object from the box
await box.removeAsync(person.id);

// Put a new object into the box

var person = Person(name: "Joe Green");

final id = await box.putAsync(person);

// Get the object back from the box

person = await box.getAsync(id)!;

// Update the object

person.name = "Joe Black";

await box.putAsync(person);

// Remove the object from the box

await box.removeAsync(person.id);

The Query API also has added async variants of methods to find matching objects. Let’s make the query example async as well:

// Query for objects
final query = box.query(Person_.name.equals("Joe Black"))
    .order(Person_.name).build();
final people = await query.findAsync();
query.close();

// Query for objects

final query = box.query(Person_.name.equals("Joe Black"))

.order(Person_.name).build();

final people = await query.findAsync();

query.close();

Behind the scenes, these use the existing async API provided by Store which runs the operation on a worker isolate. With this release we have made additional improvements that allow it to be used with objects that contain relations (ToOne and ToMany). This made us comfortable to offer it through the new async convenience methods on Box and Query mentioned above.

Sometimes, it is favorable to bundle multiple database operations and execute them “at once”. This is what runInTransactionAsync() is for. It allows to use the synchronous APIs and wrap them in a single, asynchronous transaction. For example, let’s look at transferring funds between two bank accounts. The fund can safely be transferred from one account to another by reading the current balances, deducting the amount from one account and adding the amount to another account:

void _transferFunds(Store store, List<int> ids) {
  final box = store.box<account>();
  final from = box.get(ids[0])!;
  final to = box.get(ids[1])!;
  from.balance -= 100;
  to.balance += 100;
  box.putMany([from, to]);
}

await store.runInTransactionAsync(TxMode.write, 
    _transferFunds, [accountIdFrom, accountIdTo]);
</account></int>

void _transferFunds(Store store, List<int> ids) {

final box = store.box<account>();

final from = box.get(ids[0])!;

final to = box.get(ids[1])!;

from.balance -= 100;

to.balance += 100;

box.putMany([from, to]);

}

await store.runInTransactionAsync(TxMode.write,

_transferFunds, [accountIdFrom, accountIdTo]);

</account></int>

This is more efficient than calling multiple async operations and further offers transactional safety as ObjectBox offers ACID semantics.

Ready to go? To upgrade to this major release run flutter pub upgrade objectbox --major-versions (or for Dart Native apps dart pub upgrade objectbox --major-versions ).

To add ObjectBox database to your Flutter project read our Getting Started guide. Also, if you are interested to know how ObjectBox compares to competitors, check out this 2023 overview and comparison of Flutter databases article.

As always, we look forward to your feedback on GitHub or via our anonymous feedback form and hope you have a great time building apps with ObjectBox!

ObjectBox Database Java 3.1 – Flex type

by Anna | Dec 20, 2021 | Android, Mobile Database, ObjectBox, Release

We are happy to announce version 3.1 of ObjectBox for Java and Kotlin. The major feature of this version is the new Flex type. For a long time, ObjectBox worked on rigid data schemas, and we think that this is a good thing. Knowing what your data looks like is a feature – similar to programming languages that are statically typed. Fixed schemas make data handling more predictable and robust. Nevertheless, sometimes there are use cases which require flexible data structures. ObjectBox 3.1 allows exactly this.

Flex properties

Expanding on the string and flexible map support in 3.0.0, this release adds support for Flex properties where the type must not be known at compile time. To add a Flex property to an entity use Object in Java and Any? in Kotlin. Then at runtime store any of the supported types.

For example, assume a customer entity with a tag property:

// Java
@Entity
public class Customer { 

   @Id    
   private long id;    
   private Object tag;

   // TODO getter and setter
}

// Kotlin
@Entity
data class Customer(    
   @Id var id: Long = 0,    
   var tag: Any? = null
)

// Java

@Entity

public class Customer {

@Id

private long id;

private Object tag;

// TODO getter and setter

}

// Kotlin

@Entity

data class Customer(

@Id var id: Long = 0,

var tag: Any? = null

)

Then set a String tag on one customer, and an Integer tag on another customer and just put them:

// Java
Customer customerStrTag = new Customer();
customerStrTag.setTag("string-tag");
Customer customerIntTag = new Customer();
customerIntTag.setTag(1234);
box.put(customerStrTag, customerIntTag);

// Kotlin
val customerStrTag = Customer(tag = "string-tag")
val customerIntTag = Customer(tag = 1234)
box.put(customerStrTag, customerIntTag)

// Java

Customer customerStrTag = new Customer();

customerStrTag.setTag("string-tag");

Customer customerIntTag = new Customer();

customerIntTag.setTag(1234);

box.put(customerStrTag, customerIntTag);

// Kotlin

val customerStrTag = Customer(tag = "string-tag")

val customerIntTag = Customer(tag = 1234)

box.put(customerStrTag, customerIntTag)

When getting the customer from its box the original type is restored. For simplicity the below example just casts the tag to the expected type:

// Java
String stringTag = (String) 
box.get(customerStrTag.getId()).getTag();
Integer intTag = (Integer) 
box.get(customerIntTag.getId()).getTag();

// Kotlin
val stringTag = box.get(customerStrTag.id).tag as String
val intTag = box.get(customerIntTag.id).tag as Int

// Java

String stringTag = (String)

box.get(customerStrTag.getId()).getTag();

Integer intTag = (Integer)

box.get(customerIntTag.getId()).getTag();

// Kotlin

val stringTag = box.get(customerStrTag.id).tag as String

val intTag = box.get(customerIntTag.id).tag as Int

A Flex property can be not justString or Integer. Supported types are all integers (Byte, Short, Integer, Long), floating point numbers (Float, Double), String and byte arrays.

It can also hold a List<Object> or a Map<String, Object> of those types. Lists and maps can be nested.

Behind the scenes Flex properties use a FlexBuffer converter to store the property value, so some limitations apply. See the FlexObjectConverter class documentation for details.

Query for map keys and values

If the Flex property contains integers or strings, or a list or map of those types, it’s also possible to do queries. For example, take this customer entity with a properties String to String map:

// Java
@Entity
public class Customer {
    @Id
    private long id;
    private Map<String, String> properties;

    // TODO getter and setter
}

// Kotlin
@Entity
data class Customer(
    @Id var id: Long = 0,
    var properties: MutableMap<String, String>? = null
)

// Java

@Entity

public class Customer {

@Id

private long id;

private Map<String, String> properties;

// TODO getter and setter

}

// Kotlin

@Entity

data class Customer(

@Id var id: Long = 0,

var properties: MutableMap<String, String>? = null

)

Why is properties not of type Object? ObjectBox supports using Map<String, String> (or Map<String, Object>) directly and will still create a Flex property behind the scenes.

Then put a customer with a premium property:

// Java
Customer customer = new Customer();
Map<String, String> properties = new HashMap<>();
properties.put("premium", "tier-1");
customer.setProperties(properties);
box.put(customer);

// Kotlin
val customer = Customer(
    properties = mutableMapOf("premium" to "tier-1")
)
box.put(customer)

// Java

Customer customer = new Customer();

Map<String, String> properties = new HashMap<>();

properties.put("premium", "tier-1");

customer.setProperties(properties);

box.put(customer);

// Kotlin

val customer = Customer(

properties = mutableMapOf("premium" to "tier-1")

)

box.put(customer)

To query for any customers that have a premium key in their properties map, use the containsElement condition:

// Java
Query<customer> queryPremiumAll = box.query(
        Customer_.properties.containsElement("premium")
).build();

// Kotlin
val queryPremiumAll = box.query(
    Customer_.properties.containsElement("premium")
).build()
</customer>

// Java

Query<customer> queryPremiumAll = box.query(

Customer_.properties.containsElement("premium")

).build();

// Kotlin

val queryPremiumAll = box.query(

Customer_.properties.containsElement("premium")

).build()

</customer>

Or to only match customers where the map key has a specific value, here a specific premium tier, use the containsKeyValue condition:

// Java
Query<customer> queryPremiumTier1 = box.query(
        Customer_.properties.containsKeyValue("premium", "tier-1")
).build();

// Kotlin
val queryPremiumTier1 = box.query(
    Customer_.properties.containsKeyValue("premium", "tier-1")
).build()
</customer>

// Java

Query<customer> queryPremiumTier1 = box.query(

Customer_.properties.containsKeyValue("premium", "tier-1")

).build();

// Kotlin

val queryPremiumTier1 = box.query(

Customer_.properties.containsKeyValue("premium", "tier-1")

).build()

</customer>

What’s next?

ObjectBox database is free to use. Check out our docs and this video tutorial to get started today.

We strive to bring joy to mobile developers and appreciate all kinds feedback, both positive and negative. You can always raise an issue on GitHub or post a question on Stackoverflow. Otherwise, star the ObjectBox Java database GitHub repo and up-vote the features you’d like to see in the next release.

ObjectBox Database Java / Kotlin 3.0 + CRUD Benchmarks

by Markus | Oct 19, 2021 | Android, Benchmarks, Mobile Database, ObjectBox, Release

The Android database for superfast Java / Kotlin data persistence goes 3.0. Since our first 1.0-release in 2017 (Android-first, Java), we have released C/C++, Go, Flutter/Dart, Swift bindings, as well as Data Sync and we’re thrilled that ObjectBox has been used by over 800,000 developers.

We love our Java / Kotlin community ❤️ who have been with us since day one. So, with today’s post, we’re excited to share a feature-packed new major release for Java Database alongside CRUD performance benchmarks for MongoDB Realm, Room (SQLite) and ObjectBox.

What is ObjectBox?

ObjectBox is a high performance database and an alternative to SQLite and Room. ObjectBox empowers developers to persist objects locally on Mobile and IoT devices. It’s a NoSQL ACID-compliant object database with an out-of-the-box Data Sync providing fast and easy access to decentralized edge data (Early Access).

New Query API

A new Query API is available that works similar to our existing Dart/Flutter Query API and makes it easier to create nested conditions:

// Kotlin
// equal AND (less OR oneOf)
val query = box.query(
       User_.firstName equal "Joe"
               and (User_.age less 12
               or (User_.stamp oneOf longArrayOf(1012))))
       .order(User_.age)
       .build()

// Java
// equal AND (less OR oneOf)
Query<User> query = box.query(
        User_.firstName.equal("Joe")
                .and(User_.age.less(12)
                        .or(User_.stamp.oneOf(new long[]{1012}))))
        .order(User_.age)
        .build();

// Kotlin

// equal AND (less OR oneOf)

val query = box.query(

User_.firstName equal "Joe"

and (User_.age less 12

or (User_.stamp oneOf longArrayOf(1012))))

.order(User_.age)

.build()

// Java

// equal AND (less OR oneOf)

Query<User> query = box.query(

User_.firstName.equal("Joe")

.and(User_.age.less(12)

.or(User_.stamp.oneOf(new long[]{1012}))))

.order(User_.age)

.build();

In Kotlin, the condition methods are also available as infix functions. This can help make queries easier to read:

val query = box.query(User_.firstName equal "Joe").build()

1	val query = box.query(User_.firstName equal "Joe").build()

Unique on conflict replace strategy

One unique property in an @Entity can now be configured to replace the object in case of a conflict (“onConflict”) when putting a new object.

// Kotlin
@Entity
data class Example(
        @Id
        var id: Long = 0,

        @Unique(onConflict = ConflictStrategy.REPLACE)
        var uniqueKey: String? = null
)

// Java
@Entity
public class Example {
    @Id
    public long id;

    @Unique(onConflict = ConflictStrategy.REPLACE)
    String uniqueKey;
}

// Kotlin

@Entity

data class Example(

@Id

var id: Long = 0,

@Unique(onConflict = ConflictStrategy.REPLACE)

var uniqueKey: String? = null

)

// Java

@Entity

public class Example {

@Id

public long id;

@Unique(onConflict = ConflictStrategy.REPLACE)

String uniqueKey;

}

This can be helpful when updating existing data with a unique ID different from the ObjectBox ID. E.g. assume an app that downloads a list of playlists where each has a modifiable title (e.g. “My Jam”) and a unique String ID (“playlist-1”). When downloading an updated version of the playlists, e.g. if the title of “playlist-1” has changed to “Old Jam”, it is now possible to just do a single put with the new data. The existing object for “playlist-1” is then deleted and replaced by the new version.

Built-in string array and map support

String array or string map properties are now supported as property types out-of-the-box. For string array properties it is now also possible to find objects where the array contains a specific item using the new containsElement condition.

// Kotlin
@Entity
data class Example(
        @Id
        var id: Long = 0,
        var stringArray: Array<String>? = null,
        var stringMap: MutableMap<String, String>? = null
)

// matches [“first”, “second”, “third”]
box.query(Example_.stringArray.containsElement(“second”)).build()

// Java
@Entity
public class Example {
    @Id
    public long id;

    public String[] stringArray;
    public Map<String, String> stringMap;
}

// matches [“first”, “second”, “third”]
box.query(Example_.stringArray.containsElement(“second”)).build();

// Kotlin

@Entity

data class Example(

@Id

var id: Long = 0,

var stringArray: Array<String>? = null,

var stringMap: MutableMap<String, String>? = null

)

// matches [“first”, “second”, “third”]

box.query(Example_.stringArray.containsElement(“second”)).build()

// Java

@Entity

public class Example {

@Id

public long id;

public String[] stringArray;

public Map<String, String> stringMap;

}

// matches [“first”, “second”, “third”]

box.query(Example_.stringArray.containsElement(“second”)).build();

Kotlin Flow, Android 12 and more

Kotlin extension functions were added to obtain a Flow from a BoxStore or Query:

val flow = box.query().subscribe().toFlow()

1	val flow = box.query().subscribe().toFlow()

Data Browser has added support for apps targeting Android 12.

For details on all changes, please check the ObjectBox for Java changelog.

Room (SQLite), Realm & ObjectBox CRUD performance benchmarks

We compared against the Android databases, MongoDB Realm and Room (on top of SQLite) and are happy to share that ObjectBox is still faster across all four major database operations: Create, Read, Update, Delete.

Android database comparative benchmarks for ObjectBox, Realm, and Room

We benchmarked ObjectBox along with Room 2.3.0 using SQLite 3.22.0 and MongoDB Realm 10.6.1 on an Samsung Galaxy S9+ (Exynos) mobile phone with Android 10. All benchmarks were run 10+ times and no outliers were discovered, so we used the average for the results graph above. Find our open source benchmarking code on GitHub and as always: feel free to check them out yourself. More to come soon, follow us on Twitter or sign up to our newsletter to stay tuned (no spam ever!).

Using a fast on-device database matters

A fast local database is more than just a “nice-to-have.” It saves device resources, so you have more resources (CPU, Memory, battery) left for other resource-heavy operations. Also, a faster database allows you to keep more data locally with the device and user, thus improving privacy and data ownership by design. Keeping data locally and reducing data transferal volumes also has a significant impact on sustainability.

Sustainable Data Sync

Some data, however, you might want or need to synchronize to a backend. Reducing overhead and synchronizing data selectively, differentially, and efficiently reduces bandwidth strain, resource consumption, and cloud / Mobile Network usage – lowering the CO2 emissions too. Check out ObjectBox Data Sync, if you are interested in an out-of-the-box solution.

Get Started with ObjectBox for Java / Kotlin Today

ObjectBox is free to use and you can get started right now via this getting-started article, or follow this video.

Already an ObjectBox Android database user and ready to take your application to the next level? Check out ObjectBox Data Sync, which solves data synchronization for edge devices, out-of-the-box. It’s incredibly efficient and (you guessed it) superfast 😎

We ❤️ your Feedback

We believe, ObjectBox is super easy to use. We are on a mission to make developers’ lives better, by building developer tools that are intuitive and fun to code with. 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.

Dart Flutter Database ObjectBox 1.0 Release

by Vivien | May 18, 2021 | Mobile Database, ObjectBox, Release

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:

@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);

@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:

 // 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}’));

// 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.

Future<int> idFuture = box.putAsync(person);
...
final id = await idFuture;
userBox.get(id); // after the Future completed, the object is stored in the database

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:

for (int i = 0; i < 100; i++) {
  box.putQueued(Person(...));
}
store.awaitAsyncSubmitted();
// after `awaitAsync*`: objects are inserted
expect(box.count(), equals(100));

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.

ObjectBox, sqflite, Hive performance comparison across CRUD

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.

« Older Entries