Struct HasOne 

pub struct HasOne {
    pub target: ModelId,
    pub expr_ty: Type,
    pub pair: FieldId,
}

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

A HasOne field on model A means “A has exactly one B”. The actual foreign key lives on model B as a BelongsTo field. The two sides are linked via the pair field.

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.

pair: FieldId

The BelongsTo field on the target model that pairs with this relation.

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 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.