Support single table name with Parenthesis

Author: eyalsatori

src/parser.rs

@@ -1748,6 +1748,40 @@ impl Parser {
         Ok(TableWithJoins { relation, joins })
     }
 
+    pub fn parse_table_factor_table(&mut self) -> Result<TableFactor, ParserError> {
+        let name = self.parse_object_name()?;
+        // Postgres, MSSQL: table-valued functions:
+        let args = if self.consume_token(&Token::LParen) {
+            self.parse_optional_args()?
+        } else {
+            vec![]
+        };
+        let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
+        // MSSQL-specific table hints:
+        let mut with_hints = vec![];
+        if self.parse_keyword("WITH") {
+            if self.consume_token(&Token::LParen) {
+                with_hints = self.parse_comma_separated(Parser::parse_expr)?;
+                self.expect_token(&Token::RParen)?;
+            } else {
+                // rewind, as WITH may belong to the next statement's CTE
+                self.prev_token();
+            }
+        };
+        Ok(TableFactor::Table {
+            name,
+            alias,
+            args,
+            with_hints,
+        })
+    }
+
+    pub fn parse_table_inside_parenthesis(&mut self) -> Result<TableFactor, ParserError> {
+        let table = self.parse_table_factor_table()?; 
+        self.expect_token(&Token::RParen)?;
+        Ok(table)  
+    }
+
     /// A table name or a parenthesized subquery, followed by optional `[AS] alias`
     pub fn parse_table_factor(&mut self) -> Result<TableFactor, ParserError> {
         if self.parse_keyword("LATERAL") {
@@ -1757,6 +1791,7 @@ impl Parser {
             }
             return self.parse_derived_table_factor(Lateral);
         }
+       
 
         if self.consume_token(&Token::LParen) {
             let index = self.index;
@@ -1767,10 +1802,12 @@ impl Parser {
             // Here's an example that demonstrates the complexity:
             //                     /-------------------------------------------------------\
             //                     | /-----------------------------------\                 |
-            //     SELECT * FROM ( ( ( (SELECT 1) UNION (SELECT 2) ) AS t1 NATURAL JOIN t2 ) )
-            //                   ^ ^ ^ ^
-            //                   | | | |
-            //                   | | | |
+            //     SELECT * FROM ( ( ( (SELECT 1) UNION (SELECT 2) ) AS t1 NATURAL JOIN (t2) ) )
+            //                   ^ ^ ^ ^                                                ^
+            //                   | | | |                                                |
+            //                   | | | | /----------------------------------------------|
+            //                   | | | | |  
+            //                   | | | | (5) some db's (snowflake) allow bare table inside parenthesis                                                  
             //                   | | | (4) belongs to a SetExpr::Query inside the subquery
             //                   | | (3) starts a derived table (subquery)
             //                   | (2) starts a nested join
@@ -1788,53 +1825,39 @@ impl Parser {
                     // token following the paren can't start a query (e.g. `foo`
                     // in `FROM (foo NATURAL JOIN bar)`, or when the '(' we've
                     // consumed is followed by another '(' that starts a
-                    // derived table, like (3), or another nested join (2).
-                    //
+                    // derived table, like (3), another nested join (2), and 
+                    // in some db's even just the table name (5).  
                     // Ignore the error and back up to where we were before.
                     // Either we'll be able to parse a valid nested join, or
                     // we won't, and we'll return that error instead.
-                    self.index = index;
-                    let table_and_joins = self.parse_table_and_joins()?;
-                    match table_and_joins.relation {
-                        TableFactor::NestedJoin { .. } => (),
-                        _ => {
-                            if table_and_joins.joins.is_empty() {
-                                // The SQL spec prohibits derived tables and bare
-                                // tables from appearing alone in parentheses.
-                                self.expected("joined table", self.peek_token())?
+                    self.index = index;  
+                    //try parse bare table statement 
+                    match self.parse_table_inside_parenthesis() {
+                        Ok(res) => Ok(res), 
+                        Err(_) => {
+                            //try again to parse join statement
+                            self.index = index;
+                            let table_and_joins = self.parse_table_and_joins()?; 
+                            match table_and_joins.relation {
+                                TableFactor::NestedJoin { .. } => (),
+                                _ => {
+                                    if table_and_joins.joins.is_empty() {
+                                        // The SQL spec prohibits derived 
+                                        // tables from appearing alone in parentheses.
+                                        // bare tables in parentheses handle above as
+                                        // it supported by some database (snowflake).  
+                                        self.expected("joined table", self.peek_token())?
+                                    }
+                                }
                             }
+                            self.expect_token(&Token::RParen)?;
+                            Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
                         }
                     }
-                    self.expect_token(&Token::RParen)?;
-                    Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
                 }
             }
         } else {
-            let name = self.parse_object_name()?;
-            // Postgres, MSSQL: table-valued functions:
-            let args = if self.consume_token(&Token::LParen) {
-                self.parse_optional_args()?
-            } else {
-                vec![]
-            };
-            let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
-            // MSSQL-specific table hints:
-            let mut with_hints = vec![];
-            if self.parse_keyword("WITH") {
-                if self.consume_token(&Token::LParen) {
-                    with_hints = self.parse_comma_separated(Parser::parse_expr)?;
-                    self.expect_token(&Token::RParen)?;
-                } else {
-                    // rewind, as WITH may belong to the next statement's CTE
-                    self.prev_token();
-                }
-            };
-            Ok(TableFactor::Table {
-                name,
-                alias,
-                args,
-                with_hints,
-            })
+            self.parse_table_factor_table() 
         }
     }
 

tests/sqlparser_common.rs

@@ -1806,11 +1806,16 @@ fn parse_join_nesting() {
         vec![join(nest!(nest!(nest!(table("b"), table("c")))))]
     );
 
-    let res = parse_sql_statements("SELECT * FROM (a NATURAL JOIN (b))");
+    let res = parse_sql_statements("SELECT * FROM (a b))");
     assert_eq!(
-        ParserError::ParserError("Expected joined table, found: )".to_string()),
+        ParserError::ParserError("Expected end of statement, found: )".to_string()),
         res.unwrap_err()
     );
+
+    one_statement_parses_to("SELECT * FROM (a)","SELECT * FROM a" );
+
+    one_statement_parses_to("SELECT * FROM (a NATURAL JOIN (b))" , "SELECT * FROM (a NATURAL JOIN b)");
+ 
 }
 
 #[test]