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,21 @@ impl Ident {
             quote_style: Some(quote),
         }
     }
+
+    /// Returns the defined `Keyword` enum for this identifier if it is a keyword.
+    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 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// If the current token is the `expected` keyword followed by
+    /// specified tokens, and 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 {
+        let index = self.index;
+        match self.peek_token().token {
+            Token::Word(w) if expected == w.keyword => {
+                self.next_token();
+                for token in tokens {
+                    if !self.consume_token(token) {
+                        // reset index and return immediately
+                        self.index = index;
+                        return false;
+                    }
+                }
+                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
@@ -7506,8 +7527,9 @@ impl<'a> Parser<'a> {
                 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 +7546,20 @@ impl<'a> Parser<'a> {
                 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_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()
+    );
+}