localstack
diff --git a/‎src/ast/mod.rs‎
Lines changed: 44 additions & 0 deletions b/‎src/ast/mod.rs‎
Lines changed: 44 additions & 0 deletions
diff --git a/‎src/ast/spans.rs‎
Lines changed: 2 additions & 0 deletions b/‎src/ast/spans.rs‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎src/dialect/snowflake.rs‎
Lines changed: 35 additions & 0 deletions b/‎src/dialect/snowflake.rs‎
Lines changed: 35 additions & 0 deletions
diff --git a/‎src/parser/mod.rs‎
Lines changed: 27 additions & 0 deletions b/‎src/parser/mod.rs‎
Lines changed: 27 additions & 0 deletions
@@ -4155,6 +4155,19 @@ pub enum Statement {
         /// source database role this one is cloned from.
         clone: Option<ObjectName>,
     },
+    /// Create an application-scoped role.
+    CreateApplicationRole {
+        /// Replace an existing role.
+        or_replace: bool,
+        /// Alter an existing role or create it when absent.
+        or_alter: bool,
+        /// Succeed when the role already exists.
+        if_not_exists: bool,
+        /// Optionally application-qualified role name.
+        name: ObjectName,
+        /// Optional comment.
+        comment: Option<String>,
+    },
     /// ```sql
     /// CREATE SECRET
     /// ```
@@ -4303,6 +4316,15 @@ pub enum Statement {
         /// Operation to perform on the database role.
         operation: AlterDatabaseRoleOperation,
     },
+    /// Alter an application-scoped role.
+    AlterApplicationRole {
+        /// Succeed when the role is absent.
+        if_exists: bool,
+        /// Optionally application-qualified role name.
+        name: ObjectName,
+        /// Rename or comment operation.
+        operation: AlterDatabaseRoleOperation,
+    },
     /// ```sql
     /// ALTER POLICY <NAME> ON <TABLE NAME> [<OPERATION>]
     /// ```
@@ -7957,6 +7979,21 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::CreateApplicationRole {
+                or_replace,
+                or_alter,
+                if_not_exists,
+                name,
+                comment,
+            } => {
+                write!(f, "CREATE {}APPLICATION ROLE {}{name}",
+                    if *or_replace { "OR REPLACE " } else if *or_alter { "OR ALTER " } else { "" },
+                    if *if_not_exists { "IF NOT EXISTS " } else { "" })?;
+                if let Some(comment) = comment {
+                    write!(f, " COMMENT = '{}'", value::escape_single_quote_string(comment))?;
+                }
+                Ok(())
+            }
             Statement::CreateSecret {
                 or_replace,
                 temporary,
@@ -8054,6 +8091,10 @@ impl fmt::Display for Statement {
                     if_exists = if *if_exists { "IF EXISTS " } else { "" },
                 )
             }
+            Statement::AlterApplicationRole { if_exists, name, operation } => {
+                write!(f, "ALTER APPLICATION ROLE {}{name} {operation}",
+                    if *if_exists { "IF EXISTS " } else { "" })
+            }
             Statement::AlterPolicy(alter_policy) => write!(f, "{alter_policy}"),
             Statement::AlterConnector {
                 name,
@@ -13000,6 +13041,8 @@ pub enum ObjectType {
     Role,
     /// A database role (Snowflake).
     DatabaseRole,
+    /// An application role (Snowflake).
+    ApplicationRole,
     /// A sequence.
     Sequence,
     /// A stage.
@@ -13039,6 +13082,7 @@ impl fmt::Display for ObjectType {
             ObjectType::Database => "DATABASE",
             ObjectType::Role => "ROLE",
             ObjectType::DatabaseRole => "DATABASE ROLE",
+            ObjectType::ApplicationRole => "APPLICATION ROLE",
             ObjectType::Sequence => "SEQUENCE",
             ObjectType::Stage => "STAGE",
             ObjectType::Type => "TYPE",
 
@@ -398,6 +398,7 @@ impl Spanned for Statement {
             Statement::CreateIndex(create_index) => create_index.span(),
             Statement::CreateRole(create_role) => create_role.span(),
             Statement::CreateDatabaseRole { name, .. } => name.span(),
+            Statement::CreateApplicationRole { name, .. } => name.span(),
             Statement::CreateExtension(create_extension) => create_extension.span(),
             Statement::CreateCollation(create_collation) => create_collation.span(),
             Statement::DropExtension(drop_extension) => drop_extension.span(),
@@ -439,6 +440,7 @@ impl Spanned for Statement {
             Statement::AlterOperatorClass { .. } => Span::empty(),
             Statement::AlterRole { .. } => Span::empty(),
             Statement::AlterDatabaseRole { .. } => Span::empty(),
+            Statement::AlterApplicationRole { .. } => Span::empty(),
             Statement::AlterSession { .. } => Span::empty(),
             Statement::AttachDatabase { .. } => Span::empty(),
             Statement::AttachDuckDBDatabase { .. } => Span::empty(),
 
@@ -272,6 +272,12 @@ impl SnowflakeDialect {
         }) {
             return Some(Ok(stmt));
         }
+        if let Ok(Some(stmt)) = parser.maybe_parse(|p| {
+            p.expect_keywords(&[Keyword::ALTER, Keyword::APPLICATION, Keyword::ROLE])?;
+            parse_alter_application_role(p)
+        }) {
+            return Some(Ok(stmt));
+        }
 
         // ALTER DATABASE ROLE [IF EXISTS] <name> { SET TAG | UNSET TAG } —
         // intercept only the tag form; must win before the ALTER DATABASE tag
@@ -877,6 +883,8 @@ impl SnowflakeDialect {
                     return Some(parser.parse_create_database_role(or_replace));
                 }
                 return Some(parse_create_database(or_replace, transient, parser));
+            } else if parser.parse_keywords(&[Keyword::APPLICATION, Keyword::ROLE]) {
+                return Some(parser.parse_create_application_role(or_replace, or_alter));
             } else {
                 // Not a Snowflake-specific CREATE form — rewind the consumed
                 // tokens so the generic `parse_create` re-parses from `CREATE`.
@@ -5038,6 +5046,33 @@ fn parse_alter_database_role(parser: &mut Parser) -> Result<Statement, ParserErr
     })
 }
 
+fn parse_alter_application_role(parser: &mut Parser) -> Result<Statement, ParserError> {
+    let if_exists = parser.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
+    let name = parser.parse_object_name(false)?;
+    let operation = if parser.parse_keyword(Keyword::RENAME) {
+        parser.expect_keyword_is(Keyword::TO)?;
+        AlterDatabaseRoleOperation::RenameTo {
+            new_name: parser.parse_object_name(false)?,
+        }
+    } else if parser.parse_keyword(Keyword::SET) {
+        parser.expect_keyword_is(Keyword::COMMENT)?;
+        parser.expect_token(&Token::Eq)?;
+        AlterDatabaseRoleOperation::SetComment {
+            comment: parser.parse_literal_string()?,
+        }
+    } else if parser.parse_keyword(Keyword::UNSET) {
+        parser.expect_keyword_is(Keyword::COMMENT)?;
+        AlterDatabaseRoleOperation::UnsetComment
+    } else {
+        return parser.expected("RENAME, SET COMMENT, or UNSET COMMENT", parser.peek_token());
+    };
+    Ok(Statement::AlterApplicationRole {
+        if_exists,
+        name,
+        operation,
+    })
+}
+
 /// Parse `SHOW [TERSE] TAGS [ ... ]`
 fn parse_show_tags(terse: bool, parser: &mut Parser) -> Result<Statement, ParserError> {
     let show_options = parser.parse_show_stmt_options()?;
 
@@ -5757,6 +5757,8 @@ impl<'a> Parser<'a> {
             } else {
                 self.parse_create_database()
             }
+        } else if self.parse_keywords(&[Keyword::APPLICATION, Keyword::ROLE]) {
+            self.parse_create_application_role(or_replace, false)
         } else if self.parse_keyword(Keyword::COLLATION) {
             self.parse_create_collation().map(Into::into)
         } else if self.parse_keyword(Keyword::TYPE) {
@@ -8110,6 +8112,29 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Parse a Snowflake application role after `APPLICATION ROLE`.
+    pub fn parse_create_application_role(
+        &mut self,
+        or_replace: bool,
+        or_alter: bool,
+    ) -> Result<Statement, ParserError> {
+        let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+        let name = self.parse_object_name(false)?;
+        let comment = if self.parse_keyword(Keyword::COMMENT) {
+            self.expect_token(&Token::Eq)?;
+            Some(self.parse_literal_string()?)
+        } else {
+            None
+        };
+        Ok(Statement::CreateApplicationRole {
+            or_replace,
+            or_alter,
+            if_not_exists,
+            name,
+            comment,
+        })
+    }
+
     /// Parse an `OWNER` clause.
     pub fn parse_owner(&mut self) -> Result<Owner, ParserError> {
         let owner = match self.parse_one_of_keywords(&[Keyword::CURRENT_USER, Keyword::CURRENT_ROLE, Keyword::SESSION_USER]) {
@@ -8601,6 +8626,8 @@ impl<'a> Parser<'a> {
             } else {
                 ObjectType::Database
             }
+        } else if self.parse_keywords(&[Keyword::APPLICATION, Keyword::ROLE]) {
+            ObjectType::ApplicationRole
         } else if self.parse_keyword(Keyword::SEQUENCE) {
             ObjectType::Sequence
         } else if self.parse_keyword(Keyword::STAGE) {