This is an automated email from the ASF dual-hosted git repository. maxgekk pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/spark.git
The following commit(s) were added to refs/heads/master by this push: new 7823f84942a [SPARK-41578][SQL] Assign name to _LEGACY_ERROR_TEMP_2141 7823f84942a is described below commit 7823f84942acd1a1a6abc5c1f9045317795d00fb Author: itholic <haejoon....@databricks.com> AuthorDate: Fri Dec 30 12:18:50 2022 +0500 [SPARK-41578][SQL] Assign name to _LEGACY_ERROR_TEMP_2141 ### What changes were proposed in this pull request? This PR proposes to assign name to _LEGACY_ERROR_TEMP_2141, "ENCODER_NOT_FOUND". ### Why are the changes needed? We should assign proper name to _LEGACY_ERROR_TEMP_* ### Does this PR introduce _any_ user-facing change? No ### How was this patch tested? `./build/sbt "sql/testOnly org.apache.spark.sql.SQLQueryTestSuite*` Closes #39279 from itholic/LEGACY_2141. Authored-by: itholic <haejoon....@databricks.com> Signed-off-by: Max Gekk <max.g...@gmail.com> --- core/src/main/resources/error/error-classes.json | 11 ++- .../spark/sql/catalyst/ScalaReflection.scala | 2 +- .../spark/sql/errors/QueryExecutionErrors.scala | 8 +-- .../encoders/EncoderErrorMessageSuite.scala | 80 ++++++++++------------ .../catalyst/encoders/ExpressionEncoderSuite.scala | 13 ++-- 5 files changed, 52 insertions(+), 62 deletions(-) diff --git a/core/src/main/resources/error/error-classes.json b/core/src/main/resources/error/error-classes.json index 21b7c467b64..67398a30180 100644 --- a/core/src/main/resources/error/error-classes.json +++ b/core/src/main/resources/error/error-classes.json @@ -459,6 +459,11 @@ "The index 0 is invalid. An index shall be either < 0 or > 0 (the first element has index 1)." ] }, + "ENCODER_NOT_FOUND" : { + "message" : [ + "Not found an encoder of the type <typeName> to Spark SQL internal representation. Consider to change the input type to one of supported at https://spark.apache.org/docs/latest/sql-ref-datatypes.html." + ] + }, "FAILED_EXECUTE_UDF" : { "message" : [ "Failed to execute user defined function (<functionName>: (<signature>) => <result>)" @@ -4116,12 +4121,6 @@ "<walkedTypePath>" ] }, - "_LEGACY_ERROR_TEMP_2141" : { - "message" : [ - "No Encoder found for <tpe>", - "<walkedTypePath>" - ] - }, "_LEGACY_ERROR_TEMP_2142" : { "message" : [ "Attributes for type <schema> is not supported" diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/ScalaReflection.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/ScalaReflection.scala index 0a8a823216f..e02e42cea1a 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/ScalaReflection.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/ScalaReflection.scala @@ -779,7 +779,7 @@ object ScalaReflection extends ScalaReflection { } ProductEncoder(ClassTag(getClassFromType(t)), params) case _ => - throw QueryExecutionErrors.cannotFindEncoderForTypeError(tpe.toString, path) + throw QueryExecutionErrors.cannotFindEncoderForTypeError(tpe.toString) } } } diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryExecutionErrors.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryExecutionErrors.scala index cef4acafe07..3e234cfee2c 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryExecutionErrors.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryExecutionErrors.scala @@ -1483,13 +1483,11 @@ private[sql] object QueryExecutionErrors extends QueryErrorsBase { "walkedTypePath" -> walkedTypePath.toString())) } - def cannotFindEncoderForTypeError( - tpe: String, walkedTypePath: WalkedTypePath): SparkUnsupportedOperationException = { + def cannotFindEncoderForTypeError(typeName: String): SparkUnsupportedOperationException = { new SparkUnsupportedOperationException( - errorClass = "_LEGACY_ERROR_TEMP_2141", + errorClass = "ENCODER_NOT_FOUND", messageParameters = Map( - "tpe" -> tpe, - "walkedTypePath" -> walkedTypePath.toString())) + "typeName" -> typeName)) } def attributesForTypeUnsupportedError(schema: Schema): SparkUnsupportedOperationException = { diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/EncoderErrorMessageSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/EncoderErrorMessageSuite.scala index 8c766ef8299..501dfa58305 100644 --- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/EncoderErrorMessageSuite.scala +++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/EncoderErrorMessageSuite.scala @@ -19,7 +19,7 @@ package org.apache.spark.sql.catalyst.encoders import scala.reflect.ClassTag -import org.apache.spark.SparkFunSuite +import org.apache.spark.{SparkFunSuite, SparkUnsupportedOperationException} import org.apache.spark.sql.Encoders class NonEncodable(i: Int) @@ -52,50 +52,40 @@ class EncoderErrorMessageSuite extends SparkFunSuite { } test("nice error message for missing encoder") { - val errorMsg1 = - intercept[UnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable1]).getMessage - assert(errorMsg1.contains( - s"""root class: "${clsName[ComplexNonEncodable1]}"""")) - assert(errorMsg1.contains( - s"""field (class: "${clsName[NonEncodable]}", name: "name1")""")) - - val errorMsg2 = - intercept[UnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable2]).getMessage - assert(errorMsg2.contains( - s"""root class: "${clsName[ComplexNonEncodable2]}"""")) - assert(errorMsg2.contains( - s"""field (class: "${clsName[ComplexNonEncodable1]}", name: "name2")""")) - assert(errorMsg1.contains( - s"""field (class: "${clsName[NonEncodable]}", name: "name1")""")) - - val errorMsg3 = - intercept[UnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable3]).getMessage - assert(errorMsg3.contains( - s"""root class: "${clsName[ComplexNonEncodable3]}"""")) - assert(errorMsg3.contains( - s"""field (class: "scala.Option", name: "name3")""")) - assert(errorMsg3.contains( - s"""option value class: "${clsName[NonEncodable]}"""")) - - val errorMsg4 = - intercept[UnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable4]).getMessage - assert(errorMsg4.contains( - s"""root class: "${clsName[ComplexNonEncodable4]}"""")) - assert(errorMsg4.contains( - s"""field (class: "scala.Array", name: "name4")""")) - assert(errorMsg4.contains( - s"""array element class: "${clsName[NonEncodable]}"""")) - - val errorMsg5 = - intercept[UnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable5]).getMessage - assert(errorMsg5.contains( - s"""root class: "${clsName[ComplexNonEncodable5]}"""")) - assert(errorMsg5.contains( - s"""field (class: "scala.Option", name: "name5")""")) - assert(errorMsg5.contains( - s"""option value class: "scala.Array"""")) - assert(errorMsg5.contains( - s"""array element class: "${clsName[NonEncodable]}"""")) + checkError( + exception = intercept[ + SparkUnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable1]), + errorClass = "ENCODER_NOT_FOUND", + parameters = Map("typeName" -> "org.apache.spark.sql.catalyst.encoders.NonEncodable") + ) + + checkError( + exception = intercept[ + SparkUnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable2]), + errorClass = "ENCODER_NOT_FOUND", + parameters = Map("typeName" -> "org.apache.spark.sql.catalyst.encoders.NonEncodable") + ) + + checkError( + exception = intercept[ + SparkUnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable3]), + errorClass = "ENCODER_NOT_FOUND", + parameters = Map("typeName" -> "org.apache.spark.sql.catalyst.encoders.NonEncodable") + ) + + checkError( + exception = intercept[ + SparkUnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable4]), + errorClass = "ENCODER_NOT_FOUND", + parameters = Map("typeName" -> "org.apache.spark.sql.catalyst.encoders.NonEncodable") + ) + + checkError( + exception = intercept[ + SparkUnsupportedOperationException](ExpressionEncoder[ComplexNonEncodable5]), + errorClass = "ENCODER_NOT_FOUND", + parameters = Map("typeName" -> "org.apache.spark.sql.catalyst.encoders.NonEncodable") + ) } private def clsName[T : ClassTag]: String = implicitly[ClassTag[T]].runtimeClass.getName diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/ExpressionEncoderSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/ExpressionEncoderSuite.scala index e9336405a53..3a0db1ca121 100644 --- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/ExpressionEncoderSuite.scala +++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/encoders/ExpressionEncoderSuite.scala @@ -24,7 +24,7 @@ import java.util.Arrays import scala.collection.mutable.ArrayBuffer import scala.reflect.runtime.universe.TypeTag -import org.apache.spark.{SparkArithmeticException, SparkRuntimeException} +import org.apache.spark.{SparkArithmeticException, SparkRuntimeException, SparkUnsupportedOperationException} import org.apache.spark.sql.{Encoder, Encoders} import org.apache.spark.sql.catalyst.{FooClassWithEnum, FooEnum, OptionalData, PrimitiveData, ScroogeLikeExample} import org.apache.spark.sql.catalyst.analysis.AnalysisTest @@ -483,10 +483,13 @@ class ExpressionEncoderSuite extends CodegenInterpretedPlanTest with AnalysisTes productTest(("UDT", new ExamplePoint(0.1, 0.2))) test("AnyVal class with Any fields") { - val exception = intercept[UnsupportedOperationException](implicitly[ExpressionEncoder[Foo]]) - val errorMsg = exception.getMessage - assert(errorMsg.contains("root class: \"org.apache.spark.sql.catalyst.encoders.Foo\"")) - assert(errorMsg.contains("No Encoder found for Any")) + val exception = intercept[SparkUnsupportedOperationException]( + implicitly[ExpressionEncoder[Foo]]) + checkError( + exception = exception, + errorClass = "ENCODER_NOT_FOUND", + parameters = Map("typeName" -> "Any") + ) } test("nullable of encoder schema") { --------------------------------------------------------------------- To unsubscribe, e-mail: commits-unsubscr...@spark.apache.org For additional commands, e-mail: commits-h...@spark.apache.org