Merge support-multi-column-alias

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

@@ -1821,6 +1821,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

@@ -19,7 +19,7 @@ use crate::dialect::Dialect;
 
 /// A [`Dialect`] for [Databricks SQL](https://www.databricks.com/)
 ///
-/// See <https://docs.databricks.com/en/sql/language-manual/index.html>.
+    /// See <https://docs.databricks.com/en/sql/language-manual/index.html>.
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct DatabricksDialect;
@@ -95,7 +95,7 @@ impl Dialect for DatabricksDialect {
         true
     }
 
-/// See <https://docs.databricks.com/aws/en/sql/language-manual/functions/bangsign>
+    /// See <https://docs.databricks.com/aws/en/sql/language-manual/functions/bangsign>
     fn supports_bang_not_operator(&self) -> bool {
         true
     }
@@ -104,4 +104,9 @@ 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

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

src/dialect/mod.rs

@@ -1675,6 +1675,18 @@ pub trait Dialect: Debug + Any {
     fn supports_cte_without_as(&self) -> bool {
         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
+    }
 }
 
 /// Operators for which precedence must be defined.

src/parser/mod.rs

@@ -18107,6 +18107,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_databricks.rs

@@ -677,4 +677,19 @@ fn parse_cte_without_as() {
     assert!(all_dialects_where(|d| !d.supports_cte_without_as())
         .parse_sql_statements("WITH cte (SELECT 1) SELECT * FROM cte")
         .is_err());
+
+}
+
+#[test]
+fn parse_select_item_multi_column_alias() {
+    databricks_and_generic().verified_stmt("SELECT stack(2, 'a', 'b', 'c', 'd') AS (col1, col2)");
+
+    databricks_and_generic()
+        .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()
+    );
 }