Method can_be_printed_bare

src/sql-parser/src/ast/defs/name.rs:308–361

An identifier can be printed in bare mode if it matches the regex `[a-z_][a-z0-9_]*` and it is not a "reserved keyword."

(&self)

    ///  * it matches the regex `[a-z_][a-z0-9_]*` and
    ///  * it is not a "reserved keyword."
    pub fn can_be_printed_bare(&self) -> bool {
        self.has_only_bare_chars()
            && !self
                .as_keyword()
                .map(|kw| {
                    kw.is_sometimes_reserved()
                        || kw.begins_query_body()
                        // `AS` at the start of a SELECT item is consumed as the
                        // `AS OF` timestamp keyword (an empty projection), so a
                        // bare `as` identifier/function name fails to reparse.
                        || kw == AS
                        // `ANY`/`ALL`/`SOME` after a comparison operator start a
                        // quantified-comparison (`x op ANY (...)`), so a bare such
                        // identifier — e.g. `0 # some` — reparses as the start of a
                        // quantifier rather than an identifier.
                        || matches!(kw, ANY | ALL | SOME)
                        // `ALL`/`DISTINCT` right after `SELECT` are consumed as the
                        // projection quantifier, so a bare `"all"` / `"distinct"`
                        // column reference reparses to a quantifier with an empty
                        // projection instead of an identifier. (`ALL` is already
                        // covered above; quoting these keeps display-only — unlike
                        // marking them always-reserved, which also rejects `WHERE
                        // distinct = 1` at parse time.)
                        || kw == DISTINCT
                        // `LIST` followed by `[` re-lexes as a `LIST[...]` literal
                        // (`list[1]` is a valid one-element list), so a bare `list`
                        // identifier that gets subscripted — `"list"[1]` — would
                        // reparse as a list literal instead of a subscript. (`ARRAY`
                        // is reserved-in-scalar-expression and so already quoted;
                        // `MAP[...]` requires `=>`, so `map[1]` is unambiguously a
                        // subscript.)
                        || kw == LIST
                        // `DEALLOCATE [PREPARE] <name>` accepts an optional
                        // `PREPARE` keyword before the name, so a bare `prepare`
                        // name is consumed as that keyword on reparse, leaving no
                        // name (`DEALLOCATE prepare` -> `DEALLOCATE` + the optional
                        // keyword + a missing name).
                        || kw == PREPARE
                        // `CASE` treats a leading `WHEN` as the start of the
                        // first arm (a searched `CASE` with no operand), so a
                        // bare `when` identifier used as the `CASE` operand —
                        // `CASE when.a WHEN ...` — reparses as `CASE WHEN .a ...`
                        // ("expected an expression, found dot"). Quoting it keeps
                        // the operand an identifier.
                        || kw == WHEN
                        // `COPY [INTO] <table> FROM …` accepts an optional `INTO`
                        // keyword before the relation name, so a bare `into`
                        // relation is consumed as that keyword on reparse
                        // (`COPY into FROM x` -> `COPY INTO <name=from> …`, which
                        // then fails expecting the FROM/TO direction).
                        || kw == INTO
                })
                .unwrap_or(false)
    }

    pub fn as_str(&self) -> &str {
        &self.0