Struct mz_transform::Optimizer

pub struct Optimizer {
    pub name: &'static str,
    pub transforms: Vec<Box<dyn Transform>>,
}

A naive optimizer for relation expressions.

The optimizer currently applies only peep-hole optimizations, from a limited set that were sufficient to get some of TPC-H up and working. It is worth a review at some point to improve the quality, coverage, and architecture of the optimizations.

Fields

name: &'static str

A logical name identifying this optimizer instance.

transforms: Vec<Box<dyn Transform>>

The list of transforms to apply to an input relation.

Implementations

impl Optimizer

pub fn logical_optimizer(ctx: &mut TransformCtx<'_>) -> Self

👎Deprecated: Create an Optimize instance and call optimize instead.

Builds a logical optimizer that only performs logical transformations.

pub fn physical_optimizer(ctx: &mut TransformCtx<'_>) -> Self

Builds a physical optimizer.

Performs logical transformations followed by all physical ones. This is meant to be used for optimizing each view within a dataflow once view inlining has already happened, right before dataflow rendering.

pub fn logical_cleanup_pass( ctx: &mut TransformCtx<'_>, allow_new_globals: bool, ) -> Self

Contains the logical optimizations that should run after cross-view transformations run.

Set allow_new_globals when you will use these as the first passes. The first instance of the typechecker in an optimizer pipeline should allow new globals (or it will crash when it encounters them).

pub fn fast_path_optimizer(_ctx: &mut TransformCtx<'_>) -> Self

Builds a tiny optimizer, which is only suitable for optimizing fast-path queries.

pub fn constant_optimizer(_ctx: &mut TransformCtx<'_>) -> Self

Builds a tiny optimizer, which just folds constants. For more details, see fold_constants_fixpoint.

pub fn optimize( &self, relation: MirRelationExpr, ctx: &mut TransformCtx<'_>, ) -> Result<OptimizedMirRelationExpr, TransformError>

Optimizes the supplied relation expression.

These optimizations are performed with no information about available arrangements, which makes them suitable for pre-optimization before dataflow deployment.

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

Optimizes the supplied relation expression in place, using available arrangements.

This method should only be called with non-empty indexes when optimizing a dataflow, as the optimizations may lock in the use of arrangements that may cease to exist.

Trait Implementations

impl Debug for Optimizer

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

Formats the value using the given formatter.