Markus Junginger

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

// 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();

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

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

ObjectBox Dart/Flutter v0.11 Database: Performance & Relations

by Markus | Feb 2, 2021 | Benchmarks, Mobile Database, ObjectBox, Release | 4 comments

Flutter Databases are few. Therefore, we’re happy to take a big step towards 1.0 with this ObjectBox Dart v0.11 release, improving performance and bringing the much-desired relations support known from other ObjectBox DB language bindings to Dart/Flutter.

For those of you new to ObjectBox: ObjectBox is a superfast NoSQL object database for Flutter / Dart and here is how you can save data in your Dart / Flutter apps:

@Entity()
class Person {
  int id;

  String firstName;
  String lastName;
}

final store = Store(getObjectBoxModel());
final box = store.box<Person>();

var person = Person()
  ..firstName = "Joe"
  ..lastName = "Green";

final id = box.put(person);  // Create

person = box.get(id);        // Read

person.lastName = "Black";
box.put(person);             // Update

box.remove(person.id);       // Delete

// find all people whose name start with letter 'J'
final query = box.query(Person_.firstName.startsWith('J')).build();
final people = query.find();  // find() returns List<Person>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

@Entity()

class Person {

int id;

String firstName;

String lastName;

}

final store = Store(getObjectBoxModel());

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

var person = Person()

..firstName = "Joe"

..lastName = "Green";

final id = box.put(person); // Create

person = box.get(id); // Read

person.lastName = "Black";

box.put(person); // Update

box.remove(person.id); // Delete

// find all people whose name start with letter 'J'

final query = box.query(Person_.firstName.startsWith('J')).build();

final people = query.find(); // find() returns List<Person>

To learn about more ObjectBox features, like relations, queries and data sync, check our ObjectBox pub.dev page.

How fast is ObjectBox Dart? Performance Benchmarks

Speed is important for data persistence solutions. Accordingly, we wanted to test how ObjectBox compares performance-wise to other Flutter Dart database options. Therefore, we looked for libraries with comparable levels of storage abstraction and feature set – so not just plain SQL/Key-value storage but also ORM-like features. There doesn’t seem to be that much choice…

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 technology is phased out (see below). As a third alternative we pulled in Firestore, which does not really fit as it is no local database, but would be fun to compare anyway.

What we tested

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 was also done outside of the measured time.

We tried to keep the test implementations as close as possible to each other while picking the approaches recommended by the docs for each database. We open sourced the test code at https://github.com/objectbox/objectbox-dart-performance if you want to have a closer look.

Performance Benchmark Results

Looking at the results, we can see ObjectBox performing significantly faster than sqflite across the board, with up to 70 times speedup in case of create & update operations. Compared to Hive, the results are a little more varied, with Hive being faster at reading objects than ObjectBox (we come to that later in our outlook), and ObjectBox being faster at creating objects, about four times faster at updates and three times for deletes. As a mostly-online database, it becomes clear that Firestore’s performance is not really comparable.

Implementation notes

ObjectBox: This release largely boosted the performance. The remaining bottlenecks are due to Dart itself and how it allows to modify byte buffers. There’s potential to double the speed if we look at other languages supported by ObjectBox. And if that’s not happening soon, we’d still have the option to do some low-level hacks…

Sqflite: a wrapper around SQLite, which is a relational database without direct support for Dart objects. Each dart object field is mapped to a column in the database, as per sqflite docs, i.e. converting between the Dart class and a Map.

Hive: We’ve tested with the latest Hive release, which is technically discontinued. The author hit two architectural roadblocks (RAM usage and queries) and is currently in the process to do a rewrite from scratch.
Update: strictly speaking it’s not straightforward to directly compare e.g. ObjectBox vs. Hive. In Hive, the high read numbers result from Dart objects already cached in memory. If the objects are fetched using the async API from disk, the numbers drop by factor 1000.

Firestore: This is totally apples and oranges, but we still decided to include Firebase/Firestore as it seems at least somewhat popular to “persist data”. It’s quite Cloud centric and thus offers limited offline features. For example, in order to use batches (“transactions”), an internet connection is required to “commit”. Also, due to its low performance, the test configuration was different: batches of 500 objects and only 10 runs.

Test setup

We ran the benchmarks as a Flutter app on a Android 10 device with a Kirin 980 CPU. The app executed all operations in batches of 10.000 objects, with each batch forming a single transaction. Each test was run 50 times, averaging the results over all the runs. This ensured the VM warmup (optimization) during the first run and garbage collections don’t affect the overall result significantly. (We care about accurate benchmarks; read more about our benchmarking best practices here.)

Outlook

With this latest release, we’re not far away from a stable API for a 1.0 release (🎉), so please share your thoughts and feedback. For the next release, we’ll add features like async operations, more relation types and some smaller improvements. We are also working on an ObjectBox variant for the Web platform that is planned close to the 1.0 release. And of course there is ObjectBox Data Sync for Flutter/Dart. If you want to be first in line to try, drop us a line, we can put you on the shortlist.

ObjectBox Swift 1.4 – In Relation to…

by Markus | Sep 8, 2020 | ObjectBox, Release, Swift

ObjectBox for Swift 1.4 makes object relations more natural and intuitive for Swift developers. For example, let’s take the teacher-student relation to Swift and how you store objects in the database. Let’s say “Teacher” is a Swift class that has a collection called “students”. Now let’s say we have a new teacher with new students and want to store them in the ObjectBox database. It’s done like this:

let yoda = Teacher(name: "Yoda") yoda.students.append(Student(name: "Luke")) yoda.students.append(Student(name: "Anakin")) try box.put(yoda)

This is pretty much standard Swift. A single put command is enough to store all three new objects in the database (sorry for the “try”, Yoda, but you know, IO…). Now let’s see how this works. The students’ property in the Teacher’s class is of type ToMany<Student> and works like any Swift collection. This is because ToMany implements the protocols RandomAccessCollection and RangeReplaceableCollection. Under the hood however, it tracks all changes. Thus, when ObjectBox is instructed to put Yoda in a box, it also knows that two students were added. It also knows that our two Jedi students are new and thus puts them in database too. If you supply students that have been already persisted, it won’t put them. You can also mix new and existing objects.

Version 1.4 does not only bring TooMany (sic) improvements, but also brings a couple of new features, e.g. a bulk-get and read-only stores. You also may have heard of Sync (some kind of teleportation for objects, my young padawan). We’re still working on that, but we started to expose the Sync API with this release. It doesn’t come with any (space consuming) implementation so it’s really about getting early awareness and feedback. A full changelog is available at the docs.

So, time to start your (cocoa) pod again and let us know what you think. May the for… um, OK, that’s getting too many references for one article. One to many.

Introducing: ObjectBox Generator, plus C++ API [Request for Feedback!]

by Markus | Jun 16, 2020 | Edge Computing, IoT, Open Source, Release

We are introducing the ObjectBox Generator today to simplify ObjectBox development for more programming languages, starting with C/C++. Additionally, we are releasing a brand new C++ API that goes hand in hand with the new generator. Historically, our C API was rather low level as it was focused on providing the foundation for our Swift and Go APIs. With this release we want to provide C/C++ developers with ObjectBox convenience and ease of use.

ObjectBox Generator takes over the burden of writing the binding code and data model declaration. Based on a single input file, it generates the code for you, so you can focus on the actual application logic.

Generator Example

ObjectBox let’s you handle data as FlatBuffers. For example, you can put and get data objects as FlatBuffers encoded bytes. To work with FlatBuffers, you need to define a FlatBuffer schema file (.fbs). And this file is also the input for ObjectBox Generator. This way, everything is defined in a single location.

Let’s say we have a FlatBuffers schema file “task.fbs” with the following content:

table Task {
    id: ulong;
    text: string;
    date_created: ulong;
    date_finished: ulong;
}

1

2

3

4

5

6

table Task {

id: ulong;

text: string;

date_created: ulong;

date_finished: ulong;

}

Now, we can tell ObjectBox Generator to use this file to generate C++ sources:

   ./objectbox-generator -cpp task.fbs

1	./objectbox-generator -cpp task.fbs

This makes ObjectBox Generator to generate the following files:

objectbox-model.h: source code to build the internal data model, that you need to pass when creating a store.
objectbox-model.json: keeps track of internal schema IDs; you don’t need to worry about this except that you should put it in your source control.
task-cpp.obx.h: the C++ value structs (data objects), binding code for FlatBuffers and the new Box class.

C++ API Example

Now, let’s use the previously generated code and the new C++ API around the Store and Box classes. A simple CRUD application boils down to a few lines:

#include "objectbox-cpp.h"
#include "objectbox-model.h"  // provides create_obx_model()
#include "task-cpp.obx.h"     // provides Task struct and bindings

int main(int argc, char* args[]) {
    obx::Store store(create_obx_model()); 
    obx::Box<Task> taskBox(store);

    obx_id id = box.put({.text = "Buy milk"});  // Create
    std::unique_ptr<Task> task = box.get(id);   // Read
    if (task) {    
        task->text += " & some bread";
        box.put(*task);                         // Update
        ...
        box.remove(id);                         // Delete
    }
    ...
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

#include "objectbox-cpp.h"

#include "objectbox-model.h" // provides create_obx_model()

#include "task-cpp.obx.h" // provides Task struct and bindings

int main(int argc, char* args[]) {

obx::Store store(create_obx_model());

obx::Box<Task> taskBox(store);

obx_id id = box.put({.text = "Buy milk"}); // Create

std::unique_ptr<Task> task = box.get(id); // Read

if (task) {

task->text += " & some bread";

box.put(*task); // Update

...

box.remove(id); // Delete

}

...

}

Note that the generated code is header-only and compatible with the existing ObjectBox C-API, allowing both to be used from the same application. The C and C++ APIs both have unique advantages: the C++ API uses RAII so you do not need to worry about cleaning up, while the C API has additional features, e.g. queries.

Open Source, Docs

ObjectBox Generator is open source and available on GitHub. The repository comes with a readme file that also serves as a documentation. Among other things, you will find ObjectBox specific annotations there, which are used in fbs files to express ObjectBox-specific concerns. For example, in the definition of Task above, we used ulong as a FlatBuffers type to store dates. However, FlatBuffers does not know what a date is and we use ObjectBox annotations to express this:

 /// objectbox: date
    date_created: ulong;

1 2	/// objectbox: date date_created: ulong;

For our initial release of ObjectBox Generator and the public C++ API we decided on labeling it as version 0.9. Although we are already very close to a 1.0 and we wanted to gather some feedback before our first major release. As we can still change the API or smooth out any rough edges you may find, we cannot stress enough how much we welcome and appreciate your feedback at this point. Thank you!

ObjectBox Java 2.4

by Markus | Oct 15, 2019 | Release

Update: newer versions were released; check the changelog for details.

The 2.4.0 update of ObjectBox for Java (and Kotlin) is here. We encourage everyone to update to this release, as it includes quite a few quality of life improvements and resolves many of the issues that you have reported, so thank you for that!

This is also the first release where the ObjectBox LiveData and Paging integration has migrated from Android Support Libraries, to Jetpack (AndroidX) Libraries. If you are using those features, check the upgrade notes for possible changes that you need to make to your app.

Also note that this version makes some changes to the generated MyObjectBox and JSON model file. Make sure to commit changes to the model file after building your app. Also, if you are using a library that ships with a pre-generated MyObjectBox file, that library needs to be updated to 2.4.0 as well.

Besides those improvements, we were also fine-tuning performance a bit. While fixing a performance regression for 32 bit CPUs related to ordered queries, we were able to do additional optimizations. Now ordered queries using a limit run up to three times faster than before.

For a list of all the changes, please check the changelog.

Last not least, let us share some related ObjectBox’ developments in the mobile space. Today, we also released version 0.3 for ObjectBox Dart. So, if you are interested in creating Flutter apps, you will be able to use ObjectBox soon. Last month, we released ObjectBox Swift 1.0. Therefore, you can build native apps with ObjectBox for the two prominent mobile platforms, Android and iOS. Additionally, we’re also making great progress with data synchronization; sign up for sync updates to be notified sync related news and to be part of the upcoming early releases.

Start Developing Today