bq: named window specs

Author: donhcd

src/ast/mod.rs

@@ -445,16 +445,24 @@ impl fmt::Display for Expr {
     }
 }
 
+/// A window specification, either inline or named
+/// https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#window_clause
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum WindowSpec {
+    Inline(InlineWindowSpec),
+    Named(Ident),
+}
+
 /// A window specification (i.e. `OVER (PARTITION BY .. ORDER BY .. etc.)`)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct WindowSpec {
+pub struct InlineWindowSpec {
     pub partition_by: Vec<Expr>,
     pub order_by: Vec<OrderByExpr>,
     pub window_frame: Option<WindowFrame>,
 }
 
-impl fmt::Display for WindowSpec {
+impl fmt::Display for InlineWindowSpec {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut delim = "";
         if !self.partition_by.is_empty() {
@@ -1061,8 +1069,10 @@ impl fmt::Display for Function {
                 display_comma_separated(&self.within_group)
             )?;
         }
-        if let Some(o) = &self.over {
-            write!(f, " OVER ({})", o)?;
+        match &self.over {
+            Some(WindowSpec::Inline(over)) => write!(f, " OVER ({})", over)?,
+            Some(WindowSpec::Named(name)) => write!(f, " OVER {}", name)?,
+            None => {}
         }
         Ok(())
     }

src/ast/query.rs

@@ -136,6 +136,8 @@ pub struct Select {
     pub having: Option<Expr>,
     /// QUALIFY https://docs.snowflake.com/en/sql-reference/constructs/qualify.html
     pub qualify: Option<Expr>,
+    /// WINDOW https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#window_clause
+    pub windows: Vec<(Ident, WindowSpec)>,
 }
 
 impl fmt::Display for Select {
@@ -160,6 +162,18 @@ impl fmt::Display for Select {
         if let Some(ref qualify) = self.qualify {
             write!(f, " QUALIFY {}", qualify)?;
         }
+        if !self.windows.is_empty() {
+            write!(f, " WINDOW ")?;
+            let mut delim = "";
+            for (ident, spec) in self.windows.iter() {
+                write!(f, "{}{} AS ", delim, ident)?;
+                match spec {
+                    WindowSpec::Inline(inline) => write!(f, "({})", inline)?,
+                    WindowSpec::Named(name) => write!(f, "{}", name)?,
+                }
+                delim = ", ";
+            }
+        }
         Ok(())
     }
 }

src/parser.rs

@@ -362,32 +362,7 @@ impl<'a> Parser<'a> {
             vec![]
         };
         let over = if self.parse_keyword(Keyword::OVER) {
-            // TBD: support window names (`OVER mywin`) in place of inline specification
-            self.expect_token(&Token::LParen)?;
-            let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {
-                // a list of possibly-qualified column names
-                self.parse_comma_separated(Parser::parse_expr)?
-            } else {
-                vec![]
-            };
-            let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
-                self.parse_comma_separated(Parser::parse_order_by_expr)?
-            } else {
-                vec![]
-            };
-            let window_frame = if !self.consume_token(&Token::RParen) {
-                let window_frame = self.parse_window_frame()?;
-                self.expect_token(&Token::RParen)?;
-                Some(window_frame)
-            } else {
-                None
-            };
-
-            Some(WindowSpec {
-                partition_by,
-                order_by,
-                window_frame,
-            })
+            Some(self.parse_window_spec()?)
         } else {
             None
         };
@@ -438,20 +413,68 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse_window_frame_units(&mut self) -> Result<WindowFrameUnits, ParserError> {
-        match self.next_token() {
+    pub fn parse_named_window_expr(&mut self) -> Result<(Ident, WindowSpec), ParserError> {
+        let ident = self.parse_identifier()?;
+        self.expect_keyword(Keyword::AS)?;
+        let spec = self.parse_window_spec()?;
+        return Ok((ident, spec));
+    }
+
+    pub fn parse_window_spec(&mut self) -> Result<WindowSpec, ParserError> {
+        if self.consume_token(&Token::LParen) {
+            let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {
+                // a list of possibly-qualified column names
+                self.parse_comma_separated(Parser::parse_expr)?
+            } else {
+                vec![]
+            };
+            let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
+                self.parse_comma_separated(Parser::parse_order_by_expr)?
+            } else {
+                vec![]
+            };
+            let window_frame = self.parse_window_frame()?;
+
+            let found_rparen = self.consume_token(&Token::RParen);
+            if partition_by.is_empty() && order_by.is_empty() && window_frame.is_none() && !found_rparen {
+                // try parsing a named window if we failed to parse any part of
+                // a window spec and we haven't reached the rparen yet
+                let ident = self.parse_identifier()?;
+                self.expect_token(&Token::RParen)?;
+                return Ok(WindowSpec::Named(ident));
+            }
+
+            Ok(WindowSpec::Inline(InlineWindowSpec {
+                partition_by,
+                order_by,
+                window_frame,
+            }))
+        } else {
+            // named windows don't need parens
+            Ok(WindowSpec::Named(self.parse_identifier()?))
+        }
+    }
+
+    pub fn consume_window_frame_units(&mut self) -> Result<Option<WindowFrameUnits>, ParserError> {
+        let units = match self.peek_token() {
             Token::Word(w) => match w.keyword {
-                Keyword::ROWS => Ok(WindowFrameUnits::Rows),
-                Keyword::RANGE => Ok(WindowFrameUnits::Range),
-                Keyword::GROUPS => Ok(WindowFrameUnits::Groups),
-                _ => self.expected("ROWS, RANGE, GROUPS", Token::Word(w))?,
+                Keyword::ROWS => WindowFrameUnits::Rows,
+                Keyword::RANGE => WindowFrameUnits::Range,
+                Keyword::GROUPS => WindowFrameUnits::Groups,
+                _ => return Ok(None),
             },
-            unexpected => self.expected("ROWS, RANGE, GROUPS", unexpected),
-        }
+            _ => return Ok(None),
+        };
+        self.next_token(); // consume token
+        Ok(Some(units))
     }
 
-    pub fn parse_window_frame(&mut self) -> Result<WindowFrame, ParserError> {
-        let units = self.parse_window_frame_units()?;
+    pub fn parse_window_frame(&mut self) -> Result<Option<WindowFrame>, ParserError> {
+        let units = if let Some(units) = self.consume_window_frame_units()? {
+            units
+        } else {
+            return Ok(None);
+        };
         let (start_bound, end_bound) = if self.parse_keyword(Keyword::BETWEEN) {
             let start_bound = self.parse_window_frame_bound()?;
             self.expect_keyword(Keyword::AND)?;
@@ -460,11 +483,11 @@ impl<'a> Parser<'a> {
         } else {
             (self.parse_window_frame_bound()?, None)
         };
-        Ok(WindowFrame {
+        Ok(Some(WindowFrame {
             units,
             start_bound,
             end_bound,
-        })
+        }))
     }
 
     /// Parse `CURRENT ROW` or `{ <positive number> | UNBOUNDED } { PRECEDING | FOLLOWING }`
@@ -2324,6 +2347,13 @@ impl<'a> Parser<'a> {
             None
         };
 
+        // https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#window_clause
+        let windows = if self.parse_keyword(Keyword::WINDOW) {
+            self.parse_comma_separated(Parser::parse_named_window_expr)?
+        } else {
+            vec![]
+        };
+
         Ok(Select {
             distinct,
             top,
@@ -2333,6 +2363,7 @@ impl<'a> Parser<'a> {
             group_by,
             having,
             qualify,
+            windows,
         })
     }