Jetpack系列-Room使用和源码分析
2022-05-17 本文已影响0人
我爱田Hebe
1 简介
Room是Google官方在SQLite基础上封装的一款数据持久库，是Jetpack全家桶的一员，和Jetpack其他库有着可以高度搭配协调的天然优势。Room使用APT技术，大大简化了使用SQLite的代码量，只需使用注解配合少量代码即可实现高效的数据库操作。
优点：
- Google官方库，和Jetpack其他库(比如Lifecycle，LiveData)等有天然的融合搭配使用优势。
- 在编译器可以对SQL语法进行检查。
- 使用APT，简单地几个注解搭配少量代码即可使用，大量减少模板代码。
- 查询代码自定义，可以实现更复杂的查询功能，也可以对SQL语句进行优化。
- 简化数据库的迁移路径。
不足：
- 查询时必须手动写SQL语句，不提供默认的查询配置。
- 效率比其他数据库框架(GreenDao等)并没有多少提高。
- 数据库版本升级稍显复杂。
Google官方文档：developer.android.com/jetpack/and…
2 主要组件
Room 包含三个主要组件：
-
DataBase：数据库类，用
@Database标注，继承RoomDatabase，用于保存数据库并作为应用持久性数据底层连接的主要访问点。 -
Entity：数据实体，用
@Entity标注，用于表示应用的数据库中的表。 -
Data Access Object：数据访问对象 (DAO)，用
@DAO标注，提供您的应用可用于查询、更新、插入和删除数据库中的数据的方法。
在DataBase中获取DAO，然后在业务层使用DAO去进行数据的操作。
3 单独使用Room
在Module的build.gradle下添加APT支持。
plugins {
id 'com.android.application'
id 'kotlin-android'
id 'kotlin-kapt'
}
在Module的build.gradle下引入依赖。
def room_version = "2.4.2"
implementation "androidx.room:room-runtime:$room_version"
kapt "androidx.room:room-compiler:$room_version"
创建数据实体Book，包含bookId，name，author，price4个字段，由于bookId被设为主键，需要自增长，所以构造方法里不能有bookId。
@Entity标注Book，就表示在数据库中创建了一个名为“Book”的表。
@PrimaryKey设置该字段是主键，autoGenerate = true表示主键自增长，bookId会从1开始，每插入一条数据就会+1.
@ColumnInfo设置该字段在数据库中的列名，name后的值就是在数据库中的列名。@ColumnInfo可选，不添加的话数据库列名和实体字段名一致。
@Entity
class Book(
var name: String,
@field:ColumnInfo(name = "author") var author: String,
@field:ColumnInfo(name = "price") var price: Float
) {
@PrimaryKey(autoGenerate = true)
var bookId = 0
override fun toString(): String {
return "Book(name='$name', author='$author', price=$price, bookId=$bookId)"
}
}
接着创建一个接口类DAO，在DAO中定义数据库操作方法。用@Dao来标注，然后定义接口方法操作数据库，用对应的注解标注，增删改查分别对应@Insert、 @Delete、 @Update、@Query。
@Dao
interface BookDao {
@Insert
fun insert(book: Book)
@Delete
fun delete(book: Book)
@Update
fun update(book: Book)
//根据名字查数据
@Query("select * from Book where name like:name")
fun queryBookByName(name: String): MutableList<Book>
//根据一组id查数据
@Query("select * from Book where bookId in(:bookIds)")
fun queryBookByIds(bookIds: Array<Int>): MutableList<Book>
//查询所有数据
@Query("select * from Book")
fun queryAllBook(): MutableList<Book>
//查询所有数据中的name和author
@Query("select name,author from Book")
fun queryBookWithPartFiled(): MutableList<Book2>
}
然后创建DataBase，继承RoomDatabase，用注解@Database标注，entities后的值表示数据库中的实体，也就是表，可以有多个，version是数据库版本，exportSchema表示是否支持导出，如果没有指定数据库导出路径，需要设置为false，不然会报错。数据库导出请看文档：developer.android.com/jetpack/and…。
DataBase中提供了一个方法获取DAO。
@Database(entities = [Book::class], version = 1, exportSchema = false)
abstract class AppDataBase : RoomDatabase() {
abstract fun bookDao(): BookDao
}
最后在Activity初始化数据库并使用。数据库初始化方法是Room.databaseBuilder(Context context, Class<T> klass, String name)，3个参数分别是上下文，DataBase类，数据库名称。
class MainActivity : AppCompatActivity() {
private val TAG = "---MS---"
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//Room默认需要在子线程使用
thread {
val database =
Room.databaseBuilder(applicationContext, AppDataBase::class.java, "MsDB")
// .allowMainThreadQueries()//如果需要在主线程中使用，可以开启这行代码
.build()
val dao = database.bookDao()
//插入4条数据
dao.insert(Book("三体", "刘慈欣", 55.6f))
dao.insert(Book("黄金时代", "王小波", 32.9f))
dao.insert(Book("生死疲劳", "莫言", 32.9f))
dao.insert(Book("一句顶一万句", "刘震云", 32.9f))
Log.d(TAG, "查询名字为三体发的数据: ${dao.queryBookByName("三体")}")
Log.d(TAG, "查询id为1，3，4的数据: ${dao.queryBookByIds(arrayOf(1, 3, 4))}")
Log.d(TAG, "查询所有数据: ${dao.queryAllBook()}")
Log.d(TAG, "查询name和author: ${dao.queryBookWithPartFiled()}")
}
}
}
回到BookDao中可以看到，queryBookWithPartFiled方法查询的不是Book表中所有列，而是name和author这两列，返回的对象是Book2，不是Book。这是因为Room查询的时候，查询的列必须和返回的实体中所有字段对应，这也是Room的一个弊端之一。所以这里又定义了一个Book2，用来接收查询到的数据，Book2中只有两个字段name和author，并且不能用@Entity标注，不然Book2也变成了数据库中的一张表。
class Book2(
var name: String,
@field:ColumnInfo(name = "author") var author: String,
) {
override fun toString(): String {
return "Book2(name='$name', author='$author')"
}
}
4 数据库版本升级
Room的数据库版本升级稍显麻烦，核心是Migration类。
修改实体类，新增一个publishData字段。
@Entity
class Book(
var name: String,
@field:ColumnInfo(name = "author") var author: String,
@field:ColumnInfo(name = "price") var price: Float,
//新增字段
@field:ColumnInfo(name = "data") var publishData: String
) {
@PrimaryKey(autoGenerate = true)
var bookId = 0
override fun toString(): String {
return "Book(name='$name', author='$author', price=$price, bookId=$bookId)"
}
}
然后把version改为2。
@Database(entities = [Book::class], version = 2, exportSchema = false)
abstract class AppDataBase : RoomDatabase() {
abstract fun bookDao(): BookDao
}
定义一个内部类，继承Migration，实现migrate方法，执行语句往表中添加列。
/**
* 从版本1升级到版本2
*/
inner class Migration1To2 : Migration(1, 2) {
override fun migrate(database: SupportSQLiteDatabase) {
//执行sql语句，添加data列
database.execSQL("alter table book add column data TEXT not null default '2020-05-01' ")
}
}
最后在Room初始化的时候添加.addMigrations(Migration1To2())。
val database =
Room.databaseBuilder(applicationContext, AppDataBase::class.java, "MsDB")
// .allowMainThreadQueries()//如果需要在主线程中使用，可以开启这行代码
//升级
.addMigrations(Migration1To2())
.build()
5 源码分析
Room使用APT技术，提供了大量的注解。
当用@Dao标注BookDao类，会在build/generated/source/kapt/debug/包名/下生成BookDao_impl.java。该类实现了BookDao中所有的接口方法，实现了具体的增删改查方法。
package cn.zhangmushui.room;
import android.database.Cursor;
import androidx.room.EntityDeletionOrUpdateAdapter;
import androidx.room.EntityInsertionAdapter;
import androidx.room.RoomDatabase;
import androidx.room.RoomSQLiteQuery;
import androidx.room.util.CursorUtil;
import androidx.room.util.DBUtil;
import androidx.room.util.StringUtil;
import androidx.sqlite.db.SupportSQLiteStatement;
import java.lang.Class;
import java.lang.Integer;
import java.lang.Override;
import java.lang.String;
import java.lang.StringBuilder;
import java.lang.SuppressWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@SuppressWarnings({"unchecked", "deprecation"})
public final class BookDao_Impl implements BookDao {
private final RoomDatabase __db;
private final EntityInsertionAdapter<Book> __insertionAdapterOfBook;
private final EntityDeletionOrUpdateAdapter<Book> __deletionAdapterOfBook;
private final EntityDeletionOrUpdateAdapter<Book> __updateAdapterOfBook;
public BookDao_Impl(RoomDatabase __db) {
this.__db = __db;
this.__insertionAdapterOfBook = new EntityInsertionAdapter<Book>(__db) {
@Override
public String createQuery() {
return "INSERT OR ABORT INTO `Book` (`name`,`author`,`price`,`data`,`bookId`) VALUES (?,?,?,?,nullif(?, 0))";
}
@Override
public void bind(SupportSQLiteStatement stmt, Book value) {
if (value.getName() == null) {
stmt.bindNull(1);
} else {
stmt.bindString(1, value.getName());
}
if (value.getAuthor() == null) {
stmt.bindNull(2);
} else {
stmt.bindString(2, value.getAuthor());
}
stmt.bindDouble(3, value.getPrice());
if (value.getPublishData() == null) {
stmt.bindNull(4);
} else {
stmt.bindString(4, value.getPublishData());
}
stmt.bindLong(5, value.getBookId());
}
};
this.__deletionAdapterOfBook = new EntityDeletionOrUpdateAdapter<Book>(__db) {
@Override
public String createQuery() {
return "DELETE FROM `Book` WHERE `bookId` = ?";
}
@Override
public void bind(SupportSQLiteStatement stmt, Book value) {
stmt.bindLong(1, value.getBookId());
}
};
this.__updateAdapterOfBook = new EntityDeletionOrUpdateAdapter<Book>(__db) {
@Override
public String createQuery() {
return "UPDATE OR ABORT `Book` SET `name` = ?,`author` = ?,`price` = ?,`data` = ?,`bookId` = ? WHERE `bookId` = ?";
}
@Override
public void bind(SupportSQLiteStatement stmt, Book value) {
if (value.getName() == null) {
stmt.bindNull(1);
} else {
stmt.bindString(1, value.getName());
}
if (value.getAuthor() == null) {
stmt.bindNull(2);
} else {
stmt.bindString(2, value.getAuthor());
}
stmt.bindDouble(3, value.getPrice());
if (value.getPublishData() == null) {
stmt.bindNull(4);
} else {
stmt.bindString(4, value.getPublishData());
}
stmt.bindLong(5, value.getBookId());
stmt.bindLong(6, value.getBookId());
}
};
}
@Override
public void insert(final Book book) {
__db.assertNotSuspendingTransaction();
__db.beginTransaction();
try {
__insertionAdapterOfBook.insert(book);
__db.setTransactionSuccessful();
} finally {
__db.endTransaction();
}
}
@Override
public void delete(final Book book) {
__db.assertNotSuspendingTransaction();
__db.beginTransaction();
try {
__deletionAdapterOfBook.handle(book);
__db.setTransactionSuccessful();
} finally {
__db.endTransaction();
}
}
@Override
public void update(final Book book) {
__db.assertNotSuspendingTransaction();
__db.beginTransaction();
try {
__updateAdapterOfBook.handle(book);
__db.setTransactionSuccessful();
} finally {
__db.endTransaction();
}
}
@Override
public List<Book> queryBookByName(final String name) {
final String _sql = "select * from Book where name like?";
final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 1);
int _argIndex = 1;
if (name == null) {
_statement.bindNull(_argIndex);
} else {
_statement.bindString(_argIndex, name);
}
__db.assertNotSuspendingTransaction();
final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
try {
final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "name");
final int _cursorIndexOfAuthor = CursorUtil.getColumnIndexOrThrow(_cursor, "author");
final int _cursorIndexOfPrice = CursorUtil.getColumnIndexOrThrow(_cursor, "price");
final int _cursorIndexOfPublishData = CursorUtil.getColumnIndexOrThrow(_cursor, "data");
final int _cursorIndexOfBookId = CursorUtil.getColumnIndexOrThrow(_cursor, "bookId");
final List<Book> _result = new ArrayList<Book>(_cursor.getCount());
while(_cursor.moveToNext()) {
final Book _item;
final String _tmpName;
if (_cursor.isNull(_cursorIndexOfName)) {
_tmpName = null;
} else {
_tmpName = _cursor.getString(_cursorIndexOfName);
}
final String _tmpAuthor;
if (_cursor.isNull(_cursorIndexOfAuthor)) {
_tmpAuthor = null;
} else {
_tmpAuthor = _cursor.getString(_cursorIndexOfAuthor);
}
final float _tmpPrice;
_tmpPrice = _cursor.getFloat(_cursorIndexOfPrice);
final String _tmpPublishData;
if (_cursor.isNull(_cursorIndexOfPublishData)) {
_tmpPublishData = null;
} else {
_tmpPublishData = _cursor.getString(_cursorIndexOfPublishData);
}
_item = new Book(_tmpName,_tmpAuthor,_tmpPrice,_tmpPublishData);
final int _tmpBookId;
_tmpBookId = _cursor.getInt(_cursorIndexOfBookId);
_item.setBookId(_tmpBookId);
_result.add(_item);
}
return _result;
} finally {
_cursor.close();
_statement.release();
}
}
@Override
public List<Book> queryBookByIds(final Integer[] bookIds) {
StringBuilder _stringBuilder = StringUtil.newStringBuilder();
_stringBuilder.append("select * from Book where bookId in(");
final int _inputSize = bookIds.length;
StringUtil.appendPlaceholders(_stringBuilder, _inputSize);
_stringBuilder.append(")");
final String _sql = _stringBuilder.toString();
final int _argCount = 0 + _inputSize;
final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, _argCount);
int _argIndex = 1;
for (Integer _item : bookIds) {
if (_item == null) {
_statement.bindNull(_argIndex);
} else {
_statement.bindLong(_argIndex, _item);
}
_argIndex ++;
}
__db.assertNotSuspendingTransaction();
final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
try {
final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "name");
final int _cursorIndexOfAuthor = CursorUtil.getColumnIndexOrThrow(_cursor, "author");
final int _cursorIndexOfPrice = CursorUtil.getColumnIndexOrThrow(_cursor, "price");
final int _cursorIndexOfPublishData = CursorUtil.getColumnIndexOrThrow(_cursor, "data");
final int _cursorIndexOfBookId = CursorUtil.getColumnIndexOrThrow(_cursor, "bookId");
final List<Book> _result = new ArrayList<Book>(_cursor.getCount());
while(_cursor.moveToNext()) {
final Book _item_1;
final String _tmpName;
if (_cursor.isNull(_cursorIndexOfName)) {
_tmpName = null;
} else {
_tmpName = _cursor.getString(_cursorIndexOfName);
}
final String _tmpAuthor;
if (_cursor.isNull(_cursorIndexOfAuthor)) {
_tmpAuthor = null;
} else {
_tmpAuthor = _cursor.getString(_cursorIndexOfAuthor);
}
final float _tmpPrice;
_tmpPrice = _cursor.getFloat(_cursorIndexOfPrice);
final String _tmpPublishData;
if (_cursor.isNull(_cursorIndexOfPublishData)) {
_tmpPublishData = null;
} else {
_tmpPublishData = _cursor.getString(_cursorIndexOfPublishData);
}
_item_1 = new Book(_tmpName,_tmpAuthor,_tmpPrice,_tmpPublishData);
final int _tmpBookId;
_tmpBookId = _cursor.getInt(_cursorIndexOfBookId);
_item_1.setBookId(_tmpBookId);
_result.add(_item_1);
}
return _result;
} finally {
_cursor.close();
_statement.release();
}
}
@Override
public List<Book> queryAllBook() {
final String _sql = "select * from Book";
final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
__db.assertNotSuspendingTransaction();
final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
try {
final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "name");
final int _cursorIndexOfAuthor = CursorUtil.getColumnIndexOrThrow(_cursor, "author");
final int _cursorIndexOfPrice = CursorUtil.getColumnIndexOrThrow(_cursor, "price");
final int _cursorIndexOfPublishData = CursorUtil.getColumnIndexOrThrow(_cursor, "data");
final int _cursorIndexOfBookId = CursorUtil.getColumnIndexOrThrow(_cursor, "bookId");
final List<Book> _result = new ArrayList<Book>(_cursor.getCount());
while(_cursor.moveToNext()) {
final Book _item;
final String _tmpName;
if (_cursor.isNull(_cursorIndexOfName)) {
_tmpName = null;
} else {
_tmpName = _cursor.getString(_cursorIndexOfName);
}
final String _tmpAuthor;
if (_cursor.isNull(_cursorIndexOfAuthor)) {
_tmpAuthor = null;
} else {
_tmpAuthor = _cursor.getString(_cursorIndexOfAuthor);
}
final float _tmpPrice;
_tmpPrice = _cursor.getFloat(_cursorIndexOfPrice);
final String _tmpPublishData;
if (_cursor.isNull(_cursorIndexOfPublishData)) {
_tmpPublishData = null;
} else {
_tmpPublishData = _cursor.getString(_cursorIndexOfPublishData);
}
_item = new Book(_tmpName,_tmpAuthor,_tmpPrice,_tmpPublishData);
final int _tmpBookId;
_tmpBookId = _cursor.getInt(_cursorIndexOfBookId);
_item.setBookId(_tmpBookId);
_result.add(_item);
}
return _result;
} finally {
_cursor.close();
_statement.release();
}
}
@Override
public List<Book2> queryBookWithPartFiled() {
final String _sql = "select name,author from Book";
final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
__db.assertNotSuspendingTransaction();
final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
try {
final int _cursorIndexOfName = 0;
final int _cursorIndexOfAuthor = 1;
final List<Book2> _result = new ArrayList<Book2>(_cursor.getCount());
while(_cursor.moveToNext()) {
final Book2 _item;
final String _tmpName;
if (_cursor.isNull(_cursorIndexOfName)) {
_tmpName = null;
} else {
_tmpName = _cursor.getString(_cursorIndexOfName);
}
final String _tmpAuthor;
if (_cursor.isNull(_cursorIndexOfAuthor)) {
_tmpAuthor = null;
} else {
_tmpAuthor = _cursor.getString(_cursorIndexOfAuthor);
}
_item = new Book2(_tmpName,_tmpAuthor);
_result.add(_item);
}
return _result;
} finally {
_cursor.close();
_statement.release();
}
}
public static List<Class<?>> getRequiredConverters() {
return Collections.emptyList();
}
}
当用@DataBase标注AppDataBase类，会在build/generated/source/kapt/debug/包名/下生成AppDataBase_impl.java。该类主要进行了表的创建工作。
package cn.zhangmushui.room;
import androidx.annotation.NonNull;
import androidx.room.DatabaseConfiguration;
import androidx.room.InvalidationTracker;
import androidx.room.RoomOpenHelper;
import androidx.room.RoomOpenHelper.Delegate;
import androidx.room.RoomOpenHelper.ValidationResult;
import androidx.room.migration.AutoMigrationSpec;
import androidx.room.migration.Migration;
import androidx.room.util.DBUtil;
import androidx.room.util.TableInfo;
import androidx.room.util.TableInfo.Column;
import androidx.room.util.TableInfo.ForeignKey;
import androidx.room.util.TableInfo.Index;
import androidx.sqlite.db.SupportSQLiteDatabase;
import androidx.sqlite.db.SupportSQLiteOpenHelper;
import androidx.sqlite.db.SupportSQLiteOpenHelper.Callback;
import androidx.sqlite.db.SupportSQLiteOpenHelper.Configuration;
import java.lang.Class;
import java.lang.Override;
import java.lang.String;
import java.lang.SuppressWarnings;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@SuppressWarnings({"unchecked", "deprecation"})
public final class AppDataBase_Impl extends AppDataBase {
private volatile BookDao _bookDao;
@Override
protected SupportSQLiteOpenHelper createOpenHelper(DatabaseConfiguration configuration) {
final SupportSQLiteOpenHelper.Callback _openCallback = new RoomOpenHelper(configuration, new RoomOpenHelper.Delegate(2) {
@Override
public void createAllTables(SupportSQLiteDatabase _db) {
_db.execSQL("CREATE TABLE IF NOT EXISTS `Book` (`name` TEXT NOT NULL, `author` TEXT NOT NULL, `price` REAL NOT NULL, `data` TEXT NOT NULL, `bookId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL)");
_db.execSQL("CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)");
_db.execSQL("INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '049deb639df8f34cc670d599e5105986')");
}
@Override
public void dropAllTables(SupportSQLiteDatabase _db) {
_db.execSQL("DROP TABLE IF EXISTS `Book`");
if (mCallbacks != null) {
for (int _i = 0, _size = mCallbacks.size(); _i < _size; _i++) {
mCallbacks.get(_i).onDestructiveMigration(_db);
}
}
}
@Override
protected void onCreate(SupportSQLiteDatabase _db) {
if (mCallbacks != null) {
for (int _i = 0, _size = mCallbacks.size(); _i < _size; _i++) {
mCallbacks.get(_i).onCreate(_db);
}
}
}
@Override
public void onOpen(SupportSQLiteDatabase _db) {
mDatabase = _db;
internalInitInvalidationTracker(_db);
if (mCallbacks != null) {
for (int _i = 0, _size = mCallbacks.size(); _i < _size; _i++) {
mCallbacks.get(_i).onOpen(_db);
}
}
}
@Override
public void onPreMigrate(SupportSQLiteDatabase _db) {
DBUtil.dropFtsSyncTriggers(_db);
}
@Override
public void onPostMigrate(SupportSQLiteDatabase _db) {
}
@Override
protected RoomOpenHelper.ValidationResult onValidateSchema(SupportSQLiteDatabase _db) {
final HashMap<String, TableInfo.Column> _columnsBook = new HashMap<String, TableInfo.Column>(5);
_columnsBook.put("name", new TableInfo.Column("name", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
_columnsBook.put("author", new TableInfo.Column("author", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
_columnsBook.put("price", new TableInfo.Column("price", "REAL", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
_columnsBook.put("data", new TableInfo.Column("data", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
_columnsBook.put("bookId", new TableInfo.Column("bookId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
final HashSet<TableInfo.ForeignKey> _foreignKeysBook = new HashSet<TableInfo.ForeignKey>(0);
final HashSet<TableInfo.Index> _indicesBook = new HashSet<TableInfo.Index>(0);
final TableInfo _infoBook = new TableInfo("Book", _columnsBook, _foreignKeysBook, _indicesBook);
final TableInfo _existingBook = TableInfo.read(_db, "Book");
if (! _infoBook.equals(_existingBook)) {
return new RoomOpenHelper.ValidationResult(false, "Book(cn.zhangmushui.room.Book).\n"
+ " Expected:\n" + _infoBook + "\n"
+ " Found:\n" + _existingBook);
}
return new RoomOpenHelper.ValidationResult(true, null);
}
}, "049deb639df8f34cc670d599e5105986", "4598151ad10511f4531db7d976d441f6");
final SupportSQLiteOpenHelper.Configuration _sqliteConfig = SupportSQLiteOpenHelper.Configuration.builder(configuration.context)
.name(configuration.name)
.callback(_openCallback)
.build();
final SupportSQLiteOpenHelper _helper = configuration.sqliteOpenHelperFactory.create(_sqliteConfig);
return _helper;
}
@Override
protected InvalidationTracker createInvalidationTracker() {
final HashMap<String, String> _shadowTablesMap = new HashMap<String, String>(0);
HashMap<String, Set<String>> _viewTables = new HashMap<String, Set<String>>(0);
return new InvalidationTracker(this, _shadowTablesMap, _viewTables, "Book");
}
@Override
public void clearAllTables() {
super.assertNotMainThread();
final SupportSQLiteDatabase _db = super.getOpenHelper().getWritableDatabase();
try {
super.beginTransaction();
_db.execSQL("DELETE FROM `Book`");
super.setTransactionSuccessful();
} finally {
super.endTransaction();
_db.query("PRAGMA wal_checkpoint(FULL)").close();
if (!_db.inTransaction()) {
_db.execSQL("VACUUM");
}
}
}
@Override
protected Map<Class<?>, List<Class<?>>> getRequiredTypeConverters() {
final HashMap<Class<?>, List<Class<?>>> _typeConvertersMap = new HashMap<Class<?>, List<Class<?>>>();
_typeConvertersMap.put(BookDao.class, BookDao_Impl.getRequiredConverters());
return _typeConvertersMap;
}
@Override
public Set<Class<? extends AutoMigrationSpec>> getRequiredAutoMigrationSpecs() {
final HashSet<Class<? extends AutoMigrationSpec>> _autoMigrationSpecsSet = new HashSet<Class<? extends AutoMigrationSpec>>();
return _autoMigrationSpecsSet;
}
@Override
public List<Migration> getAutoMigrations(
@NonNull Map<Class<? extends AutoMigrationSpec>, AutoMigrationSpec> autoMigrationSpecsMap) {
return Arrays.asList();
}
@Override
public BookDao bookDao() {
if (_bookDao != null) {
return _bookDao;
} else {
synchronized(this) {
if(_bookDao == null) {
_bookDao = new BookDao_Impl(this);
}
return _bookDao;
}
}
}
}
