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.
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 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
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
@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 .
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:
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
RoomDatabase . This basically runs the queries in memory without caching data to a real database:
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:
Learn to test databases created using the Room Librarydeveloper.android.com
Learn to persist data more easily using the Room Librarydeveloper.android.com
If you like my post please check other stories on my profile: