Struct atmosphere::ForeignKey

pub struct ForeignKey<T>
where
    T: Table,
{
    pub field: &'static str,
    pub sql: &'static str,
    /* private fields */
}

Represents a foreign key column, establishing a relationship to another table.

Fields

field: &'static str

The rust field name of the model

sql: &'static str

The associated sql column name

Implementations

impl<T> ForeignKey<T>

where T: Table,

pub const fn new(field: &'static str, sql: &'static str) -> ForeignKey<T>

pub const fn as_col(&'static self) -> Column<T>

pub const unsafe fn transmute<I>(&'static self) -> &'static ForeignKey<I>

where I: Table,

Safety

We do treat this foreign key as a column of another table. This is not smart to do - but can become necessary when doing complex joins. This is memory safe as Self and Self have the exact same memory layout, we do not store any data (A or B) but only a PhantomData instance which is here transmuted.

Trait Implementations

impl<T> Clone for ForeignKey<T>

where T: Table,

fn clone(&self) -> ForeignKey<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ForeignKey<T>

where T: Debug + Table,

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

Formats the value using the given formatter.

impl<T> PartialEq for ForeignKey<T>

where T: PartialEq + Table,

fn eq(&self, other: &ForeignKey<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Copy for ForeignKey<T>

where T: Copy + Table,

impl<T> Eq for ForeignKey<T>

where T: Eq + Table,

impl<T> StructuralEq for ForeignKey<T>

where T: Table,

impl<T> StructuralPartialEq for ForeignKey<T>

where T: Table,