Отношения «многие ко многим» с Room & LiveData

Question

У меня есть api rest, который возвращает список мест, в которых есть список категорий:

{
      "id": "35fds-45sdgk-fsd87",
      "name" : "My awesome place",
       "categories" : [
          {
            "id": "cat1",
            "name" : "Category 1"
          },
          {
            "id": "cat2",
            "name" : "Category 2"
          },
          {
            "id": "cat3",
            "name" : "Category 3"
          }
       ]
}

Поэтому, используя модернизацию, я получаю их с удаленного сервера с этими классами моделей:

data class Category(var id: String, var name: String)

data class Place(
  var id: String,
  var name: String,
  var categories: List<Category>
)

Проблема в том, что я хочу, чтобы viewModel всегда извлекал данные из локальной базы данных комнат, возвращая Flowables, и просто запускал действия по обновлению, которые обновят базу данных и, следовательно, представление.

Пример метода DAO:

@Query("select * from Places where placeId = :id")
fun getPlace(id: String): Flowable<Place>

Поэтому я попытался смоделировать эти два класса следующим образом:

@Entity
data class Category(var id: String, var name: String)


@Entity
data class Place(
  @PrimaryKey
  var id: String,
  var name: String,
  var categories: List<Category>
)

Но, конечно, Room не может обрабатывать отношения самостоятельно.Я видел этот пост , который просто извлекает из локальной базы данных предыдущий список городов, но этот случай не соответствует этому.

Единственный вариант, о котором я могу подумать, - это сохранить категории в базе данных в виде строки JSON, но при этом теряется реляционное качество базы данных ...

Это кажется довольно распространенным использованием.дело, но я не нашел много информации об этом.

Answer 1

У меня был похожий вариант использования.Поскольку Room не управляет отношениями, я решил использовать это решение в блоге, о котором вы упомянули: /

@Entity
data class Category(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    var catId: String, 
    var name: String,
    @ForeignKey(entity = Place::class, parentColumns = ["id"], childColumns = ["placeId"], onDelete = ForeignKey.CASCADE)
    var placeId: String = ""
)

@Entity
data class Place(
    @PrimaryKey
    var id: String,
    var name: String,
    @Ignore var categories: List<Category>
)

PlaceDao

@Dao
interface PlaceDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insert(place: Place)

    @Query("SELECT * FROM place WHERE id = :id")
    fun getPlace(id: String?): LiveData<Place>
}

fun AppDatabase.getPlace(placeId: String): LiveData<Place> {
    var placeLiveData = placeDao().getPlace(placeId)
    placeLiveData = Transformations.switchMap(placeLiveData, { place ->
        val mutableLiveData = MutableLiveData<Place>()
        Completable.fromAction { // cannot query in main thread
            place.categories = categoryDao().get(placeId)
        }
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe { mutableLiveData.postValue(place) }
        mutableLiveData
    })
    return placeLiveData
}

// run in transaction
fun AppDatabase.insertOrReplace(place: Place) {
    placeDao().insert(place)
    place.categories?.let {
        it.forEach {
            it.placeId = place.id
        }
        categoryDao().delete(place.id)
        categoryDao().insert(it)
    }
}

CategoryDao

@Dao
interface CategoryDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insert(categories: List<Category>)

    @Query("DELETE FROM category WHERE placeId = :placeId")
    fun delete(placeId: String?)

    @Query("SELECT * FROM category WHERE placeId = :placeId")
    fun get(placeId: String?): List<Category>
}

Не большой поклонник, но я не нашел лучшего способа на данный момент.

Answer 2

В комнате можно иметь отношения многие ко многим.

Сначала добавьте аннотацию @Ignore в свой класс Place.Он скажет Room игнорировать это свойство, поскольку не может сохранить список объектов без конвертера.

data class Category(
        @PrimaryKey var id: String, 
        var name: String
)

data class Place(
        @PrimaryKey var id: String,
        var name: String,
        @Ignore var categories: List<Category>
) 

Затем создайте класс, который будет представлять связь между этими двумя классами.

@Entity(primaryKeys = ["place_id", "category_id"],
        indices = [
            Index(value = ["place_id"]),
            Index(value = ["category_id"])
        ],
        foreignKeys = [
            ForeignKey(entity = Place::class,
                    parentColumns = ["id"],
                    childColumns = ["place_id"]),
            ForeignKey(entity = Category::class,
                    parentColumns = ["id"],
                    childColumns = ["category_id"])
        ])
data class CategoryPlaceJoin(
        @ColumnInfo(name = "place_id") val placeId: String,
        @ColumnInfo(name = "category_id") val categoryId: String
)

Как видите, я использовал внешние ключи.

Теперь вы можете указать специальный DAO для получения списка категорий для места.

@Dao
interface PlaceCategoryJoinDao {

    @SuppressWarnings(RoomWarnings.CURSOR_MISMATCH)
    @Query("""
        SELECT * FROM category INNER JOIN placeCategoryJoin ON
        category.id = placeCategoryJoin.category_id WHERE
        placeCategoryJoin.place_id = :placeId
        """)
    fun getCategoriesWithPlaceId(placeId: String): List<Category>

    @Insert
    fun insert(join: PlaceCategoryJoin)
}

И последнее, что важновставлять объединяемый объект каждый раз, когда вы вставляете новый Place.

val id = placeDao().insert(place)
for (place in place.categories) {
   val join = CategoryPlaceJoin(id, category.id)
   placeCategoryJoinDao().insert(join)
}

Теперь, когда вы получаете места из placeDao(), у них есть пустой список категорий.Чтобы добавить категории, вы можете использовать эту часть кода:

fun getPlaces(): Flowable<List<Place>> {
    return placeDao().getAll()
            .map { it.map { place -> addCategoriesToPlace(place) } }
}

private fun addCategoriesToPlace(place: Place): Place {
    place.categories = placeCategoryJoinDao().getCategoriesWithPlaceId(place.id)
    return place
}

Чтобы увидеть больше деталей, см. эту статью .

Answer 3

Только не используйте один и тот же класс для ваших Entity и Place, которые вы выбираете из сети.

Пахнет плохо связывать логику вашего класса со структурой API.

Когда вы извлекаете данные из сети, просто создайте новые объекты Places и сохраните их в БД.