Struct sea_orm::entity::RelationDef
source · 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>,
pub condition_type: ConditionType,
}
Expand description
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
condition_type: ConditionType
Condition type of join on expression
Implementations§
source§impl RelationDef
impl RelationDef
sourcepub fn on_condition<F>(self, f: F) -> Selfwhere
F: Fn(DynIden, DynIden) -> Condition + 'static + Send + Sync,
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(" ")
);
sourcepub fn condition_type(self, condition_type: ConditionType) -> Self
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, 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§
source§impl Debug for RelationDef
impl Debug for RelationDef
source§impl<E, R> From<RelationBuilder<E, R>> for RelationDefwhere
E: EntityTrait,
R: EntityTrait,
impl<E, R> From<RelationBuilder<E, R>> for RelationDefwhere E: EntityTrait, R: EntityTrait,
source§fn from(b: RelationBuilder<E, R>) -> Self
fn from(b: RelationBuilder<E, R>) -> Self
source§impl From<RelationDef> for ForeignKeyCreateStatement
impl From<RelationDef> for ForeignKeyCreateStatement
source§fn from(relation: RelationDef) -> Self
fn from(relation: RelationDef) -> Self
source§impl From<RelationDef> for TableForeignKey
impl From<RelationDef> for TableForeignKey
Creates a column definition for example to update a table.
use sea_query::{Alias, IntoIden, MysqlQueryBuilder, TableAlterStatement, TableRef, ConditionType};
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()),
condition_type: ConditionType::All,
};
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`)"
);