Criei uma coleção muitos-para-muitos usando o Slick 3.0, mas estou lutando para recuperar dados da maneira que desejo.

Há uma relação de muitos para muitos entre eventos e interesses. Aqui estão as minhas tabelas:

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)
  }
}

Aqui está EventsInterests:

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]
}

E finalmente Interesses:

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)
  }
}

Posso consultar e recuperar tuplas de (event.name, interest) com o seguinte:

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

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

Então é isso que eu tenho atualmente.

O que eu quero é poder preencher uma classe de caso como:

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

O problema é que, se eu atualizar minha classe de caso dessa maneira, ela estragará minhadef * projeção emEventsTable. Além disso, terei que renomear oEventsTable.interests filtrar para algo comoEventsTable.interestIds que é um pouco feio, mas eu poderia conviver, se necessário.

Além disso, não consigo encontrar uma maneira de escrever umfor consulta que gera(event.name, Seq(interest.name)). De qualquer forma, isso é apenas um trampolim para eu poder produzir um(EventDao, Seq(InterestDao)) tupla que é o que eu realmente quero retornar.

Alguém sabe como eu posso conseguir essas coisas? Também quero poder 'pegar' um certo número de interesses, portanto, para algumas consultas, tudo seria retornado, mas para outras, apenas as três primeiras seriam.