Enum FragmentOperator 

pub enum FragmentOperator {
    TabletScan {
        table: String,
        predicate: Option<String>,
        projection: Vec<String>,
    },
    RemoteExchangeSource {
        exchange: ExchangeId,
    },
    RemoteExchangeSink {
        exchange: ExchangeId,
    },
    PartialAggregate {
        group_by: Vec<String>,
        aggregates: Vec<AggregateExpr>,
    },
    FinalAggregate {
        group_by: Vec<String>,
        aggregates: Vec<AggregateExpr>,
    },
    DistributedHashJoin {
        on: Vec<JoinKey>,
    },
    BroadcastJoin {
        on: Vec<JoinKey>,
        build_side: BuildSide,
    },
    RepartitionJoin {
        on: Vec<JoinKey>,
    },
    MergeSort {
        keys: Vec<SortKey>,
        limit: Option<usize>,
    },
    DistributedTopK {
        k: usize,
        score: SortKey,
    },
    DistributedLimit {
        limit: usize,
    },
}

One physical operator inside a fragment (spec section 12.10).

Variants

TabletScan

Scan one tablet’s slice of a table.

Fields

table: String

Table name.

predicate: Option<String>

Opaque pushed-down predicate text.

projection: Vec<String>

Projected columns; empty = all.

RemoteExchangeSource

Receive one exchange edge from a producer fragment.

Fields

exchange: ExchangeId

The exchange edge this source consumes.

RemoteExchangeSink

Emit this fragment’s output onto one exchange edge.

Fields

exchange: ExchangeId

The exchange edge this sink feeds.

PartialAggregate

Per-tablet partial aggregation (pre-shuffle combine).

Fields

group_by: Vec<String>

Group-by columns.

aggregates: Vec<AggregateExpr>

Aggregate expressions.

FinalAggregate

Coordinator-side combine of partial aggregates.

Fields

group_by: Vec<String>

Group-by columns.

aggregates: Vec<AggregateExpr>

Aggregate expressions.

DistributedHashJoin

Hash join over colocated inputs (no exchange needed).

Fields

on: Vec<JoinKey>

Equality key pairs.

BroadcastJoin

Join where the small build side is broadcast to every big-side fragment.

Fields

on: Vec<JoinKey>

Equality key pairs.

build_side: BuildSide

Which input is broadcast.

RepartitionJoin

Join after both sides are hash-repartitioned on the join keys.

Fields

on: Vec<JoinKey>

Equality key pairs.

MergeSort

Producer side: local bounded sort. Coordinator side: deterministic k-way merge of sorted streams.

Fields

keys: Vec<SortKey>

Sort keys.

limit: Option<usize>

Optional row limit applied after the sort/merge.

DistributedTopK

Producer side: bounded local top-k plus tie information. Coordinator side: deterministic merge (score desc, tablet asc, RowId asc) with adaptive refill (spec section 12.10).

Fields

k: usize

Number of winners.

score: SortKey

The (single, descending) score key.

DistributedLimit

Row limit (per-fragment locally; global at the coordinator).

Fields

limit: usize

Row limit.

Trait Implementations

impl Clone for FragmentOperator

fn clone(&self) -> FragmentOperator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FragmentOperator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FragmentOperator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FragmentOperator

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for FragmentOperator

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FragmentOperator