Room provides an abstraction layer over SQLite to allow fluent database access. It defines 3 main components - Entity, DAO, and Database. Entities represent tables, DAOs contain database access methods, and Database manages connections. Room avoids errors by verifying queries at compile time. Queries can return LiveData, Flowable, or RxJava observables to asynchronously retrieve data. Relationships between entities can be defined to retrieve related data.

1. Room

2. Saving Data Using the Room
Persistence Library
• Room provides an abstraction layer over SQLite to allow
fluent database access while harnessing the full power of
SQLite.
• That way, when the device cannot access the network, the user can
still browse that content while they are offline. Any user-initiated
content changes are then synced to the server after the device is back
online.

3. 3 major components in Room
Room architecture diagram

4. Entity Represents a table within the database.

5. Dao Contains the methods used for accessing the database.

6. Database
• Contains the database holder and serves as the main access point for the
underlying connection to your app's persisted, relational data. The class
that's annotated with @Database should satisfy the following conditions:
 Be an abstract class that extends RoomDatabase.
 Include the list of entities associated with the database within the
annotation.
 Contain an abstract method that has 0 arguments and returns the class
that is annotated with @Dao.
• At runtime, you can acquire an instance of Database by
calling Room.databaseBuilder() or Room.inMemoryDatabaseBuilder().

7. Note: You should follow the singleton design pattern when instantiating
an AppDatabase object, as each RoomDatabase instance is fairly expensive, and
you rarely need access to multiple instances.
After creating the files above, you get an instance of the created database
using the following code:

9. Caused by: java.lang.IllegalStateException: Cannot access database on the main
thread since it may potentially lock the UI for a long period of time.

10. Sol1.

11. Sol2.
RoomDatabase.java

12. Defining data using Room entities
• By default, Room creates a column for each field that's defined in the
entity. If an entity has fields that you don't want to persist, you can
annotate them using @Ignore. You must reference the entity class
through the entities array in the Database class.
Note: Entities can have either an empty constructor (if
the corresponding DAO class can access each persisted
field) or a constructor whose parameters contain types
and names that match those of the fields in the entity.
Room can also use full or partial constructors, such as a
constructor that receives only some of the fields.

13. Entity
• Each entity must define at least 1 field as a primary key. Even when there is
only 1 field, you still need to annotate the field with the
@PrimaryKey annotation. Also, if you want Room to assign automatic IDs to
entities, you can set the @PrimaryKey's autoGenerate property. If the entity
has a composite primary key, you can use the primaryKeys property of
the @Entity annotation, as shown in the following code snippet:
Use a primary key

14. Entity Annotate indices and uniqueness

15. Entity
• Room doesn’t allow object references
Define relationships between objects
Note: SQLite handles @Insert(onConflict = REPLACE) as a set
of REMOVE and REPLACE operations instead of a single UPDATE operation. This method of
replacing conflicting values could affect your foreign key constraints. For more details, see
the SQLite documentation for the ON_CONFLICT clause.

16. • Sometimes, you'd like to express an entity or plain
old Java object (POJO) as a cohesive whole in
your database logic, even if the object contains
several fields. In these situations, you can use
the @Embedded annotation to represent an
object that you'd like to decompose into its
subfields within a table. You can then query the
embedded fields just as you would for other
individual columns.
• The table representing a User object then
contains columns with the following
names: id, firstName, street, state, city,
and post_code.
• Note: Embedded fields can also include other
embedded fields.
Entity Create nested objects

17. Entity Create nested objects
If an entity has multiple embedded fields of the same type, you can keep each column
unique by setting the prefix property. Room then adds the provided value to the beginning of
each column name in the embedded object.

18. Accessing data using Room DAOs
• To access your app's data using the Room persistence library, you
work with data access objects, or DAOs. This set of Dao objects forms
the main component of Room, as each DAO includes methods that
offer abstract access to your app's database.
• Note: Room doesn't support database access on the main thread
unless you've called allowMainThreadQueries() on the builder
because it might lock the UI for a long period of time. Asynchronous
queries—queries that return instances of LiveData or Flowable—are
exempt from this rule because they asynchronously run the query on
a background thread when needed.

19. Insert
• If the @Insert method receives only 1 parameter, it can return a long, which
is the new rowId for the inserted item. If the parameter is an array or a
collection, it should return long[] or List<Long> instead.

20. Update
Although usually not necessary, you can have this method
return an int value instead, indicating the number of rows
updated in the database.

21. Delete
Although usually not necessary, you can have this
method return an int value instead, indicating the number
of rows removed from the database.

22. Query for information
• @Query is the main annotation used in DAO classes. It allows you to
perform read/write operations on a database. Each @Query method is
verified at compile time, so if there is a problem with the query, a
compilation error occurs instead of a runtime failure.
• Room also verifies the return value of the query such that if the name of the
field in the returned object doesn't match the corresponding column names
in the query response, Room alerts you in one of the following two ways:
 It gives a warning if only some field names match.
 It gives an error if no field names match.

23. Query Passing parameters into the query

24. Query Returning subsets of columns
Note: These POJOs can also use
the @Embedded annotation.

25. Query Passing a collection of arguments

26. Query
Observable queries
Reactive queries with RxJava Direct cursor access
Room can also return
RxJava2 Publisher and Flowable objects from the queries
you define.
Caution

27. Query Querying multiple tables

28. Query Querying multiple tables

29. Relation
• https://developer.android.com/reference/android/
arch/persistence/room/Relation.html

30. Relation
• https://developer.android.com/reference/android/
arch/persistence/room/Relation.html
In the example above, PetNameAndId is a regular Pojo but all of fields are fetched from
the entity defined in the @Relation annotation (Pet). PetNameAndId could also define its own
relations all of which would also be fetched automatically.

31. Relation
• https://developer.android.com/reference/android/
arch/persistence/room/Relation.html

32. Transaction
• https://developer.android.com/reference/android/
arch/persistence/room/Transaction.html
• When used on a Query method that has a Select statement, the generated
code for the Query will be run in a transaction. There are 2 main cases
where you may want to do that:
1. If the result of the query is fairly big, it is better to run it inside a transaction to
receive a consistent result. Otherwise, if the query result does not fit into a
single CursorWindow, the query result may be corrupted due to changes in the
database in between cursor window swaps.
2. If the result of the query is a Pojo with Relation fields, these fields are queried
separately. To receive consistent results between these queries, you probably want
to run them in a single transaction.