Realm în aplicațiile mobile: ce este și cum funcționează

Ce este Realm?

Realm este o bază de date orientată pe obiecte, creată special pentru aplicații mobile. Spre deosebire de SQLite, Realm nu folosește SQL și nici modelul relațional — datele sunt stocate ca obiecte vii (Live Objects), accesate direct, fără un strat ORM intermediar. Dezvoltatorul lucrează cu obiecte obișnuite ale limbajului (Swift, Kotlin, Dart) care se salvează automat în baza de date.

Realm a apărut în 2014 ca startup Realm Inc., iar în 2019 a fost achiziționat de MongoDB Inc. De atunci, Realm se dezvoltă ca MongoDB Realm — parte a platformei unificate Atlas Device Sync pentru sincronizarea datelor mobile. Baza de date locală Realm rămâne gratuită și open-source (licența Apache 2.0), iar Realm Sync (sincronizarea în cloud) este disponibil prin abonament.

Conform MongoDB Developer Report (2025), Realm este utilizat în 15% din aplicațiile mobile ca stocare locală principală. Principalele scenarii sunt aplicații cu mod offline, modele de obiecte complexe și nevoi de sincronizare între dispozitive, unde Realm depășește SQLite ca viteză de dezvoltare și confort de lucru cu obiectele.

Principiile Realm

Live Objects — fiecare obiect Realm este legat de disc prin maparea în memorie (fișier memory-mapped). Modificarea unui obiect în orice fir de execuție se reflectă imediat în toate celelalte fire fără notificare manuală. Interfața UI se redesenează automat la modificarea datelor prin notificările Realm. Zero-copy — Realm nu copiază datele din baza de date în obiecte, obiectele sunt datele în memorie.

Arhitectura și stocarea Realm

Nucleul Realm este scris în C++ și folosește B+ Tree pentru indexarea datelor. Spre deosebire de SQLite, unde fiecare rând este o înregistrare într-un tabel relațional, Realm stochează obiectele ca noduri într-o structură de graf cu referințe directe între ele (forward pointers). Relațiile dintre obiecte nu sunt chei externe, ci pointeri direcți, ceea ce elimină necesitatea operațiilor JOIN.

Fișierele Realm (extensia .realm) sunt memory-mapped — sistemul de operare gestionează singur încărcarea paginilor fișierului în memorie la accesare. Acest lucru permite Realm să lucreze cu baze de date care depășesc memoria RAM disponibilă și asigură o latență de citire la nivelul structurilor de date native ale limbajului (Swift Array sau Kotlin List) pentru datele care încap în RAM.

Zero-copy și Live Objects

Fișierele memory-mapped — tehnologia cheie a Realm. În loc să copieze datele din fișierul bazei de date în obiecte ale limbajului (cum face SQLite prin sqlite3_step + sqlite3_column_*), Realm mapează fișierul bazei direct în spațiul de adrese al procesului. Obiectele limbajului sunt doar pointeri către datele din memoria mapată. Modificarea unui obiect schimbă baza de date pe disc fără un apel separat save.

Consumul de memorie al Realm este mai mare la citirea activă (întregul fișier sau cea mai mare parte este mapată în memorie), dar mai mic la operațiile de scriere, deoarece nu necesită alocare de memorie pentru copii ale obiectelor. Pentru baze de date de până la 1 GB pe dispozitive mobile, abordarea memory-mapped oferă performanță generală mai bună decât SQLite cu copierea intermediară.

Realm vs SQLite vs Core Data: comparație

SQLite — sistem de gestiune a bazelor de date relaționale cu SQL și tranzacții ACID. Realm — bază de date NoSQL obiectuală cu acces memory-mapped. Core Data — strat ORM Apple peste SQLite. Fiecare dintre cele trei abordări are domeniul său de aplicare și puncte forte. Realm câștigă în viteza de acces direct la obiecte și reactivitate, SQLite — în universalitate și maturitate, Core Data — în integrarea cu ecosistemul Apple.

Performanța Realm la operațiile de citire este cu 10-50% mai mare decât SQLite datorită accesului zero-copy. La operațiile de scriere, Realm este de asemenea mai rapid datorită lipsei analizei sintactice SQL și modificării directe a paginilor memory-mapped. Totuși, Realm poate consuma mai multă memorie RAM la lucrul cu baze de date mari (>500 MB), deoarece fișierul este mapat complet în spațiul de adrese.

Alegerea între Realm și SQLite se rezumă adesea la priorități: viteză de dezvoltare și reactivitate (Realm) versus control și universalitate (SQLite). Realm este deosebit de bun pentru MVP-uri și prototipuri, unde modelul de date se schimbă frecvent și este important să obții rapid actualizări live ale UI. SQLite/Room este de preferat pentru produse mature cu volume mari de date și interogări analitice complexe.

Realm pe Android: Kotlin SDK

Realm Kotlin SDK — biblioteca oficială pentru Android, scrisă în Kotlin (nu o învelitoare peste Java SDK). Modelul de date se definește prin clase care moștenesc RealmObject, cu adnotarea @PrimaryKey pentru identificatorul unic. Realm Kotlin suportă Kotlin Coroutines, Flow și KSP (Kotlin Symbol Processing) pentru generarea codului la compilare.

RealmQuery oferă o API type-safe pentru filtrare fără SQL. Interogările se construiesc în lanț de metode: query → filter → sort → find. Rezultatul poate fi returnat ca listă (încărcat în memorie) sau ca Flow (flux reactiv care se actualizează la modificarea datelor). Realm Kotlin suportă de asemenea obiecte imbricate și liste (RealmList).

Exemplu Realm Kotlin SDK

Modelul de date Realm se definește ca o clasă de date care implementează interfața RealmObject. Câmpul _id este marcat cu @PrimaryKey pentru identificare unică. Relația unu-la-multe se realizează prin RealmList — o listă de alte obiecte RealmObject. Toate operațiile de scriere (create, update, delete) se execută în interiorul unui bloc de tranzacție write.

class Project : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId().generate()
    var name: String = ""
    var tasks: RealmList<Task> = realmListOf()
}

class Task : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId().generate()
    var title: String = ""
    var isComplete: Boolean = false
}

val config = Realm.Configuration.Builder(
    schema = setOf(Project::class, Task::class)
).build()

val realm = Realm.open(config)
realm.write { transactionRealm ->
    val project = copyToRealm(Project().apply {
        name = "Mobile App"
    })
    project.tasks.add(copyToRealm(Task().apply {
        title = "Design UI"
    }))
}

val projects: Flow<RealmResults<Project>> =
    realm.query<Project>()
        .sort(Project::name, Sort.ASCENDING)
        .asFlow()

Interogarea care returnează Flow emite automat rezultate noi la orice modificare a datelor în Realm: adăugarea, actualizarea sau ștergerea unui Project sau Task. Abordarea Flow se potrivește perfect cu Compose: collectAsState() în ViewModel recompune automat UI la modificarea datelor fără actualizarea manuală a adaptoarelor de liste sau utilizarea LiveData.

Realm pe iOS: Swift SDK

Realm Swift SDK oferă o API Swift nativă cu suport pentru async/await, Combine Publishers și Swift Concurrency. Modelele de date se definesc ca clase care moștenesc Object, cu @Persisted pentru proprietăți. Realm Swift actualizează automat obiectele la modificări, iar notificările (NotificationToken) permit abonarea la modificări ale obiectelor individuale sau colecțiilor.

@ObservedRealmObject și @ObservedResults — Property Wrappers pentru SwiftUI care redesenează automat View-ul la modificarea datelor Realm. @ObservedResults lucrează cu rezultatele interogării, @ObservedRealmObject — cu un obiect concret. Ambele proprietăți anulează abonamentul la dezinițializarea View-ului.

Exemplu Realm Swift SDK

Integrarea Realm cu SwiftUI — unul dintre punctele forte ale SDK-ului. Property Wrapper @ObservedResults leagă interogarea Realm de afișarea în SwiftUI. La modificarea oricărei sarcini, SwiftUI recompune automat lista. realm.writeAsync execută tranzacții pe un fir de fundal fără a bloca UI.

import RealmSwift

class TaskItem: Object, Identifiable {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var title: String = ""
    @Persisted var isDone: Bool = false
    @Persisted var priority: Int = 0
}

struct TaskListView: View {
    @ObservedResults(TaskItem.self,
        sortDescriptor: SortDescriptor(["priority"]))
    var tasks

    var body: some View {
        List {
            ForEach(tasks) { task in
                TaskRow(task: task)
            }
        }
        Button("Adaugă sarcină") {
            let realm = try! Realm()
            try! realm.write {
                realm.add(TaskItem(value: ["title": "New task"]))
            }
        }
    }
}

@ObservedResults gestionează automat ciclul de viață al interogării Realm: la crearea View-ului se creează un abonament la modificări, la distrugere — se anulează. Property Wrapper acceptă un predicat opțional (NSPredicate) și sortare. Aceasta elimină necesitatea de a scrie manual interogări fetch, de a crea ViewModel și de a se abona la notificările Realm.

Scenarii de utilizare Realm

Aplicații offline — Realm este ideal pentru scenarii în care datele trebuie să fie disponibile fără internet. Sincronizarea încorporată (Realm Sync cu MongoDB Atlas) rezolvă automat conflictele la reconectarea la rețea. Aplicația continuă să lucreze cu datele locale, iar sincronizarea în fundal le actualizează atunci când conexiunea apare.

Interfețe reactive — Live Objects și notificările Flow/Combine fac din Realm o alegere convenabilă pentru aplicații cu date actualizate frecvent: chat-uri, fluxuri de sarcini, documente colaborative. UI se actualizează automat la adăugarea, modificarea sau ștergerea datelor fără apel manual reloadData sau invalidate.

Proiecte cross-platform — Realm suportă Kotlin Multiplatform (KMP), Flutter, React Native și Xamarin. Modelul de date se definește o singură dată și se utilizează pe toate platformele. Aceasta reduce duplicarea codului și garantează consistența schemei de date între aplicațiile iOS și Android cu logică de afaceri comună.

Realm Sync: sincronizare prin MongoDB Atlas

Realm Sync — serviciu cloud integrat în MongoDB Atlas. Aplicația sincronizează automat datele între dispozitivele utilizatorului și server. Conflictele se rezolvă conform strategiei ultima scriere câștigă (last write wins) sau prin funcții personalizate de rezolvare a conflictelor pe server. Realm Sync suportă sincronizarea parțială (subset of data) pentru a reduce traficul.

class SyncRepository {
    private val app = App(
        AppConfiguration(
            appId = "my-realm-app-id"
        )
    )

    suspend fun syncData() {
        val user = app.login(Credentials.anonymous())
        val config = SyncConfiguration.Builder(
            user, setOf(Project::class)
        ).build()

        val syncedRealm = Realm.open(config)
        // Sincronizarea automată este activă
    }
}

SyncConfiguration configurează conexiunea la MongoDB Atlas și definește setul de modele sincronizate. După autentificarea utilizatorului, Realm încarcă automat datele din cloud și le combină cu modificările locale. Sincronizarea funcționează pe un fir de fundal și nu necesită apel manual — este suficient să creați o instanță Realm cu SyncConfiguration.