def expressionSigList: Seq[Sig] = Seq()

in src/spark-project/sparder/src/main/scala/org/apache/spark/sql/catalyst/expressions/gluten/KapExpressionTransformer.scala [54:152]
96 lines of code
14 McCabe index (conditional complexity)

  def expressionSigList: Seq[Sig] = Seq(
    Sig[FloorDateTime]("date_trunc"),
    Sig[CeilDateTime]("ceil_datetime"),
    Sig[KapAddMonths]("kap_add_months"),
    Sig[KapSubtractMonths]("kap_months_between"),
    Sig[YMDintBetween]("kap_ymd_int_between"),
    Sig[Truncate]("truncate"),
    Sig[KylinSplitPart]("kylin_split_part"),
    Sig[KylinInstr]("kylin_instr"),
    Sig[PreciseCardinality]("ke_bitmap_cardinality"),
    Sig[PreciseCountDistinctDecode]("ke_bitmap_cardinality"),
    Sig[ReusePreciseCountDistinct]("ke_bitmap_or_data"),
    Sig[PreciseCountDistinctAndValue]("ke_bitmap_and_value"),
    Sig[PreciseCountDistinctAndArray]("ke_bitmap_and_ids"),
    Sig[PreciseCountDistinct]("ke_bitmap_or_cardinality"),
    Sig[KylinTimestampAdd]("kylin_timestamp_add"),
    Sig[Sum0]("sum0")
  )

  /** Replace extension expression to transformer. */
  override def replaceWithExtensionExpressionTransformer(substraitExprName: String,
                                                         expr: Expression,
                                                         attributeSeq: Seq[Attribute]): ExpressionTransformer = expr match {
    case preciseCardinality: PreciseCardinality =>
      new KeBitmapFunctionTransformer(
        substraitExprName,
        ExpressionConverter
          .replaceWithExpressionTransformer(preciseCardinality.child, attributeSeq),
        preciseCardinality
      )
    case preciseCountDistinctDecode: PreciseCountDistinctDecode =>
      new KeBitmapFunctionTransformer(
        substraitExprName,
        ExpressionConverter
          .replaceWithExpressionTransformer(preciseCountDistinctDecode.child, attributeSeq),
        preciseCountDistinctDecode
      )
    case kylinTimestampAdd: KylinTimestampAdd =>
      new TimestampAddTransformer(
        ExpressionConverter
          .replaceWithExpressionTransformer(kylinTimestampAdd.left, attributeSeq),
        ExpressionConverter
          .replaceWithExpressionTransformer(kylinTimestampAdd.mid, attributeSeq),
        ExpressionConverter
          .replaceWithExpressionTransformer(kylinTimestampAdd.right, attributeSeq),
        kylinTimestampAdd
      )
    case ceilDateTime: CeilDateTime =>
      val floorTime = FloorDateTime(ceilDateTime.left, ceilDateTime.right, ceilDateTime.timeZoneId)
      val floorAddUnitTime = KylinTimestampAdd(ceilDateTime.right, Literal(1L), floorTime)
      val equalsExp = If(EqualTo(ceilDateTime.left, floorTime), floorTime, floorAddUnitTime)
      ExpressionConverter.replaceWithExpressionTransformer(equalsExp, attributeSeq)
    case floorDateTime: FloorDateTime =>
      new FloorDateTimeTransformer(
        ExpressionConverter.replaceWithExpressionTransformer(floorDateTime.left, attributeSeq),
        ExpressionConverter.replaceWithExpressionTransformer(floorDateTime.right, attributeSeq),
        floorDateTime
      )
    case kylinSplitPart: KylinSplitPart if kylinSplitPart.second.isInstanceOf[Literal] =>
      new GenericExpressionTransformer(
        substraitExprName,
        Seq(
          ExpressionConverter.replaceWithExpressionTransformer(kylinSplitPart.first, attributeSeq),
          LiteralTransformer(kylinSplitPart.second.asInstanceOf[Literal]),
          ExpressionConverter.replaceWithExpressionTransformer(kylinSplitPart.third, attributeSeq)
        ),
        kylinSplitPart
      )
    case kylinInstr: KylinInstr =>
      val stringLocate = StringLocate(kylinInstr.second, kylinInstr.first, kylinInstr.third)
      ExpressionConverter.replaceWithExpressionTransformer(stringLocate, attributeSeq)
    case kapAddMonths: KapAddMonths =>
      val addMonths = KylinTimestampAdd(Literal("month"), kapAddMonths.right, kapAddMonths.left)
      val equalsExp = If(EqualTo(kapAddMonths.left, LastDay(kapAddMonths.left)), LastDay(addMonths), addMonths)
      ExpressionConverter.replaceWithExpressionTransformer(equalsExp, attributeSeq)

    case kapSubtractMonths: KapSubtractMonths =>
      GenericExpressionTransformer("kap_months_between",
        Seq(
          ExpressionConverter.replaceWithExpressionTransformer(kapSubtractMonths.right, attributeSeq),
          ExpressionConverter.replaceWithExpressionTransformer(kapSubtractMonths.left, attributeSeq)),
        kapSubtractMonths)
    case kapYmdIntBetween: YMDintBetween =>
      GenericExpressionTransformer("kap_ymd_int_between",
        Seq(
          ExpressionConverter.replaceWithExpressionTransformer(kapYmdIntBetween.left, attributeSeq),
          ExpressionConverter.replaceWithExpressionTransformer(kapYmdIntBetween.right, attributeSeq)),
        kapYmdIntBetween)
    case truncate: Truncate =>
      GenericExpressionTransformer(
        "truncate",
        Seq(
          ExpressionConverter.replaceWithExpressionTransformer(truncate.left, attributeSeq),
          ExpressionConverter.replaceWithExpressionTransformer(truncate.right, attributeSeq)),
        truncate)
    case _ =>
      throw new UnsupportedOperationException(
        s"${expr.getClass} or $expr is not currently supported.")
  }