Method parse_alter_secret

src/sql-parser/src/parser.rs:6091–6141

(&mut self)

    }

    fn parse_alter_secret(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
        let name = self.parse_item_name().map_no_statement_parser_err()?;

        Ok(
            match self
                .expect_one_of_keywords(&[AS, RENAME, OWNER])
                .map_no_statement_parser_err()?
            {
                AS => {
                    let value = self
                        .parse_expr()
                        .map_parser_err(StatementKind::AlterSecret)?;
                    Statement::AlterSecret(AlterSecretStatement {
                        name,
                        if_exists,
                        value,
                    })
                }
                RENAME => {
                    self.expect_keyword(TO)
                        .map_parser_err(StatementKind::AlterObjectRename)?;
                    let to_item_name = self
                        .parse_identifier()
                        .map_parser_err(StatementKind::AlterObjectRename)?;

                    Statement::AlterObjectRename(AlterObjectRenameStatement {
                        object_type: ObjectType::Secret,
                        if_exists,
                        name: UnresolvedObjectName::Item(name),
                        to_item_name,
                    })
                }
                OWNER => {
                    self.expect_keyword(TO)
                        .map_parser_err(StatementKind::AlterOwner)?;
                    let new_owner = self
                        .parse_identifier()
                        .map_parser_err(StatementKind::AlterOwner)?;

                    Statement::AlterOwner(AlterOwnerStatement {
                        object_type: ObjectType::Secret,
                        if_exists,
                        name: UnresolvedObjectName::Item(name),
                        new_owner,
                    })
                }
                _ => unreachable!(),
            },
        )
    }

    /// Parse an ALTER SINK statement.
    fn parse_alter_sink(&mut self) -> Result<Statement<Raw>, ParserStatementError> {