Struct Condition

pub struct Condition {
    pub conjunctions: Vec<ExprImpl>,
}

Fields

conjunctions: Vec<ExprImpl>

Condition expressions in conjunction form (combined with AND)

Implementations

impl Condition

pub fn with_expr(expr: ExprImpl) -> Self

pub fn true_cond() -> Self

pub fn false_cond() -> Self

pub fn always_true(&self) -> bool

pub fn always_false(&self) -> bool

pub fn as_expr_unless_true(&self) -> Option<ExprImpl>

Convert condition to an expression. If always true, return None.

pub fn and(self, other: Self) -> Self

pub fn or(self, other: Self) -> Self

pub fn split( self, left_col_num: usize, right_col_num: usize, ) -> (Self, Self, Self)

Split the condition expressions into 3 groups: left, right and others

pub fn collect_input_refs(&self, input_col_num: usize) -> FixedBitSet

Collect all InputRefs’ indexes in the expressions.

Panics

Panics if input_ref >= input_col_num.

pub fn split_by_input_col_nums( self, input_col_nums: &[usize], only_eq: bool, ) -> (BTreeMap<(usize, usize), Self>, Self)

Split the condition expressions into (N choose 2) + 1 groups: those containing two columns from different buckets (and optionally, needing an equal condition between them), and others.

input_num_cols are the number of columns in each of the input buckets. For instance, with bucket0: col0, col1, col2 | bucket1: col3, col4 | bucket2: col5 input_num_cols = [3, 2, 1]

Returns hashmap with keys of the form (col1, col2) where col1 < col2 in terms of their col index.

only_eq: whether to only split those conditions with an eq condition predicate between two buckets.

pub fn split_eq_keys( self, left_col_num: usize, right_col_num: usize, ) -> (Vec<(InputRef, InputRef, bool)>, Self)

For EqJoinPredicate, separate equality conditions which connect left columns and right columns from other conditions.

The equality conditions are transformed into (left_col_id, right_col_id) pairs.

pub(crate) fn extract_inequality_keys( &self, left_col_num: usize, right_col_num: usize, ) -> Vec<(usize, InequalityInputPair)>

For EqJoinPredicate, extract inequality conditions which connect left columns and right columns from other conditions.

The inequality conditions are transformed into (left_col_id, right_col_id, offset) pairs.

pub fn split_disjoint(self, columns: &FixedBitSet) -> (Self, Self)

Split the condition expressions into 2 groups: those referencing columns and others which are disjoint with columns.

fn disjunctions_to_scan_ranges( table_desc: Rc<TableDesc>, max_split_range_gap: u64, disjunctions: Vec<ExprImpl>, ) -> Result<Option<(Vec<ScanRange>, Self)>, RwError>

Generate range scans from each arm of OR clause and merge them. Currently, only support equal type range scans. Keep in mind that range scans can not overlap, otherwise duplicate rows will occur.

pub fn split_to_scan_ranges( self, table_desc: Rc<TableDesc>, max_split_range_gap: u64, ) -> Result<(Vec<ScanRange>, Self), RwError>

See also ScanRange.

fn classify_conjunctions_by_pk( conjunctions: Vec<ExprImpl>, table_desc: &Rc<TableDesc>, ) -> Vec<Vec<ExprImpl>>

classify conjunctions into groups: The i-th group has exprs that only reference the i-th PK column. The last group contains all the other exprs.

fn analyze_group( group: Vec<ExprImpl>, ) -> Result<Option<(Vec<Bound<ScalarImpl>>, Vec<Bound<ScalarImpl>>, Vec<Option<ScalarImpl>>, Vec<ExprImpl>)>, RwError>

Extract the following information in a group of conjunctions:

1. lower bound conjunctions
2. upper bound conjunctions
3. eq conditions
4. other conditions

return None indicates that this conjunctions is always false

fn mutual_exclusive_with_eq_conds( new_conds: &ScalarImpl, eq_conds: &[Option<ScalarImpl>], ) -> bool

fn merge_lower_bound_conjunctions( lb: Vec<Bound<ScalarImpl>>, ) -> Bound<ScalarImpl>

fn merge_upper_bound_conjunctions( ub: Vec<Bound<ScalarImpl>>, ) -> Bound<ScalarImpl>

fn is_invalid_range( lower_bound: &Bound<ScalarImpl>, upper_bound: &Bound<ScalarImpl>, ) -> bool

fn extract_eq_conds_within_range( eq_conds: Vec<Option<ScalarImpl>>, upper_bound: &Bound<ScalarImpl>, lower_bound: &Bound<ScalarImpl>, ) -> Vec<Option<ScalarImpl>>

pub fn group_by<F, const N: usize>(self, f: F) -> [Self; N]

where F: Fn(&ExprImpl) -> usize,

Split the condition expressions into N groups. An expression expr is in the i-th group if f(expr)==i.

Panics

Panics if f(expr)>=N.

pub fn rewrite_expr(self, rewriter: &mut (impl ExprRewriter + ?Sized)) -> Self

pub fn visit_expr<V: ExprVisitor + ?Sized>(&self, visitor: &mut V)

pub fn visit_expr_mut(&mut self, mutator: &mut (impl ExprMutator + ?Sized))

fn simplify(self) -> Self

Simplify conditions It simplify conditions by applying constant folding and removing unnecessary conjunctions

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl Display for Condition

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

Formats the value using the given formatter.

impl From<Condition> for ExprImpl

fn from(c: Condition) -> Self

Converts to this type from the input type.

impl Hash for Condition

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 IntoIterator for Condition

type IntoIter = IntoIter<ExprImpl>

Which kind of iterator are we turning this into?

type Item = ExprImpl

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Condition

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

impl StructuralPartialEq for Condition