Data Persistence With Room

This talk is about how to easily persist data in Android using the Room library from the architectural components from Google. Gave the talk at the Android Nigeria meetup.

Transcript

1. Data Persistence With Room
2. Mgbemena Chike Android Artisan Code Instructor @ Envato Tuts+ @chikecodes chikemgbemena.com
3. What is Room? Room is an ORM (Object-relational mapping) library provided by Google. Google describes Room as providing “an abstraction layer over SQLite to allow fluent database access while harnessing the full power of SQLite.”
4. Other ORMs available for Android: • DBFlow • greenDAO • OrmLite • Sugar ORM
5. Why Room? • Because It’s painful getting data in and out of the database
6. Why Room? • Because It’s painful getting data in and out of the database • Made and maintained by Google
7. Why Room? • Because It’s painful getting data in and out of the database • Made and maintained by Google • Eliminates database boilerplate
8. Why Room? • Because It’s painful getting data in and out of the database • Made and maintained by Google • Eliminates database boilerplate • Compile-time validation of SQLite
9. Setup dependencies { compile 'android.arch.persistence.room:runtime:1.0.0-beta1' annotationProcessor 'android.arch.persistence.room:compiler:1.0.0-beta1' }
10. Room Classes These are the set of classes or components Room is divided into: • Entity
11. Room Classes These are the set of classes or components Room is divided into: • Entity • The data access object (DAO)
12. Room Classes These are the set of classes or components Room is divided into: • Entity • The data access object (DAO) • The database.
13. Room Classes: The Entity class POJOs that model the data you’re transferring in and out of the database. For example, entities representing students, departments and faculties.
14. Room @Entity(tableName = "persons") public class Person { @PrimaryKey @NonNull public final String id; public final String firstName; public final String lastName; @Ignore Person(String firstName, String lastName) { this(UUID.randomUUID().toString(), firstName, l) } Person(String id, String firstName, String lastName) { this.id = id; this.firstName = firstName; this.lastName = lastName; } }
15. Room Classes: DAO “Data access object” is simply the API into the data. Contains methods for the database operations that you need: inserts, updates etc.
16. Room Classes: DAO “Data access object” is simply the API into the data. Contains methods for the database operations that you need: inserts, updates etc.
17. DAO @Dao interface PersonStore { @Query("SELECT * FROM persons ORDER BY firstName") List<Person> selectAll(); @Query("SELECT * FROM persons WHERE id=:id") Person findById(String id); @Insert void insert(Person... persons); @Update void update(Person... persons); @Delete void delete(Person... persons); }
18. Room Classes: Database This abstract class ties together the database file, the entities and the DAOs.
19. Room Classes: Database @Database(entities = {Person.class}, version = 1) abstract class PersonDatabase extends RoomDatabase { abstract PersonStore personStore(); private static final String DB_NAME = "persons.db"; private static volatile PersonDatabase INSTANCE = null; synchronized static PersonDatabase get(Context ctxt) { if (INSTANCE == null) { INSTANCE = create(ctxt, false); } return (INSTANCE); } static PersonDatabase create(Context ctx, boolean memoryOnly) { RoomDatabase.Builder<PersonDatabase> b; if (memoryOnly) { b = Room.inMemoryDatabaseBuilder(ctx.getApplicationContext(), PersonDatabase.class); } else { b = Room.databaseBuilder(ctx.getApplicationContext(), PersonDatabase.class, DB_NAME); } return (b.build()); } }
20. Room Classes: Database @Database(entities = (Person.class), version = 1) abstract class PersonDatabase extends RoomDatabase { abstract PersonStore personStore(); private static final String DB_NAME = "persons.db"; private static volatile PersonDatabase INSTANCE = null; synchronized static PersonDatabase get(Context ctxt) { if (INSTANCE == null) { INSTANCE = create(ctxt, false); } return (INSTANCE); } static PersonDatabase create(Context ctx, boolean memoryOnly) { RoomDatabase.Builder<PersonDatabase> b; if (memoryOnly) { b = Room.inMemoryDatabaseBuilder(ctx.getApplicationContext(), PersonDatabase.class); } else { b = Room.databaseBuilder(ctx.getApplicationContext(), PersonDatabase.class, DB_NAME); } return (b.build()); } }
21. Room Classes: Database @Database(entities = (Person.class), version = 1) abstract class PersonDatabase extends RoomDatabase { abstract PersonStore personStore(); private static final String DB_NAME = "persons.db"; private static volatile PersonDatabase INSTANCE = null; synchronized static PersonDatabase get(Context ctxt) { if (INSTANCE == null) { INSTANCE = create(ctxt, false); } return (INSTANCE); } static PersonDatabase create(Context ctx, boolean memoryOnly) { RoomDatabase.Builder<PersonDatabase> b; if (memoryOnly) { b = Room.inMemoryDatabaseBuilder(ctx.getApplicationContext(), PersonDatabase.class); } else { b = Room.databaseBuilder(ctx.getApplicationContext(), PersonDatabase.class, DB_NAME); } return (b.build()); } }
22. Room Classes: Database @Database(entities = (Person.class), version = 1) abstract class PersonDatabase extends RoomDatabase { abstract PersonStore personStore(); private static final String DB_NAME = "persons.db"; private static volatile PersonDatabase INSTANCE = null; synchronized static PersonDatabase get(Context ctxt) { if (INSTANCE == null) { INSTANCE = create(ctxt, false); } return (INSTANCE); } static PersonDatabase create(Context ctx, boolean memoryOnly) { RoomDatabase.Builder<PersonDatabase> b; if (memoryOnly) { b = Room.inMemoryDatabaseBuilder(ctx.getApplicationContext(), PersonDatabase.class); } else { b = Room.databaseBuilder(ctx.getApplicationContext(), PersonDatabase.class, DB_NAME); } return (b.build()); } }
23. Room Classes: Database @Database(entities = (Person.class), version = 1) abstract class PersonDatabase extends RoomDatabase { abstract PersonStore personStore(); private static final String DB_NAME = "persons.db"; private static volatile PersonDatabase INSTANCE = null; synchronized static PersonDatabase get(Context ctxt) { if (INSTANCE == null) { INSTANCE = create(ctxt, false); } return (INSTANCE); } static PersonDatabase create(Context ctx, boolean memoryOnly) { RoomDatabase.Builder<PersonDatabase> b; if (memoryOnly) { b = Room.inMemoryDatabaseBuilder(ctx.getApplicationContext(), PersonDatabase.class); } else { b = Room.databaseBuilder(ctx.getApplicationContext(), PersonDatabase.class, DB_NAME); } return (b.build()); } }
24. Room Classes: Database @Database(entities = (Person.class), version = 1) abstract class PersonDatabase extends RoomDatabase { abstract PersonStore personStore(); private static final String DB_NAME = "persons.db"; private static volatile PersonDatabase INSTANCE = null; synchronized static PersonDatabase get(Context ctxt) { if (INSTANCE == null) { INSTANCE = create(ctxt, false); } return (INSTANCE); } static PersonDatabase create(Context ctx, boolean memoryOnly) { RoomDatabase.Builder<PersonDatabase> b; if (memoryOnly) { b = Room.inMemoryDatabaseBuilder(ctx.getApplicationContext(), PersonDatabase.class); } else { b = Room.databaseBuilder(ctx.getApplicationContext(), PersonDatabase.class, DB_NAME); } return (b.build()); } }
25. Testing Room Once everything is setup, it’s recommended you start testing your database by writing instrumentation tests.
26. CodeLab
27. Advantages for using In-Memory Database for Instrumentation Testing: • It is self-contained. • Test is much faster because reading and writing to and from memory is much faster than reading and writing from disk.
28. Writing Unit Tests via Mocks Our Room DAOs can be mocked using a mocking library like Mockito. This allows us to write unit tests.
29. CREATE TABLE IF NOT EXISTS Persons (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, firstName TEXT, lastName TEXT) @PrimaryKey(autoGenerate = true) @NonNull public final String id; public final String firstName; public final String lastName; Auto-Generated Primary Keys
30. Composite Primary Keys @Entity(primaryKeys = {"account_number", "account_type"}) public class AccountThingy { public final int accountNumber; public final String accountType; AccountThingy(int accountNumber, String accountType) { this.accountNumber = accountNumber; this.accountType = accountType; } } CREATE TABLE IF NOT EXISTS AccountThingy (accountNumber INTEGER, accountType String NOT NULL, PRIMARY KEY(accountNumber, accountType))
31. Adding Indexes @Entity(indices = {@Index("regNo")}) public class Student { @PrimaryKey public final String id; public final String regNo; public final String name; public Student(String id, String regNo, String name) { this.id = id; this.regNo = regNo; this.name = name } } CREATE INDEX index_Student_regNo ON Student (regNo)
32. Adding Indexes CREATE UNIQUE INDEX index_Student_regNo ON Student (regNo) @Entity(indices = {@Index(value = "regNo", unique = true)})
33. Ignoring Fields @Entity(indices = {@Index(value = "regNo", unique = true)}) public class Student { @PrimaryKey public final String id; public final String regNo; public final String name; @Ignore private String something; public Student(String id, String regNo, String name) { this.id = id; this.regNo = regNo; this.name = name } }
34. Column Name @Entity(tableName = "persons") public class Person { @PrimaryKey(autoGenerate = true) @NonNull public final String id; @ColumnInfo(name = "first_name") public final String firstName; @ColumnInfo(name = "last_name") public final String lastName; @Ignore Person(String firstName, String lastName) { this(UUID.randomUUID().toString(), firstName, lastName); } Person(String id, String firstName, String lastName) { this.id = id; this.firstName = firstName; this.lastName = lastName; } }
35. Return Types A @Query can return the following: • A single entity (e.g. findById() returning a single Person) • A collection of entity (e.g selectAll() return a List of Person entities) • A Cursor • A Flowable or Publisher from RxJava2 • A LiveData Object
36. Transactions db.beginTransaction(); try { // bunch of DAO operation here db.setTransactionSuccessful(); } finally { db.endTransaction(); }
37. Threading In Room @Query, @Insert, @update and @Delete methods are synchronous. They perform their work on the current thread.
38. Relations in Room @Entity( tableName = "phones", foreignKeys = @ForeignKey( entity = Person.class, parentColumns = "id", childColumns = "personId", onDelete = CASCADE), indices = @Index("personId")) public class Phone { public final String name; public final String personId; public Phone(String name, String personId) { this.name = name; this.personId = personId; } }
39. References https://developer.android.com/topic/libraries/architecture/room.html https://medium.com/google-developers/7-steps-to-room-27a5fe5f99b2