Support DISTINCT AS { STRUCT | VALUE } for BigQuery

According to the query syntax at
https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#select_list
you can combine `[ { ALL | DISTINCT } ]` with `[ AS { STRUCT | VALUE } ]`:

```sh
SELECT
  [ WITH differential_privacy_clause ]
  [ { ALL | DISTINCT } ]
  [ AS { STRUCT | VALUE } ]
  select_list
```

This adds support to parse `DISTINCT` or `ALL` as the first keyword
after `SELECT` and adds two new variants to the `ValueTableMode` if
defined.

Author: bombsimon

src/ast/query.rs

@@ -3340,20 +3340,29 @@ impl fmt::Display for OpenJsonTableColumn {
 /// BigQuery supports ValueTables which have 2 modes:
 /// `SELECT AS STRUCT`
 /// `SELECT AS VALUE`
+///
+/// They can be combined with `[ { ALL | DISTINCT } ]`, e.g.
+/// `SELECT DISTINCT AS STRUCT`
+///
 /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#value_tables>
+/// <https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#select_list>
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum ValueTableMode {
     AsStruct,
     AsValue,
+    DistinctAsStruct,
+    DistinctAsValue,
 }
 
 impl fmt::Display for ValueTableMode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             ValueTableMode::AsStruct => write!(f, "AS STRUCT"),
             ValueTableMode::AsValue => write!(f, "AS VALUE"),
+            ValueTableMode::DistinctAsStruct => write!(f, "DISTINCT AS STRUCT"),
+            ValueTableMode::DistinctAsValue => write!(f, "DISTINCT AS VALUE"),
         }
     }
 }

src/parser/mod.rs

@@ -11505,12 +11505,22 @@ impl<'a> Parser<'a> {
         }
 
         let select_token = self.expect_keyword(Keyword::SELECT)?;
+        let distinct_pre_as = self.parse_all_or_distinct()?;
+
         let value_table_mode =
             if dialect_of!(self is BigQueryDialect) && self.parse_keyword(Keyword::AS) {
                 if self.parse_keyword(Keyword::VALUE) {
-                    Some(ValueTableMode::AsValue)
+                    if distinct_pre_as.is_some() {
+                        Some(ValueTableMode::DistinctAsValue)
+                    } else {
+                        Some(ValueTableMode::AsValue)
+                    }
                 } else if self.parse_keyword(Keyword::STRUCT) {
-                    Some(ValueTableMode::AsStruct)
+                    if distinct_pre_as.is_some() {
+                        Some(ValueTableMode::DistinctAsStruct)
+                    } else {
+                        Some(ValueTableMode::AsStruct)
+                    }
                 } else {
                     self.expected("VALUE or STRUCT", self.peek_token())?
                 }
@@ -11524,7 +11534,17 @@ impl<'a> Parser<'a> {
             top = Some(self.parse_top()?);
             top_before_distinct = true;
         }
-        let distinct = self.parse_all_or_distinct()?;
+
+        // If we parsed a `DISTINCT` value before checking `ValueTableMode` and it is set to some,
+        // but we didn't have an `AS`, this is the initial `DISTINCT` value in the `SELECT` and
+        // should be re-used.
+        // If we don't have a `DISTINCT` parsed or if it was consumed for the `ValueTableMode` we
+        // look for `DISTINCT` again.
+        let distinct = if value_table_mode.is_none() && distinct_pre_as.is_some() {
+            distinct_pre_as
+        } else {
+            self.parse_all_or_distinct()?
+        };
         if !self.dialect.supports_top_before_distinct() && self.parse_keyword(Keyword::TOP) {
             top = Some(self.parse_top()?);
         }

tests/sqlparser_bigquery.rs

@@ -2377,3 +2377,14 @@ fn test_any_type() {
 fn test_any_type_dont_break_custom_type() {
     bigquery_and_generic().verified_stmt("CREATE TABLE foo (x ANY)");
 }
+
+#[test]
+fn test_select_distinct_as_struct_or_value() {
+    for sql in [
+        "SELECT DISTINCT AS STRUCT a, ABS(b) FROM UNNEST(c) AS T",
+        "SELECT DISTINCT AS VALUE a, ABS(b) FROM UNNEST(c) AS T",
+        "SELECT ARRAY(SELECT DISTINCT AS STRUCT a, b, ABS(c) AS c, ABS(d) AS d FROM UNNEST(e) AS T)",
+    ] {
+        bigquery().verified_stmt(sql);
+    }
+}