Enum QueryPlan 

pub enum QueryPlan {
    Scan {
        measurement: String,
        tag_filters: Vec<TagFilter>,
        projection: Vec<String>,
        time_range: TimeRange,
        field_predicates: Vec<FieldPredicate>,
        namespace_id: Option<String>,
    },
    Aggregate {
        source: Box<QueryPlan>,
        functions: Vec<AggFn>,
        group_by: Vec<String>,
        estimated_cardinality: Option<usize>,
    },
    Downsample {
        source: Box<QueryPlan>,
        interval: Duration,
        function: AggFn,
    },
    Limit {
        source: Box<QueryPlan>,
        limit: usize,
        offset: usize,
    },
    Window {
        source: Box<QueryPlan>,
        functions: Vec<WindowFn>,
        partition_by: Vec<String>,
        value_column: String,
    },
}

A logical query plan.

Describes what data to read and how to process it, without specifying the physical execution strategy.

Variants

Scan

Scan a measurement with optional filters and projection.

Fields

measurement: String

Measurement name to query.

tag_filters: Vec<TagFilter>

Tag equality filters.

projection: Vec<String>

Columns to return (empty = all fields).

time_range: TimeRange

Time range filter.

field_predicates: Vec<FieldPredicate>

Zone-map field predicates for late-materialisation row-group pruning. Each predicate compares a numeric column against a threshold; row groups whose per-block min/max stats rule out any match are skipped entirely.

namespace_id: Option<String>

Structural namespace scope.

When set, the query engine can validate that every scanned segment belongs to this namespace — providing defense-in-depth even if the tag filter injection is bypassed.

Aggregate

Aggregate results from a scan.

Fields

source: Box<QueryPlan>

The underlying scan plan.

functions: Vec<AggFn>

Aggregation functions to apply.

group_by: Vec<String>

Columns to group by.

estimated_cardinality: Option<usize>

Estimated group-key cardinality from segment column statistics. When available, the engine chooses hash aggregation for high cardinality and sort-based grouping for low cardinality. None means unknown (hash is the default).

Downsample

Downsample results into time buckets.

Fixed-width buckets only. A Duration is a span of nanoseconds, so this cannot express a calendar bucket — a day in a time zone is 23 or 25 hours across a transition, and a month is not a span at all. The type says so rather than pretending: the two surfaces that do offer calendar buckets are time_bucket() in SQL and a rollup tier, and both go through chronix::timebucket::TimeBucket. Threading that through here would put the tz database inside the query engine for a surface nobody has asked it of.

Fields

source: Box<QueryPlan>

The underlying scan plan.

interval: Duration

Bucket interval — a fixed span, aligned to the Unix epoch in UTC.

function: AggFn

Aggregation function per bucket.

Limit

Limit the number of returned rows, optionally skipping some.

Fields

source: Box<QueryPlan>

The underlying plan.

limit: usize

Maximum number of rows to return.

offset: usize

Number of rows to skip before returning.

Window

Apply window functions that produce one output row per input row.

Fields

source: Box<QueryPlan>

The underlying plan.

functions: Vec<WindowFn>

Window functions to compute.

partition_by: Vec<String>

Columns to partition by (each partition is independent).

value_column: String

The value column to apply window functions to.

Trait Implementations

impl Clone for QueryPlan

fn clone(&self) -> QueryPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryPlan

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

Formats the value using the given formatter.