Method fmt_call

src/sql-parser/src/ast/defs/expr.rs:1309–1411

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

    }

    fn fmt_call<W: fmt::Write>(&self, f: &mut AstFormatter<W>, allow_special_form: bool) {
        // This block handles printing function calls that have special parsing. In stable mode, the
        // name is quoted and so won't get the special parsing. We only need to print the special
        // formats in non-stable mode.
        //
        // The special forms (`position(a IN b)`, `extract(field FROM source)`)
        // have no syntax for `DISTINCT`, a within-group `ORDER BY`, a `FILTER`,
        // or an `OVER` window. A call literally named `"position"`/`"extract"`
        // that carries any of those modifiers (only reachable via the quoted
        // name — the real special grammar doesn't accept them) must therefore
        // fall through to the plain quoted-call form, or the special form
        // silently drops them on display.
        let has_call_modifiers = self.distinct
            || self.filter.is_some()
            || self.over.is_some()
            || matches!(&self.args, FunctionArgs::Args { order_by, .. } if !order_by.is_empty());
        if allow_special_form && !f.stable() && !has_call_modifiers {
            let special: Option<(&str, &[Option<Keyword>])> =
                match self.name.to_ast_string_stable().as_str() {
                    // `extract(field FROM source)` parses `field` into a string
                    // literal, so the special form only round-trips when arg0 is
                    // a string. A generic `"extract"(a, b)` with a non-string
                    // first arg must use the plain (quoted) call form.
                    r#""extract""#
                        if self.args.len() == Some(2)
                            && matches!(self.args.first(), Some(Expr::Value(Value::String(_)))) =>
                    {
                        Some(("extract", &[None, Some(FROM)]))
                    }
                    // `position(<needle> IN <haystack>)` parses the needle at
                    // `Precedence::Like`, so a low-precedence needle (`NOT`, a
                    // comparison, `IS`, a boolean connective, a quantified
                    // comparison, ...) printed bare before the `IN` would swallow
                    // or stop short of the delimiter. Only use the special form
                    // with a needle that's safe to sit left of `IN`.
                    r#""position""#
                        if self.args.len() == Some(2)
                            && self.args.first().is_some_and(prints_self_delimiting) =>
                    {
                        Some(("position", &[None, Some(IN)]))
                    }

                    // "trim" doesn't need to appear here because it changes the function name (to
                    // "btrim", "ltrim", or "rtrim"), but only "trim" is parsed specially. "substring"
                    // supports comma-delimited arguments, so doesn't need to be here.
                    _ => None,
                };
            if let Some((name, kws)) = special {
                f.write_str(name);
                f.write_str("(");
                self.args.intersperse_function_argument_keywords(f, kws);
                f.write_str(")");
                return;
            }
        }

        // If the function name clashes with a keyword that has its own special
        // parser form, an unquoted name on reparse would trigger the