Struct migration::TableForeignKey

pub struct TableForeignKey { /* private fields */ }

Specification of a foreign key

Implementations

impl TableForeignKey

pub fn new() -> TableForeignKey

Construct a new foreign key

pub fn name<T>(&mut self, name: T) -> &mut TableForeignKey

where T: Into<String>,

Set foreign key name

pub fn from_tbl<T>(&mut self, table: T) -> &mut TableForeignKey

where T: IntoTableRef,

Set key table

pub fn to_tbl<R>(&mut self, ref_table: R) -> &mut TableForeignKey

where R: IntoTableRef,

Set referencing table

pub fn from_col<T>(&mut self, column: T) -> &mut TableForeignKey

where T: IntoIden,

Add key column

pub fn to_col<R>(&mut self, ref_column: R) -> &mut TableForeignKey

where R: IntoIden,

Add referencing column

pub fn on_delete(&mut self, action: ForeignKeyAction) -> &mut TableForeignKey

Set on delete action

pub fn on_update(&mut self, action: ForeignKeyAction) -> &mut TableForeignKey

Set on update action

pub fn get_ref_table(&self) -> Option<&TableRef>

pub fn get_columns(&self) -> Vec<String>

pub fn get_ref_columns(&self) -> Vec<String>

pub fn get_on_delete(&self) -> Option<ForeignKeyAction>

pub fn get_on_update(&self) -> Option<ForeignKeyAction>

pub fn take(&mut self) -> TableForeignKey

Trait Implementations

impl Clone for TableForeignKey

fn clone(&self) -> TableForeignKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TableForeignKey

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

Formats the value using the given formatter.

impl Default for TableForeignKey

fn default() -> TableForeignKey

Returns the “default value” for a type.

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`)"
);

fn from(relation: RelationDef) -> TableForeignKey

Converts to this type from the input type.