Snowflake: parse parenthesized SHOW as RESULTSET/CURSOR declaration payload

Author: sabir-akhadov-localstack

src/ast/query.rs

@@ -177,6 +177,9 @@ pub enum SetExpr {
     Merge(Statement),
     /// `TABLE` command
     Table(Box<Table>),
+    /// `SHOW` statement used as the query payload of a Snowflake `RESULTSET` or
+    /// `CURSOR` declaration (`RESULTSET DEFAULT (SHOW ...)`, `CURSOR FOR (SHOW ...)`).
+    Show(Statement),
 }
 
 impl SetExpr {
@@ -205,6 +208,7 @@ impl fmt::Display for SetExpr {
             SetExpr::Delete(v) => v.fmt(f),
             SetExpr::Merge(v) => v.fmt(f),
             SetExpr::Table(t) => t.fmt(f),
+            SetExpr::Show(v) => v.fmt(f),
             SetExpr::SetOperation {
                 left,
                 right,

src/ast/spans.rs

@@ -235,6 +235,7 @@ impl Spanned for SetExpr {
             SetExpr::Update(statement) => statement.span(),
             SetExpr::Delete(statement) => statement.span(),
             SetExpr::Merge(statement) => statement.span(),
+            SetExpr::Show(statement) => statement.span(),
         }
     }
 }

src/dialect/mod.rs

@@ -432,6 +432,13 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect accepts a parenthesized `SHOW` statement as
+    /// the query payload of a `RESULTSET` or `CURSOR` declaration
+    /// (`res RESULTSET DEFAULT (SHOW ...)`, `cur CURSOR FOR (SHOW ...)`).
+    fn supports_show_in_resultset_cursor(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports the MATCH_RECOGNIZE operation.
     fn supports_match_recognize(&self) -> bool {
         false

src/dialect/snowflake.rs

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

src/parser/mod.rs

@@ -8094,7 +8094,9 @@ impl<'a> Parser<'a> {
                         _ => (
                             Some(DeclareType::Cursor),
                             None,
-                            Some(DeclareAssignment::For(Box::new(self.parse_expr()?))),
+                            Some(DeclareAssignment::For(Box::new(
+                                self.parse_snowflake_declaration_payload_expr()?,
+                            ))),
                             None,
                         ),
                     }
@@ -8275,18 +8277,54 @@ impl<'a> Parser<'a> {
         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_expr()?)))
+                Some(DeclareAssignment::Default(Box::new(
+                    self.parse_snowflake_declaration_payload_expr()?,
+                )))
             }
             Token::Assignment => {
                 self.next_token(); // Skip `:=`
                 Some(DeclareAssignment::DuckAssignment(Box::new(
-                    self.parse_expr()?,
+                    self.parse_snowflake_declaration_payload_expr()?,
                 )))
             }
             _ => None,
         })
     }
 
+    /// 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> {
+        let is_paren_show = self.dialect.supports_show_in_resultset_cursor()
+            && self.peek_nth_token_ref(0).token == Token::LParen
+            && matches!(
+                &self.peek_nth_token_ref(1).token,
+                Token::Word(w) if w.keyword == Keyword::SHOW
+            );
+        if !is_paren_show {
+            return self.parse_expr();
+        }
+        self.expect_token(&Token::LParen)?;
+        self.expect_keyword_is(Keyword::SHOW)?;
+        let show = self.parse_show()?;
+        self.expect_token(&Token::RParen)?;
+        Ok(Expr::Subquery(Box::new(Query {
+            with: None,
+            body: Box::new(SetExpr::Show(show)),
+            order_by: None,
+            limit_clause: None,
+            fetch: None,
+            locks: vec![],
+            for_clause: None,
+            settings: None,
+            format_clause: None,
+            pipe_operators: vec![],
+        })))
+    }
+
     /// Parses the assigned expression in a variable declaration.
     ///
     /// Syntax:

tests/sqlparser_snowflake.rs

@@ -1915,6 +1915,59 @@ fn parse_snowflake_declare_result_set() {
     );
 }
 
+#[test]
+fn parse_snowflake_declare_show_payload() {
+    fn payload_show(stmt: Statement) -> Statement {
+        match stmt {
+            Statement::Declare { mut stmts } => {
+                assert_eq!(1, stmts.len());
+                let Declare {
+                    assignment,
+                    for_query,
+                    ..
+                } = stmts.swap_remove(0);
+                let query = match (assignment, for_query) {
+                    (Some(DeclareAssignment::Default(expr)), None)
+                    | (Some(DeclareAssignment::DuckAssignment(expr)), None)
+                    | (Some(DeclareAssignment::For(expr)), None) => match *expr {
+                        Expr::Subquery(query) => query,
+                        other => panic!("expected subquery payload, got {other:?}"),
+                    },
+                    other => panic!("unexpected declaration payload: {other:?}"),
+                };
+                match *query.body {
+                    SetExpr::Show(show) => show,
+                    other => panic!("expected SHOW body, got {other:?}"),
+                }
+            }
+            other => panic!("expected DECLARE, got {other:?}"),
+        }
+    }
+
+    for sql in [
+        "DECLARE res RESULTSET DEFAULT (SHOW TASKS)",
+        "DECLARE res RESULTSET := (SHOW TASKS LIKE 'foo%')",
+        "DECLARE cur CURSOR FOR (SHOW TASKS)",
+    ] {
+        let stmt = snowflake().verified_stmt(sql);
+        // The parsed SHOW must be recoverable from the declaration AST.
+        assert!(matches!(payload_show(stmt), Statement::ShowTasks { .. }));
+    }
+
+    // The pre-existing parenthesized-SELECT payload is unaffected.
+    snowflake().verified_stmt("DECLARE res RESULTSET DEFAULT (SELECT price FROM invoices)");
+    snowflake().verified_stmt("DECLARE cur CURSOR FOR (SELECT id FROM invoices)");
+
+    // Under a non-Snowflake dialect the SHOW payload still errors.
+    let generic = TestedDialects::new(vec![Box::new(GenericDialect {})]);
+    for sql in [
+        "DECLARE res RESULTSET DEFAULT (SHOW TASKS)",
+        "DECLARE cur CURSOR FOR (SHOW TASKS)",
+    ] {
+        assert!(generic.parse_sql_statements(sql).is_err());
+    }
+}
+
 #[test]
 fn parse_snowflake_declare_exception() {
     for (sql, expected_name, expected_assigned_expr) in [