You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by gi...@apache.org on 2026/10/02 09:34:06 UTC
(datafusion-sqlparser-rs) 01/01: Generic: Parse IN lists that start with a parenthesized subquery (#2586)
This is an automated email from the ASF dual-hosted git repository.
github-merge-queue[bot] pushed a commit to branch gh-readonly-queue/main/pr-2586-7939d4b649ba18fa37b9782838c855ec5e9289a8
in repository https://gitbox.apache.org/repos/asf/datafusion-sqlparser-rs.git
commit 1ba145bd7defe37b25f374c9dcd479777e293437
Author: Luca Cappelletti <ca...@gmail.com>
AuthorDate: Fri Oct 2 09:33:44 2026 +0000
Generic: Parse IN lists that start with a parenthesized subquery (#2586)
---
src/parser/mod.rs | 64 +++++++++++++++++++------
tests/sqlparser_common.rs | 116 ++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 165 insertions(+), 15 deletions(-)
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 0d99cf58..1a46c6e5 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -355,6 +355,11 @@ pub struct Parser<'a> {
/// `parse_table_factor`. See [`Parser::parse_table_factor`] for the 2^N
/// pattern this guards.
failed_derived_table_factor_positions: BTreeSet<usize>,
+ /// Cached failures from the speculative subquery arm of [`Parser::parse_in`],
+ /// which `IN` lists nested in a leading subquery would otherwise retry at
+ /// every level, taking 2^N time. Maps the arm's start to where a parsed
+ /// query lacked its `)`.
+ failed_in_subquery_positions: BTreeMap<usize, Option<usize>>,
}
/// Copy marker for a [`ParserError`] cached by the `parse_prefix` failure
@@ -401,6 +406,7 @@ impl<'a> Parser<'a> {
failed_prefix_positions: BTreeMap::new(),
failed_reserved_word_prefix_positions: BTreeMap::new(),
failed_derived_table_factor_positions: BTreeSet::new(),
+ failed_in_subquery_positions: BTreeMap::new(),
}
}
@@ -469,6 +475,7 @@ impl<'a> Parser<'a> {
self.failed_prefix_positions.clear();
self.failed_reserved_word_prefix_positions.clear();
self.failed_derived_table_factor_positions.clear();
+ self.failed_in_subquery_positions.clear();
self
}
@@ -4464,24 +4471,51 @@ impl<'a> Parser<'a> {
});
}
self.expect_token(&Token::LParen)?;
- let in_op = match self.maybe_parse(|p| p.parse_query())? {
- Some(subquery) => Expr::InSubquery {
- expr: Box::new(expr),
- subquery,
- negated,
- },
- None => Expr::InList {
+ // A leading query is the whole subquery only when `)` follows it,
+ // otherwise it is the first item of a list, as in `IN ((SELECT 1), 2)`.
+ let start = self.index;
+ // Where a parsed query lacked its `)`. Reported if the list fails no
+ // further in, since that error would sit inside the query.
+ let missing_rparen = match self.failed_in_subquery_positions.get(&start) {
+ Some(&cached) => cached,
+ None => {
+ let mut missing_rparen = None;
+ if let Some(subquery) = self.maybe_parse(|p| p.parse_query())? {
+ if self.consume_token(&Token::RParen) {
+ return Ok(Expr::InSubquery {
+ expr: Box::new(expr),
+ subquery,
+ negated,
+ });
+ }
+ missing_rparen = Some(self.index);
+ self.index = start;
+ }
+ self.failed_in_subquery_positions
+ .insert(start, missing_rparen);
+ missing_rparen
+ }
+ };
+ let list = if self.dialect.supports_in_empty_list() {
+ self.parse_comma_separated0(Parser::parse_expr, Token::RParen)
+ } else {
+ self.parse_comma_separated(Parser::parse_expr)
+ };
+ match list.and_then(|list| self.expect_token(&Token::RParen).map(|_| list)) {
+ Ok(list) => Ok(Expr::InList {
expr: Box::new(expr),
- list: if self.dialect.supports_in_empty_list() {
- self.parse_comma_separated0(Parser::parse_expr, Token::RParen)?
- } else {
- self.parse_comma_separated(Parser::parse_expr)?
- },
+ list,
negated,
+ }),
+ Err(ParserError::RecursionLimitExceeded) => Err(ParserError::RecursionLimitExceeded),
+ Err(e) => match missing_rparen {
+ Some(index) if self.index <= index => {
+ self.index = index;
+ self.expected_ref(")", self.peek_token_ref())
+ }
+ _ => Err(e),
},
- };
- self.expect_token(&Token::RParen)?;
- Ok(in_op)
+ }
}
/// Parses `BETWEEN <low> AND <high>`, assuming the `BETWEEN` keyword was already consumed.
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index d92d7154..8e08c657 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -20301,6 +20301,122 @@ fn parse_placeholder_disallows_quoted_ident() {
);
}
+#[test]
+fn parse_in_list_leading_subquery() {
+ let x = || Box::new(Expr::Identifier(Ident::new("x")));
+ let subquery = || Expr::Subquery(Box::new(verified_query("SELECT a FROM u")));
+
+ let select = verified_only_select("SELECT * FROM t WHERE x IN ((SELECT a FROM u), 1)");
+ assert_eq!(
+ Expr::InList {
+ expr: x(),
+ list: vec![subquery(), Expr::value(number("1"))],
+ negated: false,
+ },
+ select.selection.unwrap()
+ );
+
+ let select = verified_only_select("SELECT * FROM t WHERE x NOT IN (((SELECT a FROM u)), 1)");
+ assert_eq!(
+ Expr::InList {
+ expr: x(),
+ list: vec![Expr::Nested(Box::new(subquery())), Expr::value(number("1"))],
+ negated: true,
+ },
+ select.selection.unwrap()
+ );
+
+ let select = verified_only_select("SELECT * FROM t WHERE x IN ((SELECT a FROM u) + 1, 2)");
+ assert_eq!(
+ Expr::InList {
+ expr: x(),
+ list: vec![
+ Expr::BinaryOp {
+ left: Box::new(subquery()),
+ op: BinaryOperator::Plus,
+ right: Box::new(Expr::value(number("1"))),
+ },
+ Expr::value(number("2"))
+ ],
+ negated: false,
+ },
+ select.selection.unwrap()
+ );
+
+ let select = pg_and_generic()
+ .verified_only_select("SELECT * FROM t WHERE x IN ((SELECT a FROM u)[1], 2)");
+ assert_matches!(
+ select.selection,
+ Some(Expr::InList { ref list, .. })
+ if matches!(&list[0], Expr::CompoundFieldAccess { root, .. } if **root == subquery())
+ );
+
+ let select = verified_only_select("SELECT * FROM t WHERE x IN ((SELECT a FROM u))");
+ assert_eq!(
+ Expr::InSubquery {
+ expr: x(),
+ subquery: Box::new(verified_query("(SELECT a FROM u)")),
+ negated: false,
+ },
+ select.selection.unwrap()
+ );
+
+ assert_eq!(
+ ParserError::ParserError("Expected: ), found: 1".to_string()),
+ parse_sql_statements("SELECT * FROM t WHERE x IN ((SELECT a FROM u) 1)").unwrap_err()
+ );
+ assert_eq!(
+ ParserError::ParserError("Expected: ), found: EOF".to_string()),
+ parse_sql_statements("SELECT * FROM t WHERE x IN (SELECT a FROM u").unwrap_err()
+ );
+ assert_eq!(
+ ParserError::ParserError("Expected: ), found: EOF".to_string()),
+ parse_sql_statements("SELECT * FROM t WHERE x IN ((SELECT a FROM u), 1").unwrap_err()
+ );
+ // The inner `IN` is read again for the outer list after its subquery
+ // arm was cached as failed.
+ assert_eq!(
+ ParserError::ParserError("Expected: ), found: EOF".to_string()),
+ parse_sql_statements("SELECT * FROM t WHERE x IN ((SELECT 1 FROM u WHERE y IN (SELECT 2")
+ .unwrap_err()
+ );
+}
+
+/// Hang guard for `IN` lists nested in the leading subquery of an enclosing
+/// `IN` list, where every level is first tried as the whole subquery and then
+/// read again as a list item.
+#[test]
+fn parse_in_list_nested_leading_subquery_no_exponential_blowup() {
+ use std::sync::mpsc;
+ use std::thread;
+ use std::time::Duration;
+
+ for level in [
+ "x IN ((SELECT {}), 1)",
+ "x IN ((SELECT {}) + 1, 2)",
+ "x IN (((SELECT {}) + 1), 2)",
+ ] {
+ let sql = format!(
+ "SELECT {}",
+ (0..30).fold("1".to_string(), |inner, _| level.replace("{}", &inner))
+ );
+
+ let (tx, rx) = mpsc::channel();
+ thread::spawn(move || {
+ let result = Parser::new(&GenericDialect {})
+ .with_recursion_limit(1000)
+ .try_with_sql(&sql)
+ .and_then(|mut parser| parser.parse_statements());
+ let _ = tx.send(result.is_ok());
+ });
+
+ let parsed = rx
+ .recv_timeout(Duration::from_secs(5))
+ .expect("parser should handle this quickly, not loop exponentially");
+ assert!(parsed, "{level} nested 30 deep should parse");
+ }
+}
+
#[test]
fn parse_bang_not_renders_apart_from_operand() {
let dialects = all_dialects_where(|d| d.supports_bang_not_operator());
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org