Method doc_expr

src/sql-pretty/src/doc.rs:1209–1397

(&'a self, v: &'a Expr<T>)

    }

    pub fn doc_expr<'a, T: AstInfo>(&'a self, v: &'a Expr<T>) -> RcDoc<'a> {
        match v {
            Expr::Op { op, expr1, expr2 } => {
                if let Some(expr2) = expr2 {
                    RcDoc::concat([
                        self.doc_expr(expr1),
                        RcDoc::line(),
                        RcDoc::text(format!("{} ", op)),
                        self.doc_expr(expr2).nest(TAB),
                    ])
                } else {
                    // See the AstDisplay `Expr::Op` comment (`prefix_operand_needs_parens`):
                    // a prefix op binds tighter than `COLLATE`/the binary ops but
                    // looser than the postfix `::`/`[…]`, and `- <number>` folds, so
                    // peel the tight postfixes and parenthesize when the chain
                    // bottoms out at a numeric literal or a non-self-delimiting /
                    // `COLLATE` operand.
                    let needs_parens = {
                        let mut e = expr1.as_ref();
                        let mut saw_postfix = false;
                        loop {
                            match e {
                                Expr::Cast { expr, .. } | Expr::Subscript { expr, .. } => {
                                    saw_postfix = true;
                                    e = expr.as_ref();
                                }
                                Expr::Value(Value::Number(_)) => break saw_postfix,
                                // Another prefix operator stacks directly (no
                                // re-association, no `- <number>` fold) — safe,
                                // and avoids exploding deep unary chains.
                                Expr::Op { expr2: None, .. } | Expr::Not { .. } => break false,
                                Expr::Value(_)
                                | Expr::Identifier(_)
                                | Expr::QualifiedWildcard(_)
                                | Expr::Parameter(_)
                                | Expr::Function(_)
                                | Expr::HomogenizingFunction { .. }
                                | Expr::NullIf { .. }
                                | Expr::Subquery(_)
                                | Expr::Exists(_)
                                | Expr::Nested(_)
                                | Expr::Array(_)
                                | Expr::ArraySubquery(_)
                                | Expr::List(_)
                                | Expr::ListSubquery(_)
                                | Expr::Map(_)
                                | Expr::MapSubquery(_)
                                | Expr::Case { .. }
                                | Expr::Row { .. } => break false,
                                _ => break true,
                            }
                        }
                    };
                    let operand = if needs_parens {
                        bracket("(", self.doc_expr(expr1), ")")
                    } else {
                        self.doc_expr(expr1)
                    };