Struct MigrationRunner 

pub struct MigrationRunner<'a, Ctx, S>
where
    S: MigrationStore,
{ /* private fields */ }

Runs migrations against a context using a store for tracking.

Generic parameters:

• Ctx: The context passed to migrations (e.g., database connection)
• S: The store implementation for tracking applied migrations

Implementations

impl<'a, Ctx, S> MigrationRunner<'a, Ctx, S>

where S: MigrationStore,

pub fn new(store: S) -> MigrationRunner<'a, Ctx, S>

pub fn into_store(self) -> S

Consume the runner and return the store

pub fn store(&self) -> &S

Get a reference to the store

pub fn store_mut(&mut self) -> &mut S

Get a mutable reference to the store

pub fn add<M>(self, migration: M) -> MigrationRunner<'a, Ctx, S>

where M: Migration<Ctx> + 'a,

Add a migration

pub fn add_all<I, M>(self, migrations: I) -> MigrationRunner<'a, Ctx, S>

where I: IntoIterator<Item = M>, M: Migration<Ctx> + 'a,

Add multiple migrations

pub fn init(&mut self) -> Result<(), Error>

Initialize store and validate migrations

pub fn current_version(&self) -> Result<u64, Error>

Get current schema version

pub fn status(&self) -> Result<Vec<MigrationStatus>, Error>

Get status of all migrations

pub fn pending(&self) -> Result<Vec<&dyn Migration<Ctx>>, Error>

Get pending (unapplied) migrations

pub fn pending_phase( &self, phase: Phase, ) -> Result<Vec<&dyn Migration<Ctx>>, Error>

Get pending migrations for a specific phase

pub fn migrate(&mut self, ctx: &mut Ctx) -> Result<usize, Error>

Run all pending migrations

pub fn migrate_phase( &mut self, ctx: &mut Ctx, phase: Phase, ) -> Result<usize, Error>

Run pending migrations for a specific phase only

pub fn dry_run(&self) -> Result<DryRunResult, Error>

Dry-run: show what would be applied without actually applying

pub fn dry_run_phase(&self, phase: Phase) -> Result<DryRunResult, Error>

Dry-run for a specific phase

pub fn migrate_to(&mut self, ctx: &mut Ctx, target: u64) -> Result<usize, Error>

Migrate to a specific version (up or down)