Slick 3.0 запрос «многие ко многим» с объединением в качестве итерируемого

Я создал коллекцию «многие ко многим», используя Slick 3.0, но я изо всех сил пытаюсь получить данные так, как я хочу.

Между событиями и интересами существует отношение многих ко многим. Вот мои таблицы:

case class EventDao(title: String,
                    id: Option[Int] = None)


class EventsTable(tag: Tag)
  extends Table[EventDao](tag, "events") {

  def id = column[Int]("event_id", O.PrimaryKey, O.AutoInc)
  def title = column[String]("title")

  def * = (
    title,
    id.?) <> (EventDao.tupled, EventDao.unapply)

  def interests = EventInterestQueries.query.filter(_.eventId === id)
    .flatMap(_.interestFk)
}


object EventQueries {

  lazy val query = TableQuery[EventsTable]

  val findById = Compiled { k: Rep[Int] =>
    query.filter(_.id === k)
  }
}

Вот События Интересы:

case class EventInterestDao(event: Int, interest: Int)


class EventsInterestsTable(tag: Tag)
  extends Table[EventInterestDao](tag, "events_interests") {

  def eventId = column[Int]("event_id")
  def interestId = column[Int]("interest_id")

  def * = (
    eventId,
    interestId) <> (EventInterestDao.tupled, EventInterestDao.unapply)

  def eventFk = foreignKey("event_fk", eventId, EventQueries.query)(e => e.id)
  def interestFk = foreignKey("interest_fk", interestId, InterestQueries.query)(i => i.id)
}


object EventInterestQueries {
  lazy val query = TableQuery[EventsInterestsTable]
}

И напоследок Интересы:

case class InterestDao(name: String,
                       id: Option[Int] = None)

class InterestsTable(tag: Tag)
  extends Table[InterestDao](tag, "interests") {

  def id = column[Int]("interest_id", O.PrimaryKey, O.AutoInc)
  def name = column[String]("name")
  def name_idx = index("idx_name", name, unique = true)

  def * = (
    name,
    id.?) <> (InterestDao.tupled, InterestDao.unapply)

  def events = EventInterestQueries.query.filter(_.interestId === id)
    .flatMap(_.eventFk)
}


object InterestQueries {

  lazy val query = TableQuery[InterestsTable]

  val findById = Compiled { k: Rep[Int] =>
    query.filter(_.id === k)
  }
}

Я могу запросить и получить кортежи (event.name, интерес) с помощью следующего:

val eventInterestQuery = for {
  event <- EventQueries.query
  interest <- event.interests
} yield (event.title, interest.name)

Await.result(db.run(eventInterestQuery.result).map(println), Duration.Inf)

Так что это то, что у меня сейчас есть.

То, что я хочу, это иметь возможность заполнять класс case, как:

case class EventDao(title: String,
                interests: Seq[InterestDao],
                id: Option[Int] = None)

Проблема в том, что если я обновлю свой класс дел таким образом, это испортит мойdef * проекция вEventsTable, Кроме того, мне придется переименоватьEventsTable.interests фильтровать что-то вродеEventsTable.interestIds что немного уродливо, но я мог бы жить с ним, если это необходимо.

Кроме того, я не могу найти способ написанияfor запрос, который дает(event.name, Seq(interest.name)), Во всяком случае, это всего лишь ступенька для меня, чтобы быть в состоянии дать(EventDao, Seq(InterestDao)) кортеж, который я действительно хочу вернуть.

Кто-нибудь знает, как мне этого добиться? Я также хочу иметь возможность «забрать» определенное количество интересов, поэтому для некоторых запросов все будет возвращено, а для других - только первые 3.

Ответы на вопрос(2)

Ваш ответ на вопрос