Struct HasManyThrough

pub struct HasManyThrough<T>(/* private fields */);

A “has many through” association.

Imagine you have these models:

struct User {
    id: i32,
}

struct Company {
    id: i32,
}

struct Employments {
    id: i32,
    user_id: i32,
    company_id: i32,
}

For this setup we say “user has many companies through employments”. This means uses can work at many companies and companies can have many employees, provided that we join with Employment.

This requires that we use the JoinModel type on EagerLoadChildrenOfType and is therefore a bit different from the other associations since it involves a third type.

Example

You can find a complete example of HasManyThrough here.

Attributes

Name	Description	Default	Example
model_field	The field on the contained type that holds the model	{name of contained type} in snakecase	model_field = company
join_model	The model we have to join with	N/A	join_model = models::Employment
child_primary_key_field_on_join_model	The field on the join model that holds the primary key of the child model (Company in the example above)	{name of model}_id	child_primary_key_field_on_join_model = company_identifier
foreign_key_field	The field on the join model that holds the primary key of the parent model (User in the example above)	{name of model}_id	foreign_key_field = user_identifier
child_primary_key_field	The field on the child model that holds its primary key	id	foreign_key_field = identifier
graphql_field	The name of this field in your GraphQL schema	{name of field}	graphql_field = country
predicate_method	Method used to filter child associations. This can be used if you only want to include a subset of the models. This method will be called to filter the join models.	N/A (attribute is optional)	predicate_method = a_predicate_method

Additionally it also supports the attributes print, skip, and field_arguments. See the root model docs for more into on those.

Errors

try_unwrap will never error. If the association wasn’t loaded or wasn’t found it will return Ok(vec![]).

Implementations

impl<T> HasManyThrough<T>

pub fn try_unwrap(&self) -> Result<&Vec<T>, Error>

Borrow the loaded values. If no values have been loaded it will return an empty list. It will not return an error.

Trait Implementations

impl<T> Association<T> for HasManyThrough<T>

fn loaded_child(&mut self, child: T)

Store the loaded child on the association.

fn assert_loaded_otherwise_failed(&mut self)

The association should have been loaded by now, if not store an error inside the association (if applicable for the particular association).

impl<T: Clone> Clone for HasManyThrough<T>

fn clone(&self) -> HasManyThrough<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HasManyThrough<T>

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

Formats the value using the given formatter.

impl<T> Default for HasManyThrough<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Ord> Ord for HasManyThrough<T>

fn cmp(&self, other: &HasManyThrough<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for HasManyThrough<T>

fn eq(&self, other: &HasManyThrough<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for HasManyThrough<T>

fn partial_cmp(&self, other: &HasManyThrough<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq> Eq for HasManyThrough<T>

impl<T> StructuralPartialEq for HasManyThrough<T>