Function split_subquery_predicates

src/sql/src/plan/transform_hir.rs:60–148

Rewrites predicates that contain subqueries so that the subqueries appear in their own later predicate when possible. For example, this function rewrites this expression ```text Filter { predicates: [a = b AND EXISTS ( ) AND c = d AND ( ) = e] } ``` like so: ```text Filter { predicates: [ a = b AND c = d, EXISTS ( ), ( ) = e, ] } ``` The rewrite cause

(expr: &mut HirRelationExpr)

/// d AND EXISTS(<subquery>)`. This can vastly reduce the cost of the
/// subquery, especially when the original conjunction contains join keys.
pub fn split_subquery_predicates(expr: &mut HirRelationExpr) -> Result<(), RecursionLimitError> {
    fn walk_relation(expr: &mut HirRelationExpr) -> Result<(), RecursionLimitError> {
        #[allow(deprecated)]
        expr.visit_mut_fallible(0, &mut |expr, _| {
            match expr {
                HirRelationExpr::Map { scalars, .. } => {
                    for scalar in scalars {
                        walk_scalar(scalar)?;
                    }
                }
                HirRelationExpr::CallTable { exprs, .. } => {
                    for expr in exprs {
                        walk_scalar(expr)?;
                    }
                }
                HirRelationExpr::Filter { predicates, .. } => {
                    let mut subqueries = vec![];
                    for predicate in &mut *predicates {
                        walk_scalar(predicate)?;
                        extract_conjuncted_subqueries(predicate, &mut subqueries)?;
                    }
                    // TODO(benesch): we could be smarter about the order in which
                    // we emit subqueries. At the moment we just emit in the order
                    // we discovered them, but ideally we'd emit them in an order
                    // that accounted for their cost/selectivity. E.g., low-cost,
                    // high-selectivity subqueries should go first.
                    for subquery in subqueries {
                        predicates.push(subquery);
                    }
                }
                _ => (),
            }
            Ok(())
        })
    }

    fn walk_scalar(expr: &mut HirScalarExpr) -> Result<(), RecursionLimitError> {
        expr.try_visit_direct_subqueries_mut(&mut walk_relation)
    }

    fn contains_subquery(expr: &HirScalarExpr) -> Result<bool, RecursionLimitError> {
        let mut found = false;
        expr.try_visit_direct_subqueries(|_| {
            found = true;
            Ok(())
        })?;
        Ok(found)
    }

    /// Extracts subqueries from a conjunction into `out`.
    ///
    /// For example, given an expression like
    ///
    /// ```text
    /// a = b AND EXISTS (<subquery 1>) AND c = d AND (<subquery 2>) = e
    /// ```
    ///
    /// this function rewrites the expression to