Kotlin Database Programming

# CHAPTER 25

Kotlin Database Programming #

1. Chapter Introduction #

2. Learning Objectives #

• Understand the role of SQLite in mobile apps.

• Understand the Room architecture (Entity, DAO, Database).

• Define a database table using @Entity.

• Define database operations using a @Dao.

• Execute CRUD (Create, Read, Update, Delete) operations.

3. The Room Architecture #

1. 1. Entity: A Kotlin Data Class representing a single table in the database.

1. 2. DAO (Data Access Object): An Interface containing the SQL methods to access the database.

1. 3. Database: An abstract class that ties the Entities and DAOs together to create the actual database instance.

4. Step 1: The Entity (The Table) #

import androidx.room.Entity
import androidx.room.PrimaryKey

// This creates a table named "students"
@Entity(tableName = "students")
data class Student(
    // AutoGenerate means SQLite will automatically create 1, 2, 3...
    @PrimaryKey(autoGenerate = true) 
    val id: Int = 0,
    
    val name: String,
    val grade: String
)

5. Step 2: The DAO (The Queries) #

*Crucial: Database queries are slow. We MUST mark them as suspend functions so they run safely inside Coroutines!*

import androidx.room.*

@Dao
interface StudentDao {
    
    // Insert a new student
    @Insert
    suspend fun insertStudent(student: Student)
    
    // Get all students
    @Query("SELECT * FROM students ORDER BY name ASC")
    suspend fun getAllStudents(): List<Student>
    
    // Delete a student
    @Delete
    suspend fun deleteStudent(student: Student)
}

6. Step 3: The Database #

import androidx.room.Database
import androidx.room.RoomDatabase

// Set version=1. If we change the table structure later, we must increase this version.
@Database(entities = [Student::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    
    // Expose the DAO
    abstract fun studentDao(): StudentDao
}

7. Executing Database Operations #

// Example inside an Android Activity/ViewModel
fun saveStudent(db: AppDatabase, name: String, grade: String) {
    val newStudent = Student(name = name, grade = grade)
    
    // Launch a background coroutine!
    GlobalScope.launch {
        db.studentDao().insertStudent(newStudent)
        println("Student saved successfully!")
    }
}

8. Common Mistakes #

• Running Queries on the Main Thread: Room actively prevents this. If you try to call .insertStudent() without a Coroutine, Room will crash the app with a Cannot access database on the main thread exception to protect the UI.

• Forgetting @PrimaryKey: Every SQLite table must have a primary key to uniquely identify rows. Room will refuse to compile if your Entity is missing one.

9. Best Practices #

• Use the Repository Pattern: Don't call the database directly from your UI (Activity/Fragment). Create a Repository class that handles the database calls, and have the UI communicate with the Repository.

10. Exercises #

1. 1. Define a @Entity data class for a Book with properties id, title, and author.

1. 2. Define a @Dao interface with an @Insert function for the Book.

11. MCQs with Answers #

12. Interview Questions #

• Q: Explain the three primary components of the Room Database architecture.

• Q: Why does Room heavily utilize Kotlin Coroutines? (Answer: Because database I/O is a blocking operation. Coroutines allow the queries to run asynchronously, ensuring smooth 60fps UI rendering).

13. Summary #

14. Next Chapter Recommendation #