Struct CreateUserStatement 

pub struct CreateUserStatement {
    pub user_name: String,
    pub if_not_exists: bool,
    pub attributes: Vec<RoleAttribute>,
    pub default_roles: Vec<String>,
    pub options: Vec<UserOption>,
}

CREATE USER statement builder

This struct provides a fluent API for building CREATE USER statements.

PostgreSQL

PostgreSQL CREATE USER is an alias for CREATE ROLE WITH LOGIN. Use the `attribute()` method to add role attributes.

MySQL

MySQL CREATE USER supports:

• IF NOT EXISTS clause
• User@host specification
• DEFAULT ROLE clause
• User options

Examples

Create a simple user:

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new()
    .user("app_user");

Create a user with password (PostgreSQL):

use reinhardt_query::dcl::{CreateUserStatement, RoleAttribute};

let stmt = CreateUserStatement::new()
    .user("app_user")
    .attribute(RoleAttribute::Password("password123".to_string()))
    .attribute(RoleAttribute::ConnectionLimit(5));

Create a user with default role (MySQL):

use reinhardt_query::dcl::{CreateUserStatement, UserOption};

let stmt = CreateUserStatement::new()
    .user("app_user@localhost")
    .if_not_exists(true)
    .default_role(vec!["app_role".to_string()])
    .option(UserOption::Comment("My application user".to_string()));

Fields

user_name: String

User name (with optional @host for MySQL)

if_not_exists: bool

IF NOT EXISTS clause (MySQL only)

attributes: Vec<RoleAttribute>

PostgreSQL role attributes (PostgreSQL only)

default_roles: Vec<String>

MySQL DEFAULT ROLE clause (MySQL only)

options: Vec<UserOption>

MySQL user options

Implementations

impl CreateUserStatement

pub fn new() -> Self

Create a new CREATE USER statement

Examples

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new();

pub fn user(self, name: impl Into<String>) -> Self

Set the user name

Examples

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new()
    .user("app_user");

MySQL with host:

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new()
    .user("app_user@localhost");

pub fn if_not_exists(self, flag: bool) -> Self

Set IF NOT EXISTS flag (MySQL only)

Examples

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new()
    .user("app_user")
    .if_not_exists(true);

pub fn attribute(self, attr: RoleAttribute) -> Self

Add a single PostgreSQL role attribute

Examples

use reinhardt_query::dcl::{CreateUserStatement, RoleAttribute};

let stmt = CreateUserStatement::new()
    .user("app_user")
    .attribute(RoleAttribute::Password("secret".to_string()))
    .attribute(RoleAttribute::CreateDb);

pub fn attributes(self, attrs: Vec<RoleAttribute>) -> Self

Set all PostgreSQL role attributes at once

Examples

use reinhardt_query::dcl::{CreateUserStatement, RoleAttribute};

let stmt = CreateUserStatement::new()
    .user("app_user")
    .attributes(vec![
        RoleAttribute::Password("secret".to_string()),
        RoleAttribute::CreateDb,
        RoleAttribute::ConnectionLimit(10),
    ]);

pub fn default_role(self, roles: Vec<String>) -> Self

Set DEFAULT ROLE clause (MySQL only)

Examples

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new()
    .user("app_user@localhost")
    .default_role(vec!["app_role".to_string(), "admin_role".to_string()]);

pub fn option(self, opt: UserOption) -> Self

Add a single MySQL user option

Examples

use reinhardt_query::dcl::{CreateUserStatement, UserOption};

let stmt = CreateUserStatement::new()
    .user("app_user")
    .option(UserOption::Comment("Application user".to_string()));

pub fn options(self, opts: Vec<UserOption>) -> Self

Set all MySQL user options at once

Examples

use reinhardt_query::dcl::{CreateUserStatement, UserOption};

let stmt = CreateUserStatement::new()
    .user("app_user")
    .options(vec![
        UserOption::Comment("Application user".to_string()),
        UserOption::AccountLock,
    ]);

pub fn validate(&self) -> Result<(), String>

Validate the CREATE USER statement

Validation Rules

1. User name cannot be empty

Examples

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new()
    .user("app_user");

assert!(stmt.validate().is_ok());

use reinhardt_query::dcl::CreateUserStatement;

let stmt = CreateUserStatement::new();
assert!(stmt.validate().is_err());

Trait Implementations

impl Clone for CreateUserStatement

fn clone(&self) -> CreateUserStatement

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CreateUserStatement

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CreateUserStatement

fn default() -> CreateUserStatement

Returns the “default value” for a type.