Parse alter iceberg table

Author: osipovartem

src/ast/mod.rs

@@ -2677,6 +2677,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
@@ -4448,8 +4451,13 @@ impl fmt::Display for Statement {
                 operations,
                 location,
                 on_cluster,
+                iceberg,
             } => {
-                write!(f, "ALTER TABLE ")?;
+                if *iceberg {
+                    write!(f, "ALTER ICEBERG TABLE ")?;
+                } else {
+                    write!(f, "ALTER TABLE ")?;
+                }
                 if *if_exists {
                     write!(f, "IF EXISTS ")?;
                 }

src/ast/spans.rs

@@ -410,6 +410,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

@@ -8221,39 +8221,16 @@ 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 => {
-                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)?;
-                let on_cluster = self.parse_optional_on_cluster()?;
-                let operations = self.parse_comma_separated(Parser::parse_alter_table_operation)?;
-
-                let mut location = None;
-                if self.parse_keyword(Keyword::LOCATION) {
-                    location = Some(HiveSetLocation {
-                        has_set: false,
-                        location: self.parse_identifier()?,
-                    });
-                } else if self.parse_keywords(&[Keyword::SET, Keyword::LOCATION]) {
-                    location = Some(HiveSetLocation {
-                        has_set: true,
-                        location: self.parse_identifier()?,
-                    });
-                }
-
-                Ok(Statement::AlterTable {
-                    name: table_name,
-                    if_exists,
-                    only,
-                    operations,
-                    location,
-                    on_cluster,
-                })
+            Keyword::ICEBERG => {
+                self.expect_keyword(Keyword::TABLE)?;
+                self.parse_alter_table(true)
             }
+            Keyword::TABLE => self.parse_alter_table(false),
             Keyword::INDEX => {
                 let index_name = self.parse_object_name(false)?;
                 let operation = if self.parse_keyword(Keyword::RENAME) {
@@ -8346,6 +8323,38 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// 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)?;
+        let on_cluster = self.parse_optional_on_cluster()?;
+        let operations = self.parse_comma_separated(Parser::parse_alter_table_operation)?;
+
+        let mut location = None;
+        if self.parse_keyword(Keyword::LOCATION) {
+            location = Some(HiveSetLocation {
+                has_set: false,
+                location: self.parse_identifier()?,
+            });
+        } else if self.parse_keywords(&[Keyword::SET, Keyword::LOCATION]) {
+            location = Some(HiveSetLocation {
+                has_set: true,
+                location: self.parse_identifier()?,
+            });
+        }
+
+        Ok(Statement::AlterTable {
+            name: table_name,
+            if_exists,
+            only,
+            operations,
+            location,
+            on_cluster,
+            iceberg,
+        })
+    }
+
     /// Parse a `CALL procedure_name(arg1, arg2, ...)`
     /// or `CALL procedure_name` statement
     pub fn parse_call(&mut self) -> Result<Statement, ParserError> {

src/test_utils.rs

@@ -325,10 +325,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_snowflake.rs

@@ -1563,6 +1563,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") {