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 e29ada0c13e [SPARK-41062][SQL] Rename `UNSUPPORTED_CORRELATED_REFERENCE` to `CORRELATED_REFERENCE` e29ada0c13e is described below commit e29ada0c13e71aaad0566ef67591a33d4c58fe2a Author: itholic <haejoon....@databricks.com> AuthorDate: Tue Dec 13 21:48:11 2022 +0300 [SPARK-41062][SQL] Rename `UNSUPPORTED_CORRELATED_REFERENCE` to `CORRELATED_REFERENCE` ### What changes were proposed in this pull request? This PR proposes to rename `UNSUPPORTED_CORRELATED_REFERENCE` to `CORRELATED_REFERENCE`. Also, show `sqlExprs` rather than `treeNode` which is more useful information to users. ### Why are the changes needed? The sub-error class name is duplicated with its main class, `UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY`. We should make the all error class name clear and briefly. ### Does this PR introduce _any_ user-facing change? No ### How was this patch tested? ``` ./build/sbt “sql/testOnly org.apache.spark.sql.SQLQueryTestSuite*” ``` Closes #38576 from itholic/SPARK-41062. Lead-authored-by: itholic <haejoon....@databricks.com> Co-authored-by: Haejoon Lee <44108233+itho...@users.noreply.github.com> Signed-off-by: Max Gekk <max.g...@gmail.com> --- core/src/main/resources/error/error-classes.json | 10 +++++----- .../apache/spark/sql/catalyst/analysis/CheckAnalysis.scala | 7 ++++--- .../spark/sql/catalyst/analysis/ResolveSubquerySuite.scala | 13 ++++++++----- .../subquery/negative-cases/invalid-correlation.sql.out | 4 ++-- .../src/test/scala/org/apache/spark/sql/SubquerySuite.scala | 12 +++++------- 5 files changed, 24 insertions(+), 22 deletions(-) diff --git a/core/src/main/resources/error/error-classes.json b/core/src/main/resources/error/error-classes.json index 25362d5893f..e1df3db4291 100644 --- a/core/src/main/resources/error/error-classes.json +++ b/core/src/main/resources/error/error-classes.json @@ -1471,6 +1471,11 @@ "A correlated outer name reference within a subquery expression body was not found in the enclosing query: <value>" ] }, + "CORRELATED_REFERENCE" : { + "message" : [ + "Expressions referencing the outer query are not supported outside of WHERE/HAVING clauses: <sqlExprs>" + ] + }, "LATERAL_JOIN_CONDITION_NON_DETERMINISTIC" : { "message" : [ "Lateral join condition cannot be non-deterministic: <condition>" @@ -1496,11 +1501,6 @@ "Non-deterministic lateral subqueries are not supported when joining with outer relations that produce more than one row<treeNode>" ] }, - "UNSUPPORTED_CORRELATED_REFERENCE" : { - "message" : [ - "Expressions referencing the outer query are not supported outside of WHERE/HAVING clauses<treeNode>" - ] - }, "UNSUPPORTED_CORRELATED_REFERENCE_DATA_TYPE" : { "message" : [ "Correlated column reference '<expr>' cannot be <dataType> type" diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/CheckAnalysis.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/CheckAnalysis.scala index e7e153a319d..5303364710c 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/CheckAnalysis.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/CheckAnalysis.scala @@ -1089,11 +1089,12 @@ trait CheckAnalysis extends PredicateHelper with LookupCatalog with QueryErrorsB // 2. Expressions containing outer references on plan nodes other than allowed operators. def failOnInvalidOuterReference(p: LogicalPlan): Unit = { p.expressions.foreach(checkMixedReferencesInsideAggregateExpr) - if (!canHostOuter(p) && p.expressions.exists(containsOuter)) { + val exprs = stripOuterReferences(p.expressions.filter(expr => containsOuter(expr))) + if (!canHostOuter(p) && !exprs.isEmpty) { p.failAnalysis( errorClass = - "UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.UNSUPPORTED_CORRELATED_REFERENCE", - messageParameters = Map("treeNode" -> planToString(p))) + "UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.CORRELATED_REFERENCE", + messageParameters = Map("sqlExprs" -> exprs.map(toSQLExpr).mkString(","))) } } diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/ResolveSubquerySuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/ResolveSubquerySuite.scala index 577f663d8b1..7b99153acf9 100644 --- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/ResolveSubquerySuite.scala +++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/ResolveSubquerySuite.scala @@ -51,11 +51,14 @@ class ResolveSubquerySuite extends AnalysisTest { test("SPARK-17251 Improve `OuterReference` to be `NamedExpression`") { val expr = Filter( InSubquery(Seq(a), ListQuery(Project(Seq(UnresolvedAttribute("a")), t2))), t1) - val m = intercept[AnalysisException] { - SimpleAnalyzer.checkAnalysis(SimpleAnalyzer.ResolveSubquery(expr)) - }.getMessage - assert(m.contains( - "Expressions referencing the outer query are not supported outside of WHERE/HAVING clauses")) + checkError( + exception = intercept[AnalysisException] { + SimpleAnalyzer.checkAnalysis(SimpleAnalyzer.ResolveSubquery(expr)) + }, + errorClass = "UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.CORRELATED_REFERENCE", + parameters = Map("sqlExprs" -> "\"a\""), + matchPVals = true + ) } test("SPARK-29145 Support subquery in join condition") { diff --git a/sql/core/src/test/resources/sql-tests/results/subquery/negative-cases/invalid-correlation.sql.out b/sql/core/src/test/resources/sql-tests/results/subquery/negative-cases/invalid-correlation.sql.out index cc4349e05f2..26d402479de 100644 --- a/sql/core/src/test/resources/sql-tests/results/subquery/negative-cases/invalid-correlation.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/subquery/negative-cases/invalid-correlation.sql.out @@ -155,9 +155,9 @@ struct<> -- !query output org.apache.spark.sql.AnalysisException { - "errorClass" : "UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.UNSUPPORTED_CORRELATED_REFERENCE", + "errorClass" : "UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.CORRELATED_REFERENCE", "messageParameters" : { - "treeNode" : "Aggregate [min(outer(t2a#x)) AS min(outer(t2.t2a))#x]\n+- SubqueryAlias t3\n +- View (`t3`, [t3a#x,t3b#x,t3c#x])\n +- Project [cast(t3a#x as int) AS t3a#x, cast(t3b#x as int) AS t3b#x, cast(t3c#x as int) AS t3c#x]\n +- Project [t3a#x, t3b#x, t3c#x]\n +- SubqueryAlias t3\n +- LocalRelation [t3a#x, t3b#x, t3c#x]\n" + "sqlExprs" : "\"min(t2a) AS `min(outer(t2.t2a))`\"" }, "queryContext" : [ { "objectType" : "", diff --git a/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala index fe65e282c77..65dd911df31 100644 --- a/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala +++ b/sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala @@ -964,17 +964,15 @@ class SubquerySuite extends QueryTest | WHERE t1.c1 = t2.c1) """.stripMargin) } - checkErrorMatchPVals( + checkError( exception1, - errorClass = "UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.UNSUPPORTED_CORRELATED_REFERENCE", - parameters = Map("treeNode" -> "(?s).*"), - sqlState = None, + errorClass = "UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.CORRELATED_REFERENCE", + parameters = Map("sqlExprs" -> "\"explode(arr_c2)\""), context = ExpectedContext( fragment = "LATERAL VIEW explode(t2.arr_c2) q AS c2", start = 68, - stop = 106)) - assert(exception1.getMessage.contains( - "Expressions referencing the outer query are not supported outside of WHERE/HAVING")) + stop = 106) + ) } } --------------------------------------------------------------------- To unsubscribe, e-mail: commits-unsubscr...@spark.apache.org For additional commands, e-mail: commits-h...@spark.apache.org