Struct HasMany 

pub struct HasMany<P, C> { /* private fields */ }

One parent, many children.

// A user has many posts, found by `posts.user_id`.
HasMany::<User, Post>::new()

Implementations

impl<P, C> HasMany<P, C>

where P: Model, C: Model,

pub fn new() -> HasMany<P, C>

With the conventional keys: posts.user_id matched against users.id.

pub fn foreign_key(self, column: impl Into<String>) -> HasMany<P, C>

The column on the child pointing back at the parent.

pub fn local_key(self, column: impl Into<String>) -> HasMany<P, C>

The column on the parent the child points at. Defaults to its key.

pub fn matching(self, criteria: Criteria) -> HasMany<P, C>

Narrow, order or limit the children — a constrained eager load.

A limit here limits the whole query, not each parent’s share: one query cannot take the newest three per parent without a window function, and pretending otherwise would silently drop rows.

Trait Implementations

impl<P, C> Default for HasMany<P, C>

where P: Model, C: Model,

fn default() -> HasMany<P, C>

Returns the “default value” for a type.

impl<P, C> Relation<P> for HasMany<P, C>

where P: Model, C: Model,

type Related = C

The model on the other side.

fn near_key(&self) -> &str

The column on P that identifies it in this relationship.

fn far_key(&self) -> &str

The column on the other side that this relationship matches against.

fn load<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, parents: &'life1 [P], related: &'life2 (dyn Repository<C> + 'static), ) -> Pin<Box<dyn Future<Output = Result<Related<C>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, HasMany<P, C>: 'async_trait,

Load the related rows for every parent, in one query.

fn count<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, parents: &'life1 [P], related: &'life2 (dyn Repository<C> + 'static), ) -> Pin<Box<dyn Future<Output = Result<RelatedCounts, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, HasMany<P, C>: 'async_trait,

Count the related rows for every parent, in one query, without transferring them.

fn for_one<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, parent: &'life1 P, related: &'life2 (dyn Repository<Self::Related> + 'static), ) -> Pin<Box<dyn Future<Output = Result<Vec<Self::Related>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sized + 'async_trait,

Load for a single parent.