Use dialects in the parser for support snowflake uninque parenthesis syntax

Snowflake DB allow single table to be within parenthesis.
This behaviour is diffrent than other DB ,
and it has some impact on the parsing table factor.

For supporting we do the following :
1. Add refrence to the dialect in the parser
2. Add Snowflake dialect
3. add function to the dialect trait the identify if single table inside parenthesis allowed
4. When parsing table factor in the allow/deny single table inside parenthesis according to dialect

Author: eyalsatori

src/dialect/mod.rs

@@ -16,14 +16,15 @@ pub mod keywords;
 mod mssql;
 mod mysql;
 mod postgresql;
-
+mod snowflake;
 use std::fmt::Debug;
 
 pub use self::ansi::AnsiDialect;
 pub use self::generic::GenericDialect;
 pub use self::mssql::MsSqlDialect;
 pub use self::mysql::MySqlDialect;
 pub use self::postgresql::PostgreSqlDialect;
+pub use self::snowflake::SnowflakeDialect;
 
 pub trait Dialect: Debug {
     /// Determine if a character starts a quoted identifier. The default
@@ -38,4 +39,8 @@ pub trait Dialect: Debug {
     fn is_identifier_start(&self, ch: char) -> bool;
     /// Determine if a character is a valid unquoted identifier character
     fn is_identifier_part(&self, ch: char) -> bool;
+
+    fn alllow_single_table_in_parenthesis(&self) -> bool {
+        false
+    }
 }

src/dialect/snowflake.rs

@@ -0,0 +1,26 @@
+use crate::dialect::Dialect;
+
+#[derive(Debug, Default)]
+pub struct SnowflakeDialect;
+
+impl Dialect for SnowflakeDialect {
+    //Revisit: currently copied from Genric dialect
+    fn is_identifier_start(&self, ch: char) -> bool {
+        (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch == '#' || ch == '@'
+    }
+
+    //Revisit: currently copied from Genric dialect
+    fn is_identifier_part(&self, ch: char) -> bool {
+        (ch >= 'a' && ch <= 'z')
+            || (ch >= 'A' && ch <= 'Z')
+            || (ch >= '0' && ch <= '9')
+            || ch == '@'
+            || ch == '$'
+            || ch == '#'
+            || ch == '_'
+    }
+
+    fn alllow_single_table_in_parenthesis(&self) -> bool {
+        true
+    }
+}

src/parser.rs

@@ -83,23 +83,28 @@ impl fmt::Display for ParserError {
 impl Error for ParserError {}
 
 /// SQL Parser
-pub struct Parser {
+pub struct Parser<'a> {
     tokens: Vec<Token>,
     /// The index of the first unprocessed token in `self.tokens`
     index: usize,
+    dialect: &'a dyn Dialect,
 }
 
-impl Parser {
+impl<'a> Parser<'a> {
     /// Parse the specified tokens
-    pub fn new(tokens: Vec<Token>) -> Self {
-        Parser { tokens, index: 0 }
+    pub fn new(tokens: Vec<Token>, dialect: &'a dyn Dialect) -> Self {
+        Parser {
+            tokens,
+            index: 0,
+            dialect,
+        }
     }
 
     /// Parse a SQL statement and produce an Abstract Syntax Tree (AST)
     pub fn parse_sql(dialect: &dyn Dialect, sql: &str) -> Result<Vec<Statement>, ParserError> {
         let mut tokenizer = Tokenizer::new(dialect, &sql);
         let tokens = tokenizer.tokenize()?;
-        let mut parser = Parser::new(tokens);
+        let mut parser = Parser::new(tokens, dialect);
         let mut stmts = Vec::new();
         let mut expecting_statement_delimiter = false;
         debug!("Parsing sql '{}'...", sql);
@@ -950,7 +955,7 @@ impl Parser {
     /// Parse a comma-separated list of 1+ items accepted by `F`
     pub fn parse_comma_separated<T, F>(&mut self, mut f: F) -> Result<Vec<T>, ParserError>
     where
-        F: FnMut(&mut Parser) -> Result<T, ParserError>,
+        F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
     {
         let mut values = vec![];
         loop {
@@ -2056,9 +2061,91 @@ impl Parser {
             };
             joins.push(join);
         }
+
         Ok(TableWithJoins { relation, joins })
     }
 
+    fn add_alias_to_single_table_in_parenthesis(
+        &self,
+        table_facor: TableFactor,
+        consumed_alias: TableAlias,
+    ) -> Result<TableFactor, ParserError> {
+        match table_facor {
+            // Add the alias to dervied table
+            TableFactor::Derived {
+                lateral,
+                subquery,
+                alias,
+            } => match alias {
+                None => Ok(TableFactor::Derived {
+                    lateral,
+                    subquery,
+                    alias: Some(consumed_alias),
+                }),
+                // "Select * from (table1 as alias1) as alias1" - it prohabited
+                Some(alias) => Err(ParserError::ParserError(format!(
+                    "duplicate alias {}",
+                    alias
+                ))),
+            },
+            // Add The alias to the table
+            TableFactor::Table {
+                name,
+                alias,
+                args,
+                with_hints,
+            } => match alias {
+                None => Ok(TableFactor::Table {
+                    name,
+                    alias: Some(consumed_alias),
+                    args,
+                    with_hints,
+                }),
+                // "Select * from (table1 as alias1) as alias1" - it prohabited
+                Some(alias) => Err(ParserError::ParserError(format!(
+                    "duplicate alias {}",
+                    alias
+                ))),
+            },
+            TableFactor::NestedJoin(_) => Err(ParserError::ParserError(
+                "aliasing joins is not allowed".to_owned(),
+            )),
+        }
+    }
+
+    fn remove_redundent_parenthesis(
+        &mut self,
+        table_and_joins: TableWithJoins,
+    ) -> Result<TableFactor, ParserError> {
+        let table_factor = table_and_joins.relation;
+
+        // check if we have alias after the parenthesis
+        let alias = match self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)? {
+            None => {
+                return Ok(table_factor);
+            }
+            Some(alias) => alias,
+        };
+
+        // if we have alias, we attached it to the single table that inside parenthesis
+        self.add_alias_to_single_table_in_parenthesis(table_factor, alias)
+    }
+
+    fn validate_nested_join(&self, table_and_joins: &TableWithJoins) -> Result<(), ParserError> {
+        match table_and_joins.relation {
+            TableFactor::NestedJoin { .. } => (),
+            _ => {
+                if table_and_joins.joins.is_empty() {
+                    // validate thats indeed join and not dervied
+                    // or nested table
+                    self.expected("joined table", self.peek_token())?
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     /// 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(Keyword::LATERAL) {
@@ -2102,10 +2189,28 @@ impl Parser {
             // followed by some joins or another level of nesting.
             let table_and_joins = self.parse_table_and_joins()?;
             self.expect_token(&Token::RParen)?;
+
             // The SQL spec prohibits derived and bare tables from appearing
-            // alone in parentheses. We don't enforce this as some databases
-            // (e.g. Snowflake) allow such syntax.
-            Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
+            // alone in parentheses. But as some databases
+            // (e.g. Snowflake) allow such syntax - it's can be allowed
+            // for specfic dialect.
+            if self.dialect.alllow_single_table_in_parenthesis() {
+                if table_and_joins.joins.is_empty() {
+                    // In case the DB's like snowflake that allowed single dervied or bare
+                    // table in parenthesis (for example : `Select * from (a) as b` )
+                    // the parser will parse it as Nested join, but if it's actually a single table
+                    // we don't want to treat such case as join , because we don't actually join
+                    // any tables.
+                    let table_factor = self.remove_redundent_parenthesis(table_and_joins)?;
+                    Ok(table_factor)
+                } else {
+                    Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
+                }
+            } else {
+                // Defualt behaviuor
+                self.validate_nested_join(&table_and_joins)?;
+                Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
+            }
         } else {
             let name = self.parse_object_name()?;
             // Postgres, MSSQL: table-valued functions:

src/test_utils.rs

@@ -53,7 +53,7 @@ impl TestedDialects {
         self.one_of_identical_results(|dialect| {
             let mut tokenizer = Tokenizer::new(dialect, sql);
             let tokens = tokenizer.tokenize().unwrap();
-            f(&mut Parser::new(tokens))
+            f(&mut Parser::new(tokens, dialect))
         })
     }
 
@@ -104,7 +104,9 @@ impl TestedDialects {
     /// Ensures that `sql` parses as an expression, and is not modified
     /// after a serialization round-trip.
     pub fn verified_expr(&self, sql: &str) -> Expr {
-        let ast = self.run_parser_method(sql, Parser::parse_expr).unwrap();
+        let ast = self
+            .run_parser_method(sql, |parser| parser.parse_expr())
+            .unwrap();
         assert_eq!(sql, &ast.to_string(), "round-tripping without changes");
         ast
     }

tests/sqlparser_common.rs

@@ -22,7 +22,7 @@ use matches::assert_matches;
 
 use sqlparser::ast::*;
 use sqlparser::dialect::keywords::ALL_KEYWORDS;
-use sqlparser::parser::{Parser, ParserError};
+use sqlparser::parser::ParserError;
 use sqlparser::test_utils::{all_dialects, expr_from_projection, number, only};
 
 #[test]
@@ -147,13 +147,14 @@ fn parse_update() {
 
 #[test]
 fn parse_invalid_table_name() {
-    let ast = all_dialects().run_parser_method("db.public..customer", Parser::parse_object_name);
+    let ast = all_dialects()
+        .run_parser_method("db.public..customer", |parser| parser.parse_object_name());
     assert!(ast.is_err());
 }
 
 #[test]
 fn parse_no_table_name() {
-    let ast = all_dialects().run_parser_method("", Parser::parse_object_name);
+    let ast = all_dialects().run_parser_method("", |parser| parser.parse_object_name());
     assert!(ast.is_err());
 }
 
@@ -2273,19 +2274,12 @@ fn parse_join_nesting() {
         vec![join(nest!(nest!(nest!(table("b"), table("c")))))]
     );
 
-    // Parenthesized table names are non-standard, but supported in Snowflake SQL
-    let sql = "SELECT * FROM (a NATURAL JOIN (b))";
-    let select = verified_only_select(sql);
-    let from = only(select.from);
-
-    assert_eq!(from.relation, nest!(table("a"), nest!(table("b"))));
-
-    // Double parentheses around table names are non-standard, but supported in Snowflake SQL
-    let sql = "SELECT * FROM (a NATURAL JOIN ((b)))";
-    let select = verified_only_select(sql);
-    let from = only(select.from);
-
-    assert_eq!(from.relation, nest!(table("a"), nest!(nest!(table("b")))));
+    // Nesting a subquery in parentheses is non-standard, but supported in Snowflake SQL
+    let res = parse_sql_statements("SELECT * FROM ((SELECT 1) AS t)");
+    assert_eq!(
+        ParserError::ParserError("Expected joined table, found: EOF".to_string()),
+        res.unwrap_err()
+    );
 }
 
 #[test]
@@ -2427,26 +2421,6 @@ fn parse_derived_tables() {
             }],
         }))
     );
-
-    // Nesting a subquery in parentheses is non-standard, but supported in Snowflake SQL
-    let sql = "SELECT * FROM ((SELECT 1) AS t)";
-    let select = verified_only_select(sql);
-    let from = only(select.from);
-
-    assert_eq!(
-        from.relation,
-        TableFactor::NestedJoin(Box::new(TableWithJoins {
-            relation: TableFactor::Derived {
-                lateral: false,
-                subquery: Box::new(verified_query("SELECT 1")),
-                alias: Some(TableAlias {
-                    name: "t".into(),
-                    columns: vec![],
-                })
-            },
-            joins: Vec::new(),
-        }))
-    );
 }
 
 #[test]