support the single table in parnes with alias in snowflake by dialect

Author: eyalsatori

src/parser.rs

@@ -2116,14 +2116,58 @@ impl<'a> Parser<'a> {
             // recently consumed does not start a derived table (cases 1, 2, or 4).
             // `maybe_parse` will ignore such an error and rewind to be after the opening '('.
 
-            // Inside the parentheses we expect to find a table factor
-            // 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)))
+            // Inside the parentheses we expect to find an (A) table factor
+            // followed by some joins or (B) another level of nesting.
+            let mut table_and_joins = self.parse_table_and_joins()?;
+
+            if !table_and_joins.joins.is_empty() {
+                self.expect_token(&Token::RParen)?;
+                Ok(TableFactor::NestedJoin(Box::new(table_and_joins))) // (A)
+            } else if let TableFactor::NestedJoin(_) = &table_and_joins.relation {
+                // (B): `table_and_joins` (what we found inside the parentheses)
+                // is a nested join `(foo JOIN bar)`, not followed by other joins.
+                self.expect_token(&Token::RParen)?;
+                Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
+            } else if dialect_of!(self is SnowflakeDialect) {
+                // Dialect-specific behavior: Snowflake diverges from the
+                // standard and most of other implementations by allowing
+                // extra parentheses not only around a join (B), but around
+                // lone table names (e.g. `FROM (mytable [AS alias])`) and
+                // around derived tables (e.g. `FROM ((SELECT ...) [AS alias])`
+                // as well.
+                self.expect_token(&Token::RParen)?;
+
+                if let Some(outer_alias) =
+                    self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?
+                {
+                    // Snowflake also allows specifying an alias *after* parens
+                    // e.g. `FROM (mytable) AS alias`
+                    match &mut table_and_joins.relation {
+                        TableFactor::Derived { alias, .. }
+                        | TableFactor::Table { alias, .. }
+                        | TableFactor::TableFunction { alias, .. } => {
+                            // but not `FROM (mytable AS alias1) AS alias2`.
+                            if let Some(inner_alias) = alias {
+                                return Err(ParserError::ParserError(format!(
+                                    "duplicate alias {}",
+                                    inner_alias
+                                )));
+                            }
+                            // Act as if the alias was specified normally next
+                            // to the table name: `(mytable) AS alias` ->
+                            // `(mytable AS alias)`
+                            alias.replace(outer_alias);
+                        }
+                        TableFactor::NestedJoin(_) => unreachable!(),
+                    };
+                }
+                // Do not store the extra set of parens in the AST
+                Ok(table_and_joins.relation)
+            } else {
+                // The SQL spec prohibits derived tables and bare tables from
+                // appearing alone in parentheses (e.g. `FROM (mytable)`)
+                self.expected("joined table", self.peek_token())
+            }
         } else {
             let name = self.parse_object_name()?;
             // Postgres, MSSQL: table-valued functions:

tests/sqlparser_common.rs

@@ -17,6 +17,14 @@
 //! that 1) it's either standard or widely supported and 2) it can be parsed by
 //! sqlparser regardless of the chosen dialect (i.e. it doesn't conflict with
 //! dialect-specific parsing rules).
+//!
+//!
+
+#[macro_use]
+#[path = "utils/mod.rs"]
+mod utils;
+
+use utils::*;
 
 use matches::assert_matches;
 
@@ -2282,75 +2290,48 @@ fn parse_complex_join() {
 
 #[test]
 fn parse_join_nesting() {
-    fn table(name: impl Into<String>) -> TableFactor {
-        TableFactor::Table {
-            name: ObjectName(vec![Ident::new(name.into())]),
-            alias: None,
-            args: vec![],
-            with_hints: vec![],
-        }
-    }
-
-    fn join(relation: TableFactor) -> Join {
-        Join {
-            relation,
-            join_operator: JoinOperator::Inner(JoinConstraint::Natural),
-        }
-    }
-
-    macro_rules! nest {
-        ($base:expr $(, $join:expr)*) => {
-            TableFactor::NestedJoin(Box::new(TableWithJoins {
-                relation: $base,
-                joins: vec![$(join($join)),*]
-            }))
-        };
-    }
-
     let sql = "SELECT * FROM a NATURAL JOIN (b NATURAL JOIN (c NATURAL JOIN d NATURAL JOIN e)) \
                NATURAL JOIN (f NATURAL JOIN (g NATURAL JOIN h))";
     assert_eq!(
         only(&verified_only_select(sql).from).joins,
         vec![
-            join(nest!(table("b"), nest!(table("c"), table("d"), table("e")))),
-            join(nest!(table("f"), nest!(table("g"), table("h"))))
+            join(nest!(
+                table("b", None),
+                nest!(table("c", None), table("d", None), table("e", None))
+            )),
+            join(nest!(
+                table("f", None),
+                nest!(table("g", None), table("h", None))
+            ))
         ],
     );
 
     let sql = "SELECT * FROM (a NATURAL JOIN b) NATURAL JOIN c";
     let select = verified_only_select(sql);
     let from = only(select.from);
-    assert_eq!(from.relation, nest!(table("a"), table("b")));
-    assert_eq!(from.joins, vec![join(table("c"))]);
+    assert_eq!(from.relation, nest!(table("a", None), table("b", None)));
+    assert_eq!(from.joins, vec![join(table("c", None))]);
 
     let sql = "SELECT * FROM (((a NATURAL JOIN b)))";
     let select = verified_only_select(sql);
     let from = only(select.from);
-    assert_eq!(from.relation, nest!(nest!(nest!(table("a"), table("b")))));
+    assert_eq!(
+        from.relation,
+        nest!(nest!(nest!(table("a", None), table("b", None))))
+    );
     assert_eq!(from.joins, vec![]);
 
     let sql = "SELECT * FROM a NATURAL JOIN (((b NATURAL JOIN c)))";
     let select = verified_only_select(sql);
     let from = only(select.from);
-    assert_eq!(from.relation, table("a"));
+    assert_eq!(from.relation, table("a", None));
     assert_eq!(
         from.joins,
-        vec![join(nest!(nest!(nest!(table("b"), table("c")))))]
+        vec![join(nest!(nest!(nest!(
+            table("b", None),
+            table("c", None)
+        ))))]
     );
-
-    // 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")))));
 }
 
 #[test]
@@ -2492,26 +2473,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]

tests/sqlparser_snowflake.rs

@@ -9,9 +9,26 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
+#[macro_use]
+#[path = "utils/mod.rs"]
+mod utils;
+
 use sqlparser::ast::*;
 use sqlparser::dialect::{GenericDialect, SnowflakeDialect};
+use sqlparser::parser::ParserError;
 use sqlparser::test_utils::*;
+use utils::*;
+
+fn table_alias(alias: &str) -> TableAlias {
+    TableAlias {
+        name: Ident {
+            value: alias.to_owned(),
+            quote_style: None,
+        },
+        columns: Vec::new(),
+    }
+}
 
 #[test]
 fn test_snowflake_create_table() {
@@ -24,6 +41,120 @@ fn test_snowflake_create_table() {
     }
 }
 
+fn get_from_section_from_select_query(query: &str) -> Vec<TableWithJoins> {
+    let statement = snowflake().parse_sql_statements(query).unwrap()[0].clone();
+
+    let query = match statement {
+        Statement::Query(query) => query,
+        _ => panic!("Not a query"),
+    };
+
+    let select = match query.body {
+        SetExpr::Select(select) => select,
+        _ => panic!("not a select query"),
+    };
+
+    select.from.clone()
+}
+
+#[test]
+fn test_sf_derives_single_table_in_parenthesis() {
+    let from = get_from_section_from_select_query("SELECT * FROM (((SELECT 1) AS t))");
+
+    assert_eq!(
+        from[0].relation,
+        TableFactor::Derived {
+            lateral: false,
+            subquery: Box::new(snowflake().verified_query("SELECT 1")),
+            alias: Some(TableAlias {
+                name: "t".into(),
+                columns: vec![],
+            })
+        }
+    );
+}
+
+#[test]
+fn test_single_table_in_parenthesis() {
+    //Parenthesized table names are non-standard, but supported in Snowflake SQL
+    let from = get_from_section_from_select_query("SELECT * FROM (a NATURAL JOIN (b))");
+
+    assert_eq!(from[0].relation, nest!(table("a", None), table("b", None)));
+
+    let from = get_from_section_from_select_query("SELECT * FROM (a NATURAL JOIN ((b)))");
+    assert_eq!(from[0].relation, nest!(table("a", None), table("b", None)));
+}
+
+#[test]
+fn test_single_table_in_parenthesis_with_alias() {
+    let sql = "SELECT * FROM (a NATURAL JOIN (b) c )";
+    let table_with_joins = get_from_section_from_select_query(sql)[0].clone();
+    assert_eq!(
+        table_with_joins.relation,
+        nest!(table("a", None), table("b", Some(table_alias("c"))))
+    );
+
+    let sql = "SELECT * FROM (a NATURAL JOIN ((b)) c )";
+    let table_with_joins = get_from_section_from_select_query(sql)[0].clone();
+    assert_eq!(
+        table_with_joins.relation,
+        nest!(table("a", None), table("b", Some(table_alias("c"))))
+    );
+
+    let sql = "SELECT * FROM (a NATURAL JOIN ( (b) c ) )";
+    let table_with_joins = get_from_section_from_select_query(sql)[0].clone();
+    assert_eq!(
+        table_with_joins.relation,
+        nest!(table("a", None), table("b", Some(table_alias("c"))))
+    );
+
+    let sql = "SELECT * FROM (a NATURAL JOIN ( (b) as c ) )";
+    let table_with_joins = get_from_section_from_select_query(sql)[0].clone();
+    assert_eq!(
+        table_with_joins.relation,
+        nest!(table("a", None), table("b", Some(table_alias("c"))))
+    );
+
+    let sql = "SELECT * FROM (a alias1 NATURAL JOIN ( (b) c ) )";
+    let table_with_joins = get_from_section_from_select_query(sql)[0].clone();
+    assert_eq!(
+        table_with_joins.relation,
+        nest!(
+            table("a", Some(table_alias("alias1"))),
+            table("b", Some(table_alias("c")))
+        )
+    );
+
+    let sql = "SELECT * FROM (a as alias1 NATURAL JOIN ( (b) as c ) )";
+    let table_with_joins = get_from_section_from_select_query(sql)[0].clone();
+    assert_eq!(
+        table_with_joins.relation,
+        nest!(
+            table("a", Some(table_alias("alias1"))),
+            table("b", Some(table_alias("c")))
+        )
+    );
+
+    let res = snowflake().parse_sql_statements("SELECT * FROM (a NATURAL JOIN b) c");
+    assert_eq!(
+        ParserError::ParserError("Expected end of statement, found: c".to_string()),
+        res.unwrap_err()
+    );
+
+    let res = snowflake().parse_sql_statements("SELECT * FROM (a b) c");
+    assert_eq!(
+        ParserError::ParserError("duplicate alias b".to_string()),
+        res.unwrap_err()
+    );
+}
+
+fn snowflake() -> TestedDialects {
+    TestedDialects {
+        // we don't have a separate SQLite dialect, so test only the generic dialect for now
+        dialects: vec![Box::new(SnowflakeDialect {})],
+    }
+}
+
 fn snowflake_and_generic() -> TestedDialects {
     TestedDialects {
         dialects: vec![Box::new(SnowflakeDialect {}), Box::new(GenericDialect {})],

tests/utils/mod.rs

@@ -0,0 +1,38 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use sqlparser::ast::*;
+
+pub fn table(name: impl Into<String>, alias: Option<TableAlias>) -> TableFactor {
+    TableFactor::Table {
+        name: ObjectName(vec![Ident::new(name.into())]),
+        alias,
+        args: vec![],
+        with_hints: vec![],
+    }
+}
+
+pub fn join(relation: TableFactor) -> Join {
+    Join {
+        relation,
+        join_operator: JoinOperator::Inner(JoinConstraint::Natural),
+    }
+}
+
+macro_rules! nest {
+    ($base:expr $(, $join:expr)*) => {
+        TableFactor::NestedJoin(Box::new(TableWithJoins {
+            relation: $base,
+            joins: vec![$(join($join)),*]
+        }))
+    };
+}