Struct mz_compute_client::plan::join::JoinClosure

pub struct JoinClosure {
    pub ready_equivalences: Vec<Vec<MirScalarExpr>>,
    pub before: SafeMfpPlan,
}

A manual closure implementation of filtering and logic application.

This manual implementation exists to express lifetime constraints clearly, as there is a relationship between the borrowed lifetime of the closed-over state and the arguments it takes when invoked. It was not clear how to do this with a Rust closure (glorious battle was waged, but ultimately lost).

Fields

ready_equivalences: Vec<Vec<MirScalarExpr>>

before: SafeMfpPlan

Implementations

impl JoinClosure

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

Applies per-row filtering and logic.

fn build( columns: &mut BTreeMap<usize, usize>, equivalences: &mut Vec<Vec<MirScalarExpr>>, mfp: &mut MapFilterProject, permutation: BTreeMap<usize, usize>, thinned_arity_with_key: usize ) -> Self

Construct an instance of the closure from available columns.

This method updates the available columns, equivalences, and the MapFilterProject instance. The columns are updated to include reference to any columns added by the application of this logic, which might result from partial application of the MapFilterProject instance.

If all columns are available for mfp, this method works extra hard to ensure that the closure contains all the work, and mfp is left as an identity transform (which can then be ignored).

pub fn is_identity(&self) -> bool

True iff the closure neither filters nor transforms records.

pub fn could_error(&self) -> bool

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

Trait Implementations

impl Arbitrary for JoinClosure

type Parameters = ()

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

type Strategy = BoxedStrategy<JoinClosure>

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

fn arbitrary_with(_: 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 JoinClosure

fn clone(&self) -> JoinClosure

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JoinClosure

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for JoinClosure

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

Deserialize this value from the given Serde deserializer.

impl DisplayText<PlanRenderingContext<'_, Plan<Timestamp>>> for JoinClosure

fn fmt_text( &self, f: &mut Formatter<'_>, ctx: &mut PlanRenderingContext<'_, Plan> ) -> Result

impl PartialEq<JoinClosure> for JoinClosure

fn eq(&self, other: &JoinClosure) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl RustType<ProtoJoinClosure> for JoinClosure

fn into_proto(&self) -> ProtoJoinClosure

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

impl Serialize for JoinClosure

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

Serialize this value into the given Serde serializer.

impl Eq for JoinClosure

impl StructuralEq for JoinClosure

impl StructuralPartialEq for JoinClosure