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 6347857 [SPARK-37937][SQL] Use error classes in the parsing errors of
lateral join
6347857 is described below
commit 6347857f0bad105541971283f79281c490f6bb18
Author: Terry Kim <[email protected]>
AuthorDate: Thu Feb 3 14:56:11 2022 +0300
[SPARK-37937][SQL] Use error classes in the parsing errors of lateral join
### What changes were proposed in this pull request?
In the PR, I propose to use the following error classes for the parsing
errors of lateral joins:
- `INVALID_SQL_SYNTAX `
- `UNSUPPORTED_FEATURE `
These new error classes are added to `error-classes.json`.
### Why are the changes needed?
Porting the parsing errors for lateral join to the new error framework
should improve user experience with Spark SQL.
### Does this PR introduce _any_ user-facing change?
No
### How was this patch tested?
Added new test suite
Closes #35328 from imback82/SPARK-37937.
Authored-by: Terry Kim <[email protected]>
Signed-off-by: Max Gekk <[email protected]>
---
core/src/main/resources/error/error-classes.json | 4 ++
.../spark/sql/errors/QueryParsingErrors.scala | 8 +--
.../sql/catalyst/parser/ErrorParserSuite.scala | 10 ---
.../sql-tests/results/join-lateral.sql.out | 4 +-
.../spark/sql/errors/QueryParsingErrorsSuite.scala | 81 ++++++++++++++++++++++
5 files changed, 91 insertions(+), 16 deletions(-)
diff --git a/core/src/main/resources/error/error-classes.json
b/core/src/main/resources/error/error-classes.json
index a1ac99f..06ce22a 100644
--- a/core/src/main/resources/error/error-classes.json
+++ b/core/src/main/resources/error/error-classes.json
@@ -93,6 +93,10 @@
"message" : [ "The value of parameter(s) '%s' in %s is invalid: %s" ],
"sqlState" : "22023"
},
+ "INVALID_SQL_SYNTAX" : {
+ "message" : [ "Invalid SQL syntax: %s" ],
+ "sqlState" : "42000"
+ },
"MAP_KEY_DOES_NOT_EXIST" : {
"message" : [ "Key %s does not exist. If necessary set %s to false to
bypass this error." ]
},
diff --git
a/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala
b/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala
index 938bbfd..6bcd20c 100644
---
a/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala
+++
b/sql/catalyst/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala
@@ -102,19 +102,19 @@ object QueryParsingErrors {
}
def lateralJoinWithNaturalJoinUnsupportedError(ctx: ParserRuleContext):
Throwable = {
- new ParseException("LATERAL join with NATURAL join is not supported", ctx)
+ new ParseException("UNSUPPORTED_FEATURE", Array("LATERAL join with NATURAL
join."), ctx)
}
def lateralJoinWithUsingJoinUnsupportedError(ctx: ParserRuleContext):
Throwable = {
- new ParseException("LATERAL join with USING join is not supported", ctx)
+ new ParseException("UNSUPPORTED_FEATURE", Array("LATERAL join with USING
join."), ctx)
}
def unsupportedLateralJoinTypeError(ctx: ParserRuleContext, joinType:
String): Throwable = {
- new ParseException(s"Unsupported LATERAL join type $joinType", ctx)
+ new ParseException("UNSUPPORTED_FEATURE", Array(s"LATERAL join type
'$joinType'."), ctx)
}
def invalidLateralJoinRelationError(ctx: RelationPrimaryContext): Throwable
= {
- new ParseException(s"LATERAL can only be used with subquery", ctx)
+ new ParseException("INVALID_SQL_SYNTAX", Array("LATERAL can only be used
with subquery."), ctx)
}
def repetitiveWindowDefinitionError(name: String, ctx: WindowClauseContext):
Throwable = {
diff --git
a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ErrorParserSuite.scala
b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ErrorParserSuite.scala
index dfc5edc..99051d6 100644
---
a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ErrorParserSuite.scala
+++
b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ErrorParserSuite.scala
@@ -208,14 +208,4 @@ class ErrorParserSuite extends AnalysisTest {
|SELECT b
""".stripMargin, 2, 9, 10, msg + " test-table")
}
-
- test("SPARK-35789: lateral join with non-subquery relations") {
- val msg = "LATERAL can only be used with subquery"
- intercept("SELECT * FROM t1, LATERAL t2", msg)
- intercept("SELECT * FROM t1 JOIN LATERAL t2", msg)
- intercept("SELECT * FROM t1, LATERAL (t2 JOIN t3)", msg)
- intercept("SELECT * FROM t1, LATERAL (LATERAL t2)", msg)
- intercept("SELECT * FROM t1, LATERAL VALUES (0, 1)", msg)
- intercept("SELECT * FROM t1, LATERAL RANGE(0, 1)", msg)
- }
}
diff --git a/sql/core/src/test/resources/sql-tests/results/join-lateral.sql.out
b/sql/core/src/test/resources/sql-tests/results/join-lateral.sql.out
index c1b595e..cc16198 100644
--- a/sql/core/src/test/resources/sql-tests/results/join-lateral.sql.out
+++ b/sql/core/src/test/resources/sql-tests/results/join-lateral.sql.out
@@ -153,7 +153,7 @@ struct<>
-- !query output
org.apache.spark.sql.catalyst.parser.ParseException
-LATERAL join with NATURAL join is not supported(line 1, pos 14)
+The feature is not supported: LATERAL join with NATURAL join.(line 1, pos 14)
== SQL ==
SELECT * FROM t1 NATURAL JOIN LATERAL (SELECT c1 + c2 AS c2)
@@ -167,7 +167,7 @@ struct<>
-- !query output
org.apache.spark.sql.catalyst.parser.ParseException
-LATERAL join with USING join is not supported(line 1, pos 14)
+The feature is not supported: LATERAL join with USING join.(line 1, pos 14)
== SQL ==
SELECT * FROM t1 JOIN LATERAL (SELECT c1 + c2 AS c2) USING (c2)
diff --git
a/sql/core/src/test/scala/org/apache/spark/sql/errors/QueryParsingErrorsSuite.scala
b/sql/core/src/test/scala/org/apache/spark/sql/errors/QueryParsingErrorsSuite.scala
new file mode 100644
index 0000000..1a213bf
--- /dev/null
+++
b/sql/core/src/test/scala/org/apache/spark/sql/errors/QueryParsingErrorsSuite.scala
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.errors
+
+import org.apache.spark.sql.QueryTest
+import org.apache.spark.sql.catalyst.parser.ParseException
+import org.apache.spark.sql.test.SharedSparkSession
+
+class QueryParsingErrorsSuite extends QueryTest with SharedSparkSession {
+ def validateParsingError(
+ sqlText: String,
+ errorClass: String,
+ sqlState: String,
+ message: String): Unit = {
+ val e = intercept[ParseException] {
+ sql(sqlText)
+ }
+ assert(e.getErrorClass === errorClass)
+ assert(e.getSqlState === sqlState)
+ assert(e.getMessage.contains(message))
+ }
+
+ test("UNSUPPORTED_FEATURE: LATERAL join with NATURAL join not supported") {
+ validateParsingError(
+ sqlText = "SELECT * FROM t1 NATURAL JOIN LATERAL (SELECT c1 + c2 AS c2)",
+ errorClass = "UNSUPPORTED_FEATURE",
+ sqlState = "0A000",
+ message = "The feature is not supported: LATERAL join with NATURAL
join.")
+ }
+
+ test("UNSUPPORTED_FEATURE: LATERAL join with USING join not supported") {
+ validateParsingError(
+ sqlText = "SELECT * FROM t1 JOIN LATERAL (SELECT c1 + c2 AS c2) USING
(c2)",
+ errorClass = "UNSUPPORTED_FEATURE",
+ sqlState = "0A000",
+ message = "The feature is not supported: LATERAL join with USING join.")
+ }
+
+ test("UNSUPPORTED_FEATURE: Unsupported LATERAL join type") {
+ Seq(("RIGHT OUTER", "RightOuter"),
+ ("FULL OUTER", "FullOuter"),
+ ("LEFT SEMI", "LeftSemi"),
+ ("LEFT ANTI", "LeftAnti")).foreach { pair =>
+ validateParsingError(
+ sqlText = s"SELECT * FROM t1 ${pair._1} JOIN LATERAL (SELECT c1 + c2
AS c3) ON c2 = c3",
+ errorClass = "UNSUPPORTED_FEATURE",
+ sqlState = "0A000",
+ message = s"The feature is not supported: LATERAL join type
'${pair._2}'.")
+ }
+ }
+
+ test("SPARK-35789: INVALID_SQL_SYNTAX - LATERAL can only be used with
subquery") {
+ Seq("SELECT * FROM t1, LATERAL t2",
+ "SELECT * FROM t1 JOIN LATERAL t2",
+ "SELECT * FROM t1, LATERAL (t2 JOIN t3)",
+ "SELECT * FROM t1, LATERAL (LATERAL t2)",
+ "SELECT * FROM t1, LATERAL VALUES (0, 1)",
+ "SELECT * FROM t1, LATERAL RANGE(0, 1)").foreach { sqlText =>
+ validateParsingError(
+ sqlText = sqlText,
+ errorClass = "INVALID_SQL_SYNTAX",
+ sqlState = "42000",
+ message = "Invalid SQL syntax: LATERAL can only be used with
subquery.")
+ }
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
