Struct RelationshipInfo 

pub struct RelationshipInfo {

    pub name: &'static str,
    pub related_table: &'static str,
    pub kind: RelationshipKind,
    pub local_key: Option<&'static str>,
    pub remote_key: Option<&'static str>,
    pub link_table: Option<LinkTableInfo>,
    pub back_populates: Option<&'static str>,
    pub lazy: bool,
    pub cascade_delete: bool,
    pub passive_deletes: PassiveDeletes,
    pub order_by: Option<&'static str>,
    pub lazy_strategy: Option<LazyLoadStrategy>,
    pub cascade: Option<&'static str>,
    pub uselist: Option<bool>,
}

Metadata about a relationship between models.

Fields

name: &'static str

Name of the relationship field.

related_table: &'static str

The related model’s table name.

kind: RelationshipKind

Kind of relationship.

local_key: Option<&'static str>

Local foreign key column (for ManyToOne). e.g., "team_id" on Hero.

remote_key: Option<&'static str>

Remote foreign key column (for OneToMany). e.g., "team_id" on Hero when accessed from Team.

link_table: Option<LinkTableInfo>

Link table for ManyToMany relationships.

back_populates: Option<&'static str>

The field on the related model that points back.

lazy: bool

Whether to use lazy loading (simple flag).

cascade_delete: bool

Cascade delete behavior.

passive_deletes: PassiveDeletes

Passive delete behavior - whether ORM emits DELETE or relies on DB cascade.

order_by: Option<&'static str>

Default ordering for related items (e.g., “name”, “created_at DESC”).

lazy_strategy: Option<LazyLoadStrategy>

Loading strategy for this relationship.

cascade: Option<&'static str>

Full cascade options string (e.g., “all, delete-orphan”).

uselist: Option<bool>

Force list or single (override field type inference).

• Some(true): Always return a list
• Some(false): Always return a single item
• None: Infer from field type

Implementations

impl RelationshipInfo

pub const fn new( name: &'static str, related_table: &'static str, kind: RelationshipKind, ) -> Self

Create a new relationship with required fields.

pub const fn local_key(self, key: &'static str) -> Self

Set the local foreign key column (ManyToOne).

pub const fn remote_key(self, key: &'static str) -> Self

Set the remote foreign key column (OneToMany).

pub const fn link_table(self, info: LinkTableInfo) -> Self

Set the link table metadata (ManyToMany).

pub const fn back_populates(self, field: &'static str) -> Self

Set the back-populates field name (bidirectional relationships).

pub const fn lazy(self, value: bool) -> Self

Enable/disable lazy loading.

pub const fn cascade_delete(self, value: bool) -> Self

Enable/disable cascade delete behavior.

pub const fn passive_deletes(self, value: PassiveDeletes) -> Self

Set passive delete behavior.

• PassiveDeletes::Active (default): ORM emits DELETE for related objects
• PassiveDeletes::Passive: Relies on DB ON DELETE CASCADE
• PassiveDeletes::All: Passive + disables orphan tracking

pub const fn order_by(self, ordering: &'static str) -> Self

Set default ordering for related items.

pub const fn order_by_opt(self, ordering: Option<&'static str>) -> Self

Set default ordering from optional.

pub const fn lazy_strategy(self, strategy: LazyLoadStrategy) -> Self

Set the lazy loading strategy.

pub const fn lazy_strategy_opt(self, strategy: Option<LazyLoadStrategy>) -> Self

Set the lazy loading strategy from optional.

pub const fn cascade(self, opts: &'static str) -> Self

Set full cascade options string.

pub const fn cascade_opt(self, opts: Option<&'static str>) -> Self

Set cascade options from optional.

pub const fn uselist(self, value: bool) -> Self

Force list or single.

pub const fn uselist_opt(self, value: Option<bool>) -> Self

Set uselist from optional.

pub const fn is_passive_deletes(&self) -> bool

Check if passive deletes are enabled (Passive or All).

pub const fn is_passive_deletes_all(&self) -> bool

Check if orphan tracking is disabled (passive_deletes=‘all’).

Trait Implementations

impl Clone for RelationshipInfo

fn clone(&self) -> RelationshipInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RelationshipInfo

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

Formats the value using the given formatter.

impl Default for RelationshipInfo

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for RelationshipInfo

fn eq(&self, other: &RelationshipInfo) -> 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 Copy for RelationshipInfo

impl Eq for RelationshipInfo

impl StructuralPartialEq for RelationshipInfo