Realm sa mga mobile app: ano ito at paano ito gumagana

Ano ang Realm?

Realm ay isang object-oriented database na espesyal na ginawa para sa mga mobile application. Hindi tulad ng SQLite, hindi gumagamit ang Realm ng SQL at relational na modelo — ang data ay naka-imbak bilang mga live na object (Live Objects) na direktang maa-access nang walang intermediary ORM layer. Ang developer ay gumagana sa mga ordinaryong object ng wika (Swift, Kotlin, Dart) na awtomatikong nai-save sa database.

Ang Realm ay lumitaw noong 2014 bilang isang startup na Realm Inc., at noong 2019 ay nakuha ng MongoDB Inc. Mula noon, ang Realm ay binuo bilang MongoDB Realm — bahagi ng pinag-isang Atlas Device Sync platform para sa mobile data synchronization. Ang lokal na Realm database ay nananatiling libre at open-source (lisensyang Apache 2.0), habang ang Realm Sync (cloud synchronization) ay ipinamamahagi sa pamamagitan ng subscription.

Ayon sa MongoDB Developer Report (2025), ang Realm ay ginagamit sa 15% ng mga mobile application bilang pangunahing lokal na imbakan. Ang mga pangunahing sitwasyon ay mga application na may offline mode, kumplikadong object model, at pangangailangan para sa pag-sync sa pagitan ng mga device, kung saan nahihigitan ng Realm ang SQLite sa bilis ng pag-develop at kadalian ng pagtatrabaho sa mga object.

Mga Prinsipyo ng Realm

Live Objects bawat object ng Realm ay konektado sa disk sa pamamagitan ng memory-mapped file. Ang pagbabago ng object sa anumang thread ay agad na naaaninag sa lahat ng iba pang thread nang walang manu-manong abiso. Ang UI ay awtomatikong nagre-redraw kapag nagbago ang data sa pamamagitan ng Realm notification. Zero-copy hindi kinokopya ng Realm ang data mula sa database papunta sa mga object, ang mga object mismo ay ang data sa memorya.

Paano binuo ang Realm: arkitektura at imbakan

Ang core ng Realm ay nakasulat sa C++ at gumagamit ng B+ Tree para sa pag-index ng data. Hindi tulad ng SQLite, kung saan ang bawat row ay isang record sa isang relational table, iniimbak ng Realm ang mga object bilang mga node sa isang graph structure na may direktang mga reference sa pagitan nila (forward pointers). Ang mga ugnayan sa pagitan ng mga object ay hindi foreign keys, kundi mga direktang pointer, na nag-aalis ng pangangailangan para sa JOIN operations.

Ang mga file ng Realm (.realm extension) ay memory-mapped — ang OS mismo ang namamahala sa pag-load ng mga page ng file sa memorya habang ina-access. Ito ay nagpapahintulot sa Realm na gumana sa mga database na lampas sa available na RAM at tinitiyak ang read latency sa antas ng native data structures ng wika (Swift Array o Kotlin List) para sa data na kasya sa RAM.

Zero-copy at Live Objects

Memory-mapped files ay ang pangunahing teknolohiya ng Realm. Sa halip na kopyahin ang data mula sa database file patungo sa mga language object (gaya ng ginagawa ng SQLite sa pamamagitan ng sqlite3_step + sqlite3_column_*), minamapa ng Realm ang database file nang direkta sa address space ng process. Ang mga language object ay mga pointer lamang sa data sa naka-map na memorya. Ang pagbabago ng isang object ay nagbabago sa database sa disk nang walang hiwalay na save call.

Ang pagkonsumo ng memorya ng Realm ay mas mataas sa aktibong pagbasa (ang buong file o malaking bahagi nito ay naka-map sa memorya), ngunit mas mababa sa mga write operation, dahil hindi kailangan ng memory allocation para sa mga kopya ng object. Para sa mga database hanggang 1 GB sa mga mobile device, ang memory-mapped approach ay nagbibigay ng mas mahusay na pangkalahatang performance kaysa sa SQLite na may intermediate copying nito.

Realm vs SQLite vs Core Data: paghahambing

SQLite ay isang relational database management system na may SQL at ACID transactions. Ang Realm ay isang object NoSQL database na may memory-mapped access. Ang Core Data ay isang Apple ORM layer sa ibabaw ng SQLite. Bawat isa sa tatlong approach ay may sariling lugar ng aplikasyon at mga kalakasan. Nananalo ang Realm sa bilis ng direktang access sa object at reaktibiti, ang SQLite sa universality at kapanahunan, ang Core Data sa integrasyon sa Apple ecosystem.

Ang performance ng Realm sa read operations ay 10-50% mas mataas kaysa SQLite dahil sa zero-copy access. Sa write operations, mas mabilis din ang Realm dahil sa kawalan ng SQL syntax parsing at direktang pagbabago ng memory-mapped pages. Gayunpaman, ang Realm ay maaaring kumonsumo ng mas maraming RAM kapag nagtatrabaho sa malalaking database (>500 MB), dahil ang file ay ganap na naka-map sa address space.

Ang pagpili sa pagitan ng Realm at SQLite ay madalas na nakadepende sa mga priyoridad: bilis ng pag-develop at reaktibiti (Realm) laban sa kontrol at universality (SQLite). Ang Realm ay lalong mabuti para sa MVP at prototypes, kung saan ang modelo ng data ay madalas nagbabago at mahalaga ang mabilis na pagkuha ng live na UI updates. Ang SQLite/Room ay mas gusto para sa mga mature na produkto na may malalaking volume ng data at kumplikadong analytical queries.

Realm sa Android: Kotlin SDK

Realm Kotlin SDK ay ang opisyal na library para sa Android, na nakasulat sa Kotlin (hindi wrapper sa ibabaw ng Java SDK). Ang modelo ng data ay tinutukoy sa pamamagitan ng mga klase na nagmana mula sa RealmObject, na may annotation na @PrimaryKey para sa natatanging identifier. Sinusuportahan ng Realm Kotlin ang Kotlin Coroutines, Flow, at KSP (Kotlin Symbol Processing) para sa compile-time code generation.

RealmQuery ay nagbibigay ng type-safe API para sa pag-filter nang walang SQL. Ang mga query ay binuo sa pamamagitan ng method chaining: query → filter → sort → find. Ang resulta ay maaaring ibalik bilang listahan (na may pag-load sa memorya) o bilang Flow (reactive stream na nag-a-update kapag nagbago ang data). Sinusuportahan din ng Realm Kotlin ang mga nested object at listahan (RealmList).

Halimbawa ng Realm Kotlin SDK

Ang modelo ng data ng Realm ay tinutukoy bilang data class na nag-i-implement ng RealmObject interface. Ang field na _id ay minarkahan ng @PrimaryKey para sa natatanging identification. Ang relasyong “isahan-sa-marami” ay ipinapatupad sa pamamagitan ng RealmList — isang listahan ng iba pang RealmObject. Lahat ng write operations (create, update, delete) ay isinasagawa sa loob ng write transaction block.

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

Isang Flow-returning query ay awtomatikong naglalabas ng mga bagong resulta sa bawat pagbabago ng data sa Realm: pagdaragdag, pag-update, o pagtanggal ng Project o Task. Ang Flow approach ay perpektong pinagsama sa Compose: ang collectAsState() sa ViewModel ay awtomatikong nag-recompose ng UI kapag nagbago ang data nang walang manu-manong pag-update ng list adapter o paggamit ng LiveData.

Realm sa iOS: Swift SDK

Realm Swift SDK ay nagbibigay ng native Swift API na may suporta para sa async/await, Combine Publishers, at Swift Concurrency. Ang mga modelo ng data ay tinutukoy bilang mga klase na nagmana mula sa Object, gamit ang @Persisted para sa mga property. Awtomatikong nag-a-update ang Realm Swift ng mga object kapag may mga pagbabago, at ang mga notification (NotificationToken) ay nagpapahintulot ng pag-subscribe sa mga pagbabago ng indibidwal na object o koleksyon.

@ObservedRealmObject at @ObservedResults ay Property Wrappers para sa SwiftUI na awtomatikong nagre-redraw ng View kapag nagbago ang data ng Realm. Ang @ObservedResults ay gumagana sa mga resulta ng query, ang @ObservedRealmObject ay gumagana sa isang partikular na object. Ang parehong property ay nagka-cancel ng subscription kapag na-deinitialize ang View.

Halimbawa ng Realm Swift SDK

SwiftUI integration ng Realm ay isa sa mga kalakasan ng SDK. Ang Property Wrapper na @ObservedResults ay nag-uugnay ng Realm query sa display sa SwiftUI. Kapag nagbago ang anumang gawain, awtomatikong nagre-recompose ang SwiftUI ng listahan. Ang realm.writeAsync ay nagsasagawa ng mga transaction sa background thread nang hindi hinaharangan ang 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("Magdagdag ng Gawain") {
            let realm = try! Realm()
            try! realm.write {
                realm.add(TaskItem(value: ["title": "New task"]))
            }
        }
    }
}

@ObservedResults ay awtomatikong namamahala sa lifecycle ng Realm query: kapag ginawa ang View, isang subscription sa mga pagbabago ay nilikha, kapag nawasak, ito ay kinakansela. Ang Property Wrapper ay tumatanggap ng opsyonal na predicate (NSPredicate) at sorting. Tinatanggal nito ang pangangailangan na manu-manong sumulat ng fetch query, lumikha ng ViewModel, at mag-subscribe sa Realm notification.

Mga sitwasyon ng paggamit ng Realm

Offline na application Ang Realm ay perpekto para sa mga sitwasyon kung saan ang data ay dapat na available nang walang internet. Ang built-in na pag-sync (Realm Sync sa MongoDB Atlas) ay awtomatikong nireso ang mga conflict kapag kumonekta sa network. Ang application ay patuloy na gumagana sa lokal na data, at ang background sync ay nag-a-update nito kapag may koneksyon.

Reactive na interface Ang Live Objects at Flow/Combine notification ay ginagawang magandang pagpipilian ang Realm para sa mga application na may madalas na nagbabagong data: mga chat, task feed, shared documents. Ang UI ay awtomatikong nag-a-update kapag ang data ay idinagdag, binago, o tinanggal nang walang manu-manong tawag sa reloadData o invalidate.

Cross-platform na proyekto Sinusuportahan ng Realm ang Kotlin Multiplatform (KMP), Flutter, React Native, at Xamarin. Ang modelo ng data ay tinutukoy nang isang beses at ginagamit sa lahat ng platform. Binabawasan nito ang pagdoble ng code at ginagarantiyahan ang consistency ng data schema sa pagitan ng iOS at Android application na may shared business logic.

Realm Sync: pag-sync sa pamamagitan ng MongoDB Atlas

Realm Sync ay isang cloud service na naka-embed sa MongoDB Atlas. Awtomatikong sine-sync ng application ang data sa pagitan ng mga device ng user at ng server. Ang mga conflict ay nireso ayon sa “last write wins” na strategy o sa pamamagitan ng custom na Conflict Resolution Functions sa server. Sinusuportahan ng Realm Sync ang partial synchronization (subset of data) para mabawasan ang traffic.

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)
        // Aktibo ang awtomatikong pag-sync
    }
}

SyncConfiguration ay nagko-configure ng koneksyon sa MongoDB Atlas at tinutukoy ang set ng mga model na isi-sync. Pagkatapos ng authentication ng user, awtomatikong naglo-load ang Realm ng data mula sa cloud at pinagsasama ito sa mga lokal na pagbabago. Ang pag-sync ay gumagana sa background thread at hindi nangangailangan ng manu-manong tawag — sapat na ang gumawa ng Realm instance na may SyncConfiguration.