bq: handle interval parsing

Author: donhcd

src/ast/value.rs

@@ -43,6 +43,7 @@ pub enum Value {
     /// so the user will have to reject intervals like `HOUR TO YEAR`.
     Interval {
         value: String,
+        value_quoting: Option<char>,
         leading_field: Option<DateTimeField>,
         leading_precision: Option<u64>,
         last_field: Option<DateTimeField>,
@@ -66,6 +67,7 @@ impl fmt::Display for Value {
             Value::Boolean(v) => write!(f, "{}", v),
             Value::Interval {
                 value,
+                value_quoting,
                 leading_field: Some(DateTimeField::Second),
                 leading_precision: Some(leading_precision),
                 last_field,
@@ -74,22 +76,32 @@ impl fmt::Display for Value {
                 // When the leading field is SECOND, the parser guarantees that
                 // the last field is None.
                 assert!(last_field.is_none());
+                write!(f, "INTERVAL ")?;
+                if let Some(ch) = value_quoting {
+                    write!(f, "{}{}{}", ch, escape_single_quote_string(value), ch)?;
+                } else {
+                    write!(f, "{}", value)?;
+                }
                 write!(
                     f,
-                    "INTERVAL '{}' SECOND ({}, {})",
-                    escape_single_quote_string(value),
-                    leading_precision,
-                    fractional_seconds_precision
+                    " SECOND ({}, {})",
+                    leading_precision, fractional_seconds_precision
                 )
             }
             Value::Interval {
                 value,
+                value_quoting,
                 leading_field,
                 leading_precision,
                 last_field,
                 fractional_seconds_precision,
             } => {
-                write!(f, "INTERVAL '{}'", escape_single_quote_string(value))?;
+                write!(f, "INTERVAL ")?;
+                if let Some(ch) = value_quoting {
+                    write!(f, "{}{}{}", ch, escape_single_quote_string(value), ch)?;
+                } else {
+                    write!(f, "{}", value)?;
+                }
                 if let Some(leading_field) = leading_field {
                     write!(f, " {}", leading_field)?;
                 }

src/parser.rs

@@ -719,7 +719,13 @@ 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, value_quoting) = if dialect_of!(self is BigQueryDialect) {
+            // in BigQuery, the value is not quoted
+            // https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions
+            (self.parse_expr()?.to_string(), None)
+        } else {
+            (self.parse_literal_string()?, Some('\''))
+        };
 
         // Following the string literal is a qualifier which indicates the units
         // of the duration specified in the string literal.
@@ -771,6 +777,7 @@ impl<'a> Parser<'a> {
 
         Ok(Expr::Value(Value::Interval {
             value,
+            value_quoting,
             leading_field,
             leading_precision,
             last_field,