src/main/scala/xyz/driver/common/db/EntityExtractorDerivation.scala


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

package xyz.driver.common.db

import java.sql.ResultSet

import io.getquill.NamingStrategy
import io.getquill.dsl.EncodingDsl

import scala.language.experimental.macros
import scala.reflect.macros.blackbox

trait EntityExtractorDerivation[Naming <: NamingStrategy] {
  this: EncodingDsl =>

  /**
    * Simple Quill extractor derivation for [[T]]
    * Only case classes available. Type parameters is not supported
    *
    * @tparam T
    * @return
    */
  def entityExtractor[T]: (ResultSet => T) = macro EntityExtractorDerivation.impl[T]
}

object EntityExtractorDerivation {
  def impl[T: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
    import c.universe._
    val namingStrategy = c.prefix.actualType
      .baseType(c.weakTypeOf[EntityExtractorDerivation[NamingStrategy]].typeSymbol)
      .typeArgs
      .head
      .typeSymbol
      .companion
    val functionBody = {
      val tpe = weakTypeOf[T]
      val resultOpt = tpe.decls.collectFirst {
        // Find first constructor of T
        case cons: MethodSymbol if cons.isConstructor =>
          // Create param list for constructor
          val params = cons.paramLists.flatten.map { param =>
            val t = param.typeSignature
            val paramName = param.name.toString
            val col = q"$namingStrategy.column($paramName)"
            // Resolve implicit decoders (from SqlContext) and apply ResultSet for each
            val d = q"implicitly[${c.prefix}.Decoder[$t]]"
            // Minus 1 cause Quill JDBC decoders make plus one.
            // ¯\_(ツ)_/¯
            val i = q"row.findColumn($col) - 1"
            val decoderName = TermName(paramName + "Decoder")
            val valueName = TermName(paramName + "Value")
            (
              q"val $decoderName = $d",
              q"val $valueName = $decoderName($i, row)",
              valueName
            )
          }
          // Call constructor with param list
          q"""
            ..${params.map(_._1)}
            ..${params.map(_._2)}
            new $tpe(..${params.map(_._3)})
          """
      }
      resultOpt match {
        case Some(result) => result
        case None => c.abort(c.enclosingPosition,
          s"Can not derive extractor for $tpe. Constructor not found.")
      }
    }
    q"(row: java.sql.ResultSet) => $functionBody"
  }
}