Function write_dot_receiver

src/sql-parser/src/ast/defs/expr.rs:576–612

Write `expr` as the receiver of a `.` operator (used by `FieldAccess` and `WildcardAccess`), parenthesizing when the receiver could re-bind the trailing dot on reparse. The `.` token has very high precedence and both the lexer and parser greedily extend adjacent tokens: `1.x` tokenizes the number `1.` and leaves `x` as an alias, and `'a'::T.x` consumes `T.x` as a qualified type name. The whitelist

(f: &mut AstFormatter<W>, expr: &Expr<T>)

/// are a single `(…)`/`ARRAY(…)` primary, so a trailing dot attaches to the whole
/// thing.)
fn write_dot_receiver<W: fmt::Write, T: AstInfo>(f: &mut AstFormatter<W>, expr: &Expr<T>) {
    let safe = matches!(
        expr,
        Expr::FieldAccess { .. }
            | Expr::WildcardAccess(_)
            | Expr::Parameter(_)
            | Expr::Nested(_)
            | Expr::Row { .. }
            | Expr::Function(_)
            | Expr::Case { .. }
            | Expr::Exists(_)
            | Expr::Subquery(_)
            | Expr::Array(_)
            | Expr::ArraySubquery(_)
            | Expr::List(_)
            | Expr::ListSubquery(_)
            | Expr::Map(_)
            | Expr::MapSubquery(_)
            | Expr::Subscript { .. }
            | Expr::HomogenizingFunction { .. }
            | Expr::NullIf { .. }
            | Expr::Value(
                Value::String(_)
                    | Value::Boolean(_)
                    | Value::Null
                    | Value::HexString(_)
                    | Value::Interval(_)
            )
    );
    if safe {
        f.write_node(expr);
    } else {
        f.write_str("(");
        f.write_node(expr);
        f.write_str(")");
    }
}

/// Write `left` as the LHS of `<left> <op> ANY/ALL (...)`. The printed `<op>` is an
/// ordinary binary infix. It can be any operator the parser accepts here, from