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.

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.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:
| Estrategia | API | Cuándo usarla | Datos conservados |
|---|---|---|---|
| Migración automática | @AutoMigration(from, to) | Tabla, columna o índice nuevos; renombres y eliminaciones con una AutoMigrationSpec | Sí |
| Migración manual | Migration(start, end) + addMigrations() | División de tablas, transformación de datos, cambios de tipo, todo lo que Room no puede deducir | Sí |
| Fallback destructivo | fallbackToDestructiveMigration(dropAllTables = true) | Cachés y datos que se pueden volver a descargar | No |
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.
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.
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.
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.
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.
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.
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.
@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 : AutoMigrationSpecLas 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.
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) | Causa | Solución |
|---|---|---|
A migration from 1 to 2 was required but not found | Se subió la versión sin registrar migración para ese paso | Agregar una Migration o una @AutoMigration para cada paso, o una Migration(1, 3) directa |
Migration didn't properly handle: users | La 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 integrity | Se cambiaron las entidades sin incrementar version | Incrementar version y agregar la migración |
Schema '1.json' required for migration was not found | Migración automática sin el esquema exportado de la versión anterior | Configurar schemaDirectory y subir schemas/ al repositorio desde el primer lanzamiento |
Cannot add a NOT NULL column with default value NULL | ADD COLUMN ... NOT NULL sin DEFAULT | Agregar 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:
SupportSQLiteDatabasedesaparece. Hace falta unSQLiteDriverpara construir la base, y las migraciones reciben unaSQLiteConnection.Migration.migrate()yAutoMigrationSpec.onPostMigrate()son funcionessuspend.- Solo se admite KSP; KAPT y la generación de código Java se eliminan.
- Las funciones de DAO deben ser
suspendo devolver un tipo reactivo comoFlow. @TypeConverterpasa a llamarse@ColumnTypeConverter.
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.
@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.
@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.
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.
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.
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.
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-ktxfusionado enroom-runtime, Kotlin 2.0), Room 2.8 (minSdk23), 2.8.5 versión estable actual - Notas de versión de Room 3.0: nuevo paquete
androidx.room3,SQLiteDriverobligatorio, solo KSP, migracionessuspend,@ColumnTypeConverter - Migrar la base de datos Room: migraciones automáticas,
AutoMigrationSpec, pruebas de migración, fallbacks destructivos - ALTER TABLE de SQLite: restricciones de
ADD COLUMNy 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
schemaDirectoryy subirschemas/al repositorio desde el primer lanzamiento; sin eso, las migraciones automáticas y las pruebas de migración son imposibles - Incrementar
versionen cada cambio de esquema y ofrecer un camino para cada paso, automático o manual - Agregar columnas no nulas con un
DEFAULTen SQL que coincida con@ColumnInfo(defaultValue) - Probar cada migración con
MigrationTestHelpery verificar los datos migrados, no solo el esquema - Reservar
fallbackToDestructiveMigration(dropAllTables = true)para cachés, nunca para datos del usuario - Preferir
@UpsertaREPLACEcuando hay filas hijas que dependen del padre medianteCASCADE - Usar
@Transactionen 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)comosuspend, 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.
¿Sabrías detectar el bug en Android?
Un fragmento real, un bug oculto, un intento al día. Sin cuenta para probar.

Escrito por
Anthony Fillion-MailletFundador 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

Trabajos freelance para desarrolladores Android en 2026: dónde encontrar contratos, tarifas y preparación
Guía completa sobre trabajos freelance para desarrolladores Android en 2026: plataformas para encontrar contratos, tarifas diarias por región y cómo prepararse para las entrevistas técnicas.

Trabajo de desarrollador Android en 2026: dónde buscar, rangos salariales y preparación
Cómo encontrar trabajo como desarrollador Android en 2026: plataformas de empleo, rangos salariales por nivel, opciones de trabajo remoto y preparación para entrevistas técnicas.

Modularización Android en 2026: Arquitectura Multi-Módulo y Preguntas de Entrevista
Guía completa sobre modularización Android en 2026. Aprende a estructurar una arquitectura multi-módulo, usar catálogos de versiones Gradle y dominar las preguntas de entrevista técnica esenciales.