bq: typeless structs

Author: donhcd

src/ast/mod.rs

@@ -283,6 +283,9 @@ pub enum Expr {
     Subquery(Box<Query>),
     /// The `LISTAGG` function `SELECT LISTAGG(...) WITHIN GROUP (ORDER BY ...)`
     ListAgg(ListAgg),
+    /// bigquery structs https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type
+    /// `STRUCT( expr1 [AS field_name] [, ... ])`
+    Struct(Struct),
 }
 
 impl fmt::Display for Expr {
@@ -458,6 +461,7 @@ impl fmt::Display for Expr {
             Expr::Exists(s) => write!(f, "EXISTS ({})", s),
             Expr::Subquery(s) => write!(f, "({})", s),
             Expr::ListAgg(listagg) => write!(f, "{}", listagg),
+            Expr::Struct(strct) => write!(f, "{}", strct),
         }
     }
 }
@@ -1161,6 +1165,28 @@ impl fmt::Display for ListAgg {
     }
 }
 
+/// A `STRUCT` invocation `STRUCT( expr1 [AS field_name] [, ... ])`
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct Struct {
+    pub fields: Vec<(Expr, Option<Ident>)>,
+}
+
+impl fmt::Display for Struct {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "STRUCT(")?;
+        let mut delim = "";
+        for (expr, maybe_alias) in self.fields.iter() {
+            write!(f, "{}{}", delim, expr)?;
+            if let Some(alias) = maybe_alias {
+                write!(f, " AS {}", alias)?;
+            }
+            delim = ", ";
+        }
+        write!(f, ")")
+    }
+}
+
 /// The `ON OVERFLOW` clause of a LISTAGG invocation
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

src/dialect/keywords.rs

@@ -430,6 +430,7 @@ define_keywords!(
     STDDEV_SAMP,
     STDIN,
     STORED,
+    STRUCT,
     SUBMULTISET,
     SUBSTRING,
     SUBSTRING_REGEX,

src/parser.rs

@@ -264,6 +264,7 @@ impl<'a> Parser<'a> {
                 Keyword::EXTRACT => self.parse_extract_expr(),
                 Keyword::INTERVAL => self.parse_literal_interval(),
                 Keyword::LISTAGG => self.parse_listagg_expr(),
+                Keyword::STRUCT if dialect_of!(self is BigQueryDialect) => self.parse_struct(),
                 Keyword::NOT => Ok(Expr::UnaryOp {
                     op: UnaryOperator::Not,
                     expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
@@ -639,6 +640,20 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    /// bigquery structs https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type
+    pub fn parse_struct(&mut self) -> Result<Expr, ParserError> {
+        self.expect_token(&Token::LParen)?;
+        let fields = self.parse_comma_separated(Parser::parse_struct_field)?;
+        self.expect_token(&Token::RParen)?;
+        Ok(Expr::Struct(Struct { fields }))
+    }
+
+    pub fn parse_struct_field(&mut self) -> Result<(Expr, Option<Ident>), ParserError> {
+        let expr = self.parse_expr()?;
+        let maybe_alias = self.parse_optional_alias(keywords::RESERVED_FOR_COLUMN_ALIAS)?;
+        Ok((expr, maybe_alias))
+    }
+
     // This function parses date/time fields for both the EXTRACT function-like
     // operator and interval qualifiers. EXTRACT supports a wider set of
     // date/time fields than interval qualifiers, so this function may need to