Struct Relation 

pub struct Relation<O, R> { /* private fields */ }

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

How a model O reaches related rows of R: for QueryBuilder::with, and to load the rows of one owner (load) or of many (load_for). Usually returned by an associated function of the owner, so call sites name it:

impl User {
    pub fn posts() -> Relation<User, Post> { Relation::has_many("user_id") }
}
let posts: Vec<Post> = User::posts().load(&pool, &user).await?;

Implementations

impl<O, R> Relation<O, R>

where O: Model, R: Model,

pub fn has_many(foreign_key: &'static str) -> Relation<O, R>

One owner, many R: R’s column foreign_key holds the owner’s primary key (Relation::<User, Post>::has_many("user_id")).

pub fn has_one(foreign_key: &'static str) -> Relation<O, R>

As has_many, at most one R per owner (the one with the lowest primary key when there are more).

pub fn belongs_to(foreign_key: &'static str) -> Relation<O, R>

The owner’s column foreign_key holds R’s primary key (Relation::<Post, User>::belongs_to("user_id")); NULL means none.

pub fn belongs_to_many( join_table: &'static str, owner_key: &'static str, related_key: &'static str, ) -> Relation<O, R>

Many-to-many through join_table, whose column owner_key holds the owner’s primary key and related_key R’s (Relation::<Post, Tag>::belongs_to_many("post_tags", "post_id", "tag_id")). BelongsToMany adds and removes the links.

pub fn kind(&self) -> RelationKind

What the relation is.

pub fn foreign_key(&self) -> &'static str

The column holding the key that links the two: R’s for HasMany/HasOne, O’s for BelongsTo, the join table’s owner column for BelongsToMany.

pub fn join_table(&self) -> Option<(&'static str, &'static str)>

BelongsToMany: the join table and its column holding R’s key.

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

where R: Clone,

The related rows of one owner (one query).

pub async fn load_for( &self, pool: &DbPool, owners: &[O], ) -> Result<Vec<Vec<R>>, DbError>

where R: Clone,

The related rows of every owner, in the owners’ order — one query per IN_BATCH distinct keys, the related rows by primary key. A row related to several owners (a shared author, a tag) is cloned into each.

Trait Implementations

impl<O, R> Clone for Relation<O, R>

fn clone(&self) -> Relation<O, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O, R> Copy for Relation<O, R>

impl<O, R> Debug for Relation<O, R>

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

Formats the value using the given formatter.