Merge branch 'main' into push-vuqvpqzkltln

yoavcloud · web-flow · commit e8ac6b13e38d · 2026-02-27T11:55:24.000+01:00
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -7625,6 +7625,10 @@ pub enum FunctionArgExpr {
     QualifiedWildcard(ObjectName),
     /// An unqualified `*` wildcard.
     Wildcard,
+    /// An unqualified `*` wildcard with additional options, e.g. `* EXCLUDE(col)`.
+    ///
+    /// Used in Snowflake to support expressions like `HASH(* EXCLUDE(col))`.
+    WildcardWithOptions(WildcardAdditionalOptions),
 }
 
 impl From<Expr> for FunctionArgExpr {
@@ -7643,6 +7647,7 @@ impl fmt::Display for FunctionArgExpr {
             FunctionArgExpr::Expr(expr) => write!(f, "{expr}"),
             FunctionArgExpr::QualifiedWildcard(prefix) => write!(f, "{prefix}.*"),
             FunctionArgExpr::Wildcard => f.write_str("*"),
+            FunctionArgExpr::WildcardWithOptions(opts) => write!(f, "*{opts}"),
         }
     }
 }
diff --git a/src/ast/query.rs b/src/ast/query.rs
@@ -934,6 +934,9 @@ pub struct WildcardAdditionalOptions {
     pub opt_replace: Option<ReplaceSelectItem>,
     /// `[RENAME ...]`.
     pub opt_rename: Option<RenameSelectItem>,
+    /// `[AS <alias>]`.
+    ///  Redshift syntax: <https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_list.html>
+    pub opt_alias: Option<Ident>,
 }
 
 impl Default for WildcardAdditionalOptions {
@@ -945,6 +948,7 @@ impl Default for WildcardAdditionalOptions {
             opt_except: None,
             opt_replace: None,
             opt_rename: None,
+            opt_alias: None,
         }
     }
 }
@@ -966,6 +970,9 @@ impl fmt::Display for WildcardAdditionalOptions {
         if let Some(rename) = &self.opt_rename {
             write!(f, " {rename}")?;
         }
+        if let Some(alias) = &self.opt_alias {
+            write!(f, " AS {alias}")?;
+        }
         Ok(())
     }
 }
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -1824,6 +1824,7 @@ impl Spanned for WildcardAdditionalOptions {
             opt_except,
             opt_replace,
             opt_rename,
+            opt_alias,
         } = self;
 
         union_spans(
@@ -1832,7 +1833,8 @@ impl Spanned for WildcardAdditionalOptions {
                 .chain(opt_exclude.as_ref().map(|i| i.span()))
                 .chain(opt_rename.as_ref().map(|i| i.span()))
                 .chain(opt_replace.as_ref().map(|i| i.span()))
-                .chain(opt_except.as_ref().map(|i| i.span())),
+                .chain(opt_except.as_ref().map(|i| i.span()))
+                .chain(opt_alias.as_ref().map(|i| i.span)),
         )
     }
 }
@@ -2128,6 +2130,7 @@ impl Spanned for FunctionArg {
 ///
 /// Missing spans:
 /// - [FunctionArgExpr::Wildcard]
+/// - [FunctionArgExpr::WildcardWithOptions]
 impl Spanned for FunctionArgExpr {
     fn span(&self) -> Span {
         match self {
@@ -2136,6 +2139,7 @@ impl Spanned for FunctionArgExpr {
                 union_spans(object_name.0.iter().map(|i| i.span()))
             }
             FunctionArgExpr::Wildcard => Span::empty(),
+            FunctionArgExpr::WildcardWithOptions(_) => Span::empty(),
         }
     }
 }
diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs
@@ -1529,6 +1529,18 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if this dialect supports aliasing a wildcard select item.
+    ///
+    /// Example:
+    /// ```sql
+    /// SELECT t.* AS alias FROM t
+    /// ```
+    ///
+    /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_list.html)
+    fn supports_select_wildcard_with_alias(&self) -> bool {
+        false
+    }
+
     /// Returns true if this dialect supports the `OPTIMIZE TABLE` statement.
     ///
     /// Example:
diff --git a/src/dialect/mssql.rs b/src/dialect/mssql.rs
@@ -129,18 +129,64 @@ impl Dialect for MsSqlDialect {
 
     fn is_select_item_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
         match kw {
-            // List of keywords that cannot be used as select item aliases in MSSQL
-            // regardless of whether the alias is explicit or implicit
-            Keyword::IF | Keyword::ELSE => false,
+            // List of keywords that cannot be used as select item (column) aliases in MSSQL
+            // regardless of whether the alias is explicit or implicit.
+            //
+            // These are T-SQL statement-starting keywords; allowing them as implicit aliases
+            // causes the parser to consume the keyword as an alias for the previous expression,
+            // then fail on the token that follows (e.g. `TABLE`, `@var`, `sp_name`, …).
+            Keyword::IF
+            | Keyword::ELSE
+            | Keyword::DECLARE
+            | Keyword::EXEC
+            | Keyword::EXECUTE
+            | Keyword::INSERT
+            | Keyword::UPDATE
+            | Keyword::DELETE
+            | Keyword::DROP
+            | Keyword::CREATE
+            | Keyword::ALTER
+            | Keyword::TRUNCATE
+            | Keyword::PRINT
+            | Keyword::WHILE
+            | Keyword::RETURN
+            | Keyword::THROW
+            | Keyword::RAISERROR
+            | Keyword::MERGE => false,
             _ => explicit || self.is_column_alias(kw, parser),
         }
     }
 
     fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
         match kw {
             // List of keywords that cannot be used as table aliases in MSSQL
-            // regardless of whether the alias is explicit or implicit
-            Keyword::IF | Keyword::ELSE => false,
+            // regardless of whether the alias is explicit or implicit.
+            //
+            // These are T-SQL statement-starting keywords. Without blocking them here,
+            // a bare `SELECT * FROM t` followed by a newline and one of these keywords
+            // would cause the parser to consume the keyword as a table alias for `t`,
+            // then fail on the token that follows (e.g. `@var`, `sp_name`, `TABLE`, …).
+            //
+            // `SET` is already covered by the global `RESERVED_FOR_TABLE_ALIAS` list;
+            // the keywords below are MSSQL-specific additions.
+            Keyword::IF
+            | Keyword::ELSE
+            | Keyword::DECLARE
+            | Keyword::EXEC
+            | Keyword::EXECUTE
+            | Keyword::INSERT
+            | Keyword::UPDATE
+            | Keyword::DELETE
+            | Keyword::DROP
+            | Keyword::CREATE
+            | Keyword::ALTER
+            | Keyword::TRUNCATE
+            | Keyword::PRINT
+            | Keyword::WHILE
+            | Keyword::RETURN
+            | Keyword::THROW
+            | Keyword::RAISERROR
+            | Keyword::MERGE => false,
             _ => explicit || self.is_table_alias(kw, parser),
         }
     }
diff --git a/src/dialect/postgresql.rs b/src/dialect/postgresql.rs
@@ -302,4 +302,8 @@ impl Dialect for PostgreSqlDialect {
     fn supports_insert_table_alias(&self) -> bool {
         true
     }
+
+    fn supports_create_table_like_parenthesized(&self) -> bool {
+        true
+    }
 }
diff --git a/src/dialect/redshift.rs b/src/dialect/redshift.rs
@@ -141,6 +141,10 @@ impl Dialect for RedshiftSqlDialect {
         true
     }
 
+    fn supports_select_wildcard_with_alias(&self) -> bool {
+        true
+    }
+
     fn supports_select_exclude(&self) -> bool {
         true
     }
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -17597,7 +17597,26 @@ impl<'a> Parser<'a> {
         if let Some(arg) = arg {
             return Ok(arg);
         }
-        Ok(FunctionArg::Unnamed(self.parse_wildcard_expr()?.into()))
+        let wildcard_expr = self.parse_wildcard_expr()?;
+        let arg_expr: FunctionArgExpr = match wildcard_expr {
+            Expr::Wildcard(ref token) if self.dialect.supports_select_wildcard_exclude() => {
+                // Support `* EXCLUDE(col1, col2, ...)` inside function calls (e.g. Snowflake's
+                // `HASH(* EXCLUDE(col))`).  Parse the options the same way SELECT items do.
+                let opts = self.parse_wildcard_additional_options(token.0.clone())?;
+                if opts.opt_exclude.is_some()
+                    || opts.opt_except.is_some()
+                    || opts.opt_replace.is_some()
+                    || opts.opt_rename.is_some()
+                    || opts.opt_ilike.is_some()
+                {
+                    FunctionArgExpr::WildcardWithOptions(opts)
+                } else {
+                    wildcard_expr.into()
+                }
+            }
+            other => other.into(),
+        };
+        Ok(FunctionArg::Unnamed(arg_expr))
     }
 
     fn parse_function_named_arg_operator(&mut self) -> Result<FunctionArgOperator, ParserError> {
@@ -17885,13 +17904,24 @@ impl<'a> Parser<'a> {
             None
         };
 
+        let opt_alias = if self.dialect.supports_select_wildcard_with_alias() {
+            if self.parse_keyword(Keyword::AS) {
+                Some(self.parse_identifier()?)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
         Ok(WildcardAdditionalOptions {
             wildcard_token: wildcard_token.into(),
             opt_ilike,
             opt_exclude,
             opt_except,
             opt_rename,
             opt_replace,
+            opt_alias,
         })
     }
 
@@ -18574,6 +18604,9 @@ impl<'a> Parser<'a> {
 
     /// Parse a SQL `EXECUTE` statement
     pub fn parse_execute(&mut self) -> Result<Statement, ParserError> {
+        // Track whether the procedure/expression name itself was wrapped in parens,
+        // i.e. `EXEC (@sql)` (dynamic string execution) vs `EXEC sp_name`.
+        // When the name has parens there are no additional parameters.
         let name = if self.dialect.supports_execute_immediate()
             && self.parse_keyword(Keyword::IMMEDIATE)
         {
@@ -18584,10 +18617,18 @@ impl<'a> Parser<'a> {
             if has_parentheses {
                 self.expect_token(&Token::RParen)?;
             }
-            Some(name)
+            Some((name, has_parentheses))
         };
 
-        let has_parentheses = self.consume_token(&Token::LParen);
+        let name_had_parentheses = name.as_ref().map(|(_, p)| *p).unwrap_or(false);
+
+        // Only look for a parameter list when the name was NOT wrapped in parens.
+        // `EXEC (@sql)` is dynamic SQL execution and takes no parameters here.
+        let has_parentheses = if name_had_parentheses {
+            false
+        } else {
+            self.consume_token(&Token::LParen)
+        };
 
         let end_kws = &[Keyword::USING, Keyword::OUTPUT, Keyword::DEFAULT];
         let end_token = match (has_parentheses, self.peek_token().token) {
@@ -18597,12 +18638,18 @@ impl<'a> Parser<'a> {
             (false, _) => Token::SemiColon,
         };
 
-        let parameters = self.parse_comma_separated0(Parser::parse_expr, end_token)?;
+        let parameters = if name_had_parentheses {
+            vec![]
+        } else {
+            self.parse_comma_separated0(Parser::parse_expr, end_token)?
+        };
 
         if has_parentheses {
             self.expect_token(&Token::RParen)?;
         }
 
+        let name = name.map(|(n, _)| n);
+
         let into = if self.parse_keyword(Keyword::INTO) {
             self.parse_comma_separated(Self::parse_identifier)?
         } else {
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -1280,6 +1280,26 @@ fn parse_select_expr_star() {
     dialects.verified_only_select("SELECT myfunc().* EXCEPT (foo) FROM T");
 }
 
+#[test]
+fn parse_select_wildcard_with_alias() {
+    let dialects = all_dialects_where(|d| d.supports_select_wildcard_with_alias());
+
+    // qualified wildcard with alias
+    dialects
+        .parse_sql_statements("SELECT t.* AS all_cols FROM t")
+        .unwrap();
+
+    // unqualified wildcard with alias
+    dialects
+        .parse_sql_statements("SELECT * AS all_cols FROM t")
+        .unwrap();
+
+    // mixed: regular column + qualified wildcard with alias
+    dialects
+        .parse_sql_statements("SELECT a.id, b.* AS b_cols FROM a JOIN b ON (a.id = b.a_id)")
+        .unwrap();
+}
+
 #[test]
 fn test_eof_after_as() {
     let res = parse_sql_statements("SELECT foo AS");
@@ -18563,3 +18583,19 @@ fn parse_array_subscript() {
     dialects.verified_stmt("SELECT arr[1][2]");
     dialects.verified_stmt("SELECT arr[:][:]");
 }
+
+#[test]
+fn test_wildcard_func_arg() {
+    // Wildcard (*) and wildcard with EXCLUDE as a function argument.
+    // Documented for Snowflake's HASH function but parsed for any dialect that
+    // supports the wildcard-EXCLUDE select syntax.
+    let dialects = all_dialects_where(|d| d.supports_select_wildcard_exclude());
+
+    // Wildcard with EXCLUDE — canonical form has a space before the parenthesised column list.
+    dialects.one_statement_parses_to(
+        "SELECT HASH(* EXCLUDE(col1)) FROM t",
+        "SELECT HASH(* EXCLUDE (col1)) FROM t",
+    );
+    dialects.verified_expr("HASH(* EXCLUDE (col1))");
+    dialects.verified_expr("HASH(* EXCLUDE (col1, col2))");
+}
diff --git a/tests/sqlparser_mssql.rs b/tests/sqlparser_mssql.rs
diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs

Original file line number	Diff line number	Diff line change
`@@ -7625,6 +7625,10 @@ pub enum FunctionArgExpr {`
`7625`	`7625`	`QualifiedWildcard(ObjectName),`
`7626`	`7626`	/// An unqualified `*` wildcard.
`7627`	`7627`	`Wildcard,`
	`7628`	+ /// An unqualified `` wildcard with additional options, e.g. ` EXCLUDE(col)`.
	`7629`	`+ ///`
	`7630`	+ /// Used in Snowflake to support expressions like `HASH(* EXCLUDE(col))`.
	`7631`	`+ WildcardWithOptions(WildcardAdditionalOptions),`
`7628`	`7632`	`}`
`7629`	`7633`
`7630`	`7634`	`impl From<Expr> for FunctionArgExpr {`
`@@ -7643,6 +7647,7 @@ impl fmt::Display for FunctionArgExpr {`
`7643`	`7647`	`FunctionArgExpr::Expr(expr) => write!(f, "{expr}"),`
`7644`	`7648`	`FunctionArgExpr::QualifiedWildcard(prefix) => write!(f, "{prefix}.*"),`
`7645`	`7649`	`FunctionArgExpr::Wildcard => f.write_str("*"),`
	`7650`	`+ FunctionArgExpr::WildcardWithOptions(opts) => write!(f, "*{opts}"),`
`7646`	`7651`	`}`
`7647`	`7652`	`}`
`7648`	`7653`	`}`
Original file line number	Diff line number	Diff line change
`@@ -934,6 +934,9 @@ pub struct WildcardAdditionalOptions {`
`934`	`934`	`pub opt_replace: Option<ReplaceSelectItem>,`
`935`	`935`	/// `[RENAME ...]`.
`936`	`936`	`pub opt_rename: Option<RenameSelectItem>,`
	`937`	+ /// `[AS <alias>]`.
	`938`	`+ /// Redshift syntax: <https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_list.html>`
	`939`	`+ pub opt_alias: Option<Ident>,`
`937`	`940`	`}`
`938`	`941`
`939`	`942`	`impl Default for WildcardAdditionalOptions {`
`@@ -945,6 +948,7 @@ impl Default for WildcardAdditionalOptions {`
`945`	`948`	`opt_except: None,`
`946`	`949`	`opt_replace: None,`
`947`	`950`	`opt_rename: None,`
	`951`	`+ opt_alias: None,`
`948`	`952`	`}`
`949`	`953`	`}`
`950`	`954`	`}`
`@@ -966,6 +970,9 @@ impl fmt::Display for WildcardAdditionalOptions {`
`966`	`970`	`if let Some(rename) = &self.opt_rename {`
`967`	`971`	`write!(f, " {rename}")?;`
`968`	`972`	`}`
	`973`	`+ if let Some(alias) = &self.opt_alias {`
	`974`	`+ write!(f, " AS {alias}")?;`
	`975`	`+ }`
`969`	`976`	`Ok(())`
`970`	`977`	`}`
`971`	`978`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1824,6 +1824,7 @@ impl Spanned for WildcardAdditionalOptions {`
`1824`	`1824`	`opt_except,`
`1825`	`1825`	`opt_replace,`
`1826`	`1826`	`opt_rename,`
	`1827`	`+ opt_alias,`
`1827`	`1828`	`} = self;`
`1828`	`1829`
`1829`	`1830`	`union_spans(`
`@@ -1832,7 +1833,8 @@ impl Spanned for WildcardAdditionalOptions {`
`1832`	`1833`	`.chain(opt_exclude.as_ref().map(\|i\| i.span()))`
`1833`	`1834`	`.chain(opt_rename.as_ref().map(\|i\| i.span()))`
`1834`	`1835`	`.chain(opt_replace.as_ref().map(\|i\| i.span()))`
`1835`		`- .chain(opt_except.as_ref().map(\|i\| i.span())),`
	`1836`	`+ .chain(opt_except.as_ref().map(\|i\| i.span()))`
	`1837`	`+ .chain(opt_alias.as_ref().map(\|i\| i.span)),`
`1836`	`1838`	`)`
`1837`	`1839`	`}`
`1838`	`1840`	`}`
`@@ -2128,6 +2130,7 @@ impl Spanned for FunctionArg {`
`2128`	`2130`	`///`
`2129`	`2131`	`/// Missing spans:`
`2130`	`2132`	`/// - [FunctionArgExpr::Wildcard]`
	`2133`	`+/// - [FunctionArgExpr::WildcardWithOptions]`
`2131`	`2134`	`impl Spanned for FunctionArgExpr {`
`2132`	`2135`	`fn span(&self) -> Span {`
`2133`	`2136`	`match self {`
`@@ -2136,6 +2139,7 @@ impl Spanned for FunctionArgExpr {`
`2136`	`2139`	`union_spans(object_name.0.iter().map(\|i\| i.span()))`
`2137`	`2140`	`}`
`2138`	`2141`	`FunctionArgExpr::Wildcard => Span::empty(),`
	`2142`	`+ FunctionArgExpr::WildcardWithOptions(_) => Span::empty(),`
`2139`	`2143`	`}`
`2140`	`2144`	`}`
`2141`	`2145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -302,4 +302,8 @@ impl Dialect for PostgreSqlDialect {`
`302`	`302`	`fn supports_insert_table_alias(&self) -> bool {`
`303`	`303`	`true`
`304`	`304`	`}`
	`305`	`+`
	`306`	`+ fn supports_create_table_like_parenthesized(&self) -> bool {`
	`307`	`+ true`
	`308`	`+ }`
`305`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -141,6 +141,10 @@ impl Dialect for RedshiftSqlDialect {`
`141`	`141`	`true`
`142`	`142`	`}`
`143`	`143`
	`144`	`+ fn supports_select_wildcard_with_alias(&self) -> bool {`
	`145`	`+ true`
	`146`	`+ }`
	`147`	`+`
`144`	`148`	`fn supports_select_exclude(&self) -> bool {`
`145`	`149`	`true`
`146`	`150`	`}`