Snowflake: Fix COPY INTO transformation parsing for cast expressions

src/dialect/snowflake.rs

@@ -1545,6 +1545,14 @@ fn parse_select_item_for_data_load(
         }
     }
 
+    // A trailing `::` means this is a cast expression (e.g.
+    // `$1:"col"::NUMBER(38,0)`), not a stage-load-select-item. Bail so
+    // `maybe_parse` rewinds and the caller falls through to
+    // `parse_select_item`, which handles the cast correctly.
+    if matches!(parser.peek_token_ref().token, Token::DoubleColon) {
+        return parser.expected("stage load select item", parser.peek_token());
+    }
+
     // as
     if parser.parse_keyword(Keyword::AS) {
         item_as = Some(match parser.next_token().token {

tests/sqlparser_snowflake.rs

@@ -2447,6 +2447,49 @@ fn test_copy_into_with_transformations() {
     snowflake().parse_sql_statements(sql1).unwrap();
 }
 
+#[test]
+fn test_copy_into_with_cast_transformation() {
+    // Snowflake `COPY INTO` transformation lists support casts like
+    // `$1:"col"::TYPE` and `$1::TYPE`. These are distinct from the bare
+    // `$<n>[.<col>][:<elem>]` stage-load-select-item shape, so the parser
+    // must fall through to the generic select-item parser to handle the
+    // `::` cast operator.
+    //
+    // Regression: the Snowflake-specific parser used to successfully
+    // consume `$1:"col"` as a stage-load-select-item, leaving `::TYPE`
+    // behind and causing "Expected: FROM, found: ::" once the COPY INTO
+    // body tried to expect `FROM`.
+    let variants = [
+        concat!(
+            "COPY INTO my_company.emp_basic (a) FROM ",
+            r#"(SELECT $1:"A"::NUMBER(38, 0) FROM @stg)"#,
+        ),
+        concat!(
+            "COPY INTO my_company.emp_basic (a) FROM ",
+            "(SELECT $1::NUMBER(38, 0) FROM @stg)",
+        ),
+        concat!(
+            "COPY INTO my_company.emp_basic (a) FROM ",
+            "(SELECT $1:SEQUENCE::NUMBER(38, 0) FROM @stg)",
+        ),
+        concat!(
+            "COPY INTO my_company.emp_basic (a, b) FROM ",
+            r#"(SELECT $1:"A"::VARIANT, $1:"B"::TEXT FROM @stg)"#,
+        ),
+        // Mix with an ordinary stage-load-select-item in the same list,
+        // so we don't over-correct and break the existing shape.
+        concat!(
+            "COPY INTO my_company.emp_basic (a, b) FROM ",
+            r#"(SELECT t.$1:plain AS plain, $1:"B"::TEXT FROM @stg AS t)"#,
+        ),
+    ];
+    for sql in variants {
+        snowflake().parse_sql_statements(sql).unwrap_or_else(|e| {
+            panic!("expected {sql:?} to parse, got {e}");
+        });
+    }
+}
+
 #[test]
 fn test_copy_into_file_format() {
     let sql = concat!(