# 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. - Published: 2026-07-10 - Updated: 2026-11-10 - Author: Anthony Fillion-Maillet - Reading time: 15 min --- 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: | 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](https://developer.android.com/training/data-storage/room/migrating-db-versions) 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. ```kotlin // build.gradle.kts (Module :app) 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. ```kotlin // User.kt 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. ```kotlin // UserDao.kt 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) // Flow emits new data whenever the table changes @Query("SELECT * FROM users WHERE is_active = 1 ORDER BY created_at DESC") fun observeActiveUsers(): Flow> // 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. ```kotlin // AppDatabase.kt 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/.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. ```kotlin // Migrations.kt 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](https://www.sqlite.org/lang_altertable.html): 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. ```kotlin // AppDatabase.kt @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. ```kotlin // MigrationTest.kt (androidTest) 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__` que genera Room. ## 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](https://developer.android.com/jetpack/androidx/releases/room3) 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`. ```kotlin // Room 3.0: the same migration, written against SQLiteConnection 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(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](https://sharpskill.dev/es/blog/android/kotlin-multiplatform-2026) 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. ```kotlin // Post.kt @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 ) // 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> ``` 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. ```kotlin // Tag.kt @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 ) ``` 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. ```kotlin // UserRepository.kt class UserRepository(private val userDao: UserDao) { val activeUsers: Flow> = 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> = 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](https://sharpskill.dev/es/blog/android/mastering-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. ```kotlin // Converters.kt 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 <-> JSON string @TypeConverter fun fromStringList(list: List?): String? = list?.joinToString(separator = ",") @TypeConverter fun toStringList(data: String?): List? = 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](https://github.com/Kotlin/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. ```kotlin // UserRepository.kt with error handling import android.database.sqlite.SQLiteConstraintException class UserRepository(private val userDao: UserDao) { suspend fun createUser(email: String, displayName: String): Result { 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` 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](https://developer.android.com/jetpack/androidx/releases/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](https://developer.android.com/jetpack/androidx/releases/room3): nuevo paquete `androidx.room3`, `SQLiteDriver` obligatorio, solo KSP, migraciones `suspend`, `@ColumnTypeConverter` - [Migrar la base de datos Room](https://developer.android.com/training/data-storage/room/migrating-db-versions): migraciones automáticas, `AutoMigrationSpec`, pruebas de migración, fallbacks destructivos - [ALTER TABLE de SQLite](https://www.sqlite.org/lang_altertable.html): restricciones de `ADD COLUMN` y el procedimiento para recrear una tabla - [Versiones de KSP](https://github.com/google/ksp/releases): 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](https://sharpskill.dev/es/technologies/android/preguntas-entrevista/android-room-database). --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/es/blog/android/room-database-android-2026-migrations-relations-coroutines