Obtaining a base entity in extended entity in Slick - mysql

Question

I'm figuring out my way into Scala 2.11 with Slick 2.1.0. I've got two entities persons and users with users extending person. How can i have a projection in users that would allow fetching person as part of users everytime i fetch a user entity.
Here are the entity classes
import scala.slick.driver.MySQLDriver.simple._
case class Person(
id: Option[Long],
name: String,
createdAt: Option[java.sql.Timestamp],
deletedAt: Option[java.sql.Timestamp]
);
class Persons(tag: Tag) extends Table[Person](tag, "persons") {
def id = column[Long]("id", O.PrimaryKey, O.AutoInc)
def name = column[String]("name", O.NotNull)
def createdAt = column[java.sql.Timestamp]("created_at")
def deletedAt = column[java.sql.Timestamp]("deleted_at")
def * = (
id.?,
name,
createdAt.?,
deletedAt.?) <> (Person.tupled, Person.unapply)
}
and
import scala.slick.driver.MySQLDriver.simple._
case class User(
id: Option[Long],
personId: Long,
active: Boolean,
createdAt: Option[java.sql.Timestamp],
modifiedAt: Option[java.sql.Timestamp],
deletedAt: Option[java.sql.Timestamp]
);
class Users(tag: Tag) extends Table[User](tag, "users") {
def id = column[Long]("id", O.PrimaryKey, O.AutoInc)
def personId = column[Long]("person_id", O.NotNull)
def active = column[Boolean]("active")
def createdAt = column[java.sql.Timestamp]("created_at")
def modifiedAt = column[java.sql.Timestamp]("modified_at")
def deletedAt = column[java.sql.Timestamp]("deleted_at")
def * = (
id.?,
personId,
active,
createdAt.?,
modifiedAt.?,
deletedAt.?) <> (User.tupled, User.unapply)
def person = foreignKey(
"user_person_fk",
personId,
TableQuery[Users])(_.id)
}
Now when i query using
val users = TableQuery[Users]
def loadAll: Option[List[Any]] = {
db withDynSession {
val query = for {
u <- users
p <- u.person
} yield (u,p)
var result = query.list map {
case (u, p) => Map("user" -> u, "person" -> p)
}
return Option(result)
}
}
I get,
List[Map:("user" -> User, "person" -> Person)]
Is there a way i can use a projection or map to get person as part of User.

Answer 1

Instead of mapping your tables using <>, you can transform them after executing the query into whatever shape you like and then map them to case classes using .map.
HOWEVER: This is not recommended practice. Best practice with Slick is to keep foreign keys in your case classes and associate case classes only using tuples (or equivalent named association classes as EndeNeu suggests). Having user embed Person directly takes away some flexibility from you. To quote the Slick manual:
From: http://slick.typesafe.com/doc/2.1.0/orm-to-slick.html#relationships
case class Address( … )
case class Person( …, address: Address )
The problem is that this hard-codes that to exist, a Person requires an Address. It can not be loaded without it. This does’t fit to Slick’s philosophy of giving you fine-grained control over what you load exactly. With Slick it is advised to map one table to a tuple or case class without them having object references to related objects. Instead you can write a function that joins two tables and returns them as a tuple or association case class instance, providing an association externally, not strongly tied one of the classes.
val tupledJoin: Query[(People,Addresses),(Person,Address), Seq]
= people join addresses on (_.addressId === _.id)
case class PersonWithAddress(person: Person, address: Address)
val caseClassJoinResults = tupledJoin.run map PersonWithAddress.tupled
Also be aware that unlike with some ORMs, Slick makes it very easy to write queries with finer granularity than whole rows for better performance. See
http://slick.typesafe.com/doc/2.1.0/orm-to-slick.html#query-granularity