Struct Three 

pub struct Three<'scope, Mode: TableMode, A: Value, B: Value, C: Value> {
    pub a: Mode::T<'scope, A>,
    pub b: Mode::T<'scope, B>,
    pub c: Mode::T<'scope, C>,
}

A helper table with three fields.

Fields

a: Mode::T<'scope, A>

b: Mode::T<'scope, B>

c: Mode::T<'scope, C>

Trait Implementations

impl<'scope, Mode: TableMode, A: Value, B: Value, C: Value> Clone for Three<'scope, Mode, A, B, C>

where Mode::T<'scope, A>: Clone, Mode::T<'scope, B>: Clone, Mode::T<'scope, C>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'scope, Mode: TableMode, A: Value, B: Value, C: Value> Debug for Three<'scope, Mode, A, B, C>

where Mode::T<'scope, A>: Debug, Mode::T<'scope, B>: Debug, Mode::T<'scope, C>: Debug,

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

Formats the value using the given formatter.

impl<'scope, A, B, C> ForLifetimeTable for Three<'scope, ExprMode, A, B, C>

where for<'a> Three<'a, ExprMode, A, B, C>: Table<'a>, A: Value, B: Value, C: Value,

type WithLt<'lt> = Three<'lt, ExprMode, A, B, C>

Substitute the lifetime of this table with 'lt.

fn with_lt<'lt>(self, marker: &mut WithLtMarker) -> Self::WithLt<'lt>

Coerce the lifetime of this table. This is used internally by the library.

impl<'scope, Mode: TableMode, A, B, C> MapTable<'scope> for Three<'scope, Mode, A, B, C>

where A: Value, B: Value, C: Value,

fn map_modes<Mapper, DestMode>( self, mapper: &mut Mapper, ) -> Self::InMode<DestMode>

where Mapper: ModeMapper<'scope, Self::Mode, DestMode>, DestMode: TableMode,

Map each field of the table

fn map_modes_ref<Mapper, DestMode>( &self, mapper: &mut Mapper, ) -> Self::InMode<DestMode>

where Mapper: ModeMapperRef<'scope, Self::Mode, DestMode>, DestMode: TableMode,

Map each field of the table, with a reference

fn map_modes_mut<Mapper, DestMode>( &mut self, mapper: &mut Mapper, ) -> Self::InMode<DestMode>

where Mapper: ModeMapperMut<'scope, Self::Mode, DestMode>, DestMode: TableMode,

Map each field of the table, with a mutable reference

impl<'scope, Mode: TableMode, A: Value, B: Value, C: Value> PartialEq for Three<'scope, Mode, A, B, C>

where Mode::T<'scope, A>: PartialEq, Mode::T<'scope, B>: PartialEq, Mode::T<'scope, C>: PartialEq,

fn eq(&self, other: &Self) -> 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<'scope, A, B, C> ShortenLifetime for Three<'scope, EmptyMode, A, B, C>

where A: Value, B: Value, C: Value,

type Shortened<'small> = Three<'small, EmptyMode, A, B, C> where Self: 'small

fn shorten_lifetime<'small, 'large: 'small>(self) -> Self::Shortened<'small>

where Self: 'large,

Shorten a lifetime, normally rust does this automatically, but if the lifetime is invariant due to being used in a Gat or trait, we need to do it manually.

impl<'scope, A, B, C> ShortenLifetime for Three<'scope, ExprMode, A, B, C>

where A: Value, B: Value, C: Value,

type Shortened<'small> = Three<'small, ExprMode, A, B, C> where Self: 'small

fn shorten_lifetime<'small, 'large: 'small>(self) -> Self::Shortened<'small>

where Self: 'large,

Shorten a lifetime, normally rust does this automatically, but if the lifetime is invariant due to being used in a Gat or trait, we need to do it manually.

impl<'scope, A, B, C> ShortenLifetime for Three<'scope, NameMode, A, B, C>

where A: Value, B: Value, C: Value,

type Shortened<'small> = Three<'small, NameMode, A, B, C> where Self: 'small

fn shorten_lifetime<'small, 'large: 'small>(self) -> Self::Shortened<'small>

where Self: 'large,

Shorten a lifetime, normally rust does this automatically, but if the lifetime is invariant due to being used in a Gat or trait, we need to do it manually.

impl<'scope, A, B, C> ShortenLifetime for Three<'scope, ValueMode, A, B, C>

where A: Value, B: Value, C: Value,

type Shortened<'small> = Three<'small, ValueMode, A, B, C> where Self: 'small

fn shorten_lifetime<'small, 'large: 'small>(self) -> Self::Shortened<'small>

where Self: 'large,

Shorten a lifetime, normally rust does this automatically, but if the lifetime is invariant due to being used in a Gat or trait, we need to do it manually.

impl<'scope, A, B, C> Table<'scope> for Three<'scope, ExprMode, A, B, C>

where A: Value, B: Value, C: Value,

type Result = <Three<'scope, ExprMode, A, B, C> as TableHKT>::InMode<ValueMode>

The value a row of this table has when loaded from the database.

fn visit(&self, f: &mut impl FnMut(&ErasedExpr), mode: VisitTableMode)

Visit each expr in the table.

fn visit_mut( &mut self, f: &mut impl FnMut(&mut ErasedExpr), mode: VisitTableMode, )

Visit each expr in the table, with a mutable reference.

impl<'scope, T: TableMode, A, B, C> TableHKT for Three<'scope, T, A, B, C>

where A: Value, B: Value, C: Value,

type InMode<Mode: TableMode> = Three<'scope, Mode, A, B, C>

Replace the mode with another.

type Mode = T

The current mode of this table.

impl<A, B, C> TableLoaderManySqlx for Three<'static, ExprMode, A, B, C>

where A: Value, B: Value, C: Value,

fn load_many<'a>( &self, values: &mut impl Iterator<Item = PgValueRef<'a>>, ) -> Vec<Self::Result>

Load the table given an iterator over a vec of row’s values

impl<A, B, C> TableLoaderSqlx for Three<'static, ExprMode, A, B, C>

where A: Value, B: Value, C: Value,

fn load<'a>( &self, values: &mut impl Iterator<Item = PgValueRef<'a>>, ) -> Self::Result

Load the table given an iterator over a row’s values

fn skip<'a>(&self, values: &mut impl Iterator<Item = PgValueRef<'a>>)

discard N columns from the iterator ofer a row This is used when this value was discarded by a MaybeTable.