Struct rusqlite_migration::AsyncMigrations

pub struct AsyncMigrations { /* private fields */ }

Available on crate feature alpha-async-tokio-rusqlite only.

Adapter to make Migrations available in an async context.

Implementations

impl AsyncMigrations

pub fn new(ms: Vec<M<'static>>) -> Self

Create a proxy struct to a Migrations instance for use in an asynchronous context.

Example

use rusqlite_migration::{Migrations, AsyncMigrations, M};

let migrations = AsyncMigrations::new(vec![
    M::up("CREATE TABLE animals (name TEXT);"),
    M::up("CREATE TABLE food (name TEXT);"),
]);

pub fn from_directory(dir: &'static Dir<'static>) -> Result<Self>

Available on crate feature from-directory only.

Proxy implementation of the same method in the Migrations struct.

Example

use rusqlite_migration::AsyncMigrations;
use include_dir::{Dir, include_dir};

static MIGRATION_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/../examples/from-directory/migrations");
let migrations = AsyncMigrations::from_directory(&MIGRATION_DIR).unwrap();

pub async fn current_version( &self, async_conn: &AsyncConnection ) -> Result<SchemaVersion>

Asynchronous version of the same method in the Migrations struct.

Example

use rusqlite_migration::{Migrations, AsyncMigrations, M, SchemaVersion};
use std::num::NonZeroUsize;

let mut conn = tokio_rusqlite::Connection::open_in_memory().await.unwrap();

let migrations = AsyncMigrations::new(vec![
    M::up("CREATE TABLE animals (name TEXT);"),
    M::up("CREATE TABLE food (name TEXT);"),
]);

assert_eq!(SchemaVersion::NoneSet, migrations.current_version(&conn).await.unwrap());

// Go to the latest version
migrations.to_latest(&mut conn).await.unwrap();

assert_eq!(SchemaVersion::Inside(NonZeroUsize::new(2).unwrap()), migrations.current_version(&conn).await.unwrap());

pub async fn to_latest(&self, async_conn: &mut AsyncConnection) -> Result<()>

Asynchronous version of the same method in the Migrations struct.

Example

use rusqlite_migration::{Migrations, AsyncMigrations, M};
let mut conn = tokio_rusqlite::Connection::open_in_memory().await.unwrap();

let migrations = AsyncMigrations::new(vec![
    M::up("CREATE TABLE animals (name TEXT);"),
    M::up("CREATE TABLE food (name TEXT);"),
]);

// Go to the latest version
migrations.to_latest(&mut conn).await.unwrap();

// You can then insert values in the database
conn.call_unwrap(|conn| conn.execute("INSERT INTO animals (name) VALUES (?)", ["dog"])).await.unwrap();
conn.call_unwrap(|conn| conn.execute("INSERT INTO food (name) VALUES (?)", ["carrot"])).await.unwrap();

pub async fn to_version( &self, async_conn: &mut AsyncConnection, version: usize ) -> Result<()>

Asynchronous version of the same method in the Migrations struct.

Example

use rusqlite_migration::{Migrations, AsyncMigrations, M};
let mut conn = tokio_rusqlite::Connection::open_in_memory().await.unwrap();
let migrations = AsyncMigrations::new(vec![
    // 0: version 0, before having run any migration
    M::up("CREATE TABLE animals (name TEXT);").down("DROP TABLE animals;"),
    // 1: version 1, after having created the “animals” table
    M::up("CREATE TABLE food (name TEXT);").down("DROP TABLE food;"),
    // 2: version 2, after having created the food table
]);

migrations.to_latest(&mut conn).await.unwrap(); // Create all tables

// Go back to version 1, i.e. after running the first migration
migrations.to_version(&mut conn, 1).await;
conn.call(|conn| Ok(conn.execute("INSERT INTO animals (name) VALUES (?)", ["dog"]))).await.unwrap();
conn.call(|conn| Ok(conn.execute("INSERT INTO food (name) VALUES (?)", ["carrot"]).unwrap_err())).await;

// Go back to an empty database
migrations.to_version(&mut conn, 0).await;
conn.call(|conn| Ok(conn.execute("INSERT INTO animals (name) VALUES (?)", ["cat"]).unwrap_err())).await;
conn.call(|conn| Ok(conn.execute("INSERT INTO food (name) VALUES (?)", ["milk"]).unwrap_err())).await;

pub async fn validate(&self) -> Result<()>

Asynchronous version of the same method in the Migrations struct.

Example

#[cfg(test)]
mod tests {

    // … Other tests …

    #[tokio::test]
    fn migrations_test() {
        assert!(migrations.validate().await.is_ok());
    }
}

Trait Implementations

impl Clone for AsyncMigrations

fn clone(&self) -> AsyncMigrations

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AsyncMigrations

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

Formats the value using the given formatter.

impl FromIterator<M<'static>> for AsyncMigrations

fn from_iter<T: IntoIterator<Item = M<'static>>>(iter: T) -> Self

Creates a value from an iterator.

impl PartialEq for AsyncMigrations

fn eq(&self, other: &AsyncMigrations) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for AsyncMigrations

impl StructuralPartialEq for AsyncMigrations