Image for post
Image for post

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:

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):

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

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:

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.


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:

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:

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

And finally:

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:

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

You can find me on my personal blog:

Written by

Android Engineer. Kotlin fan. Dedicated to the single Activity applications.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store