ObjectBox: wat is het, NoSQL-database en werken met gegevens

Wat is ObjectBox?

ObjectBox is een in-memory NoSQL-database ontwikkeld door het Duitse bedrijf ObjectBox.io. In tegenstelling tot traditionele relationele databases slaat ObjectBox objecten direct op in platte bestanden met behulp van het eigen SLOT (Super Lightweight Object Tree) formaat. Dit elimineert de overhead van ORM en SQL-parser. Het SLOT-formaat is geoptimaliseerd voor apparaten met beperkt geheugen: gegevens worden automatisch gedefragmenteerd en de databasegrootte is gemiddeld 4–6 keer kleiner dan een equivalente SQLite-database met hetzelfde aantal records.

ObjectBox ondersteunt alle belangrijke mobiele platforms: Android, iOS en Flutter. Voor Android is codegeneratie beschikbaar via ObjectBox Gradle Plugin, die geannoteerde entiteiten verwerkt en Box-klassen maakt voor het werken met gegevens. Voor Flutter wordt een native plugin met Dart-wrapper gebruikt. Naast mobiele platforms werkt ObjectBox op Linux, macOS, Windows en WebAssembly, waardoor het gegevensmodel kan worden hergebruikt tussen de mobiele app en serversynchronisatie.

Volgens onderzoeksgegevens van ObjectBox (2023) wordt de database gebruikt in meer dan 5000 apps in Google Play, waaronder apps met een publiek van meer dan 10 miljoen gebruikers. Belangrijkste scenario’s: gegevenscaching, offline werken en het opslaan van tijdreeksen (IoT). ObjectBox is vooral populair in gezondheids- en fitnessapps, waar snelle registratie van sensorwaarden op het apparaat zonder constante internetverbinding en het verzamelen van analyses van meerdere apparaten vereist is.

Geschiedenis en positionering

ObjectBox ontstond als alternatief voor Realm en SQLite voor het Android-platform. De eerste stabiele versie werd uitgebracht in 2018. Het belangrijkste verschil met Realm: ObjectBox heeft geen GPL-beperkingen (gebruikt Apache 2.0) en ondersteunt meer platforms: van mobiele apparaten tot Linux-servers.

Belangrijkste functionaliteiten

ObjectBox biedt: automatische generatie van Box-klassen, ingebouwde indexen voor snel zoeken, transacties met terugrolondersteuning, reactieve query’s via RxJava en Kotlin Flow, en synchronisatie tussen apparaten via ObjectBox Sync (eigen protocol). In tegenstelling tot Firebase Realtime Database werkt ObjectBox Sync volgens een peer-to-peer model zonder centrale server, wat latentie en infrastructuurkosten vermindert.

Hoe werkt ObjectBox?

ObjectBox slaat gegevens op in zijn eigen binaire .mdb (ObjectBox Data File) formaat. Elke entiteit wordt toegewezen aan een bestand, waar records sequentieel worden opgeslagen met een vaste offset. Dit maakt het mogelijk individuele objecten te lezen en schrijven zonder het hele bestand te scannen.

Voor het werken met ObjectBox is geen SQL nodig: query’s worden opgebouwd via een fluent-API in de code. De compiler genereert de hulpklassen MyObjectBox en Boxen die alle CRUD-bewerkingen inkapselen. Het gegevensmodel wordt beschreven via annotaties @Entity, @Id, @Index en @Relation.

// ObjectBox verbinden in Android
class App: Application() {
    lateinit var boxStore: BoxStore

    override fun onCreate() {
        super.onCreate()
        boxStore = MyObjectBox.builder()
            .androidContext(this)
            .build()
    }
}

ObjectBox vs SQLite: prestatievergelijking

Volgens officiële benchmarks presteert ObjectBox aanzienlijk beter dan SQLite qua bewerkingssnelheid, vooral bij batch-invoeging en massa-uitlezing. SQLite blijft echter de de facto standaard voor mobiele applicaties vanwege de wijdverbreidheid en ingebouwde SQL-ondersteuning.

Wanneer ObjectBox niet optimaal is

ObjectBox verliest van SQLite in scenario’s waar complexe JOIN-query’s, aggregatiefuncties (SUM, COUNT met groepering) of integratie met een bestaand SQL-schema nodig zijn. Als het project al SQLite met Room ORM gebruikt, vereist migratie naar ObjectBox het herschrijven van de volledige gegevenstoegangslogica. ObjectBox ondersteunt ook geen aangepaste SQL-query’s, alleen fluent-API. Voor typische CRUD-bewerkingen en caching biedt ObjectBox echter een prestatieverbetering tot 100 keer, wat wordt bevestigd door officiële benchmarks op Android-apparaten met verschillende OS-versies.

Codevoorbeelden met ObjectBox

ObjectBox gebruikt annotaties om entiteiten te definiëren. Na compilatie worden Box-klassen gemaakt met methoden put, get, remove en query. Hieronder staan typische bewerkingen voor het Task-model in een takenlijst-app.

Entiteit definiëren

Elke entiteit wordt geannoteerd met @Entity. Het veld met @Id wordt de primaire sleutel, @Index versnelt het zoeken op het veld. ObjectBox ondersteunt automatische ID-generatie bij waarde 0.

@Entity
data class Task(
    @Id var id: Long = 0,
    @Index var title: String = "",
    var isCompleted: Boolean = false,
    var priority: Int = 0
)

CRUD-bewerkingen

Box is de hoofdklasse voor het werken met entiteiten. De methode put() slaat het object op of werkt het bij, get() leest op ID, remove() verwijdert het. Alle basisbewerkingen zijn synchroon en worden uitgevoerd op de aanroepende thread.

val taskBox: Box<Task> = boxStore.boxFor(Task::class.java)

// Aanmaken
val task = Task(title = "Producten kopen", priority = 3)
val newId = taskBox.put(task)

// Lezen
val savedTask = taskBox.get(newId)

// Bijwerken
savedTask.isCompleted = true
taskBox.put(savedTask)

// Verwijderen
taskBox.remove(newId)

Reactieve query’s

ObjectBox ondersteunt reactieve query’s via .subscribe(). De abonnee ontvangt meldingen bij elke wijziging van gegevens die aan de queryvoorwaarde voldoen. Dit is handig voor de UI die de lijst automatisch bijwerkt bij het toevoegen of verwijderen van elementen.

val query = taskBox.query()
    .equal(Task_.isCompleted, false)
    .orderDesc(Task_.priority)
    .build()

query.subscribe { tasks ->
    // tasks — List, wordt automatisch bijgewerkt
    updateUi(tasks)
}

Relaties en query’s in ObjectBox

ObjectBox ondersteunt relaties tussen entiteiten: To-One, To-Many en Many-to-Many. Relaties worden gedefinieerd via de annotatie @Relation. In tegenstelling tot SQLite gebruikt ObjectBox geen externe sleutels: relaties worden geïmplementeerd via ID-lijsten in platte bestanden, wat navigatie door de objectgraaf versnelt.

One-to-Many via @Backlink

De relatie @Backlink maakt het mogelijk om van een onderliggende entiteit naar de ouder te gaan zonder een apart referentieveld. ObjectBox onderhoudt automatisch de terugverwijzing, waardoor gegevensduplicatie en synchronisatie tussen twee tabellen wordt geëlimineerd.

Fluent-query's

ObjectBox Query Builder maakt het mogelijk om ketens van voorwaarden te bouwen: equal, notEqual, greater, less, in, contains, startsWith. Alle voorwaarden worden gecombineerd via and/or. Het resultaat kan worden gesorteerd, beperkt en verkregen als List of LazyList (voor grote datasets).

Indexconfiguratie voor sneller zoeken

ObjectBox indexeert automatisch het @Id-veld. Gebruik voor aangepaste indexen de annotatie @Index op velden waarop vaak query’s worden uitgevoerd. Indexen versnellen equal- en in-query’s, maar vertragen het invoegen: indexeer geen velden waarop niet wordt gezocht. ObjectBox ondersteunt samengestelde indexen voor gelijktijdig filteren op meerdere velden. Samengestelde indexen zijn bijzonder nuttig voor filters in lijsten: bijvoorbeeld het zoeken naar onvoltooide taken met hoge prioriteit wordt tientallen keren sneller uitgevoerd met een samengestelde index op de velden isCompleted en priority.

ObjectBox Sync: synchronisatie tussen apparaten

ObjectBox Sync is een eigen technologie voor realtime gegevenssynchronisatie tussen apparaten. Het gebruikt een op WebSocket gebaseerd protocol met conflictoplossing volgens last-writer-wins. Sync is geschikt voor apps die offline synchronisatie nodig hebben: notities, takenlijsten, IoT-gegevens van meerdere sensoren. Voor productie is echter aanschaf van een licentie vereist.

// Query met meerdere voorwaarden
val highPriorityIncomplete = taskBox.query()
    .greater(Task_.priority, 5)
    .equal(Task_.isCompleted, false)
    .build()
    .find()

// Zoeken op substring
val searchResults = taskBox.query()
    .contains(Task_.title, "product", StringOrder.CASE_INSENSITIVE)
    .build()
    .find()