Add support for un-parenthesized "RETURN SELECT" syntax

- rename `AsReturn` to `AsReturnSubquery` for clarity between these two variants

Author: aharpervc

src/ast/ddl.rs

@@ -2313,7 +2313,10 @@ impl fmt::Display for CreateFunction {
         if let Some(CreateFunctionBody::Return(function_body)) = &self.function_body {
             write!(f, " RETURN {function_body}")?;
         }
-        if let Some(CreateFunctionBody::AsReturn(function_body)) = &self.function_body {
+        if let Some(CreateFunctionBody::AsReturnSubquery(function_body)) = &self.function_body {
+            write!(f, " AS RETURN {function_body}")?;
+        }
+        if let Some(CreateFunctionBody::AsReturnSelect(function_body)) = &self.function_body {
             write!(f, " AS RETURN {function_body}")?;
         }
         if let Some(using) = &self.using {

src/ast/mod.rs

@@ -8671,7 +8671,17 @@ pub enum CreateFunctionBody {
     /// ```
     ///
     /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql
-    AsReturn(Expr),
+    AsReturnSubquery(Expr),
+
+    /// Function body expression using the 'AS RETURN' keywords, with an un-parenthesized SELECT query
+    ///
+    /// Example:
+    /// ```sql
+    /// CREATE FUNCTION myfunc(a INT, b INT)
+    /// RETURNS TABLE
+    /// AS RETURN SELECT a + b AS sum;
+    /// ```
+    AsReturnSelect(Select),
 }
 
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

src/parser/mod.rs

@@ -5248,11 +5248,25 @@ impl<'a> Parser<'a> {
             }))
         } else if self.peek_keyword(Keyword::RETURN) {
             self.expect_keyword(Keyword::RETURN)?;
-            let expr = self.parse_expr()?;
-            if !matches!(expr, Expr::Subquery(_)) {
-                parser_err!("Expected a subquery after RETURN", expr.span().start)?;
+
+            if self.peek_token() == Token::LParen {
+                let expr = self.parse_expr()?;
+                if !matches!(expr, Expr::Subquery(_)) {
+                    parser_err!(
+                        "Expected a subquery after RETURN",
+                        self.peek_token().span.start
+                    )?
+                }
+                Some(CreateFunctionBody::AsReturnSubquery(expr))
+            } else if self.peek_keyword(Keyword::SELECT) {
+                let select = self.parse_select()?;
+                Some(CreateFunctionBody::AsReturnSelect(select))
+            } else {
+                parser_err!(
+                    "Expected a subquery (or bare SELECT statement) after RETURN",
+                    self.peek_token().span.start
+                )?
             }
-            Some(CreateFunctionBody::AsReturn(expr))
         } else {
             parser_err!("Unparsable function body", self.peek_token().span.start)?
         };

tests/sqlparser_mssql.rs

@@ -303,6 +303,14 @@ fn parse_create_function() {
     ";
     let _ = ms().verified_stmt(create_inline_table_value_function);
 
+    let create_inline_table_value_function_without_parentheses = "\
+        CREATE FUNCTION some_inline_tvf(@foo INT, @bar VARCHAR(256)) \
+        RETURNS TABLE \
+        AS \
+        RETURN SELECT 1 AS col_1\
+    ";
+    let _ = ms().verified_stmt(create_inline_table_value_function_without_parentheses);
+
     let create_inline_table_value_function_without_as =
         create_inline_table_value_function.replace(" AS", "");
     let _ = ms().one_statement_parses_to(