You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by lu...@apache.org on 2026/09/25 15:27:42 UTC
(datafusion-sqlparser-rs) branch upstream/in-list-leading-subquery created (now 7f68cb35e)
This is an automated email from the ASF dual-hosted git repository.
LucaCappelletti94 pushed a change to branch upstream/in-list-leading-subquery
in repository https://gitbox.apache.org/repos/asf/datafusion-sqlparser-rs.git
at 7f68cb35e Generic: Parse IN lists that start with a parenthesized subquery
This branch includes the following new commits:
new 7f68cb35e Generic: Parse IN lists that start with a parenthesized subquery
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org
(datafusion-sqlparser-rs) 01/01: Generic: Parse IN lists that start with a parenthesized subquery
Posted by lu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
LucaCappelletti94 pushed a commit to branch upstream/in-list-leading-subquery
in repository https://gitbox.apache.org/repos/asf/datafusion-sqlparser-rs.git
commit 7f68cb35e270b628048da9c9ddae3060a2c2310f
Author: LucaCappelletti94 <ca...@gmail.com>
AuthorDate: Fri Sep 25 17:27:31 2026 +0200
Generic: Parse IN lists that start with a parenthesized subquery
---
src/parser/mod.rs | 48 ++++++++++++++--------
tests/sqlparser_common.rs | 101 ++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 133 insertions(+), 16 deletions(-)
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 816e8979d..e93de26c1 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -355,6 +355,10 @@ 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.
+ failed_in_subquery_positions: BTreeSet<usize>,
}
/// Copy marker for a [`ParserError`] cached by the `parse_prefix` failure
@@ -401,6 +405,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: BTreeSet::new(),
}
}
@@ -469,6 +474,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
}
@@ -4452,24 +4458,34 @@ 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 {
- 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)?
- },
- negated,
- },
+ // 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;
+ if !self.failed_in_subquery_positions.contains(&start) {
+ if let Some(subquery) = self.maybe_parse(|p| {
+ let subquery = p.parse_query()?;
+ p.expect_token(&Token::RParen)?;
+ Ok(subquery)
+ })? {
+ return Ok(Expr::InSubquery {
+ expr: Box::new(expr),
+ subquery,
+ negated,
+ });
+ }
+ self.failed_in_subquery_positions.insert(start);
+ }
+ 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)?
};
self.expect_token(&Token::RParen)?;
- Ok(in_op)
+ Ok(Expr::InList {
+ expr: Box::new(expr),
+ list,
+ negated,
+ })
}
/// 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 354ccc8b7..9c63c2101 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -20263,3 +20263,104 @@ fn parse_placeholder_disallows_quoted_ident() {
err
);
}
+
+#[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()
+ );
+}
+
+/// 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");
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org