Fix parsing EXECUTE (...) with a more general string expression, rather than just a variable.

Statements like "EXEC (@SQL)" as well as "EXEC ('SELECT * FROM ' + @tableName)" should both parse
successfully and should both parse equivalently to e.g. EXECUTE
IMMEDIATE '<sql>' on BigQuery and Snowflake, meaning the sql expression
is parsed as the first (and only) "parameter".

Author: Roman Borschel

src/ast/mod.rs

@@ -4456,7 +4456,7 @@ pub enum Statement {
         name: Option<ObjectName>,
         /// Parameter expressions passed to execute.
         parameters: Vec<Expr>,
-        /// Whether parentheses were present.
+        /// Whether parentheses were present around `parameters`.
         has_parentheses: bool,
         /// Is this an `EXECUTE IMMEDIATE`.
         immediate: bool,
@@ -5911,7 +5911,8 @@ impl fmt::Display for Statement {
                 default,
             } => {
                 let (open, close) = if *has_parentheses {
-                    ("(", ")")
+                    // Space before `(` only when there is no name directly preceding it.
+                    (if name.is_some() { "(" } else { " (" }, ")")
                 } else {
                     (if parameters.is_empty() { "" } else { " " }, "")
                 };

src/parser/mod.rs

@@ -18881,31 +18881,21 @@ impl<'a> Parser<'a> {
 
     /// Parse a SQL `EXECUTE` statement
     pub fn parse_execute(&mut self) -> Result<Statement, ParserError> {
-        // Track whether the procedure/expression name itself was wrapped in parens,
-        // i.e. `EXEC (@sql)` (dynamic string execution) vs `EXEC sp_name`.
-        // When the name has parens there are no additional parameters.
-        let name = if self.dialect.supports_execute_immediate()
-            && self.parse_keyword(Keyword::IMMEDIATE)
-        {
+        let immediate =
+            self.dialect.supports_execute_immediate() && self.parse_keyword(Keyword::IMMEDIATE);
+
+        // When `EXEC` is immediately followed by `(`, the content is a dynamic-SQL
+        // expression — e.g. `EXEC (@sql)`, `EXEC ('SELECT ...')`, or
+        // `EXEC ('SELECT ... FROM ' + @tbl + ' WHERE ...')`.
+        // Skip name parsing; the expression ends up in `parameters` via the
+        // `has_parentheses` path below, consistent with `EXECUTE IMMEDIATE <expr>`.
+        let name = if immediate || matches!(self.peek_token_ref().token, Token::LParen) {
             None
         } else {
-            let has_parentheses = self.consume_token(&Token::LParen);
-            let name = self.parse_object_name(false)?;
-            if has_parentheses {
-                self.expect_token(&Token::RParen)?;
-            }
-            Some((name, has_parentheses))
+            Some(self.parse_object_name(false)?)
         };
 
-        let name_had_parentheses = name.as_ref().map(|(_, p)| *p).unwrap_or(false);
-
-        // Only look for a parameter list when the name was NOT wrapped in parens.
-        // `EXEC (@sql)` is dynamic SQL execution and takes no parameters here.
-        let has_parentheses = if name_had_parentheses {
-            false
-        } else {
-            self.consume_token(&Token::LParen)
-        };
+        let has_parentheses = self.consume_token(&Token::LParen);
 
         let end_kws = &[Keyword::USING, Keyword::OUTPUT, Keyword::DEFAULT];
         let end_token = match (has_parentheses, self.peek_token().token) {
@@ -18915,18 +18905,12 @@ impl<'a> Parser<'a> {
             (false, _) => Token::SemiColon,
         };
 
-        let parameters = if name_had_parentheses {
-            vec![]
-        } else {
-            self.parse_comma_separated0(Parser::parse_expr, end_token)?
-        };
+        let parameters = self.parse_comma_separated0(Parser::parse_expr, end_token)?;
 
         if has_parentheses {
             self.expect_token(&Token::RParen)?;
         }
 
-        let name = name.map(|(n, _)| n);
-
         let into = if self.parse_keyword(Keyword::INTO) {
             self.parse_comma_separated(Self::parse_identifier)?
         } else {
@@ -18944,7 +18928,7 @@ impl<'a> Parser<'a> {
         let default = self.parse_keyword(Keyword::DEFAULT);
 
         Ok(Statement::Execute {
-            immediate: name.is_none(),
+            immediate,
             name,
             parameters,
             has_parentheses,

tests/sqlparser_common.rs

@@ -12294,8 +12294,8 @@ fn parse_execute_stored_procedure() {
         }
         _ => unreachable!(),
     }
-    // Test optional parentheses around procedure name
-    ms_and_generic().one_statement_parses_to("EXEC ('name')", "EXECUTE 'name'");
+    // Parenthesised form is dynamic SQL; the expression ends up in parameters.
+    ms_and_generic().one_statement_parses_to("EXEC ('name')", "EXECUTE ('name')");
 }
 
 #[test]

tests/sqlparser_mssql.rs

@@ -2819,6 +2819,20 @@ fn test_exec_dynamic_sql() {
     assert_eq!(stmts.len(), 2);
 }
 
+#[test]
+fn test_exec_dynamic_sql_string_concat() {
+    // EXEC with string concatenation: EXEC ('...' + @var + '...')
+    let stmts = tsql()
+        .parse_sql_statements("EXEC ('SELECT * FROM ' + @TableName + ' WHERE 1=1')")
+        .expect("EXEC with string concatenation should parse");
+    assert_eq!(stmts.len(), 1);
+    assert!(
+        matches!(&stmts[0], Statement::Execute { .. }),
+        "expected Execute, got: {:?}",
+        stmts[0]
+    );
+}
+
 // MSSQL OUTPUT clause on INSERT/UPDATE/DELETE
 // https://learn.microsoft.com/en-us/sql/t-sql/queries/output-clause-transact-sql
 #[test]