Struct MoveModel 

pub struct MoveModel {
    pub model_name: String,
    pub from_app: String,
    pub to_app: String,
    pub rename_table: bool,
    pub old_table_name: Option<String>,
    pub new_table_name: Option<String>,
}

Available on native and crate feature database only.

Move a model from one app to another

This operation moves a model from one application to another while preserving its data and structure. Unlike Django which requires manual migration steps, Reinhardt provides an explicit MoveModel operation.

Example

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

let mut state = ProjectState::new();

// Create a model in myapp
let create = CreateModel::new(
    "User",
    vec![FieldDefinition::new("id", FieldType::Integer, true, false, Option::<&str>::None)],
);
create.state_forwards("myapp", &mut state);

// Move it to auth app
let move_op = MoveModel::new("User", "myapp", "auth");
move_op.state_forwards("auth", &mut state);

assert!(state.get_model("myapp", "User").is_none());
assert!(state.get_model("auth", "User").is_some());

Fields

model_name: String

The model name.

from_app: String

The from app.

to_app: String

The to app.

rename_table: bool

The rename table.

old_table_name: Option<String>

The old table name.

new_table_name: Option<String>

The new table name.

Implementations

impl MoveModel

pub fn new( model_name: impl Into<String>, from_app: impl Into<String>, to_app: impl Into<String>, ) -> MoveModel

Create a new MoveModel operation

Example

use reinhardt_db::migrations::operations::models::MoveModel;

let move_op = MoveModel::new("User", "myapp", "auth");
assert_eq!(move_op.model_name, "User");
assert_eq!(move_op.from_app, "myapp");
assert_eq!(move_op.to_app, "auth");
assert!(!move_op.rename_table);

pub fn with_table_rename( self, old_table: impl Into<String>, new_table: impl Into<String>, ) -> MoveModel

Enable table renaming during the move

Example

use reinhardt_db::migrations::operations::models::MoveModel;

let move_op = MoveModel::new("User", "myapp", "auth")
    .with_table_rename("myapp_user", "auth_user");

assert!(move_op.rename_table);
assert_eq!(move_op.old_table_name, Some("myapp_user".to_string()));
assert_eq!(move_op.new_table_name, Some("auth_user".to_string()));

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

Apply to project state (forward)

This removes the model from the source app and adds it to the target app.

pub fn state_backwards(&self, _app_label: &str, state: &mut ProjectState)

Apply to project state (backward/reverse)

This moves the model back to its original app.

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

Generate SQL using schema editor

If rename_table is true, generates ALTER TABLE RENAME statement. Otherwise, no SQL is needed since app_label is a Python/Rust concept that doesn’t affect the database schema.

Example

use reinhardt_db::migrations::operations::models::MoveModel;
use reinhardt_db::backends::schema::factory::{SchemaEditorFactory, DatabaseType};

// Without table rename
let move_op1 = MoveModel::new("User", "myapp", "auth");
let factory = SchemaEditorFactory::new();
let editor = factory.create_for_database(DatabaseType::PostgreSQL);
let sql1 = move_op1.database_forwards(editor.as_ref());
assert!(sql1.is_empty()); // No SQL needed

// With table rename
let move_op2 = MoveModel::new("User", "myapp", "auth")
    .with_table_rename("myapp_user", "auth_user");
let sql2 = move_op2.database_forwards(editor.as_ref());
assert_eq!(sql2.len(), 1);
assert!(sql2[0].contains("ALTER TABLE"));

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

Generate reverse SQL

Trait Implementations

impl Clone for MoveModel

fn clone(&self) -> MoveModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MoveModel

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MoveModel

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MigrationOperation for MoveModel

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 MoveModel

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.