Method parse_alter_object

src/sql-parser/src/parser.rs:5636–5739

(&mut self)

    }

    fn parse_alter_object(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
        let object_type = self.expect_object_type().map_no_statement_parser_err()?;

        match object_type {
            ObjectType::Role => self
                .parse_alter_role()
                .map_parser_err(StatementKind::AlterRole),
            ObjectType::Sink => self.parse_alter_sink(),
            ObjectType::Source => self.parse_alter_source(),
            ObjectType::Index => self.parse_alter_index(),
            ObjectType::Secret => self.parse_alter_secret(),
            ObjectType::Connection => self.parse_alter_connection(),
            ObjectType::View | ObjectType::MaterializedView | ObjectType::Table => {
                self.parse_alter_views(object_type)
            }
            ObjectType::Type => {
                let if_exists = self
                    .parse_if_exists()
                    .map_parser_err(StatementKind::AlterOwner)?;
                let name = UnresolvedObjectName::Item(
                    self.parse_item_name()
                        .map_parser_err(StatementKind::AlterOwner)?,
                );
                self.expect_keywords(&[OWNER, TO])
                    .map_parser_err(StatementKind::AlterOwner)?;
                let new_owner = self
                    .parse_identifier()
                    .map_parser_err(StatementKind::AlterOwner)?;
                Ok(Statement::AlterOwner(AlterOwnerStatement {
                    object_type,
                    if_exists,
                    name,
                    new_owner,
                }))
            }
            ObjectType::Cluster => self.parse_alter_cluster(object_type),
            ObjectType::ClusterReplica => {
                let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
                let name = UnresolvedObjectName::ClusterReplica(
                    self.parse_cluster_replica_name()
                        .map_no_statement_parser_err()?,
                );
                let action = self
                    .expect_one_of_keywords(&[OWNER, RENAME])
                    .map_no_statement_parser_err()?;
                self.expect_keyword(TO).map_no_statement_parser_err()?;
                match action {
                    OWNER => {
                        let new_owner = self
                            .parse_identifier()
                            .map_parser_err(StatementKind::AlterOwner)?;
                        Ok(Statement::AlterOwner(AlterOwnerStatement {
                            object_type,
                            if_exists,
                            name,
                            new_owner,
                        }))
                    }