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 {
@@ -2054,9 +2059,113 @@ impl Parser {
             };
             joins.push(join);
         }
+
         Ok(TableWithJoins { relation, joins })
     }
 
+    fn add_alias_to_single_table_in_parenthesis(
+        &self,
+        table_and_joins: TableWithJoins,
+        consumed_alias: TableAlias,
+    ) -> Result<TableWithJoins, ParserError> {
+        // This function deal with alias after single table in parenthesis
+        // aliases not allow in joining between multiple tables (At least in snowflake DB)
+        if !table_and_joins.joins.is_empty() {
+            return Err(ParserError::ParserError(
+                "alias not allowed on multiple table join".to_owned(),
+            ));
+        }
+
+        match table_and_joins.relation {
+            // If the realation is Nested join - we will seep the alias
+            // into the nested table, it's resonable as it's based
+            // on the assumation that aliasing not allowed on join between
+            // 2 diffrent tables - so the alias accutaly belong to the inner table
+            TableFactor::NestedJoin(table_and_joins_box) => Ok(TableWithJoins {
+                relation: TableFactor::NestedJoin(Box::new(
+                    self.add_alias_to_single_table_in_parenthesis(
+                        *table_and_joins_box,
+                        consumed_alias,
+                    )?,
+                )),
+                joins: Vec::new(),
+            }),
+            // Add the alias to dervied table
+            TableFactor::Derived {
+                lateral,
+                subquery,
+                alias,
+            } => match alias {
+                None => Ok(TableWithJoins {
+                    relation: TableFactor::Derived {
+                        lateral,
+                        subquery,
+                        alias: Some(consumed_alias),
+                    },
+                    joins: Vec::new(),
+                }),
+                // "Select * from (table1 as alias1) as alias1" - it prohabited
+                Some(alias) => Err(ParserError::ParserError(format!(
+                    "duplicate alias {}",
+                    alias
+                ))),
+            },
+            // Add The alias to the table factor
+            TableFactor::Table {
+                name,
+                alias,
+                args,
+                with_hints,
+            } => match alias {
+                None => Ok(TableWithJoins {
+                    relation: TableFactor::Table {
+                        name,
+                        alias: Some(consumed_alias),
+                        args,
+                        with_hints,
+                    },
+                    joins: Vec::new(),
+                }),
+                // "Select * from (table1 as alias1) as alias1" - it prohabited
+                Some(alias) => Err(ParserError::ParserError(format!(
+                    "duplicate alias {}",
+                    alias
+                ))),
+            },
+        }
+    }
+
+    fn check_for_alias_after_parenthesis(
+        &mut self,
+        table_and_joins: TableWithJoins,
+    ) -> Result<TableWithJoins, ParserError> {
+        // Try to parse alias if there is no alias - just return the TableWithJoins as is .
+        let alias = match self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)? {
+            None => {
+                return Ok(table_and_joins);
+            }
+            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_and_joins, 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) {
@@ -2100,10 +2209,21 @@ 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() {
+                // In case of single dervied or bare table in parenthesis,
+                // the alias could appears also after the parenthesis
+                let table_and_joins = self.check_for_alias_after_parenthesis(table_and_joins)?;
+                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]