Skip to main content

HasMany

wundergraph::query_builder::types

Struct HasMany 

Source 
pub struct HasMany<T, FK>(/* private fields */);
Expand description

Type used to indicate that a given field references multiple other entities by a given id

Trait Implementations§

Source§

impl<L, O, DB, Ctx, FK> AsNonColumnFilter<L, DB, Ctx> for HasMany<O, FK>
where L: HasTable, FK: Default + NonAggregate + QueryFragment<DB> + SelectableExpression<O::Table>, O: WundergraphBelongsTo<L::Table, DB, Ctx, FK>, O::Table: 'static, DB: Backend + ApplyOffset + 'static, <O::Table as QuerySource>::FromClause: QueryFragment<DB>, DB::QueryBuilder: Default,

Source§

type Filter = ReferenceFilter<<<L as HasTable>::Table as Table>::PrimaryKey, Filter<<O as LoadingHandler<DB, Ctx>>::Filter, <O as HasTable>::Table>, FK>

Type of the filter
Source§

impl<T: Clone, FK: Clone> Clone for HasMany<T, FK>

Source§

fn clone(&self) -> HasMany<T, FK>

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<T: Debug, FK: Debug> Debug for HasMany<T, FK>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T: Hash, FK: Hash> Hash for HasMany<T, FK>

Source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl<A, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A,)
where (A,): NonTableFieldExtractor, <(A,) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A,) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B)
where (A, B): NonTableFieldExtractor, <(A, B) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C)
where (A, B, C): NonTableFieldExtractor, <(A, B, C) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D)
where (A, B, C, D): NonTableFieldExtractor, <(A, B, C, D) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E)
where (A, B, C, D, E): NonTableFieldExtractor, <(A, B, C, D, E) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F)
where (A, B, C, D, E, F): NonTableFieldExtractor, <(A, B, C, D, E, F) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G)
where (A, B, C, D, E, F, G): NonTableFieldExtractor, <(A, B, C, D, E, F, G) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H)
where (A, B, C, D, E, F, G, H): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I)
where (A, B, C, D, E, F, G, H, I): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J)
where (A, B, C, D, E, F, G, H, I, J): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I, J) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I, J) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K)
where (A, B, C, D, E, F, G, H, I, J, K): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I, J, K) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I, J, K) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L)
where (A, B, C, D, E, F, G, H, I, J, K, L): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I, J, K, L) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M)
where (A, B, C, D, E, F, G, H, I, J, K, L, M): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I, J, K, L, M) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
where (A, B, C, D, E, F, G, H, I, J, K, L, M, N): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
where (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
where (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): NonTableFieldExtractor, <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,

Source§

const FIELD_COUNT: usize

Number of collected fields
Source§

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<T, FK> NonTableFieldCollector<HasMany<T, FK>> for ()

Source§

const FIELD_COUNT: usize = 1

Number of collected fields
Source§

type Out = (HasMany<T, FK>,)

List of all collected fields Read more
Source§

fn map<F: Fn(usize) -> R, R>(local_index: usize, callback: F) -> Option<R>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<T: PartialEq, FK: PartialEq> PartialEq for HasMany<T, FK>

Source§

fn eq(&self, other: &HasMany<T, FK>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl<A, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A,)
where (A,): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A,) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A,) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B)
where (A, B): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C)
where (A, B, C): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D)
where (A, B, C, D): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E)
where (A, B, C, D, E): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F)
where (A, B, C, D, E, F): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G)
where (A, B, C, D, E, F, G): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H)
where (A, B, C, D, E, F, G, H): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I)
where (A, B, C, D, E, F, G, H, I): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J)
where (A, B, C, D, E, F, G, H, I, J): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I, J) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I, J) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K)
where (A, B, C, D, E, F, G, H, I, J, K): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I, J, K) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I, J, K) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L)
where (A, B, C, D, E, F, G, H, I, J, K, L): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I, J, K, L) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M)
where (A, B, C, D, E, F, G, H, I, J, K, L, M): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I, J, K, L, M) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
where (A, B, C, D, E, F, G, H, I, J, K, L, M, N): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
where (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
where (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): FieldListExtractor,

Source§

const FIELD_COUNT: usize = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as FieldListExtractor>::FIELD_COUNT

Number of collected fields
Source§

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as FieldListExtractor>::Out

List of all collected fields Read more
Source§

fn map<Func: Fn(usize) -> Ret, Ret>( local_index: usize, callback: Func, ) -> Option<Ret>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<T, FK> TableFieldCollector<HasMany<T, FK>> for ()

Source§

const FIELD_COUNT: usize = 0

Number of collected fields
Source§

type Out = ()

List of all collected fields Read more
Source§

fn map<F: Fn(usize) -> R, R>(_local_index: usize, _callback: F) -> Option<R>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)
Source§

impl<T: Eq, FK: Eq> Eq for HasMany<T, FK>

Source§

impl<T, FK> StructuralPartialEq for HasMany<T, FK>

Auto Trait Implementations§

§

impl<T, FK> Freeze for HasMany<T, FK>

§

impl<T, FK> RefUnwindSafe for HasMany<T, FK>
where FK: RefUnwindSafe, T: RefUnwindSafe,

§

impl<T, FK> Send for HasMany<T, FK>
where FK: Send, T: Send,

§

impl<T, FK> Sync for HasMany<T, FK>
where FK: Sync, T: Sync,

§

impl<T, FK> Unpin for HasMany<T, FK>
where FK: Unpin, T: Unpin,

§

impl<T, FK> UnsafeUnpin for HasMany<T, FK>

§

impl<T, FK> UnwindSafe for HasMany<T, FK>
where FK: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoSql for T

Source§

fn into_sql<T>(self) -> Self::Expression
where Self: Sized + AsExpression<T>,

Convert self to an expression for Diesel’s query builder. Read more
Source§

fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression
where &'a Self: AsExpression<T>,

Convert &self to an expression for Diesel’s query builder. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.