Support for INTERVAL inside window frames

src/ast/mod.rs

@@ -880,9 +880,9 @@ pub enum WindowFrameBound {
     /// `CURRENT ROW`
     CurrentRow,
     /// `<N> PRECEDING` or `UNBOUNDED PRECEDING`
-    Preceding(Option<u64>),
+    Preceding(Option<RangeBounds>),
     /// `<N> FOLLOWING` or `UNBOUNDED FOLLOWING`.
-    Following(Option<u64>),
+    Following(Option<RangeBounds>),
 }
 
 impl fmt::Display for WindowFrameBound {
@@ -897,6 +897,27 @@ impl fmt::Display for WindowFrameBound {
     }
 }
 
+/// Specifies offset values in the [WindowFrameBound]'s `Preceding` and `Following`
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum RangeBounds {
+    /// Number literal, e.g `1`, `1.1`
+    Number(String),
+    /// Interval, such as `INTERVAL '1 DAY' `
+    Interval(Expr),
+}
+
+impl fmt::Display for RangeBounds {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RangeBounds::Number(s) => write!(f, "{}", s),
+            RangeBounds::Interval(interval) => {
+                write!(f, "{}", interval)
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum AddDropSync {
@@ -2670,7 +2691,7 @@ impl fmt::Display for CloseCursor {
 pub struct Function {
     pub name: ObjectName,
     pub args: Vec<FunctionArg>,
-    pub over: Option<WindowSpec>,
+    pub over: Option<Box<WindowSpec>>,
     // aggregate functions may specify eg `COUNT(DISTINCT x)`
     pub distinct: bool,
     // Some functions must be called without trailing parentheses, for example Postgres

src/parser.rs

@@ -620,7 +620,7 @@ impl<'a> Parser<'a> {
         } else {
             None
         };
-
+        let over = over.map(Box::new);
         Ok(Expr::Function(Function {
             name,
             args,
@@ -682,7 +682,7 @@ impl<'a> Parser<'a> {
             let rows = if self.parse_keyword(Keyword::UNBOUNDED) {
                 None
             } else {
-                Some(self.parse_literal_uint()?)
+                Some(self.parse_range_values()?)
             };
             if self.parse_keyword(Keyword::PRECEDING) {
                 Ok(WindowFrameBound::Preceding(rows))
@@ -3319,6 +3319,42 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse a literal inside window frames such as 1 PRECEDING or '1 DAY' PRECEDING
+    pub fn parse_range_values(&mut self) -> Result<RangeBounds, ParserError> {
+        match self.peek_token() {
+            Token::Number(s, _) => {
+                // consume token Token::Number
+                self.next_token();
+                Ok(RangeBounds::Number(s))
+            }
+            Token::Word(w) => match w.keyword {
+                Keyword::INTERVAL => {
+                    // consume token Keyword::INTERVAL
+                    self.next_token();
+                    match self.parse_interval() {
+                        Ok(interval) => Ok(RangeBounds::Interval(interval)),
+                        e => Err(ParserError::ParserError(format!(
+                            "Interval is not valid {:?}",
+                            e
+                        ))),
+                    }
+                }
+                e => Err(ParserError::ParserError(format!(
+                    "Interval is not valid {:?}",
+                    e
+                ))),
+            },
+            Token::SingleQuotedString(_) => match self.parse_interval() {
+                Ok(interval) => Ok(RangeBounds::Interval(interval)),
+                e => Err(ParserError::ParserError(format!(
+                    "Interval is not valid {:?}",
+                    e
+                ))),
+            },
+            unexpected => self.expected("literal Expression", unexpected),
+        }
+    }
+
     /// Parse a literal string
     pub fn parse_literal_string(&mut self) -> Result<String, ParserError> {
         match self.next_token() {

tests/sqlparser_common.rs

@@ -1555,15 +1555,15 @@ fn parse_select_qualify() {
             left: Box::new(Expr::Function(Function {
                 name: ObjectName(vec![Ident::new("ROW_NUMBER")]),
                 args: vec![],
-                over: Some(WindowSpec {
+                over: Some(Box::new(WindowSpec {
                     partition_by: vec![Expr::Identifier(Ident::new("p"))],
                     order_by: vec![OrderByExpr {
                         expr: Expr::Identifier(Ident::new("o")),
                         asc: None,
                         nulls_first: None
                     }],
                     window_frame: None
-                }),
+                })),
                 distinct: false,
                 special: false
             })),
@@ -2865,26 +2865,30 @@ fn parse_window_functions() {
                ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), \
                avg(bar) OVER (ORDER BY a \
                RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING), \
+               sum(bar) OVER (ORDER BY a \
+               RANGE BETWEEN INTERVAL '1' DAY PRECEDING AND INTERVAL '1 MONTH' FOLLOWING), \
+               COUNT(*) OVER (ORDER BY a \
+               RANGE BETWEEN INTERVAL '1 DAYS' PRECEDING AND INTERVAL '1 DAY' FOLLOWING), \
                max(baz) OVER (ORDER BY a \
                ROWS UNBOUNDED PRECEDING), \
                sum(qux) OVER (ORDER BY a \
                GROUPS BETWEEN 1 PRECEDING AND 1 FOLLOWING) \
                FROM foo";
     let select = verified_only_select(sql);
-    assert_eq!(5, select.projection.len());
+    assert_eq!(7, select.projection.len());
     assert_eq!(
         &Expr::Function(Function {
             name: ObjectName(vec![Ident::new("row_number")]),
             args: vec![],
-            over: Some(WindowSpec {
+            over: Some(Box::new(WindowSpec {
                 partition_by: vec![],
                 order_by: vec![OrderByExpr {
                     expr: Expr::Identifier(Ident::new("dt")),
                     asc: Some(false),
                     nulls_first: None,
                 }],
                 window_frame: None,
-            }),
+            })),
             distinct: false,
             special: false,
         }),