Struct GroupOperand 

pub struct GroupOperand<M: IndexDomain, K: GroupKey, O: Operand> { /* private fields */ }

Trait Implementations

impl<M, K, S, C, P> Apply<P, Element> for GroupOperand<M, K, OperandHandle<S, C>>

where M: IndexDomain, K: GroupKey, S: ElementShape + ElementTransition<P::OutShape, P::Emission>, C: Arity, P: ElementKernel<S>,

type Output = GroupOperand<M, K, <OperandHandle<S, C> as Apply<P, Element>>::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<M, K, S, C, P> Apply<P, Group> for GroupOperand<M, K, OperandHandle<S, C>>

where M: IndexDomain, K: GroupKey, S: ElementShape, C: Arity, P: GroupKernel<M, K, OperandHandle<S, C>>,

type Output = <P as GroupKernel<M, K, OperandHandle<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<M: IndexDomain, K: GroupKey, S: ElementShape, C: Arity, P: LaneKernel<S, C>> Apply<P, Lane> for GroupOperand<M, K, OperandHandle<S, C>>

type Output = GroupOperand<M, K, <OperandHandle<S, C> as Apply<P, Lane>>::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<M, K, N, L, O, P, S> Apply<P, S> for GroupOperand<M, K, GroupOperand<N, L, O>>

where M: IndexDomain, K: GroupKey, N: IndexDomain, L: GroupKey, O: Operand, P: Operation<Scope = S>, S: OperationScope, GroupOperand<N, L, O>: Apply<P, S>,

type Output = GroupOperand<M, K, <GroupOperand<N, L, O> as Apply<P, S>>::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<M: IndexDomain, K: GroupKey, O: CacheableOperand> CacheableOperand for GroupOperand<M, K, O>

type Cached = PartitionOwned<M, K, <O as CacheableOperand>::Cached>

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

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

impl<M: IndexDomain, K: GroupKey, O: Operand> Clone for GroupOperand<M, K, O>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: IndexDomain, K: GroupKey, O: Operand> Estimated for GroupOperand<M, K, O>

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

impl<M: IndexDomain, K: GroupKey, O: Operand> EvaluateOperand for GroupOperand<M, K, O>

type ReturnValue<'a> = Partition<'a, M, K, O> where Self: 'a

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

impl<M: IndexDomain, K: GroupKey, O: IntoReturn> IntoReturn for GroupOperand<M, K, O>

type Return<'a> = ReturnPartition<'a, M, K, <O as IntoReturn>::Return<'a>> where Self: 'a

fn into_return<'a>(values: Partition<'a, M, K, O>) -> Self::Return<'a>

where Self: 'a,

impl<M: IndexDomain, K: GroupKey, O: Operand> Operand for GroupOperand<M, K, O>

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<'a, M: IndexDomain, K: GroupKey, O: IntoReturn> ReturnOperand<'a> for GroupOperand<M, K, O>

type ReturnValue = <GroupOperand<M, K, O> 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