Struct mz_expr::linear::plan::MfpPlan

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

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

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

lower_bounds: Vec<MirScalarExpr>

Expressions that when evaluated lower-bound MzNow.

upper_bounds: Vec<MirScalarExpr>

Expressions that when evaluated upper-bound MzNow.

Implementations

impl MfpPlan

pub fn create_from(mfp: MapFilterProject) -> 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 take(&mut self) -> Self

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

pub fn into_nontemporal(self) -> Result<SafeMfpPlan, 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 MirScalarExpr>

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

The order of iteration is unspecified.

pub fn evaluate<'b, 'a: 'b, E: 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), (E, Timestamp, Diff)>>

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.

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.

Trait Implementations

impl Arbitrary for MfpPlan

type Parameters = <SafeMfpPlan as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<(<SafeMfpPlan as Arbitrary>::Strategy, BoxedStrategy<Vec<MirScalarExpr>>, BoxedStrategy<Vec<MirScalarExpr>>), fn(_: (SafeMfpPlan, Vec<MirScalarExpr>, Vec<MirScalarExpr>)) -> MfpPlan>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for MfpPlan

fn clone(&self) -> MfpPlan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MfpPlan

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

Formats the value using the given formatter.

impl PartialEq for MfpPlan

fn eq(&self, other: &MfpPlan) -> 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 RustType<ProtoMfpPlan> for MfpPlan

fn into_proto(&self) -> ProtoMfpPlan

Convert a Self into a Proto value.

fn from_proto(proto: ProtoMfpPlan) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl StructuralPartialEq for MfpPlan