Struct expr::linear::plan::SafeMfpPlan

pub struct SafeMfpPlan {
    mfp: MapFilterProject,
}

A wrapper type which indicates it is safe to simply evaluate all expressions.

Fields

mfp: MapFilterProject

Implementations

impl SafeMfpPlan

pub fn permute(&mut self, map: HashMap<usize, usize>, new_arity: usize)

pub fn evaluate_into<'a>(
    &'a self,
    datums: &mut Vec<Datum<'a>>,
    arena: &'a RowArena,
    row: &'a mut Row
) -> Result<Option<Row>, EvalError>

Evaluates the linear operator on a supplied list of datums.

The arguments are the initial datums associated with the row, and an appropriately lifetimed arena for temporary allocations needed by scalar evaluation.

An Ok result will either be None if any predicate did not evaluate to Datum::True, or the values of the columns listed by self.projection if all predicates passed. If an error occurs in the evaluation it is returned as an Err variant. As the evaluation exits early with failed predicates, it may miss some errors that would occur later in evaluation.

The row is not cleared first, but emptied if the function returns `Ok(Some(row)).

pub fn evaluate_iter<'b, 'a: 'b>(
    &'a self,
    datums: &'b mut Vec<Datum<'a>>,
    arena: &'a RowArena
) -> Result<Option<impl Iterator<Item = Datum<'a>> + 'b>, EvalError>

A version of evaluate which produces an iterator over Datum as output.

This version can be useful when one wants to capture the resulting datums without packing and then unpacking a row.

pub fn evaluate_inner<'b, 'a: 'b>(
    &'a self,
    datums: &'b mut Vec<Datum<'a>>,
    arena: &'a RowArena
) -> Result<bool, EvalError>

Populates datums with self.expressions and tests self.predicates.

This does not apply self.projection, which is up to the calling method.

Methods from Deref<Target = MapFilterProject>

pub fn is_identity(&self) -> bool

True if the operator describes the identity transformation.

pub fn as_map_filter_project(
    &self
) -> (Vec<MirScalarExpr>, Vec<MirScalarExpr>, Vec<usize>)

As the arguments to Map, Filter, and Project operators.

In principle, this operator can be implemented as a sequence of more elemental operators, likely less efficiently.

pub fn literal_constraint(&self, expr: &MirScalarExpr) -> Option<Datum<'_>>

Determines if a scalar expression must be equal to a literal datum.

pub fn literal_constraints(&self, exprs: &[MirScalarExpr]) -> Option<Row>

Determines if a sequence of scalar expressions must be equal to a literal row.

This method returns None on an empty exprs, which might be surprising, but seems to line up with its callers’ expectations of that being a non-constraint. The caller knows if exprs is empty, and can modify their behavior appopriately. if they would rather have a literal empty row.

pub fn demand(&self) -> HashSet<usize>

Lists input columns whose values are used in outputs.

It is entirely appropriate to determine the demand of an instance and then both apply a projection to the subject of the instance and self.permute this instance.

Trait Implementations

impl Clone for SafeMfpPlan

fn clone(&self) -> SafeMfpPlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SafeMfpPlan

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

Formats the value using the given formatter.

impl Deref for SafeMfpPlan

type Target = MapFilterProject

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for SafeMfpPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for SafeMfpPlan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.