SGA-11419 Added snowflake ability for if not exists after create view, also added ability to write view name before if not exists in snowflake as it is implemented, replaced dialect of with trait functions

Author: etgarperets

src/ast/mod.rs

@@ -3263,6 +3263,8 @@ pub enum Statement {
         materialized: bool,
         /// View name
         name: ObjectName,
+        // Name IF NOT EXIST instead of IF NOT EXIST name
+        name_before_not_exists: bool,
         columns: Vec<ViewColumnDef>,
         query: Box<Query>,
         options: CreateTableOptions,
@@ -4962,6 +4964,7 @@ impl fmt::Display for Statement {
                 temporary,
                 to,
                 params,
+                name_before_not_exists,
             } => {
                 write!(
                     f,
@@ -4974,11 +4977,18 @@ impl fmt::Display for Statement {
                 }
                 write!(
                     f,
-                    "{materialized}{temporary}VIEW {if_not_exists}{name}{to}",
+                    "{materialized}{temporary}VIEW {if_not_and_name}{to}",
+                    if_not_and_name = if *if_not_exists {
+                        if *name_before_not_exists {
+                            format!("{name} IF NOT EXISTS")
+                        } else {
+                            format!("IF NOT EXISTS {name}")
+                        }
+                    } else {
+                        format!("{name}")
+                    },
                     materialized = if *materialized { "MATERIALIZED " } else { "" },
-                    name = name,
                     temporary = if *temporary { "TEMPORARY " } else { "" },
-                    if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" },
                     to = to
                         .as_ref()
                         .map(|to| format!(" TO {to}"))

src/ast/spans.rs

@@ -400,6 +400,7 @@ impl Spanned for Statement {
                 if_not_exists: _,
                 temporary: _,
                 to,
+                name_before_not_exists: _,
                 params: _,
             } => union_spans(
                 core::iter::once(name.span())

src/dialect/bigquery.rs

@@ -108,6 +108,11 @@ impl Dialect for BigQueryDialect {
         true
     }
 
+    // See https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#:~:text=CREATE%20%5B%20OR%20REPLACE%20%5D%20VIEW%20%5B%20IF%20NOT%20EXISTS%20%5D
+    fn create_view_if_not_exists_supported(&self) -> bool {
+        true
+    }
+
     fn require_interval_qualifier(&self) -> bool {
         true
     }

src/dialect/generic.rs

@@ -88,6 +88,14 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn create_view_if_not_exists_supported(&self) -> bool {
+        true
+    }
+
+    fn create_view_name_before_if_not_exists_supported(&self) -> bool {
+        true
+    }
+
     fn support_map_literal_syntax(&self) -> bool {
         true
     }

src/dialect/mod.rs

@@ -247,6 +247,18 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Does the dialect support sql statements such as:
+    /// CREATE VIEW IF NOT EXISTS view_name AS SELECT * FROM table_name
+    fn create_view_if_not_exists_supported(&self) -> bool {
+        false
+    }
+
+    /// Does the dialect support view_name before IF NOT EXISTS in CREATE VIEW:
+    /// CREATE VIEW IF NOT EXISTS view_name AS SELECT * FROM table_name
+    fn create_view_name_before_if_not_exists_supported(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports referencing another named window
     /// within a window clause declaration.
     ///

src/dialect/snowflake.rs

@@ -283,6 +283,16 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
+    // See https://docs.snowflake.com/en/sql-reference/sql/create-view
+    fn create_view_if_not_exists_supported(&self) -> bool {
+        true
+    }
+
+    // Snowflake allows table name before if not exists in CREATE VIEW
+    fn create_view_name_before_if_not_exists_supported(&self) -> bool {
+        true
+    }
+
     fn supports_left_associative_joins_without_parens(&self) -> bool {
         false
     }

src/dialect/sqlite.rs

@@ -57,6 +57,11 @@ impl Dialect for SQLiteDialect {
         true
     }
 
+    // See https://www.sqlite.org/lang_createview.html
+    fn create_view_if_not_exists_supported(&self) -> bool {
+        true
+    }
+
     fn supports_start_transaction_modifier(&self) -> bool {
         true
     }

src/parser/mod.rs

@@ -5704,12 +5704,30 @@ impl<'a> Parser<'a> {
     ) -> Result<Statement, ParserError> {
         let materialized = self.parse_keyword(Keyword::MATERIALIZED);
         self.expect_keyword_is(Keyword::VIEW)?;
-        let if_not_exists = dialect_of!(self is BigQueryDialect|SQLiteDialect|GenericDialect)
-            && self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+        let allow_unquoted_hyphen = dialect_of!(self is BigQueryDialect);
+        let mut if_not_exists = false;
+        let name: ObjectName;
+        let mut name_before_not_exists = false;
+        if self.peek_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]) {
+            // Possible syntax -> ... IF NOT EXISTS <name>
+            if self.dialect.create_view_if_not_exists_supported() {
+                if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+            }
+            name = self.parse_object_name(allow_unquoted_hyphen)?;
+        } else {
+            // Possible syntax -> ... <name> IF NOT EXISTS
+            name = self.parse_object_name(allow_unquoted_hyphen)?;
+            if self
+                .dialect
+                .create_view_name_before_if_not_exists_supported()
+                && self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS])
+            {
+                if_not_exists = true;
+                name_before_not_exists = true;
+            }
+        }
         // Many dialects support `OR ALTER` right after `CREATE`, but we don't (yet).
         // ANSI SQL and Postgres support RECURSIVE here, but we don't support it either.
-        let allow_unquoted_hyphen = dialect_of!(self is BigQueryDialect);
-        let name = self.parse_object_name(allow_unquoted_hyphen)?;
         let columns = self.parse_view_columns()?;
         let mut options = CreateTableOptions::None;
         let with_options = self.parse_options(Keyword::WITH)?;
@@ -5776,6 +5794,7 @@ impl<'a> Parser<'a> {
             temporary,
             to,
             params: create_view_params,
+            name_before_not_exists,
         })
     }
 

tests/sqlparser_common.rs

@@ -7985,6 +7985,7 @@ fn parse_create_view() {
             temporary,
             to,
             params,
+            name_before_not_exists: _,
         } => {
             assert_eq!(or_alter, false);
             assert_eq!("myschema.myview", name.to_string());
@@ -8053,6 +8054,7 @@ fn parse_create_view_with_columns() {
             temporary,
             to,
             params,
+            name_before_not_exists: _,
         } => {
             assert_eq!(or_alter, false);
             assert_eq!("v", name.to_string());
@@ -8102,6 +8104,7 @@ fn parse_create_view_temporary() {
             temporary,
             to,
             params,
+            name_before_not_exists: _,
         } => {
             assert_eq!(or_alter, false);
             assert_eq!("myschema.myview", name.to_string());
@@ -8141,6 +8144,7 @@ fn parse_create_or_replace_view() {
             temporary,
             to,
             params,
+            name_before_not_exists: _,
         } => {
             assert_eq!(or_alter, false);
             assert_eq!("v", name.to_string());
@@ -8184,6 +8188,7 @@ fn parse_create_or_replace_materialized_view() {
             temporary,
             to,
             params,
+            name_before_not_exists: _,
         } => {
             assert_eq!(or_alter, false);
             assert_eq!("v", name.to_string());
@@ -8223,6 +8228,7 @@ fn parse_create_materialized_view() {
             temporary,
             to,
             params,
+            name_before_not_exists: _,
         } => {
             assert_eq!(or_alter, false);
             assert_eq!("myschema.myview", name.to_string());
@@ -8262,6 +8268,7 @@ fn parse_create_materialized_view_with_cluster_by() {
             temporary,
             to,
             params,
+            name_before_not_exists: _,
         } => {
             assert_eq!(or_alter, false);
             assert_eq!("myschema.myview", name.to_string());
@@ -16183,3 +16190,21 @@ fn test_identifier_unicode_start() {
     ]);
     let _ = dialects.verified_stmt(sql);
 }
+
+#[test]
+fn parse_create_view_if_not_exists() {
+    let sql = "CREATE VIEW IF NOT EXISTS v AS SELECT 1";
+    let dialects = TestedDialects::new(vec![
+        Box::new(SnowflakeDialect {}),
+        Box::new(GenericDialect {}),
+        Box::new(SQLiteDialect {}),
+        Box::new(BigQueryDialect {}),
+    ]);
+    let _ = dialects.verified_stmt(sql);
+    let sql = "CREATE VIEW v IF NOT EXISTS AS SELECT 1";
+    let dialects = TestedDialects::new(vec![
+        Box::new(SnowflakeDialect {}),
+        Box::new(GenericDialect {}),
+    ]);
+    let _ = dialects.verified_stmt(sql);
+}