Struct Multiple 

pub struct Multiple<O: OrderState>(/* private fields */);

Trait Implementations

impl<I: IndexDomain, V: ValueDomain, O: OrderState> AlignableArity<Indexed<I, V>, Keyed<I>> for Multiple<O>

type Retention = Preserving

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, address: &<Keyed<I> as Alignment>::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Indexed<I, V>: 'a,

impl<O: OrderState> Arity for Multiple<O>

type AfterDrop = Multiple<O>

type AfterOrderedExpansion = Multiple<O>

type AfterUnorderedExpansion = Multiple<Unordered>

type Container<'a, X: 'a> = Box<dyn Iterator<Item = X> + 'a>

fn map_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Y + 'a, ) -> Self::Container<'a, Y>

fn filter_map_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Option<Y> + 'a, ) -> <Self::AfterDrop as Arity>::Container<'a, Y>

fn flat_map_ordered_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Vec<Y> + 'a, ) -> <Self::AfterOrderedExpansion as Arity>::Container<'a, Y>

fn flat_map_unordered_elements<'a, X: 'a, Y: 'a>( container: Self::Container<'a, X>, function: impl Fn(X) -> Vec<Y> + 'a, ) -> <Self::AfterUnorderedExpansion as Arity>::Container<'a, Y>

impl<V: BareValueDomain, O: OrderState> BucketFailureArity<Bare<V>> for Multiple<O>

fn bucket_failure<'payload, 'a>( payload: &'payload QueryResult<Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>>, ) -> Option<&'payload Failure>

where Bare<V>: 'a,

impl<I: IndexDomain, V: ValueDomain, O: OrderState> BucketFailureArity<Indexed<I, V>> for Multiple<O>

fn bucket_failure<'payload, 'a>( payload: &'payload QueryResult<Self::Container<'a, <Indexed<I, V> as ElementShape>::Element<'a>>>, ) -> Option<&'payload Failure>

where Indexed<I, V>: 'a,

impl<S: CacheableShape, O: OrderState> CacheableArity<S> for Multiple<O>

type Cached = Vec<<S as CacheableShape>::CachedElement>

fn into_cached<'a>(values: Self::Container<'a, S::Element<'a>>) -> Self::Cached

fn from_cached(cached: &Self::Cached) -> Self::Container<'_, S::Element<'_>>

impl<I: IndexDomain, V: ValueDomain, O: OrderState> EnumerableArity<Indexed<I, V>, I> for Multiple<O>

fn elements<'a>( prepared: Self::Prepared<'a>, ) -> Self::Container<'a, (I::Index<'a>, QueryResult<V::Value<'a>>)>

where Indexed<I, V>: 'a,

impl<E: EntityDomain, O: OrderState> LaneKernel<Bare<EntityReference<E>>, Multiple<O>> for SelectOperation

type Output = OperandHandle<Indexed<E, Unit>, Multiple<Unordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, EntityReference<E>, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<O: OrderState> LaneKernel<Bare<Mask>, Multiple<O>> for AllOperation

type Output = OperandHandle<Bare<Mask>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, Mask, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<O: OrderState> LaneKernel<Bare<Mask>, Multiple<O>> for AnyOperation

type Output = OperandHandle<Bare<Mask>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, Mask, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for CountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MaximumOperation

where V: ValueOrdering + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MeanOperation

where V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MedianOperation

where V: ValueMedian + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MinimumOperation

where V: ValueOrdering + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueMode + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for ModeOperation

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for ProductOperation

where V: ValueMultiply + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for RandomOperation

where V: BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for StandardDeviationOperation

where V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<Scalar>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for SumOperation

where V: ValueAdd + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueEquivalence + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for UniqueCountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for VarianceOperation

where V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<Scalar>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for Raise

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhen<C>

where V: BareValueDomain, O: OrderState, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState, D: Diagnostic> LaneKernel<Bare<V>, Multiple<O>> for RaiseErrorsOf<D>

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState, G: ErrorGroup> LaneKernel<Bare<V>, Multiple<O>> for RaiseErrorsIn<G>

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState, E: Error + 'static> LaneKernel<Bare<V>, Multiple<O>> for RaiseErrorsWithCause<E>

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, D, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhenErrorsOf<D, C>

where V: BareValueDomain, O: OrderState, D: Diagnostic, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, G, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhenErrorsIn<G, C>

where V: BareValueDomain, O: OrderState, G: ErrorGroup, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, E, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhenErrorsWithCause<E, C>

where V: BareValueDomain, O: OrderState, E: Error + 'static, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for ShuffleOperation

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for SortOperation

where V: ValueOrdering + BareValueDomain, O: OrderState, for<'a> V::Value<'a>: EnsureSortable, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for UnorderOperation

type Output = OperandHandle<Bare<V>, Multiple<Unordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueEquivalence + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for IsDuplicatedOperation

type Output = OperandHandle<Bare<Mask>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueEquivalence + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for UniqueOperation

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for EnumerateOperation

type Output = OperandHandle<Indexed<Positional, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for FirstOperation

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for LastOperation

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for ReverseOrderOperation

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for TakeOperation

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<O: OrderState> LaneKernel<Indexed<GraphRecordAttribute, Unit>, Multiple<O>> for EdgesOperation

type Output = OperandHandle<Indexed<u32, Unit>, Multiple<Unordered>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, NodeIndex, Unit, Multiple<O>>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<O: OrderState> LaneKernel<Indexed<GraphRecordAttribute, Unit>, Multiple<O>> for NeighborsOperation

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, NodeIndex, Unit, Multiple<O>>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<E: EntityDomain, I: IndexDomain, O: OrderState> LaneKernel<Indexed<I, EntityReference<E>>, Multiple<O>> for SelectOperation

type Output = OperandHandle<Indexed<E, Unit>, Multiple<Unordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, EntityReference<E>, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, O: OrderState> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Multiple<O>> for EdgesOperation

type Output = OperandHandle<Indexed<u32, Unit>, Multiple<Unordered>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, EntityReference<NodeIndex>, Multiple<O>>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, O: OrderState> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Multiple<O>> for NeighborsOperation

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, EntityReference<NodeIndex>, Multiple<O>>, direction: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, O: OrderState> LaneKernel<Indexed<I, EntityReference<u32>>, Multiple<O>> for NodesOperation

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, EntityReference<EdgeIndex>, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, O: OrderState> LaneKernel<Indexed<I, Mask>, Multiple<O>> for AllOperation

type Output = OperandHandle<Bare<Mask>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, Mask, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, O: OrderState> LaneKernel<Indexed<I, Mask>, Multiple<O>> for AnyOperation

type Output = OperandHandle<Bare<Mask>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, Mask, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain, O: OrderState> LaneKernel<Indexed<I, V>, Multiple<O>> for CountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for MaximumOperation

where I: IndexDomain, V: ValueOrdering + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for MeanOperation

where I: IndexDomain, V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for MedianOperation

where I: IndexDomain, V: ValueMedian + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for MinimumOperation

where I: IndexDomain, V: ValueOrdering + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueMode + BareValueDomain, O: OrderState> LaneKernel<Indexed<I, V>, Multiple<O>> for ModeOperation

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for ProductOperation

where I: IndexDomain, V: ValueMultiply + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for RandomOperation

where I: IndexDomain, V: ValueDomain, O: OrderState,

type Output = OperandHandle<Indexed<I, V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for StandardDeviationOperation

where I: IndexDomain, V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<Scalar>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for SumOperation

where I: IndexDomain, V: ValueAdd + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueEquivalence, O: OrderState> LaneKernel<Indexed<I, V>, Multiple<O>> for UniqueCountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for VarianceOperation

where I: IndexDomain, V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<Scalar>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain, O: OrderState> LaneKernel<Indexed<I, V>, Multiple<O>> for Raise

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O, C> LaneKernel<Indexed<I, V>, Multiple<O>> for RaiseWhen<C>

where I: IndexDomain, V: ValueDomain, O: OrderState, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain, O: OrderState, D: Diagnostic> LaneKernel<Indexed<I, V>, Multiple<O>> for RaiseErrorsOf<D>

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain, O: OrderState, G: ErrorGroup> LaneKernel<Indexed<I, V>, Multiple<O>> for RaiseErrorsIn<G>

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain, O: OrderState, E: Error + 'static> LaneKernel<Indexed<I, V>, Multiple<O>> for RaiseErrorsWithCause<E>

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O, D, C> LaneKernel<Indexed<I, V>, Multiple<O>> for RaiseWhenErrorsOf<D, C>

where I: IndexDomain, V: ValueDomain, O: OrderState, D: Diagnostic, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O, G, C> LaneKernel<Indexed<I, V>, Multiple<O>> for RaiseWhenErrorsIn<G, C>

where I: IndexDomain, V: ValueDomain, O: OrderState, G: ErrorGroup, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O, E, C> LaneKernel<Indexed<I, V>, Multiple<O>> for RaiseWhenErrorsWithCause<E, C>

where I: IndexDomain, V: ValueDomain, O: OrderState, E: Error + 'static, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Indexed<I, V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain, O: OrderState> LaneKernel<Indexed<I, V>, Multiple<O>> for ShuffleOperation

type Output = OperandHandle<Indexed<I, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, O> LaneKernel<Indexed<I, V>, Multiple<O>> for SortOperation

where I: IndexDomain, V: ValueOrdering, O: OrderState, for<'a> I::Index<'a>: EnsureSortable, for<'a> V::Value<'a>: EnsureSortable, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Indexed<I, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I, V, A, O> LaneKernel<Indexed<I, V>, Multiple<O>> for SortByOperation<A>

where I: IndexDomain, V: ValueDomain, A: ArgumentSource<Keyed<I>>, O: OrderState, for<'a> I::Index<'a>: EnsureSortable, for<'a> <A::ValueDomain as ValueDomain>::Value<'a>: EnsureSortable, <A::ValueDomain as ValueDomain>::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Indexed<I, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain, O: OrderState> LaneKernel<Indexed<I, V>, Multiple<O>> for UnorderOperation

type Output = OperandHandle<Indexed<I, V>, Multiple<Unordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueEquivalence, O: OrderState> LaneKernel<Indexed<I, V>, Multiple<O>> for IsDuplicatedOperation

type Output = OperandHandle<Indexed<I, Mask>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Multiple<Ordered>> for EnumerateOperation

type Output = OperandHandle<Indexed<Positional, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Multiple<Ordered>> for FirstOperation

type Output = OperandHandle<Indexed<I, V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Multiple<Ordered>> for LastOperation

type Output = OperandHandle<Indexed<I, V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Multiple<Ordered>> for ReverseOrderOperation

type Output = OperandHandle<Indexed<I, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Multiple<Ordered>> for TakeOperation

type Output = OperandHandle<Indexed<I, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<Ordered>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<I: IndexDomain, V: ValueEquivalence> LaneKernel<Indexed<I, V>, Multiple<Ordered>> for DropDuplicatesOperation

type Output = OperandHandle<Indexed<I, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<O: OrderState> LaneKernel<Indexed<u32, Unit>, Multiple<O>> for NodesOperation

type Output = OperandHandle<Indexed<GraphRecordAttribute, Unit>, Multiple<Unordered>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: KeyedStream<'a, EdgeIndex, Unit, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<S: ElementShape, O: OrderState> PartitionArity<S> for Multiple<O>

fn into_elements<'a>( container: Self::Container<'a, S::Element<'a>>, ) -> BoxedIterator<'a, S::Element<'a>>

where S: 'a,

fn from_bucket<'a>( elements: Vec<S::Element<'a>>, ) -> QueryResult<Self::Container<'a, S::Element<'a>>>

where S: 'a,

impl<V: BareValueDomain, O: OrderState> PreparedArity<Bare<V>> for Multiple<O>

type Prepared<'a> = Arc<Vec<Result<<V as ValueDomain>::Value<'a>, Box<Failure>>>> where Bare<V>: 'a

fn prepare<'a>( container: Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>, ) -> QueryResult<Self::Prepared<'a>>

where Bare<V>: 'a,

impl<I: IndexDomain, V: ValueDomain, O: OrderState> PreparedArity<Indexed<I, V>> for Multiple<O>

type Prepared<'a> = Arc<PreparedIndexedMultiple<'a, I, V>> where Indexed<I, V>: 'a

fn prepare<'a>( container: Self::Container<'a, <Indexed<I, V> as ElementShape>::Element<'a>>, ) -> QueryResult<Self::Prepared<'a>>

where Indexed<I, V>: 'a,

impl<V, O> SetArity<Bare<V>> for Multiple<O>

where V: BareValueDomain, O: OrderState, for<'a> V::Value<'a>: Eq + Hash,

fn set<'a>(prepared: Self::Prepared<'a>) -> QueryResult<GrHashSet<V::Value<'a>>>

where Bare<V>: 'a,

impl<I, V, O> SetArity<Indexed<I, V>> for Multiple<O>

where I: IndexDomain, V: ValueDomain, O: OrderState, for<'a> V::Value<'a>: Eq + Hash,

fn set<'a>(prepared: Self::Prepared<'a>) -> QueryResult<GrHashSet<V::Value<'a>>>

where Indexed<I, V>: 'a,