Struct migrant_lib::config::Config

pub struct Config { /* fields omitted */ }

Full project configuration

Methods

impl Config

fn use_migrations(
    &mut self,
    migrations: Vec<Box<Migratable>>
) -> Result<&mut Self>

Define an explicit set of Migratable migrations to use.

When using explicit migrations, make sure they are defined on the Config instance before applied migrations are loaded from the database. This is required because tag format requirements are stricter for implicit (file-system based) migrations, requiring a timestamp to maintain a deterministic order.

Example

extern crate migrant_lib;
use migrant_lib::{
    Config, search_for_settings_file,
    EmbeddedMigration, FileMigration, FnMigration
};

mod migrations {
    use super::*;
    pub struct Custom;
    impl Custom {
        pub fn up(_: migrant_lib::DbConn) -> Result<(), Box<std::error::Error>> {
            print!(" <[Up!]>");
            Ok(())
        }
        pub fn down(_: migrant_lib::DbConn) -> Result<(), Box<std::error::Error>> {
            print!(" <[Down!]>");
            Ok(())
        }
    }
}

let p = search_for_settings_file(&std::env::current_dir()?)
    .ok_or_else(|| "Settings file not found")?;
let mut config = Config::from_settings_file(&p)?;
config.use_migrations(vec![
    EmbeddedMigration::with_tag("initial")?
        .up(include_str!("../migrations/embedded/initial/up.sql"))
        .down(include_str!("../migrations/embedded/initial/down.sql"))
        .boxed(),
    FileMigration::with_tag("second")?
        .up("migrations/embedded/second/up.sql")?
        .down("migrations/embedded/second/down.sql")?
        .boxed(),
    FnMigration::with_tag("custom")?
        .up(migrations::Custom::up)
        .down(migrations::Custom::down)
        .boxed(),
])?;

// Load applied migrations
let config = config.reload()?;

fn is_explicit(&self) -> bool

Migrations are explicitly defined

fn reload(&self) -> Result<Config>

Do a full reload of the configuration file (only if a settings file is being used) and query the database to load applied migrations, keeping track of manually specified migrations.

fn from_settings_file<T: AsRef<Path>>(path: T) -> Result<Config>

Load config file from the given path without querying the database to check for applied migrations

fn with_settings(s: &Settings) -> Config

Initialize a Config using an explicitly created Settings object. This alleviates the need for a settings file.

let settings = Settings::configure_sqlite()
    .database_path("/absolute/path/to/db.db")?
    .migration_location("/absolute/path/to/migration_dir")?
    .build()?;
let config = Config::with_settings(&settings);
// Setup migrations table
config.setup()?;

// Reload config, ping the database for applied migrations
let config = config.reload()?;

fn init_in<T: AsRef<Path>>(dir: T) -> SettingsFileInitializer

Initialize a new settings file in the given directory

fn setup(&self) -> Result<bool>

Confirm the database can be accessed and setup the database migrations table if it doesn't already exist

fn migration_dir(&self) -> Result<PathBuf>

Return the absolute path to the directory containing migration folders

fn database_type(&self) -> DbKind

Return the database type

fn database_path(&self) -> Result<PathBuf>

Return the absolute path to the database file. This is intended for sqlite databases only

fn connect_string(&self) -> Result<String>

Generate a database connection string. Not intended for file-based databases (sqlite)

Trait Implementations

impl Debug for Config

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

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

Performs copy-assignment from source.