Mapped projection with <> to a case class with companion object in Slick

Question

With Slick, I am trying to project database table entries directly to the case class they represent. Following the example in the documentation, I set up a mapped projection using the <> operator:

case class SomeEntity3(id: Int, entity1: Int, entity2: Int)

val SomeEntityTable = new Table[SomeEntity3]("some_entity_table") {
  def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
  def entity1 = column[Int]("entity1")
  def entity2 = column[Int]("entity2")

  def * = id ~ entity1 ~ entity2 <> (SomeEntity3, SomeEntity3.unapply _)
}

Now, I'd like to add some static constants and auxiliary methods to SomeEntity3. For that, I create a companion object. But as soon as I include the line

object SomeEntity3

a pretty wild multi-line error pops up for the definition of * saying something illegible about "overloaded method value <> with alternatives".

How does the companion object relate to bi-directional mapping in Slick and can I somehow accomplish my goal?

score 9 · Answer 1 · answered Mar 02 '13 at 15:28

9

The fix is quite simple:

def * = id ~ entity1 ~ entity2 <> (SomeEntity3.apply _, SomeEntity3.unapply _)

answered Mar 02 '13 at 15:28

pedrofurla

12,763
1
38
49

This does work, indeed. Any explanation on why spelling apply out explicitly is needed and fixes the problem here? – notan3xit Mar 03 '13 at 13:27
1

Explicitly turning the apply method into a function (eta expansion) yields `(Int, Int, Int) => SomeEntity3`, i.e. the type that the companion object should be in the first place. More generally, turning a function object's apply method into a "new" function object yields the same type as the original function. – Mar 03 '13 at 13:36
For some reason scalac gets confused when you have a companion object and doesn't lifts the object's apply. – pedrofurla Mar 03 '13 at 14:03

score 8 · Accepted Answer · answered Mar 03 '13 at 12:29

Companion objects of case classes usually are a function from the case class' first argument list to the case class. So if you had

case class Fnord(a: A, b: B, c: C)(d: D)

the Scala compiler would autogenerate the companion object similar to

object Fnord extends ((A, B, C) => Fnord) {
  ...
}

Now, as soon as you explicitly spell out something about the companion object yourself, the compiler no longer generates the FunctionN extending thingy. Thus, most of the time it is a good idea to add it yourself. In your case that would mean defining the companion of SomeEntity3 like so:

object SomeEntity3 extends ((Int, Int, Int) => SomeEntity3) {
  ...
}

There's a (long open) issue for this behaviour, too: https://issues.scala-lang.org/browse/SI-3664

score 1 · Answer 3 · answered May 29 '14 at 20:58

Another way to do it is to turn the objects apply method into a tuple and pass that to the <> as shown below.

package models

import play.api._
import play.api.libs.json._
import scala.slick.driver.H2Driver.simple._

case class User(
  name: String,
  id: Option[Int] = None
)

object User {
  implicit val format = Json.format[User]
}

class UserTable(tag: Tag) extends Table[User](tag, "USERS") {
  def id = column[Int]("ID", O.PrimaryKey, O.AutoInc)
  def name = column[String]("NAME", O.NotNull)

  def * = (name, id.?) <> ((User.apply _).tupled, User.unapply)
}

object Users extends TableQuery(new UserTable(_)) {
  val findByID = this.findBy(_.id)
}

score 0 · Answer 4 · edited May 23 '17 at 12:14

Personally, the partially applied apply method from the case class does not work with my setup and Slick 3.0.

This however, works, burrowing to the proper tupled method indirectly:

class WidgetTable(tag: Tag) extends Table[WidgetEntity](tag, "widget_tbl") {

    def id = column[Int]("id",O.PrimaryKey)
    def foo = column[String]("foo")

    override def * = (id,foo) <> ((WidgetEntity.apply _).tupled,WidgetEntity.unapply)
}

See the full details: https://stackoverflow.com/a/38589579/564157

Mapped projection with <> to a case class with companion object in Slick

4 Answers4

Linked