Struct ColumnSpecs

pub struct ColumnSpecs<'a> {
    pub relation: &'a RelationType,
    pub columns: Vec<ResultSpec<'a>>,
    pub unmaterializables: BTreeMap<UnmaterializableFunc, ResultSpec<'a>>,
    pub arena: &'a RowArena,
}

An interpreter that:

• stores both the type and the range of possible values for every column and unmaterializable function. (See the push_ methods.)
• given an expression (or MFP, etc.), returns the range of possible results that evaluating that expression might have. (See the eval_ methods.)

Fields

relation: &'a RelationType

columns: Vec<ResultSpec<'a>>

unmaterializables: BTreeMap<UnmaterializableFunc, ResultSpec<'a>>

arena: &'a RowArena

Implementations

impl<'a> ColumnSpecs<'a>

const MAX_EVAL_ARGS: usize = 6usize

pub fn new(relation: &'a RelationType, arena: &'a RowArena) -> Self

Create a new, empty set of column specs. (Initially, the only assumption we make about the data in the column is that it matches the type.)

pub fn push_column(&mut self, id: usize, update: ResultSpec<'a>)

Restrict the set of possible values in a given column. (By intersecting it with the existing spec.)

pub fn push_unmaterializable( &mut self, func: UnmaterializableFunc, update: ResultSpec<'a>, )

Restrict the set of possible values a given unmaterializable func might return. (By intersecting it with the existing spec.)

fn eval_result<'b, E>(&self, result: Result<Datum<'b>, E>) -> ResultSpec<'a>

fn set_literal(expr: &mut MirScalarExpr, update: Result<Datum<'_>, EvalError>)

fn set_argument( expr: &mut MirScalarExpr, arg: usize, value: Result<Datum<'_>, EvalError>, )

fn placeholder(col_type: ColumnType) -> MirScalarExpr

A literal with the given type and a trivial default value. Callers should ensure that Self::set_literal is called on the resulting expression to give it a meaningful value before evaluating.

Trait Implementations

impl<'a> Clone for ColumnSpecs<'a>

fn clone(&self) -> ColumnSpecs<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ColumnSpecs<'a>

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

Formats the value using the given formatter.

impl<'a> Interpreter for ColumnSpecs<'a>

type Summary = ColumnSpec<'a>

fn column(&self, id: usize) -> Self::Summary

A column of the input row.

fn literal( &self, result: &Result<Row, EvalError>, col_type: &ColumnType, ) -> Self::Summary

A literal value. (Stored as a row, because we can’t own a Datum.)

fn unmaterializable(&self, func: &UnmaterializableFunc) -> Self::Summary

A call to an unmaterializable function.

fn unary(&self, func: &UnaryFunc, summary: Self::Summary) -> Self::Summary

A function call that takes one expression as an argument.

fn binary( &self, func: &BinaryFunc, left: Self::Summary, right: Self::Summary, ) -> Self::Summary

A function call that takes two expressions as arguments.

fn variadic( &self, func: &VariadicFunc, args: Vec<Self::Summary>, ) -> Self::Summary

A function call that takes an arbitrary number of arguments.

fn cond( &self, cond: Self::Summary, then: Self::Summary, els: Self::Summary, ) -> Self::Summary

Conditionally evaluated expressions.

fn expr(&self, expr: &MirScalarExpr) -> Self::Summary

Evaluate an entire expression, by delegating to the fine-grained methods on Interpreter.

fn mfp_filter(&self, mfp: &MapFilterProject) -> Self::Summary

Specifically, this evaluates the map and filters stages of an MFP: summarize each of the map expressions, then and together all of the filters.

fn mfp_plan_filter(&self, plan: &MfpPlan) -> Self::Summary

Similar to Self::mfp_filter, but includes the additional temporal filters that have been broken out.