Hogyan hoznád létre az adatbázist egy…

Az Android-on történő helyi adatbázis létrehozásához a Room Persistence Library-t használnám.

Ez egy absztrakció a SQLite fölött, amely egyszerűsíti az adatbázissal való munkát, annotált API-t biztosítva sémák, lekérdezések és migrációk létrehozásához.

Fő lépések:

Függőségek hozzáadása:

// build.gradle-ben (alkalmazási szinten)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Java-hoz
    kapt("androidx.room:room-compiler:2.6.1") // Kotlin-hoz
    implementation("androidx.room:room-ktx:2.6.1") // Coroutine-hoz
}

Entitások (Entities) létrehozása: POJO vagy adat osztályok, amelyek a táblákat képviselik az adatbázisban. Az @Entity, @PrimaryKey, @ColumnInfo annotációk használata a struktúra meghatározásához.

@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?
)

DAO (Data Access Object) létrehozása: Interfészek, amelyek meghatározzák az adatokhoz való hozzáférés módszereit (beszúrás, törlés, frissítés, lekérdezések). Az @Dao, @Insert, @Delete, @Update, @Query annotációk használata.
```
@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): List<User>

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}
```

Adatbázis osztály létrehozása: Absztrakt osztály, amely kiterjeszti a RoomDatabase-t, hozzáférést biztosít a DAO-hoz és meghatározza az adatbázis sémáját. Az @Database annotáció használata.

@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
            }
        }
    }
}

Az adatbázissal való munka: Az adatbázis példányának megszerzése és műveletek végrehajtása a DAO-n keresztül.

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

// Adatok beszúrása (általában háttérszálon)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Adatok lekérése
GlobalScope.launch {
    val users = userDao.getAll()
}

A Room előnyei:

Lekérdezések fordítói ellenőrzése: Az SQL-lekérdezések fordítási időben ellenőrzöttek, csökkentve a futási hibákat.
Könnyű munka szálakkal: A coroutine vagy LiveData integráció megkönnyíti az adatok kezelését háttérszálon.
Egyszerűbb migráció: Eszközöket kínál az adatbázis séma változásainak kezelésére.
Kevesebb boilerplate kód a natív SQLite-hoz képest.

Ha a követelmények nagyon specifikusak vagy nagyon kicsik lennének, akkor a Shared Preferences használata egyszerű key-value párokhoz is lehetne, de strukturált adatok és lekérdezések esetén a Room a preferált választás. Komplexebb forgatókönyvekhez, ahol szinkronizációra vagy több forrásból való hozzáférésre van szükség (pl. web), a Firebase Realtime Database vagy Firestore használata is megfontolandó, de helyi tárolásra a Room a szabványos és ajánlott megoldás.

Hogyan hoznád létre az adatbázist egy mobilalkalmazáshoz?