Disallow keywords as table aliases for parsing statements without semicolons

Author: aharpervc

src/dialect/mod.rs

@@ -1028,8 +1028,14 @@ pub trait Dialect: Debug + Any {
     /// Returns true if the specified keyword should be parsed as a table factor alias.
     /// When explicit is true, the keyword is preceded by an `AS` word. Parser is provided
     /// to enable looking ahead if needed.
-    fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
-        explicit || self.is_table_alias(kw, parser)
+    ///
+    /// When the dialect supports statements without semicolon delimiter, actual keywords aren't parsed as aliases.
+    fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, _parser: &mut Parser) -> bool {
+        if self.supports_statements_without_semicolon_delimiter() {
+            kw == &Keyword::NoKeyword
+        } else {
+            explicit || self.is_table_alias(kw, _parser)
+        }
     }
 
     /// Returns true if this dialect supports querying historical table data

tests/sqlparser_common.rs

@@ -668,6 +668,28 @@ fn parse_select_with_table_alias() {
     );
 }
 
+#[test]
+fn parse_select_with_table_alias_keyword() {
+    // note: DECLARE isn't included in RESERVED_FOR_TABLE_ALIAS
+    let table_alias_non_reserved_keyword = "SELECT a FROM lineitem DECLARE";
+    let statements = all_dialects_requiring_semicolon_statement_delimiter()
+        .parse_sql_statements(table_alias_non_reserved_keyword)
+        .unwrap();
+    assert_eq!(1, statements.len());
+    assert_eq!(
+        ParserError::ParserError("Expected: identifier, found: EOF".to_string()),
+        all_dialects_not_requiring_semicolon_statement_delimiter()
+            .parse_sql_statements(table_alias_non_reserved_keyword)
+            .unwrap_err()
+    );
+
+    let table_alias_quoted_keyword = "SELECT a FROM lineitem \"DECLARE\"";
+    let statements = all_dialects()
+        .parse_sql_statements(table_alias_quoted_keyword)
+        .unwrap();
+    assert_eq!(1, statements.len());
+}
+
 #[test]
 fn parse_consecutive_queries() {
     let select_then_exec = "SELECT * FROM deleted; EXECUTE my_sp 'some', 'params'";
@@ -951,7 +973,18 @@ fn parse_limit() {
 
 #[test]
 fn parse_invalid_limit_by() {
-    assert_err_parse_statements("SELECT * FROM user BY name", "name");
+    assert_eq!(
+        ParserError::ParserError("Expected: end of statement, found: name".to_string()),
+        all_dialects_requiring_semicolon_statement_delimiter()
+            .parse_sql_statements("SELECT * FROM user BY name")
+            .unwrap_err()
+    );
+    assert_eq!(
+        ParserError::ParserError("Expected: an SQL statement, found: BY".to_string()),
+        all_dialects_not_requiring_semicolon_statement_delimiter()
+            .parse_sql_statements("SELECT * FROM user BY name")
+            .unwrap_err()
+    );
 }
 
 #[test]
@@ -11029,7 +11062,9 @@ fn parse_select_table_with_index_hints() {
 
     // Test that dialects that don't support table hints will keep parsing the USE as table alias
     let sql = "SELECT * FROM T USE LIMIT 1";
-    let unsupported_dialects = all_dialects_where(|d| !d.supports_table_hints());
+    let unsupported_dialects = all_dialects_where(|d| {
+        !d.supports_table_hints() && !d.supports_statements_without_semicolon_delimiter()
+    });
     let select = unsupported_dialects
         .verified_only_select_with_canonical(sql, "SELECT * FROM T AS USE LIMIT 1");
     assert_eq!(