¿Cómo crearías una base de datos para una aplicación…

Para crear una base de datos local en Android, usaría Room Persistence Library.

Es una abstracción sobre SQLite que simplifica el trabajo con bases de datos, proporcionando una API anotada para crear esquemas, consultas y gestionar migraciones.

Pasos principales:

Agregar dependencias:

// En build.gradle (nivel de la app)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Para Java
    kapt("androidx.room:room-compiler:2.6.1") // Para Kotlin
    implementation("androidx.room:room-ktx:2.6.1") // Para corrutinas
}

Crear entidades (Entities): POJO (Plain Old Java Object) o clases de datos que representan tablas en la base de datos. Las anotaciones @Entity, @PrimaryKey, @ColumnInfo se usan para definir la estructura.

@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    @ColumnInfo(name = "first_name") val firstName: String?,
    @ColumnInfo(name = "last_name") val lastName: String?
)

Crear DAO (Data Access Objects): Interfaces que definen métodos de acceso a datos (insertar, eliminar, actualizar, consultas). Las anotaciones @Dao, @Insert, @Delete, @Update, @Query se usan para definir operaciones.

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): List<User>

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}

Crear clase Database: Clase abstracta que hereda de RoomDatabase, que proporciona acceso a DAO y define el esquema de la base de datos. La anotación @Database indica las entidades y la versión.

@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao

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

        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

Trabajar con la base de datos: Obtener la instancia y realizar operaciones a través del DAO.

val db = AppDatabase.getDatabase(applicationContext)
val userDao = db.userDao()

// Insertar datos (normalmente en un hilo de fondo)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Obtener datos
GlobalScope.launch {
    val users = userDao.getAll()
}

Ventajas de Room:

Verificación de consultas en tiempo de compilación: Las consultas SQL se verifican en tiempo de compilación, reduciendo errores en tiempo de ejecución.
Trabajo sencillo con hilos: La integración con corrutinas o LiveData facilita el trabajo con datos en hilos de fondo.
Migración más sencilla: Ofrece herramientas para gestionar cambios en el esquema.
Menos código boilerplate comparado con SQLite nativo.

Si los requisitos son muy específicos o pequeños, se podría considerar usar Shared Preferences para pares clave-valor simples, pero para datos estructurados y consultas, Room es preferido. Para escenarios más complejos que requieran sincronización o acceso desde diferentes fuentes (como web), se puede considerar usar bases de datos en la nube como Firebase Realtime Database o Firestore, pero para almacenamiento local, Room es la solución estándar y recomendada.

¿Cómo crearías una base de datos para una aplicación móvil?