pub trait JoinTarget<S, A, E, F, Sc: Score> {
type Output;
// Required method
fn apply(self, extractor_a: E, filter_a: F) -> Self::Output;
}Expand description
Trait for single .join() dispatch.
E is the extractor type of the left stream.
F is the filter type of the left stream.
Implementors consume self and receive the left stream’s extractor and filter,
producing the appropriate cross-stream type.
Required Associated Types§
Required Methods§
Dyn Compatibility§
This trait is dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".
Implementations on Foreign Types§
Source§impl<S, A, B, E, F, EB, FB, P, Sc> JoinTarget<S, A, E, F, Sc> for (UniConstraintStream<S, B, EB, FB, Sc>, P)
Predicate cross-join: .join((other_stream, |a, b| predicate)) — an
explicit opposite-input scan under the exact predicate. The relationship
compiles to FilteringJoiner, so no synthetic constant equality key is
ever built for a non-indexable condition.
impl<S, A, B, E, F, EB, FB, P, Sc> JoinTarget<S, A, E, F, Sc> for (UniConstraintStream<S, B, EB, FB, Sc>, P)
Predicate cross-join: .join((other_stream, |a, b| predicate)) — an
explicit opposite-input scan under the exact predicate. The relationship
compiles to FilteringJoiner, so no synthetic constant equality key is
ever built for a non-indexable condition.
Source§impl<S, A, B, E, F, EB, J1, J2, Sc> JoinTarget<S, A, E, F, Sc> for (EB, AndJoiner<J1, J2>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
J1: ToViewPlan<A, B> + 'static,
J2: ToViewPlan<A, B> + 'static,
AndJoiner<J1::ViewPlan, J2::ViewPlan>: CompileCondition<Plan: IndexedPlan> + 'static,
for<'a> <AndJoiner<J1::ViewPlan, J2::ViewPlan> as CompileCondition>::Plan: ExecutablePlan<Leaf<'a, A>, Leaf<'a, B>>,
Sc: Score + 'static,
Composed conjunction: each operand converts to its view plan, then the two
compose into one concrete AndJoiner plan. No dynamic condition list.
impl<S, A, B, E, F, EB, J1, J2, Sc> JoinTarget<S, A, E, F, Sc> for (EB, AndJoiner<J1, J2>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
J1: ToViewPlan<A, B> + 'static,
J2: ToViewPlan<A, B> + 'static,
AndJoiner<J1::ViewPlan, J2::ViewPlan>: CompileCondition<Plan: IndexedPlan> + 'static,
for<'a> <AndJoiner<J1::ViewPlan, J2::ViewPlan> as CompileCondition>::Plan: ExecutablePlan<Leaf<'a, A>, Leaf<'a, B>>,
Sc: Score + 'static,
Composed conjunction: each operand converts to its view plan, then the two
compose into one concrete AndJoiner plan. No dynamic condition list.
type Output = Bi<S, A, B, <AndJoiner<<J1 as ToViewPlan<A, B>>::ViewPlan, <J2 as ToViewPlan<A, B>>::ViewPlan> as CompileCondition>::Plan, E, EB, UniLeftBiFilter<F, B>, Sc>
fn apply(self, extractor_a: E, filter_a: F) -> Self::Output
Source§impl<S, A, B, E, F, EB, K, KA, KB, Mode, Sc> JoinTarget<S, A, E, F, Sc> for (EB, EqualJoiner<KA, KB, K, Mode>)
Keyed cross-join: .join((extractor_b, equal_bi(ka, kb))) — pairs two collections by key.
impl<S, A, B, E, F, EB, K, KA, KB, Mode, Sc> JoinTarget<S, A, E, F, Sc> for (EB, EqualJoiner<KA, KB, K, Mode>)
Keyed cross-join: .join((extractor_b, equal_bi(ka, kb))) — pairs two collections by key.
Source§impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, GreaterThanJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, GreaterThanJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
Source§impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, GreaterThanOrEqualJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, GreaterThanOrEqualJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
Source§impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, LessThanJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, LessThanJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
Source§impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, LessThanOrEqualJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, LessThanOrEqualJoiner<KA, KB, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
KA: Fn(&A) -> K + Send + Sync + 'static,
KB: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
Source§impl<S, A, B, E, F, EB, K, SA, EA, SB, EBd, Sc> JoinTarget<S, A, E, F, Sc> for (EB, OverlappingJoiner<SA, EA, SB, EBd, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
SA: Fn(&A) -> K + Send + Sync + 'static,
EA: Fn(&A) -> K + Send + Sync + 'static,
SB: Fn(&B) -> K + Send + Sync + 'static,
EBd: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
Interval overlap over entity-authored bounds, executed over leaf views.
impl<S, A, B, E, F, EB, K, SA, EA, SB, EBd, Sc> JoinTarget<S, A, E, F, Sc> for (EB, OverlappingJoiner<SA, EA, SB, EBd, K>)where
S: Send + Sync + 'static,
A: Send + Sync + 'static,
B: Send + Sync + 'static,
E: CollectionExtract<S, Item = A>,
F: UniFilter<S, A>,
EB: CollectionExtract<S, Item = B>,
K: Ord + Clone + Send + Sync + 'static,
SA: Fn(&A) -> K + Send + Sync + 'static,
EA: Fn(&A) -> K + Send + Sync + 'static,
SB: Fn(&B) -> K + Send + Sync + 'static,
EBd: Fn(&B) -> K + Send + Sync + 'static,
Sc: Score + 'static,
Interval overlap over entity-authored bounds, executed over leaf views.
Implementors§
Source§impl<S, A, E, F, K, KA, Sc> JoinTarget<S, A, E, F, Sc> for EqualJoiner<KA, KA, K, Symmetric>
Self-join: .join(equal(|a: &A| a.key)) — pairs same-collection entities.
impl<S, A, E, F, K, KA, Sc> JoinTarget<S, A, E, F, Sc> for EqualJoiner<KA, KA, K, Symmetric>
Self-join: .join(equal(|a: &A| a.key)) — pairs same-collection entities.