Struct ModelState 

pub struct ModelState {
    pub app_label: String,
    pub name: String,
    pub table_name: String,
    pub fields: BTreeMap<String, FieldState>,
    pub options: HashMap<String, String>,
    pub base_model: Option<String>,
    pub inheritance_type: Option<String>,
    pub discriminator_column: Option<String>,
    pub indexes: Vec<IndexDefinition>,
    pub constraints: Vec<ConstraintDefinition>,
    pub many_to_many_fields: Vec<ManyToManyMetadata>,
}

Available on crate feature database and non-WebAssembly only.

Model state for migration detection

Django equivalent: ModelState in django/db/migrations/state.py

Fields

app_label: String

Application label (e.g., “auth”, “blog”)

name: String

Model name (e.g., “User”, “Post”)

table_name: String

Database table name (e.g., “users”, “blog_posts”)

fields: BTreeMap<String, FieldState>

Fields: field_name -> FieldState

options: HashMap<String, String>

Model options (db_table, ordering, etc.)

base_model: Option<String>

Base model for inheritance

inheritance_type: Option<String>

Inheritance type: “single_table” or “joined_table”

discriminator_column: Option<String>

Discriminator column for single table inheritance

indexes: Vec<IndexDefinition>

Indexes: index_name -> IndexDefinition

constraints: Vec<ConstraintDefinition>

Constraints: constraint_name -> ConstraintDefinition

many_to_many_fields: Vec<ManyToManyMetadata>

ManyToMany relationships

Implementations

impl ModelState

pub fn new(app_label: impl Into<String>, name: impl Into<String>) -> ModelState

Create a new ModelState with app_label and name

Examples

use reinhardt_db::migrations::ModelState;

let model = ModelState::new("myapp", "User");
assert_eq!(model.app_label, "myapp");
assert_eq!(model.name, "User");
assert_eq!(model.table_name, "user");
assert_eq!(model.fields.len(), 0);

pub fn add_field(&mut self, field: FieldState)

Add a field to this model

Examples

use reinhardt_db::migrations::{ModelState, FieldState, FieldType};

let mut model = ModelState::new("myapp", "User");
let field = FieldState::new("email", FieldType::VarChar(255), false);
model.add_field(field);
assert_eq!(model.fields.len(), 1);
assert!(model.has_field("email"));

pub fn get_field(&self, name: &str) -> Option<&FieldState>

Get a field by name

Examples

use reinhardt_db::migrations::{ModelState, FieldState, FieldType};

let mut model = ModelState::new("myapp", "User");
let field = FieldState::new("email", FieldType::VarChar(255), false);
model.add_field(field);

let retrieved = model.get_field("email");
assert!(retrieved.is_some());
assert_eq!(retrieved.unwrap().field_type, FieldType::VarChar(255));

pub fn has_field(&self, name: &str) -> bool

Check if a field exists

Examples

use reinhardt_db::migrations::{ModelState, FieldState, FieldType};

let mut model = ModelState::new("myapp", "User");
let field = FieldState::new("email", FieldType::VarChar(255), false);
model.add_field(field);

assert!(model.has_field("email"));
assert!(!model.has_field("username"));

pub fn rename_field(&mut self, old_name: &str, new_name: String)

Rename a field

Examples

use reinhardt_db::migrations::{ModelState, FieldState, FieldType};

let mut model = ModelState::new("myapp", "User");
let field = FieldState::new("email", FieldType::VarChar(255), false);
model.add_field(field);

model.rename_field("email", "email_address".to_string());
assert!(!model.has_field("email"));
assert!(model.has_field("email_address"));

pub fn add_constraint(&mut self, constraint: ConstraintDefinition)

Add a constraint to this model

Examples

use reinhardt_db::migrations::{ModelState, ConstraintDefinition};

let mut model = ModelState::new("myapp", "User");
let constraint = ConstraintDefinition {
    name: "unique_email".to_string(),
    constraint_type: "unique".to_string(),
    fields: vec!["email".to_string()],
    expression: None,
    foreign_key_info: None,
};
model.add_constraint(constraint);
assert_eq!(model.constraints.len(), 1);

pub fn add_foreign_key_constraint_from_field(&mut self, field_name: &str)

Add a ForeignKey constraint from field information

impl ModelState

pub fn remove_field(&mut self, name: &str)

Remove a field from this model

Examples

use reinhardt_db::migrations::{ModelState, FieldState, FieldType};

let mut model = ModelState::new("myapp", "User");
let field = FieldState::new("email", FieldType::VarChar(255), false);
model.add_field(field);
assert!(model.has_field("email"));

model.remove_field("email");
assert!(!model.has_field("email"));

pub fn alter_field(&mut self, name: &str, new_field: FieldState)

Alter a field definition

Examples

use reinhardt_db::migrations::{ModelState, FieldState, FieldType};

let mut model = ModelState::new("myapp", "User");
let field = FieldState::new("email", FieldType::VarChar(255), false);
model.add_field(field);

let new_field = FieldState::new("email", FieldType::Text, true);
model.alter_field("email", new_field);

let altered = model.get_field("email").unwrap();
assert_eq!(altered.field_type, FieldType::Text);
assert!(altered.nullable);

Trait Implementations

impl Clone for ModelState

fn clone(&self) -> ModelState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelState

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

Formats the value using the given formatter.