feat: Support INTERVAL with EXPR

Can drop this after rebase on commit d981f70 "fix: Support expr instead of string for argument to interval (apache#517)", first released in 0.19.0

Author: ovr

src/ast/value.rs

@@ -19,6 +19,8 @@ use bigdecimal::BigDecimal;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use super::Expr;
+
 /// Primitive SQL values such as number and string
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -50,7 +52,7 @@ pub enum Value {
     /// that the `<leading_field>` units >= the units in `<last_field>`,
     /// so the user will have to reject intervals like `HOUR TO YEAR`.
     Interval {
-        value: String,
+        value: Box<Expr>,
         leading_field: Option<DateTimeField>,
         leading_precision: Option<u64>,
         last_field: Option<DateTimeField>,
@@ -88,8 +90,8 @@ impl fmt::Display for Value {
                 assert!(last_field.is_none());
                 write!(
                     f,
-                    "INTERVAL '{}' SECOND ({}, {})",
-                    escape_single_quote_string(value),
+                    "INTERVAL {} SECOND ({}, {})",
+                    value.to_string(),
                     leading_precision,
                     fractional_seconds_precision
                 )
@@ -101,7 +103,8 @@ impl fmt::Display for Value {
                 last_field,
                 fractional_seconds_precision,
             } => {
-                write!(f, "INTERVAL '{}'", escape_single_quote_string(value))?;
+                write!(f, "INTERVAL {}", value.to_string())?;
+
                 if let Some(leading_field) = leading_field {
                     write!(f, " {}", leading_field)?;
                 }

src/parser.rs

@@ -1003,7 +1003,7 @@ impl<'a> Parser<'a> {
 
         // The first token in an interval is a string literal which specifies
         // the duration of the interval.
-        let value = self.parse_literal_string()?;
+        let value = self.parse_expr()?;
 
         // Following the string literal is a qualifier which indicates the units
         // of the duration specified in the string literal.
@@ -1070,7 +1070,7 @@ impl<'a> Parser<'a> {
             };
 
         Ok(Expr::Value(Value::Interval {
-            value,
+            value: Box::new(value),
             leading_field,
             leading_precision,
             last_field,

tests/sqlparser_common.rs

@@ -2573,13 +2573,45 @@ fn parse_literal_timestamp() {
     );
 }
 
+#[test]
+fn parse_expr_interval() {
+    let sql = "SELECT INTERVAL HOUR(order_date) HOUR";
+    let select = verified_only_select(sql);
+
+    let value = Expr::Function(Function {
+        name: ObjectName(vec![Ident {
+            value: "HOUR".to_string(),
+            quote_style: None,
+        }]),
+        args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(
+            Expr::Identifier(Ident {
+                value: "order_date".to_string(),
+                quote_style: None,
+            }),
+        ))],
+        over: None,
+        distinct: false,
+    });
+
+    assert_eq!(
+        &Expr::Value(Value::Interval {
+            value: Box::new(value),
+            leading_field: Some(DateTimeField::Hour),
+            leading_precision: None,
+            last_field: None,
+            fractional_seconds_precision: None,
+        }),
+        expr_from_projection(only(&select.projection)),
+    );
+}
+
 #[test]
 fn parse_literal_interval() {
     let sql = "SELECT INTERVAL '1-1' YEAR TO MONTH";
     let select = verified_only_select(sql);
     assert_eq!(
         &Expr::Value(Value::Interval {
-            value: "1-1".into(),
+            value: Box::new(Expr::Value(Value::SingleQuotedString("1-1".to_string()))),
             leading_field: Some(DateTimeField::Year),
             leading_precision: None,
             last_field: Some(DateTimeField::Month),
@@ -2592,7 +2624,9 @@ fn parse_literal_interval() {
     let select = verified_only_select(sql);
     assert_eq!(
         &Expr::Value(Value::Interval {
-            value: "01:01.01".into(),
+            value: Box::new(Expr::Value(Value::SingleQuotedString(
+                "01:01.01".to_string()
+            ))),
             leading_field: Some(DateTimeField::Minute),
             leading_precision: Some(5),
             last_field: Some(DateTimeField::Second),
@@ -2605,7 +2639,7 @@ fn parse_literal_interval() {
     let select = verified_only_select(sql);
     assert_eq!(
         &Expr::Value(Value::Interval {
-            value: "1".into(),
+            value: Box::new(Expr::Value(Value::SingleQuotedString("1".to_string()))),
             leading_field: Some(DateTimeField::Second),
             leading_precision: Some(5),
             last_field: None,
@@ -2618,7 +2652,7 @@ fn parse_literal_interval() {
     let select = verified_only_select(sql);
     assert_eq!(
         &Expr::Value(Value::Interval {
-            value: "10".into(),
+            value: Box::new(Expr::Value(Value::SingleQuotedString("10".to_string()))),
             leading_field: Some(DateTimeField::Hour),
             leading_precision: None,
             last_field: None,
@@ -2631,7 +2665,7 @@ fn parse_literal_interval() {
     let select = verified_only_select(sql);
     assert_eq!(
         &Expr::Value(Value::Interval {
-            value: "10".into(),
+            value: Box::new(Expr::Value(Value::SingleQuotedString("10".to_string()))),
             leading_field: Some(DateTimeField::Hour),
             leading_precision: Some(1),
             last_field: None,
@@ -2644,7 +2678,7 @@ fn parse_literal_interval() {
     let select = verified_only_select(sql);
     assert_eq!(
         &Expr::Value(Value::Interval {
-            value: "1 DAY".into(),
+            value: Box::new(Expr::Value(Value::SingleQuotedString("1 DAY".to_string()))),
             leading_field: None,
             leading_precision: None,
             last_field: None,