Slick junta duas tabelas e obtém o resultado de ambas

9

Eu tenho uma configuração de relacionamento Muitos para Muitos assim:

Pessoa < - > PersonField < - > Field

Agora eu quero consultar não apenas todos os campos de uma pessoa (eu posso fazer isso), mas uma versão unida de PersonField com o campo de uma pessoa. (Eu quero consultar / recuperar as informações na Tabela Pivô / Intermediário "PersonField" também!)

Pessoa:

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

Agora, para consultar todos os campos de uma pessoa, tenho uma pequena classe auxiliar:

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

Então eu posso fazer

val personX ...

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

Agora, cada campo do personX é impresso no console. Funciona como um encanto.

A coisa é, eu quero pegar o PersonField também (com o Field)!

Então eu tentei as seguintes alterações (entre outras que não funcionaram, que não consigo lembrar)

Em Pessoa :

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

Em PersonS

def fields = PersonFields.all.filter(_.personID === id) // Não flatMap aqui!

então getFields (p: Person) se parece com isto:

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

mas

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

não me dá nada, então acho que minha participação deve estar errada. Mas o que exatamente estou fazendo errado?

    
por Sorona 09.09.2015 в 00:14
fonte

1 resposta

2

Você pode unir todos os três e gerar o resultado

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)

(Não tenho certeza se recebi exatamente o que você estava tentando tirar da consulta, para que você possa editar a parte de produção)

    
por Liza Shakury 29.12.2015 / 15:11
fonte