Struct MfpPlan 

pub struct MfpPlan<E: OptimizableExpr = MirScalarExpr> {
    pub(crate) mfp: SafeMfpPlan<E>,
    pub(crate) lower_bounds: Vec<E>,
    pub(crate) upper_bounds: Vec<E>,
}

Predicates partitioned into temporal and non-temporal.

Temporal predicates require some recognition to determine their structure, and it is best to do that once and re-use the results.

There are restrictions on the temporal predicates we currently support. They must directly constrain MzNow from below or above, by expressions that do not themselves contain MzNow. Conjunctions of such constraints are also ok.

Fields

mfp: SafeMfpPlan<E>

Normal predicates to evaluate on &[Datum] and expect Ok(Datum::True).

lower_bounds: Vec<E>

Expressions that when evaluated lower-bound or equal (<=) MzNow.

upper_bounds: Vec<E>

Expressions that when evaluated strictly upper-bound MzNow.

Implementations

impl<E: OptimizableExpr> MfpPlan<E>

pub fn from_parts( mfp: SafeMfpPlan<E>, lower_bounds: Vec<E>, upper_bounds: Vec<E>, ) -> Self

Construct an MfpPlan from its components.

pub fn into_parts(self) -> (SafeMfpPlan<E>, Vec<E>, Vec<E>)

Deconstruct into components.

pub fn safe_mfp(&self) -> &SafeMfpPlan<E>

Access the inner SafeMfpPlan.

pub fn as_parts(&self) -> (&SafeMfpPlan<E>, &[E], &[E])

Borrow all parts: (safe_mfp, lower_bounds, upper_bounds).

pub fn create_from(mfp: MapFilterProject<E>) -> Result<Self, String>

Partitions predicates into non-temporal, and lower and upper temporal bounds.

The first returned list is of predicates that do not contain mz_now. The second and third returned lists contain expressions that, once evaluated, lower and upper bound the validity interval of a record, respectively. These second two lists are populated only by binary expressions of the form

mz_now cmp_op expr

where cmp_op is a comparison operator and expr does not contain mz_now.

If any unsupported expression is found, for example one that uses mz_now in an unsupported position, an error is returned.

pub fn is_identity(&self) -> bool

Indicates if the planned MapFilterProject emits exactly its inputs as outputs.

pub fn has_temporal_bounds(&self) -> bool

Returns true if the plan contains temporal bounds (i.e., predicates involving mz_now()).

pub fn take(&mut self) -> Self

Returns self, and leaves behind an identity operator that acts on its output.

pub fn into_nontemporal(self) -> Result<SafeMfpPlan<E>, Self>

Attempt to convert self into a non-temporal MapFilterProject plan.

If that is not possible, the original instance is returned as an error.

pub fn iter_nontemporal_exprs(&mut self) -> impl Iterator<Item = &mut E>

Returns an iterator over mutable references to all non-temporal scalar expressions in the plan.

The order of iteration is unspecified.

pub fn ignores_input(&self) -> bool

Indicates that Self ignores its input to the extent that it can be evaluated on &[].

At the moment, this is only true if it projects away all columns and applies no filters, but it could be extended to plans that produce literals independent of the input.

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

pub fn evaluate<'b, 'a: 'b, Err: From<EvalError>, V: Fn(&Timestamp) -> bool>( &'a self, datums: &'b mut Vec<Datum<'a>>, arena: &'a RowArena, time: Timestamp, diff: Diff, valid_time: V, row_builder: &mut Row, ) -> impl Iterator<Item = Result<(Row, Timestamp, Diff), (Err, Timestamp, Diff)>> + use<Err, V, E>

Evaluate the predicates, temporal and non-, and return times and differences for data.

If self contains only non-temporal predicates, the result will either be (time, diff), or an evaluation error. If self contains temporal predicates, the results can be times that are greater than the input time, and may contain negated diff` values.

The row_builder is not cleared first, but emptied if the function returns an iterator with any Ok(_) element.

pub fn could_error(&self) -> bool

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

Trait Implementations

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

fn clone(&self) -> MfpPlan<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 MfpPlan<E>

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

Formats the value using the given formatter.

impl<'de, E> Deserialize<'de> for MfpPlan<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 MfpPlan<E>

fn cmp(&self, other: &MfpPlan<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 MfpPlan<E>

fn eq(&self, other: &MfpPlan<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 MfpPlan<E>

fn partial_cmp(&self, other: &MfpPlan<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 MfpPlan<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 MfpPlan<E>

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