[SPARK-49768][SQL] Provide error conditions for make_date/make_timestamp errors _LEGACY_ERROR_TEMP_2000

common/utils/src/main/resources/error/error-conditions.json

@@ -1083,6 +1083,12 @@
     ],
     "sqlState" : "22008"
   },
+  "DATE_TIME_FIELD_OUT_OF_BOUNDS" : {
+    "message" : [
+      "The value '<badValue>' you entered for <unit> is not valid. Please provide a value between <range>. To disable strict validation, you can turn off ANSI mode by setting <ansiConfig> to false."
+    ],
+    "sqlState" : "22008"
+  },
   "DECIMAL_PRECISION_EXCEEDS_MAX_PRECISION" : {
     "message" : [
       "Decimal precision <precision> exceeds max precision <maxPrecision>."
@@ -6691,11 +6697,6 @@
       "Sinks cannot request distribution and ordering in continuous execution mode."
     ]
   },
-  "_LEGACY_ERROR_TEMP_2000" : {
-    "message" : [
-      "<message>. If necessary set <ansiConfig> to false to bypass this error."
-    ]
-  },
   "_LEGACY_ERROR_TEMP_2003" : {
     "message" : [
       "Unsuccessful try to zip maps with <size> unique keys due to exceeding the array size limit <maxRoundedArrayLength>."

common/utils/src/main/scala/org/apache/spark/SparkException.scala

@@ -306,8 +306,9 @@ private[spark] class SparkDateTimeException private(
     message: String,
     errorClass: Option[String],
     messageParameters: Map[String, String],
-    context: Array[QueryContext])
-  extends DateTimeException(message) with SparkThrowable {
+    context: Array[QueryContext],
+    cause: Option[Throwable])
+  extends DateTimeException(message, cause.orNull) with SparkThrowable {
 
   def this(
     errorClass: String,
@@ -318,7 +319,23 @@ private[spark] class SparkDateTimeException private(
       SparkThrowableHelper.getMessage(errorClass, messageParameters, summary),
       Option(errorClass),
       messageParameters,
-      context
+      context,
+      cause = None
+    )
+  }
+
+  def this(
+    errorClass: String,
+    messageParameters: Map[String, String],
+    context: Array[QueryContext],
+    summary: String,
+    cause: Option[Throwable]) = {
+    this(
+      SparkThrowableHelper.getMessage(errorClass, messageParameters, summary),
+      Option(errorClass),
+      messageParameters,
+      context,
+      cause.orElse(None)
     )
   }
 

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

@@ -304,8 +304,7 @@ object DateTimeUtils extends SparkDateTimeUtils {
      start: Int,
      interval: CalendarInterval): Int = {
     if (interval.microseconds != 0) {
-      throw QueryExecutionErrors.ansiIllegalArgumentError(
-        "Cannot add hours, minutes or seconds, milliseconds, microseconds to a date")
+      throw QueryExecutionErrors.ansiIllegalArgumentError()
     }
     val ld = daysToLocalDate(start).plusMonths(interval.months).plusDays(interval.days)
     localDateToDays(ld)

sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryExecutionErrors.scala

@@ -278,21 +278,45 @@ private[sql] object QueryExecutionErrors extends QueryErrorsBase with ExecutionE
   }
 
   def ansiDateTimeError(e: Exception): SparkDateTimeException = {
+    def extractDateTimeErrorInfo(e: Exception): (String, String, String) = {
+      val errorMessage = e.getMessage
+
+      val pattern = "Invalid value for ([A-Za-z]+) \\(valid values (.+)\\): (.+)".r
+
+      errorMessage match {
+        case pattern(field, range, badValue) =>
+          val unit = field match {
+            case "Year" => "YEAR"
+            case "MonthOfYear" => "MONTH"
+            case "DayOfMonth" => "DAY"
+            case "Hour" => "HOUR"
+            case "Minute" => "MINUTE"
+            case "Second" => "SECOND"
+            case _ => field
+          }
+          (unit, range, badValue)
+      }
+    }
+    val (unit, range, badValue) = extractDateTimeErrorInfo(e)
     new SparkDateTimeException(
-      errorClass = "_LEGACY_ERROR_TEMP_2000",
+      errorClass = "DATE_TIME_FIELD_OUT_OF_BOUNDS",
       messageParameters = Map(
-        "message" -> e.getMessage,
-        "ansiConfig" -> toSQLConf(SQLConf.ANSI_ENABLED.key)),
+        "ansiConfig" -> toSQLConf(SQLConf.ANSI_ENABLED.key),
+        "unit" -> unit,
+        "range" -> range,
+        "badValue" -> badValue
+      ),
       context = Array.empty,
-      summary = "")
+      summary = "",
+      cause = Some(e)
+    )
   }
 
-  def ansiIllegalArgumentError(message: String): SparkIllegalArgumentException = {
-    new SparkIllegalArgumentException(
-      errorClass = "_LEGACY_ERROR_TEMP_2000",
-      messageParameters = Map(
-        "message" -> message,
-        "ansiConfig" -> toSQLConf(SQLConf.ANSI_ENABLED.key)))
+  def ansiIllegalArgumentError(): SparkException = {
+    SparkException.internalError(
+      "Cannot add hours, minutes or seconds, milliseconds, microseconds to a date. " +
+        s"If necessary set ${toSQLConf(SQLConf.ANSI_ENABLED.key)} to false to bypass this error"
+    )
   }
 
   def overflowInSumOfDecimalError(context: QueryContext): ArithmeticException = {

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

@@ -434,12 +434,14 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper {
     }
 
     withSQLConf((SQLConf.ANSI_ENABLED.key, "true")) {
-      checkErrorInExpression[SparkIllegalArgumentException](
+      checkErrorInExpression[SparkException](
         DateAddInterval(Literal(d), Literal(new CalendarInterval(1, 1, 25 * MICROS_PER_HOUR))),
-        "_LEGACY_ERROR_TEMP_2000",
-        Map("message" ->
-          "Cannot add hours, minutes or seconds, milliseconds, microseconds to a date",
-          "ansiConfig" -> "\"spark.sql.ansi.enabled\""))
+        condition = "INTERNAL_ERROR",
+        parameters = Map(
+          "message" ->
+            ("Cannot add hours, minutes or seconds, milliseconds, microseconds to a date. " +
+              "If necessary set \"spark.sql.ansi.enabled\" to false to bypass this error"))
+      )
     }
 
     withSQLConf((SQLConf.ANSI_ENABLED.key, "false")) {
@@ -1140,12 +1142,33 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper {
 
     // ansi test
     withSQLConf(SQLConf.ANSI_ENABLED.key -> "true") {
-      checkExceptionInExpression[DateTimeException](MakeDate(Literal(Int.MaxValue), Literal(13),
-        Literal(19)), EmptyRow, "Invalid value for Year")
-      checkExceptionInExpression[DateTimeException](MakeDate(Literal(2019),
-        Literal(13), Literal(19)), EmptyRow, "Invalid value for Month")
-      checkExceptionInExpression[DateTimeException](MakeDate(Literal(2019), Literal(7),
-        Literal(32)), EmptyRow, "Invalid value for Day")
+      checkErrorInExpression[SparkDateTimeException](
+        MakeDate(Literal(Int.MaxValue), Literal(13), Literal(19)),
+        "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+        Map(
+          "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+          "unit" -> "YEAR",
+          "range" -> "-999999999 - 999999999",
+          "badValue" -> "2147483647")
+      )
+      checkErrorInExpression[SparkDateTimeException](
+        MakeDate(Literal(2019), Literal(13), Literal(19)),
+        "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+        Map(
+          "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+          "unit" -> "MONTH",
+          "range" -> "1 - 12",
+          "badValue" -> "13")
+      )
+      checkErrorInExpression[SparkDateTimeException](
+        MakeDate(Literal(2019), Literal(7), Literal(32)),
+        "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+        Map(
+          "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+          "unit" -> "DAY",
+          "range" -> "1 - 28/31",
+          "badValue" -> "32")
+      )
     }
 
     // non-ansi test
@@ -1183,19 +1206,72 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper {
             checkEvaluation(makeTimestampExpr.copy(timezone = None), expected)
 
             Seq(
-              (makeTimestampExpr.copy(year = Literal(Int.MaxValue)), "Invalid value for Year"),
-              (makeTimestampExpr.copy(month = Literal(13)), "Invalid value for Month"),
-              (makeTimestampExpr.copy(day = Literal(32)), "Invalid value for Day"),
-              (makeTimestampExpr.copy(hour = Literal(25)), "Invalid value for Hour"),
-              (makeTimestampExpr.copy(min = Literal(65)), "Invalid value for Min"),
-              (makeTimestampExpr.copy(sec = Literal(Decimal(
-                BigDecimal(70.0), 16, 6))), "Invalid value for Second")
+              makeTimestampExpr.copy(year = Literal(Int.MaxValue)),
+              makeTimestampExpr.copy(month = Literal(13)),
+              makeTimestampExpr.copy(day = Literal(32)),
+              makeTimestampExpr.copy(hour = Literal(25)),
+              makeTimestampExpr.copy(min = Literal(65)),
+              makeTimestampExpr.copy(sec = Literal(Decimal(
+                BigDecimal(70.0), 16, 6)))
             ).foreach { entry =>
-              if (ansi) {
-                checkExceptionInExpression[DateTimeException](entry._1, EmptyRow, entry._2)
-              } else {
-                checkEvaluation(entry._1, null)
-              }
+              if (!ansi) checkEvaluation(entry, null)
+            }
+
+            if (ansi) {
+              checkErrorInExpression[SparkDateTimeException](
+                makeTimestampExpr.copy(year = Literal(Int.MaxValue)),
+                "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+                Map(
+                  "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+                  "unit" -> "YEAR",
+                  "range" -> "-999999999 - 999999999",
+                  "badValue" -> "2147483647")
+              )
+              checkErrorInExpression[SparkDateTimeException](
+                makeTimestampExpr.copy(month = Literal(13)),
+                "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+                Map(
+                  "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+                  "unit" -> "MONTH",
+                  "range" -> "1 - 12",
+                  "badValue" -> "13")
+              )
+              checkErrorInExpression[SparkDateTimeException](
+                makeTimestampExpr.copy(day = Literal(32)),
+                "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+                Map(
+                  "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+                  "unit" -> "DAY",
+                  "range" -> "1 - 28/31",
+                  "badValue" -> "32")
+              )
+              checkErrorInExpression[SparkDateTimeException](
+                makeTimestampExpr.copy(hour = Literal(25)),
+                "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+                Map(
+                  "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+                  "unit" -> "HourOfDay",
+                  "range" -> "0 - 23",
+                  "badValue" -> "25")
+              )
+              checkErrorInExpression[SparkDateTimeException](
+                makeTimestampExpr.copy(min = Literal(65)),
+                "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+                Map(
+                  "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+                  "unit" -> "MinuteOfHour",
+                  "range" -> "0 - 59",
+                  "badValue" -> "65")
+              )
+              checkErrorInExpression[SparkDateTimeException](
+                makeTimestampExpr.copy(sec = Literal(Decimal(BigDecimal(70.0), 16, 6))),
+                "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+                Map(
+                  "ansiConfig" -> "\"spark.sql.ansi.enabled\"",
+                  "unit" -> "SecondOfMinute",
+                  "range" -> "0 - 59",
+                  "badValue" -> "70")
+              )
             }
 
             makeTimestampExpr = MakeTimestamp(Literal(2019), Literal(6), Literal(30),

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/DateTimeUtilsSuite.scala

@@ -26,7 +26,7 @@ import java.util.concurrent.TimeUnit
 import org.scalatest.matchers.must.Matchers
 import org.scalatest.matchers.should.Matchers._
 
-import org.apache.spark.{SparkFunSuite, SparkIllegalArgumentException}
+import org.apache.spark.{SparkException, SparkFunSuite, SparkIllegalArgumentException}
 import org.apache.spark.sql.catalyst.plans.SQLHelper
 import org.apache.spark.sql.catalyst.util.DateTimeConstants._
 import org.apache.spark.sql.catalyst.util.DateTimeTestUtils._
@@ -540,12 +540,14 @@ class DateTimeUtilsSuite extends SparkFunSuite with Matchers with SQLHelper {
     assert(dateAddInterval(input, new CalendarInterval(36, 47, 0)) === days(2000, 4, 15))
     assert(dateAddInterval(input, new CalendarInterval(-13, 0, 0)) === days(1996, 1, 28))
     checkError(
-      exception = intercept[SparkIllegalArgumentException](
+      exception = intercept[SparkException](
         dateAddInterval(input, new CalendarInterval(36, 47, 1))),
-      condition = "_LEGACY_ERROR_TEMP_2000",
+      condition = "INTERNAL_ERROR",
       parameters = Map(
-        "message" -> "Cannot add hours, minutes or seconds, milliseconds, microseconds to a date",
-        "ansiConfig" -> "\"spark.sql.ansi.enabled\""))
+        "message" ->
+          ("Cannot add hours, minutes or seconds, milliseconds, microseconds to a date. " +
+          "If necessary set \"spark.sql.ansi.enabled\" to false to bypass this error"))
+    )
   }
 
   test("timestamp add interval") {

sql/core/src/test/resources/sql-tests/results/ansi/date.sql.out

@@ -53,10 +53,13 @@ struct<>
 -- !query output
 org.apache.spark.SparkDateTimeException
 {
-  "errorClass" : "_LEGACY_ERROR_TEMP_2000",
+  "errorClass" : "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+  "sqlState" : "22008",
   "messageParameters" : {
     "ansiConfig" : "\"spark.sql.ansi.enabled\"",
-    "message" : "Invalid value for MonthOfYear (valid values 1 - 12): 13"
+    "badValue" : "13",
+    "range" : "1 - 12",
+    "unit" : "MONTH"
   }
 }
 
@@ -68,10 +71,13 @@ struct<>
 -- !query output
 org.apache.spark.SparkDateTimeException
 {
-  "errorClass" : "_LEGACY_ERROR_TEMP_2000",
+  "errorClass" : "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+  "sqlState" : "22008",
   "messageParameters" : {
     "ansiConfig" : "\"spark.sql.ansi.enabled\"",
-    "message" : "Invalid value for DayOfMonth (valid values 1 - 28/31): 33"
+    "badValue" : "33",
+    "range" : "1 - 28/31",
+    "unit" : "DAY"
   }
 }
 

sql/core/src/test/resources/sql-tests/results/ansi/timestamp.sql.out

@@ -154,10 +154,13 @@ struct<>
 -- !query output
 org.apache.spark.SparkDateTimeException
 {
-  "errorClass" : "_LEGACY_ERROR_TEMP_2000",
+  "errorClass" : "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+  "sqlState" : "22008",
   "messageParameters" : {
     "ansiConfig" : "\"spark.sql.ansi.enabled\"",
-    "message" : "Invalid value for SecondOfMinute (valid values 0 - 59): 61"
+    "badValue" : "61",
+    "range" : "0 - 59",
+    "unit" : "SecondOfMinute"
   }
 }
 
@@ -185,10 +188,13 @@ struct<>
 -- !query output
 org.apache.spark.SparkDateTimeException
 {
-  "errorClass" : "_LEGACY_ERROR_TEMP_2000",
+  "errorClass" : "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+  "sqlState" : "22008",
   "messageParameters" : {
     "ansiConfig" : "\"spark.sql.ansi.enabled\"",
-    "message" : "Invalid value for SecondOfMinute (valid values 0 - 59): 99"
+    "badValue" : "99",
+    "range" : "0 - 59",
+    "unit" : "SecondOfMinute"
   }
 }
 
@@ -200,10 +206,13 @@ struct<>
 -- !query output
 org.apache.spark.SparkDateTimeException
 {
-  "errorClass" : "_LEGACY_ERROR_TEMP_2000",
+  "errorClass" : "DATE_TIME_FIELD_OUT_OF_BOUNDS",
+  "sqlState" : "22008",
   "messageParameters" : {
     "ansiConfig" : "\"spark.sql.ansi.enabled\"",
-    "message" : "Invalid value for SecondOfMinute (valid values 0 - 59): 999"
+    "badValue" : "999",
+    "range" : "0 - 59",
+    "unit" : "SecondOfMinute"
   }
 }