Struct 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 skip_fk: bool,
    pub on_delete: Option<ForeignKeyAction>,
    pub on_update: Option<ForeignKeyAction>,
    pub on_condition: Option<Arc<dyn Fn(DynIden, DynIden) -> Condition>>,
    pub fk_name: Option<String>,
    pub condition_type: ConditionType,
}

Concrete description of a relation between two entities: which tables and columns participate, whether Self is the FK-owning side, and the optional foreign-key constraint metadata.

Build one with RelationBuilder (returned by EntityTrait::belongs_to / has_one / has_many), or destructure one returned by a RelationTrait::def impl when you need to customise it.

Fields

rel_type: RelationType

Cardinality of the relation.

from_tbl: TableRef

Table at the FK-owning end of the relation.

to_tbl: TableRef

Table being pointed to by the foreign key.

from_col: Identity

FK column(s) on from_tbl.

to_col: Identity

Referenced column(s) on to_tbl (usually the primary key).

is_owner: bool

true if Self is the FK-owning side (i.e. holds from_col).

skip_fk: bool

Skip emitting a FOREIGN KEY constraint when this relation is used to generate schema DDL.

on_delete: Option<ForeignKeyAction>

ON DELETE action for the foreign key.

on_update: Option<ForeignKeyAction>

ON UPDATE action for the foreign key.

on_condition: Option<Arc<dyn Fn(DynIden, DynIden) -> Condition>>

Extra predicate to AND/OR into the join’s ON clause; see RelationDef::on_condition.

fk_name: Option<String>

Name of the foreign-key constraint to emit in DDL.

condition_type: ConditionType

How on_condition is combined with the column equality predicate (All = AND, Any = OR).

Implementations

impl RelationDef

pub fn rev(self) -> Self

Swap the from and to ends of this relation. Useful when joining from the FK-pointed-at side back to the FK-owning side.

pub fn from_alias<A>(self, alias: A) -> Self

where A: IntoIden,

Express the relation from a table alias.

This is a shorter and more discoverable equivalent to modifying from_tbl field by hand.

Examples

Here’s a short synthetic example. In real life you’d use aliases when the table name comes up twice and you need to disambiguate, e.g. https://github.com/SeaQL/sea-orm/discussions/2133.

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

let cf = "cf";

assert_eq!(
    cake::Entity::find()
        .join_as(
            JoinType::LeftJoin,
            cake_filling::Relation::Cake.def().rev(),
            cf.clone()
        )
        .join(
            JoinType::LeftJoin,
            cake_filling::Relation::Filling.def().from_alias(cf)
        )
        .build(DbBackend::MySql)
        .to_string(),
    [
        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
        "LEFT JOIN `cake_filling` AS `cf` ON `cake`.`id` = `cf`.`cake_id`",
        "LEFT JOIN `filling` ON `cf`.`filling_id` = `filling`.`id`",
    ]
    .join(" ")
);

pub fn on_condition<F>(self, f: F) -> Self

where F: Fn(DynIden, DynIden) -> Condition + 'static,

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, ExprTrait, 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(" ")
);

pub fn condition_type(self, condition_type: ConditionType) -> Self

Set the condition type of join on expression

Examples

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

assert_eq!(
    cake::Entity::find()
        .join(
            JoinType::LeftJoin,
            cake_filling::Relation::Cake
                .def()
                .rev()
                .condition_type(ConditionType::Any)
                .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` OR `cake_filling`.`cake_id` > 10",
    ]
    .join(" ")
);

Trait Implementations

impl Clone for RelationDef

fn clone(&self) -> RelationDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RelationDef

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

Formats the value using the given formatter.

impl Eq for RelationDef

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.

impl From<RelationDef> for Condition

Idiomatically generate the join condition.

This allows using a RelationDef directly anywhere sea_query expects an IntoCondition.

Examples

use sea_orm::tests_cfg::{cake, fruit};
use sea_orm::{entity::*, sea_query::*};

let query = Query::select()
    .from(fruit::Entity)
    .inner_join(cake::Entity, fruit::Relation::Cake.def())
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT  FROM `fruit` INNER JOIN `cake` ON `fruit`.`cake_id` = `cake`.`id`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT  FROM "fruit" INNER JOIN "cake" ON "fruit"."cake_id" = "cake"."id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT  FROM "fruit" INNER JOIN "cake" ON "fruit"."cake_id" = "cake"."id""#
);

fn from(rel: RelationDef) -> Condition

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, IntoTableRef, ConditionType};
use sea_orm::{EnumIter, Iden, Identity, PrimaryKeyTrait, RelationDef, RelationTrait, RelationType};

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

let mut alter_table = TableAlterStatement::new()
    .table("foo")
    .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.

impl Hash for RelationDef

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RelationDef

fn eq(&self, other: &Self) -> 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.