Parser: add regression test and bench for named-arg chain blowup

Author: LucaCappelletti94

sqlparser_bench/benches/sqlparser_bench.rs

@@ -16,7 +16,7 @@
 // under the License.
 
 use criterion::{criterion_group, criterion_main, Criterion};
-use sqlparser::dialect::GenericDialect;
+use sqlparser::dialect::{GenericDialect, PostgreSqlDialect};
 use sqlparser::keywords::Keyword;
 use sqlparser::parser::Parser;
 use sqlparser::tokenizer::{Span, Word};
@@ -177,11 +177,38 @@ fn parse_compound_chain(c: &mut Criterion) {
     group.finish();
 }
 
+/// Benchmark parsing pathological named-arg chains that previously caused
+/// 2^N work in `parse_function_args` on dialects with expression-named
+/// function arguments (PostgreSQL, MSSQL). Each `--<newline>` swallows the
+/// trailing `,i)`, leaving a chain of unterminated function calls that the
+/// previous `maybe_parse(parse_expr)` re-walked on rollback.
+fn parse_named_arg_chain(c: &mut Criterion) {
+    let mut group = c.benchmark_group("parse_named_arg_chain");
+    let dialect = PostgreSqlDialect {};
+
+    for &n in &[5usize, 10, 15] {
+        let body = std::iter::repeat(".foo(t--,i)")
+            .take(n)
+            .collect::<Vec<_>>()
+            .join("\n");
+        let sql = format!("SELECT Y\n{body}");
+
+        group.bench_function(format!("chain_{n}"), |b| {
+            b.iter(|| {
+                let _ = Parser::parse_sql(&dialect, std::hint::black_box(&sql));
+            });
+        });
+    }
+
+    group.finish();
+}
+
 criterion_group!(
     benches,
     basic_queries,
     word_to_ident,
     parse_many_identifiers,
-    parse_compound_chain
+    parse_compound_chain,
+    parse_named_arg_chain
 );
 criterion_main!(benches);

tests/sqlparser_common.rs

@@ -19004,3 +19004,30 @@ fn parse_compound_chain_no_exponential_blowup() {
     rx.recv_timeout(Duration::from_secs(5))
         .expect("parser should reject this quickly, not loop exponentially");
 }
+
+/// Regression test for the 2^N parse-time blowup in `parse_function_args` on
+/// dialects that allow `<expr> <op> <expr>` named args (PostgreSQL, MSSQL).
+/// Each `--<newline>` swallows the trailing `,i)`, leaving a chain of
+/// unterminated function calls that the previous `maybe_parse(parse_expr)`
+/// re-walked on rollback. Post-fix the parser returns `Err` in well under
+/// a millisecond.
+#[test]
+fn parse_named_arg_chain_no_exponential_blowup() {
+    use std::sync::mpsc;
+    use std::thread;
+    use std::time::Duration;
+
+    let body: String = std::iter::repeat_n(".foo(t--,i)", 25)
+        .collect::<Vec<_>>()
+        .join("\n");
+    let sql = format!("SELECT Y\n{body}");
+
+    let (tx, rx) = mpsc::channel();
+    thread::spawn(move || {
+        let _ = Parser::parse_sql(&PostgreSqlDialect {}, &sql);
+        let _ = tx.send(());
+    });
+
+    rx.recv_timeout(Duration::from_secs(5))
+        .expect("PostgreSQL parser should reject this quickly, not loop exponentially");
+}