Moved CreateRole struct out of the Statement enum

LucaCappelletti94 · LucaCappelletti94 · commit ef260ca0317c · 2025-10-06T14:12:29.000+02:00
diff --git a/src/ast/dcl.rs b/src/ast/dcl.rs
@@ -28,8 +28,9 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
-use super::{display_comma_separated, Expr, Ident, Password};
+use super::{display_comma_separated, Expr, Ident, Password, Spanned};
 use crate::ast::{display_separated, ObjectName};
+use crate::tokenizer::Span;
 
 /// An option in `ROLE` statement.
 ///
@@ -252,3 +253,113 @@ impl fmt::Display for SecondaryRoles {
         }
     }
 }
+
+/// CREATE ROLE statement
+/// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createrole.html)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateRole {
+    pub names: Vec<ObjectName>,
+    pub if_not_exists: bool,
+    // Postgres
+    pub login: Option<bool>,
+    pub inherit: Option<bool>,
+    pub bypassrls: Option<bool>,
+    pub password: Option<Password>,
+    pub superuser: Option<bool>,
+    pub create_db: Option<bool>,
+    pub create_role: Option<bool>,
+    pub replication: Option<bool>,
+    pub connection_limit: Option<Expr>,
+    pub valid_until: Option<Expr>,
+    pub in_role: Vec<Ident>,
+    pub in_group: Vec<Ident>,
+    pub role: Vec<Ident>,
+    pub user: Vec<Ident>,
+    pub admin: Vec<Ident>,
+    // MSSQL
+    pub authorization_owner: Option<ObjectName>,
+}
+
+impl fmt::Display for CreateRole {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE ROLE {if_not_exists}{names}{superuser}{create_db}{create_role}{inherit}{login}{replication}{bypassrls}",
+            if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" },
+            names = display_separated(&self.names, ", "),
+            superuser = match self.superuser {
+                Some(true) => " SUPERUSER",
+                Some(false) => " NOSUPERUSER",
+                None => ""
+            },
+            create_db = match self.create_db {
+                Some(true) => " CREATEDB",
+                Some(false) => " NOCREATEDB",
+                None => ""
+            },
+            create_role = match self.create_role {
+                Some(true) => " CREATEROLE",
+                Some(false) => " NOCREATEROLE",
+                None => ""
+            },
+            inherit = match self.inherit {
+                Some(true) => " INHERIT",
+                Some(false) => " NOINHERIT",
+                None => ""
+            },
+            login = match self.login {
+                Some(true) => " LOGIN",
+                Some(false) => " NOLOGIN",
+                None => ""
+            },
+            replication = match self.replication {
+                Some(true) => " REPLICATION",
+                Some(false) => " NOREPLICATION",
+                None => ""
+            },
+            bypassrls = match self.bypassrls {
+                Some(true) => " BYPASSRLS",
+                Some(false) => " NOBYPASSRLS",
+                None => ""
+            }
+        )?;
+        if let Some(limit) = &self.connection_limit {
+            write!(f, " CONNECTION LIMIT {limit}")?;
+        }
+        match &self.password {
+            Some(Password::Password(pass)) => write!(f, " PASSWORD {pass}")?,
+            Some(Password::NullPassword) => write!(f, " PASSWORD NULL")?,
+            None => {}
+        };
+        if let Some(until) = &self.valid_until {
+            write!(f, " VALID UNTIL {until}")?;
+        }
+        if !self.in_role.is_empty() {
+            write!(f, " IN ROLE {}", display_comma_separated(&self.in_role))?;
+        }
+        if !self.in_group.is_empty() {
+            write!(f, " IN GROUP {}", display_comma_separated(&self.in_group))?;
+        }
+        if !self.role.is_empty() {
+            write!(f, " ROLE {}", display_comma_separated(&self.role))?;
+        }
+        if !self.user.is_empty() {
+            write!(f, " USER {}", display_comma_separated(&self.user))?;
+        }
+        if !self.admin.is_empty() {
+            write!(f, " ADMIN {}", display_comma_separated(&self.admin))?;
+        }
+        if let Some(owner) = &self.authorization_owner {
+            write!(f, " AUTHORIZATION {owner}")?;
+        }
+        Ok(())
+    }
+}
+
+impl Spanned for CreateRole {
+    fn span(&self) -> Span {
+        Span::empty()
+    }
+}
diff --git a/src/ast/ddl.rs b/src/ast/ddl.rs
@@ -19,7 +19,7 @@
 //! (commonly referred to as Data Definition Language, or DDL)
 
 #[cfg(not(feature = "std"))]
-use alloc::{boxed::Box, string::String, vec::Vec};
+use alloc::{boxed::Box, format, string::String, vec, vec::Vec};
 use core::fmt::{self, Display, Write};
 
 #[cfg(feature = "serde")]
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -56,7 +56,7 @@ pub use self::data_type::{
     ExactNumberInfo, IntervalFields, StructBracketKind, TimezoneInfo,
 };
 pub use self::dcl::{
-    AlterRoleOperation, ResetConfig, RoleOption, SecondaryRoles, SetConfigValue, Use,
+    AlterRoleOperation, CreateRole, ResetConfig, RoleOption, SecondaryRoles, SetConfigValue, Use,
 };
 pub use self::ddl::{
     AlterColumnOperation, AlterConnectorOwner, AlterIndexOperation, AlterPolicyOperation,
@@ -3273,28 +3273,7 @@ pub enum Statement {
     /// CREATE ROLE
     /// ```
     /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createrole.html)
-    CreateRole {
-        names: Vec<ObjectName>,
-        if_not_exists: bool,
-        // Postgres
-        login: Option<bool>,
-        inherit: Option<bool>,
-        bypassrls: Option<bool>,
-        password: Option<Password>,
-        superuser: Option<bool>,
-        create_db: Option<bool>,
-        create_role: Option<bool>,
-        replication: Option<bool>,
-        connection_limit: Option<Expr>,
-        valid_until: Option<Expr>,
-        in_role: Vec<Ident>,
-        in_group: Vec<Ident>,
-        role: Vec<Ident>,
-        user: Vec<Ident>,
-        admin: Vec<Ident>,
-        // MSSQL
-        authorization_owner: Option<ObjectName>,
-    },
+    CreateRole(CreateRole),
     /// ```sql
     /// CREATE SECRET
     /// ```
@@ -4870,98 +4849,7 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
-            Statement::CreateRole {
-                names,
-                if_not_exists,
-                inherit,
-                login,
-                bypassrls,
-                password,
-                create_db,
-                create_role,
-                superuser,
-                replication,
-                connection_limit,
-                valid_until,
-                in_role,
-                in_group,
-                role,
-                user,
-                admin,
-                authorization_owner,
-            } => {
-                write!(
-                    f,
-                    "CREATE ROLE {if_not_exists}{names}{superuser}{create_db}{create_role}{inherit}{login}{replication}{bypassrls}",
-                    if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" },
-                    names = display_separated(names, ", "),
-                    superuser = match *superuser {
-                        Some(true) => " SUPERUSER",
-                        Some(false) => " NOSUPERUSER",
-                        None => ""
-                    },
-                    create_db = match *create_db {
-                        Some(true) => " CREATEDB",
-                        Some(false) => " NOCREATEDB",
-                        None => ""
-                    },
-                    create_role = match *create_role {
-                        Some(true) => " CREATEROLE",
-                        Some(false) => " NOCREATEROLE",
-                        None => ""
-                    },
-                    inherit = match *inherit {
-                        Some(true) => " INHERIT",
-                        Some(false) => " NOINHERIT",
-                        None => ""
-                    },
-                    login = match *login {
-                        Some(true) => " LOGIN",
-                        Some(false) => " NOLOGIN",
-                        None => ""
-                    },
-                    replication = match *replication {
-                        Some(true) => " REPLICATION",
-                        Some(false) => " NOREPLICATION",
-                        None => ""
-                    },
-                    bypassrls = match *bypassrls {
-                        Some(true) => " BYPASSRLS",
-                        Some(false) => " NOBYPASSRLS",
-                        None => ""
-                    }
-                )?;
-                if let Some(limit) = connection_limit {
-                    write!(f, " CONNECTION LIMIT {limit}")?;
-                }
-                match password {
-                    Some(Password::Password(pass)) => write!(f, " PASSWORD {pass}"),
-                    Some(Password::NullPassword) => write!(f, " PASSWORD NULL"),
-                    None => Ok(()),
-                }?;
-                if let Some(until) = valid_until {
-                    write!(f, " VALID UNTIL {until}")?;
-                }
-                if !in_role.is_empty() {
-                    write!(f, " IN ROLE {}", display_comma_separated(in_role))?;
-                }
-                if !in_group.is_empty() {
-                    write!(f, " IN GROUP {}", display_comma_separated(in_group))?;
-                }
-                if !role.is_empty() {
-                    write!(f, " ROLE {}", display_comma_separated(role))?;
-                }
-                if !user.is_empty() {
-                    write!(f, " USER {}", display_comma_separated(user))?;
-                }
-                if !admin.is_empty() {
-                    write!(f, " ADMIN {}", display_comma_separated(admin))?;
-                }
-                if let Some(owner) = authorization_owner {
-                    write!(f, " AUTHORIZATION {owner}")?;
-                }
-                Ok(())
-            }
+            Statement::CreateRole(create_role) => write!(f, "{create_role}"),
             Statement::CreateSecret {
                 or_replace,
                 temporary,
@@ -10728,6 +10616,12 @@ impl From<CreateView> for Statement {
     }
 }
 
+impl From<CreateRole> for Statement {
+    fn from(cr: CreateRole) -> Self {
+        Self::CreateRole(cr)
+    }
+}
+
 impl From<CaseStatement> for Statement {
     fn from(c: CaseStatement) -> Self {
         Self::Case(c)
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -361,7 +361,7 @@ impl Spanned for Statement {
                     .chain(module_args.iter().map(|i| i.span)),
             ),
             Statement::CreateIndex(create_index) => create_index.span(),
-            Statement::CreateRole { .. } => Span::empty(),
+            Statement::CreateRole(create_role) => create_role.span(),
             Statement::CreateSecret { .. } => Span::empty(),
             Statement::CreateServer { .. } => Span::empty(),
             Statement::CreateConnector { .. } => Span::empty(),
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -6210,7 +6210,7 @@ impl<'a> Parser<'a> {
             }?
         }
 
-        Ok(Statement::CreateRole {
+        Ok(CreateRole {
             names,
             if_not_exists,
             login,
@@ -6229,7 +6229,8 @@ impl<'a> Parser<'a> {
             user,
             admin,
             authorization_owner,
-        })
+        }
+        .into())
     }
 
     pub fn parse_owner(&mut self) -> Result<Owner, ParserError> {
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -9406,21 +9406,17 @@ fn parse_drop_index() {
 fn parse_create_role() {
     let sql = "CREATE ROLE consultant";
     match verified_stmt(sql) {
-        Statement::CreateRole { names, .. } => {
-            assert_eq_vec(&["consultant"], &names);
+        Statement::CreateRole(create_role) => {
+            assert_eq_vec(&["consultant"], &create_role.names);
         }
         _ => unreachable!(),
     }
 
     let sql = "CREATE ROLE IF NOT EXISTS mysql_a, mysql_b";
     match verified_stmt(sql) {
-        Statement::CreateRole {
-            names,
-            if_not_exists,
-            ..
-        } => {
-            assert_eq_vec(&["mysql_a", "mysql_b"], &names);
-            assert!(if_not_exists);
+        Statement::CreateRole(create_role) => {
+            assert_eq_vec(&["mysql_a", "mysql_b"], &create_role.names);
+            assert!(create_role.if_not_exists);
         }
         _ => unreachable!(),
     }
diff --git a/tests/sqlparser_mssql.rs b/tests/sqlparser_mssql.rs
@@ -772,14 +772,10 @@ fn parse_mssql_bin_literal() {
 fn parse_mssql_create_role() {
     let sql = "CREATE ROLE mssql AUTHORIZATION helena";
     match ms().verified_stmt(sql) {
-        Statement::CreateRole {
-            names,
-            authorization_owner,
-            ..
-        } => {
-            assert_eq_vec(&["mssql"], &names);
+        Statement::CreateRole(create_role) => {
+            assert_eq_vec(&["mssql"], &create_role.names);
             assert_eq!(
-                authorization_owner,
+                create_role.authorization_owner,
                 Some(ObjectName::from(vec![Ident {
                     value: "helena".into(),
                     quote_style: None,
diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs
