Struct SafeMfpPlan 

pub struct SafeMfpPlan<E: OptimizableExpr = MirScalarExpr> {
    pub(crate) mfp: MapFilterProject<E>,
}

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

Fields

mfp: MapFilterProject<E>

Implementations

impl<E: OptimizableExpr> SafeMfpPlan<E>

pub fn from_mfp(mfp: MapFilterProject<E>) -> Self

Wrap a MapFilterProject in a SafeMfpPlan.

pub fn into_mfp(self) -> MapFilterProject<E>

Unwrap the inner MapFilterProject.

pub fn permute_fn<F>(&mut self, remap: F, new_arity: usize)

where F: Fn(usize) -> usize,

Remaps references to input columns according to remap.

Leaves other column references, e.g. to newly mapped columns, unchanged.

pub fn is_identity(&self) -> bool

Returns true when Self is the identity.

impl<E: OptimizableExpr + Eval> SafeMfpPlan<E>

pub fn evaluate_into<'a, 'row>( &'a self, datums: &mut Vec<Datum<'a>>, arena: &'a RowArena, row_buf: &'row mut Row, ) -> Result<Option<&'row 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.

pub fn could_error(&self) -> bool

Returns true if evaluation could introduce an error on non-error inputs.

Methods from Deref<Target = MapFilterProject<E>>

pub fn is_identity(&self) -> bool

True if the operator describes the identity transformation.

pub fn as_map_filter_project(&self) -> (Vec<E>, Vec<E>, 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 has_temporal_predicates(&self) -> bool

Returns true if any predicate in this MFP contains a temporal expression (mz_now()).

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

Lists input columns whose values are used in outputs.

You can use BTreeSet::last() to extract the maximum demanded column from the set.

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.

pub fn size(&self) -> usize

Total expression sizes across all expressions.

Trait Implementations

impl<E: Clone + OptimizableExpr> Clone for SafeMfpPlan<E>

fn clone(&self) -> SafeMfpPlan<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug + OptimizableExpr> Debug for SafeMfpPlan<E>

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

Formats the value using the given formatter.

impl<E: OptimizableExpr> Deref for SafeMfpPlan<E>

type Target = MapFilterProject<E>

The resulting type after dereferencing.

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

Dereferences the value.

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

where E: DeserializeOwned + OptimizableExpr,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E: Ord + OptimizableExpr> Ord for SafeMfpPlan<E>

fn cmp(&self, other: &SafeMfpPlan<E>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<E: PartialEq + OptimizableExpr> PartialEq for SafeMfpPlan<E>

fn eq(&self, other: &SafeMfpPlan<E>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: PartialOrd + OptimizableExpr> PartialOrd for SafeMfpPlan<E>

fn partial_cmp(&self, other: &SafeMfpPlan<E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E> Serialize for SafeMfpPlan<E>

where E: Serialize + OptimizableExpr,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Eq + OptimizableExpr> Eq for SafeMfpPlan<E>

impl<E: OptimizableExpr> StructuralPartialEq for SafeMfpPlan<E>