From 976a0a2482b5091f772a3324745c80af963f819f Mon Sep 17 00:00:00 2001 From: Yuan Zhou Date: Fri, 5 Aug 2022 14:26:03 +0800 Subject: [PATCH] add missing codegen check Signed-off-by: Yuan Zhou --- .../oap/expression/ColumnarArithmetic.scala | 51 +++++++++++- .../expression/ColumnarBinaryExpression.scala | 8 ++ .../expression/ColumnarBinaryOperator.scala | 83 +++++++++++++++++-- .../ColumnarDateTimeExpressions.scala | 12 +++ .../oap/expression/ColumnarExpression.scala | 2 +- .../expression/ColumnarRoundOperator.scala | 7 ++ .../ColumnarString2TrimOperator.scala | 19 +++++ .../expression/ColumnarTernaryOperator.scala | 19 +++++ .../expression/ColumnarUnaryOperator.scala | 49 +++++++++-- 9 files changed, 236 insertions(+), 14 deletions(-) diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarArithmetic.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarArithmetic.scala index 6331c2014..049641ab0 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarArithmetic.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarArithmetic.scala @@ -39,6 +39,13 @@ class ColumnarAdd(left: Expression, right: Expression, original: Expression) extends Add(left: Expression, right: Expression) with ColumnarExpression with Logging { + val gName = "add" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } // If casting between DecimalType, unnecessary cast is skipped to avoid data loss, // because actually res type of "cast" is the res type in "add/subtract", @@ -103,6 +110,14 @@ class ColumnarSubtract(left: Expression, right: Expression, original: Expression with ColumnarExpression with Logging { + val gName = "subtract" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + val left_val: Any = left match { case c: ColumnarCast => if (c.child.dataType.isInstanceOf[DecimalType] && @@ -163,6 +178,14 @@ class ColumnarMultiply(left: Expression, right: Expression, original: Expression with ColumnarExpression with Logging { + val gName = "multiply" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + val left_val: Any = left match { case c: ColumnarCast => if (c.child.dataType.isInstanceOf[DecimalType] && @@ -247,9 +270,6 @@ class ColumnarMultiply(left: Expression, right: Expression, original: Expression } } - override def supportColumnarCodegen(args: java.lang.Object): Boolean = { - return left_val.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && right_val.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) - } } class ColumnarDivide(left: Expression, right: Expression, @@ -257,6 +277,13 @@ class ColumnarDivide(left: Expression, right: Expression, extends Divide(left: Expression, right: Expression) with ColumnarExpression with Logging { + val gName = "divide" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } val left_val: Any = left match { case c: ColumnarCast => @@ -349,6 +376,15 @@ class ColumnarBitwiseAnd(left: Expression, right: Expression, original: Expressi extends BitwiseAnd(left: Expression, right: Expression) with ColumnarExpression with Logging { + + val gName = "bitwise_and" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -370,6 +406,15 @@ class ColumnarBitwiseOr(left: Expression, right: Expression, original: Expressio extends BitwiseOr(left: Expression, right: Expression) with ColumnarExpression with Logging { + + val gName = "bitwise_or" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryExpression.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryExpression.scala index 6fcd6a5a2..7402b37f8 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryExpression.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryExpression.scala @@ -103,6 +103,14 @@ class ColumnarGetJsonObject(left: Expression, right: Expression, original: GetJs class ColumnarStringInstr(left: Expression, right: Expression, original: StringInstr) extends StringInstr(original.str, original.substr) with ColumnarExpression with Logging { + val gName = "locate" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: Object): (TreeNode, ArrowType) = { val (left_node, _): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryOperator.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryOperator.scala index 443c0b3e8..e64be10f3 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryOperator.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarBinaryOperator.scala @@ -103,6 +103,14 @@ class ColumnarStartsWith(left: Expression, right: Expression, original: Expressi extends StartsWith(left: Expression, right: Expression) with ColumnarExpression with Logging { + val gName = "starts_with" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -121,6 +129,14 @@ class ColumnarLike(left: Expression, right: Expression, original: Expression) with ColumnarExpression with Logging { + val gName = "like" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + buildCheck() def buildCheck(): Unit = { @@ -154,7 +170,14 @@ class ColumnarRLike(left: Expression, right: Expression, original: Expression) extends RLike(left: Expression, right: Expression) with ColumnarExpression with Logging { + val gName = "equal" + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + buildCheck() def buildCheck(): Unit = { @@ -164,10 +187,6 @@ class ColumnarRLike(left: Expression, right: Expression, original: Expression) } } - override def supportColumnarCodegen(args: java.lang.Object): Boolean = { - false - } - override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -206,6 +225,14 @@ class ColumnarEqualTo(left: Expression, right: Expression, original: Expression) extends EqualTo(left: Expression, right: Expression) with ColumnarExpression with Logging { + val gName = "equal" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -305,8 +332,11 @@ class ColumnarLessThan(left: Expression, right: Expression, original: Expression with ColumnarExpression with Logging { + val gName = "less_than" + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { - true && left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) } @@ -352,6 +382,14 @@ class ColumnarLessThanOrEqual(left: Expression, right: Expression, original: Exp extends LessThanOrEqual(left: Expression, right: Expression) with ColumnarExpression with Logging { + val gName = "less_than_or_equal_to" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -396,6 +434,15 @@ class ColumnarGreaterThan(left: Expression, right: Expression, original: Express extends GreaterThan(left: Expression, right: Expression) with ColumnarExpression with Logging { + + val gName = "greater_than" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -440,6 +487,14 @@ class ColumnarGreaterThanOrEqual(left: Expression, right: Expression, original: extends GreaterThanOrEqual(left: Expression, right: Expression) with ColumnarExpression with Logging { + val gName = "greater_than_or_equal_to" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: java.lang.Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -484,6 +539,15 @@ class ColumnarShiftLeft(left: Expression, right: Expression, original: Expressio extends ShiftLeft(left: Expression, right: Expression) with ColumnarExpression with Logging { + + val gName = "shift_left" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: Object): (TreeNode, ArrowType) = { var (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) @@ -506,6 +570,15 @@ class ColumnarShiftRight(left: Expression, right: Expression, original: Expressi extends ShiftRight(left: Expression, right: Expression) with ColumnarExpression with Logging { + + val gName = "shift_right" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + left.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + right.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + override def doColumnarCodeGen(args: Object): (TreeNode, ArrowType) = { val (left_node, left_type): (TreeNode, ArrowType) = left.asInstanceOf[ColumnarExpression].doColumnarCodeGen(args) diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarDateTimeExpressions.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarDateTimeExpressions.scala index de338d322..937193ebe 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarDateTimeExpressions.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarDateTimeExpressions.scala @@ -255,6 +255,12 @@ object ColumnarDateTimeExpressions { class ColumnarYear(child: Expression) extends Year(child) with ColumnarExpression { + val gName = "extractYear" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() @@ -420,6 +426,12 @@ object ColumnarDateTimeExpressions { class ColumnarMicrosToTimestamp(child: Expression) extends MicrosToTimestamp(child) with ColumnarExpression { + val gName = "micros_to_timestamp" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarExpression.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarExpression.scala index 4868bc2bd..371acd47a 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarExpression.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarExpression.scala @@ -28,7 +28,7 @@ import scala.collection.mutable.ListBuffer trait ColumnarExpression { val codegenFuncList: List[String] = List( - "less_than", + "less_than", "less_than_with_nan", "greater_than", "greater_than_with_nan", diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarRoundOperator.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarRoundOperator.scala index ec7808a68..1cb733a6e 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarRoundOperator.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarRoundOperator.scala @@ -38,6 +38,13 @@ class ColumnarRound(child: Expression, scale: Expression, original: Expression) extends Round(child: Expression, scale: Expression) with ColumnarExpression with Logging { + val gName = "round" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + scale.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarString2TrimOperator.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarString2TrimOperator.scala index 5e2c18c20..a47ae226b 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarString2TrimOperator.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarString2TrimOperator.scala @@ -32,6 +32,13 @@ class ColumnarStringTrim(srcStr: Expression, trimStr: Option[Expression], origin extends StringTrim(srcStr: Expression, trimStr: Option[Expression]) with ColumnarExpression with Logging { + val gName = "btrim" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + srcStr.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + trimStr.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() @@ -63,7 +70,13 @@ class ColumnarStringTrimLeft(srcStr: Expression, trimStr: Option[Expression], or extends StringTrimLeft(srcStr: Expression, trimStr: Option[Expression]) with ColumnarExpression with Logging { + val gName = "ltrim" + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + srcStr.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + trimStr.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() def buildCheck(): Unit = { @@ -93,7 +106,13 @@ class ColumnarStringTrimRight(child: Expression, trimStr: Option[Expression], or extends StringTrimRight(child: Expression, trimStr: Option[Expression]) with ColumnarExpression with Logging { + val gName = "rtrim" + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + srcStr.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + trimStr.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() def buildCheck(): Unit = { diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarTernaryOperator.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarTernaryOperator.scala index 2bb88571e..ac66e1bb4 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarTernaryOperator.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarTernaryOperator.scala @@ -39,6 +39,16 @@ class ColumnarSubString(str: Expression, pos: Expression, len: Expression, origi with ColumnarExpression with Logging { + + val gName = "substr" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + first.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + second.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + third.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + buildCheck() def buildCheck(): Unit = { @@ -117,6 +127,15 @@ class ColumnarStringTranslate(src: Expression, matchingExpr: Expression, replaceExpr: Expression, original: Expression) extends StringTranslate(src, matchingExpr, replaceExpr) with ColumnarExpression { + val gName = "translate" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + first.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + second.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) && + third.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + buildCheck def buildCheck: Unit = { diff --git a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarUnaryOperator.scala b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarUnaryOperator.scala index bd847b969..db1c117fb 100644 --- a/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarUnaryOperator.scala +++ b/native-sql-engine/core/src/main/scala/com/intel/oap/expression/ColumnarUnaryOperator.scala @@ -58,6 +58,12 @@ class ColumnarIsNotNull(child: Expression, original: Expression) extends IsNotNull(child: Expression) with ColumnarExpression with Logging { + val gName = "isnotnull" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() @@ -92,10 +98,17 @@ class ColumnarIsNotNull(child: Expression, original: Expression) } class ColumnarIsNull(child: Expression, original: Expression) - extends IsNotNull(child: Expression) + extends IsNull(child: Expression) with ColumnarExpression with Logging { + val gName = "isnull" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } + buildCheck() def buildCheck(): Unit = { @@ -282,6 +295,12 @@ class ColumnarAbs(child: Expression, original: Expression) extends Abs(child: Expression) with ColumnarExpression with Logging { + val gName = "abs" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() @@ -369,6 +388,12 @@ class ColumnarUpper(child: Expression, original: Expression) extends Upper(child: Expression) with ColumnarExpression with Logging { + val gName = "upper" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() @@ -395,6 +420,12 @@ class ColumnarLower(child: Expression, original: Expression) extends Lower(child: Expression) with ColumnarExpression with Logging { + val gName = "lower" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() @@ -415,10 +446,6 @@ class ColumnarLower(child: Expression, original: Expression) TreeBuilder.makeFunction("lower", Lists.newArrayList(child_node), resultType) (funcNode, resultType) } - - override def supportColumnarCodegen(args: java.lang.Object): Boolean = { - false - } } class ColumnarBitwiseNot(child: Expression, original: Expression) @@ -492,6 +519,12 @@ class ColumnarCast( extends Cast(child: Expression, datatype: DataType, timeZoneId: Option[String]) with ColumnarExpression with Logging { + val gName = "Cast" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + true && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck() @@ -874,6 +907,12 @@ class ColumnarNormalizeNaNAndZero(child: Expression, original: NormalizeNaNAndZe extends NormalizeNaNAndZero(child: Expression) with ColumnarExpression with Logging { + val gName = "normalize" + + override def supportColumnarCodegen(args: java.lang.Object): Boolean = { + codegenFuncList.contains(gName) && + child.asInstanceOf[ColumnarExpression].supportColumnarCodegen(args) + } buildCheck()