Struct sea_orm::entity::prelude::RelationDef

pub struct RelationDef {
    pub rel_type: RelationType,
    pub from_tbl: TableRef,
    pub to_tbl: TableRef,
    pub from_col: Identity,
    pub to_col: Identity,
    pub is_owner: bool,
    pub on_delete: Option<ForeignKeyAction>,
    pub on_update: Option<ForeignKeyAction>,
    pub on_condition: Option<Box<dyn Fn(DynIden, DynIden) -> Condition + Send + Sync>>,
    pub fk_name: Option<String>,
}

Defines a relationship

Fields

rel_type: RelationType

The type of relationship defined in RelationType

from_tbl: TableRef

Reference from another Entity

to_tbl: TableRef

Reference to another ENtity

from_col: Identity

Reference to from a Column

to_col: Identity

Reference to another column

is_owner: bool

Defines the owner of the Relation

on_delete: Option<ForeignKeyAction>

Defines an operation to be performed on a Foreign Key when a DELETE Operation is performed

on_update: Option<ForeignKeyAction>

Defines an operation to be performed on a Foreign Key when a UPDATE Operation is performed

on_condition: Option<Box<dyn Fn(DynIden, DynIden) -> Condition + Send + Sync>>

Custom join ON condition

fk_name: Option<String>

The name of foreign key constraint

Implementations

impl RelationDef

pub fn rev(self) -> Self

Reverse this relation (swap from and to)

pub fn on_condition<F>(self, f: F) -> Self where
    F: Fn(DynIden, DynIden) -> Condition + 'static + Send + Sync, 

Set custom join ON condition.

This method takes a closure with two parameters denoting the left-hand side and right-hand side table in the join expression.

Examples

assert_eq!( cake::Entity::find() .join( JoinType::LeftJoin, cake_filling::Relation::Cake .def() .rev() .on_condition(|_left, right| { Expr::tbl(right, cake_filling::Column::CakeId) .gt(10) .into_condition() }) ) .build(DbBackend::MySql) .to_string(), [ “SELECT cake.id, cake.name FROM cake”, “LEFT JOIN cake_filling ON cake.id = cake_filling.cake_id AND cake_filling.cake_id > 10”, ] .join(“ “) );

Trait Implementations

impl Debug for RelationDef

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

Formats the value using the given formatter.

impl<E, R> From<RelationBuilder<E, R>> for RelationDef where
    E: EntityTrait,
    R: EntityTrait, 

fn from(b: RelationBuilder<E, R>) -> Self

Converts to this type from the input type.