Room, the basics


Official Stavro Xhardhas page · Post Room, the basics Posting as Stavro Xhardha Room, the basics * { font-family: Georgia, Cambria, “Times New Roman”, Times, serif; } html, body { margin: 0; padding: 0; } h1 { font-size: 50px; margin-bottom: 17px; color: #333; } h2 { font-size: 24px; line-height: 1.6; margin: 30px 0 0 0; margin-bottom: 18px; margin-top: 33px; color: #333; } h3 { font-size: 30px; margin: 10px 0 20px 0; color: #333; } header { width: 640px; margin: auto; } section { width: 640px; margin: auto; } section p { margin-bottom: 27px; font-size: 20px; line-height: 1.6; color: #333; } section img { max-width: 640px; } footer { padding: 0 20px; margin: 50px 0; text-align: center; font-size: 12px; } .aspectRatioPlaceholder { max-width: auto !important; max-height: auto !important; } .aspectRatioPlaceholder-fill { padding-bottom: 0 !important; } header, section[data-field=subtitle], section[data-field=description] { display: none; }

It has been a while since Roompersistence library is out. It was about time, the SQLiteimplementation was awful, long work and sometimes…*k-2OMl39M12VjKS__y8zIQ.jpeg

It has been a while since Room persistence library is out. It was about time, the SQLite implementation was awful, long work and sometimes confusing.
Therefore, the Android team built Room:

The Room persistence library provides an abstraction layer over SQLite to allow for more robust database access while harnessing the full power of SQLite.

According to the above statement from the official documentation, Room is nothing more than a “refactored and improved” SQLite library.

The setup:

implementation ""
kapt ""
implementation ""

The third dependency is not necessary for room but I am using Room with Coroutines

The Entity:

After you have imported the dependencies, you may start constructing your database. What your database needs at first is a table (or on Room language the Entity):

@Entity(tableName = "names")
data class Name(
    @ColumnInfo(name = "id")
    var number: Int,

    @ColumnInfo(name = "arabic_name")
    var arabicName: String,

    @ColumnInfo(name = "transliteration")
    var transliteration: String,

    val englishNameMeaning: EnglishNameMeaning?,

    @ColumnInfo(name = "name_meaning")
    var meaning: String
    public constructor(): this("" , "", 0, null, "")

This is a table in terms of Room and a model class in terms of Kotlin . It is a representation of your data. To tell Room that I have a table to define I need to provide the @Entity annotation with the required parameter. Every table in Room should have a Primary Key . You can use also the AutoIncrement but I don’t really need it for my case.With the @ColumnInfo I am telling room what name will this field have. Notice the @Ignore annotation. This is a special annotation that tells Room not to care about that field. Since I am using the same Name model for my network request and also for Room I need that field for the network but not for the Database.

The Dao:

The Dao is nothing more than a way to define your queries based on the Entity you declared. Basically, every Entity must have a Dao in order to deal with the table data. Leave the rest to the Room

interface NamesDao {

    @Query("SELECT * FROM names")
    suspend fun selectAllNames(): List<Name>

    suspend fun insertName(name: Name)

    @Query("SELECT * FROM names where id =:number")
    suspend fun findName(number: Int): Name

Dao should be an interface or an abstract class . Just annotate it with the @Dao annotation. I believe there is no need to say what @Query or @Insert annotations do. One thing I must notice here is that, the table name must be the same as your tableName defined in your entity. However don’t worry, the IDE will provide it for you as soon as you start typing it. The other thing I have to mention here is passing method parameters in the query. It can be done as the example states by adding : before the query parameter:
SELECT * FROM names where id = :number .

Database Declaration:

@Database(entities = [Name::class], version = 1, exportSchema = false)
abstract class MyDatabase : RoomDatabase() {
    abstract fun namesDao(): NamesDao

This is where your database is declared, your entities are defined and also the version and the schema. If you want to keep your database version for testing purposes, or you need other things to check, set the exportSchema to true.


    fun provideRoomDatabase(context: Application): MyDatabase = Room.databaseBuilder(
        context,, MY_DATABASE_NAME

Remember, Room instance is a Singleton and needs to declared only one time for application. With the help of Dagger2 I instantiate it like this:

And after that I only require the Dao according to the module dependencies:

    fun provideNamesDao(myDatabase: MyDatabase): NamesDao = myDatabase.namesDao()

Notice the fallbackToDestructiveMigration() method. This one tells Room to delete my data when I migrate to a new database version. It is optional, you can remove it if you want.


I am pretty new at testing myself, but testing in room is not that difficult. First, go to the androidtest package and create a new class:

class NameReadWriteTest

After that you need a Fake for RoomDatabase . This basically runs the queries in memory without caching data to a real database:

   private lateinit var namesDao: NamesDao
    private lateinit var myDatabase: MyDatabase

    fun createDatabase() {
        val context = ApplicationProvider.getApplicationContext<Context>()
        myDatabase = Room.inMemoryDatabaseBuilder(context,
        namesDao = myDatabase.namesDao()

    fun closeDatabase() {

And finally:

    fun writeNameAndReadInList() = runBlocking {
        val name = Name("ArabicLetters", "ArabicTransliteration", 1, null, "It's just a use case")

        val insertedNames = namesDao.selectAllNames()

        assertEquals(listOf(name), insertedNames)

Remember, I am using the runBlocking only because I am using Room with coroutines. Done!


After I learned how to use Room , I have to say that using a database in Android jumped from being my stress to my hobby.

What helped me:

Room 🔗 Coroutines
_Add some suspense to your

Testing your database | Android Developers
_Learn to test databases created using the Room

Save data in a local database using Room | Android Developers
_Learn to persist data more easily using the Room

If you like my post please check other stories on my profile:

Stavro Xhardha - Medium
_Read writing from Stavro Xhardha on Medium. Android Dev . Kotlin Lover. Every day, Stavro Xhardha and thousands of…

By Stavro Xhardha on May 22, 2019.

Canonical link

Exported from Medium on June 19, 2019.

Post settings Labels Published on 6/19/19, 1:46 AM Pacific Daylight Time Permalink Location Options