Struct sea_orm::entity::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) -> Selfwhere 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.

This replaces the current condition if it is already set.

Examples

use sea_orm::{entity::*, query::*, DbBackend, tests_cfg::{cake, cake_filling}};
use sea_query::{Expr, IntoCondition};

assert_eq!(
    cake::Entity::find()
        .join(
            JoinType::LeftJoin,
            cake_filling::Relation::Cake
                .def()
                .rev()
                .on_condition(|_left, right| {
                    Expr::col((right, cake_filling::Column::CakeId))
                        .gt(10i32)
                        .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 RelationDefwhere E: EntityTrait, R: EntityTrait,

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

Converts to this type from the input type.

impl From<RelationDef> for ForeignKeyCreateStatement

fn from(relation: RelationDef) -> Self

Converts to this type from the input type.

impl From<RelationDef> for TableForeignKey

Creates a column definition for example to update a table.

use sea_query::{Alias, IntoIden, MysqlQueryBuilder, TableAlterStatement, TableRef};
use sea_orm::{EnumIter, Iden, Identity, PrimaryKeyTrait, RelationDef, RelationTrait, RelationType};

let relation = RelationDef {
    rel_type: RelationType::HasOne,
    from_tbl: TableRef::Table(Alias::new("foo").into_iden()),
    to_tbl: TableRef::Table(Alias::new("bar").into_iden()),
    from_col: Identity::Unary(Alias::new("bar_id").into_iden()),
    to_col: Identity::Unary(Alias::new("bar_id").into_iden()),
    is_owner: false,
    on_delete: None,
    on_update: None,
    on_condition: None,
    fk_name: Some("foo-bar".to_string()),
};

let mut alter_table = TableAlterStatement::new()
    .table(TableRef::Table(Alias::new("foo").into_iden()))
    .add_foreign_key(&mut relation.into()).take();
assert_eq!(
    alter_table.to_string(MysqlQueryBuilder::default()),
    "ALTER TABLE `foo` ADD CONSTRAINT `foo-bar` FOREIGN KEY (`bar_id`) REFERENCES `bar` (`bar_id`)"
);

fn from(relation: RelationDef) -> Self

Converts to this type from the input type.