From 1cdb7483ec4b6a9d2cb0a37f386a05be887065ce Mon Sep 17 00:00:00 2001 From: Jaden-Varkey Date: Sun, 15 Nov 2026 01:52:23 -0500 Subject: [PATCH 1/3] Fix parsing of reserved keyword select items after a comma With projection trailing commas enabled (e.g. GenericDialect), a reserved keyword after a comma was always treated as the start of a clause, so `SELECT a, offset FROM t` failed to parse. Fixes #2049 --- .../generic_2049_keyword_after_comma.sql | 1 + src/parser/mod.rs | 15 ++++++++++++++- tests/sqlparser_common.rs | 19 +++++++++++++++++++ 3 files changed, 34 insertions(+), 1 deletion(-) create mode 100644 fuzz/fuzz_seeds/generic_2049_keyword_after_comma.sql diff --git a/fuzz/fuzz_seeds/generic_2049_keyword_after_comma.sql b/fuzz/fuzz_seeds/generic_2049_keyword_after_comma.sql new file mode 100644 index 0000000000..a9f7f2675e --- /dev/null +++ b/fuzz/fuzz_seeds/generic_2049_keyword_after_comma.sql @@ -0,0 +1 @@ +SELECT a, offset FROM t; diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 76bd114071..057b96cb47 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -5188,10 +5188,23 @@ impl<'a> Parser<'a> { self.parse_comma_separated_with_trailing_commas( |p| p.parse_select_item(), trailing_commas, - Self::is_reserved_for_column_alias, + |kw, parser| { + Self::is_reserved_for_column_alias(kw, parser) + && !Self::is_keyword_projection_item(parser) + }, ) } + /// Called after a reserved keyword that follows a comma in a projection, e.g. + /// `SELECT a, offset FROM t`. Returns true if the next token means the keyword + /// is a select item rather than a clause after a trailing comma. + fn is_keyword_projection_item(parser: &mut Parser) -> bool { + parser.peek_token_ref().token == Token::Comma + || parser + .peek_one_of_keywords(&[Keyword::FROM, Keyword::AS]) + .is_some() + } + /// Parse a list of actions for `GRANT` statements. pub fn parse_actions_list(&mut self) -> Result, ParserError> { let mut values = vec![]; diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs index f2f7849154..82b0bf85c5 100644 --- a/tests/sqlparser_common.rs +++ b/tests/sqlparser_common.rs @@ -23516,3 +23516,22 @@ fn parse_national_character_string_types() { ParserError::ParserError("Expected: ), found: EOF".to_string()) ); } + +#[test] +fn parse_projection_trailing_comma_keyword_column() { + let dialects = all_dialects_where(|d| d.supports_projection_trailing_commas()); + + for sql in [ + "SELECT 'a' AS a, offset FROM t", + "SELECT a, offset FROM t", + "SELECT a, limit FROM t", + "SELECT a, offset, b FROM t", + "SELECT a, offset AS o FROM t", + "SELECT * FROM (SELECT a, offset FROM t)", + ] { + dialects.verified_stmt(sql); + } + + dialects.one_statement_parses_to("SELECT a, FROM t", "SELECT a FROM t"); + dialects.one_statement_parses_to("SELECT a, LIMIT 1", "SELECT a LIMIT 1"); +} From 61d34f87b65fb676790be063bdd6c6bface80d6e Mon Sep 17 00:00:00 2001 From: Jaden-Varkey Date: Sun, 15 Nov 2026 13:08:03 -0500 Subject: [PATCH 2/3] Limit keyword select items to LIMIT and OFFSET Also parse a leading LIMIT/OFFSET column in dialects with empty projections. --- src/parser/mod.rs | 22 +++++++++++++--------- tests/sqlparser_common.rs | 21 +++++++++++++++++++++ 2 files changed, 34 insertions(+), 9 deletions(-) diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 057b96cb47..1e21b6514e 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -5190,19 +5190,20 @@ impl<'a> Parser<'a> { trailing_commas, |kw, parser| { Self::is_reserved_for_column_alias(kw, parser) - && !Self::is_keyword_projection_item(parser) + && !(matches!(kw, Keyword::LIMIT | Keyword::OFFSET) + && parser.peek_select_item_end(0)) }, ) } - /// Called after a reserved keyword that follows a comma in a projection, e.g. - /// `SELECT a, offset FROM t`. Returns true if the next token means the keyword - /// is a select item rather than a clause after a trailing comma. - fn is_keyword_projection_item(parser: &mut Parser) -> bool { - parser.peek_token_ref().token == Token::Comma - || parser - .peek_one_of_keywords(&[Keyword::FROM, Keyword::AS]) - .is_some() + /// Returns true if the `n`th next token ends a select item, so that a `LIMIT` + /// or `OFFSET` before it names a column, as in `SELECT offset, limit FROM t`. + fn peek_select_item_end(&self, n: usize) -> bool { + match &self.peek_nth_token_ref(n).token { + Token::Comma => true, + Token::Word(w) => matches!(w.keyword, Keyword::FROM | Keyword::AS), + _ => false, + } } /// Parse a list of actions for `GRANT` statements. @@ -16499,6 +16500,9 @@ impl<'a> Parser<'a> { fn peek_empty_projection(&self) -> bool { match &self.peek_token_ref().token { Token::EOF | Token::SemiColon | Token::RParen => true, + Token::Word(w) if matches!(w.keyword, Keyword::LIMIT | Keyword::OFFSET) => { + !self.peek_select_item_end(1) + } Token::Word(w) => matches!( w.keyword, Keyword::INTO diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs index 82b0bf85c5..5267c49cab 100644 --- a/tests/sqlparser_common.rs +++ b/tests/sqlparser_common.rs @@ -23522,6 +23522,8 @@ fn parse_projection_trailing_comma_keyword_column() { let dialects = all_dialects_where(|d| d.supports_projection_trailing_commas()); for sql in [ + "SELECT offset FROM t", + "SELECT offset, 'a' AS a FROM t", "SELECT 'a' AS a, offset FROM t", "SELECT a, offset FROM t", "SELECT a, limit FROM t", @@ -23534,4 +23536,23 @@ fn parse_projection_trailing_comma_keyword_column() { dialects.one_statement_parses_to("SELECT a, FROM t", "SELECT a FROM t"); dialects.one_statement_parses_to("SELECT a, LIMIT 1", "SELECT a LIMIT 1"); + assert_eq!( + dialects + .parse_sql_statements("SELECT a, union, b FROM t") + .unwrap_err(), + ParserError::ParserError( + "Expected: SELECT, VALUES, or a subquery in the query body, found: ,".to_string() + ) + ); + + let dialects = all_dialects_where(|d| d.supports_empty_projections()); + for sql in [ + "SELECT offset FROM t", + "SELECT limit, offset FROM t", + "SELECT offset AS o FROM t", + ] { + dialects.verified_stmt(sql); + } + dialects.verified_stmt("SELECT LIMIT 1"); + dialects.verified_stmt("SELECT OFFSET 1"); } From 72996fe0cb557d80ff5ab99391ebe23e60e3bf0b Mon Sep 17 00:00:00 2001 From: Jaden-Varkey Date: Sun, 15 Nov 2026 15:22:14 -0500 Subject: [PATCH 3/3] Treat every select item terminator as ending a LIMIT/OFFSET column --- src/parser/mod.rs | 17 +++++++++++++++-- tests/sqlparser_common.rs | 7 +++++++ 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 1e21b6514e..8726ed8d16 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -5200,8 +5200,21 @@ impl<'a> Parser<'a> { /// or `OFFSET` before it names a column, as in `SELECT offset, limit FROM t`. fn peek_select_item_end(&self, n: usize) -> bool { match &self.peek_nth_token_ref(n).token { - Token::Comma => true, - Token::Word(w) => matches!(w.keyword, Keyword::FROM | Keyword::AS), + Token::Comma | Token::EOF | Token::SemiColon | Token::RParen => true, + Token::Word(w) => matches!( + w.keyword, + Keyword::AS + | Keyword::INTO + | Keyword::FROM + | Keyword::WHERE + | Keyword::GROUP + | Keyword::HAVING + | Keyword::WINDOW + | Keyword::ORDER + | Keyword::UNION + | Keyword::INTERSECT + | Keyword::EXCEPT + ), _ => false, } } diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs index 5267c49cab..63526d6cd2 100644 --- a/tests/sqlparser_common.rs +++ b/tests/sqlparser_common.rs @@ -23530,6 +23530,11 @@ fn parse_projection_trailing_comma_keyword_column() { "SELECT a, offset, b FROM t", "SELECT a, offset AS o FROM t", "SELECT * FROM (SELECT a, offset FROM t)", + "SELECT a, offset", + "SELECT * FROM (SELECT a, offset) AS s", + "SELECT a, offset WHERE b", + "SELECT a, offset INTO u FROM t", + "SELECT a, offset UNION SELECT 1, 2", ] { dialects.verified_stmt(sql); } @@ -23550,6 +23555,8 @@ fn parse_projection_trailing_comma_keyword_column() { "SELECT offset FROM t", "SELECT limit, offset FROM t", "SELECT offset AS o FROM t", + "SELECT offset", + "SELECT offset WHERE b", ] { dialects.verified_stmt(sql); }