Add SECURE keyword for views in Snowflake (apache#2004)

Author: Vedin

src/ast/mod.rs

@@ -2564,6 +2564,9 @@ pub enum Statement {
     CreateView {
         or_replace: bool,
         materialized: bool,
+        /// Snowflake: SECURE view modifier
+        /// <https://docs.snowflake.com/en/sql-reference/sql/create-view#syntax>
+        secure: bool,
         /// View name
         name: ObjectName,
         columns: Vec<ViewColumnDef>,
@@ -4268,6 +4271,7 @@ impl fmt::Display for Statement {
                 columns,
                 query,
                 materialized,
+                secure,
                 options,
                 cluster_by,
                 comment,
@@ -4287,11 +4291,15 @@ impl fmt::Display for Statement {
                 }
                 write!(
                     f,
-                    "{materialized}{temporary}VIEW {if_not_exists}{name}{to}",
+                    "{secure}{materialized}{temporary}VIEW {if_not_and_name}{to}",
+                    if_not_and_name = if *if_not_exists {
+                        format!("IF NOT EXISTS {name}")
+                    } else {
+                        format!("{name}")
+                    },
+                    secure = if *secure { "SECURE " } else { "" },
                     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

@@ -369,6 +369,7 @@ impl Spanned for Statement {
             Statement::CreateView {
                 or_replace: _,
                 materialized: _,
+                secure: _,
                 name,
                 columns,
                 query,

src/keywords.rs

@@ -778,6 +778,7 @@ define_keywords!(
     SECONDARY,
     SECONDS,
     SECRET,
+    SECURE,
     SECURITY,
     SEED,
     SELECT,

src/parser/mod.rs

@@ -4380,8 +4380,11 @@ impl<'a> Parser<'a> {
         let create_view_params = self.parse_create_view_params()?;
         if self.parse_keyword(Keyword::TABLE) {
             self.parse_create_table(or_replace, temporary, global, transient)
-        } else if self.parse_keyword(Keyword::MATERIALIZED) || self.parse_keyword(Keyword::VIEW) {
-            self.prev_token();
+        } else if self.peek_keyword(Keyword::MATERIALIZED)
+            || self.peek_keyword(Keyword::VIEW)
+            || self.peek_keywords(&[Keyword::SECURE, Keyword::MATERIALIZED, Keyword::VIEW])
+            || self.peek_keywords(&[Keyword::SECURE, Keyword::VIEW])
+        {
             self.parse_create_view(or_replace, temporary, create_view_params)
         } else if self.parse_keyword(Keyword::POLICY) {
             self.parse_create_policy()
@@ -5293,6 +5296,7 @@ impl<'a> Parser<'a> {
         temporary: bool,
         create_view_params: Option<CreateViewParams>,
     ) -> Result<Statement, ParserError> {
+        let secure = self.parse_keyword(Keyword::SECURE);
         let materialized = self.parse_keyword(Keyword::MATERIALIZED);
         self.expect_keyword_is(Keyword::VIEW)?;
         let if_not_exists = dialect_of!(self is BigQueryDialect|SQLiteDialect|GenericDialect)
@@ -5361,6 +5365,7 @@ impl<'a> Parser<'a> {
             columns,
             query,
             materialized,
+            secure,
             or_replace,
             options,
             cluster_by,

tests/sqlparser_common.rs

@@ -7806,6 +7806,7 @@ fn parse_create_view() {
             temporary,
             to,
             params,
+            secure: _,
         } => {
             assert_eq!("myschema.myview", name.to_string());
             assert_eq!(Vec::<ViewColumnDef>::new(), columns);
@@ -7870,6 +7871,7 @@ fn parse_create_view_with_columns() {
             temporary,
             to,
             params,
+            secure: _,
         } => {
             assert_eq!("v", name.to_string());
             assert_eq!(
@@ -7917,6 +7919,7 @@ fn parse_create_view_temporary() {
             temporary,
             to,
             params,
+            secure: _,
         } => {
             assert_eq!("myschema.myview", name.to_string());
             assert_eq!(Vec::<ViewColumnDef>::new(), columns);
@@ -7954,6 +7957,7 @@ fn parse_create_or_replace_view() {
             temporary,
             to,
             params,
+            secure: _,
         } => {
             assert_eq!("v", name.to_string());
             assert_eq!(columns, vec![]);
@@ -7995,6 +7999,7 @@ fn parse_create_or_replace_materialized_view() {
             temporary,
             to,
             params,
+            secure: _,
         } => {
             assert_eq!("v", name.to_string());
             assert_eq!(columns, vec![]);
@@ -8032,6 +8037,7 @@ fn parse_create_materialized_view() {
             temporary,
             to,
             params,
+            secure: _,
         } => {
             assert_eq!("myschema.myview", name.to_string());
             assert_eq!(Vec::<ViewColumnDef>::new(), columns);
@@ -8069,6 +8075,7 @@ fn parse_create_materialized_view_with_cluster_by() {
             temporary,
             to,
             params,
+            secure: _,
         } => {
             assert_eq!("myschema.myview", name.to_string());
             assert_eq!(Vec::<ViewColumnDef>::new(), columns);

tests/sqlparser_snowflake.rs

@@ -44,6 +44,33 @@ fn test_snowflake_create_table() {
     }
 }
 
+#[test]
+fn parse_sf_create_secure_view_and_materialized_view() {
+    for sql in [
+        "CREATE SECURE VIEW v AS SELECT 1",
+        "CREATE SECURE MATERIALIZED VIEW v AS SELECT 1",
+        "CREATE OR REPLACE SECURE VIEW v AS SELECT 1",
+        "CREATE OR REPLACE SECURE MATERIALIZED VIEW v AS SELECT 1",
+    ] {
+        match snowflake().verified_stmt(sql) {
+            Statement::CreateView {
+                secure,
+                materialized,
+                ..
+            } => {
+                assert!(secure);
+                if sql.contains("MATERIALIZED") {
+                    assert!(materialized);
+                } else {
+                    assert!(!materialized);
+                }
+            }
+            _ => unreachable!(),
+        }
+        assert_eq!(snowflake().verified_stmt(sql).to_string(), sql);
+    }
+}
+
 #[test]
 fn test_snowflake_create_or_replace_table() {
     let sql = "CREATE OR REPLACE TABLE my_table (a number)";