Struct mz_transform::predicate_pushdown::PredicatePushdown

pub struct PredicatePushdown {
    recursion_guard: RecursionGuard,
}

Pushes predicates down through other operators.

Fields

recursion_guard: RecursionGuard

Implementations

impl PredicatePushdown

pub fn action( &self, relation: &mut MirRelationExpr, get_predicates: &mut BTreeMap<Id, BTreeSet<MirScalarExpr>>, ) -> Result<(), TransformError>

Predicate pushdown

This method looks for opportunities to push predicates toward sources of data. Primarily, this is the Filter expression, and moving its predicates through the operators it contains.

In addition, the method accumulates the intersection of predicates applied to each Get expression, so that the predicate can then be pushed through to a Let binding, or to the external source of the data if the Get binds to another view.

fn update_join_inputs_with_push_downs( inputs: &mut Vec<MirRelationExpr>, push_downs: Vec<Vec<MirScalarExpr>>, )

fn push_into_let_binding( get_predicates: &mut BTreeMap<Id, BTreeSet<MirScalarExpr>>, id: &LocalId, value: &mut MirRelationExpr, users: &mut [&mut MirRelationExpr], )

pub fn push_filters_through_join( input_mapper: &JoinInputMapper, equivalences: &Vec<Vec<MirScalarExpr>>, predicates: Vec<MirScalarExpr>, ) -> (Vec<MirScalarExpr>, Vec<Vec<MirScalarExpr>>)

Returns (<predicates to retain>, <predicates to push at each input>).

pub fn push_filters_through_map( map_exprs: &Vec<MirScalarExpr>, predicates: &mut Vec<MirScalarExpr>, input_arity: usize, all_errors: bool, ) -> Result<(Vec<MirScalarExpr>, Vec<MirScalarExpr>), TransformError>

Computes “safe” predicates to push through a Map.

In the case of a Filter { Map {…} }, we can always push down the Filter by inlining expressions from the Map. We don’t want to do this in general, however, since general inlining can result in exponential blowup in the size of expressions, so we only do this in the case where the size after inlining is below a certain limit.

Returns the predicates that can be pushed down, followed by ones that cannot.

fn inline_if_not_too_big( expr: &MirScalarExpr, input_arity: usize, map_exprs: &Vec<MirScalarExpr>, ) -> Result<Option<MirScalarExpr>, RecursionLimitError>

This fn should be called with a Filter expr that is after a Map. input_arity is the arity of the input of the Map. This fn eliminates such column refs in expr that refer not to a column in the input of the Map, but to a column that is created by the Map. It does this by transitively inlining Map expressions until no such expression remains that points to a Map expression. The return value is the cleaned up expression. The fn bails out with a None if the resulting expression would be made too big by the inlinings.

OOO: (Optimizer Optimization Opportunity) This function might do work proportional to the total size of the Map expressions. We call this function for each predicate above the Map, which will be kind of quadratic, i.e., if there are many predicates and a big Map, then this will be slow. We could instead pass a vector of Map expressions and call this fn only once. The only downside would be that then the inlining limit being hit in the middle part of this function would prevent us from inlining any predicates, even ones that wouldn’t hit the inlining limit if considered on their own.

fn push_filters_through_flat_map( predicates: &mut Vec<MirScalarExpr>, input_arity: usize, ) -> (Vec<MirScalarExpr>, Vec<MirScalarExpr>)

Computes “safe” predicate to push through a FlatMap.

In the case of a Filter { FlatMap {…} }, we want to push through all predicates that (1) are not literal errors and (2) have support exclusively in the columns provided by the FlatMap input.

Returns the predicates that can be pushed down, followed by ones that cannot.

fn extract_equal_or_both_null( s: &mut MirScalarExpr, column_types: &[ColumnType], ) -> Option<(MirScalarExpr, MirScalarExpr)>

If s is of the form (isnull(expr1) && isnull(expr2)) || (expr1 = expr2), or (decompose_is_null(expr1) && decompose_is_null(expr2)) || (expr1 = expr2), extract expr1 and expr2.

fn extract_equal_or_both_null_inner( or_arg1: &MirScalarExpr, or_arg2: &MirScalarExpr, column_types: &[ColumnType], ) -> Option<(MirScalarExpr, MirScalarExpr)>

fn extract_reduced_conjunction_terms( s: MirScalarExpr, column_types: &[ColumnType], ) -> Vec<MirScalarExpr>

Reduces the given expression and returns its AND-ed terms.

Trait Implementations

impl CheckedRecursion for PredicatePushdown

fn recursion_guard(&self) -> &RecursionGuard

Extracts a reference to the recursion guard embedded within the type.

fn checked_recur<F, T, E>(&self, f: F) -> Result<T, E>

where F: FnOnce(&Self) -> Result<T, E>, E: From<RecursionLimitError>,

Checks whether it is safe to recur and calls f if so.

fn checked_recur_mut<F, T, E>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<RecursionLimitError>,

Like CheckedRecursion::checked_recur, but operates on a mutable reference to Self.

impl Debug for PredicatePushdown

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

Formats the value using the given formatter.

impl Default for PredicatePushdown

fn default() -> PredicatePushdown

Returns the “default value” for a type.

impl Transform for PredicatePushdown

fn name(&self) -> &'static str

A short string naming the transform, as it will be reported in metrics.

fn actually_perform_transform( &self, relation: &mut MirRelationExpr, _: &mut TransformCtx<'_>, ) -> Result<(), TransformError>

Transform a relation into a functionally equivalent relation.

fn transform( &self, relation: &mut MirRelationExpr, args: &mut TransformCtx<'_>, ) -> Result<(), TransformError>

Transforms a relation into a functionally equivalent relation.

fn debug(&self) -> String

A string describing the transform.