---
title: "Room vs SQLDelight: Qual Melhor em 2026? | Kotlin Brasil"
url: "https://kotlin.dev.br/comparacoes/room-vs-sqldelight/"
markdown_url: "https://kotlin.dev.br/comparacoes/room-vs-sqldelight.MD"
description: "Comparação entre Room e SQLDelight para persistencia em Kotlin em 2026. API, performance, multiplataforma, exemplos de código e quando usar cada biblioteca."
date: "2025-09-09"
author: "Karina Melo"
---

# Room vs SQLDelight: Qual Melhor em 2026? | Kotlin Brasil

Comparação entre Room e SQLDelight para persistencia em Kotlin em 2026. API, performance, multiplataforma, exemplos de código e quando usar cada biblioteca.


## Room vs SQLDelight em 2026: qual biblioteca de persistencia escolher?

A persistencia de dados é um componente essencial em aplicações mobile e multiplataforma. Room e SQLDelight são as duas bibliotecas mais populares para trabalhar com SQLite em projetos Kotlin. Este artigo compara ambas em detalhes para ajudar você a escolher a mais adequada para seu projeto. Se sua decisão já aponta para multiplataforma, veja também o guia prático de [SQLDelight com Kotlin Multiplatform](/blog/sqldelight-kotlin-multiplatform-android-ios-2026/).

## Visao geral

| Caracteristica | Room | SQLDelight |
|---------------|------|-----------|
| Criador | Google (Jetpack) | Square / CashApp |
| Abordagem | ORM com anotações | SQL-first com geracao de código |
| Multiplataforma | Somente Android | Kotlin Multiplatform |
| Coroutines | Suporte nativo | Suporte nativo |
| Migração | Automatica e manual | Manual com SQL |
| IDE | Android Studio | IntelliJ / Android Studio |

## Abordagem fundamental

Room utiliza uma abordagem ORM onde você define entidades como classes Kotlin e queries como métodos com anotações:

```kotlin
@Entity(tableName = "usuarios")
data class UsuarioEntity(
    @PrimaryKey(autoGenerate = true)
    val id: Int = 0,
    val nome: String,
    val email: String,
    val dataCriacao: Long = System.currentTimeMillis()
)

@Dao
interface UsuarioDao {
    @Query("SELECT * FROM usuarios ORDER BY nome ASC")
    fun listarTodos(): Flow<List<UsuarioEntity>>

    @Query("SELECT * FROM usuarios WHERE id = :id")
    suspend fun buscarPorId(id: Int): UsuarioEntity?

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun inserir(usuario: UsuarioEntity)

    @Delete
    suspend fun deletar(usuario: UsuarioEntity)

    @Query("SELECT * FROM usuarios WHERE nome LIKE '%' || :termo || '%'")
    fun buscarPorNome(termo: String): Flow<List<UsuarioEntity>>
}

@Database(entities = [UsuarioEntity::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun usuarioDao(): UsuarioDao
}
```

SQLDelight utiliza uma abordagem SQL-first onde você escreve SQL puro em arquivos .sq e a biblioteca gera código Kotlin type-safe:

```sql
-- Usuario.sq
CREATE TABLE usuario (
    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    email TEXT NOT NULL,
    data_criacao INTEGER NOT NULL DEFAULT 0
);

listarTodos:
SELECT * FROM usuario ORDER BY nome ASC;

buscarPorId:
SELECT * FROM usuario WHERE id = ?;

inserir:
INSERT OR REPLACE INTO usuario (nome, email, data_criacao)
VALUES (?, ?, ?);

deletar:
DELETE FROM usuario WHERE id = ?;

buscarPorNome:
SELECT * FROM usuario WHERE nome LIKE '%' || ? || '%';
```

O código gerado pelo SQLDelight oferece funções type-safe para cada query definida:

```kotlin
// Uso do codigo gerado
val database = Database(driver)
val queries = database.usuarioQueries

// Listar com Flow
val usuarios: Flow<List<Usuario>> = queries.listarTodos()
    .asFlow()
    .mapToList(Dispatchers.IO)

// Inserir
queries.inserir(
    nome = "Maria",
    email = "maria@email.com",
    data_criacao = Clock.System.now().toEpochMilliseconds()
)
```

## Segurança de tipos

Room válida queries SQL em tempo de compilação usando annotation processing. Erros em queries são detectados durante a compilação, o que é uma grande vantagem sobre acesso SQL manual. Porem, a válidação depende do schema definido pelas entidades anotadas.

SQLDelight também válida SQL em tempo de compilação, mas vai além ao gerar modelos de dados diretamente a partir do schema SQL. Isso garante que o código Kotlin esta sempre sincronizado com o schema do banco de dados.

## Performance

| Aspecto | Room | SQLDelight |
|---------|------|-----------|
| Overhead de abstracoes | Baixo | Minimo |
| Geracao de código | Annotation processing | Gradle plugin |
| Tempo de compilação | Moderado | Rapido |
| Runtime overhead | Pequeno (reflexao minima) | Minimo |
| Cache de queries | Sim | Sim |

Ambas as bibliotecas oferecem performance excelente. SQLDelight tende a ter um overhead ligeiramente menor por não utilizar reflexao e gerar código mais direto. Na prática, a diferenca e negligivel para a maioria das aplicações.

## Kotlin Multiplatform

Esta e a maior diferenca estrategica entre as duas bibliotecas. SQLDelight suporta Kotlin Multiplatform nativamente, permitindo compartilhar a camada de persistencia entre Android, iOS, desktop e backend com o mesmo código SQL.

Room e específico para Android e não oferece suporte a outras plataformas. Se você planeja compartilhar código entre plataformas, SQLDelight e a única opção entre as duas.

## Migracoes de schema

Room oferece migracoes automaticas para mudancas simples e migracoes manuais para cenários complexos:

```kotlin
val MIGRATION_1_2 = object : Migration(1, 2) {
    override fun migrate(db: SupportSQLiteDatabase) {
        db.execSQL("ALTER TABLE usuarios ADD COLUMN telefone TEXT")
    }
}
```

SQLDelight utiliza migracoes SQL puras em arquivos numerados:

```sql
-- 1.sqm
ALTER TABLE usuario ADD COLUMN telefone TEXT;
```

Ambas as abordagens funcionam bem. Room oferece mais automação para migracoes simples, enquanto SQLDelight da controle total com SQL puro.

## Integração com Jetpack Compose

Ambas as bibliotecas se integram bem com Jetpack Compose através de Flow e collectAsState. A experiência e similar em ambos os casos, com dados reativos fluindo do banco para a UI de forma transparente.

## Ecossistema e comunidade

Room faz parte do Jetpack e possui documentação extensa, exemplos oficiais do Google e uma comunidade enorme. E a escolha padrão para a maioria dos projetos Android.

SQLDelight possui documentação boa e uma comunidade ativa, embora menor. Sendo desenvolvido pela Square/CashApp, possui manutenção profissional e releases regulares.

## Casos de uso recomendados

### Quando usar Room

Room e ideal para projetos exclusivamente Android, equipes familiarizadas com o ecossistema Jetpack, projetos que se beneficiam de migracoes automaticas e aplicações que precisam do suporte e documentação extensos do Google.

### Quando usar SQLDelight

SQLDelight e ideal para projetos Kotlin Multiplatform que compartilham persistencia, equipes que preferem SQL puro a abstraccoes ORM, projetos que priorizam performance maxima e aplicações onde o controle total sobre queries e prioritario.

## Veredicto

Em 2026, a escolha entre Room e SQLDelight depende principalmente de uma pergunta: seu projeto precisa de suporte multiplataforma? Se sim, SQLDelight e a escolha clara. Se não, ambas são excelentes, com Room oferecendo mais conveniencia e integração com o Jetpack, e SQLDelight oferecendo mais controle e performance marginal superior. Para novos projetos que podem eventualmente precisar de multiplataforma, SQLDelight e a escolha mais estrategica a longo prazo.