Struct mz_compute_types::plan::AvailableCollections

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

The forms in which an operator’s output is available; it can be considered the plan-time equivalent of render::context::CollectionBundle.

These forms are either “raw”, representing an unarranged collection, or “arranged”, representing one that has been arranged by some key.

The raw collection, if it exists, may be consumed directly.

The arranged collections are slightly more complicated: Each key here is attached to a description of how the corresponding arrangement is permuted to remove value columns that are redundant with key columns. Thus, the first element in each tuple of arranged is the arrangement key; the second is the map of logical output columns to columns in the key or value of the deduplicated representation, and the third is a “thinning expression”, or list of columns to include in the value when arranging.

For example, assume a 5-column collection is to be arranged by the key [Column(2), Column(0) + Column(3), Column(1)]. Then Column(1) and Column(2) in the value are redundant with the key, and only columns 0, 3, and 4 need to be stored separately. The thinning expression will then be [0, 3, 4].

The permutation represents how to recover the original values (logically [Column(0), Column(1), Column(2), Column(3), Column(4)]) from the key and value of the arrangement, logically [Column(2), Column(0) + Column(3), Column(1), Column(0), Column(3), Column(4)]. Thus, the permutation in this case should be {0: 3, 1: 2, 2: 0, 3: 4, 4: 5}.

Note that this description, while true at the time of writing, is merely illustrative; users of this struct should not rely on the exact strategy used for generating the permutations. As long as clients apply the thinning expression when creating arrangements, and permute by the hashmap when reading them, the contract of the function where they are generated (mz_expr::permutation_for_arrangement) ensures that the correct values will be read.

Fields

raw: bool

Whether the collection exists in unarranged form.

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

The set of arrangements of the collection, along with a column permutation mapping

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>, BTreeMap<usize, 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>, BTreeMap<usize, 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>, BTreeMap<usize, usize>, Vec<usize>)>>, <Option<Vec<ColumnType>> as Arbitrary>::Strategy), fn(_: (bool, Vec<(Vec<MirScalarExpr>, BTreeMap<usize, 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