Entity, DAO, Database classes in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an <strong>Entity</strong> class in Android Room?

An Entity class represents a table in the database. Each instance of the class is a row in that table. It uses annotations like @Entity and @PrimaryKey to define the table and its primary key.

beginner

What does a DAO (Data Access Object) do in Room?

A DAO defines methods to access the database, like inserting, updating, deleting, and querying data. It uses annotations like @Insert, @Update, @Delete, and @Query to specify SQL operations.

beginner

What is the role of the <strong>Database</strong> class in Room?

The Database class holds the database and serves as the main access point. It is an abstract class annotated with @Database and lists the entities and version. It provides abstract methods to get DAOs.

intermediate

Why do we use annotations like @Entity, @Dao, and @Database in Room?

Annotations tell Room how to generate the necessary code. @Entity marks a data class as a table, @Dao marks an interface or abstract class for database operations, and @Database defines the database configuration.

intermediate

How does Room help with database operations compared to raw SQLite?

Room provides a simple, type-safe way to work with SQLite databases. It reduces boilerplate code, handles SQL queries with annotations, and integrates with Kotlin coroutines and LiveData for reactive apps.

Which annotation marks a Kotlin data class as a database table in Room?

A @Entity

B @Dao

C @Database

D @Table

The @Entity annotation marks a class as a table in Room.

What does the @Dao annotation indicate?

A Defines a database table

B Defines a primary key

C Defines the database version

D Defines database access methods

The @Dao annotation marks an interface or abstract class that contains methods to access the database.

Which class holds the database and provides DAOs in Room?

A Entity class

B Database class

C DAO class

D Repository class

The Database class is the main access point to the database and provides DAOs.

Which annotation specifies the database version in Room?

A @Entity(version = 1)

B @Dao(version = 1)

C @Database(version = 1)

D @Version(1)

The @Database annotation includes the version number of the database.

What is the purpose of the @PrimaryKey annotation in an Entity?

A Marks a field as the unique identifier

B Marks a method as primary

C Marks a class as primary

D Marks a query as primary

The @PrimaryKey annotation marks a field as the unique identifier for each row in the table.

Explain the roles of Entity, DAO, and Database classes in Android Room.

Think about how data is stored, accessed, and managed.

Describe how annotations help Room generate database code.

Annotations are like labels telling Room what to do.

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