Struct KGroupedStream 

pub struct KGroupedStream<K, V> { /* private fields */ }

Handle produced by groupByKey and groupBy. A terminal aggregation consumes it.

Implementations

impl<K, V> KGroupedStream<K, V>

where K: Any + Send + Sync + Clone, V: Any + Send + Clone,

pub fn count_explicit<KS, VS>( self, materialized: impl Into<Materialized<KS, VS>>, ) -> KTable<K, i64, KS, VS>

where KS: Serde<K> + Clone + 'static, VS: Serde<i64> + Clone + 'static,

count: count records per key into a materialized KTable<K, i64>.

init = || 0, agg = |_k, _v, acc| acc + 1.

pub fn reduce_explicit<KS, VS, R>( self, reducer: R, materialized: impl Into<Materialized<KS, VS>>, ) -> KTable<K, V, KS, VS>

where KS: Serde<K> + Clone + 'static, VS: Serde<V> + Clone + 'static, R: Fn(&V, &V) -> V + Clone + Send + Sync + 'static,

reduce: combine values per key with reducer.

The result is materialized as KTable<K, V>. The first value for a key seeds the accumulator, because the JVM Reducer has no separate init. Later values fold with reducer(&acc, &value). The backing processor keeps the public value type V, so no Option and no sentinel leaks into the KTable.

pub fn aggregate_explicit<KS, VS, VA, I, A>( self, init: I, agg: A, materialized: impl Into<Materialized<KS, VS>>, ) -> KTable<K, VA, KS, VS>

where VA: Any + Send + Clone, KS: Serde<K> + Clone + 'static, VS: Serde<VA> + Clone + 'static, I: Fn() -> VA + Clone + Send + Sync + 'static, A: Fn(&K, &V, VA) -> VA + Clone + Send + Sync + 'static,

aggregate: general aggregation with a caller-supplied init and agg.

The result is materialized as KTable<K, VA>.

pub fn count( self, store_name: impl Into<String>, ) -> KTable<K, i64, <K as DefaultSerde>::Serde, I64Serde>

where K: DefaultSerde, <K as DefaultSerde>::Serde: Serde<K> + Clone,

pub fn reduce<R>( self, reducer: R, store_name: impl Into<String>, ) -> KTable<K, V, <K as DefaultSerde>::Serde, <V as DefaultSerde>::Serde>

where K: DefaultSerde, V: DefaultSerde, <K as DefaultSerde>::Serde: Serde<K> + Clone, <V as DefaultSerde>::Serde: Serde<V> + Clone, R: Fn(&V, &V) -> V + Clone + Send + Sync + 'static,

pub fn aggregate<VA, I, A>( self, init: I, agg: A, store_name: impl Into<String>, ) -> KTable<K, VA, <K as DefaultSerde>::Serde, <VA as DefaultSerde>::Serde>

where VA: DefaultSerde + Any + Send + Clone, K: DefaultSerde, <K as DefaultSerde>::Serde: Serde<K> + Clone, <VA as DefaultSerde>::Serde: Serde<VA> + Clone, I: Fn() -> VA + Clone + Send + Sync + 'static, A: Fn(&K, &V, VA) -> VA + Clone + Send + Sync + 'static,

pub fn windowed_by( self, windows: TimeWindows, ) -> TimeWindowedKGroupedStream<K, V>

windowedBy(TimeWindows): switch to a windowed aggregation.

This method moves the grouped lineage into a crate::dsl::TimeWindowedKGroupedStream. The lineage is the parent, the key-changing flag, and the repartition thunk. That handle exposes the windowed count, reduce, and aggregate, which produce a KTable<Windowed<K>, _>.

pub fn windowed_by_session( self, windows: SessionWindows, ) -> SessionWindowedKGroupedStream<K, V>

where V: Sync,

windowedBy(SessionWindows): switch to a session aggregation.

This method moves the grouped lineage into a crate::dsl::SessionWindowedKGroupedStream. That handle exposes the session count, reduce, and aggregate, which produce a KTable<Windowed<K>, _>. The method name is distinct, because Rust cannot overload windowed_by by the window-spec argument type as the JVM does.

pub fn windowed_by_sliding( self, windows: SlidingWindows, ) -> SlidingWindowedKGroupedStream<K, V>

where V: Sync,

windowedBy(SlidingWindows): switch to a sliding-window aggregation (KIP-450).

This method moves the grouped lineage into a crate::dsl::SlidingWindowedKGroupedStream. The method name is distinct, because Rust cannot overload windowed_by by the window-spec argument type as the JVM does.

pub fn cogroup<VOut, A>(self, agg: A) -> CogroupedKStream<K, VOut>

where V: Sync, VOut: Any + Send + Sync + Clone, A: Fn(&K, &V, VOut) -> VOut + Send + Sync + 'static,

cogroup: begin a KIP-150 cogroup with this stream as the first input.

agg is this input’s aggregator. Returns a CogroupedKStream<K, VOut>. Chain more inputs onto it, then terminate with aggregate or one of the windowed_by* methods.