Restrain JSON_TABLE table function parsing to MySqlDialect and AnsiDialect

src/ast/mod.rs

@@ -23,6 +23,7 @@ use core::fmt::{self, Display};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use sqlparser::keywords::{ALL_KEYWORDS, ALL_KEYWORDS_INDEX};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
@@ -54,6 +55,7 @@ pub use self::value::{
 use crate::ast::helpers::stmt_data_loading::{
     DataLoadingOptions, StageLoadSelectItem, StageParamsObject,
 };
+use crate::keywords::Keyword;
 #[cfg(feature = "visitor")]
 pub use visitor::*;
 
@@ -141,6 +143,24 @@ impl Ident {
             quote_style: Some(quote),
         }
     }
+
+    /// If this identifier is also a keyword, return the corresponding [`Keyword`].
+    ///
+    /// For example even though `AVRO` is a keyword, it can also be used as an
+    /// identifier for a column, such as `SELECT avro FROM my_table`.
+    pub fn find_keyword(&self) -> Option<Keyword> {
+        ALL_KEYWORDS
+            .iter()
+            .enumerate()
+            .find_map(|(idx, &kw)| {
+                if kw.to_string().to_uppercase() == self.value.to_uppercase() {
+                    Some(idx)
+                } else {
+                    None
+                }
+            })
+            .map(|idx| ALL_KEYWORDS_INDEX[idx])
+    }
 }
 
 impl From<&str> for Ident {

src/parser/mod.rs

@@ -2771,6 +2771,27 @@
         }
     }
 
+    /// If the current token is the `expected` keyword followed by
+    /// specified tokens, consume them and returns true.
+    /// Otherwise, no tokens are consumed and returns false.
+    pub fn parse_keyword_with_tokens(&mut self, expected: Keyword, tokens: &[Token]) -> bool {
+        match self.peek_token().token {
+            Token::Word(w) if expected == w.keyword => {
+                for (idx, token) in tokens.iter().enumerate() {
+                    if self.peek_nth_token(idx + 1).token != *token {
+                        return false;
+                    }
+                }
+                // consume all tokens
+                for _ in 0..(tokens.len() + 1) {
+                    self.next_token();
+                }
+                true
+            }
+            _ => false,
+        }
+    }
+
     /// If the current and subsequent tokens exactly match the `keywords`
     /// sequence, consume them and returns true. Otherwise, no tokens are
     /// consumed and returns false
@@ -2779,7 +2800,6 @@
         let index = self.index;
         for &keyword in keywords {
             if !self.parse_keyword(keyword) {
-                // println!("parse_keywords aborting .. did not find {:?}", keyword);
                 // reset index and return immediately
                 self.index = index;
                 return false;
@@ -7506,8 +7526,9 @@
                 with_offset,
                 with_offset_alias,
             })
-        } else if self.parse_keyword(Keyword::JSON_TABLE) {
-            self.expect_token(&Token::LParen)?;
+        } else if dialect_of!(self is MySqlDialect | AnsiDialect)
+            && self.parse_keyword_with_tokens(Keyword::JSON_TABLE, &[Token::LParen])
+        {
             let json_expr = self.parse_expr()?;
             self.expect_token(&Token::Comma)?;
             let json_path = self.parse_value()?;
@@ -7524,8 +7545,20 @@
                 alias,
             })
         } else {
+            let loc = self.peek_token().location;
             let name = self.parse_object_name(true)?;
 
+            for ident in &name.0 {
+                if ident.quote_style.is_none() {
+                    if ident.find_keyword().is_some() {
+                        return parser_err!(
+                            "Cannot specify a keyword as identifier for table factor",
+                            loc
+                        );
+                    }
+                }
+            }
+
             let partitions: Vec<Ident> = if dialect_of!(self is MySqlDialect | GenericDialect)
                 && self.parse_keyword(Keyword::PARTITION)
             {

tests/sqlparser_bigquery.rs

@@ -866,13 +866,13 @@ fn parse_table_identifiers() {
         vec![Ident::with_quote('`', "GROUP"), Ident::new("dataField")],
     );
 
-    // TODO: this should be error
-    // test_table_ident_err("GROUP.dataField");
+    test_table_ident_err("GROUP.dataField");
+    test_table_ident_err("abc5.GROUP");
 
     test_table_ident(
-        "abc5.GROUP",
+        "abc5.`GROUP`",
         None,
-        vec![Ident::new("abc5"), Ident::new("GROUP")],
+        vec![Ident::new("abc5"), Ident::with_quote('`', "GROUP")],
     );
 
     test_table_ident(
@@ -1205,7 +1205,7 @@ fn parse_array_agg_func() {
 
 #[test]
 fn test_select_wildcard_with_except() {
-    let select = bigquery_and_generic().verified_only_select("SELECT * EXCEPT (col_a) FROM data");
+    let select = bigquery_and_generic().verified_only_select("SELECT * EXCEPT (col_a) FROM `data`");
     let expected = SelectItem::Wildcard(WildcardAdditionalOptions {
         opt_except: Some(ExceptSelectItem {
             first_element: Ident::new("col_a"),

tests/sqlparser_clickhouse.rs

@@ -356,10 +356,10 @@ fn parse_double_equal() {
 #[test]
 fn parse_limit_by() {
     clickhouse_and_generic().verified_stmt(
-        r#"SELECT * FROM default.last_asset_runs_mv ORDER BY created_at DESC LIMIT 1 BY asset"#,
+        r#"SELECT * FROM `default`.last_asset_runs_mv ORDER BY created_at DESC LIMIT 1 BY asset"#,
     );
     clickhouse_and_generic().verified_stmt(
-        r#"SELECT * FROM default.last_asset_runs_mv ORDER BY created_at DESC LIMIT 1 BY asset, toStartOfDay(created_at)"#,
+        r#"SELECT * FROM `default`.last_asset_runs_mv ORDER BY created_at DESC LIMIT 1 BY asset, toStartOfDay(created_at)"#,
     );
 }
 

tests/sqlparser_common.rs

@@ -8407,3 +8407,25 @@ fn test_buffer_reuse() {
     p.parse_statements().unwrap();
     let _ = p.into_tokens();
 }
+
+#[test]
+fn parse_json_table_function_err() {
+    let unsupported_dialects =
+        all_dialects_except(|d| d.is::<AnsiDialect>() || d.is::<MySqlDialect>());
+
+    // JSON_TABLE table function is not supported in the above dialects.
+    assert!(unsupported_dialects
+        .parse_sql_statements("SELECT * FROM JSON_TABLE('[[1, 2], [3, 4]]', '$[*]' COLUMNS(a INT PATH '$[0]', b INT PATH '$[1]')) AS t")
+        .is_err());
+}
+
+#[test]
+fn parse_json_table_as_identifier() {
+    let parsed = all_dialects().parse_sql_statements("SELECT * FROM json_table");
+    assert_eq!(
+        ParserError::ParserError(
+            "Cannot specify a keyword as identifier for table factor".to_string()
+        ),
+        parsed.unwrap_err()
+    );
+}