Struct HasMany 

pub struct HasMany {
    pub target: ModelId,
    pub expr_ty: Type,
    pub singular: Name,
    pub kind: HasKind,
}

The inverse side of a one-to-many relationship.

A HasMany field on model A means “A has many Bs”. A direct HasMany pairs with a BelongsTo field on model B that holds the foreign key; a multi-step (via) HasMany reaches B by following a path of existing relations. Which one it is is recorded in kind.

Examples

// Given a `User` model that has many `Post`s:
let has_many: &HasMany = user_field.ty.as_has_many_unwrap();
let post_model = has_many.target(&schema);
let inverse = has_many.pair(&schema); // the BelongsTo on Post

Fields

target: ModelId

The ModelId of the associated (target) model.

expr_ty: Type

The expression type this field evaluates to from the application’s perspective.

singular: Name

The singular name for one associated item (used in generated method names).

kind: HasKind

How this relation reaches its target — a paired BelongsTo (HasKind::Direct) or a Via path (HasKind::Via).

Implementations

impl HasMany

pub fn target<'a>(&self, schema: &'a Schema) -> &'a Model

Resolves the target Model from the given schema.

pub fn pair<'a>(&self, schema: &'a Schema) -> &'a BelongsTo

Resolves the paired BelongsTo relation on the target model.

Panics

Panics if this is a multi-step (via) relation — it has no pair — or if the paired field is not a BelongsTo variant.

Trait Implementations

impl Clone for HasMany

fn clone(&self) -> HasMany

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HasMany

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

Formats the value using the given formatter.