He creado una colección de muchos a muchos usando Slick 3.0, pero estoy luchando por recuperar los datos de la manera que quiero.

Existe una relación de muchos a muchos entre eventos e intereses. Aquí están mis tablas:

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

Aquí hay eventos de interés:

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

Y finalmente Intereses:

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

Puedo consultar y recuperar tuplas de (evento.nombre, interés) con lo siguiente:

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

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

Entonces esto es lo que tengo actualmente.

Lo que quiero es poder completar una clase de caso como:

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

El problema es que si actualizo mi clase de caso de esta manera, arruina midef * proyección enEventsTable. Además, tendré que cambiar el nombre delEventsTable.interests filtrar a algo comoEventsTable.interestIds lo cual es un poco feo pero podría vivir si fuera necesario.

Además, no puedo encontrar una manera de escribir unfor consulta que rinde(event.name, Seq(interest.name)). De todos modos, eso es solo un trampolín para que yo pueda rendir un(EventDao, Seq(InterestDao)) tupla que es lo que realmente quiero devolver.

¿Alguien sabe cómo puedo lograr estas cosas? También quiero poder 'tomar' una cierta cantidad de intereses, por lo que para algunas consultas se devolverán todas, pero para otras solo se recibirán las 3 primeras.