Revert "[SIG-43218] support for snowflake EXCLUDE wildcard modifier (#11)"

This reverts commit e174e14.

Author: jmhain

src/ast/query.rs

@@ -228,7 +228,6 @@ pub enum SelectItem {
     Wildcard {
         prefix: Option<ObjectName>,
         except: Vec<Ident>,
-        exclude: Vec<Ident>, // Snowflake's flavor of EXCEPT
         replace: Vec<(Expr, Ident)>,
     },
 }
@@ -241,7 +240,6 @@ impl fmt::Display for SelectItem {
             SelectItem::Wildcard {
                 prefix,
                 except,
-                exclude,
                 replace,
             } => {
                 if let Some(pre) = prefix {
@@ -259,19 +257,6 @@ impl fmt::Display for SelectItem {
                     write!(f, ")")?;
                 }
                 delim = "";
-                if !exclude.is_empty() {
-                    write!(f, " EXCLUDE ")?;
-                    if exclude.len() == 1 {
-                        write!(f, "{}", exclude[0])?;
-                    } else {
-                        write!(f, "(")?;
-                        for col in exclude {
-                            write!(f, "{}{}", delim, col)?;
-                            delim = ", ";
-                        }
-                        write!(f, ")")?;
-                    }
-                }
                 if !replace.is_empty() {
                     write!(f, " REPLACE (")?;
                     for &(ref expr, ref alias) in replace.iter() {

src/dialect/keywords.rs

@@ -201,7 +201,6 @@ define_keywords!(
     ESCAPE,
     EVERY,
     EXCEPT,
-    EXCLUDE,
     EXEC,
     EXECUTE,
     EXISTS,

src/parser.rs

@@ -28,7 +28,6 @@ pub enum ParserError {
 }
 
 pub type WildcardExcept = Vec<Ident>;
-pub type WildcardExclude = Vec<Ident>;
 pub type WildcardReplace = Vec<(Expr, Ident)>;
 
 // Use `Parser::expected` instead, if possible
@@ -2872,19 +2871,17 @@ impl<'a> Parser<'a> {
     pub fn parse_select_item(&mut self) -> Result<SelectItem, ParserError> {
         let expr = self.parse_expr()?;
         if let Expr::Wildcard = expr {
-            let (except, exclude, replace) = self.parse_wildcard_modifiers()?;
+            let (except, replace) = self.parse_wildcard_modifiers()?;
             Ok(SelectItem::Wildcard {
                 prefix: None,
                 except,
-                exclude,
                 replace,
             })
         } else if let Expr::QualifiedWildcard(prefix) = expr {
-            let (except, exclude, replace) = self.parse_wildcard_modifiers()?;
+            let (except, replace) = self.parse_wildcard_modifiers()?;
             Ok(SelectItem::Wildcard {
                 prefix: Some(ObjectName(prefix)),
                 except,
-                exclude,
                 replace,
             })
         } else {
@@ -2911,7 +2908,7 @@ impl<'a> Parser<'a> {
 
     pub fn parse_wildcard_modifiers(
         &mut self,
-    ) -> Result<(WildcardExcept, WildcardExclude, WildcardReplace), ParserError> {
+    ) -> Result<(WildcardExcept, WildcardReplace), ParserError> {
         let except = if self.parse_keyword(Keyword::EXCEPT) {
             self.expect_token(&Token::LParen)?;
             let aliases = self.parse_comma_separated(Parser::parse_identifier)?;
@@ -2920,26 +2917,15 @@ impl<'a> Parser<'a> {
         } else {
             vec![]
         };
-        let exclude = if self.parse_keyword(Keyword::EXCLUDE) {
-            if self.consume_token(&Token::LParen) {
-                let aliases = self.parse_comma_separated(Parser::parse_identifier)?;
-                self.expect_token(&Token::RParen)?;
-                aliases
-            } else {
-                vec![self.parse_identifier()?]
-            }
-        } else {
-            vec![]
-        };
-        let replace = if self.parse_keyword(Keyword::REPLACE) {
+        let replace = if self.parse_keyword(Keyword::EXCEPT) {
             self.expect_token(&Token::LParen)?;
             let replace = self.parse_comma_separated(Parser::parse_replace_item)?;
             self.expect_token(&Token::RParen)?;
             replace
         } else {
             vec![]
         };
-        Ok((except, exclude, replace))
+        Ok((except, replace))
     }
 
     /// Parse an expression, optionally followed by ASC or DESC (used in ORDER BY)

tests/queries/bigquery/wildcard_modifiers_except.sql

@@ -273,7 +273,6 @@ fn parse_select_wildcard() {
         &SelectItem::Wildcard {
             prefix: None,
             except: vec![],
-            exclude: vec![],
             replace: vec![]
         },
         only(&select.projection)
@@ -285,7 +284,6 @@ fn parse_select_wildcard() {
         &SelectItem::Wildcard {
             prefix: Some(ObjectName(vec![Ident::new("foo")])),
             except: vec![],
-            exclude: vec![],
             replace: vec![]
         },
         only(&select.projection)
@@ -300,7 +298,6 @@ fn parse_select_wildcard() {
                 Ident::new("mytable"),
             ])),
             except: vec![],
-            exclude: vec![],
             replace: vec![]
         },
         only(&select.projection)

tests/queries/snowflake/wildcard_modifiers_exclude.sql

@@ -15,75 +15,50 @@
 use sqlparser::dialect::GenericDialect;
 use sqlparser::parser::Parser;
 
-macro_rules! regression_tests {
-    (
-        path: $path:literal,
-        tests: [$(
-            $(#[$attr:ident])?
-            $name:ident: $file:expr,
-        )*] $(,)?
-    ) => {
+macro_rules! tpch_tests {
+    ($($name:ident: $value:expr,)*) => {
+        const QUERIES: &[&str] = &[
+            $(include_str!(concat!("queries/tpch/", $value, ".sql"))),*
+        ];
     $(
 
         #[test]
-        $(#[$attr])?
         fn $name() {
             let dialect = GenericDialect {};
 
-            let stmts = Parser::parse_sql(&dialect, include_str!(concat!($path, $file, ".sql")))
-                .unwrap_or_else(|err| panic!("{}", err));
-
-            // check that each statement still parses after being rendered
-            for stmt in stmts {
-                assert!(Parser::parse_sql(&dialect, &dbg!(stmt.to_string())).is_ok());
+            let res = Parser::parse_sql(&dialect, QUERIES[$value -1]);
+            // Ignore 6.sql and 22.sql
+            if $value != 6 && $value != 22 {
+                assert!(res.is_ok());
             }
         }
     )*
     }
 }
 
-regression_tests! {
-    path: "queries/tpch/",
-    tests: [
-        tpch_1: "1",
-        tpch_2: "2",
-        tpch_3: "3",
-        tpch_4: "4",
-        tpch_5: "5",
-        tpch_6: "6",
-        tpch_7: "7",
-        tpch_8: "8",
-        tpch_9: "9",
-        tpch_10: "10",
-        tpch_11: "11",
-        tpch_12: "12",
-        tpch_13: "13",
-        tpch_14: "14",
-        tpch_15: "15",
-        tpch_16: "16",
-        tpch_17: "17",
-        tpch_18: "18",
-        tpch_19: "19",
-        tpch_20: "20",
-        tpch_21: "21",
-        #[ignore]
-        tpch_22: "22",
-        tpch_23: "23",
-        tpch_24: "24",
-    ],
-}
-
-regression_tests! {
-    path: "queries/snowflake/",
-    tests: [
-        snowflake_wildcard_modifiers_exclude: "wildcard_modifiers_exclude",
-        snowflake_wildcard_modifiers_replace: "wildcard_modifiers_replace",
-    ],
-}
-
-regression_tests! {
-    path: "queries/bigquery/",
-    tests: [
-        bigquery_wildcard_modifiers_except: "wildcard_modifiers_except",
-    ],
+tpch_tests! {
+    tpch_1: 1,
+    tpch_2: 2,
+    tpch_3: 3,
+    tpch_4: 4,
+    tpch_5: 5,
+    tpch_6: 6,
+    tpch_7: 7,
+    tpch_8: 8,
+    tpch_9: 9,
+    tpch_10: 10,
+    tpch_11: 11,
+    tpch_12: 12,
+    tpch_13: 13,
+    tpch_14: 14,
+    tpch_15: 15,
+    tpch_16: 16,
+    tpch_17: 17,
+    tpch_18: 18,
+    tpch_19: 19,
+    tpch_20: 20,
+    tpch_21: 21,
+    tpch_22: 22,
+    tpch_23: 23,
+    tpch_24: 24,
 }

tests/queries/snowflake/wildcard_modifiers_replace.sql

@@ -1428,7 +1428,6 @@ fn parse_complicated_sql() {
                                         quote_style: None,
                                     }])),
                                     except: vec![],
-                                    exclude: vec![],
                                     replace: vec![],
                                 },
                                 ExprWithAlias {
@@ -2045,7 +2044,6 @@ fn parse_complicated_sql() {
                                 SelectItem::Wildcard {
                                     prefix: None,
                                     except: vec![],
-                                    exclude: vec![],
                                     replace: vec![],
                                 },
                                 ExprWithAlias {
@@ -2122,7 +2120,6 @@ fn parse_complicated_sql() {
                                         quote_style: None,
                                     }])),
                                     except: vec![],
-                                    exclude: vec![],
                                     replace: vec![],
                                 },
                                 ExprWithAlias {
@@ -2643,7 +2640,6 @@ fn parse_complicated_sql() {
                                         quote_style: None,
                                     }])),
                                     except: vec![],
-                                    exclude: vec![],
                                     replace: vec![],
                                 },
                                 ExprWithAlias {
@@ -2768,7 +2764,6 @@ fn parse_complicated_sql() {
                         quote_style: None,
                     }])),
                     except: vec![],
-                    exclude: vec![],
                     replace: vec![],
                 },
                 ExprWithAlias {