Generate Fast Path Converters in `.mapTo`

slick-testkit/src/main/scala/com/typesafe/slick/testkit/tests/JdbcMapperTest.scala

@@ -406,10 +406,11 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
     class T(tag: Tag) extends Table[Data](tag, "T_fastpath") {
       def a = column[Int]("A")
       def b = column[Int]("B")
-      def * = (a, b).mapTo[Data].fastPath(new FastPath(_) {
+      def * = (a, b).<>(Data.tupled, Data.unapply _).fastPath(new FastPath(_) {
         val (a, b) = (next[Int], next[Int])
         override def read(r: Reader) = Data(a.read(r), b.read(r))
       })
+      def auto = (a, b).mapTo[Data]
     }
     val ts = TableQuery[T]
 
@@ -418,7 +419,8 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
       ts ++= Seq(new Data(1, 2), new Data(3, 4), new Data(5, 6)),
       ts.filter(_.a === 1).update(Data(7, 8)),
       ts.filter(_.a === 3).map(identity).update(Data(9, 10)),
-      ts.to[Set].result.map(_ shouldBe Set(Data(7, 8), Data(9, 10), Data(5, 6)))
+      ts.to[Set].result.map(_ shouldBe Set(Data(7, 8), Data(9, 10), Data(5, 6))),
+      ts.map(_.auto).to[Set].result.map(_ shouldBe Set(Data(7, 8), Data(9, 10), Data(5, 6)))
     )
   }
 }

slick/src/main/scala/slick/ast/Type.scala

@@ -217,7 +217,7 @@ final class MappedScalaType(val baseType: Type, val mapper: MappedScalaType.Mapp
 }
 
 object MappedScalaType {
-  case class Mapper(toBase: Any => Any, toMapped: Any => Any, fastPath: Option[PartialFunction[Any, Any]])
+  case class Mapper(toBase: Any => Any, toMapped: Any => Any, fastPath: Option[Any => Any])
 }
 
 /** The standard type for freshly constructed nodes without an explicit type. */

slick/src/main/scala/slick/jdbc/JdbcMappingCompilerComponent.scala

@@ -46,7 +46,7 @@ trait JdbcMappingCompilerComponent { driver: JdbcDriver =>
     override def createTypeMappingResultConverter(rc: ResultConverter[JdbcResultConverterDomain, Any], mapper: MappedScalaType.Mapper) = {
       val tm = new TypeMappingResultConverter(rc, mapper.toBase, mapper.toMapped)
       mapper.fastPath match {
-        case Some(pf) => pf.orElse[Any, Any] { case x => x }.apply(tm).asInstanceOf[ResultConverter[JdbcResultConverterDomain, Any]]
+        case Some(f) => f(tm).asInstanceOf[ResultConverter[JdbcResultConverterDomain, Any]]
         case None => tm
       }
     }

slick/src/main/scala/slick/lifted/Shape.scala

@@ -1,5 +1,7 @@
 package slick.lifted
 
+import slick.relational.{ProductResultConverter, SimpleFastPathResultConverter, ResultConverterDomain, TypeMappingResultConverter}
+
 import scala.language.{existentials, implicitConversions, higherKinds}
 import scala.language.experimental.macros
 import scala.annotation.implicitNotFound
@@ -289,34 +291,48 @@ object ShapedValue {
       case NoSymbol => q"${rSym.name.toTermName}" // This can happen for case classes defined inside of methods
       case s => q"$s"
     }
-    val caseFields =  rTag.tpe.decls.collect {
-      case s: TermSymbol if s.isVal && s.isCaseAccessor => (TermName(s.name.toString.trim), s.typeSignature)
+    val fields =  rTag.tpe.decls.collect {
+      case s: TermSymbol if s.isVal && s.isCaseAccessor => (TermName(s.name.toString.trim), s.typeSignature, TermName(c.freshName()))
     }.toIndexedSeq
     val (f, g) = if(uTag.tpe <:< c.typeOf[slick.collection.heterogeneous.HList]) { // Map from HList
-      val rTypeAsHList = caseFields.foldRight[Tree](tq"_root_.slick.collection.heterogeneous.HNil.type") {
-        case ((_, t), z) => tq"_root_.slick.collection.heterogeneous.HCons[$t, $z]"
+      val rTypeAsHList = fields.foldRight[Tree](tq"_root_.slick.collection.heterogeneous.HNil.type") {
+        case ((_, t, _), z) => tq"_root_.slick.collection.heterogeneous.HCons[$t, $z]"
       }
-      val matchNames = caseFields.map(_ => TermName(c.freshName()))
-      val pat = matchNames.foldRight[Tree](pq"_root_.slick.collection.heterogeneous.HNil") {
-        case (n, z) => pq"_root_.slick.collection.heterogeneous.HCons($n, $z)"
+      val pat = fields.foldRight[Tree](pq"_root_.slick.collection.heterogeneous.HNil") {
+        case ((_, _, n), z) => pq"_root_.slick.collection.heterogeneous.HCons($n, $z)"
       }
-      val cons = caseFields.foldRight[Tree](q"_root_.slick.collection.heterogeneous.HNil") {
-        case ((n, _), z) => q"v.$n :: $z"
+      val cons = fields.foldRight[Tree](q"_root_.slick.collection.heterogeneous.HNil") {
+        case ((n, _, _), z) => q"v.$n :: $z"
       }
-      (q"({ case $pat => new $rTag(..$matchNames) } : ($rTypeAsHList => $rTag)): ($uTag => $rTag)",
+      (q"({ case $pat => new $rTag(..${fields.map(_._3)}) } : ($rTypeAsHList => $rTag)): ($uTag => $rTag)",
        q"{ case v => $cons }: ($rTag => $uTag)")
-    } else if(caseFields.length == 1) { // Map from single value
+    } else if(fields.length == 1) { // Map from single value
       (q"($rModule.apply _) : ($uTag => $rTag)",
        q"(($rModule.unapply _) : $rTag => Option[$uTag]).andThen(_.get)")
     } else { // Map from tuple
       (q"($rModule.tupled) : ($uTag => $rTag)",
         q"(($rModule.unapply _) : $rTag => Option[$uTag]).andThen(_.get)")
     }
-    q"""val ff = $f // Resolving f first creates more useful type errors
-        new _root_.slick.lifted.MappedProjection[$rTag, $uTag](${c.prefix}.toNode,
-          _root_.slick.ast.MappedScalaType.Mapper($g.asInstanceOf[Any => Any], ff.asInstanceOf[Any => Any], _root_.scala.None),
-          $rCT
-        )"""
+
+    val fpName = Constant("Fast Path of ("+fields.map(_._2).mkString(", ")+").mapTo["+rTag.tpe+"]")
+    val fpChildren = fields.map { case (_, t, n) => q"val $n = next[$t]" }
+    val fpReadChildren = fields.map { case (_, _, n) => q"$n.read(r)" }
+
+    q"""
+      val ff = $f.asInstanceOf[_root_.scala.Any => _root_.scala.Any] // Resolving f first creates more useful type errors
+      val gg = $g.asInstanceOf[_root_.scala.Any => _root_.scala.Any]
+      val fpMatch: (_root_.scala.Any => _root_.scala.Any) = {
+        case tm @ _root_.slick.relational.TypeMappingResultConverter(_: _root_.slick.relational.ProductResultConverter[_, _], _, _) =>
+          new _root_.slick.relational.SimpleFastPathResultConverter[_root_.slick.relational.ResultConverterDomain, $rTag](tm.asInstanceOf[_root_.slick.relational.TypeMappingResultConverter[_root_.slick.relational.ResultConverterDomain, $rTag, _]]) {
+            ..$fpChildren
+            override def read(r: Reader) = new $rTag(..$fpReadChildren)
+            override def getDumpInfo = super.getDumpInfo.copy(name = $fpName)
+          }
+        case tm => tm
+      }
+      new _root_.slick.lifted.MappedProjection[$rTag, $uTag](${c.prefix}.toNode,
+        _root_.slick.ast.MappedScalaType.Mapper(gg, ff, _root_.scala.Some(fpMatch)), $rCT)
+    """
   }
 }
 
@@ -362,7 +378,7 @@ class MappedProjection[T, P](child: Node, mapper: MappedScalaType.Mapper, classT
   def encodeRef(path: Node): MappedProjection[T, P] = new MappedProjection[T, P](child, mapper, classTag) {
     override def toNode = path
   }
-  def genericFastPath(pf: PartialFunction[Any, Any]) = new MappedProjection[T, P](child, mapper.copy(fastPath = Some(pf)), classTag)
+  def genericFastPath(f: Function[Any, Any]) = new MappedProjection[T, P](child, mapper.copy(fastPath = Some(f)), classTag)
 }
 
 object MappedProjection {

slick/src/main/scala/slick/profile/RelationalProfile.scala

@@ -80,7 +80,7 @@ trait RelationalProfile extends BasicProfile with RelationalTableComponent
     def fastPath(fpf: (TypeMappingResultConverter[M, T, _] => SimpleFastPathResultConverter[M, T])): MappedProjection[T, P] = mp.genericFastPath {
       case tm @ TypeMappingResultConverter(_: ProductResultConverter[_, _], _, _) =>
         fpf(tm.asInstanceOf[TypeMappingResultConverter[M, T, _]])
-
+      case tm => tm
     }
   }
 }