MobiConf 2018 | Room: an SQLite object mapping library

@magdamiu
Room: an SQLite object
mapping library

Magda Miu
Mobile Tech Lead @Roweb
magdamiu.com
@magdamiu
@magdamiu
/magdamiu

If you would have the
possibility to change
something in the Android
development what will it be
that thing?

I don’t want to deal
with technical things.
I just want
to deliver the project.
yiğit boyar - Architecture Components
– Behind the Scenes

public class DatabaseHandler extends SQLiteOpenHelper {
// All Static variables
// Database Version
private static final int DATABASE_VERSION = 1;
// Database Name
private static final String DATABASE_NAME = "CountriesManager";
// Countries table name
private static final String TABLE_Countries = "Country";
// Countries Table Columns names
private static final String KEY_ID = "id";
private static final String KEY_NAME = "name";
private static final String KEY_TOWN = "town";

public DatabaseHandler(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
// Creating Tables
@Override
public void onCreate(SQLiteDatabase db) {
String CREATE_Countries_TABLE = "CREATE TABLE " + TABLE_Countries + "("
+ KEY_ID + " INTEGER PRIMARY KEY," + KEY_NAME + " TEXT,"
+ KEY_TOWN + " TEXT" + ")";
db.execSQL(CREATE_Countries_TABLE);
}

public void addCountry(Country country) {
SQLiteDatabase db = this.getWritableDatabase();
db.beginTransaction();
try {
ContentValues values = new ContentValues();
values.put(KEY_NAME, country.getName()); // Country Name
values.put(KEY_TOWN, country.getTown()); // Country Town
db.insert(TABLE_Countries, null, values);
db.setTransactionSuccessful();
} catch (Exception e) {
Log.d(TAG, "Error while trying to add country to database");
} finally {
db.endTransaction();
}
}

Country getCountry(int id) {
SQLiteDatabase db = this.getReadableDatabase(); Country country = null;
Cursor cursor = db.query(TABLE_Countries, new String[]{KEY_ID,
KEY_NAME, KEY_TOWN}, KEY_ID + "=?",
new String[]{String.valueOf(id)}, null, null, null, null);
try {
if (cursor != null) {
cursor.moveToFirst();
country = new Country(Integer.parseInt(cursor.getString(0)),
cursor.getString(1), cursor.getString(2));
}
} catch (Exception e) {
Log.d(TAG, "Error while trying to get countries from database");
} finally {
if (cursor != null && !cursor.isClosed()) cursor.close();

SQLite
Challenges
Boilerplate code

SQLite
Challenges
Boilerplate code
SQL queries checked at runtime

SQLite
Challenges
Boilerplate code
Db operations on the main thread

SQLite
Challenges
Boilerplate code
Unmaintainable code

SQLite
Challenges
Boilerplate code
Unmaintainable code
Untestable code

Navigation
LiveData
Room
ViewModel
Lifecycle
Pagination
Work
Manager
Architecture Components

ROOM an SQLite object mapping library

Why
ORM?
Productivity
Application Design

Why
ORM?
Productivity
Application Design
Application Maintainability

YES NO
Compile time
query verification
x
Migration support x
Java Query Builder
API
x
SQL Completion in
Android Studio
x
Relationships x
Architecture Components - Behind the Scenes by Yiğit Boyar

Dependencies 1.1.1. Room dependency
2.0.0 AndroidX

01 Entity
Dao02
Database03
Components

public class Company {
private int companyId;
private String name;
Bitmap picture;
}

Bitmap picture;
}
Company
id integer
name text

@Entity(tableName = "Company")
@PrimaryKey(autoGenerate = true)
@ColumnInfo(name = "id")
@ColumnInfo(name = "name")
@Ignore
Bitmap picture;
Company
id integer
name text

Company
id integer
name text
date_added

Company
id integer
name text
date_added date

Company
id integer
name text
date_added integer

@TypeConverter Converts your custom object type into a known
type in terms of database types.

public class DateConverter {
@TypeConverter
public static Date toDate(Long timestamp) {
return timestamp == null ? null : new Date(timestamp);
}
@TypeConverter
public static Long toTimestamp(Date date) {
return date == null ? null : date.getTime();
}
}
Company
id integer
name text
date integer

@ColumnInfo(name = "date_updated")
@TypeConverters(DateConverter.class)
private Date itemUpdatedDate;
-------------------------------------------------

-------------------------------------------------
@Dao
public interface CompanyDao
-------------------------------------------------

-------------------------------------------------
@Dao
public interface CompanyDao
-------------------------------------------------
@Database(entities = {Company.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase

@Dao
public interface CompanyDao {
@Query("SELECT * FROM Company")
LiveData<List<Company>> getAllCountries();
@Insert
void insertCompany(Company company);
@Update
void updateCompany(Company company);
@Delete
void deleteCompany(Company company);
}

@Dao
List<Company> getAllCompanies();
@Insert
@Update
@Delete
}

@Dao
@Query("SELECT * FROM Companies")
@Insert
@Update
@Delete
}

@Dao
public interface DepartmentDao {
@Insert
void insertAll(List<Department> departments);
}

public class DepartmentDao_Impl implements DepartmentDao {
Behind the scenes

private final RoomDatabase __db;
Behind the scenes

private final RoomDatabase __db;
public void insertAll(List<Department> departments) {
this.__db.beginTransaction();
try {
this.__insertionAdapterOfDepartment.insert(departments);
this.__db.setTransactionSuccessful();
} finally {
this.__db.endTransaction();
}
}
}
Behind the scenes

@Database(entities = {Company.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
private static AppDatabase INSTANCE;
public abstract CompanyDao companyDao();
public static AppDatabase getAppDatabase(Context context) {
if (INSTANCE == null) {
INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
AppDatabase.class,
"company-db")
.build();
}
return INSTANCE;

private int directorId;
private Employee director;
public Employee getDirector() {
if(director == null) {
director = getEmployee(employeeId)
}
return director;
}

txtName.setText(company.getDirector().getName());

public class Location {
private double latitude;
private double longitude;
// getters
// setters

@Embedded
private Location location;
@Embedded
private Location headLocation;

@Embedded
private Location location;
@Embedded(prefix = "hq_")
private Location headLocation;

Company
id integer
name text
date integer
latitude real
longitude real
hq_latitude real
hq_longitude real

Employee
id integer
name text
company_id integer

Employee
id integer
name text
company_id integer
Company
id integer
name text
date integer
latitude real
longitude real
hq_latitude real
hq_longitude real
1 M

@ForeignKey constraints across Entities that will ensure that
the relationship is valid on database changes

@Entity(foreignKeys = @ForeignKey(entity = Company.class,
parentColumns = "id",
childColumns = "company_id",
onDelete = ForeignKey.NO_ACTION))
public class Employee {
private int employeeId;
@ColumnInfo(name = "company_id")

@Relation A convenience annotation which can be used in a
Pojo to automatically fetch relation entities

@Entity
public class Department {
@PrimaryKey
private int id;
…
Department
id integer
name text

public class CompanyAndAllDepartments {
@Embedded
public Company company;
@Relation(parentColumn = "id", entityColumn = "companyId", entity = Department.class)
public List<Department> departments;
…
---------------------------------------------------------------------------------

public class CompanyAndAllDepartments {
@Embedded
public Company company;
@Relation(parentColumn = "id", entityColumn = "companyId", entity = Department.class)
public List<Department> departments;
…
@Dao
public interface CompanyDepartmentsDao {
@Transaction
@Query("SELECT * FROM Company WHERE id = :companyId")
CompanyAndAllDepartments loadCompanyAllDepartments(long companyId);
…
---------------------------------------------------------------------------------

Queries
@
Insert
@
Update
@
Delete
@
Q
uery

@Insert
@Update
@Delete
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertAll(List<Company> companies);
void insertAll(Company... companies);
------------------------------------------------

@Insert
@Update
@Delete
@Update
@Update
void updateCompanies(Company... company);
------------------------------------------------
------------------------------------------------

@Insert
@Update
@Delete
@Update
@Update
void updateCompanies(Company... company);
------------------------------------------------
@Delete
@Delete
void deleteCompanies(Company... company);
------------------------------------------------

@Query*
@Query("SELECT * FROM Company WHERE name =
:companyName")
List<Company> getCompanies(String companyName);
LiveData<List<Company>> getAllCompanies();
Flowable<List<Company>> getAllCompanies();
@RawQuery(observedEntities = Employee.class)
LiveData<List<Employee>>
getAllEmployeesWithLimit(SupportSQLiteQuery query);
java.lang.IllegalStateException: Cannot access database
on the main thread since it may potentially lock the UI
for a long period of time.

@Transaction
@Dao
public abstract class DepartmentDao {
@Insert
public abstract void insert(Department product);
@Delete
public abstract void delete(Department product);
@Transaction
public void insertAndDeleteInTransaction(Department
newDepartment, Department oldDepartment) {
// Anything inside this method runs in a single
transaction.
insert(newDepartment);
delete(oldDepartment);
}
}

Threading - Room 1.0
First thread Second Thread

WRITE

WRITE WAITING...

WRITE WAITING...
READ

WRITE READ

Company
id integer
name text
date integer
latitude real
longitude real
hq_latitude real
hq_longitude real
Version 1

Company
id integer
name text
date integer
latitude real
longitude real
hq_latitude real
hq_longitude real
ref_no text
Version 2

Version yVersion x
------------------------------------------------------------
Migration

Version yVersion x
Version 2Version 1
------------------------------------------------------------
Migration

// Upgrading database
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// oldVersion -> newVersion
}

// Upgrading database
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// oldVersion -> newVersion
}
“CLASSICAL”
APPRO
ACH

final Migration MIGRATION_X_Y = new Migration(X, Y) {
@Override
public void migrate(SupportSQLiteDatabase database) {
// your code here
}
};

final Migration MIGRATION_X_Y = new Migration(X, Y) {
@Override
// your code here
}
};
RO
O
M
APPRO
ACH

static final Migration MIGRATION_1_2 = new Migration(1, 2) {
@Override
database.execSQL("ALTER TABLE Company "
+ " ADD COLUMN ref_no TEXT");
}
};

public static AppDatabase getAppDatabase(Context context) {
AppDatabase.class,
DATABASE_NAME)
.addMigrations(MIGRATION_1_2)
.build();
}
return INSTANCE;
}

Version 2Version 1
room_master_table
id identity_hash
42 <v1_hash>
room_master_table
id identity_hash
42 <v2_hash>
Migration

/**
* You can set annotation processor argument (room.schemaLocation) to tell Room to
* export the schema into a folder. Even though it is not mandatory, it is a good
* practice to have version history in your codebase and you should commit that file
* into your version control system (but don't ship it with your app!).
* */
//export schema
javaCompileOptions {
annotationProcessorOptions {
arguments = ["room.schemaLocation": "$projectDir/schemas".toString()]
}
}

/**
* Room will throw an IllegalStateException if you don’t provide a Migration.
* */
AppDatabase.class,
"company-db")
.fallbackToDestructiveMigration()
.build();
}

/**
* Room will throw an IllegalStateException if you don’t provide a Migration.
* */
AppDatabase.class,
"company-db")
.fallbackToDestructiveMigrationFrom(int...
startVersions)
.build();
}

Room
Advantages
Less boilerplate code
SQL queries checked at compile time
No db operations on the main thread
Maintainable code
Migration support

● Official docs:
https://developer.android.com/topic/libraries/archite
cture/room.html
● Google code samples and Youtube channel:
https://github.com/googlesamples/android-architec
ture-components
● CommonsWare:
https://commonsware.com/AndroidArch/
● Slides from: https://www.slidescarnival.com/ and gifs
from: https://gifer.com
Resources

Connecting designers
and developers!
Dziękuję!
Thank you!

MobiConf 2018 | Room: an SQLite object mapping library

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to MobiConf 2018 | Room: an SQLite object mapping library

Similar to MobiConf 2018 | Room: an SQLite object mapping library (20)

Recently uploaded

Recently uploaded (20)

MobiConf 2018 | Room: an SQLite object mapping library