diff --git a/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs b/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs
index bcc1c2284..21543329a 100644
--- a/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/mod.rs
@@ -8,5 +8,6 @@ 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 snowflake_alter_resources;
 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 f92b640db..e650afc10 100644
--- a/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter.rs
@@ -15,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
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..3e051aae8
--- /dev/null
+++ b/crates/sqlquack-syntax/src/parser/_helpers/ddl/snowflake_alter_objects.rs
@@ -0,0 +1,831 @@
+//! 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::constants::CONTACT;
+use crate::parser::constants::TAG;
+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<Expression> = 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<ObjectProperty> = 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();
+        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;
+                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 {
+                        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_ends_set = true;
+                    }
+                }
+            } 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.expect_token(TokenType::Eq)?;
+                    Some(self.parse_alter_value()?)
+                } else if self.match_token(TokenType::Eq) {
+                    Some(self.object_operand()?)
+                } 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);
+            }
+            if contact_list_ends_set {
+                return Err(self.parse_error("Expected the end of the statement after CONTACT"));
+            }
+        }
+    }
+
+    /// 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`, with the action's suffix.
+    fn parse_alter_policy(&mut self) -> Result<(Parts, String)> {
+        let policy = self.object_operand()?;
+        let suffix = if self.match_text_seq(&["FORCE"]) {
+            " FORCE"
+        } else {
+            ""
+        };
+        Ok(((vec![policy], vec![]), suffix.to_owned()))
+    }
+
+    /// 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" => {
+                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" => {
+                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<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 matches!(action.as_str(), "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`, 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"]])?;
+        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 = match change.as_str() {
+                    "ADD" => "TO",
+                    _ => "FROM",
+                };
+                self.expect_alter_words(&[&[word]])?;
+                let target = self.expect_alter_words(namespaces)?;
+                suffix.push_str(&format!(" {word} {target}"));
+                Ok(((vec![list], vec![]), suffix))
+            }
+            "SET" => {
+                let name = self.expect_alter_words(&[
+                    &["ALLOWED_WRITE_OPERATIONS"],
+                    &["SYNC_INTERVAL_SECONDS"],
+                ])?;
+                self.expect_token(TokenType::Eq)?;
+                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))]), suffix))
+            }
+            _ => {
+                let target = self.expect_alter_words(namespaces)?;
+                suffix.push_str(&format!(" {target}"));
+                Ok(((vec![], vec![]), suffix))
+            }
+        }
+    }
+
+    /// 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 matches!(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" => {
+                let (parts, suffix) = self.parse_alter_policy()?;
+                action.push_str(&suffix);
+                parts
+            }
+            "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<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<Expression> = 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![])
+                    }
+                    _ => {
+                        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();
+                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) {
+                    return Err(self.parse_error("Snowflake unsets one package property at a time"));
+                }
+                parts
+            }
+        };
+        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<ObjectProperty> = 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`, 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), suffix));
+        }
+        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"]])?;
+                    suffix.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"]) {
+            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)?);
+        }
+        if !action.contains("REMOVE")
+            && !suffix.contains("REMOVE")
+            && self.match_text_seq(&["FORCE"])
+        {
+            suffix.push_str(" FORCE");
+        }
+        Ok(((operands, properties), suffix))
+    }
+
+    /// 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" => {
+                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()?;
+                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<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)));
+                }
+                (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(matches!(action.as_str(), "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()
+                        && !self.check_next(TokenType::Semicolon))
+                {
+                    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<Expression> = 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/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";
 
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
+        );
+    }
+}