Add support for MSSQL's XQuery methods

src/ast/mod.rs

@@ -560,6 +560,13 @@ pub enum Expr {
         expr: Box<Expr>,
         key: Ident,
     },
+    /// CompositeFunction (mssql) e.g. SELECT (SELECT ',' + name FROM sys.objects  FOR XML PATH(''), TYPE).value('.','NVARCHAR(MAX)')   
+    /// <https://learn.microsoft.com/en-us/sql/t-sql/xml/xml-data-type-methods?view=sql-server-ver16>
+    CompositeFunction {
+        expr: Box<Expr>,
+        name: Ident,
+        args: Vec<Expr>,
+    },
     /// `IS FALSE` operator
     IsFalse(Box<Expr>),
     /// `IS NOT FALSE` operator
@@ -1629,6 +1636,9 @@ impl fmt::Display for Expr {
             Expr::CompositeAccess { expr, key } => {
                 write!(f, "{expr}.{key}")
             }
+            Expr::CompositeFunction { expr, name, args } => {
+                write!(f, "{expr}.{name}({})", display_comma_separated(args))
+            }
             Expr::AtTimeZone {
                 timestamp,
                 time_zone,

src/parser/mod.rs

@@ -1269,6 +1269,50 @@ impl<'a> Parser<'a> {
             _ => self.expected("an expression", next_token),
         }?;
 
+        if dialect_of!(self is MsSqlDialect) {
+            // Convert `CompositeAccess` to `CompositeFunction` (MSSQL doesn't support `CompositeAccess` syntax)
+            // ```sql
+            // SELECT (SELECT ',' + name FROM sys.objects  FOR XML PATH(''), TYPE).value('.','NVARCHAR(MAX)')
+            // ```
+            if let Expr::CompositeAccess { expr, key } = expr {
+                self.expect_token(&Token::LParen)?;
+                let args = self.parse_comma_separated(Parser::parse_expr)?;
+                self.expect_token(&Token::RParen)?;
+                return Ok(Expr::CompositeFunction {
+                    expr: expr,
+                    name: key,
+                    args,
+                });
+            }
+            // ```sql
+            // SELECT CONVERT(XML,'<Book>abc</Book>').value('.','NVARCHAR(MAX)')
+            // ```
+            else if matches!(
+                expr,
+                Expr::Cast { .. } | Expr::Convert { .. } | Expr::Function(_)
+            ) && self.consume_token(&Token::Period)
+            {
+                let tok = self.next_token();
+                let name = match tok.token {
+                    Token::Word(word) => word.to_ident(),
+                    _ => {
+                        return parser_err!(
+                            format!("Expected identifier, found: {tok}"),
+                            tok.location
+                        )
+                    }
+                };
+                self.expect_token(&Token::LParen)?;
+                let args = self.parse_comma_separated(Parser::parse_expr)?;
+                self.expect_token(&Token::RParen)?;
+                return Ok(Expr::CompositeFunction {
+                    expr: Box::new(expr),
+                    name,
+                    args,
+                });
+            }
+        }
+
         if self.parse_keyword(Keyword::COLLATE) {
             Ok(Expr::Collate {
                 expr: Box::new(expr),

tests/sqlparser_mssql.rs

@@ -1029,6 +1029,16 @@ fn parse_create_table_with_identity_column() {
     }
 }
 
+#[test]
+fn parse_mssql_xquery() {
+    let sql = "SELECT STUFF((SELECT ',' + name FROM sys.objects FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'), 1, 1, '') AS T";
+    let _ = ms().verified_query(sql);
+    let sql = "SELECT CAST(column AS XML).value('.', 'NVARCHAR(MAX)') AS T";
+    let _ = ms().verified_query(sql);
+    let sql = "SELECT CONVERT(XML, '<Book>abc</Book>').value('.', 'NVARCHAR(MAX)') AS T";
+    let _ = ms().verified_query(sql);
+}
+
 fn ms() -> TestedDialects {
     TestedDialects::new(vec![Box::new(MsSqlDialect {})])
 }