Android 房间数据库，用列表构造和查询实体

这是我的设置。我有一个WorkoutPlan对象，其中可以包含一个训练对象列表。我目前建模的方式是使用第三个表来处理两者之间的映射。一个训练计划可以包含许多训练，一个训练可以被许多训练计划使用

@Entity(tableName = "workoutPlans")
data class DbWorkoutPlan(@ColumnInfo(name = "name")
                         val name: String,
                         @ColumnInfo(name = "date")
                         val date: Date) {

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id: Int = 0
}

@Entity(tableName = "workouts")
data class DbWorkout(@ColumnInfo(name = "name")
                     val name: String,
                     @ColumnInfo(name = "date")
                     val data: Date) {

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id: Int = 0
}

@Entity(tableName = "DbWorkoutPlanWorkoutJoin",
    primaryKeys = arrayOf("workoutPlanId", "workoutId"),
    foreignKeys = arrayOf(ForeignKey(entity = DbWorkoutPlan::class,
                                     parentColumns = arrayOf("id"),
                                     childColumns = arrayOf("workoutPlanId")),
                          ForeignKey(entity = DbWorkout::class,
                                     parentColumns = arrayOf("id"),
                                     childColumns = arrayOf("workoutId"))))
data class DbWorkoutPlanWorkoutJoin(@ColumnInfo(name = "workoutPlanId")
                                    val workoutPlanId: Int,
                                    @ColumnInfo(name = "workoutId")
                                    val workoutId: Int)

这就是我对表格的数据设置。我不确定它是否正确。在返回的数据端，我有这个

data class DbWorkoutPlanResult(@Embedded
                               val workoutPlan: WorkoutPlan,
                               @Relation(parentColumn = "id", entityColumn = "workoutId")
                               val workoutIds: List<DbWorkout>)

数据类DbWorkoutPlanResult（@Embedded
val工作计划：工作计划，
@关系（parentColumn=“id”，entityColumn=“workUtid”）
val（用户ID：列表）

因此，我想返回一个DbWorkoutPlanResult，其中包含一个WorkoutPlan及其所有训练的列表

我知道我做得不对，而且复杂性正在迅速增加。有人知道我在设置中做错了什么吗？我要问什么？我最好的尝试就是这样

@Query("SELECT * " +
               "FROM DbWorkoutPlanWorkoutJoin " +
               "INNER JOIN workoutPlans " +
               "ON DbWorkoutPlanWorkoutJoin.workoutPlanId = workoutPlans.id " +
               "INNER JOIN workouts " +
               "ON DbWorkoutPlanWorkoutJoin.workoutId = workouts.id ")
fun getWorkoutPlans(): Flowable<List<DbWorkoutPlanResult>>

@Query（“选择*”+
“来自DbWorkoutPlanWorkoutJoin”+
“内部联接计划”+
“在DbWorkoutPlanWorkoutJoin.workoutPlanId=workoutPlans.id上”+
“内部连接训练”+
“在DbWorkoutPlanWorkoutJoin.workoutId=workouts.id上”）
fun getWorkoutPlans（）：可流动

提前感谢。

使用注释可以创建1:N（一对多）关系。比如，在您的情况下，一个计划可以有多个训练，但每个训练只能属于一个计划。这显然不是你想要的

对于您的需求，我假设是这样的：获取包含

计划的
POJO
列表和相关的
训练列表，您需要使用一个单独的联接表（我想您已经是了）

获取结果的简单方法是将操作分为两个查询：

获取所有计划的
列表
查询联接表并获取每个
DbWorkoutPlan

示例代码
首先定义模型

@Entity(tableName="plans") class DbWorkoutPlan {
  @PrimaryKey
  private long id;
  // ...

  @Ignore private List<DbWorkout>; // do not persist this, also create getter/setter for this field
}

@Entity(tableName="workouts") class DbWorkout {
  @PrimaryKey
  private long id;
  // ...
}

@Entity(
  tableName="plan_workout_join"
  primaryKeys = {"workoutPlanId", "workoutId"},
  foreignKeys = {
    @ForeignKey(entity = DbWorkoutPlan.class, parentColumns = "id", childColumns = "plan"),
    @ForeignKey(entity = DbWorkout.class, parentColumns = "id", childColumns = "workout")
  }
) class PlanWorkoutJoin {
  private long plan;
  private long workout;
}

现在你可以这样查询

List<DbWorkoutPlan> plans = dao.getAllPlans();
for(DbWorkoutPlan plan : plans){
  List<DbWorkout> workouts = dao.getWorkoutsForPlan(plan.getId());
  plan.setWorkouts(workouts);
}
// ... continue

List plans=dao.getAllPlans（）；
对于（DbWorkoutPlan计划：计划）{
List workouts=dao.getWorkoutsForPlan（plan.getId（））；
计划。设置训练（训练）；
}
// ... 持续

另外，如果您使用的是RxJava，您显然需要对此进行一些修改，但核心思想保持不变
使用注释您可以创建一个1:N（一对多）关系。比如，在您的情况下，一个计划可以有多个训练，但每个训练只能属于一个计划。这显然不是你想要的

对于您的需求，我假设是这样的：获取包含
计划的
POJO
列表和相关的
训练列表，您需要使用一个单独的联接表（我想您已经是了）

获取结果的简单方法是将操作分为两个查询：

获取所有计划的
列表
查询联接表并获取每个
DbWorkoutPlan

示例代码
首先定义模型

@Entity(tableName="plans") class DbWorkoutPlan {
  @PrimaryKey
  private long id;
  // ...

  @Ignore private List<DbWorkout>; // do not persist this, also create getter/setter for this field
}

@Entity(tableName="workouts") class DbWorkout {
  @PrimaryKey
  private long id;
  // ...
}

@Entity(
  tableName="plan_workout_join"
  primaryKeys = {"workoutPlanId", "workoutId"},
  foreignKeys = {
    @ForeignKey(entity = DbWorkoutPlan.class, parentColumns = "id", childColumns = "plan"),
    @ForeignKey(entity = DbWorkout.class, parentColumns = "id", childColumns = "workout")
  }
) class PlanWorkoutJoin {
  private long plan;
  private long workout;
}

现在你可以这样查询

List<DbWorkoutPlan> plans = dao.getAllPlans();
for(DbWorkoutPlan plan : plans){
  List<DbWorkout> workouts = dao.getWorkoutsForPlan(plan.getId());
  plan.setWorkouts(workouts);
}
// ... continue

List plans=dao.getAllPlans（）；
对于（DbWorkoutPlan计划：计划）{
List workouts=dao.getWorkoutsForPlan（plan.getId（））；
计划。设置训练（训练）；
}
// ... 持续

另外，如果您使用的是RxJava，显然需要对此进行一些修改，但核心思想保持不变
非常感谢您提供了如此完整的答案！结果很好。非常感谢您给出如此完整的答案！结果很好。