Add ICEBERG keyword support to ALTER TABLE statement (#1869)

src/ast/mod.rs

@@ -3281,6 +3281,9 @@ pub enum Statement {
         /// For example: `ALTER TABLE table_name ON CLUSTER cluster_name ADD COLUMN c UInt32`
         /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/update)
         on_cluster: Option<Ident>,
+        /// Snowflake "ICEBERG" clause for Iceberg tables
+        /// <https://docs.snowflake.com/en/sql-reference/sql/alter-iceberg-table>
+        iceberg: bool,
     },
     /// ```sql
     /// ALTER INDEX
@@ -5139,8 +5142,14 @@ impl fmt::Display for Statement {
                 operations,
                 location,
                 on_cluster,
+                iceberg,
             } => {
+                if *iceberg {
+                    write!(f, "ALTER ICEBERG TABLE ")?;
+                } else {
                     write!(f, "ALTER TABLE ")?;
+                }
+
                 if *if_exists {
                     write!(f, "IF EXISTS ")?;
                 }

src/ast/spans.rs

@@ -431,6 +431,7 @@ impl Spanned for Statement {
                 operations,
                 location: _,
                 on_cluster,
+                iceberg: _,
             } => union_spans(
                 core::iter::once(name.span())
                     .chain(operations.iter().map(|i| i.span()))

src/parser/mod.rs

@@ -8893,11 +8893,44 @@ impl<'a> Parser<'a> {
             Keyword::ROLE,
             Keyword::POLICY,
             Keyword::CONNECTOR,
+            Keyword::ICEBERG,
         ])?;
         match object_type {
             Keyword::VIEW => self.parse_alter_view(),
             Keyword::TYPE => self.parse_alter_type(),
-            Keyword::TABLE => {
+            Keyword::TABLE => self.parse_alter_table(false),
+            Keyword::ICEBERG => {
+                self.expect_keyword(Keyword::TABLE)?;
+                self.parse_alter_table(true)
+            }
+            Keyword::INDEX => {
+                let index_name = self.parse_object_name(false)?;
+                let operation = if self.parse_keyword(Keyword::RENAME) {
+                    if self.parse_keyword(Keyword::TO) {
+                        let index_name = self.parse_object_name(false)?;
+                        AlterIndexOperation::RenameIndex { index_name }
+                    } else {
+                        return self.expected("TO after RENAME", self.peek_token());
+                    }
+                } else {
+                    return self.expected("RENAME after ALTER INDEX", self.peek_token());
+                };
+
+                Ok(Statement::AlterIndex {
+                    name: index_name,
+                    operation,
+                })
+            }
+            Keyword::ROLE => self.parse_alter_role(),
+            Keyword::POLICY => self.parse_alter_policy(),
+            Keyword::CONNECTOR => self.parse_alter_connector(),
+            // unreachable because expect_one_of_keywords used above
+            _ => unreachable!(),
+        }
+    }
+
+    /// Parse a [Statement::AlterTable]
+    pub fn parse_alter_table(&mut self, iceberg: bool) -> Result<Statement, ParserError> {
         let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
         let only = self.parse_keyword(Keyword::ONLY); // [ ONLY ]
         let table_name = self.parse_object_name(false)?;
@@ -8924,33 +8957,9 @@ impl<'a> Parser<'a> {
             operations,
             location,
             on_cluster,
+            iceberg,
         })
     }
-            Keyword::INDEX => {
-                let index_name = self.parse_object_name(false)?;
-                let operation = if self.parse_keyword(Keyword::RENAME) {
-                    if self.parse_keyword(Keyword::TO) {
-                        let index_name = self.parse_object_name(false)?;
-                        AlterIndexOperation::RenameIndex { index_name }
-                    } else {
-                        return self.expected("TO after RENAME", self.peek_token());
-                    }
-                } else {
-                    return self.expected("RENAME after ALTER INDEX", self.peek_token());
-                };
-
-                Ok(Statement::AlterIndex {
-                    name: index_name,
-                    operation,
-                })
-            }
-            Keyword::ROLE => self.parse_alter_role(),
-            Keyword::POLICY => self.parse_alter_policy(),
-            Keyword::CONNECTOR => self.parse_alter_connector(),
-            // unreachable because expect_one_of_keywords used above
-            _ => unreachable!(),
-        }
-    }
 
     pub fn parse_alter_view(&mut self) -> Result<Statement, ParserError> {
         let name = self.parse_object_name(false)?;

src/test_utils.rs

@@ -345,10 +345,12 @@ pub fn alter_table_op_with_name(stmt: Statement, expected_name: &str) -> AlterTa
             operations,
             on_cluster: _,
             location: _,
+            iceberg,
         } => {
             assert_eq!(name.to_string(), expected_name);
             assert!(!if_exists);
             assert!(!is_only);
+            assert!(!iceberg);
             only(operations)
         }
         _ => panic!("Expected ALTER TABLE statement"),

tests/sqlparser_mysql.rs

@@ -2507,11 +2507,13 @@ fn parse_alter_table_add_column() {
             if_exists,
             only,
             operations,
+            iceberg,
             location: _,
             on_cluster: _,
         } => {
             assert_eq!(name.to_string(), "tab");
             assert!(!if_exists);
+            assert!(!iceberg);
             assert!(!only);
             assert_eq!(
                 operations,
@@ -2536,8 +2538,7 @@ fn parse_alter_table_add_column() {
             if_exists,
             only,
             operations,
-            location: _,
+            ..
-            on_cluster: _,
         } => {
             assert_eq!(name.to_string(), "tab");
             assert!(!if_exists);
@@ -2574,8 +2575,7 @@ fn parse_alter_table_add_columns() {
             if_exists,
             only,
             operations,
-            location: _,
+            ..
-            on_cluster: _,
         } => {
             assert_eq!(name.to_string(), "tab");
             assert!(!if_exists);

tests/sqlparser_postgres.rs

@@ -834,8 +834,7 @@ fn parse_alter_table_add_columns() {
             if_exists,
             only,
             operations,
-            location: _,
+            ..
-            on_cluster: _,
         } => {
             assert_eq!(name.to_string(), "tab");
             assert!(if_exists);
@@ -915,8 +914,7 @@ fn parse_alter_table_owner_to() {
                 if_exists: _,
                 only: _,
                 operations,
-                location: _,
+                ..
-                on_cluster: _,
             } => {
                 assert_eq!(name.to_string(), "tab");
                 assert_eq!(

tests/sqlparser_snowflake.rs

@@ -1591,6 +1591,13 @@ fn test_alter_table_clustering() {
     snowflake_and_generic().verified_stmt("ALTER TABLE tbl RESUME RECLUSTER");
 }
 
+#[test]
+fn test_alter_iceberg_table() {
+    snowflake_and_generic().verified_stmt("ALTER ICEBERG TABLE tbl DROP CLUSTERING KEY");
+    snowflake_and_generic().verified_stmt("ALTER ICEBERG TABLE tbl SUSPEND RECLUSTER");
+    snowflake_and_generic().verified_stmt("ALTER ICEBERG TABLE tbl RESUME RECLUSTER");
+}
+
 #[test]
 fn test_drop_stage() {
     match snowflake_and_generic().verified_stmt("DROP STAGE s1") {