From ef06ba97676face9af557d8b2de4aad39ad89818 Mon Sep 17 00:00:00 2001
From: Kevin Longe <273747162+kvlonge@users.noreply.github.com>
Date: Wed, 4 Nov 2026 19:24:11 +0000
Subject: [PATCH 1/3] fix(syntax): parse Snowflake ALTER of application,
 database and service kinds as a typed statement

ALTER APPLICATION, APPLICATION PACKAGE, APPLICATION SERVICE, BACKUP SET,
CORTEX SEARCH SERVICE, DATABASE, SEMANTIC VIEW and STREAMLIT parsed through
the raw ALTER fallback, which accepted malformed statements. They now parse
to AlterObject with the kind, IF EXISTS, the action words and its operands
and properties, and reject missing operands, string or unquoted reserved
names, and half of a multi-word kind (ALTER CORTEX SEARCH, ALTER SEMANTIC,
ALTER BACKUP without SET).
---
 .../src/parser/_helpers/ddl/mod.rs            |   1 +
 .../parser/_helpers/ddl/snowflake_alter.rs    |  28 +-
 .../_helpers/ddl/snowflake_alter_objects.rs   | 776 ++++++++++++++++++
 .../tests/parser/test_fixes.rs                | 179 ++++
 4 files changed, 974 insertions(+), 10 deletions(-)
 create mode 100644 crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs

diff --git a/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs b/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs
index d1ad98a35..75201228c 100644
--- a/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs
@@ -8,4 +8,5 @@ pub(crate) mod create_table_forms;
 pub(crate) mod explain;
 pub(crate) mod scripting;
 pub(crate) mod snowflake_alter;
+pub(crate) mod snowflake_alter_objects;
 pub(crate) mod table_options;
diff --git a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
index 338ba936a..b7fe1f2a2 100644
--- a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
@@ -1,4 +1,5 @@
 //! Snowflake ALTER of object kinds with no statement of their own: EXPERIMENT, SNAPSHOT, SNAPSHOT SET, TAG, TASK and TASK GRAPH.
+//! The application, backup, Cortex Search, database, semantic view and Streamlit kinds are in `snowflake_alter_objects`.
 
 use crate::expressions::names::models::Identifier;
 use crate::expressions::names::models::TableRef;
@@ -14,6 +15,9 @@ use crate::tokens::types::Result;
 impl Parser {
     /// Parse a Snowflake ALTER of a kind this module owns, or None when the next words name another kind.
     pub(crate) fn parse_alter_snowflake_object(&mut self) -> Result<Option<Expression>> {
+        if let Some(expr) = self.parse_alter_snowflake_objects()? {
+            return Ok(Some(expr));
+        }
         if self.check_identifier("TASK")
             && self.check_next_identifier("GRAPH")
             && !self
@@ -60,20 +64,20 @@ impl Parser {
     }
 
     /// The uppercase text of the token `offset` tokens ahead, if there is one.
-    fn text_at(&self, offset: usize) -> Option<String> {
+    pub(crate) fn text_at(&self, offset: usize) -> Option<String> {
         self.tokens
             .get(self.current + offset)
             .map(|token| token.text.to_ascii_uppercase())
     }
 
     /// Parse `[ IF EXISTS ] <name>` after the kind.
-    fn parse_alter_object_head(&mut self) -> Result<(TableRef, bool)> {
+    pub(crate) fn parse_alter_object_head(&mut self) -> Result<(TableRef, bool)> {
         let if_exists = self.match_keywords(&[TokenType::If, TokenType::Exists]);
         Ok((self.parse_object_name()?, if_exists))
     }
 
     /// Parse an object name: an identifier, never a string or an unquoted reserved keyword.
-    fn parse_object_name(&mut self) -> Result<TableRef> {
+    pub(crate) fn parse_object_name(&mut self) -> Result<TableRef> {
         if self.check(TokenType::String)
             || self.is_snowflake_reserved_keyword()
             || !self.is_object_name_start()
@@ -91,7 +95,7 @@ impl Parser {
     }
 
     /// Parse a simple name, such as a contact purpose or a property: an identifier, not a reserved keyword.
-    fn parse_simple_name(&mut self) -> Result<Identifier> {
+    pub(crate) fn parse_simple_name(&mut self) -> Result<Identifier> {
         if self.check(TokenType::String)
             || self.is_snowflake_reserved_keyword()
             || !self.is_object_name_start()
@@ -102,7 +106,7 @@ impl Parser {
     }
 
     /// Parse a property value: a literal, TRUE, FALSE or a name.
-    fn parse_object_value(&mut self) -> Result<Expression> {
+    pub(crate) fn parse_object_value(&mut self) -> Result<Expression> {
         if self.check(TokenType::String)
             || self.check(TokenType::Number)
             || self.check(TokenType::DollarString)
@@ -126,7 +130,7 @@ impl Parser {
     }
 
     /// Parse a string literal value.
-    fn parse_string_value(&mut self) -> Result<Expression> {
+    pub(crate) fn parse_string_value(&mut self) -> Result<Expression> {
         if !self.check(TokenType::String) {
             return Err(self.parse_error("Expected a string"));
         }
@@ -134,7 +138,7 @@ impl Parser {
     }
 
     /// Consume one of `choices`, each a sequence of words, and return its words joined.
-    fn expect_alter_words(&mut self, choices: &[&[&str]]) -> Result<String> {
+    pub(crate) fn expect_alter_words(&mut self, choices: &[&[&str]]) -> Result<String> {
         match choices.iter().find(|words| self.match_text_seq(words)) {
             Some(words) => Ok(words.join(" ")),
             None => Err(self.parse_error(format!(
@@ -245,7 +249,7 @@ impl Parser {
     }
 
     /// Parse a possibly qualified name, such as a tag name, as one identifier.
-    fn parse_simple_qualified_name(&mut self) -> Result<Identifier> {
+    pub(crate) fn parse_simple_qualified_name(&mut self) -> Result<Identifier> {
         let mut name = self.parse_simple_name()?;
         while self.match_token(TokenType::Dot) {
             let part = self.parse_simple_name()?;
@@ -496,7 +500,7 @@ impl Parser {
 }
 
 /// An ALTER of `kind` on the named object, with its action, operands and properties.
-fn alter_object(
+pub(crate) fn alter_object(
     kind: &str,
     (name, if_exists): (TableRef, bool),
     action: String,
@@ -513,7 +517,11 @@ fn alter_object(
 }
 
 /// One property of kind `kind`.
-fn property(kind: &str, name: Option<Identifier>, value: Option<Expression>) -> ObjectProperty {
+pub(crate) fn property(
+    kind: &str,
+    name: Option<Identifier>,
+    value: Option<Expression>,
+) -> ObjectProperty {
     ObjectProperty {
         kind: kind.to_owned(),
         name,
diff --git a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
new file mode 100644
index 000000000..ac888d7ac
--- /dev/null
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
@@ -0,0 +1,776 @@
+//! Snowflake ALTER of APPLICATION, APPLICATION PACKAGE, APPLICATION SERVICE, BACKUP SET, CORTEX SEARCH SERVICE, DATABASE, SEMANTIC VIEW and STREAMLIT.
+
+use crate::expressions::names::models::Identifier;
+use crate::expressions::names::models::TableRef;
+use crate::expressions::schema_objects::models::ObjectProperty;
+use crate::expressions::tree::models::Expression;
+use crate::expressions::types::models::Tuple;
+use crate::parser::_helpers::ddl::snowflake_alter::alter_object;
+use crate::parser::_helpers::ddl::snowflake_alter::property;
+use crate::parser::models::Parser;
+use crate::tokens::models::TokenType;
+use crate::tokens::types::Result;
+
+/// The options that may follow a release directive's VERSION and PATCH.
+const UPGRADE_OPTIONS: &[&str] = &[
+    "UPGRADE_AFTER",
+    "UPGRADE_IN_MAINTENANCE_WINDOW",
+    "UPGRADE_DEADLINE",
+];
+
+type Parts = (Vec<Expression>, Vec<ObjectProperty>);
+
+impl Parser {
+    /// Parse a Snowflake ALTER of a kind this module owns, or None when the next words name another kind.
+    pub(crate) fn parse_alter_snowflake_objects(&mut self) -> Result<Option<Expression>> {
+        if self.match_text_seq(&["APPLICATION", "PACKAGE"]) {
+            return self.parse_alter_application_package().map(Some);
+        }
+        if self.match_text_seq(&["APPLICATION", "SERVICE"]) {
+            return self.parse_alter_application_service().map(Some);
+        }
+        if self.match_text_seq(&["APPLICATION"]) {
+            return self.parse_alter_application().map(Some);
+        }
+        if self.match_text_seq(&["BACKUP", "SET"]) {
+            return self.parse_alter_backup_set().map(Some);
+        }
+        if self.match_text_seq(&["CORTEX", "SEARCH", "SERVICE"]) {
+            return self.parse_alter_cortex_search_service().map(Some);
+        }
+        if self.match_token(TokenType::Database) {
+            return self.parse_alter_database().map(Some);
+        }
+        if self.match_text_seq(&["SEMANTIC", "VIEW"]) {
+            return self.parse_alter_semantic_view().map(Some);
+        }
+        if self.match_text_seq(&["STREAMLIT"]) {
+            return self.parse_alter_streamlit().map(Some);
+        }
+        if self.check_text_seq(&["CORTEX"])
+            || self.check_text_seq(&["SEMANTIC"])
+            || self.check_text_seq(&["BACKUP"]) && !self.check_text_seq(&["BACKUP", "POLICY"])
+        {
+            return Err(self.parse_error(format!(
+                "Snowflake has no ALTER {} {}",
+                self.peek_text().to_ascii_uppercase(),
+                self.text_at(1).unwrap_or_default()
+            )));
+        }
+        Ok(None)
+    }
+
+    /// Parse an object name as an operand.
+    fn object_operand(&mut self) -> Result<Expression> {
+        Ok(Expression::Table(Box::new(self.parse_object_name()?)))
+    }
+
+    /// Parse a comma-separated list of object names as one operand.
+    fn object_list_operand(&mut self) -> Result<Expression> {
+        let mut names = vec![self.object_operand()?];
+        while self.match_token(TokenType::Comma) {
+            names.push(self.object_operand()?);
+        }
+        Ok(tuple(names))
+    }
+
+    /// Parse a comma-separated list of account identifiers, each `[ <organization_name> . ] <account_name>`.
+    fn account_list_operand(&mut self) -> Result<Expression> {
+        let mut accounts = vec![Expression::Identifier(self.parse_simple_qualified_name()?)];
+        while self.match_token(TokenType::Comma) {
+            accounts.push(Expression::Identifier(self.parse_simple_qualified_name()?));
+        }
+        Ok(tuple(accounts))
+    }
+
+    /// Parse a parenthesized list of account identifiers.
+    fn parse_account_list(&mut self) -> Result<Expression> {
+        self.expect_token(TokenType::LParen)?;
+        let list = self.account_list_operand()?;
+        self.expect_token(TokenType::RParen)?;
+        Ok(list)
+    }
+
+    /// Parse an integer literal.
+    fn number_operand(&mut self) -> Result<Expression> {
+        if !self.check(TokenType::Number) {
+            return Err(self.parse_error("Expected a number"));
+        }
+        self.parse_primary()
+    }
+
+    /// Parse `RENAME TO <name>` or `SWAP WITH <name>` after its first word.
+    fn parse_alter_target(&mut self, second: &str) -> Result<Parts> {
+        self.expect_alter_words(&[&[second]])?;
+        Ok((vec![self.object_operand()?], vec![]))
+    }
+
+    /// Parse a property value: a parenthesized list, NULL, a literal or a name.
+    fn parse_alter_value(&mut self) -> Result<Expression> {
+        if self.match_token(TokenType::LParen) {
+            let mut items = Vec::new();
+            loop {
+                let item = self.parse_object_value()?;
+                if self.match_token(TokenType::Eq) {
+                    items.push(tuple(vec![item, self.parse_object_value()?]));
+                } else {
+                    items.push(item);
+                }
+                if !self.match_token(TokenType::Comma) {
+                    break;
+                }
+            }
+            self.expect_token(TokenType::RParen)?;
+            return Ok(tuple(items));
+        }
+        if self.check(TokenType::Null) {
+            return self.parse_primary();
+        }
+        self.parse_object_value()
+    }
+
+    /// Parse a parenthesized list of string literals.
+    fn parse_string_list(&mut self) -> Result<Expression> {
+        self.expect_token(TokenType::LParen)?;
+        let mut items = vec![self.parse_string_value()?];
+        while self.match_token(TokenType::Comma) {
+            items.push(self.parse_string_value()?);
+        }
+        self.expect_token(TokenType::RParen)?;
+        Ok(tuple(items))
+    }
+
+    /// Parse a parenthesized list of object names.
+    fn parse_name_list(&mut self) -> Result<Expression> {
+        self.expect_token(TokenType::LParen)?;
+        let list = self.object_list_operand()?;
+        self.expect_token(TokenType::RParen)?;
+        Ok(list)
+    }
+
+    /// Parse `<name> = <value>` for each name of `names` that comes next, in any order.
+    fn parse_named_options(&mut self, names: &[&str]) -> Result<Vec<ObjectProperty>> {
+        let mut properties = Vec::new();
+        while let Some(name) = names
+            .iter()
+            .find(|name| self.check_text_seq(&[name]) && self.check_next(TokenType::Eq))
+        {
+            self.skip();
+            self.skip();
+            properties.push(property(name, None, Some(self.parse_alter_value()?)));
+        }
+        Ok(properties)
+    }
+
+    /// Parse `<name> = <value>` for one required name.
+    fn parse_required_option(&mut self, name: &str) -> Result<ObjectProperty> {
+        self.expect_alter_words(&[&[name]])?;
+        self.expect_token(TokenType::Eq)?;
+        Ok(property(name, None, Some(self.parse_alter_value()?)))
+    }
+
+    /// Parse the properties of a SET (`set`) or UNSET: TAG and CONTACT lists, PRIMARY KEY, or named properties.
+    fn parse_alter_settings(&mut self, set: bool) -> Result<Vec<ObjectProperty>> {
+        let mut properties: Vec<ObjectProperty> = Vec::new();
+        loop {
+            let named = self.check_next(TokenType::Eq) || self.check_next(TokenType::Comma) || {
+                let next = self.current + 1;
+                next >= self.tokens.len() || self.tokens[next].token_type == TokenType::Semicolon
+            };
+            if !named && (self.check_text_seq(&["TAG"]) || self.check_text_seq(&["CONTACT"])) {
+                let kind = self.peek_text().to_ascii_uppercase();
+                self.skip();
+                loop {
+                    let name = if kind == "TAG" {
+                        self.parse_simple_qualified_name()?
+                    } else {
+                        self.parse_simple_name()?
+                    };
+                    let value = if set {
+                        self.expect_token(TokenType::Eq)?;
+                        Some(self.parse_object_value()?)
+                    } else {
+                        None
+                    };
+                    properties.push(property(&kind, Some(name), value));
+                    if !self.match_token(TokenType::Comma) {
+                        break;
+                    }
+                }
+            } else if self.match_text_seq(&["PRIMARY", "KEY"]) {
+                let value = if set {
+                    self.expect_token(TokenType::Eq)?;
+                    Some(self.parse_name_list()?)
+                } else {
+                    None
+                };
+                properties.push(property("PRIMARY KEY", None, value));
+            } else {
+                let name = self.parse_simple_name()?;
+                let value = if set || self.check(TokenType::Eq) {
+                    self.expect_token(TokenType::Eq)?;
+                    Some(self.parse_alter_value()?)
+                } else {
+                    None
+                };
+                properties.push(property(&name.name.to_ascii_uppercase(), None, value));
+            }
+            let comma = self.match_token(TokenType::Comma);
+            if self.is_at_end() || self.check(TokenType::Semicolon) || !set && !comma {
+                return Ok(properties);
+            }
+        }
+    }
+
+    /// Parse `SET ...` or `UNSET ...` after the word.
+    fn parse_alter_set(&mut self, set: bool) -> Result<Parts> {
+        Ok((vec![], self.parse_alter_settings(set)?))
+    }
+
+    /// Parse `<policy_name> [ FORCE ]` after `{ FEATURE | MAINTENANCE | BACKUP } POLICY`.
+    fn parse_alter_policy(&mut self, action: &mut String) -> Result<Parts> {
+        let policy = self.object_operand()?;
+        if self.match_text_seq(&["FORCE"]) {
+            action.push_str(" FORCE");
+        }
+        Ok((vec![policy], vec![]))
+    }
+
+    /// Parse ALTER DATABASE after its kind.
+    fn parse_alter_database(&mut self) -> Result<Expression> {
+        let head = self.parse_alter_object_head()?;
+        let mut action = self.expect_alter_words(&[
+            &["RENAME"],
+            &["SWAP"],
+            &["RESUME", "DISCOVERY"],
+            &["SUSPEND", "DISCOVERY"],
+            &["REFRESH"],
+            &["PRIMARY"],
+            &["ENABLE", "REPLICATION"],
+            &["ENABLE", "FAILOVER"],
+            &["DISABLE", "REPLICATION"],
+            &["DISABLE", "FAILOVER"],
+            &["SET", "FEATURE", "POLICY"],
+            &["UNSET", "FEATURE", "POLICY"],
+            &["UPDATE", "LINKED_CATALOG"],
+            &["SET"],
+            &["UNSET"],
+        ])?;
+        let parts = match action.as_str() {
+            "RENAME" => self.parse_alter_target("TO")?,
+            "SWAP" => self.parse_alter_target("WITH")?,
+            "SET FEATURE POLICY" => self.parse_alter_policy(&mut action)?,
+            "SET" => self.parse_alter_set(true)?,
+            "UNSET" => self.parse_alter_set(false)?,
+            "UPDATE LINKED_CATALOG" => self.parse_linked_catalog_update(&mut action)?,
+            _ if action.starts_with("ENABLE") || action.starts_with("DISABLE") => {
+                let mut operands = Vec::new();
+                if action.starts_with("ENABLE") || self.check_text_seq(&["TO"]) {
+                    self.expect_alter_words(&[&["TO", "ACCOUNTS"]])?;
+                    operands.push(self.account_list_operand()?);
+                }
+                if action == "ENABLE REPLICATION"
+                    && self.match_text_seq(&["IGNORE", "EDITION", "CHECK"])
+                {
+                    action.push_str(" IGNORE EDITION CHECK");
+                }
+                (operands, vec![])
+            }
+            _ => (vec![], vec![]),
+        };
+        Ok(alter_object("DATABASE", head, action, parts))
+    }
+
+    /// Parse the change after `UPDATE LINKED_CATALOG`.
+    fn parse_linked_catalog_update(&mut self, action: &mut String) -> Result<Parts> {
+        let change = self.expect_alter_words(&[&["ADD"], &["REMOVE"], &["SET"], &["UNSET"]])?;
+        action.push(' ');
+        action.push_str(&change);
+        let namespaces: &[&[&str]] = &[&["ALLOWED_NAMESPACES"], &["BLOCKED_NAMESPACES"]];
+        match change.as_str() {
+            "ADD" | "REMOVE" => {
+                let list = self.parse_string_list()?;
+                let word = if change == "ADD" { "TO" } else { "FROM" };
+                self.expect_alter_words(&[&[word]])?;
+                let target = self.expect_alter_words(namespaces)?;
+                action.push_str(&format!(" {word} {target}"));
+                Ok((vec![list], vec![]))
+            }
+            "SET" => {
+                let name = self.expect_alter_words(&[
+                    &["ALLOWED_WRITE_OPERATIONS"],
+                    &["SYNC_INTERVAL_SECONDS"],
+                ])?;
+                self.expect_token(TokenType::Eq)?;
+                let value = if name == "SYNC_INTERVAL_SECONDS" {
+                    self.parse_object_value()?
+                } else {
+                    let mode = self.expect_alter_words(&[&["NONE"], &["ALL"]])?;
+                    Expression::Identifier(Identifier::new(mode))
+                };
+                Ok((vec![], vec![property(&name, None, Some(value))]))
+            }
+            _ => {
+                let target = self.expect_alter_words(namespaces)?;
+                action.push_str(&format!(" {target}"));
+                Ok((vec![], vec![]))
+            }
+        }
+    }
+
+    /// Parse ALTER APPLICATION after its kind.
+    fn parse_alter_application(&mut self) -> Result<Expression> {
+        if let Some(action) = [
+            ["SET", "SPECIFICATION"].as_slice(),
+            &["DROP", "SPECIFICATION"],
+            &["SET", "CONFIGURATION", "DEFINITION"],
+            &["DROP", "CONFIGURATION", "DEFINITION"],
+        ]
+        .into_iter()
+        .find(|words| self.check_text_seq(words))
+        {
+            self.current += action.len();
+            let name = self.object_operand()?;
+            let properties = if action[0] == "SET" {
+                self.parse_alter_settings(true)?
+            } else {
+                vec![]
+            };
+            let head = (TableRef::new(""), false);
+            return Ok(alter_object(
+                "APPLICATION",
+                head,
+                action.join(" "),
+                (vec![name], properties),
+            ));
+        }
+        let head = self.parse_alter_object_head()?;
+        let mut action = self.expect_alter_words(&[
+            &["RENAME"],
+            &["SET", "FEATURE", "POLICY"],
+            &["SET", "MAINTENANCE", "POLICY"],
+            &["SET", "SHARED", "TELEMETRY", "EVENTS"],
+            &["SET", "CONFIGURATION"],
+            &["UNSET", "FEATURE", "POLICY"],
+            &["UNSET", "MAINTENANCE", "POLICY"],
+            &["UNSET", "REFERENCES"],
+            &["UNSET", "CONFIGURATION"],
+            &["SET"],
+            &["UNSET"],
+            &["UPGRADE"],
+            &["APPROVE", "SPECIFICATION"],
+            &["DECLINE", "SPECIFICATION"],
+        ])?;
+        let parts = match action.as_str() {
+            "RENAME" => self.parse_alter_target("TO")?,
+            "SET FEATURE POLICY" | "SET MAINTENANCE POLICY" => {
+                self.parse_alter_policy(&mut action)?
+            }
+            "SET SHARED TELEMETRY EVENTS" => (vec![self.parse_string_list()?], vec![]),
+            "SET CONFIGURATION" => {
+                let name = self.object_operand()?;
+                (vec![name], vec![self.parse_required_option("VALUE")?])
+            }
+            "UNSET CONFIGURATION" => (vec![self.object_operand()?], vec![]),
+            "UNSET REFERENCES" => {
+                if self.check(TokenType::LParen) {
+                    (vec![self.parse_string_list()?], vec![])
+                } else {
+                    (vec![], vec![])
+                }
+            }
+            "SET" => self.parse_alter_set(true)?,
+            "UNSET" => self.parse_alter_set(false)?,
+            "UPGRADE" => {
+                if self.match_text_seq(&["USING", "VERSION"]) {
+                    action.push_str(" USING VERSION");
+                    let mut operands = vec![self.object_operand()?];
+                    if self.match_text_seq(&["PATCH"]) {
+                        action.push_str(" PATCH");
+                        operands.push(self.number_operand()?);
+                    }
+                    (operands, vec![])
+                } else if self.match_text_seq(&["USING"]) {
+                    action.push_str(" USING");
+                    (vec![self.parse_string_value()?], vec![])
+                } else {
+                    (vec![], vec![])
+                }
+            }
+            "APPROVE SPECIFICATION" | "DECLINE SPECIFICATION" => {
+                let name = self.object_operand()?;
+                (
+                    vec![name],
+                    vec![self.parse_required_option("SEQUENCE_NUMBER")?],
+                )
+            }
+            _ => (vec![], vec![]),
+        };
+        Ok(alter_object("APPLICATION", head, action, parts))
+    }
+
+    /// Parse ALTER APPLICATION PACKAGE after its kind.
+    fn parse_alter_application_package(&mut self) -> Result<Expression> {
+        let head = self.parse_alter_object_head()?;
+        let mut action = self.expect_alter_words(&[
+            &["RENAME"],
+            &["ADD", "VERSION"],
+            &["REGISTER", "VERSION"],
+            &["DEREGISTER", "VERSION"],
+            &["DROP", "VERSION"],
+            &["ADD", "PATCH"],
+            &["MODIFY", "RELEASE", "CHANNEL"],
+            &["MODIFY", "RELEASE", "DIRECTIVE"],
+            &["SET", "DEFAULT", "RELEASE", "DIRECTIVE"],
+            &["SET", "RELEASE", "DIRECTIVE"],
+            &["UNSET", "RELEASE", "DIRECTIVE"],
+            &["SET"],
+            &["UNSET"],
+        ])?;
+        let parts = match action.as_str() {
+            "RENAME" => self.parse_alter_target("TO")?,
+            "ADD VERSION" | "REGISTER VERSION" => {
+                let mut operands = Vec::new();
+                if !self.check_text_seq(&["USING"]) {
+                    operands.push(self.object_operand()?);
+                }
+                self.parse_version_source(operands)?
+            }
+            "ADD PATCH" => {
+                let mut operands = Vec::new();
+                if self.check(TokenType::Number) {
+                    operands.push(self.number_operand()?);
+                }
+                self.expect_alter_words(&[&["FOR", "VERSION"]])?;
+                if !self.check_text_seq(&["USING"]) {
+                    operands.push(self.object_operand()?);
+                }
+                self.parse_version_source(operands)?
+            }
+            "DEREGISTER VERSION" | "DROP VERSION" => (vec![self.object_operand()?], vec![]),
+            "MODIFY RELEASE CHANNEL" => {
+                let channel = self.object_operand()?;
+                let change = self.expect_alter_words(&[
+                    &["ADD", "VERSION"],
+                    &["DROP", "VERSION"],
+                    &["ADD", "ACCOUNTS"],
+                    &["REMOVE", "ACCOUNTS"],
+                    &["SET", "ACCOUNTS"],
+                    &["MODIFY", "RELEASE", "DIRECTIVE"],
+                    &["SET", "DEFAULT", "RELEASE", "DIRECTIVE"],
+                    &["SET", "RELEASE", "DIRECTIVE"],
+                    &["UNSET", "RELEASE", "DIRECTIVE"],
+                ])?;
+                action.push_str(&format!(" {change}"));
+                let (mut operands, properties) = match change.as_str() {
+                    "ADD VERSION" | "DROP VERSION" => (vec![self.object_operand()?], vec![]),
+                    "ADD ACCOUNTS" | "REMOVE ACCOUNTS" | "SET ACCOUNTS" => {
+                        self.expect_token(TokenType::Eq)?;
+                        (vec![self.parse_account_list()?], vec![])
+                    }
+                    _ => self.parse_release_directive(&change, &mut action)?,
+                };
+                operands.insert(0, channel);
+                (operands, properties)
+            }
+            _ if action.contains("RELEASE DIRECTIVE") => {
+                let change = action.clone();
+                self.parse_release_directive(&change, &mut action)?
+            }
+            "SET" => self.parse_alter_set(true)?,
+            _ => self.parse_alter_set(false)?,
+        };
+        Ok(alter_object("APPLICATION PACKAGE", head, action, parts))
+    }
+
+    /// Parse `USING <path> [ LABEL = '<label>' ]` after a version or patch.
+    fn parse_version_source(&mut self, mut operands: Vec<Expression>) -> Result<Parts> {
+        self.expect_alter_words(&[&["USING"]])?;
+        operands.push(self.parse_string_value()?);
+        let mut properties = Vec::new();
+        if self.match_text_seq(&["LABEL"]) {
+            self.expect_token(TokenType::Eq)?;
+            properties.push(property("LABEL", None, Some(self.parse_string_value()?)));
+        }
+        Ok((operands, properties))
+    }
+
+    /// Parse the rest of a release directive change named by `change`.
+    fn parse_release_directive(&mut self, change: &str, action: &mut String) -> Result<Parts> {
+        let mut operands = Vec::new();
+        let mut properties = Vec::new();
+        if change != "SET DEFAULT RELEASE DIRECTIVE" {
+            operands.push(self.object_operand()?);
+        }
+        if change.starts_with("UNSET") {
+            return Ok((operands, properties));
+        }
+        let mut version_required = true;
+        let accounts = if change.starts_with("SET RELEASE") {
+            self.expect_alter_words(&[&["ACCOUNTS"]])?;
+            true
+        } else if change.starts_with("MODIFY") {
+            match self.match_one_of(&["ADD", "REMOVE"]) {
+                Some(word) => {
+                    self.expect_alter_words(&[&["ACCOUNTS"]])?;
+                    action.push_str(&format!(" {word} ACCOUNTS"));
+                    version_required = false;
+                    true
+                }
+                None => false,
+            }
+        } else {
+            false
+        };
+        if accounts {
+            self.expect_token(TokenType::Eq)?;
+            properties.push(property("ACCOUNTS", None, Some(self.parse_account_list()?)));
+        }
+        if version_required || self.check_text_seq(&["VERSION"]) {
+            properties.push(self.parse_required_option("VERSION")?);
+            properties.push(self.parse_required_option("PATCH")?);
+        }
+        if version_required {
+            properties.extend(self.parse_named_options(UPGRADE_OPTIONS)?);
+        }
+        if !action.contains("REMOVE") && self.match_text_seq(&["FORCE"]) {
+            action.push_str(" FORCE");
+        }
+        Ok((operands, properties))
+    }
+
+    /// Parse ALTER APPLICATION SERVICE after its kind.
+    fn parse_alter_application_service(&mut self) -> Result<Expression> {
+        let head = self.parse_alter_object_head()?;
+        let mut action = self.expect_alter_words(&[
+            &["SET"],
+            &["UNSET"],
+            &["SUSPEND"],
+            &["RESUME"],
+            &["UPGRADE"],
+        ])?;
+        let parts = match action.as_str() {
+            "SET" => self.parse_alter_set(true)?,
+            "UNSET" => self.parse_alter_set(false)?,
+            "UPGRADE" if self.match_text_seq(&["TO", "VERSION"]) => {
+                action.push_str(" TO VERSION");
+                (vec![self.object_operand()?], vec![])
+            }
+            _ => (vec![], vec![]),
+        };
+        Ok(alter_object("APPLICATION SERVICE", head, action, parts))
+    }
+
+    /// Parse ALTER BACKUP SET after its kind.
+    fn parse_alter_backup_set(&mut self) -> Result<Expression> {
+        let head = (self.parse_object_name()?, false);
+        let mut action = self.expect_alter_words(&[
+            &["ADD", "BACKUP"],
+            &["APPLY", "BACKUP", "POLICY"],
+            &["DELETE", "BACKUP", "IDENTIFIER"],
+            &["MODIFY", "BACKUP", "IDENTIFIER"],
+            &["RENAME"],
+            &["RESUME", "BACKUP"],
+            &["SUSPEND", "BACKUP"],
+            &["SET", "COMMENT"],
+            &["UNSET", "COMMENT"],
+            &["SET", "TAG"],
+            &["UNSET", "TAG"],
+        ])?;
+        let parts = match action.as_str() {
+            "APPLY BACKUP POLICY" => self.parse_alter_policy(&mut action)?,
+            "DELETE BACKUP IDENTIFIER" => (vec![self.parse_string_value()?], vec![]),
+            "MODIFY BACKUP IDENTIFIER" => {
+                let id = self.parse_string_value()?;
+                let change = self.expect_alter_words(&[
+                    &["ADD", "LEGAL", "HOLD"],
+                    &["REMOVE", "LEGAL", "HOLD"],
+                    &["SET", "COMMENT"],
+                    &["UNSET", "COMMENT"],
+                ])?;
+                action.push_str(&format!(" {change}"));
+                let mut properties = Vec::new();
+                if change == "SET COMMENT" {
+                    self.expect_token(TokenType::Eq)?;
+                    let comment = self.parse_string_value()?;
+                    properties.push(property("COMMENT", None, Some(comment)));
+                }
+                (vec![id], properties)
+            }
+            "RENAME" => self.parse_alter_target("TO")?,
+            "RESUME BACKUP" | "SUSPEND BACKUP" => {
+                if let Some(which) = self.match_one_of(&["CREATION", "EXPIRATION"]) {
+                    action.push_str(&format!(" {which}"));
+                }
+                self.expect_alter_words(&[&["POLICY"]])?;
+                action.push_str(" POLICY");
+                (vec![], vec![])
+            }
+            "SET COMMENT" => {
+                self.expect_token(TokenType::Eq)?;
+                let comment = self.parse_string_value()?;
+                (vec![], vec![property("COMMENT", None, Some(comment))])
+            }
+            "SET TAG" | "UNSET TAG" => {
+                self.current -= 1;
+                action.truncate(action.len() - " TAG".len());
+                self.parse_alter_set(action == "SET")?
+            }
+            _ => (vec![], vec![]),
+        };
+        Ok(alter_object("BACKUP SET", head, action, parts))
+    }
+
+    /// Consume the first of `words` that comes next and return it.
+    fn match_one_of(&mut self, words: &[&str]) -> Option<String> {
+        let word = words.iter().find(|word| self.check_text_seq(&[word]))?;
+        self.skip();
+        Some((*word).to_owned())
+    }
+
+    /// Parse ALTER CORTEX SEARCH SERVICE after its kind.
+    fn parse_alter_cortex_search_service(&mut self) -> Result<Expression> {
+        let head = self.parse_alter_object_head()?;
+        let mut action = self.expect_alter_words(&[
+            &["ADD", "SCORING", "PROFILE"],
+            &["DROP", "SCORING", "PROFILE"],
+            &["REFRESH"],
+            &["SUSPEND"],
+            &["RESUME"],
+            &["SET", "ATTRIBUTES"],
+            &["UNSET", "ATTRIBUTES"],
+            &["SET"],
+            &["UNSET"],
+        ])?;
+        let parts = match action.as_str() {
+            "ADD SCORING PROFILE" => {
+                if self.match_text_seq(&["IF", "NOT", "EXISTS"]) {
+                    action.push_str(" IF NOT EXISTS");
+                }
+                let name = self.object_operand()?;
+                (vec![name, self.parse_object_value()?], vec![])
+            }
+            "DROP SCORING PROFILE" => {
+                if self.match_keywords(&[TokenType::If, TokenType::Exists]) {
+                    action.push_str(" IF EXISTS");
+                }
+                (vec![self.object_operand()?], vec![])
+            }
+            "SUSPEND" | "RESUME" => {
+                if let Some(which) = self.match_one_of(&["INDEXING", "SERVING"]) {
+                    action.push_str(&format!(" {which}"));
+                }
+                (vec![], vec![])
+            }
+            "SET ATTRIBUTES" => (vec![self.parse_name_list()?], vec![]),
+            "SET" => self.parse_alter_set(true)?,
+            "UNSET" => {
+                if !self.check_text_seq(&["PRIMARY", "KEY"])
+                    && !(self.check_text_seq(&["TAG"])
+                        && self.text_at(1).is_some_and(|text| text != ";"))
+                {
+                    return Err(self.parse_error("Expected PRIMARY KEY or TAG"));
+                }
+                self.parse_alter_set(false)?
+            }
+            _ => (vec![], vec![]),
+        };
+        Ok(alter_object("CORTEX SEARCH SERVICE", head, action, parts))
+    }
+
+    /// Parse ALTER SEMANTIC VIEW after its kind.
+    fn parse_alter_semantic_view(&mut self) -> Result<Expression> {
+        let head = self.parse_alter_object_head()?;
+        let action = self.expect_alter_words(&[
+            &["ADD", "MATERIALIZATION"],
+            &["DROP", "MATERIALIZATION"],
+            &["REFRESH", "MATERIALIZATION"],
+            &["RESUME", "MATERIALIZATION"],
+            &["SUSPEND", "MATERIALIZATION"],
+            &["RENAME"],
+            &["SET"],
+            &["UNSET"],
+        ])?;
+        let parts = match action.as_str() {
+            "ADD MATERIALIZATION" => self.parse_materialization()?,
+            "RENAME" => self.parse_alter_target("TO")?,
+            "SET" => self.parse_alter_set(true)?,
+            "UNSET" => self.parse_alter_set(false)?,
+            _ => (vec![self.object_operand()?], vec![]),
+        };
+        Ok(alter_object("SEMANTIC VIEW", head, action, parts))
+    }
+
+    /// Parse a materialization's name, options, dimensions, metrics and filter.
+    fn parse_materialization(&mut self) -> Result<Parts> {
+        let mut operands = vec![self.object_operand()?];
+        let mut properties = vec![self.parse_required_option("WAREHOUSE")?];
+        properties.extend(self.parse_named_options(&["REFRESH_MODE"])?);
+        if self.match_text_seq(&["IMMUTABLE", "WHERE"]) {
+            properties.push(property(
+                "IMMUTABLE WHERE",
+                None,
+                Some(self.parse_condition()?),
+            ));
+        }
+        self.expect_alter_words(&[&["AS", "DIMENSIONS"]])?;
+        operands.push(self.object_list_operand()?);
+        self.expect_alter_words(&[&["METRICS"]])?;
+        operands.push(self.object_list_operand()?);
+        if self.match_token(TokenType::Where) {
+            properties.push(property("WHERE", None, Some(self.parse_condition()?)));
+        }
+        Ok((operands, properties))
+    }
+
+    /// Parse a parenthesized condition.
+    fn parse_condition(&mut self) -> Result<Expression> {
+        self.expect_token(TokenType::LParen)?;
+        let condition = self.parse_expression()?;
+        self.expect_token(TokenType::RParen)?;
+        Ok(condition)
+    }
+
+    /// Parse ALTER STREAMLIT after its kind.
+    fn parse_alter_streamlit(&mut self) -> Result<Expression> {
+        let head = self.parse_alter_object_head()?;
+        let mut action = self.expect_alter_words(&[
+            &["ABORT"],
+            &["ADD", "LIVE", "VERSION", "FROM", "LAST"],
+            &["COMMIT"],
+            &["PULL"],
+            &["PUSH"],
+            &["RENAME"],
+            &["SET"],
+            &["UNSET"],
+        ])?;
+        let parts = match action.as_str() {
+            "PUSH" => {
+                let mut operands = Vec::new();
+                if self.match_text_seq(&["TO"]) {
+                    action.push_str(" TO");
+                    operands.push(self.parse_string_value()?);
+                }
+                let properties = self.parse_named_options(&[
+                    "GIT_CREDENTIALS",
+                    "USERNAME",
+                    "PASSWORD",
+                    "NAME",
+                    "EMAIL",
+                    "COMMENT",
+                ])?;
+                (operands, properties)
+            }
+            "RENAME" => self.parse_alter_target("TO")?,
+            "SET" => self.parse_alter_set(true)?,
+            "UNSET" => self.parse_alter_set(false)?,
+            _ => (vec![], vec![]),
+        };
+        Ok(alter_object("STREAMLIT", head, action, parts))
+    }
+}
+
+/// A parenthesized list of expressions.
+fn tuple(expressions: Vec<Expression>) -> Expression {
+    Expression::Tuple(Box::new(Tuple { expressions }))
+}
diff --git a/crates/sqlquack-syntax/tests/parser/test_fixes.rs b/crates/sqlquack-syntax/tests/parser/test_fixes.rs
index 45c8ea2c2..f4304243f 100644
--- a/crates/sqlquack-syntax/tests/parser/test_fixes.rs
+++ b/crates/sqlquack-syntax/tests/parser/test_fixes.rs
@@ -654,3 +654,182 @@ fn given_a_snowflake_drop_of_another_object_kind_when_parsing_then_the_tree_name
         );
     }
 }
+
+#[test]
+fn given_a_snowflake_alter_of_an_application_database_or_service_kind_when_parsing_then_it_follows_the_grammar(
+) {
+    let test_cases = [
+        AcceptanceTestCase {
+            description: "a package adds a version from a stage (recorded semantic error)",
+            sql: "ALTER APPLICATION PACKAGE v1 ADD VERSION v1 USING '@d1.s1.st1/p1' LABEL = 'm' ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "a version needs USING (recorded errno 1003)",
+            sql: "ALTER APPLICATION PACKAGE v1 ADD VERSION '@d1.s1.st1/p1' ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+        AcceptanceTestCase {
+            description: "a release directive names its accounts, version and patch",
+            sql: "ALTER APPLICATION PACKAGE v1 SET RELEASE DIRECTIVE v1 ACCOUNTS = ( o1.a1 ) VERSION = v1 PATCH = 1 ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "an unquoted reserved account name is rejected (recorded errno 1003)",
+            sql: "ALTER APPLICATION PACKAGE v1 MODIFY RELEASE CHANNEL v1 ADD ACCOUNTS = ( v1 . SELECT ) ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+        AcceptanceTestCase {
+            description: "an application upgrades from a stage (recorded semantic error)",
+            sql: "ALTER APPLICATION v1 UPGRADE USING '@d1.s1.st1/p1' ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "UPGRADE USING needs a path (recorded errno 1003)",
+            sql: "ALTER APPLICATION v1 UPGRADE USING ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+        AcceptanceTestCase {
+            description: "a database replicates to accounts and may skip the edition check",
+            sql: "ALTER DATABASE v1 ENABLE REPLICATION TO ACCOUNTS o1.a1 , o1.a2 IGNORE EDITION CHECK ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "a linked catalog writes NONE or ALL",
+            sql: "ALTER DATABASE v1 UPDATE LINKED_CATALOG SET ALLOWED_WRITE_OPERATIONS = ALL ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "a linked catalog adds namespaces to a list",
+            sql: "ALTER DATABASE IF EXISTS v1 UPDATE LINKED_CATALOG ADD ( 'n1' , 'n2' ) TO BLOCKED_NAMESPACES ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "Cortex Search unsets its primary key (recorded accepted)",
+            sql: "ALTER CORTEX SEARCH SERVICE IF EXISTS v1 UNSET PRIMARY KEY ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "PRIMARY needs KEY (recorded errno 1003)",
+            sql: "ALTER CORTEX SEARCH SERVICE v1 UNSET PRIMARY ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+        AcceptanceTestCase {
+            description: "half of CORTEX SEARCH SERVICE is no kind (recorded errno 1003)",
+            sql: "ALTER CORTEX SEARCH v1 REFRESH ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+        AcceptanceTestCase {
+            description: "BACKUP needs SET (recorded errno 1003)",
+            sql: "ALTER BACKUP v1 ADD BACKUP ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+        AcceptanceTestCase {
+            description: "a backup set takes a legal hold",
+            sql: "ALTER BACKUP SET v1 MODIFY BACKUP IDENTIFIER 'm' ADD LEGAL HOLD ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "a semantic view adds a materialization",
+            sql: "ALTER SEMANTIC VIEW v1 ADD MATERIALIZATION v1 WAREHOUSE = v1 AS DIMENSIONS v1 METRICS v1 ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "SEMANTIC needs VIEW (recorded errno 1003)",
+            sql: "ALTER SEMANTIC v1 RENAME TO v1 ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+        AcceptanceTestCase {
+            description: "a Streamlit unsets several properties",
+            sql: "ALTER STREAMLIT v1 UNSET TITLE , COMMENT ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: true,
+        },
+        AcceptanceTestCase {
+            description: "a Streamlit name is no string (recorded errno 1003)",
+            sql: "ALTER STREAMLIT 'v1' COMMIT ;",
+            dialect: Dialect::Snowflake,
+            expected_accepted: false,
+        },
+    ];
+
+    for test_case in test_cases {
+        assert_eq!(
+            accepted(test_case.sql, test_case.dialect),
+            test_case.expected_accepted,
+            "{}",
+            test_case.description
+        );
+    }
+}
+
+#[test]
+fn given_a_snowflake_alter_of_an_application_database_or_service_kind_when_parsing_then_the_tree_keeps_the_action(
+) {
+    let test_cases = [
+        ProjectionTestCase {
+            description: "the kind is named whole",
+            sql: "ALTER APPLICATION PACKAGE v1 DROP VERSION v1",
+            pointer: "/0/alter_object/kind",
+            expected_value: json!("APPLICATION PACKAGE"),
+        },
+        ProjectionTestCase {
+            description: "a release channel change keeps both levels",
+            sql: "ALTER APPLICATION PACKAGE v1 MODIFY RELEASE CHANNEL c1 DROP VERSION v1",
+            pointer: "/0/alter_object/action",
+            expected_value: json!("MODIFY RELEASE CHANNEL DROP VERSION"),
+        },
+        ProjectionTestCase {
+            description: "the edition check option is kept",
+            sql: "ALTER DATABASE v1 ENABLE REPLICATION TO ACCOUNTS o1.a1 IGNORE EDITION CHECK",
+            pointer: "/0/alter_object/action",
+            expected_value: json!("ENABLE REPLICATION IGNORE EDITION CHECK"),
+        },
+        ProjectionTestCase {
+            description: "a linked catalog change names its list",
+            sql: "ALTER DATABASE v1 UPDATE LINKED_CATALOG REMOVE ( 'n1' ) FROM ALLOWED_NAMESPACES",
+            pointer: "/0/alter_object/action",
+            expected_value: json!("UPDATE LINKED_CATALOG REMOVE FROM ALLOWED_NAMESPACES"),
+        },
+        ProjectionTestCase {
+            description: "IF EXISTS is kept",
+            sql: "ALTER STREAMLIT IF EXISTS v1 RENAME TO v2",
+            pointer: "/0/alter_object/if_exists",
+            expected_value: json!(true),
+        },
+        ProjectionTestCase {
+            description: "a suspended backup policy names which",
+            sql: "ALTER BACKUP SET v1 SUSPEND BACKUP EXPIRATION POLICY",
+            pointer: "/0/alter_object/action",
+            expected_value: json!("SUSPEND BACKUP EXPIRATION POLICY"),
+        },
+    ];
+
+    for test_case in test_cases {
+        assert_eq!(
+            statements(test_case.sql, Dialect::Snowflake, CallMode::Faithful)
+                .pointer(test_case.pointer)
+                .cloned()
+                .unwrap_or_default(),
+            test_case.expected_value,
+            "{}",
+            test_case.description
+        );
+    }
+}

From 11444b63f392a70838aa4fa0a632a8f21939c10a Mon Sep 17 00:00:00 2001
From: Kevin Longe <273747162+kvlonge@users.noreply.github.com>
Date: Wed, 4 Nov 2026 19:42:57 +0000
Subject: [PATCH 2/3] fix(syntax): follow recorded Snowflake refusals in the
 ALTER batch

A release directive's VERSION takes an identifier, a CONTACT purpose takes a
contact name, and an UNSET value is a name, not a string. APPLICATION PACKAGE
UNSET takes one property, and a database SET ends after a CONTACT list of
several purposes.
---
 .../_helpers/ddl/snowflake_alter_objects.rs   | 40 +++++++++++++++----
 1 file changed, 32 insertions(+), 8 deletions(-)

diff --git a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
index ac888d7ac..572896c50 100644
--- a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
@@ -172,6 +172,8 @@ impl Parser {
     /// Parse the properties of a SET (`set`) or UNSET: TAG and CONTACT lists, PRIMARY KEY, or named properties.
     fn parse_alter_settings(&mut self, set: bool) -> Result<Vec<ObjectProperty>> {
         let mut properties: Vec<ObjectProperty> = Vec::new();
+        // Snowflake ends the SET after a CONTACT list of several purposes.
+        let mut contact_list = false;
         loop {
             let named = self.check_next(TokenType::Eq) || self.check_next(TokenType::Comma) || {
                 let next = self.current + 1;
@@ -186,16 +188,23 @@ impl Parser {
                     } else {
                         self.parse_simple_name()?
                     };
-                    let value = if set {
-                        self.expect_token(TokenType::Eq)?;
-                        Some(self.parse_object_value()?)
-                    } else {
+                    let value = if !set {
                         None
+                    } else {
+                        self.expect_token(TokenType::Eq)?;
+                        Some(if kind == "CONTACT" {
+                            self.object_operand()?
+                        } else {
+                            self.parse_object_value()?
+                        })
                     };
                     properties.push(property(&kind, Some(name), value));
                     if !self.match_token(TokenType::Comma) {
                         break;
                     }
+                    if kind == "CONTACT" {
+                        contact_list = true;
+                    }
                 }
             } else if self.match_text_seq(&["PRIMARY", "KEY"]) {
                 let value = if set {
@@ -207,9 +216,11 @@ impl Parser {
                 properties.push(property("PRIMARY KEY", None, value));
             } else {
                 let name = self.parse_simple_name()?;
-                let value = if set || self.check(TokenType::Eq) {
+                let value = if set {
                     self.expect_token(TokenType::Eq)?;
                     Some(self.parse_alter_value()?)
+                } else if self.match_token(TokenType::Eq) {
+                    Some(self.object_operand()?)
                 } else {
                     None
                 };
@@ -219,6 +230,9 @@ impl Parser {
             if self.is_at_end() || self.check(TokenType::Semicolon) || !set && !comma {
                 return Ok(properties);
             }
+            if contact_list {
+                return Err(self.parse_error("Expected the end of the statement after CONTACT"));
+            }
         }
     }
 
@@ -478,7 +492,13 @@ impl Parser {
                 self.parse_release_directive(&change, &mut action)?
             }
             "SET" => self.parse_alter_set(true)?,
-            _ => self.parse_alter_set(false)?,
+            _ => {
+                let parts = self.parse_alter_set(false)?;
+                if parts.1.len() > 1 && parts.1.iter().any(|p| p.kind != "TAG") {
+                    return Err(self.parse_error("Snowflake unsets one package property at a time"));
+                }
+                parts
+            }
         };
         Ok(alter_object("APPLICATION PACKAGE", head, action, parts))
     }
@@ -527,8 +547,12 @@ impl Parser {
             properties.push(property("ACCOUNTS", None, Some(self.parse_account_list()?)));
         }
         if version_required || self.check_text_seq(&["VERSION"]) {
-            properties.push(self.parse_required_option("VERSION")?);
-            properties.push(self.parse_required_option("PATCH")?);
+            self.expect_alter_words(&[&["VERSION"]])?;
+            self.expect_token(TokenType::Eq)?;
+            properties.push(property("VERSION", None, Some(self.object_operand()?)));
+            self.expect_alter_words(&[&["PATCH"]])?;
+            self.expect_token(TokenType::Eq)?;
+            properties.push(property("PATCH", None, Some(self.number_operand()?)));
         }
         if version_required {
             properties.extend(self.parse_named_options(UPGRADE_OPTIONS)?);

From ecd1e64498ded1ea6b9388a1401b8c71a965e9cb Mon Sep 17 00:00:00 2001
From: Kevin Longe <273747162+kvlonge@users.noreply.github.com>
Date: Wed, 4 Nov 2026 20:17:30 +0000
Subject: [PATCH 3/3] style(syntax): meet the fensu rules in the ALTER batch
 helpers

Typed Vec bindings, named TAG/CONTACT constants, matches! or match for literal decisions, helpers that return the action suffix instead of mutating it, and a one-line module summary. Parsing is unchanged: the coverage family and diff output are byte-identical.
---
 .../parser/_helpers/ddl/snowflake_alter.rs    |   1 -
 .../_helpers/ddl/snowflake_alter_objects.rs   | 147 +++++++++++-------
 .../sqlquack-syntax/src/parser/constants.rs   |   6 +
 3 files changed, 95 insertions(+), 59 deletions(-)

diff --git a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
index b7fe1f2a2..dcb8a1fed 100644
--- a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
@@ -1,5 +1,4 @@
 //! Snowflake ALTER of object kinds with no statement of their own: EXPERIMENT, SNAPSHOT, SNAPSHOT SET, TAG, TASK and TASK GRAPH.
-//! The application, backup, Cortex Search, database, semantic view and Streamlit kinds are in `snowflake_alter_objects`.
 
 use crate::expressions::names::models::Identifier;
 use crate::expressions::names::models::TableRef;
diff --git a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
index 572896c50..3e051aae8 100644
--- a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
@@ -7,6 +7,8 @@ use crate::expressions::tree::models::Expression;
 use crate::expressions::types::models::Tuple;
 use crate::parser::_helpers::ddl::snowflake_alter::alter_object;
 use crate::parser::_helpers::ddl::snowflake_alter::property;
+use crate::parser::constants::CONTACT;
+use crate::parser::constants::TAG;
 use crate::parser::models::Parser;
 use crate::tokens::models::TokenType;
 use crate::tokens::types::Result;
@@ -108,7 +110,7 @@ impl Parser {
     /// Parse a property value: a parenthesized list, NULL, a literal or a name.
     fn parse_alter_value(&mut self) -> Result<Expression> {
         if self.match_token(TokenType::LParen) {
-            let mut items = Vec::new();
+            let mut items: Vec<Expression> = Vec::new();
             loop {
                 let item = self.parse_object_value()?;
                 if self.match_token(TokenType::Eq) {
@@ -150,7 +152,7 @@ impl Parser {
 
     /// Parse `<name> = <value>` for each name of `names` that comes next, in any order.
     fn parse_named_options(&mut self, names: &[&str]) -> Result<Vec<ObjectProperty>> {
-        let mut properties = Vec::new();
+        let mut properties: Vec<ObjectProperty> = Vec::new();
         while let Some(name) = names
             .iter()
             .find(|name| self.check_text_seq(&[name]) && self.check_next(TokenType::Eq))
@@ -172,8 +174,7 @@ impl Parser {
     /// Parse the properties of a SET (`set`) or UNSET: TAG and CONTACT lists, PRIMARY KEY, or named properties.
     fn parse_alter_settings(&mut self, set: bool) -> Result<Vec<ObjectProperty>> {
         let mut properties: Vec<ObjectProperty> = Vec::new();
-        // Snowflake ends the SET after a CONTACT list of several purposes.
-        let mut contact_list = false;
+        let mut contact_list_ends_set = false;
         loop {
             let named = self.check_next(TokenType::Eq) || self.check_next(TokenType::Comma) || {
                 let next = self.current + 1;
@@ -183,7 +184,7 @@ impl Parser {
                 let kind = self.peek_text().to_ascii_uppercase();
                 self.skip();
                 loop {
-                    let name = if kind == "TAG" {
+                    let name = if kind == TAG {
                         self.parse_simple_qualified_name()?
                     } else {
                         self.parse_simple_name()?
@@ -192,7 +193,7 @@ impl Parser {
                         None
                     } else {
                         self.expect_token(TokenType::Eq)?;
-                        Some(if kind == "CONTACT" {
+                        Some(if kind == CONTACT {
                             self.object_operand()?
                         } else {
                             self.parse_object_value()?
@@ -202,8 +203,8 @@ impl Parser {
                     if !self.match_token(TokenType::Comma) {
                         break;
                     }
-                    if kind == "CONTACT" {
-                        contact_list = true;
+                    if kind == CONTACT {
+                        contact_list_ends_set = true;
                     }
                 }
             } else if self.match_text_seq(&["PRIMARY", "KEY"]) {
@@ -230,7 +231,7 @@ impl Parser {
             if self.is_at_end() || self.check(TokenType::Semicolon) || !set && !comma {
                 return Ok(properties);
             }
-            if contact_list {
+            if contact_list_ends_set {
                 return Err(self.parse_error("Expected the end of the statement after CONTACT"));
             }
         }
@@ -241,13 +242,15 @@ impl Parser {
         Ok((vec![], self.parse_alter_settings(set)?))
     }
 
-    /// Parse `<policy_name> [ FORCE ]` after `{ FEATURE | MAINTENANCE | BACKUP } POLICY`.
-    fn parse_alter_policy(&mut self, action: &mut String) -> Result<Parts> {
+    /// Parse `<policy_name> [ FORCE ]` after `{ FEATURE | MAINTENANCE | BACKUP } POLICY`, with the action's suffix.
+    fn parse_alter_policy(&mut self) -> Result<(Parts, String)> {
         let policy = self.object_operand()?;
-        if self.match_text_seq(&["FORCE"]) {
-            action.push_str(" FORCE");
-        }
-        Ok((vec![policy], vec![]))
+        let suffix = if self.match_text_seq(&["FORCE"]) {
+            " FORCE"
+        } else {
+            ""
+        };
+        Ok(((vec![policy], vec![]), suffix.to_owned()))
     }
 
     /// Parse ALTER DATABASE after its kind.
@@ -273,17 +276,25 @@ impl Parser {
         let parts = match action.as_str() {
             "RENAME" => self.parse_alter_target("TO")?,
             "SWAP" => self.parse_alter_target("WITH")?,
-            "SET FEATURE POLICY" => self.parse_alter_policy(&mut action)?,
+            "SET FEATURE POLICY" => {
+                let (parts, suffix) = self.parse_alter_policy()?;
+                action.push_str(&suffix);
+                parts
+            }
             "SET" => self.parse_alter_set(true)?,
             "UNSET" => self.parse_alter_set(false)?,
-            "UPDATE LINKED_CATALOG" => self.parse_linked_catalog_update(&mut action)?,
+            "UPDATE LINKED_CATALOG" => {
+                let (parts, suffix) = self.parse_linked_catalog_update()?;
+                action.push_str(&suffix);
+                parts
+            }
             _ if action.starts_with("ENABLE") || action.starts_with("DISABLE") => {
-                let mut operands = Vec::new();
+                let mut operands: Vec<Expression> = Vec::new();
                 if action.starts_with("ENABLE") || self.check_text_seq(&["TO"]) {
                     self.expect_alter_words(&[&["TO", "ACCOUNTS"]])?;
                     operands.push(self.account_list_operand()?);
                 }
-                if action == "ENABLE REPLICATION"
+                if matches!(action.as_str(), "ENABLE REPLICATION")
                     && self.match_text_seq(&["IGNORE", "EDITION", "CHECK"])
                 {
                     action.push_str(" IGNORE EDITION CHECK");
@@ -295,20 +306,22 @@ impl Parser {
         Ok(alter_object("DATABASE", head, action, parts))
     }
 
-    /// Parse the change after `UPDATE LINKED_CATALOG`.
-    fn parse_linked_catalog_update(&mut self, action: &mut String) -> Result<Parts> {
+    /// Parse the change after `UPDATE LINKED_CATALOG`, with the action's suffix.
+    fn parse_linked_catalog_update(&mut self) -> Result<(Parts, String)> {
         let change = self.expect_alter_words(&[&["ADD"], &["REMOVE"], &["SET"], &["UNSET"]])?;
-        action.push(' ');
-        action.push_str(&change);
+        let mut suffix: String = format!(" {change}");
         let namespaces: &[&[&str]] = &[&["ALLOWED_NAMESPACES"], &["BLOCKED_NAMESPACES"]];
         match change.as_str() {
             "ADD" | "REMOVE" => {
                 let list = self.parse_string_list()?;
-                let word = if change == "ADD" { "TO" } else { "FROM" };
+                let word = match change.as_str() {
+                    "ADD" => "TO",
+                    _ => "FROM",
+                };
                 self.expect_alter_words(&[&[word]])?;
                 let target = self.expect_alter_words(namespaces)?;
-                action.push_str(&format!(" {word} {target}"));
-                Ok((vec![list], vec![]))
+                suffix.push_str(&format!(" {word} {target}"));
+                Ok(((vec![list], vec![]), suffix))
             }
             "SET" => {
                 let name = self.expect_alter_words(&[
@@ -316,18 +329,19 @@ impl Parser {
                     &["SYNC_INTERVAL_SECONDS"],
                 ])?;
                 self.expect_token(TokenType::Eq)?;
-                let value = if name == "SYNC_INTERVAL_SECONDS" {
-                    self.parse_object_value()?
-                } else {
-                    let mode = self.expect_alter_words(&[&["NONE"], &["ALL"]])?;
-                    Expression::Identifier(Identifier::new(mode))
+                let value = match name.as_str() {
+                    "SYNC_INTERVAL_SECONDS" => self.parse_object_value()?,
+                    _ => {
+                        let mode = self.expect_alter_words(&[&["NONE"], &["ALL"]])?;
+                        Expression::Identifier(Identifier::new(mode))
+                    }
                 };
-                Ok((vec![], vec![property(&name, None, Some(value))]))
+                Ok(((vec![], vec![property(&name, None, Some(value))]), suffix))
             }
             _ => {
                 let target = self.expect_alter_words(namespaces)?;
-                action.push_str(&format!(" {target}"));
-                Ok((vec![], vec![]))
+                suffix.push_str(&format!(" {target}"));
+                Ok(((vec![], vec![]), suffix))
             }
         }
     }
@@ -345,7 +359,7 @@ impl Parser {
         {
             self.current += action.len();
             let name = self.object_operand()?;
-            let properties = if action[0] == "SET" {
+            let properties = if matches!(action[0], "SET") {
                 self.parse_alter_settings(true)?
             } else {
                 vec![]
@@ -378,7 +392,9 @@ impl Parser {
         let parts = match action.as_str() {
             "RENAME" => self.parse_alter_target("TO")?,
             "SET FEATURE POLICY" | "SET MAINTENANCE POLICY" => {
-                self.parse_alter_policy(&mut action)?
+                let (parts, suffix) = self.parse_alter_policy()?;
+                action.push_str(&suffix);
+                parts
             }
             "SET SHARED TELEMETRY EVENTS" => (vec![self.parse_string_list()?], vec![]),
             "SET CONFIGURATION" => {
@@ -444,14 +460,14 @@ impl Parser {
         let parts = match action.as_str() {
             "RENAME" => self.parse_alter_target("TO")?,
             "ADD VERSION" | "REGISTER VERSION" => {
-                let mut operands = Vec::new();
+                let mut operands: Vec<Expression> = Vec::new();
                 if !self.check_text_seq(&["USING"]) {
                     operands.push(self.object_operand()?);
                 }
                 self.parse_version_source(operands)?
             }
             "ADD PATCH" => {
-                let mut operands = Vec::new();
+                let mut operands: Vec<Expression> = Vec::new();
                 if self.check(TokenType::Number) {
                     operands.push(self.number_operand()?);
                 }
@@ -482,19 +498,25 @@ impl Parser {
                         self.expect_token(TokenType::Eq)?;
                         (vec![self.parse_account_list()?], vec![])
                     }
-                    _ => self.parse_release_directive(&change, &mut action)?,
+                    _ => {
+                        let (parts, suffix) = self.parse_release_directive(&change, &action)?;
+                        action.push_str(&suffix);
+                        parts
+                    }
                 };
                 operands.insert(0, channel);
                 (operands, properties)
             }
             _ if action.contains("RELEASE DIRECTIVE") => {
                 let change = action.clone();
-                self.parse_release_directive(&change, &mut action)?
+                let (parts, suffix) = self.parse_release_directive(&change, &change)?;
+                action.push_str(&suffix);
+                parts
             }
             "SET" => self.parse_alter_set(true)?,
             _ => {
                 let parts = self.parse_alter_set(false)?;
-                if parts.1.len() > 1 && parts.1.iter().any(|p| p.kind != "TAG") {
+                if parts.1.len() > 1 && parts.1.iter().any(|p| p.kind != TAG) {
                     return Err(self.parse_error("Snowflake unsets one package property at a time"));
                 }
                 parts
@@ -507,7 +529,7 @@ impl Parser {
     fn parse_version_source(&mut self, mut operands: Vec<Expression>) -> Result<Parts> {
         self.expect_alter_words(&[&["USING"]])?;
         operands.push(self.parse_string_value()?);
-        let mut properties = Vec::new();
+        let mut properties: Vec<ObjectProperty> = Vec::new();
         if self.match_text_seq(&["LABEL"]) {
             self.expect_token(TokenType::Eq)?;
             properties.push(property("LABEL", None, Some(self.parse_string_value()?)));
@@ -515,15 +537,16 @@ impl Parser {
         Ok((operands, properties))
     }
 
-    /// Parse the rest of a release directive change named by `change`.
-    fn parse_release_directive(&mut self, change: &str, action: &mut String) -> Result<Parts> {
-        let mut operands = Vec::new();
-        let mut properties = Vec::new();
-        if change != "SET DEFAULT RELEASE DIRECTIVE" {
+    /// Parse the rest of a release directive change named by `change`, with the action's suffix.
+    fn parse_release_directive(&mut self, change: &str, action: &str) -> Result<(Parts, String)> {
+        let mut suffix: String = String::new();
+        let mut operands: Vec<Expression> = Vec::new();
+        let mut properties: Vec<ObjectProperty> = Vec::new();
+        if !matches!(change, "SET DEFAULT RELEASE DIRECTIVE") {
             operands.push(self.object_operand()?);
         }
         if change.starts_with("UNSET") {
-            return Ok((operands, properties));
+            return Ok(((operands, properties), suffix));
         }
         let mut version_required = true;
         let accounts = if change.starts_with("SET RELEASE") {
@@ -533,7 +556,7 @@ impl Parser {
             match self.match_one_of(&["ADD", "REMOVE"]) {
                 Some(word) => {
                     self.expect_alter_words(&[&["ACCOUNTS"]])?;
-                    action.push_str(&format!(" {word} ACCOUNTS"));
+                    suffix.push_str(&format!(" {word} ACCOUNTS"));
                     version_required = false;
                     true
                 }
@@ -557,10 +580,13 @@ impl Parser {
         if version_required {
             properties.extend(self.parse_named_options(UPGRADE_OPTIONS)?);
         }
-        if !action.contains("REMOVE") && self.match_text_seq(&["FORCE"]) {
-            action.push_str(" FORCE");
+        if !action.contains("REMOVE")
+            && !suffix.contains("REMOVE")
+            && self.match_text_seq(&["FORCE"])
+        {
+            suffix.push_str(" FORCE");
         }
-        Ok((operands, properties))
+        Ok(((operands, properties), suffix))
     }
 
     /// Parse ALTER APPLICATION SERVICE after its kind.
@@ -602,7 +628,11 @@ impl Parser {
             &["UNSET", "TAG"],
         ])?;
         let parts = match action.as_str() {
-            "APPLY BACKUP POLICY" => self.parse_alter_policy(&mut action)?,
+            "APPLY BACKUP POLICY" => {
+                let (parts, suffix) = self.parse_alter_policy()?;
+                action.push_str(&suffix);
+                parts
+            }
             "DELETE BACKUP IDENTIFIER" => (vec![self.parse_string_value()?], vec![]),
             "MODIFY BACKUP IDENTIFIER" => {
                 let id = self.parse_string_value()?;
@@ -613,8 +643,8 @@ impl Parser {
                     &["UNSET", "COMMENT"],
                 ])?;
                 action.push_str(&format!(" {change}"));
-                let mut properties = Vec::new();
-                if change == "SET COMMENT" {
+                let mut properties: Vec<ObjectProperty> = Vec::new();
+                if matches!(change.as_str(), "SET COMMENT") {
                     self.expect_token(TokenType::Eq)?;
                     let comment = self.parse_string_value()?;
                     properties.push(property("COMMENT", None, Some(comment)));
@@ -638,7 +668,7 @@ impl Parser {
             "SET TAG" | "UNSET TAG" => {
                 self.current -= 1;
                 action.truncate(action.len() - " TAG".len());
-                self.parse_alter_set(action == "SET")?
+                self.parse_alter_set(matches!(action.as_str(), "SET"))?
             }
             _ => (vec![], vec![]),
         };
@@ -691,7 +721,8 @@ impl Parser {
             "UNSET" => {
                 if !self.check_text_seq(&["PRIMARY", "KEY"])
                     && !(self.check_text_seq(&["TAG"])
-                        && self.text_at(1).is_some_and(|text| text != ";"))
+                        && self.text_at(1).is_some()
+                        && !self.check_next(TokenType::Semicolon))
                 {
                     return Err(self.parse_error("Expected PRIMARY KEY or TAG"));
                 }
@@ -770,7 +801,7 @@ impl Parser {
         ])?;
         let parts = match action.as_str() {
             "PUSH" => {
-                let mut operands = Vec::new();
+                let mut operands: Vec<Expression> = Vec::new();
                 if self.match_text_seq(&["TO"]) {
                     action.push_str(" TO");
                     operands.push(self.parse_string_value()?);
diff --git a/crates/sqlquack-syntax/src/parser/constants.rs b/crates/sqlquack-syntax/src/parser/constants.rs
index 38fbd750d..61ee8328d 100644
--- a/crates/sqlquack-syntax/src/parser/constants.rs
+++ b/crates/sqlquack-syntax/src/parser/constants.rs
@@ -36,6 +36,9 @@ pub(crate) const COLUMNS: &str = "COLUMNS";
 /// The text "COMPOUND", as comparisons test it.
 pub(crate) const COMPOUND: &str = "COMPOUND";
 
+/// The text "CONTACT", as comparisons test it.
+pub(crate) const CONTACT: &str = "CONTACT";
+
 /// The text "DEFINER", as comparisons test it.
 pub(crate) const DEFINER: &str = "DEFINER";
 
@@ -141,6 +144,9 @@ pub(crate) const STATUS: &str = "STATUS";
 /// The text "STRUCT", as comparisons test it.
 pub(crate) const STRUCT: &str = "STRUCT";
 
+/// The text "TAG", as comparisons test it.
+pub(crate) const TAG: &str = "TAG";
+
 /// The text "TIME_TO_TIME_STR", as comparisons test it.
 pub(crate) const TIME_TO_TIME_STR: &str = "TIME_TO_TIME_STR";