Struct RelatedMany 

pub struct RelatedMany<T: Model> { /* private fields */ }

A collection of related objects (one-to-many or many-to-many).

This wrapper can be in one of two states:

• Unloaded: the collection has not been fetched yet
• Loaded: the objects have been fetched and cached

For many-to-many relationships, use link() and unlink() to track changes that will be flushed to the link table.

Implementations

impl<T: Model> RelatedMany<T>

pub fn new(fk_column: &'static str) -> Self

Create a new unloaded RelatedMany with the FK column name.

Use this for one-to-many relationships where the related model has a foreign key column pointing back to this model.

pub fn with_link_table(link_table: LinkTableInfo) -> Self

Create for a many-to-many relationship with a link table.

Example

let link = LinkTableInfo::new("hero_powers", "hero_id", "power_id");
let powers: RelatedMany<Power> = RelatedMany::with_link_table(link);

pub fn with_parent_pk(fk_column: &'static str, pk: impl Into<Value>) -> Self

Create with a parent primary key for loading.

pub fn is_loaded(&self) -> bool

Check if the collection has been loaded.

pub fn get(&self) -> Option<&[T]>

Get the loaded objects as a slice (None if not loaded).

pub fn len(&self) -> usize

Get the number of loaded items (0 if not loaded).

pub fn is_empty(&self) -> bool

Check if the collection is empty (true if not loaded or loaded empty).

pub fn set_loaded(&self, objects: Vec<T>) -> Result<(), Vec<T>>

Set the loaded objects (internal use by query system).

pub fn iter(&self) -> impl Iterator<Item = &T>

Iterate over the loaded items.

pub fn fk_column(&self) -> &'static str

Get the FK column name.

pub fn parent_pk(&self) -> Option<&Value>

Get the parent PK value (if set).

pub fn set_parent_pk(&mut self, pk: impl Into<Value>)

Set the parent PK value.

pub fn link_table(&self) -> Option<&LinkTableInfo>

Get the link table info (if this is a many-to-many relationship).

pub fn is_many_to_many(&self) -> bool

Check if this is a many-to-many relationship (has link table).

pub fn link(&self, obj: &T)

Track a link operation (will INSERT into link table on flush).

The object should already exist in the database. This method records the relationship to be persisted when flush() is called.

Duplicate links to the same object are ignored (only one INSERT will occur).

Example

hero.powers.link(&fireball);
session.flush().await?; // Inserts into hero_powers table

pub fn unlink(&self, obj: &T)

Track an unlink operation (will DELETE from link table on flush).

This method records the relationship removal to be persisted when flush() is called.

Duplicate unlinks to the same object are ignored (only one DELETE will occur).

Example

hero.powers.unlink(&fireball);
session.flush().await?; // Deletes from hero_powers table

pub fn take_pending_links(&self) -> Vec<Vec<Value>>

Get and clear pending link operations.

Returns the PK values that should be INSERTed into the link table. This is used by the flush system.

pub fn take_pending_unlinks(&self) -> Vec<Vec<Value>>

Get and clear pending unlink operations.

Returns the PK values that should be DELETEd from the link table. This is used by the flush system.

pub fn has_pending_ops(&self) -> bool

Check if there are pending link/unlink operations.

Trait Implementations

impl<T: Model + Clone> Clone for RelatedMany<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Model + Debug> Debug for RelatedMany<T>

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

Formats the value using the given formatter.

impl<T: Model> Default for RelatedMany<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for RelatedMany<T>

where T: Model + Deserialize<'de>,

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'a, T: Model> IntoIterator for &'a RelatedMany<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Serialize for RelatedMany<T>

where T: Model + Serialize,

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

Serialize this value into the given Serde serializer.