Struct mz_dataflow_types::plan::AvailableCollections

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

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>, HashMap<usize, usize>, Vec<usize>)>

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

Implementations

impl AvailableCollections

pub fn new_raw() -> Self

Represent a collection that has no arrangements.

pub fn new_arranged(
    arranged: Vec<(Vec<MirScalarExpr>, HashMap<usize, usize>, Vec<usize>)>
) -> Self

Represent a collection that is arranged in the specified ways.

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

Get some arrangement, if one exists.

Trait Implementations

impl Arbitrary for AvailableCollections

type Parameters = <bool 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>, HashMap<usize, usize>, Vec<usize>)>>), fn(_: (bool, Vec<(Vec<MirScalarExpr>, HashMap<usize, usize>, Vec<usize>)>)) -> Self>

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

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

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

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

This method tests for !=.

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.

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

impl StructuralPartialEq for AvailableCollections