Snowflake: accept :placeholder as SELECT ... INTO target

Extend parse_select_into to accept a colon placeholder (e.g.
SELECT ... INTO :var) as the target in dialects that opt in via
supports_select_into_placeholder_target (Snowflake scripting). The
:name placeholder text is preserved as the object-name part so the
round-trip is stable and downstream can distinguish it from a bare
table target. Bare-identifier targets are unchanged.

Author: sabir-akhadov-localstack

src/dialect/mod.rs

@@ -1115,6 +1115,13 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if this dialect accepts a colon placeholder as a
+    /// `SELECT ... INTO` target, e.g. `SELECT ... INTO :var` in Snowflake
+    /// scripting, where the target is a local variable rather than a table.
+    fn supports_select_into_placeholder_target(&self) -> bool {
+        false
+    }
+
     /// Returns true if this dialect supports `$` as a prefix for money literals
     /// e.g. `SELECT $123.45` (SQL Server)
     fn supports_dollar_as_money_prefix(&self) -> bool {

src/dialect/snowflake.rs

@@ -195,6 +195,12 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
+    /// Snowflake scripting accepts `SELECT ... INTO :var` where the target is a
+    /// local variable placeholder rather than a table name.
+    fn supports_select_into_placeholder_target(&self) -> bool {
+        true
+    }
+
     /// See <https://docs.snowflake.com/en/developer-guide/snowflake-scripting/cursors>
     fn supports_for_loop_over_cursor(&self) -> bool {
         true

src/parser/mod.rs

@@ -20606,7 +20606,20 @@ impl<'a> Parser<'a> {
             .is_some();
         let unlogged = self.parse_keyword(Keyword::UNLOGGED);
         let table = self.parse_keyword(Keyword::TABLE);
-        let name = self.parse_object_name(false)?;
+        let name = if self.dialect.supports_select_into_placeholder_target()
+            && self.peek_token_ref().token == Token::Colon
+        {
+            // Snowflake scripting: `SELECT ... INTO :var` targets a local
+            // variable. Keep the `:name` placeholder text as the object-name
+            // part so the round-trip is preserved and downstream can tell it
+            // apart from a bare table target.
+            let placeholder = self.parse_value()?;
+            ObjectName(vec![ObjectNamePart::Identifier(Ident::new(
+                placeholder.to_string(),
+            ))])
+        } else {
+            self.parse_object_name(false)?
+        };
 
         Ok(SelectInto {
             temporary,

tests/sqlparser_snowflake.rs

@@ -8625,3 +8625,29 @@ fn test_show_terse_stages() {
         _ => unreachable!(),
     }
 }
+
+#[test]
+fn test_select_into_placeholder_target() {
+    // Snowflake scripting: a colon placeholder is a valid `SELECT ... INTO`
+    // target (a local variable), and it round-trips as `:res`.
+    let stmt = snowflake().verified_stmt("SELECT :res + t.hmy INTO :res FROM tbl AS t");
+    let Statement::Query(query) = stmt else {
+        unreachable!()
+    };
+    let SetExpr::Select(select) = *query.body else {
+        unreachable!()
+    };
+    let into = select.into.expect("expected SELECT ... INTO clause");
+    assert_eq!(into.name.to_string(), ":res");
+    assert!(!into.table);
+
+    // Bare-identifier targets are unaffected.
+    let stmt = snowflake().verified_stmt("SELECT 1 INTO res FROM tbl");
+    let Statement::Query(query) = stmt else {
+        unreachable!()
+    };
+    let SetExpr::Select(select) = *query.body else {
+        unreachable!()
+    };
+    assert_eq!(select.into.unwrap().name.to_string(), "res");
+}