Struct BelongsToMany 

pub struct BelongsToMany<R>
where
    R: Model,
{ /* private fields */ }

Available on crate features model-mysql or model-postgres or model-sqlite only.

Many-to-many through a join table (18.30.0): the rows of R one owner is linked to, and the links themselves — attach, detach, sync.

The join table holds the owner’s key in owner_key and R’s in related_key; give it a primary key or unique index over both (the methods never insert a link twice, but two processes attaching at once could). Other columns need defaults: the methods insert the two keys only. Relation::belongs_to_many loads the same links for a whole result set.

impl Post {
    pub fn tags(&self) -> BelongsToMany<Tag> {
        BelongsToMany::new(Value::Int(self.id), "post_tags", "post_id", "tag_id")
    }
}
post.tags().attach(&pool, [1, 2]).await?;
post.tags().sync(&pool, [1, 3]).await?; // detaches 2, attaches 3
let tags: Vec<Tag> = post.tags().load(&pool).await?;

Implementations

impl<R> BelongsToMany<R>

where R: Model,

pub fn new( owner_pk: Value, join_table: &'static str, owner_key: &'static str, related_key: &'static str, ) -> BelongsToMany<R>

The links of the owner with key owner_pk in join_table.

pub async fn load(&self, pool: &DbPool) -> Result<Vec<R>, DbError>

The linked rows of R (soft-deleted ones left out), by primary key.

pub async fn ids(&self, pool: &DbPool) -> Result<Vec<Value>, DbError>

The related keys linked to the owner, as the join table holds them.

pub async fn attach<I>(&self, pool: &DbPool, ids: I) -> Result<u64, DbError>

where I: IntoIterator, <I as IntoIterator>::Item: ToColumn,

Link the owner to each of ids it isn’t linked to yet, in one transaction; answers how many links were added.

pub async fn detach<I>(&self, pool: &DbPool, ids: I) -> Result<u64, DbError>

where I: IntoIterator, <I as IntoIterator>::Item: ToColumn,

Unlink the owner from each of ids; answers how many links were removed.

pub async fn detach_all(&self, pool: &DbPool) -> Result<u64, DbError>

Unlink the owner from every row; answers how many links were removed.

pub async fn sync<I>( &self, pool: &DbPool, ids: I, ) -> Result<SyncChanges, DbError>

where I: IntoIterator, <I as IntoIterator>::Item: ToColumn,

Make ids the owner’s links, exactly: unlink the others and link the missing ones, in one transaction.

Trait Implementations

impl<R> Clone for BelongsToMany<R>

where R: Model,

fn clone(&self) -> BelongsToMany<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for BelongsToMany<R>

where R: Model,

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

Formats the value using the given formatter.