Struct ResolvedRelation 

pub struct ResolvedRelation {
    pub source_model: String,
    pub source_field: String,
    pub target_model: String,
    pub target_table: String,
    pub target_admin_name: String,
    pub target_display_field: Option<String>,
    pub kind: RelationKind,
}

One forward (BelongsTo) relation resolved against the schema.

Carries enough information for the admin to:

1. render the FK column (target_model, target_table, target_display_field);
2. link to the target’s detail page (target_admin_name);
3. issue the batched prefetch query for list pages.

Everything is owned String rather than &'static str because the registry is built from a parsed Schema whose String fields outlive the registry. Copying costs once at schema-reload time and buys simple lifetimes everywhere else.

Fields

source_model: String

Model name holding the FK column, e.g. "Appointment".

source_field: String

Field on the source carrying the id, e.g. "patient_id".

target_model: String

Target model name, e.g. "Patient".

target_table: String

Target model’s SQL table, e.g. "patients".

target_admin_name: String

Target model’s admin slug, e.g. "patients" — what appears in /admin/<slug>/<id> URLs.

target_display_field: Option<String>

Column on the target whose value is rendered as the human label. None means the admin renders #<id> and does NOT infer a column — display-field guessing is explicitly off.

kind: RelationKind

Direction marker. Always BelongsTo for forward relations.

Trait Implementations

impl Clone for ResolvedRelation

fn clone(&self) -> ResolvedRelation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedRelation

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

Formats the value using the given formatter.

impl PartialEq for ResolvedRelation

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

impl StructuralPartialEq for ResolvedRelation