Method fmt

src/sql/src/plan/explain/text.rs:301–460

(&self, f: &mut fmt::Formatter<'_>)

impl fmt::Display for HirScalarExpr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use HirRelationExpr::Get;
        use HirScalarExpr::*;
        match self {
            Column(i, TreatAsEqual(None)) => write!(
                f,
                "#{}{}",
                (0..i.level).map(|_| '^').collect::<String>(),
                i.column
            ),
            Column(i, TreatAsEqual(Some(name))) => write!(
                f,
                "#{}{}{{{name}}}",
                (0..i.level).map(|_| '^').collect::<String>(),
                i.column,
            ),
            Parameter(i, _name) => write!(f, "${}", i),
            Literal(row, _, _name) => write!(f, "{}", row.unpack_first()),
            CallUnmaterializable(func, _name) => write!(f, "{}()", func),
            CallUnary { func, expr, .. } => {
                if let mz_expr::UnaryFunc::Not(_) = *func {
                    if let CallUnary { func, expr, .. } = expr.as_ref() {
                        if let Some(is) = func.is() {
                            return write!(f, "({}) IS NOT {}", expr, is);
                        }
                    }
                }
                if let Some(is) = func.is() {
                    write!(f, "({}) IS {}", expr, is)
                } else {
                    write!(f, "{}({})", func, expr)
                }
            }
            CallBinary {
                func, expr1, expr2, ..
            } => {
                if func.is_infix_op() {
                    write!(f, "({} {} {})", expr1, func, expr2)
                } else {
                    write!(f, "{}({}, {})", func, expr1, expr2)
                }
            }
            CallVariadic { func, exprs, .. } => {
                use mz_expr::VariadicFunc::*;
                match func {
                    ArrayCreate(..) => {
                        let exprs = separated(", ", exprs);
                        write!(f, "array[{}]", exprs)
                    }
                    ListCreate(..) => {
                        let exprs = separated(", ", exprs);
                        write!(f, "list[{}]", exprs)
                    }
                    RecordCreate(..) => {
                        let exprs = separated(", ", exprs);
                        write!(f, "row({})", exprs)
                    }
                    func if func.is_infix_op() && exprs.len() > 1 => {