Method fmt

src/sql-parser/src/ast/defs/expr.rs:204–548

(&self, f: &mut AstFormatter<W>)

impl<T: AstInfo> AstDisplay for Expr<T> {
    fn fmt<W: fmt::Write>(&self, f: &mut AstFormatter<W>) {
        match self {
            Expr::Identifier(s) => f.write_node(&display::separated(s, ".")),
            Expr::QualifiedWildcard(q) => {
                f.write_node(&display::separated(q, "."));
                f.write_str(".*");
            }
            Expr::FieldAccess { expr, field } => {
                write_dot_receiver(f, expr);
                f.write_str(".");
                f.write_node(field);
            }
            Expr::WildcardAccess(expr) => {
                write_dot_receiver(f, expr);
                f.write_str(".*");
            }
            Expr::Parameter(n) => f.write_str(&format!("${}", n)),
            Expr::Not { expr } => {
                f.write_str("NOT ");
                // `NOT` binds tighter than `AND`/`OR`, so an operand exposing a
                // looser operator on its left spine (`NOT (a OR b)`) must keep its
                // parens once `Nested` is stripped. We use `left_edge`, since the
                // `NOT` sits to the operand's left.
                write_binary_operand(f, expr, left_edge(expr) < prec::NOT);
            }
            Expr::And { left, right } => {
                write_binary_operand(f, left, right_edge(left) < prec::AND);
                f.write_str(" AND ");
                write_binary_operand(f, right, left_edge(right) <= prec::AND);
            }
            Expr::Or { left, right } => {
                write_binary_operand(f, left, right_edge(left) < prec::OR);
                f.write_str(" OR ");
                write_binary_operand(f, right, left_edge(right) <= prec::OR);
            }
            Expr::IsExpr {
                expr,
                negated,
                construct,
            } => {
                write_binary_operand(f, expr, right_edge(expr) < prec::IS);
                f.write_str(" IS ");
                if *negated {
                    f.write_str("NOT ");
                }
                // `IS DISTINCT FROM <rhs>` parses the RHS at the `IS` precedence
                // (see `Parser::parse_is`), so a RHS whose left spine binds at or
                // below `IS` re-associates out of the `IS` unless parenthesized
                // (`a IS DISTINCT FROM b OR c` is `(a IS DISTINCT FROM b) OR c`).
                // The other constructs (`NULL`/`TRUE`/…) are bare keywords.
                if let IsExprConstruct::DistinctFrom(rhs) = construct {
                    f.write_str("DISTINCT FROM ");
                    write_binary_operand(f, rhs, left_edge(rhs) <= prec::IS);
                } else {
                    f.write_node(construct);
                }
            }
            Expr::InList {