Slick iki tabloyu birleştirmek ve bu gibi birçok ilişki kurmak için bir çoğu var hem

Question

sonucunu almak:

Kişi < -> PersonField < -> Tarla

Şimdi sadece tüm alanları sorgulamak istiyorum Bir Kişinin (bunu yapabilirim), ancak PersonField'ın bir Kişi Alanı ile birleştirilmiş hali. (G/sorgulamak yanı Pivot/Orta Tablo "PersonField" Bilgiyi almak istiyorum!)

Kişi:

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

Alanı:

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

Bir Kişinin tüm alanlarını sorgulamak için şimdi küçük bir yardımcı sınıfım var:

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

yüzden

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

Şimdi personX her alan konsoluna basılmış olur ...

val personX

yapabilirsiniz. ÇALIŞIYOR bir cazibe gibi.

Sorun şu ki, PersonField'ı da (Saha ile) almak istiyorum!

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

bulunan kişileri

:

yüzden Kişi yılında (hatırlayamıyorum işe yaramadı diğerleri arasında,) aşağıdaki değişiklikleri

çalıştı def fields = PersonFields.all.filter(_.personID === id) // Burada flatMap yok!

sonra getFields (p: Person):

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

ama

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

bana hiçbir verir, bu yüzden benim yanlış olmalı katılmak tahmin buna benzer. Ama tam olarak ne yapıyorum yanlış?

Answer 1

üçünü birden katılabilir, daha sonra (ben sadece verim kısmını düzenlemek böylece, sorgunun kurtulmaya çalışıyorum tam olarak ne var emin değilim)

sonucu

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) 

verim