Struct RustMigrationSource 

pub struct RustMigrationSource<Conn>
where
    Conn: Connection,
{ /* private fields */ }

A migration source that allows to register rust functions as migrations

The main use-case of this migration source is to allow writing migrations in Rust instead of in SQL. You need to specify at construction time which for which connection type this migration source is indented to be used with. It allows you to register different kinds of hooks to be executed as migrations later:

• A closure Fn(&mut Conn) -> QueryResult<()> that accepts a mutable connection reference as argument and returns a QueryResult<()>. This closure is executed as up migration.
• A function with a signature of fn(&mut Conn) -> QueryResult<()>. This function is executed as up migration.
• An instance of RustMigration, which allows you to register an up and a down migration as required. This type allows you also to configure the migration behaviour. See the documentation there for details.
• Any type implementing TypedMigration. This allows you to provide a custom type with custom fields to supply additional information to your migration. This trait gives you the full control over how the migration should behave. See the documentation there for details.

A single migration source can mix all of the variants of migrations listed above.

Example

use diesel::prelude::*;
use diesel_migrations::MigrationHarness;
use diesel_migrations::RustMigration;
use diesel_migrations::RustMigrationSource;
use diesel_migrations::TypedMigration;

fn migration_function(conn: &mut SqliteConnection) -> QueryResult<()> {
    diesel::sql_query("SELECT 'EXECUTE YOUR MIGRATION HERE'").execute(conn)?;
    Ok(())
}

struct CustomMigration(&'static str);

impl TypedMigration<SqliteConnection> for CustomMigration {
    fn up(&self, conn: &mut SqliteConnection) -> QueryResult<()> {
        diesel::sql_query("SELECT 'YOUR MIGRATION', ?")
            .bind::<diesel::sql_types::Text, _>(self.0)
            .execute(conn)?;
        Ok(())
    }
}

let mut rust_migrations = RustMigrationSource::<SqliteConnection>::new();

// register migrations callback
rust_migrations.add_migration(
    "2026-01-30-121720",
    "callback",
    |conn: &mut SqliteConnection| {
        diesel::sql_query("SELECT 'EXECUTE YOUR MIGRATION HERE'").execute(conn)?;
        Ok(())
    },
);

// register a migration as function
rust_migrations.add_migration("2026-01-30-122420", "function", migration_function);

// register a RustMigration
let migration = RustMigration::new(|conn| {
    diesel::sql_query("SELECT 'EXECUTE YOUR MIGRATION HERE'").execute(conn)?;
    Ok(())
})
.with_down(|conn| {
    diesel::sql_query("SELECT 'REVERT YOUR MIGRATION HERE'").execute(conn)?;
    Ok(())
});
rust_migrations.add_migration("2026-01-30-122520", "rust_migration", migration);

// register a custom migration type
rust_migrations.add_migration(
    "2026-01-30-122920", "custom_type",
    CustomMigration("your custom args"),
);

// run the migrations
let mut conn = SqliteConnection::establish(&connection_url)?;
conn.run_pending_migrations(rust_migrations)?;

Implementations

impl<Conn> RustMigrationSource<Conn>

where Conn: Connection,

pub fn new() -> Self

Create a new empty migration source

pub fn add_migration( &mut self, version: impl Into<String>, name: impl Into<String>, migration: impl TypedMigration<Conn> + 'static, ) -> Result<&mut Self, MigrationError>

Register a new migration

See the documentation on the type itself for examples

Trait Implementations

impl<Conn> Clone for RustMigrationSource<Conn>

where Conn: Connection,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Conn> Default for RustMigrationSource<Conn>

where Conn: Connection,

fn default() -> Self

Returns the “default value” for a type.

impl<Conn> MigrationSource<<Conn as Connection>::Backend> for RustMigrationSource<Conn>

where Conn: Connection + 'static,

fn migrations(&self) -> Result<Vec<Box<dyn Migration<Conn::Backend>>>>

Get a list of migrations associated with this migration source.