Struct TransactionMigrate

pub struct TransactionMigrate<'t, FromSchema> { /* private fields */ }

Transaction type for use in migrations.

Implementations

impl<'t, FromSchema> TransactionMigrate<'t, FromSchema>

pub fn migrate_optional<M: Migration<'t, FromSchema = FromSchema>, X: FromExpr<'t, FromSchema, M::From>>( &mut self, f: impl FnMut(X) -> Option<M>, ) -> Result<(), M::Conflict>

Migrate some rows to the new schema.

This will return an error when there is a conflict. The error type depends on the number of unique constraints that the migration can violate:

• 0 => Infallible
• 1.. => TableRow<T::From> (row in the old table that could not be migrated)

pub fn migrate<M: Migration<'t, FromSchema = FromSchema>, X: FromExpr<'t, FromSchema, M::From>>( &mut self, f: impl FnMut(X) -> M, ) -> Result<Migrated<'t, FromSchema, M::To>, M::Conflict>

Migrate all rows to the new schema.

Conflict errors work the same as in Self::migrate_optional.

However, this method will return Migrated when all rows are migrated. This can then be used as proof that there will be no foreign key violations.

pub fn migrate_ok<M: Migration<'t, FromSchema = FromSchema, Conflict = Infallible>, X: FromExpr<'t, FromSchema, M::From>>( &mut self, f: impl FnMut(X) -> M, ) -> Migrated<'t, FromSchema, M::To>

Helper method for Self::migrate.

It can only be used when the migration is known to never cause unique constraint conflicts.

Methods from Deref<Target = Transaction<'t, FromSchema>>

pub fn query<F, R>(&self, f: F) -> R

where F: for<'inner> FnOnce(&mut Query<'t, 'inner, S>) -> R,

Execute a query with multiple results.

let user_names = txn.query(|rows| {
    let user = rows.join(User);
    rows.into_vec(user.name())
});
assert_eq!(user_names, vec!["Alice".to_owned()]);

pub fn query_one<'e, O>(&self, val: impl IntoSelect<'t, 't, S, Out = O>) -> O

Retrieve a single result from the database.

let res = txn.query_one("test".into_expr());
assert_eq!(res, "test");

Instead of using Self::query_one in a loop, it is better to call Self::query and return all results at once.

Trait Implementations

impl<'t, FromSchema> Deref for TransactionMigrate<'t, FromSchema>

type Target = Transaction<'t, FromSchema>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.