From 2e5e3107f8c3c5d140d5c393e887ee6f0861d231 Mon Sep 17 00:00:00 2001 From: "Robert (Bobby) Evans" Date: Mon, 10 Jan 2022 15:44:35 -0600 Subject: [PATCH 1/3] Switch and/or to use new cudf binops to improve performance Signed-off-by: Robert (Bobby) Evans --- .../apache/spark/sql/rapids/predicates.scala | 133 +----------------- 1 file changed, 2 insertions(+), 131 deletions(-) diff --git a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala index f86c24d89bb..f6dccefb1d7 100644 --- a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala +++ b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala @@ -56,11 +56,6 @@ case class GpuNot(child: Expression) extends CudfUnaryExpression } } -object GpuLogicHelper { - def eqNullAware(lhs: GpuScalar, rhs: Boolean): Boolean = - lhs.isValid && (lhs.getValue.asInstanceOf[Boolean] == rhs) -} - case class GpuAnd(left: Expression, right: Expression) extends CudfBinaryOperator with Predicate { override def inputType: AbstractDataType = BooleanType @@ -68,69 +63,7 @@ case class GpuAnd(left: Expression, right: Expression) extends CudfBinaryOperato override def sqlOperator: String = "AND" - override def binaryOp: BinaryOp = BinaryOp.LOGICAL_AND - - import GpuLogicHelper._ - - // The CUDF implementation of `and` will return a null if either input is null - // Spark does not. - // |LHS/RHS| TRUE | FALSE | NULL | - // |TRUE | TRUE | FALSE | NULL | - // |FALSE | FALSE | FALSE | FALSE | - // |NULL | NULL | FALSE | NULL | - // So we have to make some adjustments. - // IF (A <=> FALSE, FALSE, - // IF (B <=> FALSE, FALSE, - // A cudf_and B)) - - override def doColumnar(lhs: GpuColumnVector, rhs: GpuColumnVector): ColumnVector = { - val l = lhs.getBase - val r = rhs.getBase - withResource(Scalar.fromBool(false)) { falseVal => - val firstPass = withResource(l.and(r)) { lAndR => - withResource(l.equalToNullAware(falseVal)) { lIsFalse => - lIsFalse.ifElse(falseVal, lAndR) - } - } - withResource(firstPass) { firstPass => - withResource(r.equalToNullAware(falseVal)) { rIsFalse => - rIsFalse.ifElse(falseVal, firstPass) - } - } - } - } - - override def doColumnar(lhs: GpuScalar, rhs: GpuColumnVector): ColumnVector = { - val l = lhs.getBase - val r = rhs.getBase - withResource(Scalar.fromBool(false)) { falseVal => - if (eqNullAware(lhs, false)) { - ColumnVector.fromScalar(falseVal, r.getRowCount.toInt) - } else { - withResource(l.and(r)) { lAndR => - withResource(r.equalToNullAware(falseVal)) { rIsFalse => - rIsFalse.ifElse(falseVal, lAndR) - } - } - } - } - } - - override def doColumnar(lhs: GpuColumnVector, rhs: GpuScalar): ColumnVector = { - val l = lhs.getBase - val r = rhs.getBase - withResource(Scalar.fromBool(false)) { falseVal => - if (eqNullAware(rhs, false)) { - ColumnVector.fromScalar(falseVal, l.getRowCount.toInt) - } else { - withResource(l.and(r)) { lAndR => - withResource(l.equalToNullAware(falseVal)) { lIsFalse => - lIsFalse.ifElse(falseVal, lAndR) - } - } - } - } - } + override def binaryOp: BinaryOp = BinaryOp.NULL_LOGICAL_AND } case class GpuOr(left: Expression, right: Expression) extends CudfBinaryOperator with Predicate { @@ -140,69 +73,7 @@ case class GpuOr(left: Expression, right: Expression) extends CudfBinaryOperator override def sqlOperator: String = "OR" - override def binaryOp: BinaryOp = BinaryOp.LOGICAL_OR - - import GpuLogicHelper._ - - // The CUDF implementation of `or` will return a null if either input is null - // Spark does not. - // |LHS/RHS| TRUE | FALSE | NULL | - // |TRUE | TRUE | TRUE | TRUE | - // |FALSE | TRUE | FALSE | NULL | - // |NULL | TRUE | NULL | NULL | - // So we have to make some adjustments. - // IF (A <=> TRUE, TRUE, - // IF (B <=> TRUE, TRUE, - // A cudf_or B)) - - override def doColumnar(lhs: GpuColumnVector, rhs: GpuColumnVector): ColumnVector = { - val l = lhs.getBase - val r = rhs.getBase - withResource(Scalar.fromBool(true)) { trueVal => - val firstPass = withResource(l.or(r)) { lOrR => - withResource(l.equalToNullAware(trueVal)) { lIsTrue => - lIsTrue.ifElse(trueVal, lOrR) - } - } - withResource(firstPass) { firstPass => - withResource(r.equalToNullAware(trueVal)) { rIsTrue => - rIsTrue.ifElse(trueVal, firstPass) - } - } - } - } - - override def doColumnar(lhs: GpuScalar, rhs: GpuColumnVector): ColumnVector = { - val l = lhs.getBase - val r = rhs.getBase - withResource(Scalar.fromBool(true)) { trueVal => - if (eqNullAware(lhs, true)) { - ColumnVector.fromScalar(trueVal, r.getRowCount.toInt) - } else { - withResource(l.or(r)) { lOrR => - withResource(r.equalToNullAware(trueVal)) { rIsTrue => - rIsTrue.ifElse(trueVal, lOrR) - } - } - } - } - } - - override def doColumnar(lhs: GpuColumnVector, rhs: GpuScalar): ColumnVector = { - val l = lhs.getBase - val r = rhs.getBase - withResource(Scalar.fromBool(true)) { trueVal => - if (eqNullAware(rhs, true)) { - ColumnVector.fromScalar(trueVal, l.getRowCount.toInt) - } else { - withResource(l.or(r)) { lOrR => - withResource(l.equalToNullAware(trueVal)) { lIsFalse => - lIsFalse.ifElse(trueVal, lOrR) - } - } - } - } - } + override def binaryOp: BinaryOp = BinaryOp.NULL_LOGICAL_OR } abstract class CudfBinaryComparison extends CudfBinaryOperator with Predicate { From ab7d064eedad09ee6a44b831df2786d8d2c595f3 Mon Sep 17 00:00:00 2001 From: "Robert (Bobby) Evans" Date: Tue, 11 Jan 2022 15:16:18 -0600 Subject: [PATCH 2/3] Follow on issues and an AST fix --- .../com/nvidia/spark/rapids/GpuExpressions.scala | 2 ++ .../spark/rapids/conditionalExpressions.scala | 14 +++----------- .../org/apache/spark/sql/rapids/predicates.scala | 12 ++++++------ 3 files changed, 11 insertions(+), 17 deletions(-) diff --git a/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala b/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala index afc120242f8..cf06da00541 100644 --- a/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala +++ b/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala @@ -282,7 +282,9 @@ object CudfBinaryExpression { BinaryOp.LESS -> ast.BinaryOperator.LESS, BinaryOp.LESS_EQUAL -> ast.BinaryOperator.LESS_EQUAL, BinaryOp.LOGICAL_AND -> ast.BinaryOperator.NULL_LOGICAL_AND, + BinaryOp.NULL_LOGICAL_AND -> ast.BinaryOperator.NULL_LOGICAL_AND, BinaryOp.LOGICAL_OR -> ast.BinaryOperator.NULL_LOGICAL_OR, + BinaryOp.NULL_LOGICAL_OR -> ast.BinaryOperator.NULL_LOGICAL_OR, BinaryOp.MUL -> ast.BinaryOperator.MUL, BinaryOp.POW -> ast.BinaryOperator.POW, BinaryOp.SUB -> ast.BinaryOperator.SUB) diff --git a/sql-plugin/src/main/scala/com/nvidia/spark/rapids/conditionalExpressions.scala b/sql-plugin/src/main/scala/com/nvidia/spark/rapids/conditionalExpressions.scala index 7c82883c383..5e63cbdcd31 100644 --- a/sql-plugin/src/main/scala/com/nvidia/spark/rapids/conditionalExpressions.scala +++ b/sql-plugin/src/main/scala/com/nvidia/spark/rapids/conditionalExpressions.scala @@ -16,8 +16,7 @@ package com.nvidia.spark.rapids -import ai.rapids.cudf.{ColumnVector, NullPolicy, Scalar, ScanAggregation, ScanType, Table, UnaryOp} -import ai.rapids.cudf.ast +import ai.rapids.cudf.{BinaryOp, ColumnVector, DType, NullPolicy, Scalar, ScanAggregation, ScanType, Table, UnaryOp} import com.nvidia.spark.rapids.RapidsPluginImplicits._ import com.nvidia.spark.rapids.shims.v2.ShimExpression @@ -441,15 +440,8 @@ case class GpuCaseWhen( cumulativePred match { case Some(prev) => withResource(prev) { _ => - val result = withResource(new Table(prev.getBase, whenBool.getBase)) { t => - val or = new ast.BinaryOperation(ast.BinaryOperator.NULL_LOGICAL_OR, - new ast.ColumnReference(0), - new ast.ColumnReference(1) - ) - withResource(or.compile()) { - _.computeColumn(t) - } - } + val result = prev.getBase.binaryOp(BinaryOp.NULL_LOGICAL_OR, + whenBool.getBase, DType.BOOL8) GpuColumnVector.from(result, DataTypes.BooleanType) } case _ => diff --git a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala index f6dccefb1d7..0f914cfb795 100644 --- a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala +++ b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019-2021, NVIDIA CORPORATION. + * Copyright (c) 2019-2022, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -87,7 +87,7 @@ abstract class CudfBinaryComparison extends CudfBinaryOperator with Predicate { case failure => failure } - def hasFloatingPointInputs = left.dataType == FloatType || left.dataType == DoubleType || + def hasFloatingPointInputs: Boolean = left.dataType == FloatType || left.dataType == DoubleType || right.dataType == FloatType || right.dataType == DoubleType } @@ -117,8 +117,8 @@ case class GpuEqualTo(left: Expression, right: Expression) extends CudfBinaryCom val result = super.doColumnar(lhs, rhs) if (hasFloatingPointInputs) { withResource(result) { result => - withResource(lhs.getBase.isNan()) { lhsNan => - withResource(rhs.getBase.isNan()) { rhsNan => + withResource(lhs.getBase.isNan) { lhsNan => + withResource(rhs.getBase.isNan) { rhsNan => withResource(lhsNan.and(rhsNan)) { lhsNanAndRhsNan => lhsNanAndRhsNan.or(result) } @@ -135,7 +135,7 @@ case class GpuEqualTo(left: Expression, right: Expression) extends CudfBinaryCom if (hasFloatingPointInputs) { withResource(result) { result => withResource(Scalar.fromBool(lhs.isNan)) { lhsNan => - withResource(rhs.getBase.isNan()) { rhsNan => + withResource(rhs.getBase.isNan) { rhsNan => withResource(lhsNan.and(rhsNan)) { lhsNanAndRhsNan => lhsNanAndRhsNan.or(result) } @@ -219,7 +219,7 @@ case class GpuEqualNullSafe(left: Expression, right: Expression) extends CudfBin val result = super.doColumnar(lhs, rhs) if (hasFloatingPointInputs) { withResource(result) { result => - withResource(lhs.getBase.isNan()) { lhsNan => + withResource(lhs.getBase.isNan) { lhsNan => withResource(Scalar.fromBool(rhs.isNan)) { rhsNan => withResource(lhsNan.and(rhsNan)) { lhsNanAndRhsNan => lhsNanAndRhsNan.or(result) From c7fb79787aa5de7942251c5c19f4b05cf5f9bab8 Mon Sep 17 00:00:00 2001 From: "Robert (Bobby) Evans" Date: Thu, 20 Jan 2022 17:27:51 -0600 Subject: [PATCH 3/3] Cleaup and addressed review comments --- .../nvidia/spark/rapids/GpuExpressions.scala | 24 +++---------------- .../apache/spark/sql/rapids/arithmetic.scala | 4 ++++ .../org/apache/spark/sql/rapids/bitwise.scala | 8 +++++-- .../spark/sql/rapids/mathExpressions.scala | 4 +++- .../apache/spark/sql/rapids/predicates.scala | 7 ++++++ 5 files changed, 23 insertions(+), 24 deletions(-) diff --git a/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala b/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala index cf06da00541..f8e2c5ebe68 100644 --- a/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala +++ b/sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuExpressions.scala @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019-2021, NVIDIA CORPORATION. + * Copyright (c) 2019-2022, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -271,29 +271,11 @@ trait GpuBinaryExpression extends ShimBinaryExpression with GpuExpression { trait GpuBinaryOperator extends BinaryOperator with GpuBinaryExpression -object CudfBinaryExpression { - lazy val opToAstMap: Map[BinaryOp, ast.BinaryOperator] = Map( - BinaryOp.ADD -> ast.BinaryOperator.ADD, - BinaryOp.BITWISE_AND -> ast.BinaryOperator.BITWISE_AND, - BinaryOp.BITWISE_OR -> ast.BinaryOperator.BITWISE_OR, - BinaryOp.BITWISE_XOR -> ast.BinaryOperator.BITWISE_XOR, - BinaryOp.GREATER -> ast.BinaryOperator.GREATER, - BinaryOp.GREATER_EQUAL -> ast.BinaryOperator.GREATER_EQUAL, - BinaryOp.LESS -> ast.BinaryOperator.LESS, - BinaryOp.LESS_EQUAL -> ast.BinaryOperator.LESS_EQUAL, - BinaryOp.LOGICAL_AND -> ast.BinaryOperator.NULL_LOGICAL_AND, - BinaryOp.NULL_LOGICAL_AND -> ast.BinaryOperator.NULL_LOGICAL_AND, - BinaryOp.LOGICAL_OR -> ast.BinaryOperator.NULL_LOGICAL_OR, - BinaryOp.NULL_LOGICAL_OR -> ast.BinaryOperator.NULL_LOGICAL_OR, - BinaryOp.MUL -> ast.BinaryOperator.MUL, - BinaryOp.POW -> ast.BinaryOperator.POW, - BinaryOp.SUB -> ast.BinaryOperator.SUB) -} - trait CudfBinaryExpression extends GpuBinaryExpression { def binaryOp: BinaryOp def outputTypeOverride: DType = null def castOutputAtEnd: Boolean = false + def astOperator: Option[ast.BinaryOperator] = None def outputType(l: BinaryOperable, r: BinaryOperable): DType = { val over = outputTypeOverride @@ -341,7 +323,7 @@ trait CudfBinaryExpression extends GpuBinaryExpression { } override def convertToAst(numFirstTableColumns: Int): ast.AstExpression = { - val astOp = CudfBinaryExpression.opToAstMap.getOrElse(binaryOp, + val astOp = astOperator.getOrElse( throw new IllegalStateException(s"$this is not supported by AST")) assert(left.dataType == right.dataType) new ast.BinaryOperation(astOp, diff --git a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/arithmetic.scala b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/arithmetic.scala index faa001918f6..a704725dff2 100644 --- a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/arithmetic.scala +++ b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/arithmetic.scala @@ -19,6 +19,7 @@ package org.apache.spark.sql.rapids import java.math.BigInteger import ai.rapids.cudf._ +import ai.rapids.cudf.ast.BinaryOperator import com.nvidia.spark.rapids._ import com.nvidia.spark.rapids.RapidsPluginImplicits._ import com.nvidia.spark.rapids.shims.v2.ShimExpression @@ -219,6 +220,7 @@ case class GpuAdd( override def symbol: String = "+" override def binaryOp: BinaryOp = BinaryOp.ADD + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.ADD) override def doColumnar(lhs: BinaryOperable, rhs: BinaryOperable): ColumnVector = { val ret = super.doColumnar(lhs, rhs) @@ -246,6 +248,7 @@ case class GpuSubtract( override def symbol: String = "-" override def binaryOp: BinaryOp = BinaryOp.SUB + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.SUB) private[this] def basicOpOverflowCheck( lhs: BinaryOperable, @@ -534,6 +537,7 @@ case class GpuMultiply( override def symbol: String = "*" override def binaryOp: BinaryOp = BinaryOp.MUL + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.MUL) } object GpuDivModLike extends Arm { diff --git a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/bitwise.scala b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/bitwise.scala index 7a11447b153..b7341a1dbcf 100644 --- a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/bitwise.scala +++ b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/bitwise.scala @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021, NVIDIA CORPORATION. + * Copyright (c) 2020-2022, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,8 @@ package org.apache.spark.sql.rapids -import ai.rapids.cudf.{BinaryOp, ColumnVector, DType, Scalar, UnaryOp} +import ai.rapids.cudf.{ast, BinaryOp, ColumnVector, DType, Scalar, UnaryOp} +import ai.rapids.cudf.ast.BinaryOperator import com.nvidia.spark.rapids._ import org.apache.spark.sql.catalyst.expressions.{ExpectsInputTypes, Expression, ImplicitCastInputTypes} @@ -120,6 +121,7 @@ case class GpuBitwiseAnd(left: Expression, right: Expression) extends CudfBinary override def symbol: String = "&" override def binaryOp: BinaryOp = BinaryOp.BITWISE_AND + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.BITWISE_AND) } case class GpuBitwiseOr(left: Expression, right: Expression) extends CudfBinaryArithmetic { @@ -128,6 +130,7 @@ case class GpuBitwiseOr(left: Expression, right: Expression) extends CudfBinaryA override def symbol: String = "|" override def binaryOp: BinaryOp = BinaryOp.BITWISE_OR + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.BITWISE_OR) } case class GpuBitwiseXor(left: Expression, right: Expression) extends CudfBinaryArithmetic { @@ -136,6 +139,7 @@ case class GpuBitwiseXor(left: Expression, right: Expression) extends CudfBinary override def symbol: String = "^" override def binaryOp: BinaryOp = BinaryOp.BITWISE_XOR + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.BITWISE_XOR) } case class GpuBitwiseNot(child: Expression) extends CudfUnaryExpression with ExpectsInputTypes { diff --git a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/mathExpressions.scala b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/mathExpressions.scala index f84aa67a9e2..a0f42737d48 100644 --- a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/mathExpressions.scala +++ b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/mathExpressions.scala @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019-2021, NVIDIA CORPORATION. + * Copyright (c) 2019-2022, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,6 +19,7 @@ package org.apache.spark.sql.rapids import java.io.Serializable import ai.rapids.cudf._ +import ai.rapids.cudf.ast.BinaryOperator import com.nvidia.spark.rapids._ import com.nvidia.spark.rapids.RapidsPluginImplicits.ReallyAGpuExpression @@ -650,6 +651,7 @@ case class GpuRound(child: Expression, scale: Expression) extends case class GpuPow(left: Expression, right: Expression) extends CudfBinaryMathExpression("POWER") { override def binaryOp: BinaryOp = BinaryOp.POW + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.POW) override def outputTypeOverride: DType = DType.FLOAT64 } diff --git a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala index 0f914cfb795..a98a728a1b3 100644 --- a/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala +++ b/sql-plugin/src/main/scala/org/apache/spark/sql/rapids/predicates.scala @@ -17,6 +17,7 @@ package org.apache.spark.sql.rapids import ai.rapids.cudf._ +import ai.rapids.cudf.ast.BinaryOperator import com.nvidia.spark.rapids._ import org.apache.spark.sql.catalyst.analysis.TypeCheckResult @@ -64,6 +65,7 @@ case class GpuAnd(left: Expression, right: Expression) extends CudfBinaryOperato override def sqlOperator: String = "AND" override def binaryOp: BinaryOp = BinaryOp.NULL_LOGICAL_AND + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.NULL_LOGICAL_AND) } case class GpuOr(left: Expression, right: Expression) extends CudfBinaryOperator with Predicate { @@ -74,6 +76,7 @@ case class GpuOr(left: Expression, right: Expression) extends CudfBinaryOperator override def sqlOperator: String = "OR" override def binaryOp: BinaryOp = BinaryOp.NULL_LOGICAL_OR + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.NULL_LOGICAL_OR) } abstract class CudfBinaryComparison extends CudfBinaryOperator with Predicate { @@ -256,6 +259,7 @@ case class GpuGreaterThan(left: Expression, right: Expression) extends CudfBinar override def outputTypeOverride: DType = DType.BOOL8 override def binaryOp: BinaryOp = BinaryOp.GREATER + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.GREATER) override def doColumnar(lhs: GpuColumnVector, rhs: GpuColumnVector): ColumnVector = { val result = super.doColumnar(lhs, rhs) @@ -332,6 +336,7 @@ case class GpuGreaterThanOrEqual(left: Expression, right: Expression) extends Cu override def outputTypeOverride: DType = DType.BOOL8 override def binaryOp: BinaryOp = BinaryOp.GREATER_EQUAL + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.GREATER_EQUAL) override def doColumnar(lhs: GpuColumnVector, rhs: GpuColumnVector): ColumnVector = { val result = super.doColumnar(lhs, rhs) @@ -400,6 +405,7 @@ case class GpuLessThan(left: Expression, right: Expression) extends CudfBinaryCo override def outputTypeOverride: DType = DType.BOOL8 override def binaryOp: BinaryOp = BinaryOp.LESS + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.LESS) override def doColumnar(lhs: GpuColumnVector, rhs: GpuColumnVector): ColumnVector = { val result = super.doColumnar(lhs, rhs) @@ -476,6 +482,7 @@ case class GpuLessThanOrEqual(left: Expression, right: Expression) extends CudfB override def outputTypeOverride: DType = DType.BOOL8 override def binaryOp: BinaryOp = BinaryOp.LESS_EQUAL + override def astOperator: Option[BinaryOperator] = Some(ast.BinaryOperator.LESS_EQUAL) override def doColumnar(lhs: GpuColumnVector, rhs: GpuColumnVector): ColumnVector = { val result = super.doColumnar(lhs, rhs)