Method visit_expr_mut_internal

src/sql/src/plan/transform_ast.rs:596–871

(&mut self, expr: &mut Expr<Aug>)

    }

    fn visit_expr_mut_internal(&mut self, expr: &mut Expr<Aug>) -> Result<(), PlanError> {
        // `($expr)` => `$expr`
        while let Expr::Nested(e) = expr {
            *expr = e.take();
        }

        // `$expr BETWEEN $low AND $high` => `$expr >= $low AND $expr <= $low`
        // `$expr NOT BETWEEN $low AND $high` => `$expr < $low OR $expr > $low`
        if let Expr::Between {
            expr: e,
            low,
            high,
            negated,
        } = expr
        {
            if *negated {
                *expr = Expr::lt(*e.clone(), low.take()).or(e.take().gt(high.take()));
            } else {
                *expr = e.clone().gt_eq(low.take()).and(e.take().lt_eq(high.take()));
            }
        }

        // When `$expr` is a `ROW` constructor, we need to desugar as described
        // below in order to enable the row comparision expansion at the end of
        // this function. We don't do this desugaring unconditionally (i.e.,
        // when `$expr` is not a `ROW` constructor) because the implementation
        // in `plan_in_list` is more efficient when row comparison expansion is
        // not required.
        //
        // `$expr IN ($list)` => `$expr = $list[0] OR $expr = $list[1] ... OR $expr = $list[n]`
        // `$expr NOT IN ($list)` => `$expr <> $list[0] AND $expr <> $list[1] ... AND $expr <> $list[n]`
        if let Expr::InList {
            expr: e,
            list,
            negated,
        } = expr
        {
            if let Expr::Row { .. } = &**e {
                if *negated {
                    *expr = list
                        .drain(..)
                        .map(|r| e.clone().not_equals(r))
                        .reduce(|e1, e2| e1.and(e2))
                        .expect("list known to contain at least one element");
                } else {
                    *expr = list
                        .drain(..)
                        .map(|r| e.clone().equals(r))
                        .reduce(|e1, e2| e1.or(e2))
                        .expect("list known to contain at least one element");
                }
            }
        }

        // `$expr IN ($subquery)` => `$expr = ANY ($subquery)`
        // `$expr NOT IN ($subquery)` => `$expr <> ALL ($subquery)`
        if let Expr::InSubquery {
            expr: e,