Enum PlanNodeKind 

pub enum PlanNodeKind {
    InputMeasure(MeasureId),
    Literal(Value),
    MapUnary(UnaryOp, Box<PlanNode>),
    MapBinary(BinaryOp, Box<PlanNode>, Box<PlanNode>),
    Join {
        left: Box<PlanNode>,
        right: Box<PlanNode>,
        join_keys: Vec<CategoryId>,
    },
    Aggregate {
        inputs: Vec<PlanNode>,
        params: Vec<PlanNode>,
        pred: Option<Box<PlanNode>>,
        group_by: Vec<CategoryId>,
        func: FuncId,
        order: Vec<(CategoryId, Vec<ItemId>)>,
        window: Option<Window>,
        per_item: bool,
        into: Vec<(CategoryId, Vec<ItemId>)>,
    },
    Items(CategoryId, Vec<(ItemId, Value)>),
    Recurrence {
        body: Expr,
        refs: Vec<(MeasureId, PlanNode)>,
        slots: Vec<(MeasureId, i64, Option<Expr>)>,
        cat: CategoryId,
        order: Vec<ItemId>,
    },
    Coalesce {
        args: Vec<PlanNode>,
        grid: Option<Vec<(CategoryId, Vec<ItemId>)>>,
    },
    Remap {
        input: Box<PlanNode>,
        maps: Remaps,
    },
    Shift {
        input: Box<PlanNode>,
        cat: CategoryId,
        offset: i64,
        order: Vec<ItemId>,
        default: Option<Box<PlanNode>>,
    },
    FuncCall {
        func: FuncId,
        args: Vec<PlanNode>,
    },
    Fixpoint {
        init: Expr,
        body: Expr,
        max_iter: u32,
        tolerance: f64,
    },
    If {
        test: Box<PlanNode>,
        then: Box<PlanNode>,
        otherwise: Option<Box<PlanNode>>,
        spanning: Option<u8>,
    },
}

Variants

InputMeasure(MeasureId)

The base collection for an input measure.

Literal(Value)

A constant, broadcast over the target dimension.

MapUnary(UnaryOp, Box<PlanNode>)

MapBinary(BinaryOp, Box<PlanNode>, Box<PlanNode>)

Element-wise binary op. Operands are assumed dimension-aligned (the compiler inserts Join nodes to align them first).

Join

Align two collections on shared categories (broadcast the smaller over the larger). Result dimension is the union.

Fields

left: Box<PlanNode>

right: Box<PlanNode>

join_keys: Vec<CategoryId>

Categories both sides are joined on.

Aggregate

Reduce inputs (aligned on their full coordinate; pred filters them) down to group_by. params broadcast one value per group. Rows reach the reduction in item order along order (the reduced categories). With a window (one category, kept), one result per item, each over its window; a [improv_core_model::functions::Kind::PerItem] function also keeps the category.

Fields

inputs: Vec<PlanNode>

params: Vec<PlanNode>

pred: Option<Box<PlanNode>>

group_by: Vec<CategoryId>

func: FuncId

order: Vec<(CategoryId, Vec<ItemId>)>

window: Option<Window>

per_item: bool

into: Vec<(CategoryId, Vec<ItemId>)>

An array function’s landing categories and their items: results fill them row-major (the last category varies fastest); results past the last cell are dropped. Empty: not a list.

Items(CategoryId, Vec<(ItemId, Value)>)

A static per-item collection of a category: one cell per item.

Recurrence

A recurrence along cat: per group of the other categories, items in order, each cell is body evaluated (by the scalar evaluator) with refs at its coordinate and each slot’s placeholder bound to this measure’s own value back items earlier (or the slot’s default).

Fields

body: Expr

refs: Vec<(MeasureId, PlanNode)>

slots: Vec<(MeasureId, i64, Option<Expr>)>

cat: CategoryId

order: Vec<ItemId>

Coalesce

An outer union: at each coordinate of the domain, the first of args with a cell there. The domain is every item combination of grid (FILL), else the cells of the arguments whose dimension is the result’s. An argument over fewer categories broadcasts onto the domain; it never adds coordinates of its own.

Fields

args: Vec<PlanNode>

grid: Option<Vec<(CategoryId, Vec<ItemId>)>>

Remap

input with its categories renamed (RELABEL, SWAP): per (from, to, items), a cell’s from item becomes to’s item it maps to; a cell whose item has no mapping is dropped. The maps apply at once, so two maps exchange two categories.

Fields

input: Box<PlanNode>

maps: Remaps

Shift

input moved offset items along cat (in order); where no cell lands, default (when given) at the input’s own coordinates.

Fields

input: Box<PlanNode>

cat: CategoryId

offset: i64

order: Vec<ItemId>

default: Option<Box<PlanNode>>

FuncCall

A (non-aggregating) function call over its argument plans.

Fields

func: FuncId

args: Vec<PlanNode>

Fixpoint

FIXPOINT(init, LAMBDA(r, body), max_iter, tolerance), a measure’s whole formula: init and body as written (the body reads r as functions::lambda_slot(0, 0)). Not a dataflow operator: the engine (session::Engine) solves it host-side, round by round.

Fields

init: Expr

body: Expr

max_iter: u32

tolerance: f64

If

IF(test, then, [otherwise]), evaluated lazily: a cell where the test is true and then has one, where it is false and otherwise has one, and the test’s error where it is an error. spanning names the branch (0 then, 1 otherwise) whose coordinates extend the test to the result’s categories; None when the test already spans them.

Fields

test: Box<PlanNode>

then: Box<PlanNode>

otherwise: Option<Box<PlanNode>>

spanning: Option<u8>

Trait Implementations

impl Clone for PlanNodeKind

fn clone(&self) -> PlanNodeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanNodeKind

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

Formats the value using the given formatter.

impl PartialEq for PlanNodeKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PlanNodeKind