Test XMLCONCAT parsing across dialects

Author: LucaCappelletti94

tests/sqlparser_common.rs

@@ -18779,3 +18779,20 @@ fn parse_non_pg_dialects_keep_xml_names_as_regular_identifiers() {
     let dialects = all_dialects_except(|d| d.supports_xml_expressions());
     dialects.verified_only_select("SELECT xml FROM t");
 }
+
+#[test]
+fn parse_non_pg_dialects_keep_xml_names_as_regular_functions() {
+    // On dialects that do NOT support XML expressions, `xmlconcat(...)`
+    // should parse as a plain function call, not as `Expr::XmlConcat`.
+    let dialects = all_dialects_except(|d| d.supports_xml_expressions());
+    for fn_name in ["xmlconcat"] {
+        let sql = format!("SELECT {fn_name}(1, 2)");
+        let select = dialects.verified_only_select(&sql);
+        match expr_from_projection(&select.projection[0]) {
+            Expr::Function(func) => {
+                assert_eq!(func.name.to_string(), fn_name);
+            }
+            other => panic!("Expected Expr::Function for {fn_name}, got: {other:?}"),
+        }
+    }
+}

tests/sqlparser_postgres.rs

@@ -3750,6 +3750,31 @@ fn parse_on_commit() {
     pg_and_generic().verified_stmt("CREATE TEMPORARY TABLE table (COL INT) ON COMMIT DROP");
 }
 
+#[test]
+fn parse_xmlconcat_expression() {
+    // XMLCONCAT should parse as a dedicated Expr::XmlConcat variant on
+    // PostgreSQL and Generic, preserving argument order.
+    let sql = "SELECT XMLCONCAT('<a/>', '<b/>', '<c/>')";
+    let select = pg_and_generic().verified_only_select(sql);
+    match expr_from_projection(&select.projection[0]) {
+        Expr::XmlConcat(exprs) => {
+            assert_eq!(exprs.len(), 3);
+            let strings: Vec<String> = exprs
+                .iter()
+                .map(|e| match e {
+                    Expr::Value(v) => match &v.value {
+                        Value::SingleQuotedString(s) => s.clone(),
+                        other => panic!("Expected SingleQuotedString, got: {other:?}"),
+                    },
+                    other => panic!("Expected Value, got: {other:?}"),
+                })
+                .collect();
+            assert_eq!(strings, vec!["<a/>", "<b/>", "<c/>"]);
+        }
+        other => panic!("Expected Expr::XmlConcat, got: {other:?}"),
+    }
+}
+
 #[test]
 fn parse_xml_typed_string() {
     // xml '...' should parse as a TypedString on PostgreSQL and Generic