Room简单实操

1. Room介绍，直接Copy官网介绍：

Room 持久性库在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，能够流畅地访问数据库。具体来说，Room 具有以下优势：

提供针对 SQL 查询的编译时验证。
提供方便注解，可最大限度减少重复和容易出错的样板代码。
简化了数据库迁移路径。

总结就是简化了操作数据库的难度，相对于直接操作Sqlite Api。

2. Room主要组件，包含如下三个部分，内容直接Copy官网：

数据库类（Room Database），用于保存数据库并作为应用持久性数据底层连接的主要访问点 -- 数据库类为应用提供与该数据库关联的 DAO 的实例。
数据实体（Entities），用于表示应用的数据库中的表。
数据访问对象 (Data Access Objects)，提供在数据库中查询、更新、插入和删除数据的方法。

如果链接访问不了，直接将前缀修改为中文官网的域名（https://developer.android.google.cn/）

Room架构示意图

引入依赖库，参考Android版本依赖Version catalog

// Room
implementation(libs.room.runtime)
annotationProcessor(libs.room.compiler)
// To use Kotlin Symbol Processing (KSP)
ksp(libs.room.compiler)
// optional - Kotlin Extensions and Coroutines support for Room
implementation(libs.room.ktx)
// 测试数据库
testImplementation(libs.room.testing)

一、单表

1.1 数据实体

每个 Room 实体定义为带有 @Entity 注解的类。Room 实体包含数据库中相应表中的每一列的字段，包括构成主键的一个或多个列。

/*** 用户表对象.** @param id* 如果您在定义实体类时将一个字段标记为 @PrimaryKey(autoGenerate = true)，* 并且在插入记录时不为该字段赋值，Room 将会自动生成一个唯一的值并填充到该字段中。*/
@Entity
class User(/*** 主键字段不能为空，并且必须具有唯一性，以确保每条记录都可以唯一标识.** autoGenerate = true之后我们将主键默认设置为空或者0，* room也会自动自动生成一个唯一的值并填充到该字段中，* 但是不建议设置为空，建议默认设置为0。*/@PrimaryKey(autoGenerate = true)val id: Long = 0,val name: String,val age: Int = 0,@GenderTypeval gender: Int = GenderType.MALE
) {override fun toString(): String {return "User(id=$id, name='$name', age=$age, gender=$gender)"}
}

注意：

1. 要保留某个字段，Room 必须拥有该字段的访问权限。

2. 可以通过将某个字段设为公开或为其提供 getter 和 setter 方法，确保 Room 能够访问该字段。

1.1.1 自定义表明和列名

默认情况下，Room 将类名称用作数据库表名称。如果希望表具有不同的名称，请设置 @Entity 注解的 tableName 属性。
Room 默认使用字段名称作为数据库中的列名称。如果您希望列具有不同的名称，请将 @ColumnInfo 注解添加到该字段并设置 name 属性。

@Entity(tableName = "users")
class User(@PrimaryKey(autoGenerate = true)val id: Long = 0,@ColumnInfo(name = "uaerName")val name: String,val age: Int = 0,@GenderTypeval gender: Int = GenderType.MALE
)

注意：SQLite 中的表和列名称不区分大小写。

1.1.2 主键介绍

在 Room 数据库中，主键通常定义为长整型（long）是因为长整型提供了更大的范围，可以容纳更多的唯一标识符。这种做法是出于以下几个考虑：

唯一标识符范围：长整型可以表示更大范围的整数值，最大可达到 2^63 - 1，相比于整型（int）的最大值 2^31 - 1，长整型提供了更大的唯一标识符范围，可以满足大多数情况下的需求。
避免溢出：使用长整型可以避免标识符溢出的问题。长整型的范围比较大，即使在较长时间内也不太可能出现溢出的情况。
与数据库兼容性：在许多数据库系统中，主键通常被定义为长整型或者类似的数据类型（如 BIGINT），这样可以确保 Room 数据库与其他数据库系统的兼容性。

@PrimaryKey(autoGenerate = true)
val id: Long = 0

1. 如果您在定义实体类时将一个字段标记为 @PrimaryKey(autoGenerate = true)，
并且在插入记录时不为该字段赋值，Room 将会自动生成一个唯一的值并填充到该字段中。

2. 主键字段不能为空，并且必须具有唯一性，以确保每条记录都可以唯一标识.

3. autoGenerate = true之后我们将主键默认设置为空或者0，room也会自动自动生成一个唯一的值并填充到该字段中，但是不建议设置为空，建议默认设置为0。

1.1.3 忽略字段

默认Room 会为实体中定义的每个字段创建一个列。如果某个实体中有不想保留的字段，则可以使用 @Ignore 为这些字段添加注解

@Entity
class User(@PrimaryKey(autoGenerate = true)val id: Long = 0,val name: String,val age: Int = 0,@GenderTypeval gender: Int = GenderType.MALE,@Ignore val headBm: Bitmap?
)

1.2 数据访问对象 (DAO)

对象创建须知

1. 介绍

将每个 DAO 定义为一个接口或一个抽象类。通常应使用接口。

无论哪种形式，都必须始终使用 @Dao 为创建 DAO 对象添加注解。DAO 不具有属性，但它们定义了一个或多个方法，可用于与应用数据库中的数据进行交互。

两种类型的 DAO 方法可以定义数据库交互：

在不编写任何 SQL 代码的情况下插入、更新和删除数据库中的行的便捷方法。
编写自己的 SQL 查询以与数据库进行交互的查询方法。

2. 总结：

1. 对象必须是接口或者抽象类

2. 对象必须使用@DAO注解进行修饰

3. 增、删、改不需要使用任何SQL语句，直接使用@Insert、@Delete、@Update注解方法即可

4. 查询方法直接编写SQL语句就能使用，例如：@Query("SELECT *FROM user")

1.2.1 插入

使用 @Insert 注解，您可以定义将其参数插入数据库中的相应表的方法，可以同时插入一个或多个对象。

1. 插入单个对象，参数必须是具体的`@Entity数据库表，例如例子中的User表`

@Insert 注解的方法每个参数都必须是一个带有 @Entity 注解的 Room 数据实体类实例。
如果 @Insert 方法接收到单个参数，则可返回一个 long 值，这是插入项的新 rowId。

2. 插入多个对象，参数必须是具体的`@Entity数据库表集合或者数组`

数据实体类实例的集合，而且每个参数都指向一个数据库。调用 @Insert 方法时，Room 会将每个传递的实体实例插入到相应的数据库表中。
如果参数是数组或集合，则可改为返回由 long 值组成的数组或集合，并且每个值都作为其中一个插入项的 rowId。

想了解如何返回 rowId 值，请参阅 @Insert 注解的参考文档以及 rowid 表的 SQLite 文档。

/*** 插入多个用户数据（碰到冲突就替换为最新的）.** @param users 用户数据（可变对象）* @return 插入数据ID集合*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertAll(vararg users: User): List<Long>/*** 插入用户集合数据.** @param users 用户数据集合* @return 插入数据ID集合*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertAll(users: List<User>): List<Long>

OnConflictStrategy常量介绍：

NONE：没有冲突处理策略，事务将会回滚。
REPLACE：替换旧数据并继续事务。
~~ROLLBACK：事务回滚。已弃用，请使用 ABORT。~~
ABORT：事务回滚。
~~FAIL：事务失败。已弃用，请使用 ABORT。~~
IGNORE：忽略冲突。

1.2.2 更新

更新方法直接用@Update修饰，ROOM支持更新单个对象（单行）、集合对象（多行）、数组对象（查看源码：EntityDeletionOrUpdateAdapter）。与 @Insert 方法一样，@Update 方法接受数据实体实例作为参数。

/*** 更新用户数据.** @param users 用户数据（可变对象）* @return 更新数据ID集合*/
@Update
fun update(vararg users: User)

Room 使用主键（就是User表中的id）将传递的实体实例与数据库中的行进行匹配。如果没有具有相同主键的行，Room 不会进行任何更改。

@Update 方法可以选择性地返回 int 值，指示成功更新的行数。

1.2.3 删除

删除方法直接用@Delete修饰，ROOM支持删除单个对象、集合对象、数组对象（查看源码：EntityDeletionOrUpdateAdapter）

/*** 删除多个用户数据.** @param users 用户数据（可变对象）*/
@Delete
fun delete(vararg users: User)/*** 删除用户集合.** @param users 用户集合*/
@Delete
fun delete(users: List<User>)

从源码中我们可以看到，ROOM中删除和更新调用的是相同的方法。

Room 使用主键将传递的实体实例与数据库中的行进行匹配。如果没有具有相同主键的行，Room 不会进行任何更改。

@Delete 方法可以选择性地返回 int 值，指示成功删除的行数。

1.2.4 查询

Room的查询主要是写Sql语句，只要是对Sql语句熟悉的，写起来就是得心应手。

如下常用的查询方法，使用如下注解在方法上：@Query("查询的SQL")

1. 查询数据库中所有对象

/*** 查询所有用户数据.** @return 用户数据集合*/
@Query("SELECT *FROM user")
fun getAll(): List<User>

2. 查询数据库表列的子集

在数据库查询的时候，我们偶尔不需要查询全部的列，例如此例中的用户表我们可能只需要查询用户ID、用户名。

借助 Room可以从任何查询返回简单对象，前提是将一组结果列映射到需要查询的简单的对象。

举例：

1. 创建需要的列的对象

/*** 偶尔我们只是需要查询用户数据的列子集。* 借助 Room，可以从任何查询返回简单对象，前提是可以将一组结果列映射到返回的对象。*/
data class UserTuple(val id: Long,val name: String
)

2. 查询指定子集

/*** 查询用户数据的列子集.** @return 返回用户数据列子集*/
@Query("SELECT id, name FROM user")
fun getSimpleAll(): List<UserTuple>

3. 将简单参数传递给查询，使用指定参数进行查询

/*** 通过用户ID查询用户数据.** @param id 用户ID* @return 用户数据*/
@Query("SELECT *FROM user WHERE id = :id")
fun getById(id: Int): User/*** 通过用户名查询用户数据（没啥意义，用户名可以重名，查询的是最近的用户）.** @param name 用户名* @return 用户数据*/
@Query("SELECT *FROM user WHERE name LIKE :name LIMIT 1")
fun findByName(name: String): User/*** 通过用户名查询用户数据集合.** @param name 用户名* @return 用户数据集合*/
@Query("SELECT *FROM user WHERE name LIKE :name ORDER BY id DESC")
fun findAllByName(name: String): List<User>/*** 查询某一年龄段用户数据.** @param minAge 最小年龄* @param maxAge 最大年龄* @return 用户数据集合*/
@Query("SELECT *FROM user WHERE age BETWEEN :minAge AND :maxAge")
fun getAllBetweenAges(minAge: Int, maxAge: Int): List<User>

4. 将一组参数传递给查询，查询指定组查询条件的数据

/*** 通过用户ID查询用户数据.** @param userIds 用户ID集合* @return 用户数据集合*/
@Query("SELECT * FROM user WHERE id IN (:userIds)")
fun getAllByIds(userIds: IntArray): List<User>

1.2.5 完整DAO对象

增、删、改、查完整的DAO对象代码：

/*** 用户表数据库操作对象.*/
@Dao
interface UserDao {/*** 插入多个用户数据（碰到冲突就替换为最新的）.** @param users 用户数据（可变对象）* @return 插入数据ID集合*/@Insert(onConflict = OnConflictStrategy.REPLACE)fun insertAll(vararg users: User): List<Long>/*** 插入用户集合数据.** @param users 用户数据集合* @return 插入数据ID集合*/@Insert(onConflict = OnConflictStrategy.REPLACE)fun insertAll(users: List<User>): List<Long>/*** 删除多个用户数据.** @param users 用户数据（可变对象）*/@Deletefun delete(vararg users: User)/*** 删除用户集合.** @param users 用户集合*/@Deletefun delete(users: List<User>)/*** 更新用户数据.** @param users 用户数据（可变对象）* @return 更新数据ID集合*/@Updatefun update(vararg users: User)/*** 查询所有用户数据.** @return 用户数据集合*/@Query("SELECT *FROM user")fun getAll(): List<User>/*** 查询用户数据的列子集.** @return 返回用户数据列子集*/@Query("SELECT id, name FROM user")fun getSimpleAll(): List<UserTuple>/*** 通过用户ID查询用户数据.** @param id 用户ID* @return 用户数据*/@Query("SELECT *FROM user WHERE id = :id")fun getById(id: Int): User/*** 通过用户ID查询用户数据.** @param userIds 用户ID集合* @return 用户数据集合*/@Query("SELECT * FROM user WHERE id IN (:userIds)")fun getAllByIds(userIds: IntArray): List<User>/*** 通过用户名查询用户数据（没啥意义，用户名可以重名，查询的是最近的用户）.** @param name 用户名* @return 用户数据*/@Query("SELECT *FROM user WHERE name LIKE :name LIMIT 1")fun findByName(name: String): User/*** 通过用户名查询用户数据集合.** @param name 用户名* @return 用户数据集合*/@Query("SELECT *FROM user WHERE name LIKE :name ORDER BY id DESC")fun findAllByName(name: String): List<User>/*** 查询某一年龄段用户数据.** @param minAge 最小年龄* @param maxAge 最大年龄* @return 用户数据集合*/@Query("SELECT *FROM user WHERE age BETWEEN :minAge AND :maxAge")fun getAllBetweenAges(minAge: Int, maxAge: Int): List<User>}

1.3 数据库对象

数据库类必须满足以下条件：

必须带有 @Database 注解，该注解包含列出所有与数据库关联的数据实体的 entities 数组 -- 可以定义N多表，只需要放在entities = [User::class, Work::class]。
必须是一个抽象类，用于扩展 RoomDatabase。
对于与数据库关联的每个 DAO 类，数据库类必须定义一个具有零参数的抽象方法，并返回 DAO 类的实例。

/*** 数据库.*/
@Database(entities = [User::class], version = 1)
abstract class TestDataBase : RoomDatabase() {/*** 用户表操作类.*/abstract fun userDao(): UserDao
}

注意：

1. 如果您的应用在单个进程中运行，在实例化 TestDataBase 对象时应遵循单例设计模式。每个 RoomDatabase 实例的成本相当高，而您几乎不需要在单个进程中访问多个实例。

2. 如果应用在多个进程中运行，请在数据库构建器调用中包含 enableMultiInstanceInvalidation()。这样，如果您在每个进程中都有一个 TestDataBase 实例，可以在一个进程中使共享数据库文件失效，并且这种失效会自动传播到其他进程中 TestDataBase 的实例。

1.4 构建数据库实例，进行数据库操作

@RunWith(AndroidJUnit4::class)
class RoomTest {companion object {private const val TAG = "RoomTest"}private lateinit var mDb: TestDataBaseprivate lateinit var mUserDao: UserDaoprivate lateinit var mWorkDao: WorkDaoprivate lateinit var mUserWorkDao: UserWorkDao@Beforefun createDb() {val context = ApplicationProvider.getApplicationContext<Context>()mDb = Room.databaseBuilder(context,TestDataBase::class.java,"pp-test-database").build()mUserDao = mDb.userDao()mWorkDao = mDb.workDao()mUserWorkDao = mDb.userWorkDao()}@Afterfun closeDb() {mDb.close()}@Testfun testInsert() {mUserDao.insertAll(User(name = "刘亦菲", age = 20, gender = GenderType.FEMALE),User(name = "唐嫣", age = 30, gender = GenderType.FEMALE)).run {assertEquals(2, this.size)mUserDao.getAll().run {for ((index, value ) in this.withIndex()) {// 更新// mUserDao.update(User(id = value.id, name = "修改$index", age = value.age, gender = value.gender))// 插入数据mWorkDao.insertAll(Work(introduce = "打工人$index", userId = value.id))}// 删除// mUserDao.delete(this[0])}mUserWorkDao.getAllUserWork().run {for ((index, value) in this.withIndex()) {"index=$index, value=$value".logI(TAG)}}}}
}

Room操作单表已经介绍完成，按照上述操作即可成功使用room操作Sqlite数据库

二、多表

2.1 定义对象之间的关系

由于 SQLite 是关系型数据库，因此您可以定义各个实体之间的关系。虽然大多数对象关系映射库都允许实体对象相互引用，但 Room 明确禁止这样做。

原因：了解 Room 为何不允许对象引用

Room 中，可以通过两种方式定义和查询实体之间的关系：

使用具有嵌入式对象的中间数据类
使用具有多重映射返回值类型的关系型查询方法。

2.1.1 中间数据类

创建Work工作类对象

@Entity(foreignKeys = [ForeignKey(entity = User::class,parentColumns = arrayOf("id"),childColumns = arrayOf("userId"),onDelete = ForeignKey.CASCADE)]
)
data class Work(@PrimaryKey(autoGenerate = true)val id: Long = 0,val introduce: String,/*** 外键，对应用户表的id.*/val userId: Long
) {override fun toString(): String {return "Work(id=$id, introduce='$introduce', userId=$userId)"}
}

在 Room 中，@ForeignKey 注解用于定义外键约束，这些约束用于确保数据的完整性和一致性。使用外键约束可以建立表与表之间的关联关系，从而实现数据的引用完整性。

外键约束的主要作用包括：

维护关联关系：通过外键约束，您可以在一个表中引用另一个表中的数据。这样可以建立表与表之间的关联关系，使得数据之间的关系更加清晰明确。
确保引用完整性：外键约束可以确保在引用另一个表中的数据时，被引用的数据确实存在。这样可以避免出现引用无效数据的情况，保证了数据的完整性。
实现级联操作：通过外键约束，可以实现级联操作，例如在删除或更新父表中的数据时，自动删除或更新子表中相关联的数据。这样可以保持数据之间的一致性。

1. 定义一对一关系

两个实体之间的一对一关系是指：父实体的每个实例恰好对应于子实体的 1 个实例，反之亦然。

例子：

一个用户只有一份工作，每个工作只能有一个用户。因此User尸体和Work实体之间就是一对一的关系。
如需定义一对一关系，为两个实体分别创建一个类。其中一个实体必须包含一个变量，且该变量是对另一个实体的主键的引用。

上述例子中User和Work实体，work表的userId对应的就是User表的id，重新copy一份如下

@Entity
class User(@PrimaryKey(autoGenerate = true)val id: Long = 0,val name: String,val age: Int = 0,@GenderTypeval gender: Int = GenderType.MALE
) data class Work(@PrimaryKey(autoGenerate = true)val id: Long = 0,val introduce: String,/*** 外键，对应用户表的id.*/val userId: Long
)

需要创建一个新的数据类，其中每个实例都包含父实体的一个实例和与之对应的子实体实例。
使用 @Embedded 注释表示要分解为表格中的子字段的对象，父实体。将 @Relation 注释添加到子实体的实例，同时将 parentColumn 设置为父实体主键列的名称，并将 entityColumn 设置为引用父实体主键的子实体列的名称。

/*** 用户和对应工作数据.** 一对一的关系*/
data class UserWork(@Embeddedval user: User,@Relation(parentColumn = "id",entityColumn = "userId")val work: Work
) {override fun toString(): String {return "UserWork(user=$user, work=$work)"}
}

向 DAO 类添加一个方法，用于返回将父实体与子实体配对的数据类的所有实例。该方法需要 Room 运行两次查询，因此应向该方法添加 @Transaction 注释，以确保整个操作以原子方式执行。

/*** 用户和对应工作表数据库操作对象.*/
@Dao
interface UserWorkDao {/*** 查询用户和用户工作数据.** @return 用户和用户工作数据集合*/@Transaction@Query("SELECT *FROM user")fun getAllUserWork(): List<UserWork>}

2. 定义一对多关系

父实体的每个实例对应于子实体的零个或多个实例，但子实体的每个实例只能恰好对应于父实体的一个实例。

定义一对多关系，需要为这两个实体分别创建一个类。与一对一关系一样，子实体必须包含一个变量，且该变量是对父实体的主键的引用。
将 @Relation 注释添加到子实体的实例，同时将 parentColumn 设置为父实体主键列的名称，并将 entityColumn 设置为引用父实体主键的子实体列的名称。

/*** 用户和对应工作数据.** 一对多的关系*/
class UserWorkList(@Embeddedval user: User,@Relation(parentColumn = "id",entityColumn = "userId")val workList: MutableList<Work>
) {override fun toString(): String {return "UserWorkList(user=$user, workList=$workList)"}
}

/*** 用户和对应工作表数据库操作对象.*/
@Dao
interface UserWorkDao {/*** 查询用户和用户工作数据.** @return 用户和用户工作数据集合*/@Transaction@Query("SELECT *FROM user")fun getUserWithWorkList(): List<UserWorkList>
}

3. 定义多对多关系

两个实体之间的多对多关系是指：父实体的每个实例对应于子实体的零个或多个实例，反之亦然。

例子：

每个用户表都可以包含多个计划，每个计划都可以包含在多个用户表中。因此，User 实体和 Work 实体之间存在多对多关系。
如需定义多对多关系，需要为两个实体分别创建一个类。
多对多关系与其他关系类型均不同的一点在于，子实体中通常不存在对父实体的引用。因此，需要创建第三个类来表示两个实体之间的关联实体（即交叉引用表）。交叉引用表中必须包含表中表示的多对多关系中每个实体的主键列。

@Entity
class User(/*** 主键字段不能为空，并且必须具有唯一性，以确保每条记录都可以唯一标识.** autoGenerate = true之后我们将主键默认设置为空或者0，* room也会自动自动生成一个唯一的值并填充到该字段中，* 但是不建议设置为空，建议默认设置为0。*/@PrimaryKey(autoGenerate = true)val id: Long = 0,val name: String,val age: Int = 0,@GenderTypeval gender: Int = GenderType.MALE
)/*** 计划表.*/
@Entity
data class Plan(@PrimaryKey(autoGenerate = true)val planId: Long = 0,val planName: String,val planTime: Long
)/*** 用户和对应计划数据.** 多对多的关系的交叉引用表*/
@Entity(primaryKeys = ["id", "planId"])
data class UserPlanCrossRef(val id: Long,val planId: Long
)

您想如何查询这些相关实体：

如果想查询用户表和每个用户表所含计划的列表，则应创建一个新的数据类，其中包含单个 User 对象，以及该用户表所包含的所有 Plan 对象的列表。
如果想查询计划表和每个计划所在用户表的列表，则应创建一个新的数据类，其中包含单个 Plan 对象，以及包含该计划的所有 User 对象的列表。

在这两种情况下，都可以通过以下方法在实体之间建立关系：在上述每个类中的 @Relation 注释中使用 associateBy 属性来确定提供 User 实体与 Plan 实体之间关系的交叉引用实体。

/*** 用户表对应的计划列表.*/
data class UserWithPlans(@Embedded val user: User,@Relation(parentColumn = "id",entityColumn = "planId",associateBy = Junction(UserPlanCrossRef::class))val plans: MutableList<Plan>
)/*** 计划表对应的用户列表.*/
data class PlanWithUsers(@Embedded val plan: Plan,@Relation(parentColumn = "planId",entityColumn = "id",associateBy = Junction(UserPlanCrossRef::class))val users: MutableList<User>
)

向 DAO 类添加一个方法，用于提供您的应用所需的查询功能。

getUserWithPlans：该方法会查询数据库并返回查询到的所有 UserWithPlans 对象。
getPlanWithUsers：该方法会查询数据库并返回查询到的所有 PlanWithUsers 对象。

这两个方法都需要 Room 运行两次查询，因此应为这两个方法添加 @Transaction 注释，以确保整个操作以原子方式执行。

/*** 用户和对应计划表数据库操作对象.*/
@Dao
interface UserPlanDao {/*** 查询用户和对应计划数据.** @return 用户和对应计划数据*/@Transaction@Query("SELECT *FROM user")fun getUserWithPlans(): List<UserWithPlans>/*** 查询计划和对应用户数据.** @return 查询计划和对应用户数据*/@Transaction@Query("SELECT *FROM `plan`")fun getPlanWithUsers(): List<PlanWithUsers>
}

注意：如果 @Relation 注释不适用于你的特定用例，可能需要在 SQL 查询中使用 JOIN 关键字来手动定义适当的关系。如需详细了解如何手动查询多个表，请参阅使用 Room DAO 访问数据。

4. 定义嵌套关系

嵌套关系请直接参考官方文档，一般不建议使用

定义嵌套关系

2.1.2 多重映射返回值类型

注意：Room 在 2.4 及更高版本中仅支持多重映射返回值类型。

在多重映射返回值类型方法中，无需定义任何其他数据类，而是根据所需的映射结构为您的方法定义多重映射返回值类型，并直接在 SQL 查询中定义实体之间的关系。

以下查询方法会返回 User 和 Work 实例的映射，用于表示指定用户和用户参与的所有工作

@Query("SELECT *FROM user JOIN work ON user.id = work.userId")
fun getUserWithWorks(): Map<User, List<Work>>

2.1.3 完整的数据库对象，需要将涉及到的数据表定义在

@Database(entities = [User::class, Work::class, Plan::class, UserPlanCrossRef::class], version = 1)

/*** 数据库.*/
@Database(entities = [User::class, Work::class, Plan::class, UserPlanCrossRef::class], version = 1)
abstract class TestDataBase : RoomDatabase() {/*** 用户表操作类.*/abstract fun userDao(): UserDao/*** 工作表操作类.*/abstract fun workDao(): WorkDao/*** 计划表操作类.*/abstract fun planDao(): PlanDao/*** 用户表和工作表操作类.*/abstract fun userWorkDao(): UserWorkDao/*** 用户表和计划表操作类.*/abstract fun userPlanDao(): UserPlanDao
}

示例代码：

PractiseProject

参考

1. Room使用官方文档（https://developer.android.com/?hl=zh-cn）

2. Room使用中文官方文档（Android 开发者 | Android Developers）