Optimize (#206)

* csv support vector set

* fix

Author: jxnu-liguobin

smt-common/src/main/scala/org/bitlap/common/AbstractMacroProcessor.scala

@@ -218,8 +218,10 @@ abstract class AbstractMacroProcessor(val c: blackbox.Context) {
       case t if t =:= typeOf[Long] =>
         q"0L"
       case t if t weak_<:< typeOf[List[_]]   => q"_root_.scala.Nil"
-      case t if t weak_<:< typeOf[Seq[_]]    => q"_root_.scala.Nil"
       case t if t weak_<:< typeOf[Option[_]] => q"_root_.scala.None"
+      case t if t weak_<:< typeOf[Set[_]]    => q"_root_.scala.Predef.Set.empty"
+      case t if t weak_<:< typeOf[Vector[_]] => q"_root_.scala.Vector.empty"
+      case t if t weak_<:< typeOf[Seq[_]]    => q"_root_.scala.Nil"
       case _ =>
         q"null"
     }
@@ -237,12 +239,12 @@ abstract class AbstractMacroProcessor(val c: blackbox.Context) {
         isList = true
       case t if t weak_<:< weakTypeOf[Option[_]] =>
         isOption = true
-      case t if !isList && (t weak_<:< weakTypeOf[Seq[_]]) =>
-        isSeq = true
       case t if t weak_<:< weakTypeOf[Vector[_]] =>
         isVector = true
       case t if t weak_<:< weakTypeOf[Set[_]] =>
         isSet = true
+      case t if !isList && (t weak_<:< weakTypeOf[Seq[_]]) =>
+        isSeq = true
       case _ =>
     }
     Tuple5(isOption, isSeq, isList, isVector, isSet)

smt-common/src/main/scala/org/bitlap/common/MacroCache.scala

@@ -43,5 +43,5 @@ object MacroCache {
 
   lazy val classFieldNameMapping: mutable.Map[Int, mutable.Map[String, String]] = mutable.Map.empty
 
-  lazy val classFieldValueMapping: mutable.Map[Int, mutable.Map[String, Any]] = mutable.Map.empty
+  lazy val classFieldTypeMapping: mutable.Map[Int, mutable.Map[String, Any]] = mutable.Map.empty
 }

smt-common/src/main/scala/org/bitlap/common/Transformable.scala

@@ -29,8 +29,6 @@ class Transformable[From, To] {
 
   /** @param selectFromField
    *    Select the name of the field to be mapped in the `From` class.
-   *  @param selectToField
-   *    Selects which field of `To` the `From` will eventually be mapped to.
    *  @param map
    *    Specify the type mapping of the field, which must be provided when the type is incompatible, or else attempt to
    *    search for an implicit `Transformer[FromField, ToField]` (a failed search will result in a compile failure).
@@ -43,21 +41,20 @@ class Transformable[From, To] {
    *    Transformable
    */
   @unchecked
-  def mapField[FromField, ToField](
+  def setType[FromField, ToField](
     selectFromField: From => FromField,
-    selectToField: To => ToField,
     map: FromField => ToField
   ): Transformable[From, To] =
-    macro TransformerMacro.mapFieldWithValueImpl[From, To, FromField, ToField]
+    macro TransformerMacro.mapTypeImpl[From, To, FromField, ToField]
 
   /** Same method as above, but without the map parameter. That is, no type mapping needs to be configured.
    */
   @unchecked
-  def mapField[FromField, ToField](
+  def setName[FromField, ToField](
     selectFromField: From => FromField,
     selectToField: To => ToField
   ): Transformable[From, To] =
-    macro TransformerMacro.mapFieldImpl[From, To, FromField, ToField]
+    macro TransformerMacro.mapNameImpl[From, To, FromField, ToField]
 
   def instance: Transformer[From, To] = macro TransformerMacro.instanceImpl[From, To]
 
@@ -66,7 +63,7 @@ class Transformable[From, To] {
 object Transformable {
 
   /** Automatically derive `Transformable[From, To]` for case classes only, for non-case classes you should use the
-   *  `mapField` method to configure the mapping relationship.
+   *  `setType` method to configure the mapping relationship.
    *  @tparam From
    *  @tparam To
    *  @return

smt-common/src/main/scala/org/bitlap/common/TransformerMacro.scala

@@ -30,32 +30,28 @@ import scala.reflect.macros.whitebox
  *  @version 1.0,6/15/22
  */
 class TransformerMacro(override val c: whitebox.Context) extends AbstractMacroProcessor(c) {
+
   import c.universe._
 
   protected val packageName         = q"_root_.org.bitlap.common"
   private val builderFunctionPrefix = "_TransformableFunction$"
   private val annoBuilderPrefix     = "_AnonObjectTransformable$"
   private val fromTermName          = TermName("from")
 
-  def mapFieldWithValueImpl[From, To, FromField, ToField](
+  def mapTypeImpl[From, To, FromField, ToField](
     selectFromField: Expr[From => FromField],
-    selectToField: Expr[To => ToField],
     map: Expr[FromField => ToField]
   ): Expr[Transformable[From, To]] = {
     val Function(_, Select(_, fromName)) = selectFromField.tree
-    val Function(_, Select(_, toName))   = selectToField.tree
     val builderId                        = getBuilderId(annoBuilderPrefix)
-    MacroCache.classFieldNameMapping
-      .getOrElseUpdate(builderId, mutable.Map.empty)
-      .update(toName.decodedName.toString, fromName.decodedName.toString)
-    MacroCache.classFieldValueMapping
+    MacroCache.classFieldTypeMapping
       .getOrElseUpdate(builderId, mutable.Map.empty)
-      .update(toName.decodedName.toString, map)
+      .update(fromName.decodedName.toString, map)
     val tree = q"new ${c.prefix.actualType}"
     exprPrintTree[Transformable[From, To]](force = false, tree)
   }
 
-  def mapFieldImpl[From, To, FromField, ToField](
+  def mapNameImpl[From, To, FromField, ToField](
     selectFromField: Expr[From => FromField],
     selectToField: Expr[To => ToField]
   ): Expr[Transformable[From, To]] = {
@@ -73,7 +69,8 @@ class TransformerMacro(override val c: whitebox.Context) extends AbstractMacroPr
   def instanceImpl[From: WeakTypeTag, To: WeakTypeTag]: Expr[BitlapTransformer[From, To]] = {
     val fromClassName = resolveClassTypeName[From]
     val toClassName   = resolveClassTypeName[To]
-    val tree = q"""
+    val tree =
+      q"""
        ..$getPreTree  
        new $packageName.Transformer[$fromClassName, $toClassName] {
           override def transform($fromTermName: $fromClassName): $toClassName = {
@@ -101,7 +98,7 @@ class TransformerMacro(override val c: whitebox.Context) extends AbstractMacroPr
   }
 
   private def getPreTree: Iterable[Tree] = {
-    val customTrees = MacroCache.classFieldValueMapping.getOrElse(getBuilderId(annoBuilderPrefix), mutable.Map.empty)
+    val customTrees = MacroCache.classFieldTypeMapping.getOrElse(getBuilderId(annoBuilderPrefix), mutable.Map.empty)
     val (_, preTrees) = customTrees.collect { case (key, expr: Expr[Tree] @unchecked) =>
       expr.tree match {
         case buildFunction: Function =>
@@ -126,21 +123,24 @@ class TransformerMacro(override val c: whitebox.Context) extends AbstractMacroPr
 
     val customFieldNameMapping =
       MacroCache.classFieldNameMapping.getOrElse(getBuilderId(annoBuilderPrefix), mutable.Map.empty)
-    val customFieldValueMapping =
-      MacroCache.classFieldValueMapping.getOrElse(getBuilderId(annoBuilderPrefix), mutable.Map.empty)
+    val customFieldTypeMapping =
+      MacroCache.classFieldTypeMapping.getOrElse(getBuilderId(annoBuilderPrefix), mutable.Map.empty)
     c.info(c.enclosingPosition, s"Field Name Mapping:$customFieldNameMapping", force = true)
-    c.info(c.enclosingPosition, s"Field Value Mapping:$customFieldValueMapping", force = true)
+    c.info(c.enclosingPosition, s"Field Type Mapping:$customFieldTypeMapping", force = true)
     val fields = toClassInfo.map { field =>
-      val fromFieldName     = customFieldNameMapping.get(field.fieldName)
-      val realFromFieldName = fromFieldName.fold(field.fieldName)(x => x)
-      if (customFieldValueMapping.contains(field.fieldName)) {
-        q"""${TermName(builderFunctionPrefix + field.fieldName)}.apply(${q"$fromTermName.${TermName(realFromFieldName)}"})"""
-      } else {
-        checkFieldGetFieldTerm[From](
-          realFromFieldName,
-          fromClassInfo.find(_.fieldName == realFromFieldName),
-          field
-        )
+      val fromFieldName   = customFieldNameMapping.get(field.fieldName)
+      val realToFieldName = fromFieldName.fold(field.fieldName)(x => x)
+      fromFieldName match {
+        case Some(fromName) if customFieldTypeMapping.contains(fromName) =>
+          q"""${TermName(builderFunctionPrefix + fromName)}.apply(${q"$fromTermName.${TermName(realToFieldName)}"})"""
+        case None if customFieldTypeMapping.contains(field.fieldName) =>
+          q"""${TermName(builderFunctionPrefix + field.fieldName)}.apply(${q"$fromTermName.${TermName(realToFieldName)}"})"""
+        case _ =>
+          checkFieldGetFieldTerm[From](
+            realToFieldName,
+            fromClassInfo.find(_.fieldName == realToFieldName),
+            field
+          )
       }
     }
     q"""
@@ -161,7 +161,7 @@ class TransformerMacro(override val c: whitebox.Context) extends AbstractMacroPr
     if (fromFieldOpt.isEmpty) {
       c.abort(
         c.enclosingPosition,
-        s"value `$realFromFieldName` is not a member of `$fromClassName`, Please consider using `mapField` method!"
+        s"value `$realFromFieldName` is not a member of `$fromClassName`, Please consider using `setName` method!"
       )
       return fromFieldTerm
     }
@@ -192,7 +192,8 @@ class TransformerMacro(override val c: whitebox.Context) extends AbstractMacroPr
       case (information1, information2) =>
         c.warning(
           c.enclosingPosition,
-          s"No implicit `Transformer` is defined for ${information1.fieldType} => ${information2.fieldType}, which may cause compilation errors!!!"
+          s"No implicit `Transformer` is defined for ${information1.fieldType} => ${information2.fieldType}, which may cause compilation errors!!!" +
+            s"Please consider using `setType` method, or define an `Transformer[${information1.fieldType}, ${information2.fieldType}]` implicit !"
         )
         q"""$packageName.Transformer[${information1.fieldType}, ${information2.fieldType}].transform($fromFieldTerm)"""
     }

smt-common/src/test/scala/org/bitlap/common/TransformableTest.scala

@@ -31,13 +31,13 @@ import org.scalatest.matchers.should.Matchers
 class TransformableTest extends AnyFlatSpec with Matchers {
 
   "TransformableTest simple case" should "ok for Transformable" in {
-
     case class A1(a: String, b: Int, cc: Long, d: Option[String])
     case class A2(a: String, b: Int, c: Int, d: Option[String])
 
     val a = A1("hello", 1, 2, None)
     val b: A2 = Transformable[A1, A2] // todo `fromField: Long` type Long cannot be ignored.
-      .mapField[Long, Int](_.cc, _.c, (fromField: Long) => if (fromField > 0) fromField.toInt else 0)
+      .setName(_.cc, _.c)
+      .setType[Long, Int](_.cc, fromField => if (fromField > 0) fromField.toInt else 0)
       .instance
       .transform(a)
 
@@ -52,14 +52,27 @@ class TransformableTest extends AnyFlatSpec with Matchers {
     b2.toString shouldEqual "B2(List(hello))"
   }
 
+  "TransformableTest simple case, name is equals, but type not" should "ok for Transformable" in {
+    case class A1(a: String)
+    case class A2(a: Int)
+
+    val a = A1("1112")
+    val b: A2 = Transformable[A1, A2]
+      .setType[String, Int](_.a, _.toInt)
+      .instance
+      .transform(a)
+
+    b.toString shouldEqual "A2(1112)"
+  }
+
   "TransformableTest simple case" should "ok for implicit Transformable" in {
     case class A1(a: String, b: Int, cc: Long, d: Option[String])
     case class A2(a: String, b: Int, c: Int, d: Option[String])
     val a = A1("hello", 1, 2, None)
     implicit val transformer = Transformable[A1, A2]
-      .mapField(_.b, _.c)
-      .mapField(_.a, _.a)
-      .mapField[Option[String], Option[String]](_.d, _.d, (map: Option[String]) => map)
+      .setName(_.b, _.c)
+      .setName(_.a, _.a)
+      .setType[Option[String], Option[String]](_.d, (map: Option[String]) => map)
       .instance
 
     Transformer[A1, A2].transform(a).toString shouldEqual "A2(hello,1,1,None)"
@@ -72,7 +85,7 @@ class TransformableTest extends AnyFlatSpec with Matchers {
       |    case class A2(a: String, b: Int, c: Int, d: Option[String])
       |    val a = A1("hello", 1, 2, None)
       |    val b: A2 = Transformable[A1, A2]
-      |      .mapField(_.cc, _.c)
+      |      .setName(_.cc, _.c)
       |      .instance
       |      .transform(a)
       |""".stripMargin shouldNot compile
@@ -85,7 +98,7 @@ class TransformableTest extends AnyFlatSpec with Matchers {
     case class D2(c2: C2)
 
     implicit val cTransformer: Transformer[C1, C2] = Transformable[C1, C2].instance
-    implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2].mapField(_.c1, _.c2).instance
+    implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2].setName(_.c1, _.c2).instance
 
     val d1     = D1(C1(1))
     val d2: D2 = Transformer[D1, D2].transform(d1)
@@ -99,14 +112,14 @@ class TransformableTest extends AnyFlatSpec with Matchers {
     case class D2(c2: List[C2])
 
     implicit val cTransformer: Transformer[C1, C2] = Transformable[C1, C2].instance
-    implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2].mapField(_.c1, _.c2).instance
+    implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2].setName(_.c1, _.c2).instance
 
     val d1     = D1(List(C1(1), C1(2)))
     val d2: D2 = Transformer[D1, D2].transform(d1)
     println(d2)
   }
 
-  "TransformableTest more complex case for two-layer nest field" should "ok for implicit and non-implicit(mapField)" in {
+  "TransformableTest more complex case for two-layer nest field" should "ok for implicit and non-implicit(setName)" in {
     case class C1(j: Int)
     case class D1(c1: List[List[C1]])
 
@@ -119,11 +132,10 @@ class TransformableTest extends AnyFlatSpec with Matchers {
 
     object D1 {
       implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2]
-        .mapField[List[List[C1]], List[List[C2]]](
+        .setName(_.c1, _.c2)
+        .setType[List[List[C1]], List[List[C2]]](
           _.c1,
-          _.c2,
-          // implicit values of nested dependencies cannot be at the same level, so move it to companion their object
-          (c1: List[List[C1]]) => c1.map(_.map(Transformer[C1, C2].transform(_)))
+          _.map(_.map(Transformer[C1, C2].transform(_)))
         )
         .instance
     }
@@ -162,12 +174,12 @@ class TransformableTest extends AnyFlatSpec with Matchers {
 
     object D1 {
       implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2]
-        .mapField(_.a1, _.a2)
-        .mapField(_.b1, _.b2)
-        .mapField(_.c1, _.c2)
-        .mapField(_.d1, _.d2)
-        .mapField(_.map1, _.map2)
-        .mapField(_.intMap1, _.intMap2)
+        .setName(_.a1, _.a2)
+        .setName(_.b1, _.b2)
+        .setName(_.c1, _.c2)
+        .setName(_.d1, _.d2)
+        .setName(_.map1, _.map2)
+        .setName(_.intMap1, _.intMap2)
         .instance
     }
 
@@ -191,7 +203,7 @@ class TransformableTest extends AnyFlatSpec with Matchers {
     case class A1(a: String, b: Int, cc: Int, d: Option[String]) // weak conformance
     case class A2(a: String, b: Int, c: Long, d: Option[String])
     object A1 {
-      implicit val aTransformer: Transformer[A1, A2] = Transformable[A1, A2].mapField(_.cc, _.c).instance
+      implicit val aTransformer: Transformer[A1, A2] = Transformable[A1, A2].setName(_.cc, _.c).instance
     }
     val a1 = A1("hello", 1, 2, None)
     val a2 = Transformer[A1, A2].transform(a1)
@@ -201,11 +213,11 @@ class TransformableTest extends AnyFlatSpec with Matchers {
 
   "TransformableTest type cannot match" should "compile failed if can't use weak conformance" in {
     """
-      | case class A1(a: String, b: Int, cc: Long, d: Option[String]) // Can't to use weak conformance, must use `mapField(?,?,?)` method for it.
+      | case class A1(a: String, b: Int, cc: Long, d: Option[String]) // Can't to use weak conformance, must use `setName(?,?,?)` method for it.
       |    case class A2(a: String, b: Int, c: Int, d: Option[String])
       |    object A1 {
       |      
-      |      implicit val aTransformer: Transformer[A1, A2] = Transformable[A1, A2].mapField(_.cc,_.c).instance
+      |      implicit val aTransformer: Transformer[A1, A2] = Transformable[A1, A2].setName(_.cc,_.c).instance
       |    }
       |    val a1 = A1("hello", 1, 2, None)
       |    val a2 = Transformer[A1, A2].transform(a1)
@@ -269,7 +281,7 @@ class TransformableTest extends AnyFlatSpec with Matchers {
     object D1 {
 
       implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2]
-        .mapField(_.a1, _.a2)
+        .setName(_.a1, _.a2)
         .instance
     }
 
@@ -306,9 +318,9 @@ class TransformableTest extends AnyFlatSpec with Matchers {
     object D1 {
 
       implicit val dTransformer: Transformer[D1, D2] = Transformable[D1, D2]
-        .mapField(_.a1, _.a2)
-        .mapField(_.b1, _.b2)
-        .mapField(_.c1, _.c2)
+        .setName(_.a1, _.a2)
+        .setName(_.b1, _.b2)
+        .setName(_.c1, _.c2)
         .instance
     }
 

smt-common/src/test/scala/org/bitlap/common/models.scala

@@ -40,8 +40,8 @@ object models {
       //  mapping name
       implicit val queryResultTransform: Transformer[FQueryResult, TQueryResult] =
         Transformable[FQueryResult, TQueryResult]
-          .mapField(_.rows, _.trows)
-          .mapField(_.tableSchema, _.ttableSchema)
+          .setName(_.rows, _.trows)
+          .setName(_.tableSchema, _.ttableSchema)
           .instance
     }
 
@@ -69,7 +69,7 @@ object models {
 
     object FColumnDesc {
       implicit val columnDescTransform: Transformer[FColumnDesc, TColumnDesc] = Transformable[FColumnDesc, TColumnDesc]
-        .mapField(_.columnName, _.tcolumnName) // mapping name
+        .setName(_.columnName, _.tcolumnName) // mapping name
         .instance
     }
   }