Add ACCOUNT DDL parsing for Snowflake dialect

Add CREATE/ALTER/DROP ACCOUNT and SHOW ACCOUNTS statements:
- CreateAccount, AlterAccount, DropAccount, ShowAccounts AST nodes
- AccountOption and AlterAccountOperation supporting types
- Display round-trips and Visit derive participation
- Parser entries from parse_create/parse_alter/parse_drop and the
  Snowflake SHOW dispatch
- New keywords (ACCOUNTS, ADMIN_NAME, ADMIN_PASSWORD, EDITION, EMAIL,
  FIRST_NAME, LAST_NAME, MUST_CHANGE_PASSWORD, GRACE_PERIOD_IN_DAYS,
  REGION_GROUP)

Author: hovaesco

src/ast/mod.rs

@@ -4780,6 +4780,54 @@ pub enum Statement {
         filter: Option<ShowStatementFilter>,
     },
     /// ```sql
+    /// CREATE ACCOUNT <name>
+    ///   ADMIN_NAME = <id> ADMIN_PASSWORD = '<pw>'
+    ///   [FIRST_NAME = …] [LAST_NAME = …] EMAIL = '<email>'
+    ///   [MUST_CHANGE_PASSWORD = <bool>]
+    ///   EDITION = { STANDARD | ENTERPRISE | BUSINESS_CRITICAL }
+    ///   [REGION = …] [REGION_GROUP = …] [COMMENT = '<text>']
+    /// ```
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/create-account>
+    CreateAccount {
+        /// Account name.
+        name: Ident,
+        /// Raw `key = value` option pairs (`ADMIN_NAME`, `EDITION`, …) in source
+        /// order; not validated against the Snowflake property catalogue.
+        options: Vec<AccountOption>,
+    },
+    /// ```sql
+    /// ALTER ACCOUNT [<name>] <operation>
+    /// ```
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/alter-account>
+    AlterAccount {
+        /// Optional account name (omitted to target the current account).
+        name: Option<Ident>,
+        /// The alter operation.
+        operation: AlterAccountOperation,
+    },
+    /// ```sql
+    /// DROP ACCOUNT [IF EXISTS] <name> GRACE_PERIOD_IN_DAYS = <int>
+    /// ```
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/drop-account>
+    DropAccount {
+        /// `IF EXISTS` flag.
+        if_exists: bool,
+        /// Account name.
+        name: Ident,
+        /// `GRACE_PERIOD_IN_DAYS = <int>` value.
+        grace_period_in_days: Expr,
+    },
+    /// ```sql
+    /// SHOW ACCOUNTS [HISTORY] [LIKE '<pattern>']
+    /// ```
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/show-accounts>
+    ShowAccounts {
+        /// `HISTORY` flag.
+        history: bool,
+        /// Optional `LIKE` pattern.
+        like: Option<String>,
+    },
+    /// ```sql
     /// CREATE [OR REPLACE] TASK [IF NOT EXISTS] <name>
     ///   [WAREHOUSE = <ident>]
     ///   [SCHEDULE = '<string>']
@@ -6802,6 +6850,41 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::CreateAccount { name, options } => {
+                write!(f, "CREATE ACCOUNT {name}")?;
+                for option in options {
+                    write!(f, " {option}")?;
+                }
+                Ok(())
+            }
+            Statement::AlterAccount { name, operation } => {
+                write!(f, "ALTER ACCOUNT")?;
+                if let Some(name) = name {
+                    write!(f, " {name}")?;
+                }
+                write!(f, " {operation}")
+            }
+            Statement::DropAccount {
+                if_exists,
+                name,
+                grace_period_in_days,
+            } => {
+                write!(f, "DROP ACCOUNT ")?;
+                if *if_exists {
+                    write!(f, "IF EXISTS ")?;
+                }
+                write!(f, "{name} GRACE_PERIOD_IN_DAYS = {grace_period_in_days}")
+            }
+            Statement::ShowAccounts { history, like } => {
+                write!(f, "SHOW ACCOUNTS")?;
+                if *history {
+                    write!(f, " HISTORY")?;
+                }
+                if let Some(like) = like {
+                    write!(f, " LIKE '{}'", value::escape_single_quote_string(like))?;
+                }
+                Ok(())
+            }
             Statement::CreateTask {
                 or_replace,
                 if_not_exists,
@@ -12120,6 +12203,63 @@ impl fmt::Display for AlterWarehouseOperation {
     }
 }
 
+/// A `<key> = <value>` pair inside `CREATE ACCOUNT` or `ALTER ACCOUNT … SET …`.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct AccountOption {
+    /// Property name (e.g. `ADMIN_NAME`, `EDITION`).
+    pub name: Ident,
+    /// Property value expression (e.g. `'secret'`, `STANDARD`, `TRUE`).
+    pub value: Expr,
+}
+
+impl fmt::Display for AccountOption {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} = {}", self.name, self.value)
+    }
+}
+
+/// Operations for `ALTER ACCOUNT`.
+///
+/// See <https://docs.snowflake.com/en/sql-reference/sql/alter-account>.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterAccountOperation {
+    /// `SET <param> = <value> [, ...]`
+    Set {
+        /// Raw `key = value` pairs; not validated against the Snowflake property
+        /// catalogue because the executor doesn't read them.
+        params: Vec<AccountOption>,
+    },
+    /// `RENAME TO <new_name>`
+    RenameTo {
+        /// New account name.
+        new_name: Ident,
+    },
+}
+
+impl fmt::Display for AlterAccountOperation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AlterAccountOperation::Set { params } => {
+                write!(f, "SET ")?;
+                for (i, p) in params.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{p}")?;
+                }
+                Ok(())
+            }
+            AlterAccountOperation::RenameTo { new_name } => {
+                write!(f, "RENAME TO {new_name}")
+            }
+        }
+    }
+}
+
 /// Action for [`Statement::AlterTask`].
 ///
 /// See <https://docs.snowflake.com/en/sql-reference/sql/alter-task>.

src/ast/spans.rs

@@ -527,6 +527,10 @@ impl Spanned for Statement {
             Statement::AlterWarehouse { .. } => Span::empty(),
             Statement::DescribeWarehouse { .. } => Span::empty(),
             Statement::ShowWarehouses { .. } => Span::empty(),
+            Statement::CreateAccount { .. } => Span::empty(),
+            Statement::AlterAccount { .. } => Span::empty(),
+            Statement::DropAccount { .. } => Span::empty(),
+            Statement::ShowAccounts { .. } => Span::empty(),
             Statement::CreateTask { .. } => Span::empty(),
             Statement::AlterTask { .. } => Span::empty(),
             Statement::ExecuteTask { .. } => Span::empty(),

src/dialect/snowflake.rs

@@ -430,6 +430,9 @@ impl Dialect for SnowflakeDialect {
             if parser.parse_keyword(Keyword::WAREHOUSES) {
                 return Some(parse_show_warehouses(parser));
             }
+            if parser.parse_keyword(Keyword::ACCOUNTS) {
+                return Some(parse_show_accounts(parser));
+            }
             let terse = parser.parse_keyword(Keyword::TERSE);
             if parser.parse_keyword(Keyword::OBJECTS) {
                 return Some(parse_show_objects(terse, parser));
@@ -2379,6 +2382,17 @@ fn parse_show_warehouses(parser: &mut Parser) -> Result<Statement, ParserError>
     Ok(Statement::ShowWarehouses { filter })
 }
 
+/// Parse `SHOW ACCOUNTS [HISTORY] [LIKE '<pattern>']`
+fn parse_show_accounts(parser: &mut Parser) -> Result<Statement, ParserError> {
+    let history = parser.parse_keyword(Keyword::HISTORY);
+    let like = if parser.parse_keyword(Keyword::LIKE) {
+        Some(parser.parse_literal_string()?)
+    } else {
+        None
+    };
+    Ok(Statement::ShowAccounts { history, like })
+}
+
 /// Parse `CREATE [OR REPLACE] CATALOG INTEGRATION [IF NOT EXISTS] <name> ...`
 fn parse_create_catalog_integration(
     or_replace: bool,

src/keywords.rs

@@ -98,10 +98,13 @@ define_keywords!(
     ACCESS,
     ACCESS_DELEGATION_MODE,
     ACCOUNT,
+    ACCOUNTS,
     ACTION,
     ADD,
     ADDQUOTES,
     ADMIN,
+    ADMIN_NAME,
+    ADMIN_PASSWORD,
     AFTER,
     AGAINST,
     AGGREGATE,
@@ -369,10 +372,12 @@ define_keywords!(
     DUPLICATE,
     DYNAMIC,
     EACH,
+    EDITION,
     ELEMENT,
     ELEMENTS,
     ELSE,
     ELSEIF,
+    EMAIL,
     EMPTY,
     EMPTYASNULL,
     ENABLE,
@@ -440,6 +445,7 @@ define_keywords!(
     FILTER,
     FINAL,
     FIRST,
+    FIRST_NAME,
     FIRST_VALUE,
     FIXEDSTRING,
     FIXEDWIDTH,
@@ -485,6 +491,7 @@ define_keywords!(
     GIST,
     GLOBAL,
     GLUE,
+    GRACE_PERIOD_IN_DAYS,
     GRANT,
     GRANTED,
     GRANTS,
@@ -590,6 +597,7 @@ define_keywords!(
     LANGUAGE,
     LARGE,
     LAST,
+    LAST_NAME,
     LAST_VALUE,
     LATERAL,
     LEAD,
@@ -687,6 +695,7 @@ define_keywords!(
     MSCK,
     MULTIRANGE_TYPE_NAME,
     MULTISET,
+    MUST_CHANGE_PASSWORD,
     MUTATION,
     NAME,
     NAMES,
@@ -875,6 +884,7 @@ define_keywords!(
     REGCLASS,
     REGEXP,
     REGION,
+    REGION_GROUP,
     REGR_AVGX,
     REGR_AVGY,
     REGR_COUNT,

src/parser/mod.rs

@@ -5403,6 +5403,8 @@ impl<'a> Parser<'a> {
             self.parse_create_user(or_replace).map(Into::into)
         } else if self.parse_keyword(Keyword::WAREHOUSE) {
             self.parse_create_warehouse(or_replace)
+        } else if self.parse_keyword(Keyword::ACCOUNT) {
+            self.parse_create_account()
         } else if self.parse_keyword(Keyword::TASK) {
             self.parse_create_task(or_replace)
         } else if self.parse_keyword(Keyword::PROCEDURE) {
@@ -5497,6 +5499,31 @@ impl<'a> Parser<'a> {
         })
     }
 
+    fn parse_create_account(&mut self) -> Result<Statement, ParserError> {
+        let name = self.parse_identifier()?;
+        let mut options = Vec::new();
+        while let Token::Word(_) = self.peek_token_ref().token {
+            let name = self.parse_identifier()?;
+            self.expect_token(&Token::Eq)?;
+            let value = self.parse_expr()?;
+            options.push(AccountOption { name, value });
+        }
+        Ok(Statement::CreateAccount { name, options })
+    }
+
+    fn parse_drop_account(&mut self) -> Result<Statement, ParserError> {
+        let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
+        let name = self.parse_identifier()?;
+        self.expect_keyword(Keyword::GRACE_PERIOD_IN_DAYS)?;
+        self.expect_token(&Token::Eq)?;
+        let grace_period_in_days = self.parse_expr()?;
+        Ok(Statement::DropAccount {
+            if_exists,
+            name,
+            grace_period_in_days,
+        })
+    }
+
     /// Parse `CREATE [OR REPLACE] TASK [IF NOT EXISTS] <name> ... AS <statement>`.
     fn parse_create_task(&mut self, or_replace: bool) -> Result<Statement, ParserError> {
         let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
@@ -7699,6 +7726,8 @@ impl<'a> Parser<'a> {
             ObjectType::Stream
         } else if self.parse_keyword(Keyword::WAREHOUSE) {
             ObjectType::Warehouse
+        } else if self.parse_keyword(Keyword::ACCOUNT) {
+            return self.parse_drop_account();
         } else if self.parse_keyword(Keyword::TASK) {
             ObjectType::Task
         } else if self.parse_keyword(Keyword::FUNCTION) {
@@ -11069,6 +11098,7 @@ impl<'a> Parser<'a> {
             Keyword::USER,
             Keyword::OPERATOR,
             Keyword::WAREHOUSE,
+            Keyword::ACCOUNT,
             Keyword::TASK,
         ])?;
         match object_type {
@@ -11119,10 +11149,11 @@ impl<'a> Parser<'a> {
             Keyword::CONNECTOR => self.parse_alter_connector(),
             Keyword::USER => self.parse_alter_user().map(Into::into),
             Keyword::WAREHOUSE => self.parse_alter_warehouse(),
+            Keyword::ACCOUNT => self.parse_alter_account(),
             Keyword::TASK => self.parse_alter_task(),
             // unreachable because expect_one_of_keywords used above
             unexpected_keyword => Err(ParserError::ParserError(
-                format!("Internal parser error: expected any of {{VIEW, TYPE, COLLATION, TABLE, INDEX, FUNCTION, AGGREGATE, ROLE, POLICY, CONNECTOR, ICEBERG, SCHEMA, USER, OPERATOR, WAREHOUSE, TASK}}, got {unexpected_keyword:?}"),
+                format!("Internal parser error: expected any of {{VIEW, TYPE, COLLATION, TABLE, INDEX, FUNCTION, AGGREGATE, ROLE, POLICY, CONNECTOR, ICEBERG, SCHEMA, USER, OPERATOR, WAREHOUSE, ACCOUNT, TASK}}, got {unexpected_keyword:?}"),
             )),
         }
     }
@@ -11409,6 +11440,41 @@ impl<'a> Parser<'a> {
         })
     }
 
+    fn parse_alter_account(&mut self) -> Result<Statement, ParserError> {
+        // The name is optional — bare `ALTER ACCOUNT SET ...` targets the
+        // current account. SET and RENAME are the only operations, so their
+        // presence indicates no name was provided.
+        let starts_with_op = matches!(
+            self.peek_token().token,
+            Token::Word(ref w) if matches!(w.keyword, Keyword::SET | Keyword::RENAME)
+        );
+        let name = if starts_with_op {
+            None
+        } else {
+            Some(self.parse_identifier()?)
+        };
+
+        let operation = if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
+            let new_name = self.parse_identifier()?;
+            AlterAccountOperation::RenameTo { new_name }
+        } else if self.parse_keyword(Keyword::SET) {
+            let params = self.parse_comma_separated(|p| {
+                let name = p.parse_identifier()?;
+                p.expect_token(&Token::Eq)?;
+                let value = p.parse_expr()?;
+                Ok::<AccountOption, ParserError>(AccountOption { name, value })
+            })?;
+            AlterAccountOperation::Set { params }
+        } else {
+            return self.expected(
+                "SET or RENAME TO after ALTER ACCOUNT",
+                self.peek_token(),
+            );
+        };
+
+        Ok(Statement::AlterAccount { name, operation })
+    }
+
     /// Parse `ALTER TASK [IF EXISTS] <name> { RESUME | SUSPEND }`.
     pub fn parse_alter_task(&mut self) -> Result<Statement, ParserError> {
         let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);