Method lower

src/sql/src/plan/lowering.rs:181–229

(
        self,
        config: C,
        metrics: Option<&OptimizerMetrics>,
    )

    /// This requires rewriting all correlated subqueries (nested `HirRelationExpr`s) into flat queries
    #[mz_ore::instrument(target = "optimizer", level = "trace", name = "hir_to_mir")]
    pub fn lower<C: Into<Config>>(
        self,
        config: C,
        metrics: Option<&OptimizerMetrics>,
    ) -> Result<MirRelationExpr, PlanError> {
        let context = Context {
            config: &config.into(),
            metrics,
        };
        let result = match self {
            // We directly rewrite a Constant into the corresponding `MirRelationExpr::Constant`
            // to ensure that the downstream optimizer can easily bypass most
            // irrelevant optimizations (e.g. reduce folding) for this expression
            // without having to re-learn the fact that it is just a constant,
            // as it would if the constant were wrapped in a Let-Get pair.
            HirRelationExpr::Constant { rows, typ } => {
                let rows: Vec<_> = rows.into_iter().map(|row| (row, Diff::ONE)).collect();
                MirRelationExpr::Constant {
                    rows: Ok(rows),
                    typ: ReprRelationType::from(&typ),
                }
            }
            mut other => {
                let mut id_gen = mz_ore::id_gen::IdGen::default();
                transform_hir::split_subquery_predicates(&mut other)?;
                transform_hir::try_simplify_quantified_comparisons(
                    &mut other,
                    context.config.enable_simplify_quantified_comparisons,
                )?;
                transform_hir::fuse_window_functions(&mut other, &context)?;
                MirRelationExpr::constant(vec![vec![]], ReprRelationType::new(vec![])).let_in(
                    &mut id_gen,
                    |id_gen, get_outer| {
                        other.applied_to(
                            id_gen,
                            get_outer,
                            &ColumnMap::empty(),
                            &mut CteMap::new(),
                            &context,
                        )
                    },
                )?
            }
        };

        mz_repr::explain::trace_plan(&result);

        Ok(result)
    }

    /// Return a `MirRelationExpr` which evaluates `self` once for each row of `get_outer`.
    ///