Slick unire due tavoli e ottenere risultato sia

Question

Ho un molti a molti di impostazione rapporto in questo modo:

persona < -> PersonField < -> Campo

Ora voglio interrogare non solo tutti i campi di una persona (posso farlo), ma una versione congiunta di PersonField con Field of a Person. (Voglio interrogare/recuperare le informazioni nel pivot/Intermedio Tabella "PersonField", come pure!)

Persona:

case class Person(id: Long, name: String) 
{ 
    def fields = 
    { 
     person <- Persons.all.filter(_.id === this.id) 
     field <- person.fields 
    } yield field 
} 

class Persons(tag: Tag) extends Table[Person](tag, "persons") 
{ 
    def id = column[Long]("id", O.PrimaryKey, O.AutoInc) 
    def name = column[String]("name") 

    def * = (id, name) <> (Person.tupled, Person.unapply) 
    def fields = PersonFields.all.filter(_.personID === id).flatMap(_.fieldFK) 
} 

object Persons 
{ 
    lazy val all = TableQuery[Persons] 
} 

campo:

case class Field(id: Long, name: String, description: Option[String]) 

class Fields(tag: Tag) extends Table[Field](tag, "fields") 
{ 
    def id = column[Long]("id", O.PrimaryKey, O.AutoInc) 
    def name = column[String]("name") 
    def description = column[Option[String]]("description") 

    def * = (id, name, description) <> (Field.tupled, Field.unapply) 
} 

object Fields 
{ 
    lazy val all = TableQuery[Fields] 
} 

PersonField:

case class PersonField(id: Long, personID: Long, fieldID: Long, value: String) 

// TODO add constraint to make (personID, fieldID) unique 
class PersonFields(tag: Tag) extends Table[PersonField](tag, "person_field") 
{ 
    def id = column[Long]("id", O.PrimaryKey, O.AutoInc) 
    def personID = column[Long]("person_id") 
    def fieldID = column[Long]("field_id") 
    def value = column[String]("value") 

    def * = (id, personID, fieldID, value) <> (PersonField.tupled, PersonField.unapply) 

    def personFK = foreignKey("person_fk", personID, Persons.all)(_.id) 
    def fieldFK = foreignKey("field_fk", fieldID, Fields.all)(_.id) 
} 

object PersonFields 
{ 
    lazy val all = TableQuery[PersonFields] 
} 

Ora per interrogare tutti i campi di una persona ho una piccola classe di supporto:

def getFields(p: Person): Future[Seq[Field]] = 
{ 
    val query = p.fields 
    db.run(query.result) 
} 

Così posso fare

val personX ...

personX.onSuccess 
{ 
    case p: Person => 
    { 
     val fields = helper.getFields(p) 
     fields.onSuccess 
     { 
      case f: Seq[Field] => f foreach println 
     } 
    } 
} 

Ora ogni campo della personX viene stampato alla console. Funziona come un fascino.

Il fatto è che voglio ottenere anche il PersonField (con il campo)!

Così ho provato le seguenti modifiche (tra gli altri che non hanno funzionato, che non riesco a ricordare)

In persona:

def fields = 
{ 
    for 
    { 
     person <- Persons.all.filter(_.id === this.id) 
     field <- person.fields join Fields.all on (_.fieldID === _.id) 
    } yield field 
} 

In persone

def fields = PersonFields.all.filter(_.personID === id) // No flatMappa qui!

poi getFields (p: Person) si presenta così:

def getFields(p: Person): Future[Seq[(PersonField, Field)]] 

ma

personX.onSuccess 
{ 
    case p: Person => 
    { 
     val fields = helper.getFields(p) 
     fields.onSuccess 
     { 
      case f: Seq[(PersonField, Field)] => f map(f => println(f._1)} 
     } 
    } 
} 

mi dà nulla, quindi credo che il mio aderire deve essere sbagliato. Ma cosa sto facendo di sbagliato?

Answer 1

È possibile partecipare a tutte e tre, poi cedere il risultato

for { 
     ((personField, person), field) <- PersonFields.all join Persons.all on (_.personId === _.id) join Fields.all on (_._1.fieldId === _.id) 
     if person.id === this.id 
    } yield (personField, person, field) 

(non sono sicuro ho ottenuto esattamente quello che stavi cercando di uscire della query, in modo da poter semplicemente modificare la parte resa)