You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@spark.apache.org by ma...@apache.org on 2024/08/15 07:53:44 UTC
(spark) branch master updated: [SPARK-47257][SQL] Assign names to error classes _LEGACY_ERROR_TEMP_105[3-4] and _LEGACY_ERROR_TEMP_1331
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 5a8794025652 [SPARK-47257][SQL] Assign names to error classes _LEGACY_ERROR_TEMP_105[3-4] and _LEGACY_ERROR_TEMP_1331
5a8794025652 is described below
commit 5a8794025652f022e9ee173c1768a48f7f133c30
Author: Wei Guo <gu...@gmail.com>
AuthorDate: Thu Aug 15 09:53:34 2024 +0200
[SPARK-47257][SQL] Assign names to error classes _LEGACY_ERROR_TEMP_105[3-4] and _LEGACY_ERROR_TEMP_1331
### What changes were proposed in this pull request?
This PR renames a few error classes related to usage of `ALTER COLUMN` errors:
- _LEGACY_ERROR_TEMP_1053 => UNSUPPORTED_FEATURE.TABLE_OPERATION
- _LEGACY_ERROR_TEMP_1054 => UNRESOLVED_COLUMN.WITH_SUGGESTION
- _LEGACY_ERROR_TEMP_1331 => UNRESOLVED_COLUMN.WITH_SUGGESTION
Also, this PR changes tests in corresponding test suite to use checkError() method which checks the error class name, context, error message parameters, etc.
### Why are the changes needed?
Proper error names and messages improve user experience with Spark SQL.
### Does this PR introduce _any_ user-facing change?
Yes, this PR changes user-facing error class and message.
### How was this patch tested?
By running tests from `PlanResolutionSuite`, `DataSourceV2SQLSuite` and `JDBCTableCatalogSuite`, and tests from `SQLQueryTestSuite` with `change-column.sql`.
### Was this patch authored or co-authored using generative AI tooling?
No.
Closes #46731 from wayneguow/SPARK-47257.
Authored-by: Wei Guo <gu...@gmail.com>
Signed-off-by: Max Gekk <ma...@gmail.com>
---
.../src/main/resources/error/error-conditions.json | 16 --
.../org/apache/spark/sql/jdbc/v2/V2JDBCTest.scala | 45 ++++--
.../spark/sql/catalyst/analysis/Analyzer.scala | 5 +-
.../spark/sql/errors/QueryCompilationErrors.scala | 37 ++---
.../catalyst/analysis/ResolveSessionCatalog.scala | 7 +-
.../analyzer-results/change-column.sql.out | 8 +-
.../sql-tests/results/change-column.sql.out | 8 +-
.../spark/sql/connector/AlterTableTests.scala | 175 +++++++++++++++------
.../spark/sql/connector/DataSourceV2SQLSuite.scala | 17 +-
.../connector/V2CommandsCaseSensitivitySuite.scala | 48 ++++--
.../execution/command/PlanResolutionSuite.scala | 39 ++---
.../command/v2/AlterTableDropColumnSuite.scala | 28 ++--
.../command/v2/AlterTableRenameColumnSuite.scala | 28 ++--
.../v2/jdbc/JDBCTableCatalogSuite.scala | 92 ++++-------
14 files changed, 291 insertions(+), 262 deletions(-)
diff --git a/common/utils/src/main/resources/error/error-conditions.json b/common/utils/src/main/resources/error/error-conditions.json
index 957ffcfd81ed..e02c03612611 100644
--- a/common/utils/src/main/resources/error/error-conditions.json
+++ b/common/utils/src/main/resources/error/error-conditions.json
@@ -5566,16 +5566,6 @@
"ADD COLUMN with v1 tables cannot specify NOT NULL."
]
},
- "_LEGACY_ERROR_TEMP_1053" : {
- "message" : [
- "ALTER COLUMN with v1 tables cannot specify NOT NULL."
- ]
- },
- "_LEGACY_ERROR_TEMP_1054" : {
- "message" : [
- "ALTER COLUMN cannot find column <colName> in v1 table. Available: <fieldNames>."
- ]
- },
"_LEGACY_ERROR_TEMP_1057" : {
"message" : [
"SHOW COLUMNS with conflicting databases: '<dbA>' != '<dbB>'."
@@ -6457,12 +6447,6 @@
"Class <className> doesn't implement interface UserDefinedAggregateFunction."
]
},
- "_LEGACY_ERROR_TEMP_1331" : {
- "message" : [
- "Missing field <fieldName> in table <table> with schema:",
- "<schema>."
- ]
- },
"_LEGACY_ERROR_TEMP_1332" : {
"message" : [
"<errorMessage>"
diff --git a/connector/docker-integration-tests/src/test/scala/org/apache/spark/sql/jdbc/v2/V2JDBCTest.scala b/connector/docker-integration-tests/src/test/scala/org/apache/spark/sql/jdbc/v2/V2JDBCTest.scala
index 4bc2a270edcd..b0ab614b27d1 100644
--- a/connector/docker-integration-tests/src/test/scala/org/apache/spark/sql/jdbc/v2/V2JDBCTest.scala
+++ b/connector/docker-integration-tests/src/test/scala/org/apache/spark/sql/jdbc/v2/V2JDBCTest.scala
@@ -66,10 +66,17 @@ private[v2] trait V2JDBCTest extends SharedSparkSession with DockerIntegrationFu
expectedSchema = new StructType().add("ID", StringType, true, defaultMetadata())
assert(t.schema === expectedSchema)
// Update nullability of not existing column
- val msg = intercept[AnalysisException] {
- sql(s"ALTER TABLE $catalogName.alt_table ALTER COLUMN bad_column DROP NOT NULL")
- }.getMessage
- assert(msg.contains("Missing field bad_column"))
+ val sqlText = s"ALTER TABLE $catalogName.alt_table ALTER COLUMN bad_column DROP NOT NULL"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`bad_column`",
+ "proposal" -> "`ID`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length -1))
}
def testRenameColumn(tbl: String): Unit = {
@@ -147,10 +154,17 @@ private[v2] trait V2JDBCTest extends SharedSparkSession with DockerIntegrationFu
.add("C2", StringType, true, defaultMetadata())
assert(t.schema === expectedSchema)
// Drop not existing column
- val msg = intercept[AnalysisException] {
- sql(s"ALTER TABLE $catalogName.alt_table DROP COLUMN bad_column")
- }.getMessage
- assert(msg.contains(s"Missing field bad_column in table $catalogName.alt_table"))
+ val sqlText = s"ALTER TABLE $catalogName.alt_table DROP COLUMN bad_column"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`bad_column`",
+ "proposal" -> "`C2`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length -1))
}
// Drop a column from a not existing table
val e = intercept[AnalysisException] {
@@ -163,10 +177,17 @@ private[v2] trait V2JDBCTest extends SharedSparkSession with DockerIntegrationFu
withTable(s"$catalogName.alt_table") {
testUpdateColumnType(s"$catalogName.alt_table")
// Update not existing column
- val msg2 = intercept[AnalysisException] {
- sql(s"ALTER TABLE $catalogName.alt_table ALTER COLUMN bad_column TYPE DOUBLE")
- }.getMessage
- assert(msg2.contains("Missing field bad_column"))
+ val sqlText = s"ALTER TABLE $catalogName.alt_table ALTER COLUMN bad_column TYPE DOUBLE"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`bad_column`",
+ "proposal" -> "`ID`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length -1))
}
// Update column type in not existing table
val e = intercept[AnalysisException] {
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala
index c98425ce02fa..a51f0c20b228 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala
@@ -3930,7 +3930,10 @@ class Analyzer(override val catalogManager: CatalogManager) extends RuleExecutor
fieldName: Seq[String],
context: Expression): ResolvedFieldName = {
resolveFieldNamesOpt(table, fieldName, context)
- .getOrElse(throw QueryCompilationErrors.missingFieldError(fieldName, table, context.origin))
+ .getOrElse {
+ throw QueryCompilationErrors.unresolvedColumnError(fieldName, table.schema.fieldNames,
+ context.origin)
+ }
}
private def resolveFieldNamesOpt(
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryCompilationErrors.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryCompilationErrors.scala
index 5dc7a5a7821d..281af36448dc 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryCompilationErrors.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryCompilationErrors.scala
@@ -24,7 +24,7 @@ import org.apache.hadoop.fs.Path
import org.apache.spark.{SPARK_DOC_ROOT, SparkException, SparkThrowable, SparkUnsupportedOperationException}
import org.apache.spark.sql.AnalysisException
import org.apache.spark.sql.catalyst.{ExtendedAnalysisException, FunctionIdentifier, InternalRow, QualifiedTableName, TableIdentifier}
-import org.apache.spark.sql.catalyst.analysis.{CannotReplaceMissingTableException, FunctionAlreadyExistsException, NamespaceAlreadyExistsException, NoSuchFunctionException, NoSuchNamespaceException, NoSuchPartitionException, NoSuchTableException, ResolvedTable, Star, TableAlreadyExistsException, UnresolvedRegex}
+import org.apache.spark.sql.catalyst.analysis.{CannotReplaceMissingTableException, FunctionAlreadyExistsException, NamespaceAlreadyExistsException, NoSuchFunctionException, NoSuchNamespaceException, NoSuchPartitionException, NoSuchTableException, Star, TableAlreadyExistsException, UnresolvedRegex}
import org.apache.spark.sql.catalyst.catalog.{CatalogTable, InvalidUDFClassException}
import org.apache.spark.sql.catalyst.catalog.CatalogTypes.TablePartitionSpec
import org.apache.spark.sql.catalyst.expressions.{Alias, Attribute, AttributeReference, AttributeSet, CreateMap, CreateStruct, Expression, GroupingID, NamedExpression, SpecifiedWindowFrame, WindowFrame, WindowFunction, WindowSpecDefinition}
@@ -1020,20 +1020,6 @@ private[sql] object QueryCompilationErrors extends QueryErrorsBase with Compilat
"operation" -> operation))
}
- def alterColumnWithV1TableCannotSpecifyNotNullError(): Throwable = {
- new AnalysisException(
- errorClass = "_LEGACY_ERROR_TEMP_1053",
- messageParameters = Map.empty)
- }
-
- def alterColumnCannotFindColumnInV1TableError(colName: String, v1Table: V1Table): Throwable = {
- new AnalysisException(
- errorClass = "_LEGACY_ERROR_TEMP_1054",
- messageParameters = Map(
- "colName" -> colName,
- "fieldNames" -> v1Table.schema.fieldNames.mkString(", ")))
- }
-
def wrongCommandForObjectTypeError(
operation: String,
requiredType: String,
@@ -3364,6 +3350,16 @@ private[sql] object QueryCompilationErrors extends QueryErrorsBase with Compilat
)
}
+ def unresolvedColumnError(
+ fieldName: Seq[String], fields: Array[String], context: Origin): AnalysisException = {
+ new AnalysisException(
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ messageParameters = Map(
+ "objectName" -> toSQLId(fieldName),
+ "proposal" -> fields.map(toSQLId).mkString(", ")),
+ origin = context)
+ }
+
def cannotParseIntervalError(delayThreshold: String, e: Throwable): Throwable = {
val threshold = if (delayThreshold == null) "" else delayThreshold
new AnalysisException(
@@ -3472,17 +3468,6 @@ private[sql] object QueryCompilationErrors extends QueryErrorsBase with Compilat
messageParameters = Map("className" -> className))
}
- def missingFieldError(
- fieldName: Seq[String], table: ResolvedTable, context: Origin): Throwable = {
- new AnalysisException(
- errorClass = "_LEGACY_ERROR_TEMP_1331",
- messageParameters = Map(
- "fieldName" -> fieldName.quoted,
- "table" -> table.name,
- "schema" -> table.schema.treeString),
- origin = context)
- }
-
def invalidFieldName(fieldName: Seq[String], path: Seq[String], context: Origin): Throwable = {
new AnalysisException(
errorClass = "INVALID_FIELD_NAME",
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala b/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala
index 61a27e3434c9..9053fb9cc73f 100644
--- a/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala
+++ b/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala
@@ -74,7 +74,8 @@ class ResolveSessionCatalog(val catalogManager: CatalogManager)
catalog, ident, "ALTER COLUMN with qualified column")
}
if (a.nullable.isDefined) {
- throw QueryCompilationErrors.alterColumnWithV1TableCannotSpecifyNotNullError()
+ throw QueryCompilationErrors.unsupportedTableOperationError(
+ catalog, ident, "ALTER COLUMN ... SET NOT NULL")
}
if (a.position.isDefined) {
throw QueryCompilationErrors.unsupportedTableOperationError(
@@ -88,8 +89,8 @@ class ResolveSessionCatalog(val catalogManager: CatalogManager)
table.schema.findNestedField(Seq(colName), resolver = conf.resolver)
.map(_._2.dataType)
.getOrElse {
- throw QueryCompilationErrors.alterColumnCannotFindColumnInV1TableError(
- quoteIfNeeded(colName), table)
+ throw QueryCompilationErrors.unresolvedColumnError(
+ toSQLId(a.column.name), table.schema.fieldNames)
}
}
// Add the current default column value string (if any) to the column metadata.
diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/change-column.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/change-column.sql.out
index 645057b85c00..64ae845550f2 100644
--- a/sql/core/src/test/resources/sql-tests/analyzer-results/change-column.sql.out
+++ b/sql/core/src/test/resources/sql-tests/analyzer-results/change-column.sql.out
@@ -167,11 +167,11 @@ ALTER TABLE test_change CHANGE invalid_col TYPE INT
-- !query analysis
org.apache.spark.sql.AnalysisException
{
- "errorClass" : "_LEGACY_ERROR_TEMP_1331",
+ "errorClass" : "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ "sqlState" : "42703",
"messageParameters" : {
- "fieldName" : "invalid_col",
- "schema" : "root\n |-- a: integer (nullable = true)\n |-- b: string (nullable = true)\n |-- c: integer (nullable = true)\n",
- "table" : "spark_catalog.default.test_change"
+ "objectName" : "`invalid_col`",
+ "proposal" : "`a`, `b`, `c`"
},
"queryContext" : [ {
"objectType" : "",
diff --git a/sql/core/src/test/resources/sql-tests/results/change-column.sql.out b/sql/core/src/test/resources/sql-tests/results/change-column.sql.out
index b1c0094bcfa9..a6110543159a 100644
--- a/sql/core/src/test/resources/sql-tests/results/change-column.sql.out
+++ b/sql/core/src/test/resources/sql-tests/results/change-column.sql.out
@@ -219,11 +219,11 @@ struct<>
-- !query output
org.apache.spark.sql.AnalysisException
{
- "errorClass" : "_LEGACY_ERROR_TEMP_1331",
+ "errorClass" : "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ "sqlState" : "42703",
"messageParameters" : {
- "fieldName" : "invalid_col",
- "schema" : "root\n |-- a: integer (nullable = true)\n |-- b: string (nullable = true)\n |-- c: integer (nullable = true)\n",
- "table" : "spark_catalog.default.test_change"
+ "objectName" : "`invalid_col`",
+ "proposal" : "`a`, `b`, `c`"
},
"queryContext" : [ {
"objectType" : "",
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/connector/AlterTableTests.scala b/sql/core/src/test/scala/org/apache/spark/sql/connector/AlterTableTests.scala
index 28605958c71d..5b0d61fb6d77 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/connector/AlterTableTests.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/connector/AlterTableTests.scala
@@ -432,11 +432,20 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t ADD COLUMN point.z double")
- }
-
- assert(exc.getMessage.contains("Missing field point"))
+ val sqlText = s"ALTER TABLE $t ADD COLUMN point.z double"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`point`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(
+ fragment = "point.z double",
+ start = 24 + t.length,
+ stop = 37 + t.length))
}
}
@@ -758,11 +767,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t ALTER COLUMN data TYPE string")
- }
-
- assert(exc.getMessage.contains("Missing field data"))
+ val sqlText = s"ALTER TABLE $t ALTER COLUMN data TYPE string"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`data`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
}
}
@@ -771,11 +786,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t ALTER COLUMN point.x TYPE double")
- }
-
- assert(exc.getMessage.contains("Missing field point.x"))
+ val sqlText = s"ALTER TABLE $t ALTER COLUMN point.x TYPE double"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`point`.`x`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
}
}
@@ -840,9 +861,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
.add("z", IntegerType))
.add("b", IntegerType))
- val e1 = intercept[AnalysisException](
- sql(s"ALTER TABLE $t ALTER COLUMN b AFTER non_exist"))
- assert(e1.getMessage.contains("Missing field non_exist"))
+ val sqlText1 = s"ALTER TABLE $t ALTER COLUMN b AFTER non_exist"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText1)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`non_exist`",
+ "proposal" -> "`a`, `point`, `b`"),
+ context = ExpectedContext(fragment = sqlText1, start = 0, stop = sqlText1.length - 1))
sql(s"ALTER TABLE $t ALTER COLUMN point.y FIRST")
assert(getTableMetadata(t).schema == new StructType()
@@ -862,9 +891,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
.add("y", IntegerType))
.add("b", IntegerType))
- val e2 = intercept[AnalysisException](
- sql(s"ALTER TABLE $t ALTER COLUMN point.y AFTER non_exist"))
- assert(e2.getMessage.contains("Missing field point.non_exist"))
+ val sqlText2 = s"ALTER TABLE $t ALTER COLUMN point.y AFTER non_exist"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText2)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`point`.`non_exist`",
+ "proposal" -> "`a`, `point`, `b`"),
+ context = ExpectedContext(fragment = sqlText2, start = 0, stop = sqlText2.length - 1))
// `AlterTable.resolved` checks column existence.
intercept[AnalysisException](
@@ -947,11 +984,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t ALTER COLUMN data COMMENT 'doc'")
- }
-
- assert(exc.getMessage.contains("Missing field data"))
+ val sqlText = s"ALTER TABLE $t ALTER COLUMN data COMMENT 'doc'"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`data`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
}
}
@@ -960,11 +1003,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t ALTER COLUMN point.x COMMENT 'doc'")
- }
-
- assert(exc.getMessage.contains("Missing field point.x"))
+ val sqlText = s"ALTER TABLE $t ALTER COLUMN point.x COMMENT 'doc'"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`point`.`x`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
}
}
@@ -1056,11 +1105,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t RENAME COLUMN data TO some_string")
- }
-
- assert(exc.getMessage.contains("Missing field data"))
+ val sqlText = s"ALTER TABLE $t RENAME COLUMN data TO some_string"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`data`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
}
}
@@ -1069,11 +1124,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t RENAME COLUMN point.x TO z")
- }
-
- assert(exc.getMessage.contains("Missing field point.x"))
+ val sqlText = s"ALTER TABLE $t RENAME COLUMN point.x TO z"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`point`.`x`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
}
}
@@ -1216,11 +1277,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t DROP COLUMN data")
- }
-
- assert(exc.getMessage.contains("Missing field data"))
+ val sqlText = s"ALTER TABLE $t DROP COLUMN data"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`data`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
// with if exists it should pass
sql(s"ALTER TABLE $t DROP COLUMN IF EXISTS data")
@@ -1234,11 +1301,17 @@ trait AlterTableTests extends SharedSparkSession with QueryErrorsBase {
withTable(t) {
sql(s"CREATE TABLE $t (id int) USING $v2Format")
- val exc = intercept[AnalysisException] {
- sql(s"ALTER TABLE $t DROP COLUMN point.x")
- }
-
- assert(exc.getMessage.contains("Missing field point.x"))
+ val sqlText = s"ALTER TABLE $t DROP COLUMN point.x"
+ checkError(
+ exception = intercept[AnalysisException] {
+ sql(sqlText)
+ },
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
+ parameters = Map(
+ "objectName" -> "`point`.`x`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = sqlText.length - 1))
// with if exists it should pass
sql(s"ALTER TABLE $t DROP COLUMN IF EXISTS point.x")
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2SQLSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2SQLSuite.scala
index 6cdb0d8aee91..3cde04128f42 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2SQLSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2SQLSuite.scala
@@ -2859,19 +2859,12 @@ class DataSourceV2SQLSuiteV1Filter
exception = intercept[AnalysisException] {
sql(sql1)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "non_exist",
- "table" -> "testcat.tbl",
- "schema" ->
- """root
- | |-- id: long (nullable = true)
- | |-- data: string (nullable = true)
- |""".stripMargin),
- context = ExpectedContext(
- fragment = sql1,
- start = 0,
- stop = 40))
+ "objectName" -> "`non_exist`",
+ "proposal" -> "`id`, `data`"),
+ context = ExpectedContext(fragment = sql1, start = 0, stop = 40))
val sql2 = s"CREATE index i1 ON $t(id)"
checkError(
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/connector/V2CommandsCaseSensitivitySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/connector/V2CommandsCaseSensitivitySuite.scala
index 3ab7edb78439..b4a768a75989 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/connector/V2CommandsCaseSensitivitySuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/connector/V2CommandsCaseSensitivitySuite.scala
@@ -37,7 +37,6 @@ class V2CommandsCaseSensitivitySuite
with QueryErrorsBase {
import CreateTablePartitioningValidationSuite._
- import org.apache.spark.sql.connector.catalog.CatalogV2Implicits._
private val table = ResolvedTable(
catalog,
@@ -156,7 +155,10 @@ class V2CommandsCaseSensitivitySuite
Seq(QualifiedColType(
Some(UnresolvedFieldName(field.init.toImmutableArraySeq)),
field.last, LongType, true, None, None, None))),
- Seq("Missing field " + field.head)
+ expectedErrorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ expectedMessageParameters = Map(
+ "objectName" -> s"`${field.head}`",
+ "proposal" -> "`id`, `data`, `point`")
)
}
}
@@ -328,18 +330,20 @@ class V2CommandsCaseSensitivitySuite
test("AlterTable: drop column resolution") {
Seq(Array("ID"), Array("point", "X"), Array("POINT", "X"), Array("POINT", "x")).foreach { ref =>
Seq(true, false).foreach { ifExists =>
- val expectedErrors = if (ifExists) {
- Seq.empty[String]
- } else {
- Seq("Missing field " + ref.quoted)
- }
val alter = DropColumns(table, Seq(UnresolvedFieldName(ref.toImmutableArraySeq)), ifExists)
if (ifExists) {
// using IF EXISTS will silence all errors for missing columns
assertAnalysisSuccess(alter, caseSensitive = true)
assertAnalysisSuccess(alter, caseSensitive = false)
} else {
- alterTableTest(alter, expectedErrors, expectErrorOnCaseSensitive = true)
+ alterTableTest(
+ alter = alter,
+ expectedErrorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ expectedMessageParameters = Map(
+ "objectName" -> s"${toSQLId(ref.toImmutableArraySeq)}",
+ "proposal" -> "`id`, `data`, `point`"
+ ),
+ expectErrorOnCaseSensitive = true)
}
}
}
@@ -348,8 +352,11 @@ class V2CommandsCaseSensitivitySuite
test("AlterTable: rename column resolution") {
Seq(Array("ID"), Array("point", "X"), Array("POINT", "X"), Array("POINT", "x")).foreach { ref =>
alterTableTest(
- RenameColumn(table, UnresolvedFieldName(ref.toImmutableArraySeq), "newName"),
- Seq("Missing field " + ref.quoted)
+ alter = RenameColumn(table, UnresolvedFieldName(ref.toImmutableArraySeq), "newName"),
+ expectedErrorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ expectedMessageParameters = Map(
+ "objectName" -> s"${toSQLId(ref.toImmutableArraySeq)}",
+ "proposal" -> "`id`, `data`, `point`")
)
}
}
@@ -359,7 +366,10 @@ class V2CommandsCaseSensitivitySuite
alterTableTest(
AlterColumn(table, UnresolvedFieldName(ref.toImmutableArraySeq),
None, Some(true), None, None, None),
- Seq("Missing field " + ref.quoted)
+ expectedErrorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ expectedMessageParameters = Map(
+ "objectName" -> s"${toSQLId(ref.toImmutableArraySeq)}",
+ "proposal" -> "`id`, `data`, `point`")
)
}
}
@@ -369,7 +379,10 @@ class V2CommandsCaseSensitivitySuite
alterTableTest(
AlterColumn(table, UnresolvedFieldName(ref.toImmutableArraySeq),
Some(StringType), None, None, None, None),
- Seq("Missing field " + ref.quoted)
+ expectedErrorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ expectedMessageParameters = Map(
+ "objectName" -> s"${toSQLId(ref.toImmutableArraySeq)}",
+ "proposal" -> "`id`, `data`, `point`")
)
}
}
@@ -379,7 +392,10 @@ class V2CommandsCaseSensitivitySuite
alterTableTest(
AlterColumn(table, UnresolvedFieldName(ref.toImmutableArraySeq),
None, None, Some("comment"), None, None),
- Seq("Missing field " + ref.quoted)
+ expectedErrorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ expectedMessageParameters = Map(
+ "objectName" -> s"${toSQLId(ref.toImmutableArraySeq)}",
+ "proposal" -> "`id`, `data`, `point`")
)
}
}
@@ -397,13 +413,15 @@ class V2CommandsCaseSensitivitySuite
private def alterTableTest(
alter: => AlterTableCommand,
- error: Seq[String],
+ expectedErrorClass: String,
+ expectedMessageParameters: Map[String, String],
expectErrorOnCaseSensitive: Boolean = true): Unit = {
Seq(true, false).foreach { caseSensitive =>
withSQLConf(SQLConf.CASE_SENSITIVE.key -> caseSensitive.toString) {
val expectError = if (expectErrorOnCaseSensitive) caseSensitive else !caseSensitive
if (expectError) {
- assertAnalysisError(alter, error, caseSensitive)
+ assertAnalysisErrorClass(
+ alter, expectedErrorClass, expectedMessageParameters, caseSensitive = caseSensitive)
} else {
assertAnalysisSuccess(alter, caseSensitive)
}
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/PlanResolutionSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/PlanResolutionSuite.scala
index f004ab7137f7..13735658e6fd 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/PlanResolutionSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/PlanResolutionSuite.scala
@@ -1333,18 +1333,11 @@ class PlanResolutionSuite extends AnalysisTest {
exception = intercept[AnalysisException] {
parseAndResolve(sql3)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "j",
- "table" -> "spark_catalog.default.v1Table",
- "schema" ->
- """root
- | |-- i: integer (nullable = true)
- | |-- s: string (nullable = true)
- | |-- point: struct (nullable = true)
- | | |-- x: integer (nullable = true)
- | | |-- y: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`j`",
+ "proposal" -> "`i`, `s`, `point`"),
context = ExpectedContext(fragment = sql3, start = 0, stop = 55))
val sql4 = s"ALTER TABLE $tblName ALTER COLUMN point.x TYPE bigint"
@@ -1357,6 +1350,15 @@ class PlanResolutionSuite extends AnalysisTest {
sqlState = "0A000",
parameters = Map("tableName" -> "`spark_catalog`.`default`.`v1Table`",
"operation" -> "ALTER COLUMN with qualified column"))
+
+ checkError(
+ exception = intercept[AnalysisException] {
+ parseAndResolve(s"ALTER TABLE $tblName ALTER COLUMN i SET NOT NULL")
+ },
+ errorClass = "UNSUPPORTED_FEATURE.TABLE_OPERATION",
+ sqlState = "0A000",
+ parameters = Map("tableName" -> "`spark_catalog`.`default`.`v1Table`",
+ "operation" -> "ALTER COLUMN ... SET NOT NULL"))
} else {
parsed1 match {
case AlterColumn(
@@ -1417,18 +1419,11 @@ class PlanResolutionSuite extends AnalysisTest {
exception = intercept[AnalysisException] {
parseAndResolve(sql)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "I",
- "table" -> "spark_catalog.default.v1Table",
- "schema" ->
- """root
- | |-- i: integer (nullable = true)
- | |-- s: string (nullable = true)
- | |-- point: struct (nullable = true)
- | | |-- x: integer (nullable = true)
- | | |-- y: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`I`",
+ "proposal" -> "`i`, `s`, `point`"),
context = ExpectedContext(fragment = sql, start = 0, stop = 55))
} else {
val actual = parseAndResolve(sql)
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableDropColumnSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableDropColumnSuite.scala
index 3adcc42c6be5..d541f1286e59 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableDropColumnSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableDropColumnSuite.scala
@@ -127,16 +127,12 @@ class AlterTableDropColumnSuite
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "does_not_exist",
- "table" -> t,
- "schema" ->
- """root
- | |-- id: integer (nullable = true)
- |""".stripMargin),
- context = ExpectedContext(fragment = sqlText, start = 0, stop = 57)
- )
+ "objectName" -> "`does_not_exist`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = 57))
}
}
@@ -149,16 +145,12 @@ class AlterTableDropColumnSuite
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "point.does_not_exist",
- "table" -> t,
- "schema" ->
- """root
- | |-- id: integer (nullable = true)
- |""".stripMargin),
- context = ExpectedContext(fragment = sqlText, start = 0, stop = 63)
- )
+ "objectName" -> "`point`.`does_not_exist`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = 63))
// with if exists it should pass
sql(s"ALTER TABLE $t DROP COLUMN IF EXISTS point.does_not_exist")
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableRenameColumnSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableRenameColumnSuite.scala
index a15d14182261..a2ab63d9ebd8 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableRenameColumnSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/AlterTableRenameColumnSuite.scala
@@ -153,16 +153,12 @@ class AlterTableRenameColumnSuite
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "does_not_exist",
- "table" -> t,
- "schema" ->
- """root
- | |-- id: integer (nullable = true)
- |""".stripMargin),
- context = ExpectedContext(fragment = sqlText, start = 0, stop = 64)
- )
+ "objectName" -> "`does_not_exist`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = 64))
}
}
@@ -175,16 +171,12 @@ class AlterTableRenameColumnSuite
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "point.does_not_exist",
- "table" -> t,
- "schema" ->
- """root
- | |-- id: integer (nullable = true)
- |""".stripMargin),
- context = ExpectedContext(fragment = sqlText, start = 0, stop = 70)
- )
+ "objectName" -> "`point`.`does_not_exist`",
+ "proposal" -> "`id`"),
+ context = ExpectedContext(fragment = sqlText, start = 0, stop = 70))
}
}
}
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/jdbc/JDBCTableCatalogSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/jdbc/JDBCTableCatalogSuite.scala
index d2ff33e10477..8e5fba3607b9 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/jdbc/JDBCTableCatalogSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/jdbc/JDBCTableCatalogSuite.scala
@@ -279,14 +279,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "bad_column",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- C2: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`bad_column`",
+ "proposal" -> "`C2`"),
context = ExpectedContext(sqlText, 0, 51))
}
// Drop a column to not existing table and namespace
@@ -319,15 +316,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "bad_column",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- ID: double (nullable = true)
- | |-- deptno: double (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`bad_column`",
+ "proposal" -> "`ID`, `deptno`"),
context = ExpectedContext(sqlText, 0, 64))
// Update column to wrong type
checkError(
@@ -368,15 +361,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "bad_column",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- ID: integer (nullable = true)
- | |-- deptno: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`bad_column`",
+ "proposal" -> "`ID`, `deptno`"),
context = ExpectedContext(sqlText, 0, 66))
}
// Update column nullability in not existing table and namespace
@@ -465,14 +454,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "bad_column",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- ID: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`bad_column`",
+ "proposal" -> "`ID`"),
context = ExpectedContext(sqlText, 0, 67))
}
// Update column comments in not existing table and namespace
@@ -504,15 +490,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "C2",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- c1: integer (nullable = true)
- | |-- c2: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`C2`",
+ "proposal" -> "`c1`, `c2`"),
context = ExpectedContext(sqlText, 0, 51))
}
@@ -531,15 +513,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "C3",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- c1: integer (nullable = true)
- | |-- c3: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`C3`",
+ "proposal" -> "`c1`, `c3`"),
context = ExpectedContext(sqlText, 0, sqlText.length - 1))
}
@@ -557,14 +535,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "C1",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- c1: integer (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`C1`",
+ "proposal" -> "`c1`"),
context = ExpectedContext(sqlText, 0, sqlText.length - 1))
}
@@ -582,14 +557,11 @@ class JDBCTableCatalogSuite extends QueryTest with SharedSparkSession {
exception = intercept[AnalysisException] {
sql(sqlText)
},
- errorClass = "_LEGACY_ERROR_TEMP_1331",
+ errorClass = "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ sqlState = "42703",
parameters = Map(
- "fieldName" -> "C1",
- "table" -> "h2.test.alt_table",
- "schema" ->
- """root
- | |-- c1: double (nullable = true)
- |""".stripMargin),
+ "objectName" -> "`C1`",
+ "proposal" -> "`c1`"),
context = ExpectedContext(sqlText, 0, sqlText.length - 1))
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@spark.apache.org
For additional commands, e-mail: commits-help@spark.apache.org