Struct mz_transform::literal_lifting::LiteralLifting

pub struct LiteralLifting {
    recursion_guard: RecursionGuard,
}

Hoist literal values from maps wherever possible.

Fields

recursion_guard: RecursionGuard

Implementations

impl LiteralLifting

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

Hoist literal values from maps wherever possible.

Returns a list of literal scalar expressions that must be appended to the result before it can be correctly used. The intent is that this action extracts a maximal set of literals from relation, which can then often be propagated further up and inlined in any expressions as it goes.

In several cases, we only manage to extract literals from the final columns. But in those cases where it is possible, permutations are used to move all of the literals to the final columns, and then rely on projection hoisting to allow the these literals to move up the AST.

TODO: The literals from the final columns are returned as the result of this method, whereas literals in intermediate columns are extracted using permutations. The reason for this different treatment is that in some cases it is not possible to remove the projection of the permutation, preventing the lifting of a literal that could otherwise be lifted, the following example being of them:

%0 = | Constant (1, 2, 3) (2, 2, 3)

%1 = | Constant (4, 3, 3) (4, 5, 3)

%2 = | Union %0 %1

If final literals weren’t treated differently, the example above would lead to the following transformed plan:

%0 = | Constant (1) (2) | Map 2, 3 | Project (#0..#2)

%1 = | Constant (3) (5) | Map 4, 3 | Project (#1, #0, #2)

%2 = | Union %0 %1

Since the union branches have different projections, they cannot be removed, preventing literal 3 from being lifted further.

In theory, all literals could be treated in the same way if this method returned both a list of literals and a projection vector, making the caller have to deal with the reshuffling. (see https://github.com/MaterializeInc/database-issues/issues/2055)

Trait Implementations

impl CheckedRecursion for LiteralLifting

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 LiteralLifting

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

Formats the value using the given formatter.

impl Default for LiteralLifting

fn default() -> LiteralLifting

Returns the “default value” for a type.

impl Transform for LiteralLifting

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.