Struct mz_compute_client::plan::top_k::MonotonicTop1Plan

pub struct MonotonicTop1Plan {
    pub group_key: Vec<usize>,
    pub order_key: Vec<ColumnOrder>,
    pub must_consolidate: bool,
}

A plan for monotonic TopKs with an offset of 0 and a limit of 1.

If the input to a TopK is monotonic (aka append-only aka no retractions) then we don’t have to worry about keeping every row we’ve seen around forever. Instead, the reduce can incrementally compute a new answer by looking at just the old TopK for a key and the incremental data.

This optimization generalizes to any TopK over a monotonic source, but we special case only TopK with offset=0 and limit=1 (aka Top1) for now. This is because (1) Top1 can merge in each incremental row in constant space and time while the generalized solution needs something like a priority queue and (2) we expect Top1 will be a common pattern used to turn a Kafka source’s “upsert” semantics into differential’s semantics. (2) is especially interesting because Kafka is monotonic with an ENVELOPE of NONE, which is the default for ENVELOPE in Materialize and commonly used by users.

Fields

group_key: Vec<usize>

The columns that form the key for each group.

order_key: Vec<ColumnOrder>

Ordering that is used within each group.

must_consolidate: bool

True if the input is logically but not physically monotonic, and the operator must first consolidate the inputs to remove potential negations.

Trait Implementations

impl Arbitrary for MonotonicTop1Plan

type Parameters = (<Vec<usize, Global> as Arbitrary>::Parameters, <Vec<ColumnOrder, Global> as Arbitrary>::Parameters, <bool as Arbitrary>::Parameters)

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<(<Vec<usize, Global> as Arbitrary>::Strategy, <Vec<ColumnOrder, Global> as Arbitrary>::Strategy, <bool as Arbitrary>::Strategy), fn(_: (Vec<usize, Global>, Vec<ColumnOrder, Global>, bool)) -> MonotonicTop1Plan>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for MonotonicTop1Plan

fn clone(&self) -> MonotonicTop1Plan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MonotonicTop1Plan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MonotonicTop1Plan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<MonotonicTop1Plan> for MonotonicTop1Plan

fn eq(&self, other: &MonotonicTop1Plan) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RustType<ProtoMonotonicTop1Plan> for MonotonicTop1Plan

fn into_proto(&self) -> ProtoMonotonicTop1Plan

Convert a Self into a Proto value.

fn from_proto(proto: ProtoMonotonicTop1Plan) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

impl Serialize for MonotonicTop1Plan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MonotonicTop1Plan

impl StructuralEq for MonotonicTop1Plan

impl StructuralPartialEq for MonotonicTop1Plan