pub struct Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>where
Sc: Score,
P1: CompileCondition<Plan: IndexedPlan>,
P2: CompileCondition<Plan: IndexedPlan>,
P3: CompileCondition<Plan: IndexedPlan>,
P4: CompileCondition<Plan: IndexedPlan>,{ /* private fields */ }Expand description
Five-collection join stream: the tri join extended with D through P3 and
then E through P4, each step compiled into its own plan over the row
before it.
Implementations§
Source§impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>where
S: Send + Sync + 'static,
A: Clone + Send + Sync + 'static,
B: Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,
D: Clone + Send + Sync + 'static,
E: Clone + Send + Sync + 'static,
EA: 'static,
EB: 'static,
EC: 'static,
ED: 'static,
EE: 'static,
P1: CompileCondition<Plan: IndexedPlan> + 'static,
P2: CompileCondition<Plan: IndexedPlan> + 'static,
P3: CompileCondition<Plan: IndexedPlan> + 'static,
P4: CompileCondition<Plan: IndexedPlan> + 'static,
for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S>,
F: PentaFilter<S, A, B, C, D, E>,
Sc: Score + 'static,
impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>where
S: Send + Sync + 'static,
A: Clone + Send + Sync + 'static,
B: Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,
D: Clone + Send + Sync + 'static,
E: Clone + Send + Sync + 'static,
EA: 'static,
EB: 'static,
EC: 'static,
ED: 'static,
EE: 'static,
P1: CompileCondition<Plan: IndexedPlan> + 'static,
P2: CompileCondition<Plan: IndexedPlan> + 'static,
P3: CompileCondition<Plan: IndexedPlan> + 'static,
P4: CompileCondition<Plan: IndexedPlan> + 'static,
for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S>,
F: PentaFilter<S, A, B, C, D, E>,
Sc: Score + 'static,
Sourcepub fn filter<P>(
self,
predicate: P,
) -> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, AndPentaFilter<F, FnPentaFilter<impl Fn(&S, &A, &B, &C, &D, &E, usize, usize, usize, usize, usize) -> bool + Send + Sync>>, Sc>
pub fn filter<P>( self, predicate: P, ) -> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, AndPentaFilter<F, FnPentaFilter<impl Fn(&S, &A, &B, &C, &D, &E, usize, usize, usize, usize, usize) -> bool + Send + Sync>>, Sc>
Adds a filter predicate to the stream.
Sourcepub fn penalize<W>(
self,
weight: W,
) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>
pub fn penalize<W>( self, weight: W, ) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>
Penalizes each match by weight.
weight is a fixed score, or a closure over the matched entities returning one.
A fixed weight with a non-zero hard level marks the constraint hard; closures
are soft unless wrapped in hard_weight.
Sourcepub fn reward<W>(
self,
weight: W,
) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>
pub fn reward<W>( self, weight: W, ) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>
Rewards each match by weight.
weight is a fixed score, or a closure over the matched entities returning one.
A fixed weight with a non-zero hard level marks the constraint hard; closures
are soft unless wrapped in hard_weight.
Source§impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>where
S: Send + Sync + 'static,
A: Clone + Send + Sync + 'static,
B: Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,
D: Clone + Send + Sync + 'static,
E: Clone + Send + Sync + 'static,
EA: 'static,
EB: 'static,
EC: 'static,
ED: 'static,
EE: 'static,
P1: CompileCondition<Plan: IndexedPlan> + 'static,
P2: CompileCondition<Plan: IndexedPlan> + 'static,
P3: CompileCondition<Plan: IndexedPlan> + 'static,
P4: CompileCondition<Plan: IndexedPlan> + 'static,
F: PentaFilter<S, A, B, C, D, E> + 'static,
Sc: Score + 'static,
for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S, View<'a> = Pair<Pair<Pair<Pair<Leaf<'a, A>, Leaf<'a, B>>, Leaf<'a, C>>, Leaf<'a, D>>, Leaf<'a, E>>> + Send + Sync,
Zero-erasure builder for finalizing a canonical penta constraint.
impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>where
S: Send + Sync + 'static,
A: Clone + Send + Sync + 'static,
B: Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,
D: Clone + Send + Sync + 'static,
E: Clone + Send + Sync + 'static,
EA: 'static,
EB: 'static,
EC: 'static,
ED: 'static,
EE: 'static,
P1: CompileCondition<Plan: IndexedPlan> + 'static,
P2: CompileCondition<Plan: IndexedPlan> + 'static,
P3: CompileCondition<Plan: IndexedPlan> + 'static,
P4: CompileCondition<Plan: IndexedPlan> + 'static,
F: PentaFilter<S, A, B, C, D, E> + 'static,
Sc: Score + 'static,
for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S, View<'a> = Pair<Pair<Pair<Pair<Leaf<'a, A>, Leaf<'a, B>>, Leaf<'a, C>>, Leaf<'a, D>>, Leaf<'a, E>>> + Send + Sync,
Zero-erasure builder for finalizing a canonical penta constraint.
Sourcepub fn join<G, EG, P5>(
self,
target: (EG, P5),
) -> Chain<S, JoinNode<S, PentaScored<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>, Sc>where
G: Clone + Send + Sync + 'static,
EG: CollectionExtract<S, Item = G> + 'static,
P5: CompileCondition + 'static,
for<'a> P5::Plan: IndexedPlan + ExecutablePlan<<JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan> as Operator<S>>::View<'a>, Leaf<'a, G>>,
for<'a> JoinNode<S, PentaScored<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>: Operator<S>,
pub fn join<G, EG, P5>(
self,
target: (EG, P5),
) -> Chain<S, JoinNode<S, PentaScored<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>, Sc>where
G: Clone + Send + Sync + 'static,
EG: CollectionExtract<S, Item = G> + 'static,
P5: CompileCondition + 'static,
for<'a> P5::Plan: IndexedPlan + ExecutablePlan<<JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan> as Operator<S>>::View<'a>, Leaf<'a, G>>,
for<'a> JoinNode<S, PentaScored<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>: Operator<S>,
Continues the chain past the named cross-stream arities.
Returns a Chain over this penta’s tree with every filter authored so
far applied once at the penta boundary; subsequent .join(...) calls
nest further JoinNodes with no fixed ceiling.
§Key shapes
This join also takes VIEW keys, not entity keys: the left key closure
receives the whole borrowed (A, B, C, D, E) row and the right key
receives &Leaf<'_, G> (read fields via .entity). equal_bi with
entity closures does NOT typecheck here (E0631) — use equal_on.
Source§impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>where
S: Send + Sync + 'static,
A: Clone + Send + Sync + 'static,
B: Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,
D: Clone + Send + Sync + 'static,
E: Clone + Send + Sync + 'static,
EA: 'static,
EB: 'static,
EC: 'static,
ED: 'static,
EE: 'static,
P1: CompileCondition<Plan: IndexedPlan> + 'static,
P2: CompileCondition<Plan: IndexedPlan> + 'static,
P3: CompileCondition<Plan: IndexedPlan> + 'static,
P4: CompileCondition<Plan: IndexedPlan> + 'static,
for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S, View<'a> = Pair<Pair<Pair<Pair<Leaf<'a, A>, Leaf<'a, B>>, Leaf<'a, C>>, Leaf<'a, D>>, Leaf<'a, E>>> + Send + Sync,
F: PentaFilter<S, A, B, C, D, E> + 'static,
Sc: Score + 'static,
impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>where
S: Send + Sync + 'static,
A: Clone + Send + Sync + 'static,
B: Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,
D: Clone + Send + Sync + 'static,
E: Clone + Send + Sync + 'static,
EA: 'static,
EB: 'static,
EC: 'static,
ED: 'static,
EE: 'static,
P1: CompileCondition<Plan: IndexedPlan> + 'static,
P2: CompileCondition<Plan: IndexedPlan> + 'static,
P3: CompileCondition<Plan: IndexedPlan> + 'static,
P4: CompileCondition<Plan: IndexedPlan> + 'static,
for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S, View<'a> = Pair<Pair<Pair<Pair<Leaf<'a, A>, Leaf<'a, B>>, Leaf<'a, C>>, Leaf<'a, D>>, Leaf<'a, E>>> + Send + Sync,
F: PentaFilter<S, A, B, C, D, E> + 'static,
Sc: Score + 'static,
Sourcepub fn group_by<GK, GF, Co, V, R, Acc>(
self,
key: GF,
collector: Co,
) -> JoinedGroupedStream<S, FilterNode<JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>, impl Fn(&S, &Pair<Pair<Pair<Pair<Leaf<'_, A>, Leaf<'_, B>>, Leaf<'_, C>>, Leaf<'_, D>>, Leaf<'_, E>>) -> bool + Send + Sync>, impl Fn(&Pair<Pair<Pair<Pair<Leaf<'_, A>, Leaf<'_, B>>, Leaf<'_, C>>, Leaf<'_, D>>, Leaf<'_, E>>) -> GK + Send + Sync, TupleCollector<Co, V, R, Acc>, GK, V, R, Acc, Sc>where
GK: Eq + Hash + Clone + Send + Sync + 'static,
GF: Fn(&A, &B, &C, &D, &E) -> GK + Send + Sync + 'static,
Co: for<'i> Collector<(&'i A, &'i B, &'i C, &'i D, &'i E), Value = V, Result = R, Accumulator = Acc> + 'static,
V: Send + Sync + 'static,
R: Send + Sync + 'static,
Acc: Accumulator<V, R> + 'static,
pub fn group_by<GK, GF, Co, V, R, Acc>(
self,
key: GF,
collector: Co,
) -> JoinedGroupedStream<S, FilterNode<JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>, impl Fn(&S, &Pair<Pair<Pair<Pair<Leaf<'_, A>, Leaf<'_, B>>, Leaf<'_, C>>, Leaf<'_, D>>, Leaf<'_, E>>) -> bool + Send + Sync>, impl Fn(&Pair<Pair<Pair<Pair<Leaf<'_, A>, Leaf<'_, B>>, Leaf<'_, C>>, Leaf<'_, D>>, Leaf<'_, E>>) -> GK + Send + Sync, TupleCollector<Co, V, R, Acc>, GK, V, R, Acc, Sc>where
GK: Eq + Hash + Clone + Send + Sync + 'static,
GF: Fn(&A, &B, &C, &D, &E) -> GK + Send + Sync + 'static,
Co: for<'i> Collector<(&'i A, &'i B, &'i C, &'i D, &'i E), Value = V, Result = R, Accumulator = Acc> + 'static,
V: Send + Sync + 'static,
R: Send + Sync + 'static,
Acc: Accumulator<V, R> + 'static,
Groups joined tuples by a key and an owned-value collector. Upstream filters remain binding on full and incremental evaluation.