support except

Author: simonvandel

src/ast/query.rs

@@ -2708,6 +2708,15 @@ pub enum PipeOperator {
         set_quantifier: SetQuantifier,
         queries: Vec<Box<Query>>,
     },
+    /// Returns only the rows that are present in the input table but not in the specified tables.
+    ///
+    /// Syntax: `|> EXCEPT DISTINCT (<query>), (<query>), ...`
+    ///
+    /// See more at <https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax#except_pipe_operator>
+    Except {
+        set_quantifier: SetQuantifier,
+        queries: Vec<Box<Query>>,
+    },
 }
 
 impl fmt::Display for PipeOperator {
@@ -2810,6 +2819,28 @@ impl fmt::Display for PipeOperator {
                 }
                 Ok(())
             }
+            PipeOperator::Except {
+                set_quantifier,
+                queries,
+            } => {
+                write!(f, "EXCEPT")?;
+                match set_quantifier {
+                    SetQuantifier::All => write!(f, " ALL")?,
+                    SetQuantifier::Distinct => write!(f, " DISTINCT")?,
+                    SetQuantifier::None => {}
+                    _ => {
+                        write!(f, " {}", set_quantifier)?;
+                    }
+                }
+                write!(f, " ")?;
+                for (i, query) in queries.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "({})", query)?;
+                }
+                Ok(())
+            }
         }
     }
 }

src/parser/mod.rs

@@ -11086,6 +11086,7 @@ impl<'a> Parser<'a> {
                 Keyword::RENAME,
                 Keyword::UNION,
                 Keyword::INTERSECT,
+                Keyword::EXCEPT,
             ])?;
             match kw {
                 Keyword::SELECT => {
@@ -11182,6 +11183,27 @@ impl<'a> Parser<'a> {
                     })?;
                     pipe_operators.push(PipeOperator::Intersect { set_quantifier, queries });
                 }
+                Keyword::EXCEPT => {
+                    // BigQuery EXCEPT pipe operator requires DISTINCT modifier
+                    let set_quantifier = if self.parse_keywords(&[Keyword::DISTINCT, Keyword::BY, Keyword::NAME]) {
+                        SetQuantifier::DistinctByName
+                    } else if self.parse_keyword(Keyword::DISTINCT) {
+                        SetQuantifier::Distinct
+                    } else {
+                        return Err(ParserError::ParserError(
+                            "EXCEPT pipe operator requires DISTINCT modifier".to_string()
+                        ));
+                    };
+                    // BigQuery EXCEPT pipe operator requires parentheses around queries
+                    // Parse comma-separated list of parenthesized queries
+                    let queries = self.parse_comma_separated(|parser| {
+                        parser.expect_token(&Token::LParen)?;
+                        let query = parser.parse_query()?;
+                        parser.expect_token(&Token::RParen)?;
+                        Ok(query)
+                    })?;
+                    pipe_operators.push(PipeOperator::Except { set_quantifier, queries });
+                }
                 unhandled => {
                     return Err(ParserError::ParserError(format!(
                     "`expect_one_of_keywords` further up allowed unhandled keyword: {unhandled:?}"

tests/sqlparser_common.rs

@@ -15235,12 +15235,53 @@ fn parse_pipeline_operator() {
     dialects.verified_stmt("SELECT * FROM users |> INTERSECT BY NAME (SELECT * FROM admins), (SELECT * FROM guests)");
     dialects.verified_stmt("SELECT * FROM users |> INTERSECT DISTINCT BY NAME (SELECT * FROM admins), (SELECT * FROM guests)");
 
+    // except pipe operator (BigQuery requires DISTINCT modifier for EXCEPT)
+    dialects.verified_stmt("SELECT * FROM users |> EXCEPT DISTINCT (SELECT * FROM admins)");
+    
+    // except pipe operator with BY NAME modifier  
+    dialects.verified_stmt("SELECT * FROM users |> EXCEPT DISTINCT BY NAME (SELECT * FROM admins)");
+    
+    // except pipe operator with multiple queries
+    dialects.verified_stmt("SELECT * FROM users |> EXCEPT DISTINCT (SELECT * FROM admins), (SELECT * FROM guests)");
+    
+    // except pipe operator with BY NAME and multiple queries
+    dialects.verified_stmt("SELECT * FROM users |> EXCEPT DISTINCT BY NAME (SELECT * FROM admins), (SELECT * FROM guests)");
+
     // many pipes
     dialects.verified_stmt(
         "SELECT * FROM CustomerOrders |> AGGREGATE SUM(cost) AS total_cost GROUP BY customer_id, state, item_type |> EXTEND COUNT(*) OVER (PARTITION BY customer_id) AS num_orders |> WHERE num_orders > 1 |> AGGREGATE AVG(total_cost) AS average GROUP BY state DESC, item_type ASC",
     );
 }
 
+#[test]
+fn parse_pipeline_operator_negative_tests() {
+    let dialects = all_dialects_where(|d| d.supports_pipe_operator());
+
+    // Test that plain EXCEPT without DISTINCT fails
+    assert_eq!(
+        ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()),
+        dialects.parse_sql_statements("SELECT * FROM users |> EXCEPT (SELECT * FROM admins)").unwrap_err()
+    );
+
+    // Test that EXCEPT ALL fails  
+    assert_eq!(
+        ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()),
+        dialects.parse_sql_statements("SELECT * FROM users |> EXCEPT ALL (SELECT * FROM admins)").unwrap_err()
+    );
+
+    // Test that EXCEPT BY NAME without DISTINCT fails
+    assert_eq!(
+        ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()),
+        dialects.parse_sql_statements("SELECT * FROM users |> EXCEPT BY NAME (SELECT * FROM admins)").unwrap_err()
+    );
+
+    // Test that EXCEPT ALL BY NAME fails
+    assert_eq!(
+        ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()),
+        dialects.parse_sql_statements("SELECT * FROM users |> EXCEPT ALL BY NAME (SELECT * FROM admins)").unwrap_err()
+    );
+}
+
 #[test]
 fn parse_multiple_set_statements() -> Result<(), ParserError> {
     let dialects = all_dialects_where(|d| d.supports_comma_separated_set_assignments());