Mobil Uygulamalarda Realm: Nedir ve Nasıl Çalışır

Realm Nedir?

Realm, özellikle mobil uygulamalar için oluşturulmuş nesne yönelimli bir veritabanıdır. SQLite'ın aksine, Realm SQL veya ilişkisel model kullanmaz — veriler, ara bir ORM katmanı olmadan doğrudan erişilen canlı nesneler (Live Objects) olarak depolanır. Geliştirici, otomatik olarak veritabanına kaydedilen normal dil nesneleriyle (Swift, Kotlin, Dart) çalışır.

Realm, 2014 yılında bir girişim olan Realm Inc. olarak ortaya çıktı ve 2019 yılında MongoDB Inc. tarafından satın alındı. O zamandan beri Realm, mobil veri senkronizasyonu için birleşik Atlas Device Sync platformunun bir parçası olan MongoDB Realm olarak geliştirilmektedir. Temel yerel Realm veritabanı ücretsiz ve açık kaynak (Apache 2.0 lisansı) olarak kalırken, Realm Sync (bulut senkronizasyonu) abonelik yoluyla dağıtılmaktadır.

MongoDB Developer Report'a (2025) göre, Realm mobil uygulamaların %15'inde birincil yerel depolama olarak kullanılmaktadır. Ana kullanım alanları, çevrimdışı modlu uygulamalar, karmaşık nesne modelleri ve cihazlar arasında senkronizasyon ihtiyacı olan uygulamalardır; Realm, geliştirme hızı ve nesnelerle çalışma kolaylığında SQLite'ı geride bırakır.

Realm İlkeleri

Live Objects — her Realm nesnesi, bellekle eşlenmiş dosya (memory-mapped file) aracılığıyla diske bağlanır. Herhangi bir iş parçacığında bir nesneyi değiştirmek, manuel bildirim olmadan diğer tüm iş parçacıklarına anında yansır. Realm bildirimleri aracılığıyla veri değiştiğinde kullanıcı arayüzü otomatik olarak yeniden çizilir. Zero-copy — Realm, veritabanından nesnelere veri kopyalamaz; nesneler bellekteki verinin ta kendisidir.

Realm Nasıl Çalışır: Mimari ve Depolama

Realm çekirdeği C++ ile yazılmıştır ve veri indeksleme için B+ Tree kullanır. Her satırın ilişkisel bir tabloda bir kayıt olduğu SQLite'ın aksine, Realm, nesneleri aralarında doğrudan referanslar (forward pointers) bulunan bir grafik yapısında düğümler olarak depolar. Nesneler arasındaki ilişkiler yabancı anahtarlar değil, doğrudan işaretçilerdir ve bu da JOIN işlemlerine olan ihtiyacı ortadan kaldırır.

Realm dosyaları (.realm uzantısı) bellekle eşlenmiştir (memory-mapped) — işletim sistemi, erişildikçe dosya sayfalarını belleğe yüklemeyi kendisi yönetir. Bu, Realm'in mevcut RAM'den daha büyük veritabanlarıyla çalışmasına olanak tanır ve RAM'e sığan veriler için yerel dil veri yapıları (Swift Array veya Kotlin List) düzeyinde okuma gecikmesi sağlar.

Zero-copy ve Live Objects

Bellekle eşlenmiş dosyalar — Realm'in temel teknolojisidir. Veritabanı dosyasından dil nesnelerine veri kopyalamak yerine (SQLite'ın sqlite3_step + sqlite3_column_* ile yaptığı gibi), Realm veritabanı dosyasını doğrudan işlemin adres alanına eşler. Dil nesneleri, eşlenmiş bellekteki verilere yönelik basit işaretçilerdir. Bir nesneyi değiştirmek, ayrı bir save çağrısı olmadan diskteki veritabanını değiştirir.

Bellek tüketimi aktif okuma sırasında Realm'de daha yüksektir (tüm dosya veya büyük bir kısmı belleğe eşlenmiştir), ancak yazma işlemleri sırasında daha düşüktür çünkü nesne kopyaları için bellek ayırma gerekmez. Mobil cihazlarda 1 GB'a kadar olan veritabanları için, bellek eşlemeli yaklaşım, ara kopyalama yapan SQLite'dan daha iyi genel performans sağlar.

Realm vs SQLite vs Core Data: Karşılaştırma

SQLite, SQL ve ACID işlemleriyle ilişkisel bir DBMS'dir. Realm, bellek eşlemeli erişime sahip nesne NoSQL veritabanıdır. Core Data, SQLite üzerindeki Apple'ın ORM katmanıdır. Üç yaklaşımın her birinin kendi uygulama alanı ve güçlü yönleri vardır. Realm, doğrudan nesne erişim hızı ve tepkisellikte, SQLite çok yönlülük ve olgunlukta, Core Data ise Apple ekosistemiyle entegrasyonda öne çıkar.

Realm'in okuma performansı, zero-copy erişimi sayesinde SQLite'dan %10-50 daha yüksektir. Realm, SQL ayrıştırmasının olmaması ve bellek eşlemeli sayfaların doğrudan değiştirilmesi sayesinde yazmada da daha hızlıdır. Ancak Realm, büyük veritabanlarıyla (>500 MB) çalışırken daha fazla RAM tüketebilir çünkü dosya tamamen adres alanına eşlenir.

Realm ve SQLite arasındaki seçim genellikle önceliklere bağlıdır: geliştirme hızı ve tepkisellik (Realm) ile kontrol ve çok yönlülük (SQLite) arasında bir seçim. Realm, veri modelinin sık değiştiği ve hızlı canlı kullanıcı arayüzü güncellemelerinin önemli olduğu MVP'ler ve prototipler için özellikle iyidir. SQLite/Room, büyük veri hacimleri ve karmaşık analitik sorguları olan olgun ürünler için tercih edilir.

Android'de Realm: Kotlin SDK

Realm Kotlin SDK, Android için resmi kütüphanedir ve Kotlin ile yazılmıştır (Java SDK üzerinde bir sarmalayıcı değildir). Veri modeli, benzersiz bir tanımlayıcı için @PrimaryKey ek açıklamasıyla RealmObject'tan miras alan sınıflar aracılığıyla tanımlanır. Realm Kotlin, derleme zamanı kod oluşturma için Kotlin Coroutines, Flow ve KSP'yi (Kotlin Symbol Processing) destekler.

RealmQuery, SQL olmadan filtreleme için tür güvenli bir API sağlar. Sorgular bir metot zinciriyle oluşturulur: query → filter → sort → find. Sonuç, bir liste (belleğe yüklenmiş) veya Flow (veri değiştiğinde güncellenen reaktif akış) olarak döndürülebilir. Realm Kotlin ayrıca iç içe nesneleri ve listeleri (RealmList) destekler.

Realm Kotlin SDK Örneği

Veri modeli Realm, RealmObject arayüzünü uygulayan bir veri sınıfı olarak tanımlanır. _id alanı, benzersiz tanımlama için @PrimaryKey ile işaretlenir. Bire-çok ilişkisi, RealmList (diğer RealmObject'lerin listesi) aracılığıyla uygulanır. Tüm yazma işlemleri (oluşturma, güncelleme, silme) bir write işlem bloğu içinde gerçekleştirilir.

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 döndüren bir sorgu, Realm'deki herhangi bir veri değişikliğinde (Project veya Task ekleme, güncelleme veya silme) otomatik olarak yeni sonuçlar yayar. Flow yaklaşımı, Compose ile mükemmel uyum sağlar: ViewModel'deki collectAsState(), liste bağdaştırıcılarını manuel olarak güncellemeden veya LiveData kullanmadan veri değiştiğinde kullanıcı arayüzünü otomatik olarak yeniden oluşturur.

iOS'ta Realm: Swift SDK

Realm Swift SDK, async/await, Combine Publishers ve Swift Concurrency desteğiyle yerel bir Swift API sağlar. Veri modelleri, özellikler için @Persisted kullanarak Object'ten miras alan sınıflar olarak tanımlanır. Realm Swift, değişikliklerde nesneleri otomatik olarak günceller ve bildirimler (NotificationToken), tek tek nesnelerin veya koleksiyonların değişikliklerine abone olmayı sağlar.

@ObservedRealmObject ve @ObservedResults, Realm verileri değiştiğinde Görünümü otomatik olarak yeniden çizen SwiftUI Property Wrapper'larıdır. @ObservedResults sorgu sonuçlarıyla, @ObservedRealmObject ise belirli bir nesneyle çalışır. Her iki özellik de Görünüm devre dışı bırakıldığında aboneliği iptal eder.

Realm Swift SDK Örneği

SwiftUI entegrasyonu Realm, SDK'nın güçlü yönlerinden biridir. @ObservedResults Property Wrapper'ı, bir Realm sorgusunu SwiftUI görüntülemesine bağlar. Herhangi bir görev değiştiğinde, SwiftUI listeyi otomatik olarak yeniden oluşturur. realm.writeAsync, kullanıcı arayüzünü bloke etmeden arka plan iş parçacığında işlemleri gerçekleştirir.

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 sorgu yaşam döngüsünü otomatik olarak yönetir: Görünüm oluşturulduğunda değişikliklere abone olunur; yok edildiğinde iptal edilir. Property Wrapper, isteğe bağlı bir yüklem (NSPredicate) ve sıralama tanımlayıcısı kabul eder. Bu, manuel olarak getirme istekleri yazma, ViewModel oluşturma ve Realm bildirimlerine abone olma ihtiyacını ortadan kaldırır.

Realm Kullanım Alanları

Çevrimdışı uygulamalar — Realm, verilerin internet olmadan kullanılabilir olması gereken senaryolar için idealdir. Yerleşik senkronizasyon (MongoDB Atlas ile Realm Sync), ağa bağlanıldığında çakışmaları otomatik olarak çözer. Uygulama yerel verilerle çalışmaya devam eder ve arka plan senkronizasyonu, bağlantı kullanılabilir olduğunda verileri günceller.

Tepkisel arayüzler — Live Objects ve Flow/Combine bildirimleri, Realm'i sık güncellenen verilere sahip uygulamalar (sohbetler, görev akışları, işbirlikçi belgeler) için uygun bir seçim haline getirir. Manuel olarak reloadData veya invalidate çağırmadan veri eklendiğinde, değiştirildiğinde veya silindiğinde kullanıcı arayüzü otomatik olarak güncellenir.

Çapraz platform projeleri — Realm, Kotlin Multiplatform (KMP), Flutter, React Native ve Xamarin'i destekler. Veri modeli bir kez tanımlanır ve tüm platformlarda kullanılır. Bu, kod tekrarını azaltır ve ortak iş mantığına sahip iOS ve Android uygulamaları arasında şema tutarlılığını garanti eder.

Realm Sync: MongoDB Atlas Aracılığıyla Senkronizasyon

Realm Sync, MongoDB Atlas'a entegre edilmiş bir bulut hizmetidir. Uygulama, kullanıcının cihazları ve sunucu arasında verileri otomatik olarak senkronize eder. Çakışmalar, "last write wins" stratejisi veya sunucuda özel Çakışma Çözümü İşlevleri (Conflict Resolution Functions) aracılığıyla çözülür. Realm Sync, trafiği azaltmak için kısmi senkronizasyonu (veri alt kümesi) destekler.

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)
        // Otomatik senkronizasyon aktif
    }
}

SyncConfiguration, MongoDB Atlas'a bağlantıyı yapılandırır ve senkronize edilecek modeller kümesini tanımlar. Kullanıcı kimlik doğrulamasından sonra Realm, buluttan verileri otomatik olarak yükler ve yerel değişikliklerle birleştirir. Senkronizasyon arka plan iş parçacığında çalışır ve manuel çağrı gerektirmez — sadece SyncConfiguration ile bir Realm örneği oluşturun.