fix pr notes

Author: barsela1

src/dialect/mod.rs

@@ -399,7 +399,8 @@ pub trait Dialect: Debug + Any {
         self.supports_trailing_commas()
     }
 
-    /// Does the dialect support trailing commas in the FROM clause list?
+    /// Returns true if the dialect supports trailing commas in the `FROM` clause of a `SELECT` statement.
+    /// /// Example: `SELECT 1 FROM T, U, LIMIT 1`
     fn supports_from_trailing_commas(&self) -> bool {
         false
     }
@@ -763,9 +764,10 @@ pub trait Dialect: Debug + Any {
         keywords::RESERVED_FOR_IDENTIFIER.contains(&kw)
     }
 
-    // Returns list of keyword allowed after from
-    fn get_reserved_keyword_after_from(&self) -> &[Keyword] {
-        keywords::ALLOWED_KEYWORD_AFTER_FROM
+    // Returns reserved keywords when looking to parse a [TableFactor].
+    /// See [Self::supports_from_trailing_commas]
+    fn get_reserved_keywords_for_table_factor(&self) -> &[Keyword] {
+        keywords::RESERVED_FOR_TABLE_FACTOR
     }
 
     /// Returns true if this dialect supports the `TABLESAMPLE` option

src/keywords.rs

@@ -978,7 +978,7 @@ pub const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[
 // Global list of reserved keywords alloweed after FROM.
 // Parser should call Dialect::get_reserved_keyword_after_from
 // to allow for each dialect to customize the list.
-pub const ALLOWED_KEYWORD_AFTER_FROM: &[Keyword] = &[
+pub const RESERVED_FOR_TABLE_FACTOR: &[Keyword] = &[
     Keyword::INTO,
     Keyword::LIMIT,
     Keyword::HAVING,

src/parser/mod.rs

@@ -3924,7 +3924,7 @@ impl<'a> Parser<'a> {
         self.parse_comma_separated_with_trailing_commas(
             |p| p.parse_select_item(),
             trailing_commas,
-            self.default_reserved_keywords(),
+            None,
         )
     }
 
@@ -3951,14 +3951,14 @@ impl<'a> Parser<'a> {
         Ok(values)
     }
 
-    //Parse a 'FROM' statment. support trailing comma
-    pub fn parse_from(&mut self) -> Result<Vec<TableWithJoins>, ParserError> {
+    //Parse a list of [TableWithJoins]
+    fn parse_table_with_joins(&mut self) -> Result<Vec<TableWithJoins>, ParserError> {
         let trailing_commas = self.dialect.supports_from_trailing_commas();
 
         self.parse_comma_separated_with_trailing_commas(
             Parser::parse_table_and_joins,
             trailing_commas,
-            self.dialect.get_reserved_keyword_after_from(),
+            Some(self.dialect.get_reserved_keywords_for_table_factor()),
         )
     }
 
@@ -3968,8 +3968,9 @@ impl<'a> Parser<'a> {
     fn is_parse_comma_separated_end_with_trailing_commas(
         &mut self,
         trailing_commas: bool,
-        reserved_keywords: &[Keyword],
+        reserved_keywords: Option<&[Keyword]>,
     ) -> bool {
+        let reserved_keywords = reserved_keywords.unwrap_or(keywords::RESERVED_FOR_COLUMN_ALIAS);
         if !self.consume_token(&Token::Comma) {
             true
         } else if trailing_commas {
@@ -3989,26 +3990,15 @@ impl<'a> Parser<'a> {
     /// Parse the comma of a comma-separated syntax element.
     /// Returns true if there is a next element
     fn is_parse_comma_separated_end(&mut self) -> bool {
-        self.is_parse_comma_separated_end_with_trailing_commas(
-            self.options.trailing_commas,
-            self.default_reserved_keywords(),
-        )
-    }
-
-    fn default_reserved_keywords(&self) -> &'static [Keyword] {
-        keywords::RESERVED_FOR_COLUMN_ALIAS
+        self.is_parse_comma_separated_end_with_trailing_commas(self.options.trailing_commas, None)
     }
 
     /// Parse a comma-separated list of 1+ items accepted by `F`
     pub fn parse_comma_separated<T, F>(&mut self, f: F) -> Result<Vec<T>, ParserError>
     where
         F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
     {
-        self.parse_comma_separated_with_trailing_commas(
-            f,
-            self.options.trailing_commas,
-            self.default_reserved_keywords(),
-        )
+        self.parse_comma_separated_with_trailing_commas(f, self.options.trailing_commas, None)
     }
 
     /// Parse a comma-separated list of 1+ items accepted by `F`
@@ -4017,7 +4007,7 @@ impl<'a> Parser<'a> {
         &mut self,
         mut f: F,
         trailing_commas: bool,
-        reserved_keywords: &[Keyword],
+        reserved_keywords: Option<&[Keyword]>,
     ) -> Result<Vec<T>, ParserError>
     where
         F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
@@ -9981,7 +9971,7 @@ impl<'a> Parser<'a> {
         // or `from`.
 
         let from = if self.parse_keyword(Keyword::FROM) {
-            self.parse_from()?
+            self.parse_table_with_joins()?
         } else {
             vec![]
         };

tests/sqlparser_common.rs

@@ -12796,3 +12796,9 @@ fn parse_update_from_before_select() {
         parse_sql_statements(query).unwrap_err()
     );
 }
+
+#[test]
+fn test_trailing_commas_in_from() {
+    let dialects = all_dialects_where(|d| d.supports_from_trailing_commas());
+    dialects.verified_only_select_with_canonical("SELECT 1, 2 FROM t,", "SELECT 1, 2 FROM t");
+}

tests/sqlparser_snowflake.rs

@@ -2484,36 +2484,33 @@ fn test_sf_trailing_commas() {
 }
 
 #[test]
-fn test_sf_trailing_commas_in_from() {
-    snowflake().verified_only_select_with_canonical("SELECT 1, 2 FROM t,", "SELECT 1, 2 FROM t");
-}
-
-#[test]
-fn test_sf_trailing_commas_multiple_sources() {
+fn test_sf_from_trailing_commas() {
     snowflake()
         .verified_only_select_with_canonical("SELECT 1, 2 FROM t1, t2,", "SELECT 1, 2 FROM t1, t2");
-}
 
-#[test]
-fn test_from_trailing_commas_with_limit() {
     let sql = "SELECT a, FROM b, LIMIT 1";
     let _ = snowflake().parse_sql_statements(sql).unwrap();
-}
 
-#[test]
-fn test_sf_trailing_commas_multiple_subqueries() {
+    let sql = "INSERT INTO a SELECT b FROM c,";
+    let _ = snowflake().parse_sql_statements(sql).unwrap();
+
+    let sql = "SELECT a FROM b, HAVING COUNT(*) > 1";
+    let _ = snowflake().parse_sql_statements(sql).unwrap();
+
+    let sql = "SELECT a FROM b, WHERE c = 1";
+    let _ = snowflake().parse_sql_statements(sql).unwrap();
+
+    // nasted
+    let sql = "SELECT 1, 2 FROM (SELECT * FROM t,),";
+    let _ = snowflake().parse_sql_statements(sql).unwrap();
+
+    // multiple_subqueries
     snowflake().verified_only_select_with_canonical(
         "SELECT 1, 2 FROM (SELECT * FROM t1), (SELECT * FROM t2),",
         "SELECT 1, 2 FROM (SELECT * FROM t1), (SELECT * FROM t2)",
     );
 }
 
-#[test]
-fn test_from_with_nested_trailing_commas() {
-    let sql = "SELECT 1, 2 FROM (SELECT * FROM t,),";
-    let _ = snowflake().parse_sql_statements(sql).unwrap();
-}
-
 #[test]
 fn test_select_wildcard_with_ilike() {
     let select = snowflake_and_generic().verified_only_select(r#"SELECT * ILIKE '%id%' FROM tbl"#);