fix ut

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

@@ -34,7 +34,7 @@ import org.apache.spark.sql.catalyst.expressions.aggregate._
 import org.apache.spark.sql.catalyst.expressions.objects._
 import org.apache.spark.sql.catalyst.plans._
 import org.apache.spark.sql.catalyst.plans.logical._
-import org.apache.spark.sql.catalyst.rules.{Rule, _}
+import org.apache.spark.sql.catalyst.rules._
 import org.apache.spark.sql.catalyst.trees.TreeNodeRef
 import org.apache.spark.sql.catalyst.util.toPrettySQL
 import org.apache.spark.sql.connector.catalog.{CatalogManager, CatalogPlugin, CatalogV2Util, Identifier, LookupCatalog, Table, TableCatalog, TableChange, V1Table}
@@ -285,7 +285,7 @@ class Analyzer(
           case (CalendarIntervalType, CalendarIntervalType) => Subtract(l, r)
           case (_, CalendarIntervalType) => Cast(TimeSub(l, r), l.dataType)
           case (TimestampType, _) => SubtractTimestamps(l, r)
-          case (_, TimestampType) => SubtractTimestamps(Cast(l, TimestampType), r)
+          case (_, TimestampType) => SubtractTimestamps(l, r)
           case (_, DateType) => if (conf.usePostgreSQLDialect) {
             DateDiff(l, r)
           } else {

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/dsl/package.scala

@@ -68,10 +68,10 @@ package object dsl {
     def unary_! : Predicate = Not(expr)
     def unary_~ : Expression = BitwiseNot(expr)
 
-    def + (other: Expression): Expression = UnresolvedAdd(expr, other)
-    def - (other: Expression): Expression = UnresolvedSubtract(expr, other)
-    def * (other: Expression): Expression = UnresolvedMultiply(expr, other)
-    def / (other: Expression): Expression = UnresolvedDivide(expr, other)
+    def + (other: Expression): Expression = Add(expr, other)
+    def - (other: Expression): Expression = Subtract(expr, other)
+    def * (other: Expression): Expression = Multiply(expr, other)
+    def / (other: Expression): Expression = Divide(expr, other)
     def div (other: Expression): Expression = IntegralDivide(expr, other)
     def % (other: Expression): Expression = Remainder(expr, other)
     def & (other: Expression): Expression = BitwiseAnd(expr, other)

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Average.scala

@@ -72,8 +72,8 @@ case class Average(child: Expression) extends DeclarativeAggregate with Implicit
   )
 
   override lazy val mergeExpressions = Seq(
-    /* sum = */ Add(sum.left, sum.right),
-    /* count = */ Add(count.left, count.right)
+    /* sum = */ sum.left + sum.right,
+    /* count = */ count.left + count.right
   )
 
   // If all input are nulls, count will be 0 and we will get null after the division.
@@ -83,14 +83,14 @@ case class Average(child: Expression) extends DeclarativeAggregate with Implicit
     case CalendarIntervalType =>
       DivideInterval(sum.cast(resultType), count.cast(DoubleType))
     case _ =>
-      Divide(sum.cast(resultType), count.cast(resultType))
+      sum.cast(resultType) / count.cast(resultType)
   }
 
   override lazy val updateExpressions: Seq[Expression] = Seq(
     /* sum = */
     Add(
       sum,
       coalesce(child.cast(sumDataType), Literal.default(sumDataType))),
-    /* count = */ If(child.isNull, count, Add(count, 1L))
+    /* count = */ If(child.isNull, count, count + 1L)
   )
 }

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Sum.scala

@@ -73,20 +73,20 @@ case class Sum(child: Expression) extends DeclarativeAggregate with ImplicitCast
     if (child.nullable) {
       Seq(
         /* sum = */
-        coalesce(Add(coalesce(sum, zero), child.cast(sumDataType)), sum)
+        coalesce(coalesce(sum, zero) + child.cast(sumDataType), sum)
       )
     } else {
       Seq(
         /* sum = */
-        Add(coalesce(sum, zero), child.cast(sumDataType))
+        coalesce(sum, zero) + child.cast(sumDataType)
       )
     }
   }
 
   override lazy val mergeExpressions: Seq[Expression] = {
     Seq(
       /* sum = */
-      coalesce(Add(coalesce(sum.left, zero), sum.right), sum.left)
+      coalesce(coalesce(sum.left, zero) + sum.right, sum.left)
     )
   }
 

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ExpressionParserSuite.scala

@@ -209,20 +209,22 @@ class ExpressionParserSuite extends AnalysisTest {
 
   test("binary arithmetic expressions") {
     // Simple operations
-    assertEqual("a * b", 'a * 'b)
-    assertEqual("a / b", 'a / 'b)
+    assertEqual("a * b", UnresolvedMultiply('a, 'b))
+    assertEqual("a / b", UnresolvedDivide('a, 'b))
     assertEqual("a DIV b", 'a div 'b)
     assertEqual("a % b", 'a % 'b)
-    assertEqual("a + b", 'a + 'b)
-    assertEqual("a - b", 'a - 'b)
+    assertEqual("a + b", UnresolvedAdd('a, 'b))
+    assertEqual("a - b", UnresolvedSubtract('a, 'b))
     assertEqual("a & b", 'a & 'b)
     assertEqual("a ^ b", 'a ^ 'b)
     assertEqual("a | b", 'a | 'b)
 
     // Check precedences
     assertEqual(
       "a * t | b ^ c & d - e + f % g DIV h / i * k",
-      'a * 't | ('b ^ ('c & ('d - 'e + (('f % 'g div 'h) / 'i * 'k)))))
+      UnresolvedMultiply('a, 't) |
+        ('b ^ ('c & UnresolvedAdd(UnresolvedSubtract('d, 'e),
+          UnresolvedMultiply(UnresolvedDivide(('f % 'g) div 'h, 'i), 'k)))))
   }
 
   test("unary arithmetic expressions") {
@@ -257,8 +259,9 @@ class ExpressionParserSuite extends AnalysisTest {
   private def lv(s: Symbol) = UnresolvedNamedLambdaVariable(Seq(s.name))
 
   test("lambda functions") {
-    assertEqual("x -> x + 1", LambdaFunction(lv('x) + 1, Seq(lv('x))))
-    assertEqual("(x, y) -> x + y", LambdaFunction(lv('x) + lv('y), Seq(lv('x), lv('y))))
+    assertEqual("x -> x + 1", LambdaFunction(UnresolvedAdd(lv('x), 1), Seq(lv('x))))
+    assertEqual("(x, y) -> x + y",
+      LambdaFunction(UnresolvedAdd(lv('x), lv('y)), Seq(lv('x), lv('y))))
   }
 
   test("window function expressions") {
@@ -284,12 +287,14 @@ class ExpressionParserSuite extends AnalysisTest {
     // Test use of expressions in window functions.
     assertEqual(
       "sum(product + 1) over (partition by ((product) + (1)) order by 2)",
-      WindowExpression('sum.function('product + 1),
-        WindowSpecDefinition(Seq('product + 1), Seq(Literal(2).asc), UnspecifiedFrame)))
+      WindowExpression('sum.function(UnresolvedAdd('product, 1)),
+        WindowSpecDefinition(
+          Seq(UnresolvedAdd('product, 1)), Seq(Literal(2).asc), UnspecifiedFrame)))
     assertEqual(
       "sum(product + 1) over (partition by ((product / 2) + 1) order by 2)",
-      WindowExpression('sum.function('product + 1),
-        WindowSpecDefinition(Seq('product / 2 + 1), Seq(Literal(2).asc), UnspecifiedFrame)))
+      WindowExpression('sum.function(UnresolvedAdd('product, 1)),
+        WindowSpecDefinition(Seq(UnresolvedAdd(UnresolvedDivide('product, 2), 1)),
+          Seq(Literal(2).asc), UnspecifiedFrame)))
   }
 
   test("range/rows window function expressions") {
@@ -390,13 +395,14 @@ class ExpressionParserSuite extends AnalysisTest {
     assertEqual("case when a = 1 then b when a = 2 then c else d end",
       CaseWhen(Seq(('a === 1, 'b.expr), ('a === 2, 'c.expr)), 'd))
     assertEqual("case when (1) + case when a > b then c else d end then f else g end",
-      CaseWhen(Seq((Literal(1) + CaseWhen(Seq(('a > 'b, 'c.expr)), 'd.expr), 'f.expr)), 'g))
+      CaseWhen(
+        Seq((UnresolvedAdd(Literal(1), CaseWhen(Seq(('a > 'b, 'c.expr)), 'd.expr)), 'f.expr)), 'g))
   }
 
   test("dereference") {
     assertEqual("a.b", UnresolvedAttribute("a.b"))
     assertEqual("`select`.b", UnresolvedAttribute("select.b"))
-    assertEqual("(a + b).b", ('a + 'b).getField("b")) // This will fail analysis.
+    assertEqual("(a + b).b", UnresolvedAdd('a, 'b).getField("b")) // This will fail analysis.
     assertEqual(
       "struct(a, b).b",
       namedStruct(NamePlaceholder, 'a, NamePlaceholder, 'b).getField("b"))
@@ -418,13 +424,13 @@ class ExpressionParserSuite extends AnalysisTest {
 
   test("subscript") {
     assertEqual("a[b]", 'a.getItem('b))
-    assertEqual("a[1 + 1]", 'a.getItem(Literal(1) + 1))
+    assertEqual("a[1 + 1]", 'a.getItem(UnresolvedAdd(Literal(1), 1)))
     assertEqual("`c`.a[b]", UnresolvedAttribute("c.a").getItem('b))
   }
 
   test("parenthesis") {
     assertEqual("(a)", 'a)
-    assertEqual("r * (a + b)", 'r * ('a + 'b))
+    assertEqual("r * (a + b)", UnresolvedMultiply('r, UnresolvedAdd('a, 'b)))
   }
 
   test("type constructors") {
@@ -749,8 +755,9 @@ class ExpressionParserSuite extends AnalysisTest {
   }
 
   test("composed expressions") {
-    assertEqual("1 + r.r As q", (Literal(1) + UnresolvedAttribute("r.r")).as("q"))
-    assertEqual("1 - f('o', o(bar))", Literal(1) - 'f.function("o", 'o.function('bar)))
+    assertEqual("1 + r.r As q", UnresolvedAdd(Literal(1), UnresolvedAttribute("r.r")).as("q"))
+    assertEqual("1 - f('o', o(bar))",
+      UnresolvedSubtract(Literal(1), 'f.function("o", 'o.function('bar))))
     intercept("1 - f('o', o(bar)) hello * world", "mismatched input '*'")
   }