[SPARK-58403][SQL] Assign appropriate error condition for _LEGACY_ERROR_TEMP_3201-3205: MALFORMED_EXPRESSION_INFO

Author: LuciferYang

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

@@ -5574,6 +5574,39 @@
     ],
     "sqlState" : "KD000"
   },
+  "MALFORMED_EXPRESSION_INFO" : {
+    "message" : [
+      "'<fieldName>' is malformed in the expression [<exprName>]:"
+    ],
+    "subClass" : {
+      "DEPRECATED" : {
+        "message" : [
+          "it should start with a newline and 4 leading spaces; end with a newline and two spaces; however, got [<deprecated>]."
+        ]
+      },
+      "GROUP" : {
+        "message" : [
+          "it should be a value in <validGroups>; however, got [<group>]."
+        ]
+      },
+      "NOTE" : {
+        "message" : [
+          "it should start with a newline and 4 leading spaces; end with a newline and two spaces; however, got [<note>]."
+        ]
+      },
+      "SINCE" : {
+        "message" : [
+          "it should not start with a negative number; however, got [<since>]."
+        ]
+      },
+      "SOURCE" : {
+        "message" : [
+          "it should be a value in <validSources>; however, got [<source>]."
+        ]
+      }
+    },
+    "sqlState" : "22023"
+  },
   "MALFORMED_LOG_FILE" : {
     "message" : [
       "Log file was malformed: failed to read correct log version from <text>."
@@ -11857,31 +11890,6 @@
       "Read-ahead limit < 0"
     ]
   },
-  "_LEGACY_ERROR_TEMP_3201" : {
-    "message" : [
-      "'note' is malformed in the expression [<exprName>]. It should start with a newline and 4 leading spaces; end with a newline and two spaces; however, got [<note>]."
-    ]
-  },
-  "_LEGACY_ERROR_TEMP_3202" : {
-    "message" : [
-      "'group' is malformed in the expression [<exprName>]. It should be a value in <validGroups>; however, got <group>."
-    ]
-  },
-  "_LEGACY_ERROR_TEMP_3203" : {
-    "message" : [
-      "'source' is malformed in the expression [<exprName>]. It should be a value in <validSources>; however, got [<source>]."
-    ]
-  },
-  "_LEGACY_ERROR_TEMP_3204" : {
-    "message" : [
-      "'since' is malformed in the expression [<exprName>]. It should not start with a negative number; however, got [<since>]."
-    ]
-  },
-  "_LEGACY_ERROR_TEMP_3205" : {
-    "message" : [
-      "'deprecated' is malformed in the expression [<exprName>]. It should start with a newline and 4 leading spaces; end with a newline and two spaces; however, got [<deprecated>]."
-    ]
-  },
   "_LEGACY_ERROR_TEMP_3206" : {
     "message" : [
       "<value> is not a boolean string."

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

@@ -150,36 +150,39 @@ public ExpressionInfo(
         if (!note.isEmpty()) {
             if (!note.contains("    ") || !note.endsWith("  ")) {
                 throw new SparkIllegalArgumentException(
-                  "_LEGACY_ERROR_TEMP_3201", Map.of("exprName", this.name, "note", note));
+                  "MALFORMED_EXPRESSION_INFO.NOTE",
+                  Map.of("fieldName", "note", "exprName", this.name, "note", note));
             }
             this.extended += "\n    Note:\n      " + note.trim() + "\n";
         }
         if (!group.isEmpty() && !validGroups.contains(group)) {
             throw new SparkIllegalArgumentException(
-              "_LEGACY_ERROR_TEMP_3202",
-              Map.of("exprName", this.name,
+              "MALFORMED_EXPRESSION_INFO.GROUP",
+              Map.of("fieldName", "group", "exprName", this.name,
                 "validGroups", String.valueOf(validGroups.stream().sorted().toList()),
                 "group", group));
         }
         if (!source.isEmpty() && !validSources.contains(source)) {
             throw new SparkIllegalArgumentException(
-              "_LEGACY_ERROR_TEMP_3203",
-              Map.of("exprName", this.name,
+              "MALFORMED_EXPRESSION_INFO.SOURCE",
+              Map.of("fieldName", "source", "exprName", this.name,
                 "validSources", String.valueOf(validSources.stream().sorted().toList()),
                 "source", source));
         }
         if (!since.isEmpty()) {
             if (Integer.parseInt(since.split("\\.")[0]) < 0) {
                 throw new SparkIllegalArgumentException(
-                  "_LEGACY_ERROR_TEMP_3204", Map.of("exprName", this.name, "since", since));
+                  "MALFORMED_EXPRESSION_INFO.SINCE",
+                  Map.of("fieldName", "since", "exprName", this.name, "since", since));
             }
             this.extended += "\n    Since: " + since + "\n";
         }
         if (!deprecated.isEmpty()) {
             if (!deprecated.contains("    ") || !deprecated.endsWith("  ")) {
                 throw new SparkIllegalArgumentException(
-                  "_LEGACY_ERROR_TEMP_3205",
-                  Map.of("exprName", this.name, "deprecated", deprecated));
+                  "MALFORMED_EXPRESSION_INFO.DEPRECATED",
+                  Map.of("fieldName", "deprecated", "exprName", this.name,
+                    "deprecated", deprecated));
             }
             this.extended += "\n    Deprecated:\n      " + deprecated.trim() + "\n";
         }

sql/core/src/test/scala/org/apache/spark/sql/expressions/ExpressionInfoSuite.scala

@@ -68,8 +68,9 @@ class ExpressionInfoSuite extends SharedSparkSession {
         new ExpressionInfo(
           "testClass", null, "testName", null, "", "", "", invalidGroupName, "", "", "")
       },
-      condition = "_LEGACY_ERROR_TEMP_3202",
+      condition = "MALFORMED_EXPRESSION_INFO.GROUP",
       parameters = Map(
+        "fieldName" -> "group",
         "exprName" -> "testName",
         "group" -> invalidGroupName,
         "validGroups" -> validGroups.mkString("[", ", ", "]")))
@@ -93,8 +94,9 @@ class ExpressionInfoSuite extends SharedSparkSession {
         new ExpressionInfo(
           "testClass", null, "testName", null, "", "", "", "", "", "", invalidSource)
       },
-      condition = "_LEGACY_ERROR_TEMP_3203",
+      condition = "MALFORMED_EXPRESSION_INFO.SOURCE",
       parameters = Map(
+        "fieldName" -> "source",
         "exprName" -> "testName",
         "source" -> invalidSource,
         "validSources" -> validSources.sorted.mkString("[", ", ", "]")))
@@ -106,26 +108,29 @@ class ExpressionInfoSuite extends SharedSparkSession {
       exception = intercept[SparkIllegalArgumentException] {
         new ExpressionInfo("testClass", null, "testName", null, "", "", invalidNote, "", "", "", "")
       },
-      condition = "_LEGACY_ERROR_TEMP_3201",
-      parameters = Map("exprName" -> "testName", "note" -> invalidNote))
+      condition = "MALFORMED_EXPRESSION_INFO.NOTE",
+      parameters = Map("fieldName" -> "note", "exprName" -> "testName", "note" -> invalidNote))
 
     val invalidSince = "-3.0.0"
     checkError(
       exception = intercept[SparkIllegalArgumentException] {
         new ExpressionInfo(
           "testClass", null, "testName", null, "", "", "", "", invalidSince, "", "")
       },
-      condition = "_LEGACY_ERROR_TEMP_3204",
-      parameters = Map("since" -> invalidSince, "exprName" -> "testName"))
+      condition = "MALFORMED_EXPRESSION_INFO.SINCE",
+      parameters = Map("fieldName" -> "since", "since" -> invalidSince, "exprName" -> "testName"))
 
     val invalidDeprecated = "  invalid deprecated"
     checkError(
       exception = intercept[SparkIllegalArgumentException] {
         new ExpressionInfo(
           "testClass", null, "testName", null, "", "", "", "", "", invalidDeprecated, "")
       },
-      condition = "_LEGACY_ERROR_TEMP_3205",
-      parameters = Map("exprName" -> "testName", "deprecated" -> invalidDeprecated))
+      condition = "MALFORMED_EXPRESSION_INFO.DEPRECATED",
+      parameters = Map(
+        "fieldName" -> "deprecated",
+        "exprName" -> "testName",
+        "deprecated" -> invalidDeprecated))
   }
 
   test("using _FUNC_ instead of function names in examples") {