Struct butane::ForeignKey

pub struct ForeignKey<T>where
    T: DataObject,{ /* private fields */ }

Used to implement a relationship between models.

Initialize using From or from_pk

Examples

#[model]
struct Blog {
  ...
}
#[model]
struct Post {
  blog: ForeignKey<Blog>,
  ...
}

Implementations

impl<T> ForeignKey<T>where T: DataObject,

pub fn from_pk(pk: <T as DataObject>::PKType) -> ForeignKey<T>

pub fn get(&self) -> Result<&T, Error>

Returns a reference to the value. It must have already been loaded. If not, returns Error::ValueNotLoaded

pub fn pk(&self) -> <T as DataObject>::PKType

Returns a reference to the primary key of the value.

pub fn load(&self, conn: &impl ConnectionMethods) -> Result<&T, Error>

Loads the value referred to by this foreign key from the database if necessary and returns a reference to it.

Trait Implementations

impl<T> AsPrimaryKey<T> for ForeignKey<T>where T: DataObject,

fn as_pk(&self) -> Cow<'_, <T as DataObject>::PKType>

impl<T> Clone for ForeignKey<T>where T: DataObject,

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: DataObject,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ForeignKey<T>where T: DataObject, <T as DataObject>::PKType: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<ForeignKey<T>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Dummy<Faker> for ForeignKey<T>where T: DataObject,

Fake data support is currently limited to empty ForeignKey relationships.

fn dummy_with_rng<R>(_: &Faker, _rng: &mut R) -> ForeignKey<T>where R: Rng + ?Sized,

Generate a dummy value for a given type using a random number generator.

fn dummy(config: &T) -> Self

Generate a dummy value for a type.

impl<T> FieldType for ForeignKey<T>where T: DataObject,

const SQLTYPE: SqlType = <<T as DataObject>::PKType>::SQLTYPE

type RefType = <<T as DataObject>::PKType as FieldType>::RefType

Reference type. Used for ergonomics with String (which has reference type str). For most, it is Self

impl<T> From<&T> for ForeignKey<T>where T: DataObject,

fn from(obj: &T) -> ForeignKey<T>

Converts to this type from the input type.

impl<T> From<T> for ForeignKey<T>where T: DataObject,

fn from(obj: T) -> ForeignKey<T>

Converts to this type from the input type.

impl<T> FromSql for ForeignKey<T>where T: DataObject,

fn from_sql_ref(valref: SqlValRef<'_>) -> Result<ForeignKey<T>, Error>

Used to convert a SqlValRef into another type.

fn from_sql(val: SqlVal) -> Result<Self, Error>where Self: Sized,

Used to convert a SqlVal into another type. The default implementation calls Self::from_sql_ref(val.as_ref()), which may be inefficient. This method is chiefly used only for primary keys: a more efficient implementation is unlikely to provide benefits for types not used as primary keys.

impl<T, U> PartialEq<U> for ForeignKey<T>where U: AsPrimaryKey<T>, T: DataObject,

fn eq(&self, other: &U) -> 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> Serialize for ForeignKey<T>where T: DataObject, <T as DataObject>::PKType: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> ToSql for ForeignKey<T>where T: DataObject,

fn to_sql(&self) -> SqlVal

fn to_sql_ref(&self) -> SqlValRef<'_>

fn into_sql(self) -> SqlVal

The default implementation simply calls to_sql. Provide an alternative implementation if greater efficiency can be realized by consuming self.

impl<T> Eq for ForeignKey<T>where T: DataObject,