address comments

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/intervalExpressions.scala

@@ -113,9 +113,6 @@ object ExtractIntervalPart {
 abstract class IntervalNumOperation(interval: Expression, num: Expression, operationName: String)
   extends BinaryExpression with ImplicitCastInputTypes with Serializable {
 
-  protected val methodStr: String =
-    IntervalUtils.getClass.getName.stripSuffix("$") + "." + operationName + "Exact"
-
   override def left: Expression = interval
   override def right: Expression = num
 
@@ -125,41 +122,39 @@ abstract class IntervalNumOperation(interval: Expression, num: Expression, opera
 
   override def nullable: Boolean = true
 
-  override def prettyName: String = operationName + "_interval"
-}
-
-case class MultiplyInterval(interval: Expression, num: Expression)
-  extends IntervalNumOperation(interval, num, "multiply") {
-
-  override def nullSafeEval(interval: Any, num: Any): Any = {
-    multiplyExact(interval.asInstanceOf[CalendarInterval], num.asInstanceOf[Double])
+  override def nullSafeEval(interval: Any, num: Any): Any = operationName match {
+    case "multiply" =>
+      multiplyExact(interval.asInstanceOf[CalendarInterval], num.asInstanceOf[Double])
+    case "divide" =>
+      if (num == 0) return null
+      divideExact(interval.asInstanceOf[CalendarInterval], num.asInstanceOf[Double])
   }
 
   override def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode = {
-    defineCodeGen(ctx, ev, (interval, num) => s"$methodStr($interval, $num)")
+    val methodStr: String =
+      IntervalUtils.getClass.getName.stripSuffix("$") + "." + operationName + "Exact"
+    operationName match {
+      case "multiply" => defineCodeGen(ctx, ev, (interval, num) => s"$methodStr($interval, $num)")
+      case "divide" => nullSafeCodeGen(ctx, ev, (interval, num) => {
+        s"""
+           |if ($num == 0) {
+           |  ${ev.isNull} = true;
+           |} else {
+           |  ${ev.value} = $methodStr($interval, $num);
+           |}
+           |""".stripMargin
+      })
+    }
   }
-}
 
-case class DivideInterval(interval: Expression, num: Expression)
-  extends IntervalNumOperation(interval, num, "divide") {
+  override def prettyName: String = operationName + "_interval"
+}
 
-  override def nullSafeEval(interval: Any, num: Any): Any = {
-    if (num == 0) return null
-    divideExact(interval.asInstanceOf[CalendarInterval], num.asInstanceOf[Double])
-  }
+case class MultiplyInterval(interval: Expression, num: Expression)
+  extends IntervalNumOperation(interval, num, "multiply")
 
-  override def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode = {
-    nullSafeCodeGen(ctx, ev, (interval, num) => {
-      s"""
-         |if ($num == 0) {
-         |  ${ev.isNull} = true;
-         |} else {
-         |  ${ev.value} = $methodStr($interval, $num);
-         |}
-         |""".stripMargin
-    })
-  }
-}
+case class DivideInterval(interval: Expression, num: Expression)
+  extends IntervalNumOperation(interval, num, "divide")
 
 // scalastyle:off line.size.limit
 @ExpressionDescription(

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/util/IntervalUtils.scala

@@ -429,7 +429,6 @@ object IntervalUtils {
 
   /**
    * Unary minus, return the negated the calendar interval value.
-   *
    */
   def negate(interval: CalendarInterval): CalendarInterval = {
     new CalendarInterval(-interval.months, -interval.days, -interval.microseconds)
@@ -462,7 +461,6 @@ object IntervalUtils {
    * Return a new calendar interval instance of the left interval minus the right one.
    *
    * @throws ArithmeticException if the result overflows any field value
-   *
    */
   def subtractExact(left: CalendarInterval, right: CalendarInterval): CalendarInterval = {
     val months = Math.subtractExact(left.months, right.months)

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/IntervalExpressionsSuite.scala

@@ -198,9 +198,12 @@ class IntervalExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper {
   }
 
   test("multiply") {
-    def check(interval: String, num: Double, expected: String,
-        modes: Seq[String] = Seq("true", "false"), checkException: Boolean = false): Unit = {
-      modes.foreach { v =>
+    def check(
+        interval: String,
+        num: Double,
+        expected: String,
+        checkException: Boolean = false): Unit = {
+      Seq("true", "false").foreach { v =>
         withSQLConf(SQLConf.ANSI_ENABLED.key -> v) {
           if (checkException) {
             checkExceptionInExpression[ArithmeticException](
@@ -222,15 +225,25 @@ class IntervalExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper {
     check("-100 years -1 millisecond", 0.5, "-50 years -500 microseconds")
     check("2 months 4 seconds", -0.5, "-1 months -2 seconds")
     check("1 month 2 microseconds", 1.5, "1 months 15 days 3 microseconds")
-    check("2 months", Int.MaxValue, CalendarInterval.MAX_VALUE.toString, checkException = true)
+    check("2 months", Int.MaxValue, null, checkException = true)
   }
 
   test("divide") {
-    def check(interval: String, num: Double, expected: String): Unit = {
+    def check(
+        interval: String,
+        num: Double,
+        expected: String,
+        checkException: Boolean = false): Unit = {
       Seq("true", "false").foreach { v =>
         withSQLConf(SQLConf.ANSI_ENABLED.key -> v) {
-          checkEvaluation(DivideInterval(Literal(stringToInterval(interval)), Literal(num)),
-            if (expected == null) null else stringToInterval(expected))
+          if (checkException) {
+            checkExceptionInExpression[ArithmeticException](
+              DivideInterval(Literal(stringToInterval(interval)), Literal(num)),
+              "integer overflow")
+          } else {
+            checkEvaluation(DivideInterval(Literal(stringToInterval(interval)), Literal(num)),
+              if (expected == null) null else stringToInterval(expected))
+          }
         }
       }
     }
@@ -243,6 +256,7 @@ class IntervalExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper {
     check("-1 month 2 microseconds", -0.25, "4 months -8 microseconds")
     check("1 month 3 microsecond", 1.5, "20 days 2 microseconds")
     check("1 second", 0, null)
+    check(s"${Int.MaxValue} months", 0.9, null, checkException = true)
   }
 
   test("make interval") {