fix(parser): gate EXCLUDE by PG dialect; parse OPERATOR() and element ordering

Three related fixes to the `EXCLUDE` table-constraint arm:

- Guard the match on `PostgreSqlDialect | GenericDialect` so MySQL,
  SQLite, and others can continue to use `exclude` as a column name.
  Previously the arm fired on any dialect and hard-errored once the
  expected continuation was missing, instead of falling through to
  `parse_column_def`.

- Extend `parse_exclusion_element` to parse the optional `opclass`,
  `ASC`/`DESC`, and `NULLS FIRST`/`LAST` qualifiers that precede
  `WITH <op>`, matching the PG `index_elem` grammar.

- Add `parse_exclusion_operator` so the schema-qualified
  `OPERATOR(schema.op)` form is consumed as one unit. The previous
  single-token lookahead silently stopped at `OPERATOR` and left the
  parenthesised path to corrupt the surrounding parse.

Author: fmguerreiro

src/parser/mod.rs

@@ -9915,16 +9915,18 @@ impl<'a> Parser<'a> {
                     .into(),
                 ))
             }
-            Token::Word(w) if w.keyword == Keyword::EXCLUDE => {
+            Token::Word(w)
+                if w.keyword == Keyword::EXCLUDE
+                    && dialect_of!(self is PostgreSqlDialect | GenericDialect) =>
+            {
                 let index_method = if self.parse_keyword(Keyword::USING) {
                     Some(self.parse_identifier()?)
                 } else {
                     None
                 };
 
                 self.expect_token(&Token::LParen)?;
-                let elements =
-                    self.parse_comma_separated(|p| p.parse_exclusion_element())?;
+                let elements = self.parse_comma_separated(|p| p.parse_exclusion_element())?;
                 self.expect_token(&Token::RParen)?;
 
                 let include = if self.parse_keyword(Keyword::INCLUDE) {
@@ -9972,19 +9974,55 @@ impl<'a> Parser<'a> {
 
     fn parse_exclusion_element(&mut self) -> Result<ExclusionElement, ParserError> {
         let expr = self.parse_expr()?;
+
+        // `index_elem` grammar: [ opclass ] [ ASC | DESC ] [ NULLS FIRST | LAST ]
+        let operator_class: Option<ObjectName> = if self
+            .peek_one_of_keywords(&[Keyword::ASC, Keyword::DESC, Keyword::NULLS, Keyword::WITH])
+            .is_some()
+        {
+            None
+        } else {
+            self.maybe_parse(|p| p.parse_object_name(false))?
+        };
+        let order = self.parse_order_by_options()?;
+
         self.expect_keyword_is(Keyword::WITH)?;
+        let operator = self.parse_exclusion_operator()?;
+
+        Ok(ExclusionElement {
+            expr,
+            operator_class,
+            order,
+            operator,
+        })
+    }
+
+    /// Parse the operator that follows `WITH` in an `EXCLUDE` element.
+    ///
+    /// Accepts either a single operator token (e.g. `=`, `&&`, `<->`) or the
+    /// Postgres `OPERATOR(schema.op)` form for schema-qualified operators.
+    fn parse_exclusion_operator(&mut self) -> Result<String, ParserError> {
+        if self.parse_keyword(Keyword::OPERATOR) {
+            self.expect_token(&Token::LParen)?;
+            let mut parts = vec![];
+            loop {
+                self.advance_token();
+                parts.push(self.get_current_token().to_string());
+                if !self.consume_token(&Token::Period) {
+                    break;
+                }
+            }
+            self.expect_token(&Token::RParen)?;
+            return Ok(format!("OPERATOR({})", parts.join(".")));
+        }
+
         let operator_token = self.next_token();
         match &operator_token.token {
-            Token::EOF
-            | Token::RParen
-            | Token::Comma
-            | Token::SemiColon => {
-                return self.expected("exclusion operator", operator_token);
+            Token::EOF | Token::RParen | Token::Comma | Token::SemiColon => {
+                self.expected("exclusion operator", operator_token)
             }
-            _ => {}
+            _ => Ok(operator_token.token.to_string()),
         }
-        let operator = operator_token.token.to_string();
-        Ok(ExclusionElement { expr, operator })
     }
 
     fn parse_optional_nulls_distinct(&mut self) -> Result<NullsDistinctOption, ParserError> {