From 17d4b3705fafa5a10fb3a93858d22a36812a5459 Mon Sep 17 00:00:00 2001 From: sahilkumarsingh Date: Tue, 9 Dec 2025 00:25:17 +0530 Subject: [PATCH 1/5] [SPARK-54634][SQL] Add clear error message for empty IN predicate --- .../resources/error/error-conditions.json | 5 +++ .../sql/catalyst/parser/SqlBaseParser.g4 | 2 +- .../spark/sql/errors/QueryParsingErrors.scala | 9 ++++ .../sql/catalyst/parser/AstBuilder.scala | 4 ++ .../sql-tests/inputs/predicate-functions.sql | 4 ++ .../results/predicate-functions.sql.out | 42 +++++++++++++++++++ .../sql/errors/QueryParsingErrorsSuite.scala | 41 ++++++++++++++++++ 7 files changed, 106 insertions(+), 1 deletion(-) diff --git a/common/utils/src/main/resources/error/error-conditions.json b/common/utils/src/main/resources/error/error-conditions.json index ac1cde10bdf59..baac54760e3e2 100644 --- a/common/utils/src/main/resources/error/error-conditions.json +++ b/common/utils/src/main/resources/error/error-conditions.json @@ -3909,6 +3909,11 @@ "CREATE TEMPORARY TABLE ... USING ... is a deprecated syntax. To overcome the issue, please use CREATE TEMPORARY VIEW instead." ] }, + "EMPTY_IN_PREDICATE" : { + "message" : [ + "IN predicate requires at least one value. Empty IN clauses like 'IN ()' are not allowed. " + ] + }, "EMPTY_PARTITION_VALUE" : { "message" : [ "Partition key must set value." diff --git a/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseParser.g4 b/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseParser.g4 index 132ced820e9a9..38c7b0f5d03df 100644 --- a/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseParser.g4 +++ b/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseParser.g4 @@ -1206,7 +1206,7 @@ booleanExpression predicate : errorCapturingNot? kind=BETWEEN lower=valueExpression AND upper=valueExpression - | errorCapturingNot? kind=IN LEFT_PAREN expression (COMMA expression)* RIGHT_PAREN + | errorCapturingNot? kind=IN (LEFT_PAREN RIGHT_PAREN | LEFT_PAREN expression (COMMA expression)* RIGHT_PAREN) | errorCapturingNot? kind=IN LEFT_PAREN query RIGHT_PAREN | errorCapturingNot? kind=RLIKE pattern=valueExpression | errorCapturingNot? kind=(LIKE | ILIKE) quantifier=(ANY | SOME | ALL) (LEFT_PAREN RIGHT_PAREN | LEFT_PAREN expression (COMMA expression)* RIGHT_PAREN) diff --git a/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala b/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala index 553161ea2db0a..bebf4b7dab883 100644 --- a/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala +++ b/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala @@ -821,6 +821,15 @@ private[sql] object QueryParsingErrors extends DataTypeErrorsBase { ctx) } + def emptyInPredicateError(ctx: ParserRuleContext): Throwable = { + new ParseException( + errorClass = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + messageParameters = Map( + "alternative" -> ("Consider using 'WHERE FALSE' if you need an always-false condition, " + + "or provide at least one value in the IN list.")), + ctx) + } + /** * Throws an internal error for unexpected parameter markers found during AST building. This * should be unreachable in normal operation due to grammar-level blocking. diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala index f918232c42ac9..2f5e3c03c55ae 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala @@ -2837,6 +2837,10 @@ class AstBuilder extends DataTypeAstBuilder case SqlBaseParser.IN if ctx.query != null => invertIfNotDefined(InSubquery(getValueExpressions(e), ListQuery(plan(ctx.query)))) case SqlBaseParser.IN => + // Validate that IN clause is not empty + if (ctx.expression.isEmpty) { + throw QueryParsingErrors.emptyInPredicateError(ctx) + } invertIfNotDefined(In(e, ctx.expression.asScala.map(expression).toSeq)) case SqlBaseParser.LIKE | SqlBaseParser.ILIKE => Option(ctx.quantifier).map(_.getType) match { diff --git a/sql/core/src/test/resources/sql-tests/inputs/predicate-functions.sql b/sql/core/src/test/resources/sql-tests/inputs/predicate-functions.sql index 195db17a3a1f9..314ac205b7dd8 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/predicate-functions.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/predicate-functions.sql @@ -94,6 +94,10 @@ select 1 not in ('2', '3', '4', null); select null not in (1, 2, 3); select null not in (1, 2, null); +-- Empty IN clause (negative case - should error) +select 1 in (); +select 1 not in (); + -- Between select 1 between 0 and 2; select 0.5 between 0 and 1; diff --git a/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out b/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out index 10ff268a56060..66135ab41a683 100644 --- a/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out @@ -743,6 +743,48 @@ struct<(NOT (NULL IN (1, 2, NULL))):boolean> -- !query output NULL +-- !query +select 1 in () +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.parser.ParseException +{ + "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + "sqlState" : "42000", + "messageParameters" : { + "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 10, + "stopIndex" : 14, + "fragment" : "in ()" + } ] +} + + +-- !query +select 1 not in () +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.parser.ParseException +{ + "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + "sqlState" : "42000", + "messageParameters" : { + "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 10, + "stopIndex" : 18, + "fragment" : "not in ()" + } ] +} -- !query select 1 between 0 and 2 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 index 629d85f19b0a2..4309d783680fe 100644 --- 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 @@ -726,4 +726,45 @@ class QueryParsingErrorsSuite extends QueryTest with SharedSparkSession with SQL start = 32, stop = 58)) } + + test("INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE: Empty IN clause") { + val alternativeMsg = "Consider using 'WHERE FALSE' if you need an always-false condition, " + + "or provide at least one value in the IN list." + + // Test with single column IN () + // PredicateContext captures "IN ()" starting at position 33 + checkError( + exception = parseException("SELECT * FROM range(10) WHERE id IN ()"), + condition = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + sqlState = "42000", + parameters = Map("alternative" -> alternativeMsg), + context = ExpectedContext( + fragment = "IN ()", + start = 33, + stop = 37)) + + // Test with expression IN () + // PredicateContext captures "IN ()" starting at position 39 + checkError( + exception = parseException("SELECT * FROM range(10) WHERE (id + 1) IN ()"), + condition = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + sqlState = "42000", + parameters = Map("alternative" -> alternativeMsg), + context = ExpectedContext( + fragment = "IN ()", + start = 39, + stop = 43)) + + // Test with NOT IN () + // PredicateContext captures "NOT IN ()" starting at position 33 + checkError( + exception = parseException("SELECT * FROM range(10) WHERE id NOT IN ()"), + condition = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + sqlState = "42000", + parameters = Map("alternative" -> alternativeMsg), + context = ExpectedContext( + fragment = "NOT IN ()", + start = 33, + stop = 41)) + } } From b25783f3feb14c9c3dbe6b39b0a644a7db81039f Mon Sep 17 00:00:00 2001 From: sahilkumarsingh Date: Tue, 9 Dec 2025 10:58:23 +0530 Subject: [PATCH 2/5] Updated the PlanParserSuite test --- .../scala/org/apache/spark/sql/errors/QueryParsingErrors.scala | 2 +- .../org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala b/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala index bebf4b7dab883..c569f45575e6a 100644 --- a/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala +++ b/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala @@ -829,7 +829,7 @@ private[sql] object QueryParsingErrors extends DataTypeErrorsBase { "or provide at least one value in the IN list.")), ctx) } - + /** * Throws an internal error for unexpected parameter markers found during AST building. This * should be unreachable in normal operation due to grammar-level blocking. diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala index 59205f308471e..e005c364eec1d 100644 --- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala +++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala @@ -1395,7 +1395,7 @@ class PlanParserSuite extends AnalysisTest { checkError( exception = parseException(sql2), condition = "PARSE_SYNTAX_ERROR", - parameters = Map("error" -> "'IN'", "hint" -> "")) + parameters = Map("error" -> "'INSERT'", "hint" -> "")) } test("relation in v2 catalog") { From 1caa5c6ce55afa0ff6e560c82c17350b4f846070 Mon Sep 17 00:00:00 2001 From: sahilkumarsingh Date: Tue, 9 Dec 2025 14:04:50 +0530 Subject: [PATCH 3/5] Updated the PlanParserSuite test again and predicate-functions.sql.out --- .../sql/catalyst/parser/PlanParserSuite.scala | 2 +- .../predicate-functions.sql.out | 40 +++++++++++++++++++ 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala index e005c364eec1d..0128a3f090c5e 100644 --- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala +++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/PlanParserSuite.scala @@ -1395,7 +1395,7 @@ class PlanParserSuite extends AnalysisTest { checkError( exception = parseException(sql2), condition = "PARSE_SYNTAX_ERROR", - parameters = Map("error" -> "'INSERT'", "hint" -> "")) + parameters = Map("error" -> "'INTO'", "hint" -> "")) } test("relation in v2 catalog") { diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out index 55822a10041f5..a774d0b1d6d74 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out @@ -517,6 +517,46 @@ Project [NOT cast(null as int) IN (cast(1 as int),cast(2 as int),cast(null as in +- OneRowRelation +-- !query +select 1 in () +-- !query analysis +org.apache.spark.sql.catalyst.parser.ParseException +{ + "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + "sqlState" : "42000", + "messageParameters" : { + "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 10, + "stopIndex" : 14, + "fragment" : "in ()" + } ] +} + + +-- !query +select 1 not in () +-- !query analysis +org.apache.spark.sql.catalyst.parser.ParseException +{ + "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", + "sqlState" : "42000", + "messageParameters" : { + "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 10, + "stopIndex" : 18, + "fragment" : "not in ()" + } ] +} + + -- !query select 1 between 0 and 2 -- !query analysis From 415fb9c40d5d72f47202e20ef699e86af63d8190 Mon Sep 17 00:00:00 2001 From: sahilkumarsingh Date: Wed, 7 Jan 2026 11:20:36 +0530 Subject: [PATCH 4/5] Moved static alternative message into error template for EMPTY_IN_PREDICATE --- .../utils/src/main/resources/error/error-conditions.json | 2 +- .../org/apache/spark/sql/errors/QueryParsingErrors.scala | 4 +--- .../analyzer-results/predicate-functions.sql.out | 8 ++------ .../sql-tests/results/predicate-functions.sql.out | 8 ++------ .../spark/sql/errors/QueryParsingErrorsSuite.scala | 9 +++------ 5 files changed, 9 insertions(+), 22 deletions(-) diff --git a/common/utils/src/main/resources/error/error-conditions.json b/common/utils/src/main/resources/error/error-conditions.json index baac54760e3e2..c4a046b3fd915 100644 --- a/common/utils/src/main/resources/error/error-conditions.json +++ b/common/utils/src/main/resources/error/error-conditions.json @@ -3911,7 +3911,7 @@ }, "EMPTY_IN_PREDICATE" : { "message" : [ - "IN predicate requires at least one value. Empty IN clauses like 'IN ()' are not allowed. " + "IN predicate requires at least one value. Empty IN clauses like 'IN ()' are not allowed. Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." ] }, "EMPTY_PARTITION_VALUE" : { diff --git a/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala b/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala index c569f45575e6a..113c6d4abdb84 100644 --- a/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala +++ b/sql/api/src/main/scala/org/apache/spark/sql/errors/QueryParsingErrors.scala @@ -824,9 +824,7 @@ private[sql] object QueryParsingErrors extends DataTypeErrorsBase { def emptyInPredicateError(ctx: ParserRuleContext): Throwable = { new ParseException( errorClass = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", - messageParameters = Map( - "alternative" -> ("Consider using 'WHERE FALSE' if you need an always-false condition, " + - "or provide at least one value in the IN list.")), + messageParameters = Map.empty, ctx) } diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out index a774d0b1d6d74..c699072a662ed 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out @@ -524,9 +524,7 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { - "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." - }, + "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "", @@ -544,9 +542,7 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { - "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." - }, + "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "", diff --git a/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out b/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out index 66135ab41a683..a5ffe6daeaab3 100644 --- a/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out @@ -752,9 +752,7 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { - "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." - }, + "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "", @@ -774,9 +772,7 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { - "alternative" : "Consider using 'WHERE FALSE' if you need an always-false condition, or provide at least one value in the IN list." - }, + "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "", 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 index 4309d783680fe..a58e2d9a8a500 100644 --- 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 @@ -728,16 +728,13 @@ class QueryParsingErrorsSuite extends QueryTest with SharedSparkSession with SQL } test("INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE: Empty IN clause") { - val alternativeMsg = "Consider using 'WHERE FALSE' if you need an always-false condition, " + - "or provide at least one value in the IN list." - // Test with single column IN () // PredicateContext captures "IN ()" starting at position 33 checkError( exception = parseException("SELECT * FROM range(10) WHERE id IN ()"), condition = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", sqlState = "42000", - parameters = Map("alternative" -> alternativeMsg), + parameters = Map.empty, context = ExpectedContext( fragment = "IN ()", start = 33, @@ -749,7 +746,7 @@ class QueryParsingErrorsSuite extends QueryTest with SharedSparkSession with SQL exception = parseException("SELECT * FROM range(10) WHERE (id + 1) IN ()"), condition = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", sqlState = "42000", - parameters = Map("alternative" -> alternativeMsg), + parameters = Map.empty, context = ExpectedContext( fragment = "IN ()", start = 39, @@ -761,7 +758,7 @@ class QueryParsingErrorsSuite extends QueryTest with SharedSparkSession with SQL exception = parseException("SELECT * FROM range(10) WHERE id NOT IN ()"), condition = "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", sqlState = "42000", - parameters = Map("alternative" -> alternativeMsg), + parameters = Map.empty, context = ExpectedContext( fragment = "NOT IN ()", start = 33, From 3a6ec292e04398c418b5efe053f23fbb526e08fb Mon Sep 17 00:00:00 2001 From: sahilkumarsingh Date: Wed, 7 Jan 2026 15:58:41 +0530 Subject: [PATCH 5/5] Updated the golden files --- .../sql-tests/analyzer-results/predicate-functions.sql.out | 2 -- .../resources/sql-tests/results/predicate-functions.sql.out | 2 -- 2 files changed, 4 deletions(-) diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out index c699072a662ed..d894ce26af499 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/predicate-functions.sql.out @@ -524,7 +524,6 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "", @@ -542,7 +541,6 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "", diff --git a/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out b/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out index a5ffe6daeaab3..dd87b536d1d63 100644 --- a/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/predicate-functions.sql.out @@ -752,7 +752,6 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "", @@ -772,7 +771,6 @@ org.apache.spark.sql.catalyst.parser.ParseException { "errorClass" : "INVALID_SQL_SYNTAX.EMPTY_IN_PREDICATE", "sqlState" : "42000", - "messageParameters" : { }, "queryContext" : [ { "objectType" : "", "objectName" : "",