Keep plain notation for ordinary values in the error message and assert it

Co-authored-by: Isaac <no-reply@databricks.com>

Author: viirya

sql/api/src/main/scala/org/apache/spark/sql/errors/DataTypeErrors.scala

@@ -31,6 +31,10 @@ import org.apache.spark.unsafe.types.UTF8String
  * into [[CompilationErrors]].
  */
 private[sql] object DataTypeErrors extends DataTypeErrorsBase {
+  // Above this many trailing zeros, a decimal value in an error message is rendered in
+  // scientific notation instead of plain notation.
+  private val MAX_PLAIN_STRING_TRAILING_ZEROS = 1000
+
   def unsupportedOperationExceptionError(): SparkUnsupportedOperationException = {
     new SparkUnsupportedOperationException("_LEGACY_ERROR_TEMP_2225")
   }
@@ -210,9 +214,10 @@ private[sql] object DataTypeErrors extends DataTypeErrorsBase {
     new SparkArithmeticException(
       errorClass = "NUMERIC_VALUE_OUT_OF_RANGE.WITH_SUGGESTION",
       messageParameters = Map(
-        // A negative scale (legacy mode only) can make the plain string arbitrarily long,
-        // e.g. 1E+2147483647.
-        "value" -> (if (value.scale < 0) value.toString else value.toPlainString),
+        // A huge negative scale (legacy mode only) makes the plain string too long to build,
+        // e.g. for 1E+2147483647.
+        "value" -> (if (value.scale < -MAX_PLAIN_STRING_TRAILING_ZEROS) value.toString
+          else value.toPlainString),
         "precision" -> decimalPrecision.toString,
         "scale" -> decimalScale.toString,
         "config" -> toSQLConf("spark.sql.ansi.enabled")),

sql/catalyst/src/main/java/org/apache/spark/sql/catalyst/expressions/CastUtils.java

@@ -18,6 +18,7 @@
 package org.apache.spark.sql.catalyst.expressions;
 
 import org.apache.spark.QueryContext;
+import org.apache.spark.sql.errors.DataTypeErrors;
 import org.apache.spark.sql.errors.QueryExecutionErrors;
 import org.apache.spark.sql.types.DataType;
 import org.apache.spark.sql.types.DataTypes;
@@ -107,7 +108,7 @@ public static short doubleToShortExact(double v) {
   public static Decimal changePrecisionExact(
       Decimal d, int precision, int scale, QueryContext context) {
     if (d.changePrecision(precision, scale)) return d;
-    throw QueryExecutionErrors.cannotChangeDecimalPrecisionError(d, precision, scale, context);
+    throw DataTypeErrors.cannotChangeDecimalPrecisionError(d, precision, scale, context);
   }
 
   public static Decimal changePrecisionOrNull(Decimal d, int precision, int scale) {

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

@@ -103,15 +103,6 @@ private[sql] object QueryExecutionErrors extends QueryErrorsBase with ExecutionE
     )
   }
 
-  def cannotChangeDecimalPrecisionError(
-      value: Decimal,
-      decimalPrecision: Int,
-      decimalScale: Int,
-      context: QueryContext = null): ArithmeticException = {
-    DataTypeErrors.cannotChangeDecimalPrecisionError(
-      value, decimalPrecision, decimalScale, context)
-  }
-
   def invalidInputSyntaxForBooleanError(
       s: UTF8String,
       context: QueryContext): SparkRuntimeException = {

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

@@ -489,6 +489,25 @@ class CastWithAnsiOnSuite extends CastSuiteBase with QueryErrorsBase {
           "cannot be represented as Decimal(10, 2)")
       }
       checkEvaluation(cast("0e2147483647", DecimalType(10, 2)), Decimal("0.00"))
+
+      // The value is shown in plain notation unless its scale is hugely negative.
+      Seq("1e2147483647" -> "1E+2147483647", "1e40" -> ("1" + "0" * 40)).foreach {
+        case (str, value) =>
+          if (!isTryCast) {
+            checkError(
+              exception = intercept[SparkArithmeticException](
+                cast(str, DecimalType(10, 2)).eval()),
+              condition = "NUMERIC_VALUE_OUT_OF_RANGE.WITH_SUGGESTION",
+              parameters = Map(
+                "value" -> value,
+                "precision" -> "10",
+                "scale" -> "2",
+                "config" -> """"spark.sql.ansi.enabled""""),
+              queryContext = Array(ExpectedContext(fragment = "", start = -1, stop = -1)))
+          } else {
+            checkEvaluation(cast(str, DecimalType(10, 2)), null)
+          }
+      }
     }
   }
 

sql/catalyst/src/test/scala/org/apache/spark/sql/types/DecimalSuite.scala

@@ -494,7 +494,7 @@ class DecimalSuite extends SparkFunSuite with PrivateMethodTester with SQLHelper
   }
 
   test("SPARK-60119: changePrecision with a source scale far from the target scale") {
-    // A value below 0.1 ulp of the target scale rounds to 0 or +/-1 ulp depending only on its
+    // A value below 0.01 ulp of the target scale rounds to 0 or +/-1 ulp depending only on its
     // sign and the rounding mode, so it must round like a small value of the same sign.
     Seq("1e-2147483647", "-1e-2147483647", "9.99e-100000000", "-1e-100000000",
       "0e-2147483647").foreach { str =>