Quelle est la différence entre Room et SQLite…

SQLite est une base de données relationnelle légère intégrée à Android. Room est une bibliothèque d'abstraction sur SQLite qui fournit une API de haut niveau pour travailler avec la base de données, simplifiant l'interaction et réduisant la probabilité d'erreurs.

Principales différences :

ORM : Room est un ORM (Object-Relational Mapper), permettant de travailler avec des données sous forme de classes POJO, plutôt qu'avec des tables et des colonnes directement.
Vérifications en compilation : Room effectue des vérifications des requêtes à la base de données lors de la compilation, détectant les erreurs de syntaxe et les incohérences de types de données avant l'exécution de l'application.
Simplification du code : Room génère du code boilerplate pour travailler avec la base de données (par exemple, pour convertir un POJO en lignes de la table et vice versa), ce qui réduit considérablement la quantité de code manuel.
Support pour LiveData et Flow : Room s'intègre avec les composants de Android Architecture Components, tels que LiveData et Flow, facilitant le travail avec des opérations asynchrones et la surveillance des changements de données.
Migrations : Room fournit un mécanisme pratique pour effectuer des migrations de la base de données lors du changement de son schéma.

Exemple d'utilisation de Room :

// Entité
@Entity
data class User(
    @PrimaryKey val userId: Int,
    val name: String,
    val age: Int
)

// DAO (Data Access Object)
@Dao
interface UserDao {
    @Query("SELECT * FROM user")
    fun getAllUsers(): List<User>

    @Insert
    fun insertUser(user: User)
}

// Base de données
@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

Exemple d'utilisation directe de SQLite avec SQLiteOpenHelper :

// Helper pour la base de données
class DbHelper(context: Context) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {

    override fun onCreate(db: SQLiteDatabase) {
        val createTableQuery = """
            CREATE TABLE users (
                _id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT,
                age INTEGER
            )
        """.trimIndent()
        db.execSQL(createTableQuery)
    }

    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        db.execSQL("DROP TABLE IF EXISTS users")
        onCreate(db)
    }

    companion object {
        private const val DATABASE_NAME = "mydatabase.db"
        private const val DATABASE_VERSION = 1
    }
}

// Exemple d'insertion de données
val dbHelper = DbHelper(context)
val db = dbHelper.writableDatabase
val values = ContentValues().apply {
    put("name", "Alice")
    put("age", 30)
}
db.insert("users", null, values)
db.close()

Caractéristique	Room	SQLite (direct)
Type	ORM (bibliothèque d'abstraction)	Base de données relationnelle
Travail avec les données	Objets (POJO)	Lignes et colonnes
Vérifications	En compilation	Principalement en runtime
Code boilerplate	Généré automatiquement	Nécessite une écriture manuelle
Intégration avec AAC	Oui (LiveData, Flow)	Non
Migrations	API pratique	Nécessite une implémentation manuelle
Facilité d'utilisation	Élevée	Moins, plus sujet aux erreurs

L'utilisation de Room est préférée dans la majorité des cas pour le développement neuf, car elle simplifie considérablement le travail avec la base de données, augmente la fiabilité du code et réduit le nombre d'erreurs. L'utilisation directe de SQLite peut être justifiée dans des cas très simples ou lorsque des exigences spécifiques que Room ne peut satisfaire sont présentes.

Quelle est la différence entre Room et SQLite?