Struct Pivot 

pub struct Pivot<L = i64, R = i64> { /* private fields */ }

A many-to-many relation through a pivot table with two id columns, e.g. Pivot::new("product_tags", "product_id", "tag_id"). Give the table a unique index on both columns. The table may have more columns (a role, a quantity): set them with Pivot::attach_with and Pivot::update_pivot, read them with Pivot::load_with_pivot.

L and R are the key types of the two sides, i64 unless given: const TAGS: Pivot<Ulid, i64> = Pivot::new("invoice_tags", "invoice_id", "tag_id");

Implementations

impl<L, R> Pivot<L, R>

pub const fn new( table: &'static str, left: &'static str, right: &'static str, ) -> Self

A pivot table joining the left key column to the right key column.

pub const fn with_timestamps(self) -> Self

The pivot table has created_at and updated_at columns, which attaching and Pivot::update_pivot fill.

pub const fn inverse(self) -> Pivot<R, L>

The same pivot seen from the other side (tag_id → product_id).

impl<L: ModelKey, R: ModelKey> Pivot<L, R>

pub async fn ids<'c>(&self, db: impl Executor<'c>, left: L) -> Result<Vec<R>>

The right-hand ids linked to left.

pub async fn attach<'c>( &self, db: impl Executor<'c>, left: L, rights: impl IntoIterator<Item = R>, ) -> Result<u64>

Links left to each of rights that isn’t linked yet; returns how many links were added.

pub async fn attach_with<'c>( &self, db: impl Executor<'c>, left: L, right: R, data: PivotData<'_>, ) -> Result<bool>

Links left to right with extra pivot columns, unless they’re linked already (change those with Pivot::update_pivot); returns whether a link was added.

const MEMBERS: Pivot = Pivot::new("team_user", "team_id", "user_id").with_timestamps();
MEMBERS.attach_with(&db, 1, 7, &[("role", &"admin")]).await?;
MEMBERS.update_pivot(&db, 1, 7, &[("role", &"member")]).await?;

pub async fn update_pivot<'c>( &self, db: impl Executor<'c>, left: L, right: R, data: PivotData<'_>, ) -> Result<bool>

Changes extra columns of the link between left and right (and updated_at with timestamps); returns whether they were linked.

pub async fn toggle( &self, db: &Db, left: L, rights: impl IntoIterator<Item = R>, ) -> Result<(Vec<R>, Vec<R>)>

Links each of rights that isn’t linked to left and unlinks each that is, in one transaction; returns (attached, detached).

pub async fn detach<'c>( &self, db: impl Executor<'c>, left: L, rights: impl IntoIterator<Item = R>, ) -> Result<u64>

Unlinks left from rights; returns how many links were removed.

pub async fn sync( &self, db: &Db, left: L, rights: impl IntoIterator<Item = R>, ) -> Result

Makes left linked to exactly rights (e.g. the checked boxes of a form), in one transaction.

pub fn load<'a, T: Model<Key = R> + Clone>( &'a self, db: &'a Db, lefts: impl IntoIterator<Item = L>, ) -> impl Future<Output = Result<HashMap<L, Vec<T>>>> + Send + 'a

The right-hand models linked to each left id, in one query per table.

pub fn load_with_pivot<'a, T: Model<Key = R> + Clone, D: FromRow + Send + 'a>( &'a self, db: &'a Db, lefts: impl IntoIterator<Item = L>, ) -> impl Future<Output = Result<HashMap<L, Vec<(T, D)>>>> + Send + 'a

Like Pivot::load, with each model’s pivot row decoded as D (a #[derive(FromRow)] struct naming the pivot columns it wants).

#[derive(FromRow)]
struct Membership { role: String }

let members = MEMBERS.load_with_pivot::<User, Membership>(&db, [1]).await?;
for (user, membership) in members.get(&1).map_or(&[][..], Vec::as_slice) {
    println!("{} is {}", user.name, membership.role);
}

pub fn load_for<'a, T: Model<Key = R> + Clone, P: Model<Key = L>>( &'a self, db: &'a Db, parents: &[P], ) -> impl Future<Output = Result<HashMap<L, Vec<T>>>> + Send + 'a

load for these parents’ ids.

Trait Implementations

impl<L, R> Clone for Pivot<L, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L, R> Copy for Pivot<L, R>

impl<L, R> Debug for Pivot<L, R>

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

Formats the value using the given formatter.