Enum QueryOp 

pub enum QueryOp {
    Aggregate {
        collection: String,
        group_by: Vec<String>,
        aggregates: Vec<AggregateSpec>,
        filters: Vec<u8>,
        having: Vec<u8>,
        limit: usize,
        sub_group_by: Vec<String>,
        sub_aggregates: Vec<AggregateSpec>,
        grouping_sets: Vec<Vec<u32>>,
        sort_keys: Vec<(String, bool)>,
    },
    PartialAggregate {
        collection: String,
        group_by: Vec<String>,
        aggregates: Vec<AggregateSpec>,
        filters: Vec<u8>,
    },
    HashJoin {

        left_collection: String,
        right_collection: String,
        left_alias: Option<String>,
        right_alias: Option<String>,
        on: Vec<(String, String)>,
        join_type: String,
        limit: usize,
        post_group_by: Vec<String>,
        post_aggregates: Vec<(String, String)>,
        projection: Vec<JoinProjection>,
        post_filters: Vec<u8>,
        inline_left: Option<Box<PhysicalPlan>>,
        inline_right: Option<Box<PhysicalPlan>>,
        inline_left_bitmap: Option<Box<PhysicalPlan>>,
        inline_right_bitmap: Option<Box<PhysicalPlan>>,
    
},
    InlineHashJoin {
        left_data: Vec<u8>,
        right_data: Vec<u8>,
        right_alias: Option<String>,
        on: Vec<(String, String)>,
        join_type: String,
        limit: usize,
        projection: Vec<JoinProjection>,
        post_filters: Vec<u8>,
    },
    BroadcastJoin {
        large_collection: String,
        small_collection: String,
        large_alias: Option<String>,
        small_alias: Option<String>,
        broadcast_data: Vec<u8>,
        on: Vec<(String, String)>,
        join_type: String,
        limit: usize,
        post_group_by: Vec<String>,
        post_aggregates: Vec<(String, String)>,
        projection: Vec<JoinProjection>,
        post_filters: Vec<u8>,
    },
    ShuffleJoin {
        left_collection: String,
        right_collection: String,
        on: Vec<(String, String)>,
        join_type: String,
        limit: usize,
        target_core: usize,
    },
    NestedLoopJoin {
        left_collection: String,
        right_collection: String,
        condition: Vec<u8>,
        join_type: String,
        limit: usize,
    },
    SortMergeJoin {
        left_collection: String,
        right_collection: String,
        on: Vec<(String, String)>,
        join_type: String,
        limit: usize,
        pre_sorted: bool,
    },
    FacetCounts {
        collection: String,
        filters: Vec<u8>,
        fields: Vec<String>,
        limit_per_facet: usize,
    },
    RecursiveScan {
        collection: String,
        base_filters: Vec<u8>,
        recursive_filters: Vec<u8>,
        join_link: Option<(String, String)>,
        max_iterations: usize,
        distinct: bool,
        limit: usize,
    },
    RecursiveValue {
        cte_name: String,
        columns: Vec<String>,
        init_exprs: Vec<String>,
        step_exprs: Vec<String>,
        condition: Option<String>,
        max_depth: usize,
        distinct: bool,
    },
    LateralTopK {
        outer_plan: Box<PhysicalPlan>,
        outer_alias: String,
        inner_collection: String,
        inner_filters: Vec<u8>,
        inner_order_by: Vec<(String, bool)>,
        inner_limit: usize,
        correlation_keys: Vec<(String, String)>,
        lateral_alias: String,
        projection: Vec<JoinProjection>,
        left_join: bool,
    },
    LateralLoop {
        outer_plan: Box<PhysicalPlan>,
        outer_alias: String,
        inner_collection: String,
        inner_filters: Vec<u8>,
        correlation_predicates: Vec<(String, String)>,
        lateral_alias: String,
        projection: Vec<JoinProjection>,
        left_join: bool,
        outer_row_cap: usize,
    },
}

Query-level physical operations (joins, aggregates).

Variants

Aggregate

Aggregate: GROUP BY + aggregate functions.

Fields

collection: String

group_by: Vec<String>

aggregates: Vec<AggregateSpec>

filters: Vec<u8>

having: Vec<u8>

HAVING predicates applied post-aggregation.

limit: usize

sub_group_by: Vec<String>

sub_aggregates: Vec<AggregateSpec>

grouping_sets: Vec<Vec<u32>>

ROLLUP / CUBE / GROUPING SETS expansion. Each inner Vec<u32> is one grouping set — the indices into group_by that are present (non-NULL) for rows in that set. Empty outer vec = plain single-set GROUP BY (no null-filling needed).

sort_keys: Vec<(String, bool)>

Post-aggregation sort keys: (column_name, ascending). Empty = preserve executor’s natural order (hash-map iteration for plain GROUP BY). The executor applies the sort after all groups are finalized and HAVING is filtered.

PartialAggregate

Partial aggregate: each core computes locally, Control Plane merges.

Fields

collection: String

group_by: Vec<String>

aggregates: Vec<AggregateSpec>

filters: Vec<u8>

HashJoin

Hash join: build hash map on right, probe with left.

Fields

left_collection: String

right_collection: String

left_alias: Option<String>

right_alias: Option<String>

on: Vec<(String, String)>

join_type: String

limit: usize

post_group_by: Vec<String>

Post-join GROUP BY columns (empty = no aggregation).

post_aggregates: Vec<(String, String)>

Post-join aggregates: (op, field) pairs (empty = no aggregation).

projection: Vec<JoinProjection>

Post-join projection: column names to keep (empty = all).

post_filters: Vec<u8>

Post-join WHERE filter predicates (MessagePack).

inline_left: Option<Box<PhysicalPlan>>

Inline left sub-plan for multi-way joins. When set, the executor runs this sub-plan first and uses its result as the left side instead of scanning left_collection.

inline_right: Option<Box<PhysicalPlan>>

Inline right sub-plan for scalar subqueries or other materialized small-side inputs. The Control Plane executes this plan first, merges it if needed, then embeds the result into BroadcastJoin.

inline_left_bitmap: Option<Box<PhysicalPlan>>

Bitmap-producer sub-plan for the left side. When set, the executor executes this plan first, collects surrogates from all returned rows, and injects the resulting bitmap into the probe-side prefilter before scanning. None = no bitmap pushdown for the left side.

inline_right_bitmap: Option<Box<PhysicalPlan>>

Bitmap-producer sub-plan for the right side. Same semantics as inline_left_bitmap but applied to the right (probe) collection.

InlineHashJoin

Inline hash join: both sides are pre-gathered msgpack data. Used for multi-way joins where the left side is the result of another join.

Fields

left_data: Vec<u8>

Left side: msgpack array of maps (from inner join result).

right_data: Vec<u8>

Right side: raw broadcast scan data.

right_alias: Option<String>

on: Vec<(String, String)>

join_type: String

limit: usize

projection: Vec<JoinProjection>

post_filters: Vec<u8>

BroadcastJoin

Broadcast join: small side serialized in the plan.

Fields

large_collection: String

small_collection: String

large_alias: Option<String>

small_alias: Option<String>

broadcast_data: Vec<u8>

on: Vec<(String, String)>

join_type: String

limit: usize

post_group_by: Vec<String>

Post-join GROUP BY columns (empty = no aggregation).

post_aggregates: Vec<(String, String)>

Post-join aggregates: (op, field) pairs (empty = no aggregation).

projection: Vec<JoinProjection>

Post-join projection: column names to keep (empty = all).

post_filters: Vec<u8>

Post-join WHERE filter predicates (MessagePack).

ShuffleJoin

Shuffle join: repartition by join key via SPSC.

Fields

left_collection: String

right_collection: String

on: Vec<(String, String)>

join_type: String

limit: usize

target_core: usize

NestedLoopJoin

Nested loop join: fallback for non-equi joins.

Fields

left_collection: String

right_collection: String

condition: Vec<u8>

Join condition as serialized Vec<ScanFilter>.

join_type: String

limit: usize

SortMergeJoin

Sort-merge join: both sides pre-sorted by join key. Optimal when both collections have index-ordered scans or when the planner sorts both sides before joining.

Fields

left_collection: String

right_collection: String

on: Vec<(String, String)>

join_type: String

limit: usize

pre_sorted: bool

If true, both sides are assumed pre-sorted by join key (skip sort phase).

FacetCounts

Multi-facet aggregation: compute facet counts for multiple fields in a single query, sharing the filter evaluation across all facets.

Fields

collection: String

filters: Vec<u8>

Serialized Vec<ScanFilter> predicates (MessagePack).

fields: Vec<String>

Field names to facet on (each produces a [{value, count}] array).

limit_per_facet: usize

Maximum number of values to return per facet field (0 = unlimited).

RecursiveScan

Recursive CTE: iterative fixed-point execution.

Executes the base query once, then repeatedly executes the recursive query using the previous iteration’s results as the working table, until no new rows are produced (fixed point).

Fields

collection: String

Collection for the recursive scan.

base_filters: Vec<u8>

Base query filters (seeded once).

recursive_filters: Vec<u8>

Recursive step filters (applied to working table each iteration).

join_link: Option<(String, String)>

Equi-join link for tree-traversal recursion: (collection_field, working_table_field). Each iteration finds rows where collection_field value matches a working_table_field value from the previous iteration.

max_iterations: usize

Maximum iterations to prevent infinite loops. Default: 100.

distinct: bool

Whether to deduplicate results (UNION vs UNION ALL).

limit: usize

RecursiveValue

Value-generating recursive CTE: iterative expression evaluation.

No collection is needed. The executor evaluates the anchor expressions once to produce the first row, then repeatedly applies the step expressions to the previous row until the condition becomes false, a fixed point is reached, or max_depth is exceeded (typed error).

Fields

cte_name: String

CTE name (used in error messages).

columns: Vec<String>

Column names (length == init_exprs.len() == step_exprs.len()).

init_exprs: Vec<String>

Anchor SELECT expressions as raw SQL text.

step_exprs: Vec<String>

Recursive step SELECT expressions as raw SQL text.

condition: Option<String>

Optional WHERE condition as raw SQL text.

max_depth: usize

Maximum iterations before returning a depth-exceeded error.

distinct: bool

Whether to deduplicate (UNION vs UNION ALL).

LateralTopK

LATERAL equi-correlated top-K: scan inner_collection once per outer row, applying the equi-correlation as an equality filter, then return the top inner_limit rows ordered by inner_order_by.

The executor first runs outer_plan to materialise outer rows, then for each outer row injects the equi-correlation as an equality filter on inner_collection, applies inner_order_by, and keeps the top inner_limit rows. Output rows are (outer_row merged with inner_row).

correlation_keys are (outer_col, inner_col) equi-join pairs.

Fields

outer_plan: Box<PhysicalPlan>

Sub-plan that produces the outer (driving) rows.

outer_alias: String

Alias qualifying the outer columns in output rows.

inner_collection: String

Inner collection to scan per outer row.

inner_filters: Vec<u8>

Non-correlated filters applied to every inner scan (msgpack bytes).

inner_order_by: Vec<(String, bool)>

Sort keys for the inner per-outer-row result. Each entry is (field_name, ascending).

inner_limit: usize

Maximum inner rows per outer row.

correlation_keys: Vec<(String, String)>

Equi-join pairs (outer_col, inner_col).

lateral_alias: String

Alias qualifying inner columns in output rows.

projection: Vec<JoinProjection>

Output projection (empty = all columns).

left_join: bool

LEFT join semantics: preserve outer rows when inner is empty.

LateralLoop

LATERAL nested-loop: for each outer row, re-execute the inner plan with correlated values injected as additional equality filters.

The executor runs outer_plan, then for each outer row reads the outer_col values from correlation_predicates, appends equality filters on the corresponding inner_col fields, and scans inner_collection.

Fields

outer_plan: Box<PhysicalPlan>

Sub-plan that produces the outer (driving) rows.

outer_alias: String

Alias qualifying the outer columns in output rows.

inner_collection: String

Inner collection to scan per outer row.

inner_filters: Vec<u8>

Base inner filters (non-correlated, msgpack bytes).

correlation_predicates: Vec<(String, String)>

Correlated predicates: (inner_field, outer_field).

lateral_alias: String

Alias qualifying inner columns in output rows.

projection: Vec<JoinProjection>

Output projection (empty = all columns).

left_join: bool

LEFT join semantics.

outer_row_cap: usize

Hard cap on outer rows. Queries that exceed this cap return a typed LateralCapExceeded error instead of silently truncating.

Trait Implementations

impl Clone for QueryOp

fn clone(&self) -> QueryOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QueryOp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'__msgpack_de> FromMessagePack<'__msgpack_de> for QueryOp

fn read<R: Read<'__msgpack_de>>(reader: &mut R) -> Result<Self, Error>

where Self: Sized,

Reads the MessagePack representation of this value from the provided reader.

impl PartialEq for QueryOp

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for QueryOp

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 QueryOp

impl ToMessagePack for QueryOp

fn write<W: Write>(&self, writer: &mut W) -> Result<(), Error>

Writes the MessagePack representation of this value into the provided writer.