Entity, DAO, Database classes in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Room entity with a primary key.

Android Kotlin

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

@Entity
 data class User(
    @PrimaryKey val [1]: Int,
    val name: String
)

Drag options to blanks, or click blank then click option'

Akey

BuserId

Cuid

Did

Attempts:

3 left

💡 Hint

Common Mistakes

Using a field name that is not descriptive or conventional for primary keys.

The primary key field is commonly named id to uniquely identify each entity instance.

2fill in blank

medium

Complete the DAO interface method to get all users from the database.

Android Kotlin

import androidx.room.Dao
import androidx.room.Query

@Dao
interface UserDao {
    @Query("SELECT * FROM User")
    fun [1](): List<User>
}

Drag options to blanks, or click blank then click option'

AgetAllUsers

BfetchUsers

CloadAll

DretrieveUsers

Attempts:

3 left

💡 Hint

Common Mistakes

Using vague method names that do not clearly indicate the action.

The method name getAllUsers clearly describes the action of retrieving all user records.

3fill in blank

hard

Fix the error in the database class declaration by completing the annotation.

Android Kotlin

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

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

Drag options to blanks, or click blank then click option'

A-1

B1

C0

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Setting the version to zero or negative values causes runtime errors.

The database version must be a positive integer starting at 1 to manage schema versions properly.

4fill in blank

hard

Fill both blanks to define a DAO method that inserts a user and returns the new row ID.

Android Kotlin

import androidx.room.Dao
import androidx.room.Insert

@Dao
interface UserDao {
    @Insert
    fun [1](user: User): [2]
}

Drag options to blanks, or click blank then click option'

AinsertUser

BLong

CInt

DaddUser

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect return types like Int or void for insert methods.

The method name insertUser clearly states the action, and the return type Long represents the new row ID.

5fill in blank

hard

Fill all three blanks to define a Room database class with entities, version, and an abstract DAO method.

Android Kotlin

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

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

Drag options to blanks, or click blank then click option'

AUser

B1

CAppDatabase

DUserDao

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up class names or using incorrect version numbers.

The entity is User, the version is 1, and the database class is named AppDatabase.

Practice

1. What is the main purpose of an Entity class in Android Room?

easy

A. To define the structure of a database table

B. To provide methods for database queries

C. To manage database connections

D. To handle UI updates

Solution

1. Step 1: Understand the role of Entity

   An Entity class represents a table in the database by defining its columns and data types.

2. Step 2: Differentiate from DAO and Database

   DAO provides query methods, and Database manages connections, so they are not the main purpose of Entity.

3. Final Answer:

   To define the structure of a database table -> Option A

4. Quick Check:

   Entity = Table structure [OK]

Hint: Entity = table layout definition in Room [OK]

Common Mistakes:

• Confusing Entity with DAO
• Thinking Entity manages database connections
• Assuming Entity handles UI

2. Which of the following is the correct way to annotate a Kotlin data class as an Entity with a primary key named id?

easy

A. @Entity
data class User(@PrimaryKey val id: Int, val name: String)

B. @Entity
class User(val id: Int, val name: String)

C. @Entity(primaryKeys = ["id"])
data class User(val id: Int, val name: String)

D. @Entity
data class User(val id: Int @PrimaryKey, val name: String)

Solution

1. Step 1: Identify correct primary key annotation

   The primary key must be annotated with @PrimaryKey on the property inside the data class.

2. Step 2: Check syntax correctness

   @Entity data class User(@PrimaryKey val id: Int, val name: String) correctly places @PrimaryKey before the id property in a data class annotated with @Entity.

3. Final Answer:

   @Entity data class User(@PrimaryKey val id: Int, val name: String) -> Option A

4. Quick Check:

   Primary key uses @PrimaryKey annotation [OK]

Hint: Use @PrimaryKey before property inside @Entity data class [OK]

Common Mistakes:

• Placing @PrimaryKey after property name
• Using primaryKeys parameter incorrectly
• Missing @PrimaryKey annotation

3. Given the DAO interface below, what will be the return type of getAllUsers() when called?

 @Dao
 interface UserDao {
   @Query("SELECT * FROM user")
   fun getAllUsers(): List<User>
 }

medium

A. A Cursor object

B. A single User object

C. A list of User objects

D. A LiveData object

Solution

1. Step 1: Analyze the DAO method signature

   The method getAllUsers() returns List<User>, which means a list of User objects.

2. Step 2: Understand Room query return types

   Since the return type is explicitly List<User>, it returns a list, not a single object or LiveData.

3. Final Answer:

   A list of User objects -> Option C

4. Quick Check:

   Return type List<User> means list of users [OK]

Hint: Return type in DAO method shows data returned [OK]

Common Mistakes:

• Confusing List<User> with LiveData
• Expecting a single User instead of list
• Thinking Room returns Cursor by default

4. Identify the error in the following Room database class:

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

   companion object {
     fun getInstance(context: Context): AppDatabase {
       return Room.databaseBuilder(context, AppDatabase::class.java, "app_db").build()
     }
   }
 }

medium

A. Missing @Entity annotation on User class

B. No singleton pattern to prevent multiple database instances

C. Incorrect version number format

D. Database class should be an interface, not abstract class

Solution

1. Step 1: Review database class structure

   The database class is abstract and correctly annotated with @Database and version number.

2. Step 2: Check instance creation method

   The getInstance method creates a new database instance every time, lacking a singleton pattern to reuse one instance.

3. Final Answer:

   No singleton pattern to prevent multiple database instances -> Option B

4. Quick Check:

   Database instance should be singleton [OK]

Hint: Use singleton to avoid multiple database instances [OK]

Common Mistakes:

• Not using singleton for database instance
• Confusing abstract class with interface
• Ignoring @Entity annotation on User

5. You want to create a Room database with two entities: User and Book. You also want to provide DAOs for both. Which is the correct way to define the database class?

hard

A. @Database(entities = [User::class, Book::class], version = 1)
abstract class AppDatabase {
abstract fun userDao(): UserDao
abstract fun bookDao(): BookDao
}

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

C. @Database(entities = [User::class, Book::class], version = 1)
class AppDatabase {
fun userDao(): UserDao
fun bookDao(): BookDao
}

D. @Database(entities = [User::class, Book::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
abstract fun userDao(): UserDao
abstract fun bookDao(): BookDao
}

Solution

1. Step 1: Check entities list in @Database annotation

   Both User and Book entities must be included in the entities array.

2. Step 2: Verify class declaration and DAO methods

   The database class must be abstract and extend RoomDatabase, with abstract DAO methods.

3. Final Answer:

   @Database(entities = [User::class, Book::class], version = 1) abstract class AppDatabase : RoomDatabase() { abstract fun userDao(): UserDao abstract fun bookDao(): BookDao } -> Option D

4. Quick Check:

   Entities list and abstract class with DAO methods [OK]

Hint: Include all entities and extend RoomDatabase abstract class [OK]

Common Mistakes:

• Omitting one entity from entities list
• Not extending RoomDatabase
• Making database class non-abstract