Parse XMLCONCAT as a dedicated expression

Author: LucaCappelletti94

src/ast/mod.rs

@@ -1332,6 +1332,12 @@ pub enum Expr {
     Lambda(LambdaFunction),
     /// Checks membership of a value in a JSON array
     MemberOf(MemberOf),
+    /// PostgreSQL `XMLCONCAT(xml[, ...])` — concatenates a list of
+    /// individual XML values to create a single value containing an
+    /// XML content fragment.
+    ///
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/functions-xml.html#FUNCTIONS-PRODUCING-XML-XMLCONCAT)
+    XmlConcat(Vec<Expr>),
 }
 
 impl Expr {
@@ -2182,6 +2188,9 @@ impl fmt::Display for Expr {
             Expr::Prior(expr) => write!(f, "PRIOR {expr}"),
             Expr::Lambda(lambda) => write!(f, "{lambda}"),
             Expr::MemberOf(member_of) => write!(f, "{member_of}"),
+            Expr::XmlConcat(exprs) => {
+                write!(f, "XMLCONCAT({})", display_comma_separated(exprs))
+            }
         }
     }
 }

src/ast/spans.rs

@@ -1651,6 +1651,7 @@ impl Spanned for Expr {
             Expr::Prior(expr) => expr.span(),
             Expr::Lambda(_) => Span::empty(),
             Expr::MemberOf(member_of) => member_of.value.span().union(&member_of.array.span()),
+            Expr::XmlConcat(exprs) => union_spans(exprs.iter().map(|e| e.span())),
         }
     }
 }

src/parser/mod.rs

@@ -2430,9 +2430,47 @@ impl<'a> Parser<'a> {
 
     /// Parse a function call expression named by `name` and return it as an `Expr`.
     pub fn parse_function(&mut self, name: ObjectName) -> Result<Expr, ParserError> {
+        if let Some(expr) = self.maybe_parse_xml_function(&name)? {
+            return Ok(expr);
+        }
         self.parse_function_call(name).map(Expr::Function)
     }
 
+    /// If `name` is a PostgreSQL XML function and the current dialect
+    /// supports XML expressions, parse it as a dedicated [`Expr`]
+    /// variant rather than a generic function call.
+    ///
+    /// Returns `Ok(None)` when the name is not an XML function or the
+    /// dialect does not support XML expressions, in which case the
+    /// caller should fall back to the regular function-call parser.
+    fn maybe_parse_xml_function(
+        &mut self,
+        name: &ObjectName,
+    ) -> Result<Option<Expr>, ParserError> {
+        if !self.dialect.supports_xml_expressions() {
+            return Ok(None);
+        }
+        let [ObjectNamePart::Identifier(ident)] = name.0.as_slice() else {
+            return Ok(None);
+        };
+        if ident.quote_style.is_some() {
+            return Ok(None);
+        }
+        if ident.value.eq_ignore_ascii_case("xmlconcat") {
+            return Ok(Some(self.parse_xmlconcat_expr()?));
+        }
+        Ok(None)
+    }
+
+    /// Parse the argument list of a PostgreSQL `XMLCONCAT` expression:
+    /// `(expr [, expr]...)`.
+    fn parse_xmlconcat_expr(&mut self) -> Result<Expr, ParserError> {
+        self.expect_token(&Token::LParen)?;
+        let exprs = self.parse_comma_separated(Parser::parse_expr)?;
+        self.expect_token(&Token::RParen)?;
+        Ok(Expr::XmlConcat(exprs))
+    }
+
     fn parse_function_call(&mut self, name: ObjectName) -> Result<Function, ParserError> {
         self.expect_token(&Token::LParen)?;