Add the option for the parser to try and parse an expression as identifier if the expression parsing fails

Author: yoavcloud

src/ast/mod.rs

@@ -695,6 +695,8 @@ pub enum Expr {
         // https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#formatting_syntax
         format: Option<CastFormat>,
     },
+    /// `DEFAULT` value of a column e.g. INSERT INTO tbl (a, b) VALUES ('foo', DEFAULT)
+    Default,
     /// AT a timestamp to a different timezone e.g. `FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'`
     AtTimeZone {
         timestamp: Box<Expr>,
@@ -1449,6 +1451,7 @@ impl fmt::Display for Expr {
                     write!(f, "{expr}::{data_type}")
                 }
             },
+            Expr::Default => write!(f, "DEFAULT"),
             Expr::Extract {
                 field,
                 syntax,

src/dialect/mod.rs

@@ -681,6 +681,12 @@ pub trait Dialect: Debug + Any {
     fn supports_partiql(&self) -> bool {
         false
     }
+    
+    /// Returns true if the specified keyword is reserved and cannot be
+    /// used as an identifier without special handling like quoting.
+    fn is_reserved_for_identifier(&self, kw: Keyword) -> bool {
+        keywords::RESERVED_FOR_IDENTIFIER.contains(&kw)
+    }
 }
 
 /// This represents the operators for which precedence must be defined

src/dialect/snowflake.rs

@@ -38,6 +38,8 @@ use alloc::vec::Vec;
 #[cfg(not(feature = "std"))]
 use alloc::{format, vec};
 
+use super::keywords::RESERVED_FOR_IDENTIFIER;
+
 /// A [`Dialect`] for [Snowflake](https://www.snowflake.com/)
 #[derive(Debug, Default)]
 pub struct SnowflakeDialect;
@@ -214,6 +216,16 @@ impl Dialect for SnowflakeDialect {
     fn supports_show_like_before_in(&self) -> bool {
         true
     }
+
+    fn is_reserved_for_identifier(&self, kw: Keyword) -> bool {
+        // Unreserve some keywords that Snowflake accepts as identifiers
+        // See: https://docs.snowflake.com/en/sql-reference/reserved-keywords
+        if matches!(kw, Keyword::INTERVAL) {
+            false
+        } else {
+            RESERVED_FOR_IDENTIFIER.contains(&kw)
+        }
+    }
 }
 
 /// Parse snowflake create table statement.

src/keywords.rs

@@ -948,3 +948,13 @@ pub const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[
     Keyword::INTO,
     Keyword::END,
 ];
+
+/// Global list of reserved keywords that cannot be parsed as identifiers
+/// without special handling like quoting. Parser should call `Dialect::is_reserved_for_identifier`
+/// to allow for each dialect to customize the list.
+pub const RESERVED_FOR_IDENTIFIER: &[Keyword] = &[
+    Keyword::EXISTS,
+    Keyword::INTERVAL,
+    Keyword::STRUCT,
+    Keyword::TRIM,
+];

src/parser/mod.rs

@@ -1749,10 +1749,7 @@ fn parse_merge() {
                             columns: vec![Ident::new("a"), Ident::new("b"),],
                             kind: MergeInsertKind::Values(Values {
                                 explicit_row: false,
-                                rows: vec![vec![
-                                    Expr::Value(number("1")),
-                                    Expr::Identifier(Ident::new("DEFAULT")),
-                                ]]
+                                rows: vec![vec![Expr::Value(number("1")), Expr::Default,]]
                             })
                         })
                     },
@@ -1763,10 +1760,7 @@ fn parse_merge() {
                             columns: vec![],
                             kind: MergeInsertKind::Values(Values {
                                 explicit_row: false,
-                                rows: vec![vec![
-                                    Expr::Value(number("1")),
-                                    Expr::Identifier(Ident::new("DEFAULT")),
-                                ]]
+                                rows: vec![vec![Expr::Value(number("1")), Expr::Default,]]
                             })
                         })
                     },

tests/sqlparser_bigquery.rs

@@ -34,7 +34,7 @@ use sqlparser::dialect::{
     GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, RedshiftSqlDialect,
     SQLiteDialect, SnowflakeDialect,
 };
-use sqlparser::keywords::ALL_KEYWORDS;
+use sqlparser::keywords::{Keyword, ALL_KEYWORDS};
 use sqlparser::parser::{Parser, ParserError, ParserOptions};
 use sqlparser::tokenizer::Tokenizer;
 use test_utils::{
@@ -5112,7 +5112,9 @@ fn parse_interval_dont_require_unit() {
 
 #[test]
 fn parse_interval_require_unit() {
-    let dialects = all_dialects_where(|d| d.require_interval_qualifier());
+    let dialects = all_dialects_where(|d| {
+        d.require_interval_qualifier() && d.is_reserved_for_identifier(Keyword::INTERVAL)
+    });
 
     let sql = "SELECT INTERVAL '1 DAY'";
     let err = dialects.parse_sql_statements(sql).unwrap_err();

tests/sqlparser_common.rs

@@ -1352,10 +1352,7 @@ fn parse_set() {
             local: false,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName(vec![Ident::new("a")])),
-            value: vec![Expr::Identifier(Ident {
-                value: "DEFAULT".into(),
-                quote_style: None
-            })],
+            value: vec![Expr::Default],
         }
     );
 
@@ -4229,10 +4226,7 @@ fn test_simple_postgres_insert_with_alias() {
                 body: Box::new(SetExpr::Values(Values {
                     explicit_row: false,
                     rows: vec![vec![
-                        Expr::Identifier(Ident {
-                            value: "DEFAULT".to_string(),
-                            quote_style: None
-                        }),
+                        Expr::Default,
                         Expr::Value(Value::Number("123".to_string(), false))
                     ]]
                 })),
@@ -4363,10 +4357,7 @@ fn test_simple_insert_with_quoted_alias() {
                 body: Box::new(SetExpr::Values(Values {
                     explicit_row: false,
                     rows: vec![vec![
-                        Expr::Identifier(Ident {
-                            value: "DEFAULT".to_string(),
-                            quote_style: None
-                        }),
+                        Expr::Default,
                         Expr::Value(Value::SingleQuotedString("0123".to_string()))
                     ]]
                 })),