Qual è la differenza tra Room e SQLite?

SQLite è un database relazionale leggero integrato in Android. Room è una libreria di astrazione sopra SQLite che fornisce un'API di livello superiore per lavorare con il database, semplificando l'interazione e riducendo la probabilità di errori.

Differenze principali:

• ORM: Room è un ORM (Object-Relational Mapper), che permette di lavorare con i dati sotto forma di classi POJO, invece che direttamente con tabelle e colonne.
• Controlli in fase di compilazione: Room esegue controlli sulle query al database durante la compilazione, rilevando errori di sintassi e incoerenze nei tipi di dati prima dell'esecuzione dell'app.
• Semplificazione del codice: Room genera codice boilerplate per lavorare con il database (ad esempio, per convertire POJO in righe di tabella e viceversa), riducendo significativamente la quantità di codice manuale.
• Supporto per LiveData e Flow: Room si integra con i componenti di Android Architecture Components, come LiveData e Flow, facilitando il lavoro con operazioni asincrone e la sorveglianza delle modifiche ai dati.
• Migrazioni: Room fornisce un meccanismo comodo per eseguire migrazioni del database quando si modifica lo schema.

Esempio di utilizzo di 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)
}

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

Esempio di uso diretto di SQLite con SQLiteOpenHelper:

// Helper per il database
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
    }
}

// Esempio di inserimento dati
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()

Caratteristica	Room	SQLite (diretto)
Tipo	ORM (libreria di astrazione)	Database relazionale
Lavoro con i dati	Oggetti (POJO)	Righe e colonne
Controlli	In fase di compilazione	Principalmente in runtime
Boilerplate	Generato automaticamente	Richiede scrittura manuale
Integrazione con AAC	Sì (LiveData, Flow)	No
Migrazioni	API comoda	Richiede implementazione manuale
Facilità d'uso	Alta	Inferiore, più soggetto a errori

L'uso di Room è preferito nella maggior parte dei casi per lo sviluppo nuovo, poiché semplifica notevolmente il lavoro con il database, aumenta l'affidabilità del codice e riduce il numero di errori. L'uso diretto di SQLite può essere giustificato in casi molto semplici o quando ci sono requisiti specifici che Room non può soddisfare.