Struct Lazy 

pub struct Lazy<'transaction, T: Table> { /* private fields */ }

Lazy can be used to read any column of a table row and its parents. Columns are loaded on demand, one row at at time.

As an example, if you have two tables Post and User:

fn foo(post: Lazy<Post>) {
    let user = &post.author; // If the `post` row was not retrieved yet, then it is retrieved now to read the `user` column.
    let user_id = user.table_row(); // This doesn't access the database because the `user` id was already read from the `post` row.
    let user_name = &user.name; // If the `user` row was not retrieved yet, then it is retrieved now to read the `name` column.
}

Note that Lazy borrows the transaction immutably. This means that it is not possible to keep a Lazy value when doing inserts or updates. Here are some alternatives to solve this problem:

• Copy/Clone the columns that you need from the Lazy value before doing inserts and or updates.
• Another option is to use Lazy::table_row to retrieve an owned TableRow. This can then be used to create crate::Expr referencing the table columns for use in queries.
• If you need many columns in a struct, then consider crate::FromExpr.

Implementations

impl<'transaction, T: Table> Lazy<'transaction, T>

pub fn table_row(&self) -> TableRow<T>

Get an owned TableRow out of this Lazy value.

If you don’t care about deleting the row then you probably want to immediately use TableRow::into_expr on the returned TableRow.

Trait Implementations

impl<'transaction, T: Table> Clone for Lazy<'transaction, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'transaction, T: Table> Deref for Lazy<'transaction, T>

type Target = <T as Table>::Lazy<'transaction>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.