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

Trait Implementations

impl Clone for ColIndexMapping

fn clone(&self) -> ColIndexMapping

Returns a duplicate 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 Eq for ColIndexMapping

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 StructuralPartialEq for ColIndexMapping