fix: clear error for qualified column names in EXCLUDE clause

When a user writes `f.* EXCLUDE (f.col)` instead of `f.* EXCLUDE (col)`,
the parser previously consumed only the table qualifier (e.g. `f`) as the
identifier and then hit the `.` unexpectedly, producing a confusing error
like "Expected: `,` or `)`, found `.`".

This commit detects the qualified-name pattern in
`parse_optional_select_item_exclude` and returns an actionable error:

    EXCLUDE does not support qualified column names,
    use a plain identifier instead (e.g. EXCLUDE (account_canonical_id))

Applies to both the single-column (`EXCLUDE col`) and multi-column
(`EXCLUDE (col1, col2)`) forms.

Fixes repro: `SELECT f.* EXCLUDE (f.account_canonical_id, f.amount) FROM t AS f`

Author: yoabot-droid

src/parser/mod.rs

@@ -17901,11 +17901,32 @@ impl<'a> Parser<'a> {
     ) -> Result<Option<ExcludeSelectItem>, ParserError> {
         let opt_exclude = if self.parse_keyword(Keyword::EXCLUDE) {
             if self.consume_token(&Token::LParen) {
-                let columns = self.parse_comma_separated(|parser| parser.parse_identifier())?;
+                let columns = self.parse_comma_separated(|parser| {
+                    let ident = parser.parse_identifier()?;
+                    if parser.peek_token_ref().token == Token::Period {
+                        return parser_err!(
+                            format!(
+                                "EXCLUDE does not support qualified column names, \
+                                 use a plain identifier instead (e.g. EXCLUDE ({ident}))"
+                            ),
+                            parser.peek_token_ref().span.start
+                        );
+                    }
+                    Ok(ident)
+                })?;
                 self.expect_token(&Token::RParen)?;
                 Some(ExcludeSelectItem::Multiple(columns))
             } else {
                 let column = self.parse_identifier()?;
+                if self.peek_token_ref().token == Token::Period {
+                    return parser_err!(
+                        format!(
+                            "EXCLUDE does not support qualified column names, \
+                             use a plain identifier instead (e.g. EXCLUDE {column})"
+                        ),
+                        self.peek_token_ref().span.start
+                    );
+                }
                 Some(ExcludeSelectItem::Single(column))
             }
         } else {

tests/sqlparser_common.rs

@@ -17395,6 +17395,39 @@ fn test_select_exclude() {
     );
 }
 
+#[test]
+fn test_select_exclude_qualified_names() {
+    // EXCLUDE should only accept plain identifiers, not qualified names like `f.col`.
+    // Verify that the parser produces a clear, actionable error message.
+    let dialects = all_dialects_where(|d| d.supports_select_wildcard_exclude());
+
+    // Qualified name in multi-column EXCLUDE list: f.* EXCLUDE (f.col)
+    let err = dialects
+        .parse_sql_statements("SELECT f.* EXCLUDE (f.account_canonical_id) FROM t AS f")
+        .err()
+        .unwrap();
+    assert!(
+        err.to_string()
+            .contains("EXCLUDE does not support qualified column names"),
+        "unexpected error: {err}"
+    );
+
+    // Qualified name in single-column EXCLUDE: * EXCLUDE f.col
+    let err = dialects
+        .parse_sql_statements("SELECT * EXCLUDE f.col FROM t AS f")
+        .err()
+        .unwrap();
+    assert!(
+        err.to_string()
+            .contains("EXCLUDE does not support qualified column names"),
+        "unexpected error: {err}"
+    );
+
+    // Valid forms must still parse successfully.
+    dialects.verified_only_select("SELECT f.* EXCLUDE (account_canonical_id) FROM t AS f");
+    dialects.verified_only_select("SELECT f.* EXCLUDE (col1, col2) FROM t AS f");
+}
+
 #[test]
 fn test_no_semicolon_required_between_statements() {
     let sql = r#"