Method humanize

src/expr/src/explain/text.rs:1281–1377

(
        e: &HumanizedExpr<'a, MirScalarExpr, M>,
        f: &mut fmt::Formatter<'_>,
    )

impl HumanizeDisplay for MirScalarExpr {
    fn humanize<'a, M: HumanizerMode>(
        e: &HumanizedExpr<'a, MirScalarExpr, M>,
        f: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        use MirScalarExpr::*;

        match e.expr {
            Column(i, TreatAsEqual(None)) => {
                // Delegate to the `HumanizedExpr<'a, _>` implementation (plain column reference).
                e.child(i).fmt(f)
            }
            Column(i, TreatAsEqual(Some(name))) => {
                // Delegate to the `HumanizedExpr<'a, _>` implementation (with stored name information)
                e.child(&(i, name)).fmt(f)
            }
            Literal(row, _) => {
                // Delegate to the `HumanizedExpr<'a, _>` implementation.
                e.child(row).fmt(f)
            }
            CallUnmaterializable(func) => write!(f, "{}()", func),
            CallUnary { func, expr } => {
                if let crate::UnaryFunc::Not(_) = *func {
                    if let CallUnary { func, expr } = expr.as_ref() {
                        if let Some(is) = func.is() {
                            let expr = e.child::<MirScalarExpr>(&*expr);
                            return write!(f, "({}) IS NOT {}", expr, is);
                        }
                    }
                }
                if let Some(is) = func.is() {
                    let expr = e.child::<MirScalarExpr>(&*expr);
                    write!(f, "({}) IS {}", expr, is)
                } else {
                    let expr = e.child::<MirScalarExpr>(&*expr);
                    write!(f, "{}({})", func, expr)
                }
            }
            CallBinary { func, expr1, expr2 } => {
                let expr1 = e.child::<MirScalarExpr>(&*expr1);
                let expr2 = e.child::<MirScalarExpr>(&*expr2);
                if func.is_infix_op() {
                    write!(f, "({} {} {})", expr1, func, expr2)
                } else {
                    write!(f, "{}({}, {})", func, expr1, expr2)
                }
            }
            CallVariadic { func, exprs } => {
                use crate::VariadicFunc::*;
                match func {
                    CaseLiteral(cl) => {
                        let input = e.child::<MirScalarExpr>(&exprs[0]);
                        write!(f, "case_lookup {}", input)?;
                        for entry in &cl.lookup {
                            let result = e.child::<MirScalarExpr>(&exprs[entry.expr_index]);
                            write!(f, " when ")?;
                            e.mode.humanize_datum(entry.literal.unpack_first(), f)?;
                            write!(f, " then {}", result)?;
                        }