Support Snowflake ALTER SCHEMA SET/UNSET properties

src/ast/ddl.rs

@@ -3824,6 +3824,16 @@ pub enum AlterSchemaOperation {
         /// The options to set.
         options: Vec<SqlOption>,
     },
+    /// Set primitive schema properties without an `OPTIONS (...)` wrapper (Snowflake).
+    SetOptions {
+        /// Ordered assignments, including duplicates; values are not semantically validated.
+        options: Vec<SqlOption>,
+    },
+    /// Reset schema properties to their defaults (Snowflake).
+    UnsetOptions {
+        /// Ordered property names, including duplicates.
+        options: Vec<Ident>,
+    },
     /// Rename the schema.
     Rename {
         /// The new name for the schema.
@@ -3853,6 +3863,12 @@ impl fmt::Display for AlterSchemaOperation {
             AlterSchemaOperation::SetOptionsParens { options } => {
                 write!(f, "SET OPTIONS ({})", display_comma_separated(options))
             }
+            AlterSchemaOperation::SetOptions { options } => {
+                write!(f, "SET {}", display_separated(options, " "))
+            }
+            AlterSchemaOperation::UnsetOptions { options } => {
+                write!(f, "UNSET {}", display_comma_separated(options))
+            }
             AlterSchemaOperation::Rename { name } => write!(f, "RENAME TO {name}"),
             AlterSchemaOperation::OwnerTo { owner } => write!(f, "OWNER TO {owner}"),
         }

src/ast/spans.rs

@@ -2483,9 +2483,13 @@ impl Spanned for AlterSchemaOperation {
                     .chain(options.iter().flat_map(|i| i.iter().map(|i| i.span()))),
             ),
             AlterSchemaOperation::DropReplica { replica } => replica.span,
-            AlterSchemaOperation::SetOptionsParens { options } => {
+            AlterSchemaOperation::SetOptionsParens { options }
+            | AlterSchemaOperation::SetOptions { options } => {
                 union_spans(options.iter().map(|i| i.span()))
             }
+            AlterSchemaOperation::UnsetOptions { options } => {
+                union_spans(options.iter().map(|i| i.span))
+            }
             AlterSchemaOperation::Rename { name } => name.span(),
             AlterSchemaOperation::OwnerTo { owner } => {
                 if let Owner::Ident(ident) = owner {

src/dialect/mod.rs

@@ -1509,6 +1509,15 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if `ALTER SCHEMA` supports native `SET key = <literal>`
+    /// assignments separated by whitespace or commas, and `UNSET key, ...`.
+    /// This does not enable structured properties such as `TAG` or `CONTACT`.
+    ///
+    /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/alter-schema)
+    fn supports_alter_schema_options(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports the `USING` clause in an `ALTER COLUMN` statement.
     /// Example:
     ///  ```sql

src/dialect/snowflake.rs

@@ -749,6 +749,10 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
+    fn supports_alter_schema_options(&self) -> bool {
+        true
+    }
+
     fn supports_comma_separated_drop_column_list(&self) -> bool {
         true
     }

src/parser/mod.rs

@@ -11574,6 +11574,20 @@ impl<'a> Parser<'a> {
         } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
             let owner = self.parse_owner()?;
             AlterSchemaOperation::OwnerTo { owner }
+        } else if self.dialect.supports_alter_schema_options() && self.parse_keyword(Keyword::SET) {
+            let options = self.parse_alter_schema_set_options()?;
+            AlterSchemaOperation::SetOptions { options }
+        } else if self.dialect.supports_alter_schema_options() && self.parse_keyword(Keyword::UNSET)
+        {
+            let options = self.parse_comma_separated_with_trailing_commas(
+                Self::parse_alter_schema_option_name,
+                false,
+                Self::is_reserved_for_column_alias,
+            )?;
+            if !matches!(self.peek_token_ref().token, Token::EOF | Token::SemiColon) {
+                return self.expected_ref("comma or statement end", self.peek_token_ref());
+            }
+            AlterSchemaOperation::UnsetOptions { options }
         } else {
             return self.expected_ref("ALTER SCHEMA operation", self.peek_token_ref());
         };
@@ -11584,6 +11598,62 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    fn parse_alter_schema_option_name(&mut self) -> Result<Ident, ParserError> {
+        if !matches!(self.peek_token_ref().token, Token::Word(_))
+            || self
+                .peek_one_of_keywords(&[Keyword::TAG, Keyword::CONTACT])
+                .is_some()
+        {
+            return self.expected_ref("primitive schema property name", self.peek_token_ref());
+        }
+        self.parse_identifier()
+    }
+
+    fn parse_alter_schema_set_options(&mut self) -> Result<Vec<SqlOption>, ParserError> {
+        let mut options = Vec::new();
+        loop {
+            let key = self.parse_alter_schema_option_name()?;
+            self.expect_token(&Token::Eq)?;
+            let value = match self.peek_token_ref().token {
+                Token::Plus | Token::Minus
+                    if !matches!(self.peek_nth_token_ref(1).token, Token::Number(..)) =>
+                {
+                    return self.expected_ref("signed numeric literal", self.peek_token_ref());
+                }
+                Token::Number(..) | Token::Plus | Token::Minus => self.parse_number()?,
+                Token::EOF
+                | Token::SemiColon
+                | Token::Placeholder(_)
+                | Token::Colon
+                | Token::AtSign => {
+                    return self
+                        .expected_ref("primitive schema property literal", self.peek_token_ref());
+                }
+                _ => Expr::Value(self.parse_value()?),
+            };
+            options.push(SqlOption::KeyValue { key, value });
+
+            let space_separated = matches!(
+                self.peek_nth_token_no_skip_ref(0).token,
+                Token::Whitespace(_)
+            );
+            if self.consume_token(&Token::Comma) {
+                continue;
+            }
+            match self.peek_token_ref().token {
+                Token::EOF | Token::SemiColon => break,
+                Token::Word(_) if space_separated => {}
+                _ => {
+                    return self.expected_ref(
+                        "schema property separator or statement end",
+                        self.peek_token_ref(),
+                    )
+                }
+            }
+        }
+        Ok(options)
+    }
+
     /// Parse a `CALL procedure_name(arg1, arg2, ...)`
     /// or `CALL procedure_name` statement
     pub fn parse_call(&mut self) -> Result<Statement, ParserError> {