Fixing “Kotlin Room Database Not Creating Table”

When working with Kotlin and Room Database, many Android developers face a frustrating issue: the Room database table is not being created, even when the @Entity and @Database annotations are correctly implemented. This article will walk you through why this happens, how to detect the problem, and how to fix it with practical examples and code.

What is Room Database?

Room is a part of Android Jetpack’s Architecture Components. It acts as an abstraction layer over SQLite and allows for robust database access while leveraging the full power of SQLite.

Room components:

• @Entity: Represents a table within the database.
• @Dao: Contains SQL queries and database operations.
• @Database: Abstract class that holds the database and serves as the main access point.

Common Reasons Why Room Table Is Not Created

Cause	Description
Missing @Entity annotation	Room doesn’t know what tables to generate.
Incorrect version or exportSchema	Can break schema generation or migration.
Schema changes without migration	Will crash or skip schema setup.
Multimodule issues	Entity class is not properly included.
Obfuscation / Proguard	Room annotations stripped out.

Example Case: Table Not Created

1. Entity Class

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

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

2. DAO Interface

import androidx.room.*

@Dao
interface UserDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(user: User)

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

3. Database Class

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase

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

What Went Wrong?

Despite correct setup, the database file may be created but the “users” table is missing. Possible causes:

1. Build Not Recompiled

• Clean and rebuild your project (Build > Clean Project and Build > Rebuild Project).

2. Missing Room Plugin in Gradle

Ensure you have applied the correct Room dependencies:

// build.gradle (app)
implementation "androidx.room:room-runtime:2.6.1"
kapt "androidx.room:room-compiler:2.6.1"

Enable Kotlin kapt plugin:

apply plugin: 'kotlin-kapt'

3. ProGuard Stripping Room Annotations

If you’re using ProGuard or R8, add this rule:

-keep class androidx.room.** { *; }
-keep class * extends androidx.room.RoomDatabase
-keep class * extends androidx.room.Room

4. Migration Missing (If version > 1)

If you changed the schema but forgot to write a migration:

Room.databaseBuilder(
    context,
    AppDatabase::class.java,
    "app_database"
).fallbackToDestructiveMigration()

Use .fallbackToDestructiveMigration() only in development. Otherwise, define proper migrations.

How to Check If Table Exists

Use Android Studio’s Device File Explorer or adb shell to check the database:

adb shell
run-as com.yourapp.package
cd databases
sqlite3 app_database
.tables

If you don’t see users, the table isn’t created.

Debugging Tips

• Check Logcat: Room logs database creation steps.
• Temporarily increase the version number and use fallbackToDestructiveMigration() to force rebuild.
• Ensure your AppDatabase and UserDao are referenced and used somewhere in your code to trigger Room initialization.

How to Force Table Creation in Room

Make sure:

• Your DAO is used in at least one coroutine or function.
• Room.databaseBuilder is called in the application flow.
• No crashes happen during Room setup.

Example:

GlobalScope.launch {
    val db = AppDatabase.getDatabase(context)
    db.userDao().insert(User(name = "Test", email = "test@example.com"))
}

Conclusion

The error “Kotlin Room Database Not Creating Table” is usually due to missing annotations, incorrect configurations, or ProGuard rules. By carefully checking the schema definition, Gradle setup, and initialization process, you can prevent and fix this issue.

Room is powerful and reliable — but only when all parts are correctly set up. Don’t forget to test your schema thoroughly and always define migrations when updating the version.