Apply more fixes

Author: maropu

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

@@ -526,18 +526,15 @@ case class Least(children: Seq[Expression]) extends Expression {
   private lazy val ordering = TypeUtils.getInterpretedOrdering(dataType)
 
   override def checkInputDataTypes(): TypeCheckResult = {
-    TypeUtils.checkTypeInputDimension(
-        children.map(_.dataType), s"function $prettyName", requiredMinDimension = 2) match {
-      case TypeCheckResult.TypeCheckSuccess =>
-        if (children.map(_.dataType).distinct.count(_ != NullType) > 1) {
-          TypeCheckResult.TypeCheckFailure(
-            s"The expressions should all have the same type," +
-              s" got LEAST(${children.map(_.dataType.simpleString).mkString(", ")}).")
-        } else {
-          TypeUtils.checkForOrderingExpr(dataType, s"function $prettyName")
-        }
-      case typeCheckFailure =>
-        typeCheckFailure
+    if (children.length <= 1) {
+      TypeCheckResult.TypeCheckFailure(
+        s"input to function $prettyName requires at least two arguments")
+    } else if (children.map(_.dataType).distinct.count(_ != NullType) > 1) {
+      TypeCheckResult.TypeCheckFailure(
+        s"The expressions should all have the same type," +
+          s" got LEAST(${children.map(_.dataType.simpleString).mkString(", ")}).")
+    } else {
+      TypeUtils.checkForOrderingExpr(dataType, s"function $prettyName")
     }
   }
 
@@ -595,18 +592,15 @@ case class Greatest(children: Seq[Expression]) extends Expression {
   private lazy val ordering = TypeUtils.getInterpretedOrdering(dataType)
 
   override def checkInputDataTypes(): TypeCheckResult = {
-    TypeUtils.checkTypeInputDimension(
-        children.map(_.dataType), s"function $prettyName", requiredMinDimension = 2) match {
-      case TypeCheckResult.TypeCheckSuccess =>
-        if (children.map(_.dataType).distinct.count(_ != NullType) > 1) {
-          TypeCheckResult.TypeCheckFailure(
-            s"The expressions should all have the same type," +
-              s" got GREATEST(${children.map(_.dataType.simpleString).mkString(", ")}).")
-        } else {
-          TypeUtils.checkForOrderingExpr(dataType, s"function $prettyName")
-        }
-      case typeCheckFailure =>
-        typeCheckFailure
+    if (children.length <= 1) {
+      TypeCheckResult.TypeCheckFailure(
+        s"input to function $prettyName requires at least two arguments")
+    } else if (children.map(_.dataType).distinct.count(_ != NullType) > 1) {
+      TypeCheckResult.TypeCheckFailure(
+        s"The expressions should all have the same type," +
+          s" got GREATEST(${children.map(_.dataType.simpleString).mkString(", ")}).")
+    } else {
+      TypeUtils.checkForOrderingExpr(dataType, s"function $prettyName")
     }
   }
 

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

@@ -296,25 +296,24 @@ trait CreateNamedStructLike extends Expression {
   }
 
   override def checkInputDataTypes(): TypeCheckResult = {
-    TypeUtils.checkTypeInputDimension(
-        children.map(_.dataType), s"function $prettyName", requiredMinDimension = 1) match {
-      case TypeCheckResult.TypeCheckSuccess =>
-        if (children.size % 2 != 0) {
-          TypeCheckResult.TypeCheckFailure(s"$prettyName expects an even number of arguments.")
+    if (children.length < 1) {
+      TypeCheckResult.TypeCheckFailure(
+        s"input to function $prettyName requires at least one argument")
+    } else {
+      if (children.size % 2 != 0) {
+        TypeCheckResult.TypeCheckFailure(s"$prettyName expects an even number of arguments.")
+      } else {
+        val invalidNames = nameExprs.filterNot(e => e.foldable && e.dataType == StringType)
+        if (invalidNames.nonEmpty) {
+          TypeCheckResult.TypeCheckFailure(
+            "Only foldable StringType expressions are allowed to appear at odd position, got:" +
+              s" ${invalidNames.mkString(",")}")
+        } else if (!names.contains(null)) {
+          TypeCheckResult.TypeCheckSuccess
         } else {
-          val invalidNames = nameExprs.filterNot(e => e.foldable && e.dataType == StringType)
-          if (invalidNames.nonEmpty) {
-            TypeCheckResult.TypeCheckFailure(
-              "Only foldable StringType expressions are allowed to appear at odd position, got:" +
-                s" ${invalidNames.mkString(",")}")
-          } else if (!names.contains(null)) {
-            TypeCheckResult.TypeCheckSuccess
-          } else {
-            TypeCheckResult.TypeCheckFailure("Field name should not be null")
-          }
+          TypeCheckResult.TypeCheckFailure("Field name should not be null")
         }
-      case typeCheckFailure =>
-        typeCheckFailure
+      }
     }
   }
 

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

@@ -28,7 +28,7 @@ import org.apache.commons.codec.digest.DigestUtils
 import org.apache.spark.sql.catalyst.InternalRow
 import org.apache.spark.sql.catalyst.analysis.TypeCheckResult
 import org.apache.spark.sql.catalyst.expressions.codegen._
-import org.apache.spark.sql.catalyst.util.{ArrayData, MapData, TypeUtils}
+import org.apache.spark.sql.catalyst.util.{ArrayData, MapData}
 import org.apache.spark.sql.types._
 import org.apache.spark.unsafe.hash.Murmur3_x86_32
 import org.apache.spark.unsafe.types.{CalendarInterval, UTF8String}
@@ -247,8 +247,12 @@ abstract class HashExpression[E] extends Expression {
   override def nullable: Boolean = false
 
   override def checkInputDataTypes(): TypeCheckResult = {
-    TypeUtils.checkTypeInputDimension(
-      children.map(_.dataType), s"function $prettyName", requiredMinDimension = 1)
+    if (children.length < 1) {
+      TypeCheckResult.TypeCheckFailure(
+        s"input to function $prettyName requires at least one argument")
+    } else {
+      TypeCheckResult.TypeCheckSuccess
+    }
   }
 
   override def eval(input: InternalRow = null): Any = {

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

@@ -52,13 +52,11 @@ case class Coalesce(children: Seq[Expression]) extends Expression {
   override def foldable: Boolean = children.forall(_.foldable)
 
   override def checkInputDataTypes(): TypeCheckResult = {
-    val inputDataTypes = children.map(_.dataType)
-    TypeUtils.checkTypeInputDimension(
-        inputDataTypes, s"function $prettyName", requiredMinDimension = 1) match {
-      case TypeCheckResult.TypeCheckSuccess =>
-        TypeUtils.checkForSameTypeInputExpr(inputDataTypes, s"function $prettyName")
-      case typeCheckFailure =>
-        typeCheckFailure
+    if (children.length < 1) {
+      TypeCheckResult.TypeCheckFailure(
+        s"input to function $prettyName requires at least one argument")
+    } else {
+      TypeUtils.checkForSameTypeInputExpr(children.map(_.dataType), s"function $prettyName")
     }
   }
 

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

@@ -57,17 +57,6 @@ object TypeUtils {
     }
   }
 
-  def checkTypeInputDimension(types: Seq[DataType], caller: String, requiredMinDimension: Int)
-    : TypeCheckResult = {
-    if (types.size >= requiredMinDimension) {
-      TypeCheckResult.TypeCheckSuccess
-    } else {
-      TypeCheckResult.TypeCheckFailure(
-        s"input to $caller requires at least $requiredMinDimension " +
-          s"argument${if (requiredMinDimension > 1) "s"}")
-    }
-  }
-
   def getNumeric(t: DataType): Numeric[Any] =
     t.asInstanceOf[NumericType].numeric.asInstanceOf[Numeric[Any]]
 

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/ExpressionTypeCheckingSuite.scala

@@ -155,7 +155,7 @@ class ExpressionTypeCheckingSuite extends SparkFunSuite {
       "input to function array should all be the same type")
     assertError(Coalesce(Seq('intField, 'booleanField)),
       "input to function coalesce should all be the same type")
-    assertError(Coalesce(Nil), "input to function coalesce cannot be empty")
+    assertError(Coalesce(Nil), "function coalesce requires at least one argument")
     assertError(new Murmur3Hash(Nil), "function hash requires at least one argument")
     assertError(Explode('intField),
       "input to function explode should be array or map type")
@@ -207,7 +207,7 @@ class ExpressionTypeCheckingSuite extends SparkFunSuite {
 
   test("check types for Greatest/Least") {
     for (operator <- Seq[(Seq[Expression] => Expression)](Greatest, Least)) {
-      assertError(operator(Seq('booleanField)), "requires at least 2 arguments")
+      assertError(operator(Seq('booleanField)), "requires at least two arguments")
       assertError(operator(Seq('intField, 'stringField)), "should all have the same type")
       assertError(operator(Seq('mapField, 'mapField)), "does not support ordering")
     }

sql/core/src/test/scala/org/apache/spark/sql/DataFrameFunctionsSuite.scala

@@ -471,7 +471,7 @@ class DataFrameFunctionsSuite extends QueryTest with SharedSQLContext {
       ("hash", (df: DataFrame) => df.selectExpr("hash()")) :: Nil
     funcsMustHaveAtLeastOneArg.foreach { case (name, func) =>
       val errMsg = intercept[AnalysisException] { func(df) }.getMessage
-      assert(errMsg.contains(s"input to function $name requires at least 1 argument"))
+      assert(errMsg.contains(s"input to function $name requires at least one argument"))
     }
 
     val funcsMustHaveAtLeastTwoArgs =
@@ -481,7 +481,7 @@ class DataFrameFunctionsSuite extends QueryTest with SharedSQLContext {
       ("least", (df: DataFrame) => df.selectExpr("least()")) :: Nil
     funcsMustHaveAtLeastTwoArgs.foreach { case (name, func) =>
       val errMsg = intercept[AnalysisException] { func(df) }.getMessage
-      assert(errMsg.contains(s"input to function $name requires at least 2 arguments"))
+      assert(errMsg.contains(s"input to function $name requires at least two arguments"))
     }
   }
 }