Struct Migration 

pub struct Migration {
    pub name: String,
    pub app_label: String,
    pub operations: Vec<Operation>,
    pub dependencies: Vec<(String, String)>,
    pub replaces: Vec<(String, String)>,
    pub atomic: bool,
    pub initial: Option<bool>,
    pub state_only: bool,
    pub database_only: bool,
    pub swappable_dependencies: Vec<SwappableDependency>,
    pub optional_dependencies: Vec<OptionalDependency>,
}

Available on crate feature database and non-WebAssembly only.

A database migration

Fields

name: String

Migration name (e.g., “0001_initial”)

app_label: String

App label

operations: Vec<Operation>

Operations to apply

dependencies: Vec<(String, String)>

Dependencies (app_label, migration_name)

replaces: Vec<(String, String)>

Migrations this replaces

atomic: bool

Whether this is wrapped in a transaction

initial: Option<bool>

Whether this is an initial migration (explicit or inferred from dependencies)

• Some(true): Explicitly marked as initial
• Some(false): Explicitly marked as non-initial
• None: Auto-infer from dependencies.is_empty()

state_only: bool

Whether to update only ProjectState without executing database operations (Django’s SeparateDatabaseAndState equivalent with state_operations only)

database_only: bool

Whether to execute only database operations without updating ProjectState (Django’s SeparateDatabaseAndState equivalent with database_operations only)

swappable_dependencies: Vec<SwappableDependency>

Swappable dependencies (e.g., AUTH_USER_MODEL pattern)

These dependencies resolve to different apps based on settings. For example, a migration depending on the User model might use:

swappable_dependencies: vec![
    SwappableDependency::new("AUTH_USER_MODEL", "auth", "User", "0001_initial")
]

optional_dependencies: Vec<OptionalDependency>

Optional dependencies (conditional based on app installation or settings)

These dependencies are only enforced when their condition is met. For example, a migration might optionally depend on PostGIS:

optional_dependencies: vec![
    OptionalDependency::new(
        "gis_extension",
        "0001_enable_postgis",
        DependencyCondition::AppInstalled("gis_extension".to_string())
    )
]

Implementations

impl Migration

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

Create a new migration

Examples

use reinhardt_db::migrations::Migration;

let migration = Migration::new("0001_initial", "myapp");
assert_eq!(migration.name, "0001_initial");
assert_eq!(migration.app_label, "myapp");
assert!(migration.atomic);

pub fn add_operation(self, operation: Operation) -> Migration

Add an operation to this migration

Examples

use reinhardt_db::migrations::{Migration, Operation, ColumnDefinition, FieldType};

let migration = Migration::new("0001_initial", "myapp")
    .add_operation(Operation::CreateTable {
        name: "users".to_string(),
        columns: vec![ColumnDefinition::new("id", FieldType::Custom("INTEGER PRIMARY KEY".to_string()))],
        constraints: vec![],
        without_rowid: None,
        interleave_in_parent: None,
        partition: None,
    });

assert_eq!(migration.operations.len(), 1);

pub fn add_dependency( self, app_label: impl Into<String>, name: impl Into<String>, ) -> Migration

Add a dependency to this migration

Examples

use reinhardt_db::migrations::Migration;

let migration = Migration::new("0002_add_field", "myapp")
    .add_dependency("myapp", "0001_initial");

assert_eq!(migration.dependencies.len(), 1);
assert_eq!(migration.dependencies[0].0, "myapp");
assert_eq!(migration.dependencies[0].1, "0001_initial");

pub fn add_swappable_dependency( self, dependency: SwappableDependency, ) -> Migration

Add a swappable dependency to this migration

Swappable dependencies resolve to different apps based on settings. This is used for Django’s AUTH_USER_MODEL pattern.

Examples

use reinhardt_db::migrations::Migration;
use reinhardt_db::migrations::dependency::SwappableDependency;

let migration = Migration::new("0001_create_profile", "profiles")
    .add_swappable_dependency(SwappableDependency::new(
        "AUTH_USER_MODEL",
        "auth",
        "User",
        "0001_initial",
    ));

assert_eq!(migration.swappable_dependencies.len(), 1);

pub fn add_optional_dependency( self, dependency: OptionalDependency, ) -> Migration

Add an optional dependency to this migration

Optional dependencies are only enforced when their condition is met. This is useful for migrations that depend on optional features or apps.

Examples

use reinhardt_db::migrations::Migration;
use reinhardt_db::migrations::dependency::{OptionalDependency, DependencyCondition};

let migration = Migration::new("0002_add_location", "geo_app")
    .add_optional_dependency(OptionalDependency::new(
        "gis_extension",
        "0001_enable_postgis",
        DependencyCondition::AppInstalled("gis_extension".to_string()),
    ));

assert_eq!(migration.optional_dependencies.len(), 1);

pub fn atomic(self, atomic: bool) -> Migration

Set whether this migration should run in a transaction

Examples

use reinhardt_db::migrations::Migration;

let migration = Migration::new("0001_initial", "myapp")
    .atomic(false);

assert!(!migration.atomic);

pub fn id(&self) -> String

Get full migration identifier

Examples

use reinhardt_db::migrations::Migration;

let migration = Migration::new("0001_initial", "myapp");
assert_eq!(migration.id(), "myapp.0001_initial");

pub fn initial(self, initial: bool) -> Migration

Set initial attribute explicitly

Examples

use reinhardt_db::migrations::Migration;

let migration = Migration::new("0001_initial", "myapp")
    .initial(true);

assert!(migration.is_initial());

pub fn state_only(self, value: bool) -> Migration

Set whether to update only ProjectState without database operations

Examples

use reinhardt_db::migrations::Migration;

let migration = Migration::new("0001_state_sync", "myapp")
    .state_only(true);

assert!(migration.state_only);
assert!(!migration.database_only);

pub fn database_only(self, value: bool) -> Migration

Set whether to execute only database operations without ProjectState updates

Examples

use reinhardt_db::migrations::Migration;

let migration = Migration::new("0001_db_only", "myapp")
    .database_only(true);

assert!(migration.database_only);
assert!(!migration.state_only);

pub fn is_initial(&self) -> bool

Check if this is an initial migration

Returns true if:

• initial is explicitly set to Some(true), OR
• initial is None and dependencies is empty

Examples

use reinhardt_db::migrations::Migration;

// Explicitly marked as initial
let migration1 = Migration::new("0001_initial", "myapp")
    .initial(true);
assert!(migration1.is_initial());

// Auto-inferred from empty dependencies
let migration2 = Migration::new("0001_initial", "myapp");
assert!(migration2.is_initial());

// Has dependencies, not initial
let migration3 = Migration::new("0002_add_field", "myapp")
    .add_dependency("myapp", "0001_initial");
assert!(!migration3.is_initial());

// Explicitly marked as non-initial
let migration4 = Migration::new("0001_custom", "myapp")
    .initial(false);
assert!(!migration4.is_initial());

Trait Implementations

impl Clone for Migration

fn clone(&self) -> Migration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Migration

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

Formats the value using the given formatter.

impl Default for Migration

fn default() -> Migration

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Migration

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Migration

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.