[SPARK-33421][SQL] Support Greatest and Least in Expression Canonicalize

### What changes were proposed in this pull request?

Add `Greatest` and `Least` check in `Canonicalize`.

### Why are the changes needed?

The children of both `Greatest` and `Least` are order Irrelevant.

Let's say we have `greatest(1, 2)` and `greatest(2, 1)`. We can get the same canonicalized expression in this case.

### Does this PR introduce _any_ user-facing change?

No.

### How was this patch tested?

Add test.

Closes #30330 from ulysses-you/SPARK-33421.

Authored-by: ulysses <youxiduo@weidian.com>
Signed-off-by: HyukjinKwon <gurwls223@apache.org>

Author: ulysses-you

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

@@ -109,6 +109,13 @@ object Canonicalize {
     // order the list in the In operator
     case In(value, list) if list.length > 1 => In(value, list.sortBy(_.hashCode()))
 
+    case g: Greatest =>
+      val newChildren = orderCommutative(g, { case Greatest(children) => children })
+      Greatest(newChildren)
+    case l: Least =>
+      val newChildren = orderCommutative(l, { case Least(children) => children })
+      Least(newChildren)
+
     case _ => e
   }
 }

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

@@ -142,4 +142,32 @@ class CanonicalizeSuite extends SparkFunSuite {
       }
     }
   }
+
+  test("SPARK-33421: Support Greatest and Least in Expression Canonicalize") {
+    Seq(Least(_), Greatest(_)).foreach { f =>
+      // test deterministic expr
+      val expr1 = f(Seq(Literal(1), Literal(2), Literal(3)))
+      val expr2 = f(Seq(Literal(3), Literal(1), Literal(2)))
+      val expr3 = f(Seq(Literal(1), Literal(1), Literal(1)))
+      assert(expr1.canonicalized == expr2.canonicalized)
+      assert(expr1.canonicalized != expr3.canonicalized)
+      assert(expr2.canonicalized != expr3.canonicalized)
+
+      // test non-deterministic expr
+      val randExpr1 = f(Seq(Literal(1), rand(1)))
+      val randExpr2 = f(Seq(rand(1), Literal(1)))
+      val randExpr3 = f(Seq(Literal(1), rand(2)))
+      assert(randExpr1.canonicalized == randExpr2.canonicalized)
+      assert(randExpr1.canonicalized != randExpr3.canonicalized)
+      assert(randExpr2.canonicalized != randExpr3.canonicalized)
+
+      // test nested expr
+      val nestedExpr1 = f(Seq(Literal(1), f(Seq(Literal(2), Literal(3)))))
+      val nestedExpr2 = f(Seq(f(Seq(Literal(2), Literal(3))), Literal(1)))
+      val nestedExpr3 = f(Seq(f(Seq(Literal(1), Literal(1))), Literal(1)))
+      assert(nestedExpr1.canonicalized == nestedExpr2.canonicalized)
+      assert(nestedExpr1.canonicalized != nestedExpr3.canonicalized)
+      assert(nestedExpr2.canonicalized != nestedExpr3.canonicalized)
+    }
+  }
 }