Struct mz_adapter::optimize::materialized_view::Optimizer

pub struct Optimizer {

    typecheck_ctx: SharedContext,
    catalog: Arc<dyn OptimizerCatalog>,
    compute_instance: ComputeInstanceSnapshot,
    sink_id: GlobalId,
    view_id: GlobalId,
    column_names: Vec<ColumnName>,
    non_null_assertions: Vec<usize>,
    refresh_schedule: Option<RefreshSchedule>,
    debug_name: String,
    config: OptimizerConfig,
    metrics: OptimizerMetrics,
    duration: Duration,
    force_source_non_monotonic: BTreeSet<GlobalId>,
}

Fields

typecheck_ctx: SharedContext

A typechecking context to use throughout the optimizer pipeline.

catalog: Arc<dyn OptimizerCatalog>

A snapshot of the catalog state.

compute_instance: ComputeInstanceSnapshot

A snapshot of the cluster that will run the dataflows.

sink_id: GlobalId

A durable GlobalId to be used with the exported materialized view sink.

view_id: GlobalId

A transient GlobalId to be used when constructing the dataflow.

column_names: Vec<ColumnName>

The resulting column names.

non_null_assertions: Vec<usize>

Output columns that are asserted to be not null in the CREATE VIEW statement.

refresh_schedule: Option<RefreshSchedule>

Refresh schedule, e.g., REFRESH EVERY '1 day'

debug_name: String

A human-readable name exposed internally (useful for debugging).

config: OptimizerConfig

Optimizer config.

metrics: OptimizerMetrics

Optimizer metrics.

duration: Duration

The time spent performing optimization so far.

force_source_non_monotonic: BTreeSet<GlobalId>

Overrides monotonicity for the given source collections.

This is here only for continual tasks, which at runtime introduce synthetic retractions to “input sources”. If/when we split a CT optimizer out of the MV optimizer, this can be removed.

TODO(ct3): There are other differences between a GlobalId used as a CT input vs as a normal collection, such as the statistical size estimates. Plus, at the moment, it is not possible to use the same GlobalId as both an “input” and a “reference” in a CT. So, better than this approach would be for the optimizer itself to somehow understand the distinction between a CT input and a normal collection.

In the meantime, it might be desirable to refactor the MV optimizer to have a small amount of knowledge about CTs, in particular producing the CT sink connection directly. This would allow us to replace this field with something derived directly from that sink connection.

Implementations

impl Optimizer

pub fn new( catalog: Arc<dyn OptimizerCatalog>, compute_instance: ComputeInstanceSnapshot, sink_id: GlobalId, view_id: GlobalId, column_names: Vec<ColumnName>, non_null_assertions: Vec<usize>, refresh_schedule: Option<RefreshSchedule>, debug_name: String, config: OptimizerConfig, metrics: OptimizerMetrics, force_source_non_monotonic: BTreeSet<GlobalId>, ) -> Self

Trait Implementations

impl Optimize<GlobalMirPlan> for Optimizer

type To = GlobalLirPlan

fn optimize(&mut self, plan: GlobalMirPlan) -> Result<Self::To, OptimizerError>

Execute the optimization stage, transforming the input plan of type From to an output plan of type To.

fn catch_unwind_optimize( &mut self, plan: From, ) -> Result<Self::To, OptimizerError>

Like Self::optimize, but additionally ensures that panics occurring in the Self::optimize call are caught and demoted to an OptimizerError::Internal error.

fn must_optimize(&mut self, expr: From) -> Self::To

Execute the optimization stage and panic if an error occurs.

impl Optimize<HirRelationExpr> for Optimizer

type To = LocalMirPlan

fn optimize( &mut self, expr: HirRelationExpr, ) -> Result<Self::To, OptimizerError>

Execute the optimization stage, transforming the input plan of type From to an output plan of type To.

fn catch_unwind_optimize( &mut self, plan: From, ) -> Result<Self::To, OptimizerError>

Like Self::optimize, but additionally ensures that panics occurring in the Self::optimize call are caught and demoted to an OptimizerError::Internal error.

fn must_optimize(&mut self, expr: From) -> Self::To

Execute the optimization stage and panic if an error occurs.

impl Optimize<LocalMirPlan> for Optimizer

type To = GlobalMirPlan

fn optimize(&mut self, plan: LocalMirPlan) -> Result<Self::To, OptimizerError>

Execute the optimization stage, transforming the input plan of type From to an output plan of type To.

fn catch_unwind_optimize( &mut self, plan: From, ) -> Result<Self::To, OptimizerError>

Like Self::optimize, but additionally ensures that panics occurring in the Self::optimize call are caught and demoted to an OptimizerError::Internal error.

fn must_optimize(&mut self, expr: From) -> Self::To

Execute the optimization stage and panic if an error occurs.

impl Optimize<OptimizedMirRelationExpr> for Optimizer

This is needed only because the pipeline in the bootstrap code starts from an OptimizedMirRelationExpr attached to a mz_catalog::memory::objects::CatalogItem.

type To = GlobalMirPlan

fn optimize( &mut self, expr: OptimizedMirRelationExpr, ) -> Result<Self::To, OptimizerError>

Execute the optimization stage, transforming the input plan of type From to an output plan of type To.

fn catch_unwind_optimize( &mut self, plan: From, ) -> Result<Self::To, OptimizerError>

Like Self::optimize, but additionally ensures that panics occurring in the Self::optimize call are caught and demoted to an OptimizerError::Internal error.

fn must_optimize(&mut self, expr: From) -> Self::To

Execute the optimization stage and panic if an error occurs.