Struct mz_compute_types::plan::AvailableCollections

pub struct AvailableCollections {
    pub raw: bool,
    pub arranged: Vec<(Vec<MirScalarExpr>, Vec<usize>, Vec<usize>)>,
    pub types: Option<Vec<ColumnType>>,
}

The forms in which an operator’s output is available.

These forms may include “raw”, meaning as a streamed collection, but also any number of “arranged” representations.

Each arranged representation is described by a KeyValRowMapping, or rather at the moment by its three fields in a triple. These fields explain how to form a “key” by applying some expressions to each row, how to select “values” from columns not explicitly captured by the key, and how to return to the original row from the concatenation of key and value. Further explanation is available in the documentation for KeyValRowMapping.

Fields

raw: bool

Whether the collection exists in unarranged form.

arranged: Vec<(Vec<MirScalarExpr>, Vec<usize>, Vec<usize>)>

The list of available arrangements, presented as a KeyValRowMapping, but here represented by a triple (to_key, to_val, to_row) instead. The documentation for KeyValRowMapping explains these fields better.

types: Option<Vec<ColumnType>>

The types of the columns in the raw form of the collection, if known. We only capture types when necessary to support arrangement specialization, so this only done for specific LIR operators during lowering.

Implementations

impl AvailableCollections

pub fn new_raw() -> Self

Represent a collection that has no arrangements.

pub fn new_arranged( arranged: Vec<(Vec<MirScalarExpr>, Vec<usize>, Vec<usize>)>, types: Option<Vec<ColumnType>>, ) -> Self

Represent a collection that is arranged in the specified ways, with optionally given types describing the rows that would be in the raw form of the collection.

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

Get some arrangement, if one exists.

Trait Implementations

impl Arbitrary for AvailableCollections

type Parameters = (<bool as Arbitrary>::Parameters, <Option<Vec<ColumnType>> as Arbitrary>::Parameters)

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

type Strategy = Map<(<bool as Arbitrary>::Strategy, BoxedStrategy<Vec<(Vec<MirScalarExpr>, Vec<usize>, Vec<usize>)>>, <Option<Vec<ColumnType>> as Arbitrary>::Strategy), fn(_: (bool, Vec<(Vec<MirScalarExpr>, Vec<usize>, Vec<usize>)>, Option<Vec<ColumnType>>)) -> AvailableCollections>

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 AvailableCollections

fn clone(&self) -> AvailableCollections

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AvailableCollections

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

Formats the value using the given formatter.

impl Default for AvailableCollections

fn default() -> AvailableCollections

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AvailableCollections

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>> for AvailableCollections

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

impl Ord for AvailableCollections

fn cmp(&self, other: &AvailableCollections) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for AvailableCollections

fn eq(&self, other: &AvailableCollections) -> 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 PartialOrd for AvailableCollections

fn partial_cmp(&self, other: &AvailableCollections) -> 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 RustType<ProtoAvailableCollections> for AvailableCollections

fn into_proto(&self) -> ProtoAvailableCollections

Convert a Self into a Proto value.

fn from_proto(x: ProtoAvailableCollections) -> 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 Serialize for AvailableCollections

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 AvailableCollections

impl StructuralPartialEq for AvailableCollections