Enum Join 

pub enum Join<E>
where
    E: Keyed,
{
    Entity(Box<E>),
    Key(<E as Keyed>::Key),
}

The Join struct that hold either an entity or its key.

Variants

Entity(Box<E>)

Full entity is held. The entity is wrapped inside a Box. That does allow circular dependencies, in theory. In practice the compiler goes wild :(

Key(<E as Keyed>::Key)

The entities key

Implementations

impl<T> Join<T>

where T: Keyed,

pub fn with_entity(entity: T) -> Join<T>

Constructs join for entity

pub fn with_key(key: impl Into<<T as Keyed>::Key>) -> Join<T>

Constructs join for key

pub fn entity(&self) -> Option<&T>

Returns entity or None, if key is held.

pub fn entity_mut(&mut self) -> Option<&mut T>

Returns mutable entity or None, if key is held.

pub fn entity_or_err<E>(&self, err: E) -> Result<&T, E>

Returns entity or error E, if key is held.

pub fn entity_mut_or_err<E>(&mut self, err: E) -> Result<&mut T, E>

Returns mut entity or error E, if key is held.

pub fn key(&self) -> <T as Keyed>::Key

where <T as Keyed>::Key: Clone,

Returns a key. If entity is held, key is taken from that entity

pub fn into_entity(self) -> Result<T, ToqlError>

Unwraps join into its entity. Can fail

Trait Implementations

impl<E> Clone for Join<E>

where E: Clone + Keyed, <E as Keyed>::Key: Clone,

fn clone(&self) -> Join<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E> Debug for Join<E>

where E: Debug + Keyed, <E as Keyed>::Key: Debug,

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

Formats the value using the given formatter.

impl<E> Default for Join<E>

where E: Default + Keyed,

fn default() -> Join<E>

Returns the “default value” for a type.

impl<T, R, E> FromRow<R, E> for Join<T>

where T: Keyed + FromRow<R, E>, E: From<ToqlError>,

fn forward<'a, I>(iter: &mut I) -> Result<usize, E>

where I: Iterator<Item = &'a Select>, Join<T>: Sized,

Returns the number of selects This is needed to advance the iterator and the row index. The Deserializer needs this information to skip left joins that have fields selected but are null. Those left joins cause select information in the select stream that must be skipped.

fn from_row<'a, I>( row: &R, i: &mut usize, iter: &mut I, ) -> Result<Option<Join<T>>, E>

where I: Iterator<Item = &'a Select> + Clone, Join<T>: Sized,

Read row values into struct, starting from index. Advances iter and index Returns None for value unselected values or joined entities that have null keys. Return Error, if value is selected, but cannot be converted.

impl<T> KeyFields for Join<T>

where T: KeyFields + Keyed, <T as Keyed>::Key: KeyFields,

type Entity = <T as KeyFields>::Entity

fn fields() -> Vec<String>

Return primary key fields for a given entity.

fn params(&self) -> Vec<SqlArg>

Return key values as params. Useful to loop across a composite key.

impl<T> Keyed for &Join<T>

where T: Keyed, <T as Keyed>::Key: Clone,

type Key = <T as Keyed>::Key

Type of key.

fn key(&self) -> <T as Keyed>::Key

Return value of the key for a given entity.

impl<T> Keyed for Join<T>

where T: Keyed, <T as Keyed>::Key: Clone,

type Key = <T as Keyed>::Key

Type of key.

fn key(&self) -> <T as Keyed>::Key

Return value of the key for a given entity.

impl<T> KeyedMut for Join<T>

where T: KeyedMut, <T as Keyed>::Key: Clone,

fn set_key(&mut self, key: <T as Keyed>::Key)

Set the key of the implementing struct.

impl<E> PartialEq for Join<E>

where E: PartialEq + Keyed, <E as Keyed>::Key: PartialEq,

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

impl<T> TreeIdentity for Join<T>

where T: Keyed + TreeIdentity, <T as Keyed>::Key: Clone + TryFrom<Vec<SqlArg>, Error = ToqlError>,

fn auto_id<'a, I>(descendents: I) -> Result<bool, ToqlError>

where I: Iterator<Item = FieldPath<'a>>,

Returns true, if struct located at descendents has database generated keys.

fn set_id<'a, 'b, I>( &mut self, descendents: I, action: &'b IdentityAction, ) -> Result<(), ToqlError>

where I: Iterator<Item = FieldPath<'a>> + Clone,

Set or refresh keys of structs located at descendents.

impl<T, R, E> TreeIndex<R, E> for Join<T>

where T: Keyed + TreeIndex<R, E>, E: From<ToqlError>,

fn index<'a, I>( descendents: I, rows: &[R], row_offset: usize, index: &mut HashMap<u64, Vec<usize>>, ) -> Result<(), E>

where I: Iterator<Item = FieldPath<'a>> + Clone,

impl<T> TreeInsert for Join<T>

where T: Keyed + TreeInsert + Mapped, <T as Keyed>::Key: Key + Clone,

fn columns<'a, I>(descendents: I) -> Result<SqlExpr, ToqlError>

where I: Iterator<Item = FieldPath<'a>>,

Return columns of struct located at descendents.

fn values<'a, 'b, I, J>( &self, descendents: I, roles: &HashSet<String>, should_insert: &mut J, values: &mut SqlExpr, ) -> Result<(), ToqlError>

where I: Iterator<Item = FieldPath<'a>> + Clone, J: Iterator<Item = &'b bool>,

Return values of structs located at descendents. The should_insert argument allows the method to only insert a part of the collection. This is needed to deal with newly added merges.

impl<T, R, E> TreeMerge<R, E> for Join<T>

where T: Keyed + TreeMerge<R, E>, E: From<ToqlError>,

fn merge<'a, I>( &mut self, descendents: I, field: &str, rows: &[R], row_offset: usize, index: &HashMap<u64, Vec<usize>>, selection_stream: &SelectStream, ) -> Result<(), E>

where I: Iterator<Item = FieldPath<'a>> + Clone,

impl<T> TreePredicate for Join<T>

where T: Keyed + TreePredicate, <T as Keyed>::Key: Clone,

fn columns<'a, I>(descendents: I) -> Result<Vec<String>, ToqlError>

where I: Iterator<Item = FieldPath<'a>>,

Return the key column names

fn args<'a, I>( &self, descendents: I, args: &mut Vec<SqlArg>, ) -> Result<(), ToqlError>

where I: Iterator<Item = FieldPath<'a>> + Clone,

Return the key column values

impl<T> TreeUpdate for Join<T>

where T: Keyed + TreeUpdate + Mapped, <T as Keyed>::Key: Key + Clone,

fn update<'a, I>( &self, descendents: I, fields: &HashSet<String>, roles: &HashSet<String>, exprs: &mut Vec<SqlExpr>, ) -> Result<(), ToqlError>

where I: Iterator<Item = FieldPath<'a>> + Clone,

impl<E> Eq for Join<E>

where E: Eq + Keyed, <E as Keyed>::Key: Eq,

impl<E> StructuralPartialEq for Join<E>

where E: Keyed,