Struct CreateModel 

pub struct CreateModel {
    pub name: String,
    pub fields: Vec<FieldDefinition>,
    pub options: HashMap<String, String>,
    pub bases: Vec<String>,
    pub composite_primary_key: Option<Vec<String>>,
}

Available on native and crate feature database only.

Create a new model (table)

Example

use reinhardt_db::migrations::operations::models::CreateModel;
use reinhardt_db::migrations::operations::FieldDefinition;
use reinhardt_db::migrations::{ProjectState, FieldType};

let mut state = ProjectState::new();
let create = CreateModel::new(
    "User",
    vec![
        FieldDefinition::new("id", FieldType::Integer, true, false, Option::<&str>::None),
        FieldDefinition::new("name", FieldType::VarChar(100), false, false, Option::<&str>::None),
    ],
);

create.state_forwards("myapp", &mut state);
let model = state.get_model("myapp", "User").unwrap();
assert_eq!(model.fields.len(), 2);

Fields

name: String

The name.

fields: Vec<FieldDefinition>

The fields.

options: HashMap<String, String>

The options.

bases: Vec<String>

The bases.

composite_primary_key: Option<Vec<String>>

Composite primary key fields (field names)

Implementations

impl CreateModel

pub fn new(name: impl Into<String>, fields: Vec<FieldDefinition>) -> CreateModel

Create a new CreateModel operation

pub fn with_options(self, options: HashMap<String, String>) -> CreateModel

Add model options

pub fn with_bases(self, bases: Vec<String>) -> CreateModel

Add base classes for inheritance

pub fn with_composite_primary_key( self, fields: Vec<String>, ) -> Result<CreateModel, ValidationError>

Set composite primary key with validation

Errors

Returns ValidationError::EmptyCompositePrimaryKey if the fields list is empty. Returns ValidationError::NonExistentField if any field name doesn’t exist in the table.

Example

use reinhardt_db::migrations::operations::models::CreateModel;
use reinhardt_db::migrations::operations::FieldDefinition;
use reinhardt_db::migrations::FieldType;

let create = CreateModel::new(
    "post_tags",
    vec![
        FieldDefinition::new("post_id", FieldType::Integer, false, false, Option::<&str>::None),
        FieldDefinition::new("tag_id", FieldType::Integer, false, false, Option::<&str>::None),
    ],
)
.with_composite_primary_key(vec!["post_id".to_string(), "tag_id".to_string()])
.expect("Valid composite primary key");

assert!(create.composite_primary_key.is_some());

pub fn state_forwards(&self, app_label: &str, state: &mut ProjectState)

Apply to project state (forward)

pub fn database_forwards( &self, schema_editor: &dyn BaseDatabaseSchemaEditor, ) -> Vec<String>

Generate SQL using schema editor

Example

use reinhardt_db::migrations::operations::models::CreateModel;
use reinhardt_db::migrations::operations::FieldDefinition;
use reinhardt_db::migrations::FieldType;

let create = CreateModel::new(
    "users",
    vec![
        FieldDefinition::new("id", FieldType::Integer, true, false, Option::<&str>::None),
        FieldDefinition::new("email", FieldType::VarChar(255), false, false, Option::<&str>::None),
    ],
);

// Convert to SQL - actual DB operations would use schema editor
let columns: Vec<(&str, String)> = create.fields
    .iter()
    .map(|f| (f.name.as_str(), f.to_sql_definition()))
    .collect();

assert_eq!(columns.len(), 2);
assert_eq!(columns[0].0, "id");
assert!(columns[0].1.contains("PRIMARY KEY"));

Trait Implementations

impl Clone for CreateModel

fn clone(&self) -> CreateModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CreateModel

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CreateModel

fn deserialize<__D>( __deserializer: __D, ) -> Result<CreateModel, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MigrationOperation for CreateModel

fn migration_name_fragment(&self) -> Option<String>

Generate a fragment for the migration name

fn describe(&self) -> String

Human-readable description of this operation

fn normalize(&self) -> Self

where Self: Sized + Clone,

Normalize operation for comparison

fn semantically_equal(&self, other: &Self) -> bool

where Self: Sized + Clone + PartialEq,

Check if two operations are semantically equal

impl Serialize for CreateModel

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.