Struct OperandHandle 

pub struct OperandHandle<S: ElementShape, C: Arity> { /* private fields */ }

Trait Implementations

impl<S, C, P> Apply<P, Element> for OperandHandle<S, C>

where S: ElementShape + ElementTransition<P::OutShape, P::Emission>, C: Arity, P: ElementKernel<S>,

type Output = OperandHandle<<P as ElementKernel<S>>::OutShape, <<P as ElementKernel<S>>::Emission as ElementEmission>::OutArity<C>>

fn apply<'a>( graphrecord: &'a GraphRecord, values: Self::ReturnValue<'a>, prepared: P::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

where Self: 'a,

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

impl<S: ElementShape, C: Arity, P: LaneKernel<S, C>> Apply<P, Lane> for OperandHandle<S, C>

type Output = <P as LaneKernel<S, C>>::Output

fn apply<'a>( graphrecord: &'a GraphRecord, values: Self::ReturnValue<'a>, prepared: P::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

where Self: 'a,

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

impl<S: ElementShape, C: AlignableArity<S, A>, A: Alignment> ArgumentSource<A> for OperandHandle<S, C>

type Retention = <C as AlignableArity<S, A>>::Retention

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<<S::ValueDomain as ValueDomain>::Value<'a>>>

where Self: 'a,

fn resolve<'a>( prepared: &Self::Prepared<'a>, address: &A::Address<'a>, label: &'static str, ) -> <Self::Retention as ElementEmission>::Step<QueryResult<V::Value<'a>>>

where Self: 'a,

impl<S, C, M> BitAnd<M> for OperandHandle<S, C>

where S: ElementShape, C: Arity, Self: And<M>,

type Output = <OperandHandle<S, C> as And<M>>::ReturnOperand

The resulting type after applying the & operator.

fn bitand(self, rhs: M) -> Self::Output

Performs the & operation.

impl<S, C, M> BitOr<M> for OperandHandle<S, C>

where S: ElementShape, C: Arity, Self: Or<M>,

type Output = <OperandHandle<S, C> as Or<M>>::ReturnOperand

The resulting type after applying the | operator.

fn bitor(self, rhs: M) -> Self::Output

Performs the | operation.

impl<S, C, M> BitXor<M> for OperandHandle<S, C>

where S: ElementShape, C: Arity, Self: ExclusiveOr<M>,

type Output = <OperandHandle<S, C> as ExclusiveOr<M>>::ReturnOperand

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: M) -> Self::Output

Performs the ^ operation.

impl<S: CacheableShape, C: CacheableArity<S>> CacheableOperand for OperandHandle<S, C>

type Cached = <C as CacheableArity<S>>::Cached

fn into_cached(values: Self::ReturnValue<'_>) -> Self::Cached

fn from_cached(cached: &Self::Cached) -> Self::ReturnValue<'_>

impl<S: ElementShape, C: Arity> Clone for OperandHandle<S, C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: ElementShape, C: Arity> Estimated for OperandHandle<S, C>

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

impl<S: ElementShape, C: Arity> EvaluateOperand for OperandHandle<S, C>

type ReturnValue<'a> = <C as Arity>::Container<'a, <S as ElementShape>::Element<'a>>

fn evaluate<'a>( &'a self, graphrecord: &'a GraphRecord, cache: &'a EvaluationCache<'a>, ) -> QueryResult<Self::ReturnValue<'a>>

impl<M: IndexDomain, K: GroupKey, V: BareValueDomain, C: PartitionArity<Bare<V>>> GroupKernel<M, K, OperandHandle<Bare<V>, C>> for UngroupOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Bare<V>, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, V: BareValueDomain> GroupKernel<M, K, OperandHandle<Bare<V>, Definite>> for BroadcastOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Bare<V>, Definite>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M, K, V, A> GroupKernel<M, K, OperandHandle<Bare<V>, Definite>> for BroadcastViaOperation<A>

where M: IndexDomain, K: GroupKey, V: BareValueDomain, A: IndexedElementSource, A::ValueDomain: GroupingValue<Key = K>,

type Output = OperandHandle<Indexed<<A as IndexedElementSource>::IndexDomain, V>, <A as IndexedElementSource>::Arity>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Bare<V>, Definite>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, V: BareValueDomain> GroupKernel<M, K, OperandHandle<Bare<V>, Definite>> for UngroupKeyedOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Bare<V>, Definite>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, V: BareValueDomain> GroupKernel<M, K, OperandHandle<Bare<V>, Single>> for BroadcastOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Bare<V>, Single>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M, K, V, A> GroupKernel<M, K, OperandHandle<Bare<V>, Single>> for BroadcastViaOperation<A>

where M: IndexDomain, K: GroupKey, V: BareValueDomain, A: IndexedElementSource, A::ValueDomain: GroupingValue<Key = K>,

type Output = OperandHandle<Indexed<<A as IndexedElementSource>::IndexDomain, V>, <A as IndexedElementSource>::Arity>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Bare<V>, Single>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, V: BareValueDomain> GroupKernel<M, K, OperandHandle<Bare<V>, Single>> for UngroupKeyedOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Bare<V>, Single>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, I: IndexDomain, V: ValueDomain, C: PartitionArity<Indexed<I, V>>> GroupKernel<M, K, OperandHandle<Indexed<I, V>, C>> for UngroupOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Indexed<I, V>, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, I: IndexDomain, V: ValueDomain> GroupKernel<M, K, OperandHandle<Indexed<I, V>, Definite>> for BroadcastOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Indexed<I, V>, Definite>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, I: IndexDomain, V: ValueDomain> GroupKernel<M, K, OperandHandle<Indexed<I, V>, Definite>> for UngroupKeyedOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Indexed<I, V>, Definite>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, I: IndexDomain, V: ValueDomain> GroupKernel<M, K, OperandHandle<Indexed<I, V>, Single>> for BroadcastOperation

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

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Indexed<I, V>, Single>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, I: IndexDomain, V: ValueDomain> GroupKernel<M, K, OperandHandle<Indexed<I, V>, Single>> for UngroupKeyedOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Indexed<I, V>, Single>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M, K, J, V, A> GroupKernel<M, K, OperandHandle<Indexed<J, V>, Definite>> for BroadcastViaOperation<A>

where M: IndexDomain, K: GroupKey, J: IndexDomain, V: ValueDomain, A: IndexedElementSource, A::ValueDomain: GroupingValue<Key = K>,

type Output = OperandHandle<Indexed<<A as IndexedElementSource>::IndexDomain, V>, <A as IndexedElementSource>::Arity>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Indexed<J, V>, Definite>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M, K, J, V, A> GroupKernel<M, K, OperandHandle<Indexed<J, V>, Single>> for BroadcastViaOperation<A>

where M: IndexDomain, K: GroupKey, J: IndexDomain, V: ValueDomain, A: IndexedElementSource, A::ValueDomain: GroupingValue<Key = K>,

type Output = OperandHandle<Indexed<<A as IndexedElementSource>::IndexDomain, V>, <A as IndexedElementSource>::Arity>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<Indexed<J, V>, Single>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>> GroupKernel<M, K, OperandHandle<S, C>> for BucketErrorsOperation

type Output = OperandHandle<Indexed<K, FailureValue>, Multiple<Unordered>>

fn execute<'a>( graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: Arity> GroupKernel<M, K, OperandHandle<S, C>> for KeyErrorsOperation

type Output = OperandHandle<Indexed<M, FailureValue>, Multiple<Unordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: Arity> GroupKernel<M, K, OperandHandle<S, C>> for KeysOperation

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

fn execute<'a>( graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>> GroupKernel<M, K, OperandHandle<S, C>> for DropBucketErrors

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>, D: Diagnostic> GroupKernel<M, K, OperandHandle<S, C>> for DropBucketErrorsOf<D>

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>, G: ErrorGroup> GroupKernel<M, K, OperandHandle<S, C>> for DropBucketErrorsIn<G>

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>, E: Error + 'static> GroupKernel<M, K, OperandHandle<S, C>> for DropBucketErrorsWithCause<E>

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>> GroupKernel<M, K, OperandHandle<S, C>> for RaiseBucketErrors

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>, D: Diagnostic> GroupKernel<M, K, OperandHandle<S, C>> for RaiseBucketErrorsOf<D>

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>, G: ErrorGroup> GroupKernel<M, K, OperandHandle<S, C>> for RaiseBucketErrorsIn<G>

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, C>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

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

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: BucketFailureArity<S>, E: Error + 'static> GroupKernel<M, K, OperandHandle<S, C>> for RaiseBucketErrorsWithCause<E>

type Output = GroupOperand<M, K, OperandHandle<S, C>>

fn execute<'a>( _graphrecord: &'a GraphRecord, partition: Partition<'a, M, K, OperandHandle<S, 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, C: EnumerableArity<Indexed<I, V>, I>> IndexedElementSource for OperandHandle<Indexed<I, V>, C>

type Arity = C

type IndexDomain = I

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

where Self: 'a,

impl<S: ReturnShape, C: Arity> IntoReturn for OperandHandle<S, C>

type Return<'a> = <C as Arity>::Container<'a, <S as ReturnShape>::ReturnElement<'a>> where Self: 'a

fn into_return<'a>(values: Self::ReturnValue<'a>) -> Self::Return<'a>

where Self: 'a,

impl<A: Alignment, V: BareValueDomain> MaybeAbsent<A> for OperandHandle<Bare<V>, Single>

fn on_missing<P>(self, policy: P) -> WithMissing<A, Self, P>

where Self: Sized, P: MissingPolicy<A, Self>,

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

fn on_missing<P>(self, policy: P) -> WithMissing<A, Self, P>

where Self: Sized, P: MissingPolicy<A, Self>,

impl<S, C> Not for OperandHandle<S, C>

where S: ElementShape, C: Arity, Self: Not,

type Output = <OperandHandle<S, C> as Not>::ReturnOperand

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<S: ElementShape, C: Arity> Operand for OperandHandle<S, C>

fn context(&self) -> &dyn OperandContext<Self>

fn as_plan_node(&self) -> &dyn PlanNode

fn from_context(context: Arc<dyn OperandContext<Self>>) -> Self

fn new<C: OperandContext<Self>>(context: C) -> Self

fn explain(&self) -> Explanation<'_>

impl<S: ElementShape, C: PreparedArity<S>> Prepare for OperandHandle<S, C>

type Prepared<'a> = <C as PreparedArity<S>>::Prepared<'a> where Self: 'a

fn prepare<'a>( &'a self, graphrecord: &'a GraphRecord, cache: &'a EvaluationCache<'a>, ) -> QueryResult<Self::Prepared<'a>>

impl<'a, S: ReturnShape, C: Arity> ReturnOperand<'a> for OperandHandle<S, C>

type ReturnValue = <OperandHandle<S, C> as IntoReturn>::Return<'a>

fn evaluate( &'a self, graphrecord: &'a GraphRecord, cache: &'a EvaluationCache<'a>, ) -> QueryResult<Self::ReturnValue>

fn optimize( self, optimizer: &Optimizer, stats: &Stats<'_>, ) -> (Self, OptimizationReport)

fn fmt_plan(&self, formatter: &mut Formatter<'_>) -> Result

impl<S: ElementShape, C: SetArity<S>> SetSource<<S as ElementShape>::ValueDomain> for OperandHandle<S, C>

fn set<'a>( prepared: Self::Prepared<'a>, ) -> QueryResult<GrHashSet<<S::ValueDomain as ValueDomain>::Value<'a>>>

where Self: 'a, <S::ValueDomain as ValueDomain>::Value<'a>: Eq + Hash,

impl<S: ElementShape, C: Arity> SourceDomain for OperandHandle<S, C>

type ValueDomain = <S as ElementShape>::ValueDomain