Method parse_role_attributes

src/sql-parser/src/parser.rs:4400–4443

(&mut self)

    }

    fn parse_role_attributes(&mut self) -> Result<Vec<RoleAttribute>, ParserError> {
        let mut options = vec![];
        loop {
            match self.parse_one_of_keywords(&[
                SUPERUSER,
                NOSUPERUSER,
                LOGIN,
                NOLOGIN,
                INHERIT,
                NOINHERIT,
                CREATECLUSTER,
                NOCREATECLUSTER,
                CREATEDB,
                NOCREATEDB,
                CREATEROLE,
                NOCREATEROLE,
                PASSWORD,
            ]) {
                None => break,
                Some(SUPERUSER) => options.push(RoleAttribute::SuperUser),
                Some(NOSUPERUSER) => options.push(RoleAttribute::NoSuperUser),
                Some(LOGIN) => options.push(RoleAttribute::Login),
                Some(NOLOGIN) => options.push(RoleAttribute::NoLogin),
                Some(INHERIT) => options.push(RoleAttribute::Inherit),
                Some(NOINHERIT) => options.push(RoleAttribute::NoInherit),
                Some(CREATECLUSTER) => options.push(RoleAttribute::CreateCluster),
                Some(NOCREATECLUSTER) => options.push(RoleAttribute::NoCreateCluster),
                Some(CREATEDB) => options.push(RoleAttribute::CreateDB),
                Some(NOCREATEDB) => options.push(RoleAttribute::NoCreateDB),
                Some(CREATEROLE) => options.push(RoleAttribute::CreateRole),
                Some(NOCREATEROLE) => options.push(RoleAttribute::NoCreateRole),
                Some(PASSWORD) => {
                    if self.parse_keyword(NULL) {
                        options.push(RoleAttribute::Password(None));
                        continue;
                    }
                    let password = self.parse_literal_string()?;
                    options.push(RoleAttribute::Password(Some(password)));
                }
                Some(_) => unreachable!(),
            }
        }
        Ok(options)
    }

    fn parse_create_secret(&mut self) -> Result<Statement<Raw>, ParserError> {
        self.expect_keyword(SECRET)?;