Migraciones de Room Database en Android 2026: auto-migraciones, pruebas, relaciones y coroutines

Migraciones de Room Database en Android con Room 2.8 y Room 3: auto-migraciones, Migration manual, pruebas con MigrationTestHelper, errores comunes, relaciones y Flow.

Migraciones de Room Database en Android 2026: auto-migraciones, pruebas, relaciones y coroutines

Room es la biblioteca de persistencia de Jetpack que funciona sobre SQLite en Android: las entidades se convierten en tablas, los DAO en consultas generadas, y cada cambio de esquema entre dos versiones de la app tiene que pasar por una migración. En la rama estable 2.x (2.8.5 en septiembre de 2026), los DAO suspend y las consultas Flow vienen integrados en room-runtime, y Room 3.0 lleva toda la API a coroutines y a las interfaces SQLiteDriver.

¿Room 2.8 o Room 3.0?

Room 2.8.5 (androidx.room) es la versión 2.x actual y la que usa la mayoría de los proyectos Android. Room 3.0 (androidx.room3, estable desde julio de 2026, 3.0.3 en septiembre) es un paquete aparte, orientado a Kotlin Multiplatform, solo compatible con KSP, con migraciones escritas contra SQLiteConnection. El código de abajo apunta a Room 2.8, y una sección específica muestra lo que cambia en Room 3.

Cómo funciona una migración de Room Database en Android

Una migración de Room es el código que transforma el esquema de la versión N en el esquema de la versión N+1 sin borrar los datos del usuario. Room compara la versión guardada en el dispositivo con el version de @Database, ejecuta en orden cada migración del camino y luego valida el resultado contra el esquema generado a partir de las entidades. Cualquier diferencia provoca un crash al abrir la base.

Existen tres estrategias, y la elección depende del tipo de cambio de esquema:

EstrategiaAPICuándo usarlaDatos conservados
Migración automática@AutoMigration(from, to)Tabla, columna o índice nuevos; renombres y eliminaciones con una AutoMigrationSpecSí
Migración manualMigration(start, end) + addMigrations()División de tablas, transformación de datos, cambios de tipo, todo lo que Room no puede deducirSí
Fallback destructivofallbackToDestructiveMigration(dropAllTables = true)Cachés y datos que se pueden volver a descargarNo

La guía oficial de migraciones indica que, cuando una migración automática y una manual cubren las mismas versiones, Room usa la manual.

Configurar Room 2.8 con KSP y el plugin de Gradle de Room

Room se apoya en tres componentes: las entidades (tablas), los DAO (Data Access Objects) y la clase de base de datos. El procesador KSP genera su implementación en tiempo de compilación, y desde Room 2.7 genera Kotlin en lugar de Java cuando se usa KSP.

Dos cambios de dependencias sorprenden a los proyectos que se actualizan siguiendo tutoriales antiguos. Desde Room 2.7, room-ktx está fusionado en room-runtime y se publica como un artefacto vacío, así que se puede eliminar. Y el plugin de Gradle de Room es ahora la forma recomendada de exportar los esquemas, de los que dependen tanto las migraciones automáticas como las pruebas de migración.

build.gradle.kts (Module :app)kotlin
plugins {
    id("com.google.devtools.ksp") // KSP 2.x, version declared in the root build file
    id("androidx.room") version "2.8.5"
}

room {
    // Schema JSON files used by auto-migrations and MigrationTestHelper
    schemaDirectory("$projectDir/schemas")
}

dependencies {
    val roomVersion = "2.8.5"
    implementation("androidx.room:room-runtime:$roomVersion") // includes coroutine support since 2.7
    ksp("androidx.room:room-compiler:$roomVersion")
    androidTestImplementation("androidx.room:room-testing:$roomVersion")
}

Room 2.7 y posteriores requieren Kotlin 2.0 o superior, y Room 2.8 subió el minSdk de la biblioteca de 21 a 23. La carpeta schemas/ debe ir al repositorio: es el historial de esquemas contra el que se verifica cada migración futura.

Definición de entidades con claves primarias e índices

Las entidades se corresponden directamente con tablas SQLite. Cada clase de entidad necesita al menos una clave primaria. Los índices en columnas consultadas con frecuencia aceleran las lecturas a cambio de escrituras un poco más lentas.

User.ktkotlin
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.Index
import androidx.room.PrimaryKey

@Entity(
    tableName = "users",
    indices = [
        Index(value = ["email"], unique = true), // Unique constraint + index
        Index(value = ["created_at"]) // Index for sorting queries
    ]
)
data class User(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val email: String,
    @ColumnInfo(name = "display_name")
    val displayName: String,
    @ColumnInfo(name = "phone_number")
    val phoneNumber: String? = null, // Added in schema version 2
    @ColumnInfo(name = "created_at")
    val createdAt: Long = System.currentTimeMillis(),
    @ColumnInfo(name = "is_active")
    val isActive: Boolean = true
)

La anotación @ColumnInfo define el nombre de la columna cuando difiere del nombre de la propiedad Kotlin. Sin ella, la columna toma el nombre de la propiedad (isActive), y una consulta que filtra por is_active falla en compilación.

Creación de DAOs con Coroutines y Flow

Los DAO definen las operaciones sobre la base de datos. Room 2.x admite funciones suspend para operaciones puntuales, Flow para flujos reactivos, y ListenableFuture o RxJava para interoperabilidad con Java.

UserDao.ktkotlin
import androidx.room.*
import kotlinx.coroutines.flow.Flow

@Dao
interface UserDao {
    // Default strategy ABORT: a duplicate email throws SQLiteConstraintException
    @Insert
    suspend fun insertUser(user: User): Long

    // Batch insert - efficient for multiple records
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insertUsers(users: List<User>)

    // Flow emits new data whenever the table changes
    @Query("SELECT * FROM users WHERE is_active = 1 ORDER BY created_at DESC")
    fun observeActiveUsers(): Flow<List<User>>

    // Suspend function for one-shot read
    @Query("SELECT * FROM users WHERE id = :userId")
    suspend fun getUserById(userId: Long): User?

    // Update returns the number of affected rows
    @Update
    suspend fun updateUser(user: User): Int

    // Delete by primary key
    @Delete
    suspend fun deleteUser(user: User)

    // Custom delete query
    @Query("DELETE FROM users WHERE is_active = 0")
    suspend fun deleteInactiveUsers(): Int
}

Las consultas que devuelven Flow emiten resultados nuevos automáticamente cuando cambian los datos subyacentes. Así desaparece la lógica de refresco manual en los ViewModels.

OnConflictStrategy.REPLACE es una trampa habitual en entrevistas: SQLite lo implementa como un borrado seguido de una inserción, de modo que la fila empieza un ciclo de vida nuevo y todas las filas hijas declaradas con ForeignKey.CASCADE se borran con ella. Para un upsert que conserve los hijos, @Upsert (Room 2.5+) actualiza la fila existente.

Creación de la clase Room Database

La clase de base de datos une entidades y DAO. El patrón singleton evita varias instancias de la base, que provocarían fugas de recursos.

AppDatabase.ktkotlin
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase

@Database(
    entities = [User::class, Post::class],
    version = 1,
    exportSchema = true // Writes schemas/<version>.json for migration validation
)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
    abstract fun postDao(): PostDao

    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null

        fun getInstance(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                )
                    .fallbackToDestructiveMigration(dropAllTables = true) // Only for development
                    .build()
                INSTANCE = instance
                instance
            }
        }
    }
}

Con exportSchema = true, Room escribe un archivo JSON por versión en el directorio configurado en el bloque room, que usan las migraciones automáticas y las pruebas de migración. Desde Room 2.7, fallbackToDestructiveMigration() sin argumentos está obsoleto en favor de la sobrecarga con dropAllTables, que decide si también se eliminan las tablas que ya no existen en el esquema.

Estrategia de migración en producción

fallbackToDestructiveMigration() no debe usarse nunca en producción con datos del usuario. Borra todas las tablas cuando falta un camino de migración. Para limitar el daño, fallbackToDestructiveMigrationFrom() lo restringe a versiones antiguas concretas y fallbackToDestructiveMigrationOnDowngrade() a los downgrades.

Escribir migraciones de base de datos seguras

Las migraciones conservan los datos del usuario cuando el esquema cambia entre versiones de la app. Room valida las migraciones en tiempo de ejecución comparando el esquema esperado con la base migrada.

Una migración define las sentencias SQL necesarias para llevar la base de la versión N a la versión N+1.

Migrations.ktkotlin
import androidx.room.migration.Migration
import androidx.sqlite.db.SupportSQLiteDatabase

// Migration from version 1 to 2: add phone_number column
val MIGRATION_1_2 = object : Migration(1, 2) {
    override fun migrate(db: SupportSQLiteDatabase) {
        db.execSQL("ALTER TABLE users ADD COLUMN phone_number TEXT")
    }
}

// Migration from version 2 to 3: add posts table with foreign key
val MIGRATION_2_3 = object : Migration(2, 3) {
    override fun migrate(db: SupportSQLiteDatabase) {
        db.execSQL("""
            CREATE TABLE IF NOT EXISTS posts (
                id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
                user_id INTEGER NOT NULL,
                title TEXT NOT NULL,
                content TEXT NOT NULL,
                created_at INTEGER NOT NULL,
                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
            )
        """.trimIndent())
        db.execSQL("CREATE INDEX index_posts_user_id ON posts(user_id)")
    }
}

// Register migrations in database builder
fun getInstance(context: Context): AppDatabase {
    return INSTANCE ?: synchronized(this) {
        Room.databaseBuilder(
            context.applicationContext,
            AppDatabase::class.java,
            "app_database"
        )
            .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
            .build()
            .also { INSTANCE = it }
    }
}

Room encadena migraciones. Si un usuario actualiza de la versión 1 a la 3, Room ejecuta MIGRATION_1_2 y luego MIGRATION_2_3. Una Migration(1, 3) registrada junto a ellas tiene prioridad, porque Room elige el camino más corto.

Agregar una columna no nula es donde fallan la mayoría de las migraciones escritas a mano. SQLite solo acepta ADD COLUMN ... NOT NULL con un valor DEFAULT, y Room espera entonces el mismo valor por defecto en la entidad mediante @ColumnInfo(defaultValue = "0"). Cambiar el tipo de una columna o quitar una restricción no es posible con el ALTER TABLE de SQLite: la tabla hay que recrearla, copiarla, eliminarla y renombrarla dentro de la migración.

Migraciones automáticas con AutoMigrationSpec

Para cambios de esquema simples (agregar columnas, tablas o índices), Room puede generar las migraciones automáticamente, lo que ahorra código repetitivo en las actualizaciones directas.

AppDatabase.ktkotlin
@Database(
    entities = [User::class, Post::class],
    version = 3,
    autoMigrations = [
        AutoMigration(from = 1, to = 2), // Adding nullable column
        AutoMigration(
            from = 2,
            to = 3,
            spec = AutoMigration2To3::class // Complex changes need spec
        )
    ],
    exportSchema = true
)
abstract class AppDatabase : RoomDatabase() {
    // DAOs...
}

// Migration spec for changes that need hints
@RenameColumn(tableName = "users", fromColumnName = "name", toColumnName = "display_name")
class AutoMigration2To3 : AutoMigrationSpec

Las migraciones automáticas necesitan el esquema exportado de ambas versiones para compararlas. Ante un renombre de columna o de tabla, o una eliminación, Room falla en compilación hasta que una AutoMigrationSpec incluya @RenameColumn, @RenameTable, @DeleteColumn o @DeleteTable. Las transformaciones de datos siguen requiriendo onPostMigrate() en la spec o una migración manual.

Probar migraciones de Room con MigrationTestHelper

Una migración que compila puede igualmente fallar al abrir la base, y solo en los dispositivos que se saltaron versiones. MigrationTestHelper, de room-testing, crea una base en una versión antigua a partir del esquema JSON exportado, ejecuta las migraciones y valida el resultado contra el esquema esperado. El error aparece antes de llegar a Play Store.

MigrationTest.kt (androidTest)kotlin
import androidx.room.testing.MigrationTestHelper
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.assertTrue
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class)
class MigrationTest {
    private val testDb = "migration-test"

    @get:Rule
    val helper = MigrationTestHelper(
        InstrumentationRegistry.getInstrumentation(),
        AppDatabase::class.java
    )

    @Test
    fun migrate1To2_keepsUsers() {
        // Version 1 schema: insert with raw SQL, DAOs expect the latest schema
        helper.createDatabase(testDb, 1).apply {
            execSQL("INSERT INTO users (id, email, display_name, created_at, is_active) VALUES (1, 'ada@example.com', 'Ada', 0, 1)")
            close()
        }

        // Runs MIGRATION_1_2 and checks the schema against schemas/2.json
        val db = helper.runMigrationsAndValidate(testDb, 2, true, MIGRATION_1_2)

        db.query("SELECT email, phone_number FROM users WHERE id = 1").use { cursor ->
            assertTrue(cursor.moveToFirst())
            assertTrue(cursor.isNull(1)) // New column exists and is empty
        }
    }
}

El helper valida el esquema, no los datos, así que la aserción sobre la fila migrada es lo que demuestra que los datos del usuario sobrevivieron. Las migraciones automáticas se prueban igual: runMigrationsAndValidate aplica las declaradas en @Database sin pasarlas de forma explícita. Una segunda prueba que construye la base real con todas las migraciones desde la versión 1 cubre el camino que sigue de verdad una instalación antigua.

Errores comunes de migración en Room y cómo corregirlos

Estos son los mensajes que aparecen en los reportes de crash después de un lanzamiento, y las preguntas que usan los entrevistadores para comprobar que un candidato ya publicó un cambio de esquema.

Mensaje de error (inicio)CausaSolución
A migration from 1 to 2 was required but not foundSe subió la versión sin registrar migración para ese pasoAgregar una Migration o una @AutoMigration para cada paso, o una Migration(1, 3) directa
Migration didn't properly handle: usersLa tabla migrada difiere de la entidad (tipo, nulabilidad, valor por defecto, índice)Comparar los TableInfo Expected y Found del log y alinear el SQL con la entidad
Room cannot verify the data integritySe cambiaron las entidades sin incrementar versionIncrementar version y agregar la migración
Schema '1.json' required for migration was not foundMigración automática sin el esquema exportado de la versión anteriorConfigurar schemaDirectory y subir schemas/ al repositorio desde el primer lanzamiento
Cannot add a NOT NULL column with default value NULLADD COLUMN ... NOT NULL sin DEFAULTAgregar DEFAULT en el SQL y defaultValue en @ColumnInfo

El caso Migration didn't properly handle es el más frecuente: el lado Found suele mostrar una columna declarada TEXT donde la entidad espera TEXT NOT NULL, o un índice creado con un nombre distinto de la convención index_<table>_<column> que genera Room.

¿Listo para aprobar tus entrevistas de Android?

Practica con nuestros simuladores interactivos, flashcards y tests técnicos.

Migraciones en Room 3.0: qué cambia respecto a Room 2.x

Room 3.0 mantiene @Entity, @Dao, @Query, @Database y las anotaciones de migración automática, pero bajo el paquete y el grupo Maven androidx.room3. Los cambios incompatibles que enumeran las notas de versión de Room 3.0 afectan todos al código de migración:

  • SupportSQLiteDatabase desaparece. Hace falta un SQLiteDriver para construir la base, y las migraciones reciben una SQLiteConnection.
  • Migration.migrate() y AutoMigrationSpec.onPostMigrate() son funciones suspend.
  • Solo se admite KSP; KAPT y la generación de código Java se eliminan.
  • Las funciones de DAO deben ser suspend o devolver un tipo reactivo como Flow.
  • @TypeConverter pasa a llamarse @ColumnTypeConverter.
Room 3.0: the same migration, written against SQLiteConnectionkotlin
import androidx.room3.Room
import androidx.room3.migration.Migration
import androidx.sqlite.SQLiteConnection
import androidx.sqlite.driver.AndroidSQLiteDriver
import androidx.sqlite.executeSQL

val MIGRATION_1_2 = object : Migration(1, 2) {
    override suspend fun migrate(connection: SQLiteConnection) {
        connection.executeSQL("ALTER TABLE users ADD COLUMN phone_number TEXT")
    }
}

val db = Room.databaseBuilder<AppDatabase>(context, "app_database")
    .setDriver(AndroidSQLiteDriver()) // Required in Room 3
    .addMigrations(MIGRATION_1_2)
    .build()

El SQL de cada migración no cambia: solo cambian la firma, el paquete y el builder. Para apps solo Android sin código compartido, la rama 2.x sigue recibiendo versiones (2.8.5 en septiembre de 2026) y la actualización puede esperar. Para un proyecto que comparte su capa de datos con iOS o escritorio, el objetivo es Room 3: la guía de Kotlin Multiplatform cubre esa configuración. El código que todavía depende de SupportSQLiteDatabase puede llamar a getSupportWrapper() del artefacto room3-sqlite-wrapper durante la transición.

Modelado de relaciones entre entidades con objetos embebidos

Room admite tres patrones de relación: objetos embebidos, uno a muchos y muchos a muchos. A diferencia de los ORM, Room devuelve datos planos, por lo que las relaciones requieren consultas explícitas.

Uno a muchos: usuario con sus posts

Un usuario puede tener varios posts. La relación se declara con la anotación @Relation en una data class que combina ambas entidades.

Post.ktkotlin
@Entity(
    tableName = "posts",
    foreignKeys = [
        ForeignKey(
            entity = User::class,
            parentColumns = ["id"],
            childColumns = ["user_id"],
            onDelete = ForeignKey.CASCADE // Delete posts when user deleted
        )
    ],
    indices = [Index("user_id")] // Required for foreign key performance
)
data class Post(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    @ColumnInfo(name = "user_id") val userId: Long,
    val title: String,
    val content: String,
    @ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis()
)

// UserWithPosts.kt - Relation container
data class UserWithPosts(
    @Embedded val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "user_id"
    )
    val posts: List<Post>
)

// In UserDao.kt
@Transaction // Ensures atomic read of user + posts
@Query("SELECT * FROM users WHERE id = :userId")
suspend fun getUserWithPosts(userId: Long): UserWithPosts?

@Transaction
@Query("SELECT * FROM users WHERE is_active = 1")
fun observeActiveUsersWithPosts(): Flow<List<UserWithPosts>>

La anotación @Transaction evita lecturas inconsistentes cuando la relación se resuelve internamente con varias consultas.

Muchos a muchos: usuarios y tags

Las relaciones muchos a muchos necesitan una tabla de unión (cross-reference) que guarde pares de claves foráneas.

Tag.ktkotlin
@Entity(tableName = "tags")
data class Tag(
    @PrimaryKey(autoGenerate = true) val tagId: Long = 0,
    val name: String
)

// UserTagCrossRef.kt - Junction table
@Entity(
    tableName = "user_tag_cross_ref",
    primaryKeys = ["userId", "tagId"],
    foreignKeys = [
        ForeignKey(entity = User::class, parentColumns = ["id"], childColumns = ["userId"], onDelete = ForeignKey.CASCADE),
        ForeignKey(entity = Tag::class, parentColumns = ["tagId"], childColumns = ["tagId"], onDelete = ForeignKey.CASCADE)
    ]
)
data class UserTagCrossRef(
    val userId: Long,
    val tagId: Long
)

// UserWithTags.kt
data class UserWithTags(
    @Embedded val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "tagId",
        associateBy = Junction(UserTagCrossRef::class)
    )
    val tags: List<Tag>
)

El parámetro associateBy indica la tabla de unión que vincula usuarios con tags.

Integración de Room con ViewModel y Repository

Una arquitectura limpia separa la capa de base de datos de la interfaz. El patrón Repository abstrae las fuentes de datos, mientras que el ViewModel expone el estado a la UI de Compose.

UserRepository.ktkotlin
class UserRepository(private val userDao: UserDao) {

    val activeUsers: Flow<List<User>> = userDao.observeActiveUsers()

    suspend fun createUser(email: String, displayName: String): Long {
        val user = User(email = email, displayName = displayName)
        return userDao.insertUser(user)
    }

    suspend fun deactivateUser(userId: Long) {
        userDao.getUserById(userId)?.let { user ->
            userDao.updateUser(user.copy(isActive = false))
        }
    }
}

// UserViewModel.kt
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {

    val users: StateFlow<List<User>> = repository.activeUsers
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = emptyList()
        )

    fun createUser(email: String, name: String) {
        viewModelScope.launch {
            repository.createUser(email, name)
            // No manual refresh needed - Flow emits automatically
        }
    }
}

El operador stateIn convierte el Flow frío de Room en un StateFlow caliente, apto para recolectarse desde Compose. Los patrones de coroutines se detallan en la guía de Kotlin Coroutines.

Probar bases de datos Room

Room ofrece un builder de base en memoria para pruebas: Room.inMemoryDatabaseBuilder(). Las pruebas corren más rápido y no conservan datos entre ejecuciones. Las pruebas de DAO usan el builder en memoria, y las de migración usan MigrationTestHelper sobre un archivo real, ya que una base en memoria no tiene versión anterior desde la cual migrar.

Type Converters para tipos complejos

Room solo almacena tipos primitivos de forma nativa. Los type converters transforman tipos complejos (fechas, enums, listas) en formatos almacenables.

Converters.ktkotlin
import androidx.room.TypeConverter
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset

class Converters {
    // Instant <-> Long (milliseconds)
    @TypeConverter
    fun fromInstant(instant: Instant?): Long? = instant?.toEpochMilli()

    @TypeConverter
    fun toInstant(millis: Long?): Instant? = millis?.let { Instant.ofEpochMilli(it) }

    // LocalDate <-> String (ISO format)
    @TypeConverter
    fun fromLocalDate(date: LocalDate?): String? = date?.toString()

    @TypeConverter
    fun toLocalDate(dateStr: String?): LocalDate? = dateStr?.let { LocalDate.parse(it) }

    // List<String> <-> JSON string
    @TypeConverter
    fun fromStringList(list: List<String>?): String? =
        list?.joinToString(separator = ",")

    @TypeConverter
    fun toStringList(data: String?): List<String>? =
        data?.split(",")?.filter { it.isNotBlank() }
}

// Register in database class
@Database(...)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase()

Para serializar objetos complejos a JSON, conviene usar kotlinx.serialization en lugar de manipular cadenas a mano. En Room 3.0, las mismas anotaciones se llaman @ColumnTypeConverter y @ColumnTypeConverters.

Manejo de errores de base de datos en coroutines

Las funciones suspend de un DAO ya se ejecutan en el dispatcher de consultas de Room, así que envolverlas en withContext(Dispatchers.IO) agrega un cambio de contexto sin modificar la seguridad entre hilos. La tarea del repository es traducir las excepciones de SQLite a errores de dominio.

UserRepository.kt with error handlingkotlin
import android.database.sqlite.SQLiteConstraintException

class UserRepository(private val userDao: UserDao) {

    suspend fun createUser(email: String, displayName: String): Result<Long> {
        return try {
            val id = userDao.insertUser(
                User(email = email, displayName = displayName)
            )
            Result.success(id)
        } catch (e: SQLiteConstraintException) {
            // Unique index on email, raised by the default ABORT strategy
            Result.failure(DuplicateEmailException(email))
        }
    }

    suspend fun deleteAllInactive(): Int = userDao.deleteInactiveUsers()
}

class DuplicateEmailException(email: String) : Exception("Email already exists: $email")

Envolver los resultados en Result<T> permite a los ViewModels manejar errores sin bloques try-catch repetidos. Con OnConflictStrategy.REPLACE en insertUser, la excepción nunca se lanzaría y el usuario existente se sobrescribiría sin aviso.

Fuentes

  • Notas de versión de Room: Room 2.7 (KMP, sobrecargas de migración con SQLiteConnection, room-ktx fusionado en room-runtime, Kotlin 2.0), Room 2.8 (minSdk 23), 2.8.5 versión estable actual
  • Notas de versión de Room 3.0: nuevo paquete androidx.room3, SQLiteDriver obligatorio, solo KSP, migraciones suspend, @ColumnTypeConverter
  • Migrar la base de datos Room: migraciones automáticas, AutoMigrationSpec, pruebas de migración, fallbacks destructivos
  • ALTER TABLE de SQLite: restricciones de ADD COLUMN y el procedimiento para recrear una tabla
  • Versiones de KSP: las versiones de KSP 2.3 ya no llevan como prefijo la versión de Kotlin

Checklist de migraciones Room para producción y entrevistas

Una capa de datos Room lista para producción se reduce a unas pocas prácticas que los entrevistadores también evalúan:

  • Usar KSP con Room 2.8 y quitar room-ktx, vacío desde la 2.7
  • Configurar schemaDirectory y subir schemas/ al repositorio desde el primer lanzamiento; sin eso, las migraciones automáticas y las pruebas de migración son imposibles
  • Incrementar version en cada cambio de esquema y ofrecer un camino para cada paso, automático o manual
  • Agregar columnas no nulas con un DEFAULT en SQL que coincida con @ColumnInfo(defaultValue)
  • Probar cada migración con MigrationTestHelper y verificar los datos migrados, no solo el esquema
  • Reservar fallbackToDestructiveMigration(dropAllTables = true) para cachés, nunca para datos del usuario
  • Preferir @Upsert a REPLACE cuando hay filas hijas que dependen del padre mediante CASCADE
  • Usar @Transaction en consultas con relaciones para garantizar lecturas consistentes
  • Planificar el paso a Room 3.0 si la capa de datos se comparte con otras plataformas: mismo SQL, migrate(SQLiteConnection) como suspend, paquete nuevo

La pregunta clásica de entrevista es "¿qué pasa cuando un usuario actualiza directamente de la versión 1 a la 4?". La respuesta esperada: Room encadena las migraciones registradas por el camino más corto, valida el esquema final y lanza IllegalStateException si falta un paso, salvo que haya un fallback destructivo configurado. Estos patrones se practican con las preguntas de entrevista sobre Room Database.

¡Empieza a practicar!

Pon a prueba tu conocimiento con nuestros simuladores de entrevista y tests técnicos.

Reto diario

¿Sabrías detectar el bug en Android?

Un fragmento real, un bug oculto, un intento al día. Sin cuenta para probar.

Anthony Fillion-Maillet

Escrito por

Anthony Fillion-Maillet

Fundador de SharpSkill

Desarrollador fullstack desde hace más de 10 años. Dirige SharpSkill y responde por todo lo que se publica aquí.

Actualizado el 10 de noviembre de 2026

Compartir

Artículos relacionados