Struct ColIndexMapping

pub struct ColIndexMapping {
    target_size: usize,
    map: Vec<Option<usize>>,
}

ColIndexMapping is a partial mapping from usize to usize.

It is used in optimizer for transformation of column index.

Fields

target_size: usize

The size of the target space, i.e. target index is in the range (0..target_size).

map: Vec<Option<usize>>

Each subscript is mapped to the corresponding element.

Implementations

impl ColIndexMapping

pub fn new(map: Vec<Option<usize>>, target_size: usize) -> Self

Create a partial mapping which maps from the subscripts range (0..map.len()) to (0..target_size). Each subscript is mapped to the corresponding element.

pub fn into_parts(self) -> (Vec<Option<usize>>, usize)

pub fn to_parts(&self) -> (&[Option<usize>], usize)

pub fn put(&mut self, src: usize, tar: Option<usize>)

pub fn identity(size: usize) -> Self

pub fn is_identity(&self) -> bool

pub fn identity_or_none(source_size: usize, target_size: usize) -> Self

pub fn empty(source_size: usize, target_size: usize) -> Self

pub fn with_shift_offset(source_num: usize, offset: isize) -> Self

Create a partial mapping which maps range (0..source_num) to range (offset..offset+source_num).

Examples

Positive offset:

let mapping = ColIndexMapping::with_shift_offset(3, 3);
assert_eq!(mapping.map(0), 3);
assert_eq!(mapping.map(1), 4);
assert_eq!(mapping.map(2), 5);

Negative offset:

let mapping = ColIndexMapping::with_shift_offset(6, -3);
assert_eq!(mapping.try_map(0), None);
assert_eq!(mapping.try_map(1), None);
assert_eq!(mapping.try_map(2), None);
assert_eq!(mapping.map(3), 0);
assert_eq!(mapping.map(4), 1);
assert_eq!(mapping.map(5), 2);
assert_eq!(mapping.try_map(6), None);

pub fn with_remaining_columns(cols: &[usize], src_size: usize) -> Self

Maps the smallest index to 0, the next smallest to 1, and so on.

It is useful for column pruning.

Examples

let mut remaining_cols = vec![1, 3];
let mapping = ColIndexMapping::with_remaining_columns(&remaining_cols, 4);
assert_eq!(mapping.map(1), 0);
assert_eq!(mapping.map(3), 1);
assert_eq!(mapping.try_map(0), None);
assert_eq!(mapping.try_map(2), None);
assert_eq!(mapping.try_map(4), None);

pub fn with_included_columns(cols: &[usize], src_size: usize) -> Self

pub fn with_removed_columns(cols: &[usize], src_size: usize) -> Self

Remove the given columns, and maps the remaining columns to a consecutive range starting from 0.

Examples

let mut removed_cols = vec![0, 2, 4];
let mapping = ColIndexMapping::with_removed_columns(&removed_cols, 5);
assert_eq!(mapping.map(1), 0);
assert_eq!(mapping.map(3), 1);
assert_eq!(mapping.try_map(0), None);
assert_eq!(mapping.try_map(2), None);
assert_eq!(mapping.try_map(4), None);

pub fn composite(&self, following: &Self) -> Self

Compose column index mappings. For example if this maps 0->5, and following maps 5->1, Then the composite has 0->5->1 => 0->1.

pub fn clone_with_offset(&self, offset: usize) -> Self

pub fn union(&self, other: &Self) -> Self

Union two mapping, the result mapping target_size and source size will be the max size of the two mappings.

Panics

Will panic if a source appears in both to mapping

pub fn inverse(&self) -> Option<Self>

Inverse the mapping. If a target corresponds to more than one source, return None.

pub fn mapping_pairs(&self) -> impl Iterator<Item = (usize, usize)> + '_

return iter of (src, dst) order by src

pub fn try_map(&self, index: usize) -> Option<usize>

Try mapping the source index to the target index.

pub fn try_map_all( &self, indices: impl IntoIterator<Item = usize>, ) -> Option<Vec<usize>>

Try mapping all the source indices to the target indices. Returns None if any of the indices is not mapped.

pub fn map(&self, index: usize) -> usize

Panics

Will panic if index >= self.source_size() or index is not mapped.

pub fn target_size(&self) -> usize

Returns the size of the target range. Target index is in the range (0..target_size).

pub fn source_size(&self) -> usize

Returns the size of the source range. Source index is in the range (0..source_size).

pub fn is_empty(&self) -> bool

pub fn is_injective(&self) -> bool

impl ColIndexMapping

pub fn to_protobuf(&self) -> PbColIndexMapping

pub fn from_protobuf(prost: &PbColIndexMapping) -> ColIndexMapping

impl ColIndexMapping

pub fn rewrite_dispatch_strategy( &self, strategy: &DispatchStrategy, ) -> Option<DispatchStrategy>

Rewrite the dist-key indices and output indices in the given dispatch strategy. Returns None if any of the indices is not mapped to the target.

Trait Implementations

impl Clone for ColIndexMapping

fn clone(&self) -> ColIndexMapping

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ColIndexMapping

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

Formats the value using the given formatter.

impl Hash for ColIndexMapping

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ColIndexMapping

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

impl StructuralPartialEq for ColIndexMapping