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

map: Vec<Option<usize>>

Implementations

impl ColIndexMapping

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

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) -> ColIndexMapping

pub fn is_identity(&self) -> bool

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

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

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

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, ) -> ColIndexMapping

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) -> ColIndexMapping

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

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: &ColIndexMapping) -> ColIndexMapping

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) -> ColIndexMapping

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

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

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) -> ColIndexMapping

pub fn from_protobuf(prost: &ColIndexMapping) -> 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 ColIndexMappingRewriteExt for ColIndexMapping

fn rewrite_provided_order(&self, order: &Order) -> Order

Rewrite the provided order’s column index. It will try its best to give the most accurate order. Order(0,1,2) with mapping(0->1,1->0,2->2) will be rewritten to Order(1,0,2) Order(0,1,2) with mapping(0->1,2->0) will be rewritten to Order(1)

fn rewrite_required_order(&self, order: &Order) -> Option<Order>

Rewrite the required order’s field index. if it can’t give a corresponding required order after the column index mapping, it will return None. Order(0,1,2) with mapping(0->1,1->0,2->2) will be rewritten to Order(1,0,2) Order(0,1,2) with mapping(0->1,2->0) will return None

fn rewrite_dist_key(&self, key: &[usize]) -> Option<Vec<usize>>

Rewrite the distribution key and will return None if any index of the key disappear after the mapping.

fn rewrite_provided_distribution(&self, dist: &Distribution) -> Distribution

Rewrite the provided distribution’s field index. It will try its best to give the most accurate distribution. HashShard(0,1,2), with mapping(0->1,1->0,2->2) will be rewritten to HashShard(1,0,2). HashShard(0,1,2), with mapping(0->1,2->0) will be rewritten to SomeShard.

fn rewrite_required_distribution(&self, dist: &RequiredDist) -> RequiredDist

Rewrite the required distribution’s field index. if it can’t give a corresponding required distribution after the column index mapping, it will return None. ShardByKey(0,1,2), with mapping(0->1,1->0,2->2) will be rewritten to ShardByKey(1,0,2). ShardByKey(0,1,2), with mapping(0->1,2->0) will return ShardByKey(1,0). ShardByKey(0,1), with mapping(2->0) will return Any.

fn rewrite_functional_dependency( &self, fd: &FunctionalDependency, ) -> Option<FunctionalDependency>

Rewrite the indices in a functional dependency.

fn rewrite_functional_dependency_set( &self, fd_set: FunctionalDependencySet, ) -> FunctionalDependencySet

Rewrite functional dependencies in fd_set one by one, using [ColIndexMapping::rewrite_functional_dependency].

fn rewrite_bitset(&self, bitset: &FixedBitSet) -> FixedBitSet

fn rewrite_monotonicity_map(&self, map: &MonotonicityMap) -> MonotonicityMap

impl Debug for ColIndexMapping

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

Formats the value using the given formatter.

impl ExprRewriter for ColIndexMapping

fn rewrite_input_ref(&mut self, input_ref: InputRef) -> ExprImpl

fn rewrite_expr(&mut self, expr: ExprImpl) -> ExprImpl

fn rewrite_function_call(&mut self, func_call: FunctionCall) -> ExprImpl

fn rewrite_function_call_with_lambda( &mut self, func_call: FunctionCallWithLambda, ) -> ExprImpl

fn rewrite_agg_call(&mut self, agg_call: AggCall) -> ExprImpl

fn rewrite_parameter(&mut self, parameter: Parameter) -> ExprImpl

fn rewrite_literal(&mut self, literal: Literal) -> ExprImpl

fn rewrite_subquery(&mut self, subquery: Subquery) -> ExprImpl

fn rewrite_correlated_input_ref( &mut self, input_ref: CorrelatedInputRef, ) -> ExprImpl

fn rewrite_table_function(&mut self, table_func: TableFunction) -> ExprImpl

fn rewrite_window_function(&mut self, window_func: WindowFunction) -> ExprImpl

fn rewrite_user_defined_function( &mut self, udf: UserDefinedFunction, ) -> ExprImpl

fn rewrite_now(&mut self, now: Now) -> ExprImpl

impl Hash for ColIndexMapping

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

where __H: Hasher,

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