@@ -60,7 +60,7 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
class T (tag : Tag ) extends Table [Data ](tag, " T" ) {
def a = column[Int ](" A" )
def b = column[Int ](" B" )
def * = (a, b) <> ( Data .tupled, Data .unapply _)
def * = (a, b).mapTo[ Data ]
}
val ts = TableQuery [T ]
@@ -77,8 +77,16 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
}
def testWideMappedEntity = {
import slick .collection .heterogeneous ._
import slick .collection .heterogeneous .syntax ._
case class Part (i1 : Int , i2 : Int , i3 : Int , i4 : Int , i5 : Int , i6 : Int )
case class Whole (id : Int , p1 : Part , p2 : Part , p3 : Part , p4 : Part )
case class BigCase (id : Int ,
p1i1 : Int , p1i2 : Int , p1i3 : Int , p1i4 : Int , p1i5 : Int , p1i6 : Int ,
p2i1 : Int , p2i2 : Int , p2i3 : Int , p2i4 : Int , p2i5 : Int , p2i6 : Int ,
p3i1 : Int , p3i2 : Int , p3i3 : Int , p3i4 : Int , p3i5 : Int , p3i6 : Int ,
p4i1 : Int , p4i2 : Int , p4i3 : Int , p4i4 : Int , p4i5 : Int , p4i6 : Int )
class T (tag : Tag ) extends Table [Whole ](tag, " t_wide" ) {
def id = column[Int ](" id" , O .PrimaryKey )
@@ -106,19 +114,37 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
def p4i4 = column[Int ](" p4i4" )
def p4i5 = column[Int ](" p4i5" )
def p4i6 = column[Int ](" p4i6" )
def * = (
// Composable bidirectional mappings
def m1 = (
id,
(p1i1, p1i2, p1i3, p1i4, p1i5, p1i6).mapTo[Part ],
(p2i1, p2i2, p2i3, p2i4, p2i5, p2i6) <> (Part .tupled, Part .unapply _),
(p3i1, p3i2, p3i3, p3i4, p3i5, p3i6).mapTo[Part ],
(p4i1, p4i2, p4i3, p4i4, p4i5, p4i6).mapTo[Part ]
).mapTo[Whole ]
// Manually composed mapping functions
def m2 = (
id,
(p1i1, p1i2, p1i3, p1i4, p1i5, p1i6),
(p2i1, p2i2, p2i3, p2i4, p2i5, p2i6),
(p3i1, p3i2, p3i3, p3i4, p3i5, p3i6),
(p4i1, p4i2, p4i3, p4i4, p4i5, p4i6)
).shaped <> ({ case (id, p1, p2, p3, p4) =>
).shaped <> ({ case (id, p1, p2, p3, p4) =>
// We could do this without .shaped but then we'd have to write a type annotation for the parameters
Whole (id, Part .tupled.apply(p1), Part .tupled.apply(p2), Part .tupled.apply(p3), Part .tupled.apply(p4))
}, { w : Whole =>
def f (p : Part ) = Part .unapply(p).get
Some ((w.id, f(w.p1), f(w.p2), f(w.p3), f(w.p4)))
})
// HList-based wide case class mapping
def m3 = (
id ::
p1i1 :: p1i2 :: p1i3 :: p1i4 :: p1i5 :: p1i6 ::
p2i1 :: p2i2 :: p2i3 :: p2i4 :: p2i5 :: p2i6 ::
p3i1 :: p3i2 :: p3i3 :: p3i4 :: p3i5 :: p3i6 ::
p4i1 :: p4i2 :: p4i3 :: p4i4 :: p4i5 :: p4i6 :: HNil
).mapTo[BigCase ]
def * = m1
}
val ts = TableQuery [T ]
@@ -132,7 +158,9 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
seq(
ts.schema.create,
ts + = oData,
ts.result.head.map(_ shouldBe oData)
ts.result.head.map(_ shouldBe oData),
ts.map(_.m2).result.head.map(_ shouldBe oData),
ts.map(_.m3).result.head.map(_ shouldBe BigCase (0 , 11 , 12 , 13 , 14 , 15 , 16 , 21 , 22 , 23 , 24 , 25 , 26 , 31 , 32 , 33 , 34 , 35 , 36 , 41 , 42 , 43 , 44 , 45 , 46 ))
)
}
@@ -147,7 +175,7 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
def p3 = column[String ](" p3" )
def p4 = column[Int ](" p4" )
def part1 = (p1,p2) <> (Part1 .tupled,Part1 .unapply)
def part2 = (p3,p4) <> ( Part2 .tupled, Part2 .unapply)
def part2 = (p3,p4).mapTo[ Part2 ]
def * = (part1, part2) <> (Whole .tupled,Whole .unapply)
}
val T = TableQuery [T ]
@@ -169,14 +197,14 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
class ARow (tag : Tag ) extends Table [A ](tag, " t4_a" ) {
def id = column[Int ](" id" , O .PrimaryKey , O .AutoInc )
def data = column[Int ](" data" )
def * = (id, data) <> ( A .tupled, A .unapply _)
def * = (id, data).mapTo[ A ]
}
val as = TableQuery [ARow ]
class BRow (tag : Tag ) extends Table [B ](tag, " t5_b" ) {
def id = column[Int ](" id" , O .PrimaryKey , O .AutoInc )
def data = column[String ](" data" )
def * = (id, Rep .Some (data)) <> ( B .tupled, B .unapply _)
def * = (id, Rep .Some (data)).mapTo[ B ]
}
val bs = TableQuery [BRow ]
@@ -297,11 +325,14 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
import slick .collection .heterogeneous ._
import slick .collection .heterogeneous .syntax ._
case class Data (id : Int , b : Boolean , s : String )
class B (tag : Tag ) extends Table [Int :: Boolean :: String :: HNil ](tag, " hlist_b" ) {
def id = column[Int ](" id" , O .PrimaryKey )
def b = column[Boolean ](" b" )
def s = column[String ](" s" )
def * = id :: b :: s :: HNil
def mapped = * .mapTo[Data ]
}
val bs = TableQuery [B ]
@@ -320,9 +351,10 @@ class JdbcMapperTest extends AsyncTest[JdbcTestDB] {
bs.schema.create,
bs + = (1 :: true :: " a" :: HNil ),
bs + = (2 :: false :: " c" :: HNil ),
bs + = ( 3 :: false :: " b" :: HNil ),
bs.map(_.mapped) + = Data ( 3 , false , " b" ),
q1.result.map(_ shouldBe Vector (3 :: " bb" :: (42 :: HNil ) :: HNil , 2 :: " cc" :: (42 :: HNil ) :: HNil )),
q1.result.map(_ shouldBe Vector (3 :: " bb" :: (42 :: HNil ) :: HNil , 2 :: " cc" :: (42 :: HNil ) :: HNil ))
q2.result.map(_ shouldBe Vector (3 :: " bb" :: (42 :: HNil ) :: HNil , 2 :: " cc" :: (42 :: HNil ) :: HNil )),
bs.map(_.mapped).result.map(_.toSet shouldBe Set (Data (1 , true , " a" ), Data (2 , false , " c" ), Data (3 , false , " b" )))
)
}
@@ -374,7 +406,7 @@ 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) <> ( Data .tupled, Data .unapply _) fastPath(new FastPath (_) {
def * = (a, b).mapTo[ Data ]. fastPath(new FastPath (_) {
val (a, b) = (next[Int ], next[Int ])
override def read (r : Reader ) = Data (a.read(r), b.read(r))
})
This comment has been minimized.
Wow, awesome!!👍
This comment has been minimized.
Does this commit address some complaints raised on slow compile time when using Shapeless as solution to function +22 params as per this discussion milessabin/shapeless#619 ?
Said differently is the compile time good with case classes of about 100 columns using this build of Slick?