ObjectBox: vad är det, NoSQL-databas och arbete med data

Vad är ObjectBox?

ObjectBox är en in-memory NoSQL-databas utvecklad av det tyska företaget ObjectBox.io. Till skillnad från traditionella relationsdatabaser lagrar ObjectBox objekt direkt i platta filer med hjälp av sitt eget SLOT (Super Lightweight Object Tree)-format. Detta eliminerar overhead från ORM och SQL-parser. SLOT-formatet är optimerat för enheter med begränsat minne: data defragmenteras automatiskt och databasstorleken är i genomsnitt 4–6 gånger mindre än en motsvarande SQLite-databas med samma antal poster.

ObjectBox stöder alla större mobila plattformar: Android, iOS och Flutter. För Android finns kodgenerering tillgänglig via ObjectBox Gradle Plugin som bearbetar annoterade entiteter och skapar Box-klasser för att arbeta med data. För Flutter används ett native-plugin med Dart-wrapper. Förutom mobila plattformar fungerar ObjectBox på Linux, macOS, Windows och WebAssembly, vilket gör det möjligt att återanvända datamodellen mellan mobilappen och serversynkronisering.

Enligt forskningsdata från ObjectBox (2023) används databasen i över 5000 applikationer i Google Play, inklusive appar med en publik på över 10 miljoner användare. Huvudscenarier: datacachning, arbete i offlineläge och lagring av tidsserier (IoT). ObjectBox är särskilt populärt i hälso- och fitnessappar, där snabb registrering av sensordata på enheten utan permanent internetanslutning och insamling av analysdata från flera enheter krävs.

Historia och positionering

ObjectBox uppstod som ett alternativ till Realm och SQLite för Android-plattformen. Den första stabila versionen släpptes 2018. Huvudskillnaden från Realm: ObjectBox har inga GPL-begränsningar (använder Apache 2.0) och stöder fler plattformar: från mobila enheter till Linux-servrar.

Huvudfunktioner

ObjectBox erbjuder: automatisk generering av Box-klasser, inbyggda index för snabb sökning, transaktioner med återställningsstöd, reaktiva frågor via RxJava och Kotlin Flow, samt synkronisering mellan enheter via ObjectBox Sync (proprietärt protokoll). Till skillnad från Firebase Realtime Database fungerar ObjectBox Sync i en peer-to-peer-modell utan central server, vilket minskar latens och infrastrukturkostnader.

Hur fungerar ObjectBox?

ObjectBox lagrar data i sitt eget binära .mdb (ObjectBox Data File)-format. Varje entitet mappas till en fil, där poster lagras sekventiellt med en fast offset. Detta gör det möjligt att läsa och skriva enskilda objekt utan att skanna hela filen.

För att arbeta med ObjectBox behövs ingen SQL: frågor byggs via fluent-API i koden. Kompilatorn genererar hjälpklasser MyObjectBox och lådor (Box) som kapslar in alla CRUD-operationer. Datamodellen beskrivs via annoteringar @Entity, @Id, @Index och @Relation.

// Ansluta ObjectBox i Android
class App: Application() {
    lateinit var boxStore: BoxStore

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

ObjectBox vs SQLite: prestandajämförelse

Enligt officiella prestandamätningar överträffar ObjectBox SQLite avsevärt i operationshastighet, särskilt vid batchinsättning och massläsning. SQLite förblir dock de facto-standarden för mobilapplikationer tack vare sin spridning och inbyggda SQL-stöd.

När ObjectBox inte är optimalt

ObjectBox förlorar mot SQLite i scenarier där komplexa JOIN-frågor, aggregeringsfunktioner (SUM, COUNT med gruppering) eller integration med ett befintligt SQL-schema behövs. Om projektet redan använder SQLite med Room ORM kommer migration till ObjectBox att kräva omskrivning av all dataåtkomstlogik. ObjectBox stöder inte heller anpassade SQL-frågor — endast fluent-API. För typiska CRUD-operationer och cachning ger ObjectBox dock en prestandaökning på upp till 100 gånger, vilket bekräftas av officiella prestandamätningar på Android-enheter med olika OS-versioner.

Kodexempel med ObjectBox

ObjectBox använder annoteringar för att definiera entiteter. Efter kompilering skapas Box-klasser med metoderna put, get, remove och query. Nedan visas typiska operationer för Task-modellen i en att-göra-lista-app.

Definiera entitet

Varje entitet annoteras med @Entity. Fältet med @Id blir primärnyckel, @Index snabbar upp sökning på fältet. ObjectBox stöder automatisk ID-generering vid värdet 0.

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

CRUD-operationer

Box är huvudklassen för att arbeta med entiteter. Metoden put() sparar eller uppdaterar objektet, get() läser efter ID, remove() tar bort. Alla grundläggande operationer är synkrona och utförs på den anropande tråden.

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

// Skapa
val task = Task(title = "Köp produkter", priority = 3)
val newId = taskBox.put(task)

// Läsa
val savedTask = taskBox.get(newId)

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

// Ta bort
taskBox.remove(newId)

Reaktiva frågor

ObjectBox stöder reaktiva frågor via .subscribe(). Prenumeranten får meddelanden vid varje ändring av data som matchar frågevillkoret. Detta är praktiskt för UI som automatiskt uppdaterar listan när element läggs till eller tas bort.

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

query.subscribe { tasks ->
    // tasks — List, uppdateras automatiskt
    updateUi(tasks)
}

Relationer och frågor i ObjectBox

ObjectBox stöder relationer mellan entiteter — To-One, To-Many och Many-to-Many. Relationer definieras via annoteringen @Relation. Till skillnad från SQLite använder ObjectBox inte främmande nycklar: relationer implementeras via ID-listor i platta filer, vilket snabbar upp navigering i objektdiagrammet.

One-to-Many via @Backlink

Relationen @Backlink gör det möjligt att gå från en underordnad entitet till den överordnade utan ett separat referensfält. ObjectBox upprätthåller automatiskt bakåtreferensen, vilket eliminerar dataduplicering och synkronisering mellan två tabeller.

Fluent-frågor

ObjectBox Query Builder gör det möjligt att bygga kedjor av villkor: equal, notEqual, greater, less, in, contains, startsWith. Alla villkor kombineras via and/or. Resultatet kan sorteras, begränsas och erhållas som List eller LazyList (för stora datamängder).

Konfigurering av index för snabbare sökning

ObjectBox indexerar automatiskt fältet @Id. För anpassade index, använd annoteringen @Index på fält som ofta efterfrågas. Index snabbar upp equal- och in-frågor men saktar ner insättning — indexera inte fält som inte söks på. ObjectBox stöder sammansatta index för samtidig filtrering på flera fält. Sammansatta index är särskilt användbara för filter i listor: till exempel utförs sökning efter ofullständiga uppgifter med hög prioritet tiotals gånger snabbare med ett sammansatt index på fälten isCompleted och priority.

ObjectBox Sync — synkronisering mellan enheter

ObjectBox Sync är en proprietär teknik för datasynkronisering i realtid mellan enheter. Den använder ett WebSocket-baserat protokoll med konfliktlösning enligt last-writer-wins. Sync passar för appar som behöver offlinesynkronisering: anteckningar, att-göra-listor, IoT-data från flera sensorer. För produktion krävs dock licensköp.

// Fråga med flera villkor
val highPriorityIncomplete = taskBox.query()
    .greater(Task_.priority, 5)
    .equal(Task_.isCompleted, false)
    .build()
    .find()

// Sökning efter delsträng
val searchResults = taskBox.query()
    .contains(Task_.title, "produkt", StringOrder.CASE_INSENSITIVE)
    .build()
    .find()