Realm em aplicativos móveis: o que é e como funciona

O que é Realm?

Realm é um banco de dados orientado a objetos criado especificamente para aplicações móveis. Ao contrário do SQLite, o Realm não utiliza SQL nem modelo relacional — os dados são armazenados como objetos vivos (Live Objects), acessados diretamente sem uma camada ORM intermediária. O desenvolvedor trabalha com objetos normais da linguagem (Swift, Kotlin, Dart) que são salvos automaticamente no banco de dados.

O Realm surgiu em 2014 como uma startup Realm Inc., e em 2019 foi adquirido pela MongoDB Inc. Desde então, o Realm tem sido desenvolvido como MongoDB Realm — parte da plataforma unificada Atlas Device Sync para sincronização de dados móveis. O banco de dados local básico do Realm permanece gratuito e de código aberto (licença Apache 2.0), enquanto o Realm Sync (sincronização na nuvem) é distribuído por assinatura.

De acordo com o MongoDB Developer Report (2025), o Realm é usado em 15% das aplicações móveis como armazenamento local principal. Os principais casos de uso são aplicações com modo offline, modelos de objetos complexos e necessidade de sincronização entre dispositivos, onde o Realm supera o SQLite em velocidade de desenvolvimento e facilidade de trabalho com objetos.

Princípios do Realm

Live Objects — cada objeto Realm está ligado ao disco através de um arquivo mapeado em memória (memory-mapped file). Alterar um objeto em qualquer thread é imediatamente refletido em todas as outras threads sem notificação manual. A interface do usuário é redesenhada automaticamente quando os dados mudam através de notificações do Realm. Zero-copy — o Realm não copia dados do banco de dados para objetos; os objetos são os dados na memória.

Como o Realm funciona: arquitetura e armazenamento

O núcleo do Realm é escrito em C++ e usa B+ Tree para indexação de dados. Ao contrário do SQLite, onde cada linha é um registro em uma tabela relacional, o Realm armazena objetos como nós em uma estrutura de grafo com referências diretas entre eles (forward pointers). Relacionamentos entre objetos não são chaves estrangeiras, mas ponteiros diretos, eliminando a necessidade de operações JOIN.

Os arquivos do Realm (extensão .realm) são mapeados em memória (memory-mapped) — o próprio SO gerencia o carregamento das páginas do arquivo na memória conforme são acessadas. Isso permite que o Realm trabalhe com bancos de dados maiores que a RAM disponível e fornece latência de leitura no nível das estruturas de dados nativas da linguagem (Swift Array ou Kotlin List) para dados que cabem na RAM.

Zero-copy e Live Objects

Arquivos mapeados em memória — a tecnologia chave do Realm. Em vez de copiar dados do arquivo do banco de dados para objetos da linguagem (como o SQLite faz via sqlite3_step + sqlite3_column_*), o Realm mapeia o arquivo do banco de dados diretamente no espaço de endereçamento do processo. Os objetos da linguagem são simplesmente ponteiros para dados na memória mapeada. Alterar um objeto modifica o banco de dados no disco sem uma chamada save separada.

O consumo de memória é maior no Realm durante leitura ativa (todo o arquivo ou grande parte está mapeado na memória), mas menor durante operações de escrita, pois não é necessária alocação de memória para cópias de objetos. Para bancos de dados de até 1 GB em dispositivos móveis, a abordagem memory-mapped oferece melhor desempenho geral que o SQLite com sua cópia intermediária.

Realm vs SQLite vs Core Data: comparação

SQLite é um sistema de gerenciamento de banco de dados relacional com SQL e transações ACID. Realm é um banco de dados NoSQL orientado a objetos com acesso memory-mapped. Core Data é a camada ORM da Apple sobre SQLite. Cada uma das três abordagens tem sua própria área de aplicação e pontos fortes. Realm vence em velocidade de acesso direto a objetos e reatividade, SQLite em versatilidade e maturidade, Core Data em integração com o ecossistema Apple.

O desempenho de leitura do Realm é 10-50% maior que o SQLite graças ao acesso zero-copy. Realm também é mais rápido na escrita devido à ausência de análise sintática SQL e modificação direta das páginas memory-mapped. No entanto, o Realm pode consumir mais RAM ao trabalhar com bancos de dados grandes (>500 MB), pois o arquivo é totalmente mapeado no espaço de endereçamento.

A escolha entre Realm e SQLite muitas vezes se resume a prioridades: velocidade de desenvolvimento e reatividade (Realm) versus controle e versatilidade (SQLite). Realm é especialmente bom para MVPs e protótipos onde o modelo de dados muda frequentemente e é importante obter atualizações de UI ao vivo rapidamente. SQLite/Room é preferível para produtos maduros com grandes volumes de dados e consultas analíticas complexas.

Realm no Android: Kotlin SDK

Realm Kotlin SDK é a biblioteca oficial para Android, escrita em Kotlin (não é um wrapper sobre Java SDK). O modelo de dados é definido através de classes que herdam de RealmObject, com a anotação @PrimaryKey para um identificador único. Realm Kotlin suporta Kotlin Coroutines, Flow e KSP (Kotlin Symbol Processing) para geração de código em tempo de compilação.

RealmQuery fornece uma API type-safe para filtragem sem SQL. As consultas são construídas através de uma cadeia de métodos: query → filter → sort → find. O resultado pode ser retornado como uma lista (carregada na memória) ou como um Flow (fluxo reativo que atualiza quando os dados mudam). Realm Kotlin também suporta objetos aninhados e listas (RealmList).

Exemplo do Realm Kotlin SDK

Modelo de dados Realm é definido como uma classe de dados que implementa a interface RealmObject. O campo _id é marcado com @PrimaryKey para identificação única. O relacionamento um-para-muitos é implementado através de RealmList — uma lista de outros RealmObject. Todas as operações de escrita (criar, atualizar, excluir) são executadas dentro de um bloco de transação 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()

Uma consulta que retorna Flow emite automaticamente novos resultados a qualquer mudança de dados no Realm: adicionar, atualizar ou excluir um Project ou Task. A abordagem Flow combina perfeitamente com Compose: collectAsState() no ViewModel recompõe automaticamente a UI quando os dados mudam sem atualizar manualmente os adaptadores de lista ou usar LiveData.

Realm no iOS: Swift SDK

Realm Swift SDK fornece uma API nativa Swift com suporte para async/await, Combine Publishers e Swift Concurrency. Os modelos de dados são definidos como classes que herdam de Object, usando @Persisted para propriedades. Realm Swift atualiza automaticamente os objetos nas mudanças, e as notificações (NotificationToken) permitem subscrever mudanças de objetos ou coleções individuais.

@ObservedRealmObject e @ObservedResults são Property Wrappers para SwiftUI que redesenham automaticamente a View quando os dados do Realm mudam. @ObservedResults trabalha com resultados de consulta, @ObservedRealmObject com um objeto específico. Ambas as propriedades cancelam a subscrição quando a View é desinicializada.

Exemplo do Realm Swift SDK

Integração com SwiftUI Realm é um dos pontos fortes do SDK. O Property Wrapper @ObservedResults liga uma consulta Realm com a exibição em SwiftUI. Quando qualquer tarefa muda, SwiftUI recompõe automaticamente a lista. realm.writeAsync executa transações em uma thread de fundo sem bloquear a 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 gerencia automaticamente o ciclo de vida da consulta Realm: quando a View é criada, uma subscrição a mudanças é criada; quando destruída, é cancelada. O Property Wrapper aceita um predicado opcional (NSPredicate) e um descritor de ordenação. Isso elimina a necessidade de escrever manualmente requisições fetch, criar ViewModels e subscrever notificações do Realm.

Casos de uso do Realm

Aplicações offline — Realm é ideal para cenários onde os dados devem estar disponíveis sem internet. A sincronização integrada (Realm Sync com MongoDB Atlas) resolve automaticamente conflitos ao conectar-se à rede. O aplicativo continua trabalhando com dados locais, e a sincronização em segundo plano os atualiza quando uma conexão fica disponível.

Interfaces reativas — Live Objects e notificações Flow/Combine tornam Realm uma escolha conveniente para aplicações com dados que mudam frequentemente: chats, feeds de tarefas, documentos colaborativos. A UI atualiza automaticamente quando dados são adicionados, alterados ou excluídos sem chamar manualmente reloadData ou invalidate.

Projetos multiplataforma — Realm suporta Kotlin Multiplatform (KMP), Flutter, React Native e Xamarin. O modelo de dados é definido uma vez e usado em todas as plataformas. Isso reduz a duplicação de código e garante consistência de esquema entre aplicações iOS e Android com lógica de negócios compartilhada.

Realm Sync: sincronização através do MongoDB Atlas

Realm Sync é um serviço em nuvem integrado ao MongoDB Atlas. O aplicativo sincroniza automaticamente os dados entre os dispositivos do usuário e o servidor. Conflitos são resolvidos pela estratégia "last write wins" ou através de funções personalizadas de resolução de conflitos no servidor. Realm Sync suporta sincronização parcial (subconjunto de dados) para reduzir tráfego.

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)
        // A sincronização automática está ativa
    }
}

SyncConfiguration configura a conexão ao MongoDB Atlas e define o conjunto de modelos a sincronizar. Após a autenticação do usuário, Realm carrega automaticamente os dados da nuvem e os mescla com as alterações locais. A sincronização é executada em uma thread de fundo e não requer chamadas manuais — basta criar uma instância Realm com SyncConfiguration.