Abbiamo bisogno di fare due cose. Prima trova un modo per mappare la gerarchia su una tabella. In questo caso sto usando una colonna che memorizza il tipo. Ma puoi usare anche altri trucchi.
trait Base {
val a: Int
val b: String
}
case class ChildOne(val a: Int, val b: String, val c: String) extends Base
case class ChildTwo(val a: Int, val b: String, val d: Int) extends Base
class MyTable extends Table[Base]("SOME_TABLE") {
def a = column[Int]("a")
def b = column[String]("b")
def c = column[String]("c", O.Nullable)
def d = column[Int]("d", O.Nullable)
def e = column[String]("model_type")
//mapping based on model type column
def * = a ~ b ~ c.? ~ d.? ~ e <> ({ t => t match {
case (a, b, Some(c), _, "ChildOne") => ChildOne(a, b, c)
case (a, b, _, Some(d), "ChildTwo") => ChildTwo(a, b, d)
}}, {
case ChildOne(a, b, c) => Some((a, b, Some(c), None, "ChildOne"))
case ChildTwo(a, b, d) => Some((a, b, None, Some(d), "ChildTwo"))
})
}
}
Ora per determinare specifico tipo di sub che si può fare seguente:
Query(new MyTable).foreach {
case ChildOne(a, b, c) => //childone
case ChildTwo(a, b, d) => childtwo
}
Slick è _not_ un ORM! Se si ha uno schema progettato attorno ad un tipo di modello ORM con ereditarietà, probabilmente si otterrà l'intero problema di errata corrispondenza dell'impedenza quando si tenta di usarlo in Slick ... –
So che non è un ORM , ma per un framework che ti dà qualche forma di mappatura dell'oggetto riga <->, mi chiedo se tali casi di ereditarietà siano presi in considerazione nella soluzione –