Kotlin Room Database Examples for Developers

Introduction to Kotlin Room Database

Kotlin Room is a powerful library that provides an abstraction layer over SQLite to facilitate smooth database interactions in Android. It simplifies data persistence by allowing developers to define database schemas, manage data queries, and handle migrations easily. In this article, we will explore three practical examples of Kotlin Room Database implementation, showcasing its versatility in different scenarios.

Example 1: Basic User Entity and DAO

Context

In this example, we will create a simple user entity that represents a user in our application, along with a Data Access Object (DAO) to perform operations like inserting and querying user data.

// User.kt - Define the User entity
import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "user_table")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val name: String,
    val email: String
)

// UserDao.kt - Define the User DAO
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query

@Dao
interface UserDao {
    @Insert
    suspend fun insert(user: User)

    @Query("SELECT * FROM user_table")
    suspend fun getAllUsers(): List<User>
}

Notes

• This example defines a User data class and a corresponding DAO interface for inserting and retrieving users from the database.
• Remember to add Room dependencies in your build.gradle file to use Room features.

Example 2: Room Database with a Repository Pattern

Context

In this example, we will implement a repository pattern that abstracts data operations for our user entity, making it easier to manage data from different sources (e.g., local database, remote server).

// UserRepository.kt - Repository for User operations
import kotlinx.coroutines.flow.Flow

class UserRepository(private val userDao: UserDao) {
    suspend fun insert(user: User) {
        userDao.insert(user)
    }

    fun getAllUsers(): Flow<List<User>> {
        return userDao.getAllUsers()
    }
}

// In your ViewModel or wherever you handle UI logic
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class UserViewModel(private val repository: UserRepository) : ViewModel() {
    fun addUser(name: String, email: String) {
        val user = User(name = name, email = email)
        viewModelScope.launch { repository.insert(user) }
    }
}

Notes

• The repository pattern helps centralize data access, making it easier to manage and test.
• Using Flow allows you to observe changes in the data asynchronously.

Example 3: Implementing Migrations in Room Database

Context

In this example, we will handle database migrations, which is crucial when you make changes to the database schema. We’ll ensure that data is preserved during the upgrade process.

// AppDatabase.kt - Database class with migration support
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import androidx.room.migration.Migration
import android.content.Context

@Database(entities = [User::class], version = 2)
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"
                ).addMigrations(MIGRATION_1_2)
                .build()
                INSTANCE = instance
                instance
            }
        }

        private val MIGRATION_1_2 = object : Migration(1, 2) {
            override fun migrate(database: SupportSQLiteDatabase) {
                database.execSQL("ALTER TABLE user_table ADD COLUMN age INTEGER DEFAULT 0 NOT NULL")
            }
        }
    }
}

Notes

• The migration object defines how to upgrade from version 1 to version 2, ensuring that any existing data remains intact.
• Always make sure to test migrations thoroughly to prevent data loss during updates.

These examples of Kotlin Room Database illustrate how to define entities, use DAOs, implement a repository pattern, and handle migrations, providing a comprehensive understanding of Room’s capabilities. By leveraging these techniques, developers can effectively manage data within their Android applications.