Task LAV-2255: accept parenthesized (CALL …) as a RESULTSET payload (#2663)

Add a SetExpr::Call variant and a supports_call_in_resultset dialect flag to
the vendored parser so `(CALL p(args))` is accepted in the RESULTSET
initializer (DEFAULT / :=, DECLARE and LET) and bare-assignment positions, and
rejected — at the CALL keyword, matching Snowflake's `unexpected 'CALL'` — for
the unparenthesized and CURSOR FOR forms.

Lowering unwraps the CALL payload through call_to_select in query_to_statement,
so every static-inline consumer (RETURN TABLE, FOR loop, cursor) streams the
callee's rows under the callee's own columns; the bare-assignment runtime path
re-parses the stored `CALL …` text through __snowflake$prepare_query.

Also resolve `:param`/`:local` refs in a declared-column RETURN TABLE(rs) query
(the untyped RETURNS TABLE() path already did), so a table callee whose
resultset references its parameters works.

Co-authored-by: Wojciech Padło <wojciech.padlo@localstack.cloud>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: 3 people

src/ast/query.rs

@@ -185,6 +185,11 @@ pub enum SetExpr {
     /// payload SQL is only known at runtime, so the contained statement carries
     /// the dynamic-SQL expression rather than a static query body.
     Execute(Statement),
+    /// `CALL` statement used as the query payload of a Snowflake `RESULTSET`
+    /// declaration or bare assignment (`RESULTSET DEFAULT (CALL p(...))`,
+    /// `r := (CALL p(...))`). The callee's result set becomes the resultset's
+    /// rows.
+    Call(Statement),
 }
 
 impl SetExpr {
@@ -215,6 +220,7 @@ impl fmt::Display for SetExpr {
             SetExpr::Table(t) => t.fmt(f),
             SetExpr::Show(v) => v.fmt(f),
             SetExpr::Execute(v) => v.fmt(f),
+            SetExpr::Call(v) => v.fmt(f),
             SetExpr::SetOperation {
                 left,
                 right,

src/ast/spans.rs

@@ -238,6 +238,7 @@ impl Spanned for SetExpr {
             SetExpr::Merge(statement) => statement.span(),
             SetExpr::Show(statement) => statement.span(),
             SetExpr::Execute(statement) => statement.span(),
+            SetExpr::Call(statement) => statement.span(),
         }
     }
 }

src/dialect/mod.rs

@@ -451,6 +451,14 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect accepts a parenthesized `CALL` statement as
+    /// the query payload of a `RESULTSET` declaration or bare assignment
+    /// (`res RESULTSET DEFAULT (CALL p(...))`, `res := (CALL p(...))`). Unlike
+    /// `SHOW`, this is not accepted in a `CURSOR FOR` payload.
+    fn supports_call_in_resultset(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports the MATCH_RECOGNIZE operation.
     fn supports_match_recognize(&self) -> bool {
         false

src/dialect/snowflake.rs

@@ -230,6 +230,11 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
+    /// See <https://docs.snowflake.com/en/developer-guide/snowflake-scripting/resultsets>
+    fn supports_call_in_resultset(&self) -> bool {
+        true
+    }
+
     fn supports_match_recognize(&self) -> bool {
         true
     }

src/parser/mod.rs

@@ -1104,12 +1104,13 @@ impl<'a> Parser<'a> {
                 && self.peek_nth_token_ref(1).token == Token::Assignment
             {
                 // bare assignment: var := expr
-                // Accepts `(EXECUTE IMMEDIATE …)` / `(SHOW …)` payloads the same
-                // way a RESULTSET declaration initializer does, so a dynamic
-                // query can be assigned to an existing RESULTSET variable.
+                // Accepts `(EXECUTE IMMEDIATE …)` / `(SHOW …)` / `(CALL …)`
+                // payloads the same way a RESULTSET declaration initializer
+                // does, so a dynamic query or procedure call can be assigned to
+                // an existing RESULTSET variable.
                 let target = self.parse_identifier()?;
                 self.expect_token(&Token::Assignment)?;
-                let value = self.parse_snowflake_declaration_payload_expr()?;
+                let value = self.parse_snowflake_declaration_payload_expr(true)?;
                 Statement::Assignment { target, value }
             } else if let Some(kind) = loop_control_keyword(&self.peek_nth_token_ref(0).token) {
                 // Loop-control statements only make sense inside a scripting
@@ -8717,14 +8718,14 @@ impl<'a> Parser<'a> {
                         Some(DeclareType::Cursor),
                         None,
                         Some(DeclareAssignment::For(Box::new(
-                            self.parse_snowflake_declaration_payload_expr()?,
+                            self.parse_snowflake_declaration_payload_expr(false)?,
                         ))),
                         None,
                     ),
                 }
             } else if self.parse_keyword(Keyword::RESULTSET) {
                 let assigned_expr = if self.peek_token_ref().token != Token::SemiColon {
-                    self.parse_snowflake_variable_declaration_expression()?
+                    self.parse_snowflake_variable_declaration_expression(true)?
                 } else {
                     // Nothing more to do. The statement has no further parameters.
                     None
@@ -8743,13 +8744,13 @@ impl<'a> Parser<'a> {
             } else {
                 // Without an explicit keyword, the only valid option is variable declaration.
                 let (assigned_expr, data_type) = if let Some(assigned_expr) =
-                    self.parse_snowflake_variable_declaration_expression()?
+                    self.parse_snowflake_variable_declaration_expression(false)?
                 {
                     (Some(assigned_expr), None)
                 } else if let Token::Word(_) = &self.peek_token_ref().token {
                     let data_type = self.parse_data_type()?;
                     (
-                        self.parse_snowflake_variable_declaration_expression()?,
+                        self.parse_snowflake_variable_declaration_expression(false)?,
                         Some(data_type),
                     )
                 } else {
@@ -8860,18 +8861,19 @@ impl<'a> Parser<'a> {
     /// <https://docs.snowflake.com/en/sql-reference/snowflake-scripting/declare#variable-declaration-syntax>
     pub fn parse_snowflake_variable_declaration_expression(
         &mut self,
+        allow_call: bool,
     ) -> Result<Option<DeclareAssignment>, ParserError> {
         Ok(match &self.peek_token_ref().token {
             Token::Word(w) if w.keyword == Keyword::DEFAULT => {
                 self.next_token(); // Skip `DEFAULT`
                 Some(DeclareAssignment::Default(Box::new(
-                    self.parse_snowflake_declaration_payload_expr()?,
+                    self.parse_snowflake_declaration_payload_expr(allow_call)?,
                 )))
             }
             Token::Assignment => {
                 self.next_token(); // Skip `:=`
                 Some(DeclareAssignment::DuckAssignment(Box::new(
-                    self.parse_snowflake_declaration_payload_expr()?,
+                    self.parse_snowflake_declaration_payload_expr(allow_call)?,
                 )))
             }
             _ => None,
@@ -8880,11 +8882,64 @@ impl<'a> Parser<'a> {
 
     /// Parses the expression payload of a Snowflake `RESULTSET` / `CURSOR`
     /// declaration. Identical to [`Parser::parse_expr`] except that, under a
-    /// dialect that allows it, a parenthesized `SHOW` statement is accepted as
-    /// the query payload and wrapped as an [`Expr::Subquery`] whose body is a
-    /// [`SetExpr::Show`]. The pre-existing `(SELECT ...)` subquery path is left
-    /// untouched.
-    fn parse_snowflake_declaration_payload_expr(&mut self) -> Result<Expr, ParserError> {
+    /// dialect that allows it, a parenthesized `SHOW` / `EXECUTE IMMEDIATE`
+    /// statement is accepted as the query payload and wrapped as an
+    /// [`Expr::Subquery`] whose body is a [`SetExpr::Show`] / [`SetExpr::Execute`].
+    /// When `allow_call` is set, a parenthesized `CALL` is likewise accepted and
+    /// wrapped as a [`SetExpr::Call`] — the `RESULTSET` initializer and
+    /// bare-assignment positions pass `true`, the `CURSOR FOR` position passes
+    /// `false` (Snowflake rejects `CURSOR FOR (CALL ...)`). The pre-existing
+    /// `(SELECT ...)` subquery path is left untouched.
+    fn parse_snowflake_declaration_payload_expr(
+        &mut self,
+        allow_call: bool,
+    ) -> Result<Expr, ParserError> {
+        let is_paren_call = allow_call
+            && self.dialect.supports_call_in_resultset()
+            && self.peek_nth_token_ref(0).token == Token::LParen
+            && matches!(
+                &self.peek_nth_token_ref(1).token,
+                Token::Word(w) if w.keyword == Keyword::CALL
+            );
+        if is_paren_call {
+            self.expect_token(&Token::LParen)?;
+            self.expect_keyword_is(Keyword::CALL)?;
+            let call = self.parse_call()?;
+            self.expect_token(&Token::RParen)?;
+            return Ok(Expr::Subquery(Box::new(Query {
+                with: None,
+                body: Box::new(SetExpr::Call(call)),
+                order_by: None,
+                limit_clause: None,
+                fetch: None,
+                locks: vec![],
+                for_clause: None,
+                settings: None,
+                format_clause: None,
+                pipe_operators: vec![],
+            })));
+        }
+        // Reject a `CALL` payload the accepted arm above did not consume. A bare
+        // (unparenthesized) `CALL` is never a valid payload expression, and a
+        // `(CALL ...)` in a position that forbids the procedure-call payload
+        // (`CURSOR FOR`, or any dialect without `supports_call_in_resultset`) is
+        // likewise invalid. Snowflake rejects both at the `CALL` keyword itself;
+        // the fork would otherwise parse `CALL` as a bare identifier and
+        // misreport the following token. Point the error at the `CALL` keyword.
+        let bare_call =
+            matches!(&self.peek_nth_token_ref(0).token, Token::Word(w) if w.keyword == Keyword::CALL);
+        let paren_call = self.peek_nth_token_ref(0).token == Token::LParen
+            && matches!(
+                &self.peek_nth_token_ref(1).token,
+                Token::Word(w) if w.keyword == Keyword::CALL
+            );
+        if bare_call {
+            return self.expected_ref("an expression", self.peek_nth_token_ref(0));
+        }
+        if paren_call {
+            self.expect_token(&Token::LParen)?;
+            return self.expected_ref("an expression", self.peek_nth_token_ref(0));
+        }
         let is_paren_execute = self.dialect.supports_execute_immediate()
             && self.peek_nth_token_ref(0).token == Token::LParen
             && matches!(

tests/sqlparser_snowflake.rs

@@ -2589,6 +2589,133 @@ fn parse_snowflake_declare_show_payload() {
     }
 }
 
+#[test]
+fn parse_snowflake_declare_call_payload() {
+    // The `CALL` payload embedded in a declaration's parenthesized subquery.
+    fn payload_call(stmt: Statement) -> Statement {
+        match stmt {
+            Statement::Declare { mut stmts } => {
+                assert_eq!(1, stmts.len());
+                let Declare { assignment, .. } = stmts.swap_remove(0);
+                let query = match assignment {
+                    Some(DeclareAssignment::Default(expr))
+                    | Some(DeclareAssignment::DuckAssignment(expr)) => match *expr {
+                        Expr::Subquery(query) => query,
+                        other => panic!("expected subquery payload, got {other:?}"),
+                    },
+                    other => panic!("unexpected declaration payload: {other:?}"),
+                };
+                match *query.body {
+                    SetExpr::Call(call) => call,
+                    other => panic!("expected CALL body, got {other:?}"),
+                }
+            }
+            other => panic!("expected DECLARE, got {other:?}"),
+        }
+    }
+
+    for sql in [
+        "DECLARE res RESULTSET DEFAULT (CALL p())",
+        "DECLARE res RESULTSET := (CALL p(1, 2))",
+    ] {
+        // Round-trips through Display, and the embedded statement is a CALL.
+        let stmt = snowflake().verified_stmt(sql);
+        assert!(matches!(payload_call(stmt), Statement::Call(_)));
+    }
+
+    // Mid-body `LET res RESULTSET := (CALL p())` routes through the same
+    // declaration shape.
+    let sql = r#"CREATE PROCEDURE p() RETURNS VARCHAR LANGUAGE SQL AS $$
+BEGIN
+  LET res RESULTSET := (CALL q(1));
+  RETURN 'OK';
+END $$"#;
+    let stmts = snowflake()
+        .parse_sql_statements(sql)
+        .expect("LET RESULTSET := (CALL ...) should parse");
+    let body = match &stmts[0] {
+        Statement::CreateProcedure { body, .. } => body,
+        other => panic!("expected CreateProcedure, got {other:?}"),
+    };
+    let begin_stmts = match body {
+        ConditionalStatements::BeginEnd(bes) => &bes.statements,
+        other => panic!("expected BeginEnd body, got {other:?}"),
+    };
+    let decl = match &begin_stmts[0] {
+        Statement::Declare { stmts } => &stmts[0],
+        other => panic!("expected Declare, got {other:?}"),
+    };
+    assert_eq!(decl.declare_type, Some(DeclareType::ResultSet));
+    match &decl.assignment {
+        Some(DeclareAssignment::DuckAssignment(expr)) => match expr.as_ref() {
+            Expr::Subquery(query) => assert!(matches!(*query.body, SetExpr::Call(_))),
+            other => panic!("expected subquery payload, got {other:?}"),
+        },
+        other => panic!("expected RESULTSET := assignment, got {other:?}"),
+    }
+
+    // Bare assignment `res := (CALL p())` to an already-declared RESULTSET.
+    let sql = r#"CREATE PROCEDURE p() RETURNS VARCHAR LANGUAGE SQL AS $$
+BEGIN
+  res := (CALL q(3));
+  RETURN 'OK';
+END $$"#;
+    let stmts = snowflake()
+        .parse_sql_statements(sql)
+        .expect("bare res := (CALL ...) should parse");
+    let body = match &stmts[0] {
+        Statement::CreateProcedure { body, .. } => body,
+        other => panic!("expected CreateProcedure, got {other:?}"),
+    };
+    let begin_stmts = match body {
+        ConditionalStatements::BeginEnd(bes) => &bes.statements,
+        other => panic!("expected BeginEnd body, got {other:?}"),
+    };
+    match &begin_stmts[0] {
+        Statement::Assignment { target, value } => {
+            assert_eq!(target.value, "res");
+            match value {
+                Expr::Subquery(query) => assert!(matches!(*query.body, SetExpr::Call(_))),
+                other => panic!("expected subquery payload, got {other:?}"),
+            }
+        }
+        other => panic!("expected Assignment, got {other:?}"),
+    }
+
+    // The pre-existing SELECT / SHOW / EXECUTE payloads are unaffected.
+    snowflake().verified_stmt("DECLARE res RESULTSET DEFAULT (SELECT price FROM invoices)");
+
+    // Parentheses are required: a bare `CALL` payload is rejected at the `CALL`
+    // keyword (Snowflake's `unexpected 'CALL'`), never parsed as an identifier.
+    assert_eq!(
+        ParserError::ParserError("Expected: an expression, found: CALL".to_owned()),
+        snowflake()
+            .parse_sql_statements("DECLARE res RESULTSET DEFAULT CALL p()")
+            .unwrap_err()
+    );
+    assert_eq!(
+        ParserError::ParserError("Expected: an expression, found: CALL".to_owned()),
+        snowflake()
+            .parse_sql_statements("DECLARE res RESULTSET := CALL p()")
+            .unwrap_err()
+    );
+
+    // `CURSOR FOR (CALL ...)` is rejected at the `CALL` keyword; the CALL
+    // payload is only accepted in the RESULTSET / bare-assignment positions.
+    assert_eq!(
+        ParserError::ParserError("Expected: an expression, found: CALL".to_owned()),
+        snowflake()
+            .parse_sql_statements("DECLARE cur CURSOR FOR (CALL p())")
+            .unwrap_err()
+    );
+
+    // Under a non-Snowflake dialect the parenthesized CALL payload still errors.
+    let generic = TestedDialects::new(vec![Box::new(GenericDialect {})]);
+    assert!(generic
+        .parse_sql_statements("DECLARE res RESULTSET DEFAULT (CALL p())")
+        .is_err());
+}
+
 #[test]
 fn parse_snowflake_declare_exception() {
     for (sql, expected_name, expected_assigned_expr) in [