Struct ConstEvaluator 

struct ConstEvaluator<'a> {
    can_evaluate: Vec<bool>,
    execution_props: &'a ExecutionProps,
    input_schema: DFSchema,
    input_batch: RecordBatch,
}

Partially evaluate Exprs so constant subtrees are evaluated at plan time.

Note it does not handle algebraic rewrites such as (a or false) –> a, which is handled by Simplifier

Fields

can_evaluate: Vec<bool>

can_evaluate is used during the depth-first-search of the Expr tree to track if any siblings (or their descendants) were non evaluatable (e.g. had a column reference or volatile function)

Specifically, can_evaluate[N] represents the state of traversal when we are N levels deep in the tree, one entry for this Expr and each of its parents.

After visiting all siblings if can_evaluate.top() is true, that means there were no non evaluatable siblings (or their descendants) so this Expr can be evaluated

execution_props: &'a ExecutionProps

input_schema: DFSchema

input_batch: RecordBatch

Implementations

impl<'a> ConstEvaluator<'a>

pub fn try_new(execution_props: &'a ExecutionProps) -> Result<Self>

Create a new ConstantEvaluator. Session constants (such as the time for now() are taken from the passed execution_props.

fn volatility_ok(volatility: Volatility) -> bool

Can a function of the specified volatility be evaluated?

fn can_evaluate(expr: &Expr) -> bool

Can the expression be evaluated at plan time, (assuming all of its children can also be evaluated)?

pub(crate) fn evaluate_to_scalar(&mut self, expr: Expr) -> ConstSimplifyResult

Internal helper to evaluates an Expr

Trait Implementations

impl TreeNodeRewriter for ConstEvaluator<'_>

type Node = Expr

The node type which is rewritable.

fn f_down(&mut self, expr: Expr) -> Result<Transformed<Expr>>

Invoked while traversing down the tree before any children are rewritten. Default implementation returns the node as is and continues recursion.

fn f_up(&mut self, expr: Expr) -> Result<Transformed<Expr>>

Invoked while traversing up the tree after all children have been rewritten. Default implementation returns the node as is and continues recursion.