Struct HasOne 

pub struct HasOne {
    pub target: ModelId,
    pub expr_ty: Type,
    pub kind: HasKind,
}

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

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

Examples

// Given a `User` model that has one `Profile`:
let has_one: &HasOne = user_field.ty.as_has_one_unwrap();
let profile_model = has_one.target(&schema);
let inverse = has_one.pair(&schema); // the BelongsTo on Profile

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.

kind: HasKind

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

Implementations

impl HasOne

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 HasOne

fn clone(&self) -> HasOne

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HasOne

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

Formats the value using the given formatter.

impl From<HasOne> for FieldTy

fn from(value: HasOne) -> Self

Converts to this type from the input type.