Struct Indexed 

pub struct Indexed<K: IndexDomain, V: ValueDomain>(/* 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<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<I: IndexDomain, V: ValueDomain> BucketFailureArity<Indexed<I, V>> for Single

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<I: IndexDomain, V: ValueDomain> BucketFailureArity<Indexed<I, V>> for Definite

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<I: IndexDomain, V: ValueDomain> CacheableShape for Indexed<I, V>

type CachedElement = (<I as IndexDomain>::Owned, Result<<V as ValueDomain>::Owned, Box<Failure>>)

fn into_cached_element(element: Self::Element<'_>) -> Self::CachedElement

fn from_cached_element(cached: &Self::CachedElement) -> Self::Element<'_>

impl<E: EntityAttributes> ElementKernel<Indexed<E, Unit>> for HasAttributeOperation

type Emission = Preserving

type OutShape = Indexed<E, Mask>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<E, Unit>, Self>>

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

impl<P, C, W, S> ElementKernel<Indexed<ExpandedIndex<P, C>, W>> for ExpandToOperation<S>

where P: IndexDomain, C: IndexDomain, W: ValueDomain, S: ArgumentSource<Keyed<P>> + Clone,

type Emission = <S as ArgumentSource<Keyed<P>>>::Retention

type OutShape = Indexed<ExpandedIndex<P, C>, <S as SourceDomain>::ValueDomain>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<ExpandedIndex<P, C>, W>, Self>>

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

impl ElementKernel<Indexed<GraphRecordAttribute, Unit>> for ViaEdgesOperation

type Emission = Expanding<Unordered>

type OutShape = Indexed<ExpandedIndex<GraphRecordAttribute, u32>, EntityReference<u32>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<NodeIndex, Unit>, Self>>

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

impl ElementKernel<Indexed<GraphRecordAttribute, Unit>> for ViaNeighborsOperation

type Emission = Expanding<Unordered>

type OutShape = Indexed<ExpandedIndex<GraphRecordAttribute, GraphRecordAttribute>, EntityReference<GraphRecordAttribute>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<NodeIndex, Unit>, Self>>

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

impl<E: EntityDomain, I: IndexDomain> ElementKernel<Indexed<I, EntityReference<E>>> for IndexOperation

type Emission = Preserving

type OutShape = Indexed<I, IndexValue<E>>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<E>>, Self>>

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

impl<E: EntityAttributes, I: IndexDomain> ElementKernel<Indexed<I, EntityReference<E>>> for AttributeOperation

type Emission = Preserving

type OutShape = Indexed<I, Scalar>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<E>>, Self>>

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

impl<E: EntityAttributes, I: IndexDomain> ElementKernel<Indexed<I, EntityReference<E>>> for AttributesOperation

type Emission = Expanding<Unordered>

type OutShape = Indexed<ExpandedIndex<I, AttributeName>, AttributeName>

fn pipeline<'a>( graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<E>>, Self>>

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

impl<E: EntityAttributes, I: IndexDomain> ElementKernel<Indexed<I, EntityReference<E>>> for HasAttributeOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<E>>, Self>>

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

impl<E: IndicesInGroup, I: IndexDomain> ElementKernel<Indexed<I, EntityReference<E>>> for InGroupOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<E>>, Self>>

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

impl<I: IndexDomain> ElementKernel<Indexed<I, EntityReference<GraphRecordAttribute>>> for ViaEdgesOperation

type Emission = Expanding<Unordered>

type OutShape = Indexed<ExpandedIndex<I, u32>, EntityReference<u32>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<NodeIndex>>, Self>>

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

impl<I: IndexDomain> ElementKernel<Indexed<I, EntityReference<GraphRecordAttribute>>> for ViaNeighborsOperation

type Emission = Expanding<Unordered>

type OutShape = Indexed<ExpandedIndex<I, GraphRecordAttribute>, EntityReference<GraphRecordAttribute>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<NodeIndex>>, Self>>

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

impl<I: IndexDomain> ElementKernel<Indexed<I, EntityReference<u32>>> for EndpointOperation

type Emission = Preserving

type OutShape = Indexed<I, EntityReference<GraphRecordAttribute>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<EdgeIndex>>, Self>>

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

impl<I: IndexDomain> ElementKernel<Indexed<I, EntityReference<u32>>> for ViaNodesOperation

type Emission = Expanding<Ordered>

type OutShape = Indexed<ExpandedIndex<I, EdgeEndpointRole>, EntityReference<GraphRecordAttribute>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, EntityReference<EdgeIndex>>, Self>>

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

impl<I: IndexDomain> ElementKernel<Indexed<I, FailureKindValue>> for ErrorKindNameOperation

type Emission = Preserving

type OutShape = Indexed<I, Scalar>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, FailureKindValue>, Self>>

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

impl<I: IndexDomain> ElementKernel<Indexed<I, FailureValue>> for ErrorKindOperation

type Emission = Preserving

type OutShape = Indexed<I, FailureKindValue>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, FailureValue>, Self>>

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

impl<I: IndexDomain, D: Diagnostic> ElementKernel<Indexed<I, FailureValue>> for IsErrorKindOperation<D>

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, FailureValue>, Self>>

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

impl<I: IndexDomain, G: ErrorGroup> ElementKernel<Indexed<I, FailureValue>> for InErrorGroupOperation<G>

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, FailureValue>, Self>>

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

impl<I: IndexDomain, C: Error + 'static> ElementKernel<Indexed<I, FailureValue>> for HasErrorCauseOperation<C>

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, FailureValue>, Self>>

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

impl<E: EntityDomain, I: IndexDomain> ElementKernel<Indexed<I, IndexValue<E>>> for ResolveOperation

type Emission = Preserving

type OutShape = Indexed<I, EntityReference<E>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, IndexValue<E>>, Self>>

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

impl<I: IndexDomain, P: IndexDomain, C: IndexDomain> ElementKernel<Indexed<I, IndexValue<ExpandedIndex<P, C>>>> for ParentIndexOperation

type Emission = Preserving

type OutShape = Indexed<I, IndexValue<P>>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, IndexValue<ExpandedIndex<P, C>>>, Self>>

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

impl<I: IndexDomain, P: IndexDomain, C: IndexDomain> ElementKernel<Indexed<I, IndexValue<ExpandedIndex<P, C>>>> for ChildIndexOperation

type Emission = Preserving

type OutShape = Indexed<I, IndexValue<C>>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, IndexValue<ExpandedIndex<P, C>>>, Self>>

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

impl<I, M> ElementKernel<Indexed<I, Mask>> for AndOperation<M>

where I: IndexDomain, M: ArgumentSource<Keyed<I>, Mask>,

type Emission = <M as ArgumentSource<Keyed<I>, Mask>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, Mask>, Self>>

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

impl<I, M> ElementKernel<Indexed<I, Mask>> for ExclusiveOrOperation<M>

where I: IndexDomain, M: ArgumentSource<Keyed<I>, Mask>,

type Emission = <M as ArgumentSource<Keyed<I>, Mask>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, Mask>, Self>>

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

impl<I: IndexDomain> ElementKernel<Indexed<I, Mask>> for NotOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, Mask>, Self>>

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

impl<I, M> ElementKernel<Indexed<I, Mask>> for OrOperation<M>

where I: IndexDomain, M: ArgumentSource<Keyed<I>, Mask>,

type Emission = <M as ArgumentSource<Keyed<I>, Mask>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, Mask>, Self>>

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

impl<I, S, T> ElementKernel<Indexed<I, S>> for TransitionOperation<T>

where I: IndexDomain, S: ValueTransition<T>, T: ValueDomain,

type Emission = Preserving

type OutShape = Indexed<I, T>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, S>, Self>>

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

impl<I: EntityAttributes> ElementKernel<Indexed<I, Unit>> for AttributeOperation

type Emission = Preserving

type OutShape = Indexed<I, Scalar>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, Unit>, Self>>

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

impl<I: EntityAttributes> ElementKernel<Indexed<I, Unit>> for AttributesOperation

type Emission = Expanding<Unordered>

type OutShape = Indexed<ExpandedIndex<I, AttributeName>, AttributeName>

fn pipeline<'a>( graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, Unit>, Self>>

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

impl<I: IndicesInGroup> ElementKernel<Indexed<I, Unit>> for InGroupOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, Unit>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for AddOperation<A>

where I: IndexDomain, V: ValueAdd, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for DivideOperation<A>

where I: IndexDomain, V: ValueDivide, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for ModuloOperation<A>

where I: IndexDomain, V: ValueModulo, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for MultiplyOperation<A>

where I: IndexDomain, V: ValueMultiply, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for PowerOperation<A>

where I: IndexDomain, V: ValuePower, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for SubtractOperation<A>

where I: IndexDomain, V: ValueSubtract, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for EqualToOperation<A>

where I: IndexDomain, V: ValueEquality, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for GreaterThanOperation<A>

where I: IndexDomain, V: ValueOrdering, A: ArgumentSource<Keyed<I>, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for GreaterThanOrEqualToOperation<A>

where I: IndexDomain, V: ValueOrdering, A: ArgumentSource<Keyed<I>, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for LessThanOperation<A>

where I: IndexDomain, V: ValueOrdering, A: ArgumentSource<Keyed<I>, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for LessThanOrEqualToOperation<A>

where I: IndexDomain, V: ValueOrdering, A: ArgumentSource<Keyed<I>, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for NotEqualToOperation<A>

where I: IndexDomain, V: ValueEquality, A: ArgumentSource<Keyed<I>, V>,

type Emission = <A as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, T> ElementKernel<Indexed<I, V>> for CastOperation<T>

where I: IndexDomain, V: ValueCast<T>, T: CastTarget,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: BareValueDomain> ElementKernel<Indexed<I, V>> for DiscardIndexOperation

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueDomain> ElementKernel<Indexed<I, V>> for DiscardValueOperation

type Emission = Preserving

type OutShape = Indexed<I, Unit>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueDomain> ElementKernel<Indexed<I, V>> for ErrorsOperation

type Emission = Dropping

type OutShape = Indexed<I, FailureValue>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueDomain> ElementKernel<Indexed<I, V>> for Drop

type Emission = Dropping

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueDomain, D: Diagnostic> ElementKernel<Indexed<I, V>> for DropErrorsOf<D>

type Emission = Dropping

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueDomain, G: ErrorGroup> ElementKernel<Indexed<I, V>> for DropErrorsIn<G>

type Emission = Dropping

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueDomain, C: Error + 'static> ElementKernel<Indexed<I, V>> for DropErrorsWithCause<C>

type Emission = Dropping

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, R> ElementKernel<Indexed<I, V>> for Replace<R>

where I: IndexDomain, V: ValueDomain, R: ArgumentSource<Keyed<I>, V>,

type Emission = <R as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, D, R> ElementKernel<Indexed<I, V>> for ReplaceErrorsOf<D, R>

where I: IndexDomain, V: ValueDomain, D: Diagnostic, R: ArgumentSource<Keyed<I>, V>,

type Emission = <R as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, G, R> ElementKernel<Indexed<I, V>> for ReplaceErrorsIn<G, R>

where I: IndexDomain, V: ValueDomain, G: ErrorGroup, R: ArgumentSource<Keyed<I>, V>,

type Emission = <R as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, C, R> ElementKernel<Indexed<I, V>> for ReplaceErrorsWithCause<C, R>

where I: IndexDomain, V: ValueDomain, C: Error + 'static, R: ArgumentSource<Keyed<I>, V>,

type Emission = <R as ArgumentSource<Keyed<I>, V>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueScalarKindTest> ElementKernel<Indexed<I, V>> for IsBoolOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueScalarKindTest> ElementKernel<Indexed<I, V>> for IsDateTimeOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueScalarKindTest> ElementKernel<Indexed<I, V>> for IsDurationOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueScalarKindTest> ElementKernel<Indexed<I, V>> for IsFloatOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueKindTest> ElementKernel<Indexed<I, V>> for IsIntOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueScalarKindTest> ElementKernel<Indexed<I, V>> for IsNullOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I: IndexDomain, V: ValueKindTest> ElementKernel<Indexed<I, V>> for IsStringOperation

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for IsInOperation<A>

where I: IndexDomain, V: ValueEquality, A: SetSource<V>, for<'a> V::Value<'a>: Eq + Hash,

type Emission = Preserving

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for AbsoluteOperation

where I: IndexDomain, V: ValueAbsolute,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for CeilOperation

where I: IndexDomain, V: ValueCeil,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, L, U> ElementKernel<Indexed<I, V>> for ClipOperation<L, U>

where I: IndexDomain, V: ValueClip, L: ArgumentSource<Keyed<I>, V>, U: ArgumentSource<Keyed<I>, V>,

type Emission = <<L as ArgumentSource<Keyed<I>, V>>::Retention as Retention>::Then<<U as ArgumentSource<Keyed<I>, V>>::Retention>

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for CubeRootOperation

where I: IndexDomain, V: ValueCubeRoot,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for ExponentialOperation

where I: IndexDomain, V: ValueExponential,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for FloorOperation

where I: IndexDomain, V: ValueFloor,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for LogarithmOperation

where I: IndexDomain, V: ValueLogarithm,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for NegateOperation

where I: IndexDomain, V: ValueNegate,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for RoundOperation

where I: IndexDomain, V: ValueRound,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for SignOperation

where I: IndexDomain, V: ValueSign,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for SquareRootOperation

where I: IndexDomain, V: ValueSquareRoot,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for ContainsOperation<A>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Keyed<I>>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for EndsWithOperation<A>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Keyed<I>>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for LengthOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, Scalar>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for LowercaseOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for MatchesOperation<A>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Keyed<I>>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, W, C> ElementKernel<Indexed<I, V>> for PadEndOperation<W, C>

where I: IndexDomain, V: StringValue, W: ArgumentSource<Keyed<I>>, W::ValueDomain: IntValue, C: ArgumentSource<Keyed<I>>, C::ValueDomain: StringValue,

type Emission = <<W as ArgumentSource<Keyed<I>>>::Retention as Retention>::Then<<C as ArgumentSource<Keyed<I>>>::Retention>

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, W, C> ElementKernel<Indexed<I, V>> for PadStartOperation<W, C>

where I: IndexDomain, V: StringValue, W: ArgumentSource<Keyed<I>>, W::ValueDomain: IntValue, C: ArgumentSource<Keyed<I>>, C::ValueDomain: StringValue,

type Emission = <<W as ArgumentSource<Keyed<I>>>::Retention as Retention>::Then<<C as ArgumentSource<Keyed<I>>>::Retention>

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A, B> ElementKernel<Indexed<I, V>> for ReplaceOperation<A, B>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue, B: ArgumentSource<Keyed<I>>, B::ValueDomain: StringValue,

type Emission = <<A as ArgumentSource<Keyed<I>>>::Retention as Retention>::Then<<B as ArgumentSource<Keyed<I>>>::Retention>

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A, B> ElementKernel<Indexed<I, V>> for ReplaceAllOperation<A, B>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue, B: ArgumentSource<Keyed<I>>, B::ValueDomain: StringValue,

type Emission = <<A as ArgumentSource<Keyed<I>>>::Retention as Retention>::Then<<B as ArgumentSource<Keyed<I>>>::Retention>

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for ReverseOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for SliceOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for SplitOperation<A>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue,

type Emission = Expanding<Ordered>

type OutShape = Indexed<ExpandedIndex<I, Positional>, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for StartsWithOperation<A>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Keyed<I>>>::Retention

type OutShape = Indexed<I, Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for StripPrefixOperation<A>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Keyed<I>>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, A> ElementKernel<Indexed<I, V>> for StripSuffixOperation<A>

where I: IndexDomain, V: StringValue, A: ArgumentSource<Keyed<I>>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Keyed<I>>>::Retention

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for TrimOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for TrimEndOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for TrimStartOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V> ElementKernel<Indexed<I, V>> for UppercaseOperation

where I: IndexDomain, V: StringValue,

type Emission = Preserving

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<I, V, M> ElementKernel<Indexed<I, V>> for FilterOperation<M>

where I: IndexDomain, V: ValueDomain, M: ArgumentSource<Keyed<I>, Mask>,

type Emission = Dropping

type OutShape = Indexed<I, V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<I, V>, Self>>

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

impl<K: IndexDomain> ElementKernel<Indexed<K, Unit>> for IndexOperation

type Emission = Preserving

type OutShape = Indexed<K, IndexValue<K>>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<K, Unit>, Self>>

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

impl ElementKernel<Indexed<u32, Unit>> for EndpointOperation

type Emission = Preserving

type OutShape = Indexed<u32, EntityReference<GraphRecordAttribute>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<EdgeIndex, Unit>, Self>>

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

impl ElementKernel<Indexed<u32, Unit>> for ViaNodesOperation

type Emission = Expanding<Ordered>

type OutShape = Indexed<ExpandedIndex<u32, EdgeEndpointRole>, EntityReference<GraphRecordAttribute>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Indexed<EdgeIndex, Unit>, Self>>

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

impl<K: IndexDomain, V: ValueDomain> ElementShape for Indexed<K, V>

type Element<'a> = (<K as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>)

type ValueDomain = V

impl<I: IndexDomain, V: ValueDomain, W: BareValueDomain, E: ElementEmission> ElementTransition<Bare<W>, E> for Indexed<I, V>

type Pipeline<'a> = Pipeline<'a, (<I as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>), <E as ElementEmission>::Step<Result<<W as ValueDomain>::Value<'a>, Box<Failure>>>, E>

fn apply<'a, C: Arity>( values: C::Container<'a, Self::Element<'a>>, pipeline: Self::Pipeline<'a>, ) -> <E::OutArity<C> as Arity>::Container<'a, <Bare<W> as ElementShape>::Element<'a>>

impl<P: IndexDomain, C: IndexDomain, V: ValueDomain, W: ValueDomain> ElementTransition<Indexed<ExpandedIndex<P, C>, W>, Expanding<Ordered>> for Indexed<P, V>

type Pipeline<'a> = Pipeline<'a, (<P as IndexDomain>::Index<'a>, <V as ValueDomain>::Value<'a>), Result<Vec<ExpandedChild<'a, C, W>>, Box<Failure>>, Expanding<Ordered>> where Self: 'a, Indexed<ExpandedIndex<P, C>, W>: 'a

fn apply<'a, A: Arity>( values: A::Container<'a, Self::Element<'a>>, pipeline: Self::Pipeline<'a>, ) -> <<Expanding<Ordered> as ElementEmission>::OutArity<A> as Arity>::Container<'a, <Indexed<ExpandedIndex<P, C>, W> as ElementShape>::Element<'a>>

impl<P: IndexDomain, C: IndexDomain, V: ValueDomain, W: ValueDomain> ElementTransition<Indexed<ExpandedIndex<P, C>, W>, Expanding<Unordered>> for Indexed<P, V>

type Pipeline<'a> = Pipeline<'a, (<P as IndexDomain>::Index<'a>, <V as ValueDomain>::Value<'a>), Result<Vec<ExpandedChild<'a, C, W>>, Box<Failure>>, Expanding<Unordered>> where Self: 'a, Indexed<ExpandedIndex<P, C>, W>: 'a

fn apply<'a, A: Arity>( values: A::Container<'a, Self::Element<'a>>, pipeline: Self::Pipeline<'a>, ) -> <<Expanding<Unordered> as ElementEmission>::OutArity<A> as Arity>::Container<'a, <Indexed<ExpandedIndex<P, C>, W> as ElementShape>::Element<'a>>

impl<I: IndexDomain, V: ValueDomain, W: ValueDomain, E: Retention> ElementTransition<Indexed<I, W>, E> for Indexed<I, V>

type Pipeline<'a> = Pipeline<'a, (<I as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>), <E as ElementEmission>::Step<Result<<W as ValueDomain>::Value<'a>, Box<Failure>>>, E>

fn apply<'a, C: Arity>( values: C::Container<'a, Self::Element<'a>>, pipeline: Self::Pipeline<'a>, ) -> <E::OutArity<C> as Arity>::Container<'a, <Indexed<I, W> as ElementShape>::Element<'a>>

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<I: IndexDomain, V: ValueDomain> EnumerableArity<Indexed<I, V>, I> for Single

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

where Indexed<I, V>: 'a,

impl<I: IndexDomain, V: ValueDomain> EnumerableArity<Indexed<I, V>, I> for Definite

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

where Indexed<I, V>: 'a,

impl LaneKernel<Indexed<GraphRecordAttribute, Unit>, Definite> for EdgesOperation

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

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

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

impl LaneKernel<Indexed<GraphRecordAttribute, Unit>, Definite> for NeighborsOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, NodeIndex, Unit, Definite>, 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 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 LaneKernel<Indexed<GraphRecordAttribute, Unit>, Single> for EdgesOperation

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

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

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

impl LaneKernel<Indexed<GraphRecordAttribute, Unit>, Single> for NeighborsOperation

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

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

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

impl<E: EntityDomain, I: IndexDomain> LaneKernel<Indexed<I, EntityReference<E>>, Definite> for SelectOperation

type Output = OperandHandle<Indexed<E, Unit>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<E>, Definite>, _prepared: 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<E: EntityDomain, I: IndexDomain> LaneKernel<Indexed<I, EntityReference<E>>, Single> for SelectOperation

type Output = OperandHandle<Indexed<E, Unit>, Single>

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

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

impl<I: IndexDomain> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Definite> for EdgesOperation

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

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

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

impl<I: IndexDomain> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Definite> for NeighborsOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<NodeIndex>, Definite>, 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 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> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Single> for EdgesOperation

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

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

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

impl<I: IndexDomain> LaneKernel<Indexed<I, EntityReference<GraphRecordAttribute>>, Single> for NeighborsOperation

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

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

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

impl<I: IndexDomain> LaneKernel<Indexed<I, EntityReference<u32>>, Definite> for NodesOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<EdgeIndex>, Definite>, _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<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> LaneKernel<Indexed<I, EntityReference<u32>>, Single> for NodesOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, EntityReference<EdgeIndex>, Single>, _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, V, K, C> LaneKernel<Indexed<I, V>, C> for GroupByOperation<K>

where I: IndexDomain, V: ValueDomain, K: ArgumentSource<Keyed<I>>, K::ValueDomain: GroupingValue, C: PartitionArity<Indexed<I, V>>,

type Output = GroupOperand<I, <<K as SourceDomain>::ValueDomain as GroupingValue>::Key, OperandHandle<Indexed<I, V>, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: KeyedStream<'a, I, V, C>, 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>, Definite> for CountOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Definite>, _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>, Definite> for Raise

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

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

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

impl<I, V, C> LaneKernel<Indexed<I, V>, Definite> for RaiseWhen<C>

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

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

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

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

impl<I: IndexDomain, V: ValueDomain, D: Diagnostic> LaneKernel<Indexed<I, V>, Definite> for RaiseErrorsOf<D>

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

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

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

impl<I: IndexDomain, V: ValueDomain, G: ErrorGroup> LaneKernel<Indexed<I, V>, Definite> for RaiseErrorsIn<G>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Definite>, 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 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<I: IndexDomain, V: ValueDomain> LaneKernel<Indexed<I, V>, Single> for CountOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, value: KeyedStream<'a, I, V, Single>, _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>, Single> for Raise

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

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

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

impl<I, V, C> LaneKernel<Indexed<I, V>, Single> for RaiseWhen<C>

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

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

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

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

impl<I: IndexDomain, V: ValueDomain, D: Diagnostic> LaneKernel<Indexed<I, V>, Single> for RaiseErrorsOf<D>

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

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

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

impl<I: IndexDomain, V: ValueDomain, G: ErrorGroup> LaneKernel<Indexed<I, V>, Single> for RaiseErrorsIn<G>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl LaneKernel<Indexed<u32, Unit>, Definite> for NodesOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, value: KeyedStream<'a, EdgeIndex, Unit, Definite>, _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 LaneKernel<Indexed<u32, Unit>, Single> for NodesOperation

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

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

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

impl<M: IndexDomain, V: ValueDomain> PartitionShape<M> for Indexed<M, V>

fn member<'a>(element: &Self::Element<'a>) -> M::Index<'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<I: IndexDomain, V: ValueDomain> PreparedArity<Indexed<I, V>> for Single

type Prepared<'a> = Option<(<I as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>)> 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<I: IndexDomain, V: ValueDomain> PreparedArity<Indexed<I, V>> for Definite

type Prepared<'a> = (<I as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>) 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<K: IndexDomain, V: ReturnValueDomain> ReturnShape for Indexed<K, V>

type ReturnElement<'a> = (<K as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>)

fn into_return_element(element: Self::Element<'_>) -> Self::ReturnElement<'_>

impl<K: IndexDomain> ReturnShape for Indexed<K, Unit>

type ReturnElement<'a> = Result<<K as IndexDomain>::Owned, Box<Failure>>

fn into_return_element(element: Self::Element<'_>) -> Self::ReturnElement<'_>

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,

impl<I, V> SetArity<Indexed<I, V>> for Single

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

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

where Indexed<I, V>: 'a,

impl<I, V> SetArity<Indexed<I, V>> for Definite

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

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

where Indexed<I, V>: 'a,