Support multi-column aliases in SELECT items (apache#2289)

Author: funcpp

src/ast/query.rs

@@ -872,6 +872,15 @@ pub enum SelectItem {
         /// The alias for the expression.
         alias: Ident,
     },
+    /// An expression, followed by `[ AS ] (alias1, alias2, ...)`
+    ///
+    /// [Spark SQL](https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select.html)
+    ExprWithAliases {
+        /// The expression being projected.
+        expr: Expr,
+        /// The list of aliases for the expression.
+        aliases: Vec<Ident>,
+    },
     /// An expression, followed by a wildcard expansion.
     /// e.g. `alias.*`, `STRUCT<STRING>('foo').*`
     QualifiedWildcard(SelectItemQualifiedWildcardKind, WildcardAdditionalOptions),
@@ -1175,6 +1184,12 @@ impl fmt::Display for SelectItem {
                 f.write_str(" AS ")?;
                 alias.fmt(f)
             }
+            SelectItem::ExprWithAliases { expr, aliases } => {
+                expr.fmt(f)?;
+                f.write_str(" AS (")?;
+                display_comma_separated(aliases).fmt(f)?;
+                f.write_str(")")
+            }
             SelectItem::QualifiedWildcard(kind, additional_options) => {
                 kind.fmt(f)?;
                 additional_options.fmt(f)

src/ast/spans.rs

@@ -1823,6 +1823,9 @@ impl Spanned for SelectItem {
         match self {
             SelectItem::UnnamedExpr(expr) => expr.span(),
             SelectItem::ExprWithAlias { expr, alias } => expr.span().union(&alias.span),
+            SelectItem::ExprWithAliases { expr, aliases } => {
+                union_spans(iter::once(expr.span()).chain(aliases.iter().map(|i| i.span)))
+            }
             SelectItem::QualifiedWildcard(kind, wildcard_additional_options) => union_spans(
                 [kind.span()]
                     .into_iter()

src/dialect/databricks.rs

@@ -104,4 +104,8 @@ impl Dialect for DatabricksDialect {
     fn supports_cte_without_as(&self) -> bool {
         true
     }
+
+    fn supports_select_item_multi_column_alias(&self) -> bool {
+        true
+    }
 }

src/dialect/generic.rs

@@ -297,6 +297,10 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn supports_select_item_multi_column_alias(&self) -> bool {
+        true
+    }
+
     fn supports_xml_expressions(&self) -> bool {
         true
     }

src/dialect/mod.rs

@@ -1692,6 +1692,17 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports parenthesized multi-column
+    /// aliases in SELECT items. For example:
+    /// ```sql
+    /// SELECT stack(2, 'a', 'b') AS (col1, col2)
+    /// ```
+    ///
+    /// [Spark SQL](https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select.html)
+    fn supports_select_item_multi_column_alias(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports XML-related expressions
     /// such as `xml '<foo/>'` typed strings, XML functions like
     /// `XMLCONCAT`, `XMLELEMENT`, etc.

src/parser/mod.rs

@@ -18116,6 +18116,19 @@ impl<'a> Parser<'a> {
                     self.parse_wildcard_additional_options(wildcard_token)?,
                 ))
             }
+            expr if self.dialect.supports_select_item_multi_column_alias()
+                && self.peek_keyword(Keyword::AS)
+                && self.peek_nth_token(1).token == Token::LParen =>
+            {
+                self.expect_keyword(Keyword::AS)?;
+                self.expect_token(&Token::LParen)?;
+                let aliases = self.parse_comma_separated(|p| p.parse_identifier())?;
+                self.expect_token(&Token::RParen)?;
+                Ok(SelectItem::ExprWithAliases {
+                    expr: maybe_prefixed_expr(expr, prefix),
+                    aliases,
+                })
+            }
             expr => self
                 .maybe_parse_select_item_alias()
                 .map(|alias| match alias {

tests/sqlparser_common.rs

@@ -18757,6 +18757,21 @@ fn test_wildcard_func_arg() {
     dialects.verified_expr("HASH(* EXCLUDE (col1, col2))");
 }
 
+#[test]
+fn parse_select_item_multi_column_alias() {
+    all_dialects_where(|d| d.supports_select_item_multi_column_alias())
+        .verified_stmt("SELECT stack(2, 'a', 'b', 'c', 'd') AS (col1, col2)");
+
+    all_dialects_where(|d| d.supports_select_item_multi_column_alias())
+        .verified_stmt("SELECT stack(2, 'a', 'b', 'c', 'd') AS (col1, col2) FROM t");
+
+    assert!(
+        all_dialects_where(|d| !d.supports_select_item_multi_column_alias())
+            .parse_sql_statements("SELECT stack(2, 'a', 'b') AS (col1, col2)")
+            .is_err()
+    );
+}
+
 #[test]
 fn parse_non_pg_dialects_keep_xml_names_as_regular_identifiers() {
     // On dialects that do NOT support XML expressions, bare `xml` should