मोबाइल ऐप्लिकेशन में Realm: यह क्या है और कैसे काम करता है

Realm क्या है?

Realm एक ऑब्जेक्ट-ओरिएंटेड डेटाबेस है जो विशेष रूप से मोबाइल एप्लिकेशन के लिए बनाया गया है। SQLite के विपरीत, Realm SQL या रिलेशनल मॉडल का उपयोग नहीं करता — डेटा लाइव ऑब्जेक्ट (Live Objects) के रूप में संग्रहीत होता है, जिसे बिना किसी मध्यवर्ती ORM परत के सीधे एक्सेस किया जाता है। डेवलपर भाषा की सामान्य वस्तुओं (Swift, Kotlin, Dart) के साथ काम करता है जो स्वचालित रूप से डेटाबेस में सहेजी जाती हैं।

Realm 2014 में एक स्टार्टअप Realm Inc. के रूप में उभरा, और 2019 में MongoDB Inc. द्वारा अधिग्रहित किया गया। तब से, Realm को MongoDB Realm के रूप में विकसित किया जा रहा है — मोबाइल डेटा सिंक्रोनाइज़ेशन के लिए एकीकृत Atlas Device Sync प्लेटफ़ॉर्म का हिस्सा। मूल स्थानीय Realm डेटाबेस मुफ्त और ओपन सोर्स (Apache 2.0 लाइसेंस) बना हुआ है, जबकि Realm Sync (क्लाउड सिंक्रोनाइज़ेशन) सब्सक्रिप्शन द्वारा वितरित किया जाता है।

MongoDB Developer Report (2025) के अनुसार, Realm का उपयोग 15% मोबाइल एप्लिकेशन में प्राथमिक स्थानीय भंडारण के रूप में किया जाता है। मुख्य उपयोग के मामले ऑफलाइन मोड वाले एप्लिकेशन, जटिल ऑब्जेक्ट मॉडल और उपकरणों के बीच सिंक्रोनाइज़ेशन की आवश्यकता हैं, जहाँ Realm विकास की गति और ऑब्जेक्ट के साथ काम करने में आसानी में SQLite से बेहतर प्रदर्शन करता है।

Realm के सिद्धांत

Live Objects — प्रत्येक Realm ऑब्जेक्ट मेमोरी-मैप्ड फ़ाइल के माध्यम से डिस्क से जुड़ा होता है। किसी भी थ्रेड में ऑब्जेक्ट बदलना तुरंत सभी अन्य थ्रेड्स में मैन्युअल सूचना के बिना परिलक्षित होता है। Realm नोटिफिकेशन के माध्यम से डेटा बदलने पर UI स्वचालित रूप से पुनः चित्रित होता है। Zero-copy — Realm डेटाबेस से डेटा को ऑब्जेक्ट में कॉपी नहीं करता; ऑब्जेक्ट ही मेमोरी में डेटा हैं।

Realm कैसे काम करता है: आर्किटेक्चर और स्टोरेज

Realm कोर C++ में लिखा गया है और डेटा इंडेक्सिंग के लिए B+ Tree का उपयोग करता है। SQLite के विपरीत, जहाँ प्रत्येक पंक्ति एक रिलेशनल तालिका में रिकॉर्ड है, Realm ऑब्जेक्ट को उनके बीच सीधे संदर्भों (forward pointers) के साथ ग्राफ़ संरचना में नोड्स के रूप में संग्रहीत करता है। ऑब्जेक्ट के बीच संबंध विदेशी कुंजी नहीं बल्कि सीधे पॉइंटर्स हैं, जो JOIN संचालन की आवश्यकता को समाप्त करता है।

Realm फ़ाइलें (.realm एक्सटेंशन) मेमोरी-मैप्ड होती हैं — OS स्वयं एक्सेस किए जाने पर फ़ाइल पृष्ठों को मेमोरी में लोड करने का प्रबंधन करता है। यह Realm को उपलब्ध RAM से बड़े डेटाबेस के साथ काम करने की अनुमति देता है और RAM में फिट होने वाले डेटा के लिए मूल भाषा डेटा संरचनाओं (Swift Array या Kotlin List) के स्तर पर रीड लेटेंसी प्रदान करता है।

Zero-copy और Live Objects

मेमोरी-मैप्ड फ़ाइलें — Realm की मुख्य तकनीक। डेटाबेस फ़ाइल से भाषा ऑब्जेक्ट में डेटा कॉपी करने के बजाय (जैसा SQLite sqlite3_step + sqlite3_column_* के माध्यम से करता है), Realm डेटाबेस फ़ाइल को सीधे प्रक्रिया के एड्रेस स्पेस में मैप करता है। भाषा ऑब्जेक्ट मैप की गई मेमोरी में डेटा के लिए केवल पॉइंटर्स हैं। ऑब्जेक्ट बदलना अलग save कॉल के बिना डिस्क पर डेटाबेस को संशोधित करता है।

मेमोरी खपत सक्रिय पढ़ने के दौरान Realm में अधिक होती है (पूरी फ़ाइल या उसका बड़ा भाग मेमोरी में मैप होता है), लेकिन लिखने के संचालन के दौरान कम होती है क्योंकि ऑब्जेक्ट प्रतियों के लिए मेमोरी आवंटन की आवश्यकता नहीं होती। मोबाइल उपकरणों पर 1 GB तक के डेटाबेस के लिए, मेमोरी-मैप्ड दृष्टिकोण अपनी मध्यवर्ती कॉपी के साथ SQLite की तुलना में बेहतर समग्र प्रदर्शन देता है।

Realm vs SQLite vs Core Data: तुलना

SQLite SQL और ACID लेन-देन के साथ एक रिलेशनल DBMS है। Realm मेमोरी-मैप्ड एक्सेस वाला ऑब्जेक्ट NoSQL डेटाबेस है। Core Data SQLite के ऊपर Apple की ORM परत है। तीनों दृष्टिकोणों में से प्रत्येक का अपना अनुप्रयोग क्षेत्र और ताकत है। Realm प्रत्यक्ष ऑब्जेक्ट एक्सेस गति और प्रतिक्रियाशीलता में जीतता है, SQLite बहुमुखी प्रतिभा और परिपक्वता में, Core Data Apple पारिस्थितिकी तंत्र के साथ एकीकरण में।

Realm का रीड प्रदर्शन zero-copy एक्सेस के कारण SQLite से 10-50% अधिक है। Realm लेखन में भी तेज़ है क्योंकि SQL पार्सिंग की अनुपस्थिति और मेमोरी-मैप्ड पृष्ठों का प्रत्यक्ष संशोधन होता है। हालाँकि, बड़े डेटाबेस (>500 MB) के साथ काम करते समय Realm अधिक RAM की खपत कर सकता है, क्योंकि फ़ाइल पूरी तरह से एड्रेस स्पेस में मैप हो जाती है।

Realm और SQLite के बीच चुनाव अक्सर प्राथमिकताओं पर निर्भर करता है: विकास गति और प्रतिक्रियाशीलता (Realm) बनाम नियंत्रण और बहुमुखी प्रतिभा (SQLite)। Realm विशेष रूप से MVP और प्रोटोटाइप के लिए अच्छा है जहाँ डेटा मॉडल बार-बार बदलता है और त्वरित लाइव UI अपडेट प्राप्त करना महत्वपूर्ण है। SQLite/Room बड़े डेटा वॉल्यूम और जटिल विश्लेषणात्मक क्वेरी वाले परिपक्व उत्पादों के लिए बेहतर है।

Android पर Realm: Kotlin SDK

Realm Kotlin SDK Android के लिए आधिकारिक लाइब्रेरी है, जो Kotlin में लिखी गई है (Java SDK के ऊपर रैपर नहीं)। डेटा मॉडल RealmObject से विरासत प्राप्त क्लास के माध्यम से परिभाषित किया जाता है, जिसमें अद्वितीय पहचानकर्ता के लिए @PrimaryKey एनोटेशन होता है। Realm Kotlin Kotlin Coroutines, Flow और KSP (Kotlin Symbol Processing) को कंपाइल-टाइम कोड जनरेशन के लिए समर्थन करता है।

RealmQuery SQL के बिना फ़िल्टरिंग के लिए type-safe API प्रदान करता है। क्वेरीज़ विधि श्रृंखला के माध्यम से बनाई जाती हैं: query → filter → sort → find। परिणाम सूची के रूप में (मेमोरी में लोड) या Flow के रूप में (रिएक्टिव स्ट्रीम जो डेटा बदलने पर अपडेट होती है) वापस किया जा सकता है। Realm Kotlin नेस्टेड ऑब्जेक्ट और सूचियों (RealmList) का भी समर्थन करता है।

Realm Kotlin SDK उदाहरण

डेटा मॉडल Realm को RealmObject इंटरफ़ेस को लागू करने वाले डेटा क्लास के रूप में परिभाषित किया जाता है। _id फ़ील्ड अद्वितीय पहचान के लिए @PrimaryKey से चिह्नित है। एक-से-अनेक संबंध RealmList के माध्यम से कार्यान्वित किया जाता है — अन्य RealmObject की सूची। सभी लेखन संचालन (बनाना, अपडेट करना, हटाना) 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()

Flow-वापसी करने वाली क्वेरी Realm में किसी भी डेटा परिवर्तन पर स्वचालित रूप से नए परिणाम उत्सर्जित करती है: Project या Task जोड़ना, अपडेट करना या हटाना। Flow दृष्टिकोण Compose के साथ पूरी तरह से मेल खाता है: ViewModel में collectAsState() मैन्युअल रूप से सूची एडेप्टर अपडेट किए बिना या LiveData का उपयोग किए बिना डेटा बदलने पर स्वचालित रूप से UI को पुनर्संयोजित करता है।

iOS पर Realm: Swift SDK

Realm Swift SDK async/await, Combine Publishers और Swift Concurrency के समर्थन के साथ एक मूल Swift API प्रदान करता है। डेटा मॉडल Object से विरासत प्राप्त क्लास के रूप में परिभाषित किए जाते हैं, गुणों के लिए @Persisted का उपयोग करते हुए। Realm Swift परिवर्तनों पर स्वचालित रूप से ऑब्जेक्ट अपडेट करता है, और नोटिफिकेशन (NotificationToken) व्यक्तिगत ऑब्जेक्ट या संग्रह के परिवर्तनों की सदस्यता लेने की अनुमति देते हैं।

@ObservedRealmObject और @ObservedResults SwiftUI के लिए Property Wrappers हैं जो Realm डेटा बदलने पर स्वचालित रूप से View को पुनः चित्रित करते हैं। @ObservedResults क्वेरी परिणामों के साथ काम करता है, @ObservedRealmObject एक विशिष्ट ऑब्जेक्ट के साथ। दोनों गुण View के डीइनिशियलाइज़ होने पर सब्सक्रिप्शन रद्द कर देते हैं।

Realm Swift SDK उदाहरण

SwiftUI एकीकरण Realm SDK की मजबूत विशेषताओं में से एक है। @ObservedResults Property Wrapper Realm क्वेरी को SwiftUI डिस्प्ले के साथ जोड़ता है। जब कोई कार्य बदलता है, SwiftUI स्वचालित रूप से सूची को पुनर्संयोजित करता है। realm.writeAsync 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("Add Task") {
            let realm = try! Realm()
            try! realm.write {
                realm.add(TaskItem(value: ["title": "New task"]))
            }
        }
    }
}

@ObservedResults स्वचालित रूप से Realm क्वेरी जीवनचक्र का प्रबंधन करता है: View बनने पर परिवर्तनों की सदस्यता बनाई जाती है; नष्ट होने पर रद्द कर दी जाती है। Property Wrapper एक वैकल्पिक विधेय (NSPredicate) और सॉर्ट विवरण स्वीकार करता है। यह मैन्युअल रूप से fetch अनुरोध लिखने, ViewModels बनाने और Realm नोटिफिकेशन की सदस्यता लेने की आवश्यकता को समाप्त करता है।

Realm के उपयोग के मामले

ऑफलाइन एप्लिकेशन — Realm उन परिदृश्यों के लिए आदर्श है जहाँ डेटा इंटरनेट के बिना उपलब्ध होना चाहिए। अंतर्निर्मित सिंक्रोनाइज़ेशन (MongoDB Atlas के साथ Realm Sync) नेटवर्क से कनेक्ट होने पर स्वचालित रूप से विरोधों को हल करता है। ऐप स्थानीय डेटा के साथ काम करना जारी रखता है, और पृष्ठभूमि सिंक कनेक्शन उपलब्ध होने पर इसे अपडेट करता है।

रिएक्टिव इंटरफ़ेस — Live Objects और Flow/Combine नोटिफिकेशन Realm को बार-बार अपडेट होने वाले डेटा वाले एप्लिकेशन के लिए सुविधाजनक विकल्प बनाते हैं: चैट, कार्य फ़ीड, सहयोगी दस्तावेज़। मैन्युअल रूप से reloadData या invalidate कॉल किए बिना डेटा जोड़ने, बदलने या हटाने पर UI स्वचालित रूप से अपडेट होता है।

क्रॉस-प्लेटफ़ॉर्म प्रोजेक्ट — Realm Kotlin Multiplatform (KMP), Flutter, React Native और Xamarin का समर्थन करता है। डेटा मॉडल एक बार परिभाषित किया जाता है और सभी प्लेटफ़ॉर्म पर उपयोग किया जाता है। यह कोड दोहराव को कम करता है और साझा व्यावसायिक तर्क वाले iOS और Android एप्लिकेशन के बीच स्कीमा संगति की गारंटी देता है।

Realm Sync: MongoDB Atlas के माध्यम से सिंक्रोनाइज़ेशन

Realm Sync MongoDB Atlas में निर्मित एक क्लाउड सेवा है। एप्लिकेशन स्वचालित रूप से उपयोगकर्ता के उपकरणों और सर्वर के बीच डेटा सिंक्रोनाइज़ करता है। विरोधों को "last write wins" रणनीति या सर्वर पर कस्टम Conflict Resolution Functions के माध्यम से हल किया जाता है। Realm Sync ट्रैफ़िक को कम करने के लिए आंशिक सिंक्रोनाइज़ेशन (डेटा का उपसमूह) का समर्थन करता है।

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)
        // स्वचालित सिंक्रोनाइज़ेशन सक्रिय है
    }
}

SyncConfiguration MongoDB Atlas से कनेक्शन कॉन्फ़िगर करता है और सिंक्रोनाइज़ किए जाने वाले मॉडल के सेट को परिभाषित करता है। उपयोगकर्ता प्रमाणीकरण के बाद, Realm स्वचालित रूप से क्लाउड से डेटा लोड करता है और इसे स्थानीय परिवर्तनों के साथ मर्ज करता है। सिंक्रोनाइज़ेशन पृष्ठभूमि थ्रेड पर चलता है और मैन्युअल कॉल की आवश्यकता नहीं होती — बस SyncConfiguration के साथ Realm इंस्टेंस बनाएँ।