From e35c2b964dea330122dcc710d993f6787f3c29ca Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Tue, 13 Aug 2019 15:07:00 -0400
Subject: [PATCH 1/6] Parse INTERVAL values into a `ParsedDateTime` type

ParsedDateTimes just represent all the values that were present in a datetime
string. For a regular `DateTime` object they will all be present, but for
`INTERVAL` they depend on the following token.
---
 src/ast/mod.rs            |   2 +-
 src/ast/value.rs          |  74 +++++++++++-
 src/parser.rs             |  62 ++++++++--
 src/parser/datetime.rs    | 240 ++++++++++++++++++++++++++++++++++++++
 tests/sqlparser_common.rs |  28 +++++
 5 files changed, 393 insertions(+), 13 deletions(-)
 create mode 100644 src/parser/datetime.rs

diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index 24a7fd1..0c68192 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -49,7 +49,7 @@ pub use self::query::{
     Cte, Fetch, Join, JoinConstraint, JoinOperator, OrderByExpr, Query, Select, SelectItem,
     SetExpr, SetOperator, TableAlias, TableFactor, TableWithJoins, Values,
 };
-pub use self::value::{DateTimeField, Value};
+pub use self::value::{DateTimeField, ParsedDateTime, Value};
 
 struct DisplaySeparated<'a, T>
 where
diff --git a/src/ast/value.rs b/src/ast/value.rs
index 3d10824..2458e27 100644
--- a/src/ast/value.rs
+++ b/src/ast/value.rs
@@ -36,7 +36,7 @@ pub enum Value {
     Timestamp(String),
     /// INTERVAL literals, roughly in the following format:
     ///
-    /// ```ignore
+    /// ```text
     /// INTERVAL '<value>' <leading_field> [ (<leading_precision>) ]
     ///     [ TO <last_field> [ (<fractional_seconds_precision>) ] ]
     /// ```
@@ -46,8 +46,10 @@ 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 {
-        /// The raw [value] that was present in `INTERVAL '[value]'`
+        /// The raw `[value]` that was present in `INTERVAL '[value]'`
         value: String,
+        /// the fully parsed date time
+        parsed: ParsedDateTime,
         /// The unit of the first field in the interval. `INTERVAL 'T' MINUTE`
         /// means `T` is in minutes
         leading_field: DateTimeField,
@@ -98,6 +100,7 @@ impl fmt::Display for Value {
             Value::Time(v) => write!(f, "TIME '{}'", escape_single_quote_string(v)),
             Value::Timestamp(v) => write!(f, "TIMESTAMP '{}'", escape_single_quote_string(v)),
             Value::Interval {
+                parsed: _,
                 value,
                 leading_field: DateTimeField::Second,
                 leading_precision: Some(leading_precision),
@@ -116,6 +119,7 @@ impl fmt::Display for Value {
                 )
             }
             Value::Interval {
+                parsed: _,
                 value,
                 leading_field,
                 leading_precision,
@@ -145,6 +149,33 @@ impl fmt::Display for Value {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParsedDateTime {
+    pub is_positive: bool,
+    pub year: Option<u64>,
+    pub month: Option<u64>,
+    pub day: Option<u64>,
+    pub hour: Option<u64>,
+    pub minute: Option<u64>,
+    pub second: Option<u64>,
+    pub nano: Option<u32>,
+}
+
+impl Default for ParsedDateTime {
+    fn default() -> ParsedDateTime {
+        ParsedDateTime {
+            is_positive: true,
+            year: None,
+            month: None,
+            day: None,
+            hour: None,
+            minute: None,
+            second: None,
+            nano: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub enum DateTimeField {
     Year,
     Month,
@@ -154,6 +185,45 @@ pub enum DateTimeField {
     Second,
 }
 
+impl IntoIterator for DateTimeField {
+    type Item = DateTimeField;
+    type IntoIter = DateTimeFieldIterator;
+    fn into_iter(self) -> DateTimeFieldIterator {
+        DateTimeFieldIterator(Some(self))
+    }
+}
+
+/// An iterator over DateTimeFields
+///
+/// Always starts with the value smaller than the current one.
+///
+/// ```
+/// use sqlparser::ast::DateTimeField::*;
+/// let mut itr = Hour.into_iter();
+/// assert_eq!(itr.next(), Some(Minute));
+/// assert_eq!(itr.next(), Some(Second));
+/// assert_eq!(itr.next(), None);
+/// ```
+pub struct DateTimeFieldIterator(Option<DateTimeField>);
+
+/// Go through fields in descending significance order
+impl Iterator for DateTimeFieldIterator {
+    type Item = DateTimeField;
+    fn next(&mut self) -> Option<Self::Item> {
+        use DateTimeField::*;
+        self.0 = match self.0 {
+            Some(Year) => Some(Month),
+            Some(Month) => Some(Day),
+            Some(Day) => Some(Hour),
+            Some(Hour) => Some(Minute),
+            Some(Minute) => Some(Second),
+            Some(Second) => None,
+            None => None,
+        };
+        self.0.clone()
+    }
+}
+
 impl fmt::Display for DateTimeField {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match self {
diff --git a/src/parser.rs b/src/parser.rs
index 7a313d5..4904e58 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -22,17 +22,22 @@ use super::tokenizer::*;
 use std::error::Error;
 use std::fmt;
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum ParserError {
-    TokenizerError(String),
-    ParserError(String),
-}
-
 // Use `Parser::expected` instead, if possible
 macro_rules! parser_err {
     ($MSG:expr) => {
         Err(ParserError::ParserError($MSG.to_string()))
     };
+    ($($arg:tt)*) => {
+        Err(ParserError::ParserError(format!($($arg)*)))
+    };
+}
+
+mod datetime;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ParserError {
+    TokenizerError(String),
+    ParserError(String),
 }
 
 #[derive(PartialEq)]
@@ -466,14 +471,14 @@ impl Parser {
     ///
     /// Note that we do not currently attempt to parse the quoted value.
     pub fn parse_literal_interval(&mut self) -> Result<Expr, ParserError> {
-        // The SQL standard allows an optional sign before the value string, but
+        // The SQL standard allows an optional sign before the raw_value string, but
         // it is not clear if any implementations support that syntax, so we
         // don't currently try to parse it. (The sign can instead be included
-        // inside the value string.)
+        // inside the raw_value string.)
 
         // The first token in an interval is a string literal which specifies
         // the duration of the interval.
-        let value = self.parse_literal_string()?;
+        let raw_value = self.parse_literal_string()?;
 
         // Following the string literal is a qualifier which indicates the units
         // of the duration specified in the string literal.
@@ -507,8 +512,12 @@ impl Parser {
                 }
             };
 
+        let (value, _warnings) =
+            Self::parse_interval_string(&raw_value, &leading_field, &last_field)?;
+
         Ok(Expr::Value(Value::Interval {
-            value,
+            value: raw_value,
+            parsed: value,
             leading_field,
             leading_precision,
             last_field,
@@ -588,6 +597,39 @@ impl Parser {
         }
     }
 
+    /// parse
+    ///
+    /// ```text
+    /// <unquoted interval string> ::=
+    ///   [ <sign> ] { <year-month literal> | <day-time literal> }
+    /// <year-month literal> ::=
+    ///     <years value> [ <minus sign> <months value> ]
+    ///   | <months value>
+    /// <day-time literal> ::=
+    ///     <day-time interval>
+    ///   | <time interval>
+    /// <day-time interval> ::=
+    ///   <days value> [ <space> <hours value> [ <colon> <minutes value>
+    ///       [ <colon> <seconds value> ] ] ]
+    /// <time interval> ::=
+    ///     <hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ]
+    ///   | <minutes value> [ <colon> <seconds value> ]
+    ///   | <seconds value>
+    /// ```
+    pub fn parse_interval_string(
+        value: &str,
+        leading_field: &DateTimeField,
+        trailing_field: &Option<DateTimeField>,
+    ) -> Result<(ParsedDateTime, Vec<String>), ParserError> {
+        if value.is_empty() {
+            return Err(ParserError::ParserError(
+                "Interval date string is empty!".to_string(),
+            ));
+        }
+        let toks = datetime::tokenize_interval(value)?;
+        datetime::build_parsed_datetime(&toks, &leading_field, trailing_field)
+    }
+
     /// Parses the parens following the `[ NOT ] IN` operator
     pub fn parse_in(&mut self, expr: Expr, negated: bool) -> Result<Expr, ParserError> {
         self.expect_token(&Token::LParen)?;
diff --git a/src/parser/datetime.rs b/src/parser/datetime.rs
new file mode 100644
index 0000000..7189e57
--- /dev/null
+++ b/src/parser/datetime.rs
@@ -0,0 +1,240 @@
+use crate::ast::ParsedDateTime;
+use crate::parser::{DateTimeField, ParserError};
+
+pub(crate) fn tokenize_interval(value: &str) -> Result<Vec<IntervalToken>, ParserError> {
+    let mut toks = vec![];
+    let mut num_buf = String::with_capacity(4);
+    fn parse_num(n: &str, idx: usize) -> Result<IntervalToken, ParserError> {
+        Ok(IntervalToken::Num(n.parse().map_err(|e| {
+            ParserError::ParserError(format!(
+                "Unable to parse value as a number at index {}: {}",
+                idx, e
+            ))
+        })?))
+    };
+    let mut last_field_is_frac = false;
+    for (i, chr) in value.chars().enumerate() {
+        match chr {
+            '-' => {
+                // dashes at the beginning mean make it negative
+                if !num_buf.is_empty() {
+                    toks.push(parse_num(&num_buf, i)?);
+                    num_buf.clear();
+                }
+                toks.push(IntervalToken::Dash);
+            }
+            ' ' => {
+                toks.push(parse_num(&num_buf, i)?);
+                num_buf.clear();
+                toks.push(IntervalToken::Space);
+            }
+            ':' => {
+                toks.push(parse_num(&num_buf, i)?);
+                num_buf.clear();
+                toks.push(IntervalToken::Colon);
+            }
+            '.' => {
+                toks.push(parse_num(&num_buf, i)?);
+                num_buf.clear();
+                toks.push(IntervalToken::Dot);
+                last_field_is_frac = true;
+            }
+            chr if chr.is_digit(10) => num_buf.push(chr),
+            chr => {
+                return Err(ParserError::TokenizerError(format!(
+                    "Invalid character at offset {} in {}: {:?}",
+                    i, value, chr
+                )))
+            }
+        }
+    }
+    if !num_buf.is_empty() {
+        if !last_field_is_frac {
+            toks.push(parse_num(&num_buf, 0)?);
+        } else {
+            let raw: u32 = num_buf.parse().map_err(|e| {
+                ParserError::ParserError(format!(
+                    "couldn't parse fraction of second {}: {}",
+                    num_buf, e
+                ))
+            })?;
+            let leading_zeroes = num_buf.chars().take_while(|c| c == &'0').count() as u32;
+            let multiplicand = 1_000_000_000 / 10_u32.pow(1 + leading_zeroes);
+
+            toks.push(IntervalToken::Nanos(raw * multiplicand));
+        }
+    }
+    Ok(toks)
+}
+
+/// Get the tokens that you *might* end up parsing starting with a most significant unit
+///
+/// For example, parsing `INTERVAL '9-5 4:3' MONTH` is *illegal*, but you
+/// should interpret that as `9 months 5 days 4 hours 3 minutes`. This function
+/// doesn't take any perspective on what things should be, it just teslls you
+/// what the user might have meant.
+fn potential_interval_tokens(from: &DateTimeField) -> Vec<IntervalToken> {
+    use DateTimeField::*;
+    use IntervalToken::*;
+
+    let all_toks = [
+        Num(0), // year
+        Dash,
+        Num(0), // month
+        Dash,
+        Num(0), // day
+        Space,
+        Num(0), // hour
+        Colon,
+        Num(0), // minute
+        Colon,
+        Num(0), // second
+        Dot,
+        Nanos(0), // Nanos
+    ];
+    let offset = match from {
+        Year => 0,
+        Month => 2,
+        Day => 4,
+        Hour => 6,
+        Minute => 8,
+        Second => 10,
+    };
+    all_toks[offset..].to_vec()
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum IntervalToken {
+    Dash,
+    Space,
+    Colon,
+    Dot,
+    Num(u64),
+    Nanos(u32),
+}
+
+pub(crate) fn build_parsed_datetime(
+    tokens: &[IntervalToken],
+    leading_field: &DateTimeField,
+    precision: &Option<DateTimeField>,
+) -> Result<(ParsedDateTime, Vec<String>), ParserError> {
+    use IntervalToken::*;
+
+    // if no precision is specified, then you should use the least possible precision
+    let precision = match precision {
+        Some(p) => p,
+        None => leading_field,
+    };
+
+    let expected = potential_interval_tokens(&leading_field);
+    let mut actual = tokens.iter().peekable();
+
+    let mut warnings = vec![];
+
+    if expected.len() > tokens.len() - 1 {
+        warnings.push(format!(
+            "More precision requested than supplied. Requested {} but only provided {} fields",
+            precision,
+            tokens.len(),
+        ))
+    }
+
+    let is_positive = match actual.peek() {
+        Some(val) if val == &&IntervalToken::Dash => {
+            actual.next();
+            false
+        }
+        _ => true,
+    };
+    let mut current_field = leading_field.clone();
+    let mut pdt = ParsedDateTime {
+        is_positive,
+        ..Default::default()
+    };
+    let mut seconds_seen = 0;
+    for (atok, etok) in actual.zip(&expected) {
+        match (atok, etok) {
+            (Dash, Dash) | (Space, Space) | (Colon, Colon) | (Dot, Dot) => {
+                /* matching punctuation */
+            }
+            (Num(val), Num(_)) => {
+                let val = *val;
+                match current_field {
+                    DateTimeField::Year => pdt.year = Some(val),
+                    DateTimeField::Month => pdt.month = Some(val),
+                    DateTimeField::Day => pdt.day = Some(val),
+                    DateTimeField::Hour => pdt.hour = Some(val),
+                    DateTimeField::Minute => pdt.minute = Some(val),
+                    DateTimeField::Second if seconds_seen == 0 => {
+                        seconds_seen += 1;
+                        pdt.second = Some(val);
+                    }
+                    DateTimeField::Second => {
+                        return parser_err!("Too many numbers to parse as a second at {}", val)
+                    }
+                }
+                if current_field != DateTimeField::Second {
+                    current_field = current_field
+                        .into_iter()
+                        .next()
+                        .expect("Exhausted day iterator");
+                }
+            }
+            (Nanos(val), Nanos(_)) if seconds_seen == 1 => pdt.nano = Some(*val),
+            (provided, expected) => {
+                return parser_err!(
+                    "Invalid interval part: string provided {:?} but expected {:?}",
+                    provided,
+                    expected,
+                )
+            }
+        }
+    }
+
+    Ok((pdt, warnings))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::parser::*;
+
+    #[test]
+    fn test_potential_interval_tokens() {
+        use DateTimeField::*;
+        use IntervalToken::*;
+        assert_eq!(
+            potential_interval_tokens(&Year),
+            vec![
+                Num(0),
+                Dash,
+                Num(0),
+                Dash,
+                Num(0),
+                Space,
+                Num(0),
+                Colon,
+                Num(0),
+                Colon,
+                Num(0),
+                Dot,
+                Nanos(0),
+            ]
+        );
+
+        assert_eq!(
+            potential_interval_tokens(&Day),
+            vec![
+                Num(0),
+                Space,
+                Num(0),
+                Colon,
+                Num(0),
+                Colon,
+                Num(0),
+                Dot,
+                Nanos(0),
+            ]
+        );
+    }
+}
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index 7421586..b9ae677 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -1246,6 +1246,11 @@ fn parse_literal_timestamp() {
     );
 }
 
+#[cfg(test)]
+fn dflt<T: Default>() -> T {
+    <T as Default>::default()
+}
+
 #[test]
 fn parse_literal_interval() {
     let sql = "SELECT INTERVAL '1-1' YEAR TO MONTH";
@@ -1253,6 +1258,11 @@ fn parse_literal_interval() {
     assert_eq!(
         &Expr::Value(Value::Interval {
             value: "1-1".into(),
+            parsed: ParsedDateTime {
+                year: Some(1),
+                month: Some(1),
+                ..dflt()
+            },
             leading_field: DateTimeField::Year,
             leading_precision: None,
             last_field: Some(DateTimeField::Month),
@@ -1266,6 +1276,12 @@ fn parse_literal_interval() {
     assert_eq!(
         &Expr::Value(Value::Interval {
             value: "01:01.01".into(),
+            parsed: ParsedDateTime {
+                minute: Some(1),
+                second: Some(1),
+                nano: Some(10_000_000),
+                ..dflt()
+            },
             leading_field: DateTimeField::Minute,
             leading_precision: Some(5),
             last_field: Some(DateTimeField::Second),
@@ -1279,6 +1295,10 @@ fn parse_literal_interval() {
     assert_eq!(
         &Expr::Value(Value::Interval {
             value: "1".into(),
+            parsed: ParsedDateTime {
+                second: Some(1),
+                ..dflt()
+            },
             leading_field: DateTimeField::Second,
             leading_precision: Some(5),
             last_field: None,
@@ -1292,6 +1312,10 @@ fn parse_literal_interval() {
     assert_eq!(
         &Expr::Value(Value::Interval {
             value: "10".into(),
+            parsed: ParsedDateTime {
+                hour: Some(10),
+                ..dflt()
+            },
             leading_field: DateTimeField::Hour,
             leading_precision: None,
             last_field: None,
@@ -1305,6 +1329,10 @@ fn parse_literal_interval() {
     assert_eq!(
         &Expr::Value(Value::Interval {
             value: "10".into(),
+            parsed: ParsedDateTime {
+                hour: Some(10),
+                ..dflt()
+            },
             leading_field: DateTimeField::Hour,
             leading_precision: Some(1),
             last_field: None,

From 01d6133f95d55fe742d60335a9d54f1597d7b384 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Tue, 13 Aug 2019 15:40:19 -0400
Subject: [PATCH 2/6] Convert the fields of `ast::Value::Interval { fields }`
 into a struct

This will allow us to put some methods on it.
---
 CHANGELOG.md              |   6 ++
 src/ast/mod.rs            |   2 +-
 src/ast/value.rs          | 139 +++-----------------------------------
 src/ast/value/datetime.rs | 132 ++++++++++++++++++++++++++++++++++++
 src/parser.rs             |   4 +-
 tests/sqlparser_common.rs |  20 +++---
 6 files changed, 159 insertions(+), 144 deletions(-)
 create mode 100644 src/ast/value/datetime.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 413ea14..35d331f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,12 @@ Given that the parser produces a typed AST, any changes to the AST will technica
 ## [Unreleased]
 Nothing here yet! Check https://github.com/andygrove/sqlparser-rs/commits/master for undocumented changes.
 
+### Changed
+
+- Now supports parsing date and time types
+    - ast::Value::Interval changed its representation to include an inner
+      IntervalValue that includes a `ParsedDateTime` and some useful methods.
+
 ## [0.4.0] - 2019-07-02
 This release brings us closer to SQL-92 support, mainly thanks to the improvements contributed back from @MaterializeInc's fork and other work by @benesch.
 
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index 0c68192..8bfccb1 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -49,7 +49,7 @@ pub use self::query::{
     Cte, Fetch, Join, JoinConstraint, JoinOperator, OrderByExpr, Query, Select, SelectItem,
     SetExpr, SetOperator, TableAlias, TableFactor, TableWithJoins, Values,
 };
-pub use self::value::{DateTimeField, ParsedDateTime, Value};
+pub use self::value::{DateTimeField, IntervalValue, ParsedDateTime, Value};
 
 struct DisplaySeparated<'a, T>
 where
diff --git a/src/ast/value.rs b/src/ast/value.rs
index 2458e27..7fb03ac 100644
--- a/src/ast/value.rs
+++ b/src/ast/value.rs
@@ -13,6 +13,9 @@
 use bigdecimal::BigDecimal;
 use std::fmt;
 
+mod datetime;
+pub use datetime::{DateTimeField, IntervalValue, ParsedDateTime};
+
 /// Primitive SQL values such as number and string
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Value {
@@ -45,44 +48,7 @@ pub enum Value {
     /// The parser does not validate the `<value>`, nor does it ensure
     /// that the `<leading_field>` units >= the units in `<last_field>`,
     /// so the user will have to reject intervals like `HOUR TO YEAR`.
-    Interval {
-        /// The raw `[value]` that was present in `INTERVAL '[value]'`
-        value: String,
-        /// the fully parsed date time
-        parsed: ParsedDateTime,
-        /// The unit of the first field in the interval. `INTERVAL 'T' MINUTE`
-        /// means `T` is in minutes
-        leading_field: DateTimeField,
-        /// How many digits the leading field is allowed to occupy.
-        ///
-        /// The interval `INTERVAL '1234' MINUTE(3)` is **illegal**, but `INTERVAL
-        /// '123' MINUTE(3)` is fine.
-        ///
-        /// This parser does not do any validation that fields fit.
-        leading_precision: Option<u64>,
-        /// How much precision to keep track of
-        ///
-        /// If this is ommitted, then you are supposed to ignore all of the
-        /// non-lead fields. If it is less precise than the final field, you
-        /// are supposed to ignore the final field.
-        ///
-        /// For the following specifications:
-        ///
-        /// * `INTERVAL '1:1:1' HOURS TO SECONDS` the `last_field` gets
-        ///   `Some(DateTimeField::Second)` and interpreters should generate an
-        ///   interval equivalent to `3661` seconds.
-        /// * In `INTERVAL '1:1:1' HOURS` the `last_field` gets `None` and
-        ///   interpreters should generate an interval equivalent to `3600`
-        ///   seconds.
-        /// * In `INTERVAL '1:1:1' HOURS TO MINUTES` the interval should be
-        ///   equivalent to `3660` seconds.
-        last_field: Option<DateTimeField>,
-        /// The seconds precision can be specified in SQL source as
-        /// `INTERVAL '__' SECOND(_, x)` (in which case the `leading_field`
-        /// will be `Second` and the `last_field` will be `None`),
-        /// or as `__ TO SECOND(x)`.
-        fractional_seconds_precision: Option<u64>,
-    },
+    Interval(IntervalValue),
     /// `NULL` value
     Null,
 }
@@ -99,14 +65,14 @@ impl fmt::Display for Value {
             Value::Date(v) => write!(f, "DATE '{}'", escape_single_quote_string(v)),
             Value::Time(v) => write!(f, "TIME '{}'", escape_single_quote_string(v)),
             Value::Timestamp(v) => write!(f, "TIMESTAMP '{}'", escape_single_quote_string(v)),
-            Value::Interval {
+            Value::Interval(IntervalValue {
                 parsed: _,
                 value,
                 leading_field: DateTimeField::Second,
                 leading_precision: Some(leading_precision),
                 last_field,
                 fractional_seconds_precision: Some(fractional_seconds_precision),
-            } => {
+            }) => {
                 // When the leading field is SECOND, the parser guarantees that
                 // the last field is None.
                 assert!(last_field.is_none());
@@ -118,14 +84,14 @@ impl fmt::Display for Value {
                     fractional_seconds_precision
                 )
             }
-            Value::Interval {
+            Value::Interval(IntervalValue {
                 parsed: _,
                 value,
                 leading_field,
                 leading_precision,
                 last_field,
                 fractional_seconds_precision,
-            } => {
+            }) => {
                 write!(
                     f,
                     "INTERVAL '{}' {}",
@@ -148,95 +114,6 @@ impl fmt::Display for Value {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParsedDateTime {
-    pub is_positive: bool,
-    pub year: Option<u64>,
-    pub month: Option<u64>,
-    pub day: Option<u64>,
-    pub hour: Option<u64>,
-    pub minute: Option<u64>,
-    pub second: Option<u64>,
-    pub nano: Option<u32>,
-}
-
-impl Default for ParsedDateTime {
-    fn default() -> ParsedDateTime {
-        ParsedDateTime {
-            is_positive: true,
-            year: None,
-            month: None,
-            day: None,
-            hour: None,
-            minute: None,
-            second: None,
-            nano: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub enum DateTimeField {
-    Year,
-    Month,
-    Day,
-    Hour,
-    Minute,
-    Second,
-}
-
-impl IntoIterator for DateTimeField {
-    type Item = DateTimeField;
-    type IntoIter = DateTimeFieldIterator;
-    fn into_iter(self) -> DateTimeFieldIterator {
-        DateTimeFieldIterator(Some(self))
-    }
-}
-
-/// An iterator over DateTimeFields
-///
-/// Always starts with the value smaller than the current one.
-///
-/// ```
-/// use sqlparser::ast::DateTimeField::*;
-/// let mut itr = Hour.into_iter();
-/// assert_eq!(itr.next(), Some(Minute));
-/// assert_eq!(itr.next(), Some(Second));
-/// assert_eq!(itr.next(), None);
-/// ```
-pub struct DateTimeFieldIterator(Option<DateTimeField>);
-
-/// Go through fields in descending significance order
-impl Iterator for DateTimeFieldIterator {
-    type Item = DateTimeField;
-    fn next(&mut self) -> Option<Self::Item> {
-        use DateTimeField::*;
-        self.0 = match self.0 {
-            Some(Year) => Some(Month),
-            Some(Month) => Some(Day),
-            Some(Day) => Some(Hour),
-            Some(Hour) => Some(Minute),
-            Some(Minute) => Some(Second),
-            Some(Second) => None,
-            None => None,
-        };
-        self.0.clone()
-    }
-}
-
-impl fmt::Display for DateTimeField {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(match self {
-            DateTimeField::Year => "YEAR",
-            DateTimeField::Month => "MONTH",
-            DateTimeField::Day => "DAY",
-            DateTimeField::Hour => "HOUR",
-            DateTimeField::Minute => "MINUTE",
-            DateTimeField::Second => "SECOND",
-        })
-    }
-}
-
 pub struct EscapeSingleQuoteString<'a>(&'a str);
 
 impl<'a> fmt::Display for EscapeSingleQuoteString<'a> {
diff --git a/src/ast/value/datetime.rs b/src/ast/value/datetime.rs
new file mode 100644
index 0000000..7b8793e
--- /dev/null
+++ b/src/ast/value/datetime.rs
@@ -0,0 +1,132 @@
+use std::fmt;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct IntervalValue {
+    /// The raw `[value]` that was present in `INTERVAL '[value]'`
+    pub value: String,
+    /// the fully parsed date time
+    pub parsed: ParsedDateTime,
+    /// The unit of the first field in the interval. `INTERVAL 'T' MINUTE`
+    /// means `T` is in minutes
+    pub leading_field: DateTimeField,
+    /// How many digits the leading field is allowed to occupy.
+    ///
+    /// The interval `INTERVAL '1234' MINUTE(3)` is **illegal**, but `INTERVAL
+    /// '123' MINUTE(3)` is fine.
+    ///
+    /// This parser does not do any validation that fields fit.
+    pub leading_precision: Option<u64>,
+    /// How much precision to keep track of
+    ///
+    /// If this is ommitted, then you are supposed to ignore all of the
+    /// non-lead fields. If it is less precise than the final field, you
+    /// are supposed to ignore the final field.
+    ///
+    /// For the following specifications:
+    ///
+    /// * `INTERVAL '1:1:1' HOURS TO SECONDS` the `last_field` gets
+    ///   `Some(DateTimeField::Second)` and interpreters should generate an
+    ///   interval equivalent to `3661` seconds.
+    /// * In `INTERVAL '1:1:1' HOURS` the `last_field` gets `None` and
+    ///   interpreters should generate an interval equivalent to `3600`
+    ///   seconds.
+    /// * In `INTERVAL '1:1:1' HOURS TO MINUTES` the interval should be
+    ///   equivalent to `3660` seconds.
+    pub last_field: Option<DateTimeField>,
+    /// The seconds precision can be specified in SQL source as
+    /// `INTERVAL '__' SECOND(_, x)` (in which case the `leading_field`
+    /// will be `Second` and the `last_field` will be `None`),
+    /// or as `__ TO SECOND(x)`.
+    pub fractional_seconds_precision: Option<u64>,
+}
+
+/// All of the fields that can appear in a literal `TIMESTAMP` or `INTERVAL` string
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParsedDateTime {
+    pub is_positive: bool,
+    pub year: Option<u64>,
+    pub month: Option<u64>,
+    pub day: Option<u64>,
+    pub hour: Option<u64>,
+    pub minute: Option<u64>,
+    pub second: Option<u64>,
+    pub nano: Option<u32>,
+}
+
+impl Default for ParsedDateTime {
+    fn default() -> ParsedDateTime {
+        ParsedDateTime {
+            is_positive: true,
+            year: None,
+            month: None,
+            day: None,
+            hour: None,
+            minute: None,
+            second: None,
+            nano: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum DateTimeField {
+    Year,
+    Month,
+    Day,
+    Hour,
+    Minute,
+    Second,
+}
+
+impl fmt::Display for DateTimeField {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            DateTimeField::Year => "YEAR",
+            DateTimeField::Month => "MONTH",
+            DateTimeField::Day => "DAY",
+            DateTimeField::Hour => "HOUR",
+            DateTimeField::Minute => "MINUTE",
+            DateTimeField::Second => "SECOND",
+        })
+    }
+}
+
+/// Iterate over `DateTimeField`s in descending significance
+impl IntoIterator for DateTimeField {
+    type Item = DateTimeField;
+    type IntoIter = DateTimeFieldIterator;
+    fn into_iter(self) -> DateTimeFieldIterator {
+        DateTimeFieldIterator(Some(self))
+    }
+}
+
+/// An iterator over DateTimeFields
+///
+/// Always starts with the value smaller than the current one.
+///
+/// ```
+/// use sqlparser::ast::DateTimeField::*;
+/// let mut itr = Hour.into_iter();
+/// assert_eq!(itr.next(), Some(Minute));
+/// assert_eq!(itr.next(), Some(Second));
+/// assert_eq!(itr.next(), None);
+/// ```
+pub struct DateTimeFieldIterator(Option<DateTimeField>);
+
+/// Go through fields in descending significance order
+impl Iterator for DateTimeFieldIterator {
+    type Item = DateTimeField;
+    fn next(&mut self) -> Option<Self::Item> {
+        use DateTimeField::*;
+        self.0 = match self.0 {
+            Some(Year) => Some(Month),
+            Some(Month) => Some(Day),
+            Some(Day) => Some(Hour),
+            Some(Hour) => Some(Minute),
+            Some(Minute) => Some(Second),
+            Some(Second) => None,
+            None => None,
+        };
+        self.0.clone()
+    }
+}
diff --git a/src/parser.rs b/src/parser.rs
index 4904e58..dad00ba 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -515,14 +515,14 @@ impl Parser {
         let (value, _warnings) =
             Self::parse_interval_string(&raw_value, &leading_field, &last_field)?;
 
-        Ok(Expr::Value(Value::Interval {
+        Ok(Expr::Value(Value::Interval(IntervalValue {
             value: raw_value,
             parsed: value,
             leading_field,
             leading_precision,
             last_field,
             fractional_seconds_precision: fsec_precision,
-        }))
+        })))
     }
 
     /// Parse an operator following an expression
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index b9ae677..2d50ce2 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -1256,7 +1256,7 @@ 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 {
+        &Expr::Value(Value::Interval(IntervalValue {
             value: "1-1".into(),
             parsed: ParsedDateTime {
                 year: Some(1),
@@ -1267,14 +1267,14 @@ fn parse_literal_interval() {
             leading_precision: None,
             last_field: Some(DateTimeField::Month),
             fractional_seconds_precision: None,
-        }),
+        })),
         expr_from_projection(only(&select.projection)),
     );
 
     let sql = "SELECT INTERVAL '01:01.01' MINUTE (5) TO SECOND (5)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Interval {
+        &Expr::Value(Value::Interval(IntervalValue {
             value: "01:01.01".into(),
             parsed: ParsedDateTime {
                 minute: Some(1),
@@ -1286,14 +1286,14 @@ fn parse_literal_interval() {
             leading_precision: Some(5),
             last_field: Some(DateTimeField::Second),
             fractional_seconds_precision: Some(5),
-        }),
+        })),
         expr_from_projection(only(&select.projection)),
     );
 
     let sql = "SELECT INTERVAL '1' SECOND (5, 4)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Interval {
+        &Expr::Value(Value::Interval(IntervalValue {
             value: "1".into(),
             parsed: ParsedDateTime {
                 second: Some(1),
@@ -1303,14 +1303,14 @@ fn parse_literal_interval() {
             leading_precision: Some(5),
             last_field: None,
             fractional_seconds_precision: Some(4),
-        }),
+        })),
         expr_from_projection(only(&select.projection)),
     );
 
     let sql = "SELECT INTERVAL '10' HOUR";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Interval {
+        &Expr::Value(Value::Interval(IntervalValue {
             value: "10".into(),
             parsed: ParsedDateTime {
                 hour: Some(10),
@@ -1320,14 +1320,14 @@ fn parse_literal_interval() {
             leading_precision: None,
             last_field: None,
             fractional_seconds_precision: None,
-        }),
+        })),
         expr_from_projection(only(&select.projection)),
     );
 
     let sql = "SELECT INTERVAL '10' HOUR (1)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Interval {
+        &Expr::Value(Value::Interval(IntervalValue {
             value: "10".into(),
             parsed: ParsedDateTime {
                 hour: Some(10),
@@ -1337,7 +1337,7 @@ fn parse_literal_interval() {
             leading_precision: Some(1),
             last_field: None,
             fractional_seconds_precision: None,
-        }),
+        })),
         expr_from_projection(only(&select.projection)),
     );
 

From 03ba9f8c3a7afe16b666afea414ef5833f65ada9 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Wed, 14 Aug 2019 16:55:50 -0400
Subject: [PATCH 3/6] Add a `computed` value to IntervalValue to get something
 useful

Knowing that we've got some optional number of years/seconds/minutes in a
`ParsedDateTime` isn't nearly as useful as being able to state that you have 13
months or 250,000 milliseconds. Now we can get either/or of those.
---
 src/ast/mod.rs            |   2 +-
 src/ast/value.rs          |  50 +++++-
 src/ast/value/datetime.rs | 125 +++++++++++++
 src/parser.rs             |   2 +-
 tests/sqlparser_common.rs | 370 ++++++++++++++++++++++++++++++--------
 5 files changed, 476 insertions(+), 73 deletions(-)

diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index 8bfccb1..cf96104 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -49,7 +49,7 @@ pub use self::query::{
     Cte, Fetch, Join, JoinConstraint, JoinOperator, OrderByExpr, Query, Select, SelectItem,
     SetExpr, SetOperator, TableAlias, TableFactor, TableWithJoins, Values,
 };
-pub use self::value::{DateTimeField, IntervalValue, ParsedDateTime, Value};
+pub use self::value::{DateTimeField, Interval, IntervalValue, ParsedDateTime, Value};
 
 struct DisplaySeparated<'a, T>
 where
diff --git a/src/ast/value.rs b/src/ast/value.rs
index 7fb03ac..1aebcfb 100644
--- a/src/ast/value.rs
+++ b/src/ast/value.rs
@@ -14,7 +14,18 @@ use bigdecimal::BigDecimal;
 use std::fmt;
 
 mod datetime;
-pub use datetime::{DateTimeField, IntervalValue, ParsedDateTime};
+pub use datetime::{DateTimeField, Interval, IntervalValue, ParsedDateTime};
+
+#[derive(Debug)]
+pub struct ValueError(String);
+
+impl std::error::Error for ValueError {}
+
+impl fmt::Display for ValueError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "ValueError({})", self.0)
+    }
+}
 
 /// Primitive SQL values such as number and string
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -54,6 +65,7 @@ pub enum Value {
 }
 
 impl fmt::Display for Value {
+    #[allow(clippy::unneeded_field_pattern)] // want to be warned if we add another field
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Value::Long(v) => write!(f, "{}", v),
@@ -132,3 +144,39 @@ impl<'a> fmt::Display for EscapeSingleQuoteString<'a> {
 pub fn escape_single_quote_string(s: &str) -> EscapeSingleQuoteString<'_> {
     EscapeSingleQuoteString(s)
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    /// An extremely default interval value
+    fn ivalue() -> IntervalValue {
+        IntervalValue {
+            value: "".into(),
+            parsed: ParsedDateTime::default(),
+            leading_field: DateTimeField::Year,
+            leading_precision: None,
+            last_field: None,
+            fractional_seconds_precision: None,
+        }
+    }
+
+    #[test]
+    fn interval_values() {
+        let mut iv = ivalue();
+        iv.parsed.year = None;
+        match iv.computed() {
+            Err(ValueError { .. }) => {}
+            Ok(why) => panic!("should not be okay: {:?}", why),
+        }
+    }
+
+    #[test]
+    fn iterate_datetimefield() {
+        use DateTimeField::*;
+        assert_eq!(
+            Year.into_iter().take(10).collect::<Vec<_>>(),
+            vec![Month, Day, Hour, Minute, Second]
+        )
+    }
+}
diff --git a/src/ast/value/datetime.rs b/src/ast/value/datetime.rs
index 7b8793e..55163fc 100644
--- a/src/ast/value/datetime.rs
+++ b/src/ast/value/datetime.rs
@@ -1,4 +1,7 @@
 use std::fmt;
+use std::time::Duration;
+
+use super::ValueError;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IntervalValue {
@@ -40,6 +43,128 @@ pub struct IntervalValue {
     pub fractional_seconds_precision: Option<u64>,
 }
 
+impl IntervalValue {
+    /// Get Either the number of Months or the Duration specified by this interval
+    ///
+    /// # Errors
+    ///
+    /// If a required field is missing (i.e. there is no value) or the `TO` field is wrong
+    pub fn computed(&self) -> Result<Interval, ValueError> {
+        use DateTimeField::*;
+        match &self.leading_field {
+            Year => match &self.last_field {
+                Some(Month) => Ok(Interval::Months(
+                    self.positivity() * self.parsed.year.unwrap_or(0) as i64 * 12
+                        + self.parsed.month.unwrap_or(0) as i64,
+                )),
+                Some(Year) | None => self
+                    .parsed
+                    .year
+                    .ok_or_else(|| ValueError("No YEAR provided".into()))
+                    .map(|year| Interval::Months(self.positivity() * year as i64 * 12)),
+                Some(invalid) => Err(ValueError(format!(
+                    "Invalid specifier for YEAR precision: {}",
+                    &invalid
+                ))),
+            },
+            Month => match &self.last_field {
+                Some(Month) | None => self
+                    .parsed
+                    .month
+                    .ok_or_else(|| ValueError("No MONTH provided".into()))
+                    .map(|m| Interval::Months(self.positivity() * m as i64)),
+                Some(invalid) => Err(ValueError(format!(
+                    "Invalid specifier for MONTH precision: {}",
+                    &invalid
+                ))),
+            },
+            durationlike_field => {
+                let mut seconds = 0u64;
+                match self.units_of(&durationlike_field) {
+                    Some(time) => seconds += time * seconds_multiplier(&durationlike_field),
+                    None => {
+                        return Err(ValueError(format!(
+                            "No {} provided in value string for {}",
+                            durationlike_field, self.value
+                        )))
+                    }
+                }
+                let min_field = &self
+                    .last_field
+                    .clone()
+                    .unwrap_or_else(|| durationlike_field.clone());
+                for field in durationlike_field
+                    .clone()
+                    .into_iter()
+                    .take_while(|f| f <= min_field)
+                {
+                    if let Some(time) = self.units_of(&field) {
+                        seconds += time * seconds_multiplier(&field);
+                    }
+                }
+                let duration = match (min_field, self.parsed.nano) {
+                    (DateTimeField::Second, Some(nanos)) => Duration::new(seconds, nanos),
+                    (_, _) => Duration::from_secs(seconds),
+                };
+                Ok(Interval::Duration {
+                    is_positive: self.parsed.is_positive,
+                    duration,
+                })
+            }
+        }
+    }
+
+    /// Retrieve the number that we parsed out of the literal string for the `field`
+    fn units_of(&self, field: &DateTimeField) -> Option<u64> {
+        match field {
+            DateTimeField::Year => self.parsed.year,
+            DateTimeField::Month => self.parsed.month,
+            DateTimeField::Day => self.parsed.day,
+            DateTimeField::Hour => self.parsed.hour,
+            DateTimeField::Minute => self.parsed.minute,
+            DateTimeField::Second => self.parsed.second,
+        }
+    }
+
+    /// `1` if is_positive, otherwise `-1`
+    fn positivity(&self) -> i64 {
+        if self.parsed.is_positive {
+            1
+        } else {
+            -1
+        }
+    }
+}
+
+fn seconds_multiplier(field: &DateTimeField) -> u64 {
+    match field {
+        DateTimeField::Day => 60 * 60 * 24,
+        DateTimeField::Hour => 60 * 60,
+        DateTimeField::Minute => 60,
+        DateTimeField::Second => 1,
+        _other => unreachable!("Do not call with a non-duration field"),
+    }
+}
+
+/// The result of parsing an `INTERVAL '<value>' <unit> [TO <precision>]`
+///
+/// Units of type `YEAR` or `MONTH` are semantically some multiple of months,
+/// which are not well defined, and this parser normalizes them to some number
+/// of months.
+///
+/// Intervals of unit [`DateTimeField::Day`] or smaller are semantically a
+/// multiple of seconds.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Interval {
+    /// A possibly negative number of months for field types like `YEAR`
+    Months(i64),
+    /// An actual timespan, possibly negative, because why not
+    Duration {
+        is_positive: bool,
+        duration: Duration,
+    },
+}
+
 /// All of the fields that can appear in a literal `TIMESTAMP` or `INTERVAL` string
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParsedDateTime {
diff --git a/src/parser.rs b/src/parser.rs
index dad00ba..238f014 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -627,7 +627,7 @@ impl Parser {
             ));
         }
         let toks = datetime::tokenize_interval(value)?;
-        datetime::build_parsed_datetime(&toks, &leading_field, trailing_field)
+        datetime::build_parsed_datetime(&toks, leading_field, trailing_field)
     }
 
     /// Parses the parens following the `[ NOT ] IN` operator
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index 2d50ce2..2e99e4e 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -1246,35 +1246,78 @@ fn parse_literal_timestamp() {
     );
 }
 
-#[cfg(test)]
-fn dflt<T: Default>() -> T {
-    <T as Default>::default()
-}
-
 #[test]
-fn parse_literal_interval() {
-    let sql = "SELECT INTERVAL '1-1' YEAR TO MONTH";
-    let select = verified_only_select(sql);
+fn parse_literal_interval_monthlike() {
+    let mut iv = single_iv();
+    iv.value = "1-1".into();
+    iv.parsed.year = Some(1);
+    iv.parsed.month = Some(1);
+    iv.leading_field = DateTimeField::Year;
+    iv.last_field = Some(DateTimeField::Month);
+    verify_interval(
+        "SELECT INTERVAL '1-1' YEAR TO MONTH",
+        iv,
+        Interval::Months(13),
+        None,
+    );
+
+    let mut iv = single_iv();
+    iv.parsed.year = Some(1);
+    iv.leading_field = DateTimeField::Year;
+    verify_interval("SELECT INTERVAL '1' YEAR", iv, Interval::Months(12), None);
+
+    let mut iv = single_iv();
+    iv.parsed.month = Some(1);
+    iv.leading_field = DateTimeField::Month;
+    verify_interval("SELECT INTERVAL '1' MONTH", iv, Interval::Months(1), None);
+
+    let mut iv = single_iv();
+    iv.parsed.year = Some(1);
+    iv.leading_field = DateTimeField::Year;
+    iv.last_field = Some(DateTimeField::Month);
+    verify_interval(
+        "SELECT INTERVAL '1' YEAR TO MONTH",
+        iv.clone(),
+        Interval::Months(12),
+        None,
+    );
+
+    iv.value = "1-1".to_string();
+    iv.parsed.month = Some(1);
+    verify_interval(
+        "SELECT INTERVAL '1-1' YEAR TO MONTH",
+        iv.clone(),
+        Interval::Months(13),
+        None,
+    );
+
+    // if there is no last field then we only compute the highest significance one
+    iv.last_field = None;
+    verify_interval("SELECT INTERVAL '1-1' YEAR", iv, Interval::Months(12), None);
+}
+
+#[test]
+fn parse_literal_interval_error_messages() {
+    let result = parse_sql_statements("SELECT INTERVAL '1' SECOND TO SECOND");
     assert_eq!(
-        &Expr::Value(Value::Interval(IntervalValue {
-            value: "1-1".into(),
-            parsed: ParsedDateTime {
-                year: Some(1),
-                month: Some(1),
-                ..dflt()
-            },
-            leading_field: DateTimeField::Year,
-            leading_precision: None,
-            last_field: Some(DateTimeField::Month),
-            fractional_seconds_precision: None,
-        })),
-        expr_from_projection(only(&select.projection)),
+        ParserError::ParserError("Expected end of statement, found: SECOND".to_string()),
+        result.unwrap_err(),
     );
 
-    let sql = "SELECT INTERVAL '01:01.01' MINUTE (5) TO SECOND (5)";
-    let select = verified_only_select(sql);
+    let result = parse_sql_statements("SELECT INTERVAL '10' HOUR (1) TO HOUR (2)");
     assert_eq!(
-        &Expr::Value(Value::Interval(IntervalValue {
+        ParserError::ParserError("Expected end of statement, found: (".to_string()),
+        result.unwrap_err(),
+    );
+}
+
+#[test]
+fn parse_literal_interval_with_character_precision() {
+    use std::time::Duration;
+
+    verify_interval(
+        "SELECT INTERVAL '01:01.01' MINUTE (5) TO SECOND (5)",
+        IntervalValue {
             value: "01:01.01".into(),
             parsed: ParsedDateTime {
                 minute: Some(1),
@@ -1286,14 +1329,17 @@ fn parse_literal_interval() {
             leading_precision: Some(5),
             last_field: Some(DateTimeField::Second),
             fractional_seconds_precision: Some(5),
-        })),
-        expr_from_projection(only(&select.projection)),
+        },
+        Interval::Duration {
+            is_positive: true,
+            duration: Duration::new(61, 10_000_000),
+        },
+        Some("61.01s"),
     );
 
-    let sql = "SELECT INTERVAL '1' SECOND (5, 4)";
-    let select = verified_only_select(sql);
-    assert_eq!(
-        &Expr::Value(Value::Interval(IntervalValue {
+    verify_interval(
+        "SELECT INTERVAL '1' SECOND (5, 4)",
+        IntervalValue {
             value: "1".into(),
             parsed: ParsedDateTime {
                 second: Some(1),
@@ -1303,69 +1349,193 @@ fn parse_literal_interval() {
             leading_precision: Some(5),
             last_field: None,
             fractional_seconds_precision: Some(4),
-        })),
-        expr_from_projection(only(&select.projection)),
+        },
+        Interval::Duration {
+            is_positive: true,
+            duration: Duration::from_secs(1),
+        },
+        Some("1s"),
     );
 
-    let sql = "SELECT INTERVAL '10' HOUR";
-    let select = verified_only_select(sql);
-    assert_eq!(
-        &Expr::Value(Value::Interval(IntervalValue {
+    // We ignore the (1) precision because that's what postgres/mysql do, and
+    // it's not actually specified in the spec what's supposed to happen if
+    // it's provided and invalid
+    verify_interval(
+        "SELECT INTERVAL '10' HOUR (1)",
+        IntervalValue {
             value: "10".into(),
             parsed: ParsedDateTime {
                 hour: Some(10),
                 ..dflt()
             },
             leading_field: DateTimeField::Hour,
-            leading_precision: None,
+            leading_precision: Some(1),
             last_field: None,
             fractional_seconds_precision: None,
-        })),
-        expr_from_projection(only(&select.projection)),
+        },
+        Interval::Duration {
+            is_positive: true,
+            duration: Duration::from_secs(10 * 60 * 60),
+        },
+        Some("36000s"),
     );
+}
 
-    let sql = "SELECT INTERVAL '10' HOUR (1)";
-    let select = verified_only_select(sql);
-    assert_eq!(
-        &Expr::Value(Value::Interval(IntervalValue {
+#[test]
+fn parse_literal_interval_durationlike() {
+    use std::time::Duration;
+
+    verify_interval(
+        "SELECT INTERVAL '10' HOUR",
+        IntervalValue {
             value: "10".into(),
             parsed: ParsedDateTime {
                 hour: Some(10),
                 ..dflt()
             },
             leading_field: DateTimeField::Hour,
-            leading_precision: Some(1),
+            leading_precision: None,
             last_field: None,
             fractional_seconds_precision: None,
-        })),
-        expr_from_projection(only(&select.projection)),
-    );
-
-    let result = parse_sql_statements("SELECT INTERVAL '1' SECOND TO SECOND");
-    assert_eq!(
-        ParserError::ParserError("Expected end of statement, found: SECOND".to_string()),
-        result.unwrap_err(),
+        },
+        Interval::Duration {
+            is_positive: true,
+            duration: Duration::from_secs(10 * 60 * 60),
+        },
+        Some("36000s"),
+    );
+
+    let mut iv = single_iv();
+    iv.parsed.day = Some(1);
+    iv.leading_field = DateTimeField::Day;
+    verify_interval(
+        "SELECT INTERVAL '1' DAY",
+        iv,
+        dur_secs(3600 * 24),
+        Some("86400s"),
+    );
+    let mut iv = single_iv();
+    iv.parsed.hour = Some(1);
+    iv.leading_field = DateTimeField::Hour;
+    verify_interval(
+        "SELECT INTERVAL '1' HOUR",
+        iv,
+        dur_secs(3600),
+        Some("3600s"),
+    );
+    let mut iv = single_iv();
+    iv.parsed.minute = Some(1);
+    iv.leading_field = DateTimeField::Minute;
+    verify_interval("SELECT INTERVAL '1' MINUTE", iv, dur_secs(60), Some("60s"));
+    let mut iv = single_iv();
+    iv.parsed.second = Some(1);
+    iv.leading_field = DateTimeField::Second;
+    verify_interval("SELECT INTERVAL '1' SECOND", iv, dur_secs(1), Some("1s"));
+
+    let mut iv = single_iv();
+    iv.parsed.day = Some(1);
+    iv.leading_field = DateTimeField::Day;
+    iv.last_field = Some(DateTimeField::Hour);
+    verify_interval(
+        "SELECT INTERVAL '1' DAY TO HOUR",
+        iv.clone(),
+        dur_secs(3600 * 24),
+        Some("86400s"),
+    );
+    iv.last_field = Some(DateTimeField::Minute);
+    verify_interval(
+        "SELECT INTERVAL '1' DAY TO MINUTE",
+        iv.clone(),
+        dur_secs(3600 * 24),
+        Some("86400s"),
+    );
+    iv.last_field = Some(DateTimeField::Second);
+    verify_interval(
+        "SELECT INTERVAL '1' DAY TO SECOND",
+        iv.clone(),
+        dur_secs(3600 * 24),
+        Some("86400s"),
+    );
+    iv.value = "1 1:1:1.1".to_string();
+    iv.parsed.hour = Some(1);
+    iv.parsed.minute = Some(1);
+    iv.parsed.second = Some(1);
+    iv.parsed.nano = Some(100_000_000);
+    verify_interval(
+        "SELECT INTERVAL '1 1:1:1.1' DAY TO SECOND",
+        iv.clone(),
+        Interval::Duration {
+            is_positive: true,
+            duration: Duration::new(3600 * 24 + 3600 + 60 + 1, 100_000_000),
+        },
+        Some("90061.1s"),
+    );
+
+    iv.last_field = None;
+    verify_interval(
+        "SELECT INTERVAL '1 1:1:1.1' DAY",
+        iv,
+        dur_secs(3600 * 24),
+        Some("86400s"),
+    );
+
+    let mut iv = single_iv();
+    iv.parsed.hour = Some(1);
+    iv.last_field = Some(DateTimeField::Minute);
+    verify_interval(
+        "SELECT INTERVAL '1' HOUR TO MINUTE",
+        iv.clone(),
+        dur_secs(3600),
+        Some("3600s"),
+    );
+    iv.last_field = Some(DateTimeField::Second);
+    verify_interval(
+        "SELECT INTERVAL '1' HOUR TO SECOND",
+        iv,
+        dur_secs(3600),
+        Some("3600s"),
+    );
+
+    let mut iv = single_iv();
+    iv.parsed.minute = Some(1);
+    iv.leading_field = DateTimeField::Minute;
+    iv.last_field = Some(DateTimeField::Minute);
+    verify_interval(
+        "SELECT INTERVAL '1' MINUTE TO MINUTE",
+        iv.clone(),
+        dur_secs(60),
+        Some("60s"),
+    );
+    iv.last_field = Some(DateTimeField::Second);
+    verify_interval(
+        "SELECT INTERVAL '1' MINUTE TO SECOND",
+        iv,
+        dur_secs(60),
+        Some("60s"),
+    );
+
+    // Negatives
+    let mut iv = single_iv();
+    iv.value = "-1".into();
+    iv.parsed.is_positive = false;
+    iv.parsed.hour = Some(1);
+    verify_interval(
+        "SELECT INTERVAL '-1' HOUR",
+        iv,
+        Interval::Duration {
+            is_positive: false,
+            duration: Duration::from_secs(3600),
+        },
+        Some("3600s"),
     );
 
-    let result = parse_sql_statements("SELECT INTERVAL '10' HOUR (1) TO HOUR (2)");
-    assert_eq!(
-        ParserError::ParserError("Expected end of statement, found: (".to_string()),
-        result.unwrap_err(),
-    );
+    let mut iv = single_iv();
+    iv.value = "-1".into();
+    iv.leading_field = DateTimeField::Month;
+    iv.parsed.is_positive = false;
+    iv.parsed.month = Some(1);
 
-    verified_only_select("SELECT INTERVAL '1' YEAR");
-    verified_only_select("SELECT INTERVAL '1' MONTH");
-    verified_only_select("SELECT INTERVAL '1' DAY");
-    verified_only_select("SELECT INTERVAL '1' HOUR");
-    verified_only_select("SELECT INTERVAL '1' MINUTE");
-    verified_only_select("SELECT INTERVAL '1' SECOND");
-    verified_only_select("SELECT INTERVAL '1' YEAR TO MONTH");
-    verified_only_select("SELECT INTERVAL '1' DAY TO HOUR");
-    verified_only_select("SELECT INTERVAL '1' DAY TO MINUTE");
-    verified_only_select("SELECT INTERVAL '1' DAY TO SECOND");
-    verified_only_select("SELECT INTERVAL '1' HOUR TO MINUTE");
-    verified_only_select("SELECT INTERVAL '1' HOUR TO SECOND");
-    verified_only_select("SELECT INTERVAL '1' MINUTE TO SECOND");
+    verify_interval("SELECT INTERVAL '-1' MONTH", iv, Interval::Months(-1), None);
 }
 
 #[test]
@@ -2786,3 +2956,63 @@ fn verified_only_select(query: &str) -> Select {
 fn verified_expr(query: &str) -> Expr {
     all_dialects().verified_expr(query)
 }
+
+// interval test helpers
+
+fn dflt<T: Default>() -> T {
+    <T as Default>::default()
+}
+
+fn verify_interval(
+    sql: &str,
+    value: IntervalValue,
+    expected_computed: Interval,
+    expected_duration_str: Option<&str>,
+) {
+    // If there's a failure this shows every the statement verified in this
+    // test, pointing out which one failed
+    println!("testing: {}", sql);
+    let select = verified_only_select(sql);
+    match expr_from_projection(only(&select.projection)) {
+        Expr::Value(Value::Interval(iv)) => {
+            assert_eq!(&value, iv);
+
+            let actually_computed = iv.computed().unwrap();
+            assert_eq!(expected_computed, actually_computed);
+
+            if let Some(expected_dur) = expected_duration_str {
+                match actually_computed {
+                    // XXX: technically the duration debug format is unstable,
+                    // so this might break for no reason, but it's very
+                    // convenient for sanity-checking that our math is right.
+                    Interval::Duration { duration, .. } => {
+                        assert_eq!(expected_dur, &format!("{:?}", duration))
+                    }
+                    other => panic!("unexpected computed for {}: {:?}", sql, other),
+                }
+            }
+        }
+        v => panic!("invalid value, expected interval for {}: {:?}", sql, v),
+    }
+}
+
+/// Get an `IntervalValue` that has some reasonable defaults for test mocks
+fn single_iv() -> IntervalValue {
+    IntervalValue {
+        value: "1".into(),
+        parsed: ParsedDateTime::default(),
+        leading_field: DateTimeField::Hour,
+        leading_precision: None,
+        last_field: None,
+        fractional_seconds_precision: None,
+    }
+}
+
+fn dur_secs(n: u64) -> Interval {
+    use std::time::Duration;
+
+    Interval::Duration {
+        is_positive: true,
+        duration: Duration::from_secs(n),
+    }
+}

From 1c69bee539ef7fdf9f56b3bf68610490f0f04333 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Tue, 20 Aug 2019 10:58:16 -0400
Subject: [PATCH 4/6] Add an `IntervalValue::fields_match_precision`
 error-checking method

This allows parser-users to be more restrictive in the values that they accept
if they want to use the `IntervalValue::computed` method, because afaict no
databases in existence actually match any SQL spec for their interpretation of
interval literal values[1].

[1]: https://github.com/MaterializeInc/sqlparser/pull/8#issuecomment-522064450
---
 src/ast/value.rs          |   4 +-
 src/ast/value/datetime.rs | 104 +++++++++++++++++++++++++++++++-
 src/parser.rs             |   8 +--
 src/parser/datetime.rs    |  28 +++------
 tests/sqlparser_common.rs | 123 +++++++++++++++++++++++++++++++++++---
 5 files changed, 230 insertions(+), 37 deletions(-)

diff --git a/src/ast/value.rs b/src/ast/value.rs
index 1aebcfb..2b3ecab 100644
--- a/src/ast/value.rs
+++ b/src/ast/value.rs
@@ -23,7 +23,7 @@ impl std::error::Error for ValueError {}
 
 impl fmt::Display for ValueError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "ValueError({})", self.0)
+        write!(f, "{}", self.0)
     }
 }
 
@@ -165,7 +165,7 @@ mod test {
     fn interval_values() {
         let mut iv = ivalue();
         iv.parsed.year = None;
-        match iv.computed() {
+        match iv.computed_permissive() {
             Err(ValueError { .. }) => {}
             Ok(why) => panic!("should not be okay: {:?}", why),
         }
diff --git a/src/ast/value/datetime.rs b/src/ast/value/datetime.rs
index 55163fc..d7f18c2 100644
--- a/src/ast/value/datetime.rs
+++ b/src/ast/value/datetime.rs
@@ -46,10 +46,20 @@ pub struct IntervalValue {
 impl IntervalValue {
     /// Get Either the number of Months or the Duration specified by this interval
     ///
+    /// This computes the fiels permissively: it assumes that the leading field
+    /// (i.e. the lead in `INTERVAL 'str' LEAD [TO LAST]`) is valid and parses
+    /// all field in the `str` starting at the leading field, ignoring the
+    /// truncation that should be specified by `LAST`.
+    ///
+    /// See also the related [`fields_match_precision`] function that will give
+    /// an error if the interval string does not exactly match the `FROM TO
+    /// LAST` spec.
+    ///
     /// # Errors
     ///
-    /// If a required field is missing (i.e. there is no value) or the `TO` field is wrong
-    pub fn computed(&self) -> Result<Interval, ValueError> {
+    /// If a required field is missing (i.e. there is no value) or the `TO
+    /// LAST` field is larger than the `LEAD`.
+    pub fn computed_permissive(&self) -> Result<Interval, ValueError> {
         use DateTimeField::*;
         match &self.leading_field {
             Year => match &self.last_field {
@@ -126,6 +136,89 @@ impl IntervalValue {
         }
     }
 
+    /// Verify that the fields in me make sense
+    ///
+    /// Returns Ok if the fields are fully specified, otherwise an error
+    ///
+    /// # Examples
+    ///
+    /// ```sql
+    /// INTERVAL '1 5' DAY TO HOUR -- Ok
+    /// INTERVAL '1 5' DAY         -- Err
+    /// INTERVAL '1:2:3' HOUR TO SECOND   -- Ok
+    /// INTERVAL '1:2:3' HOUR TO MINUTE   -- Err
+    /// INTERVAL '1:2:3' MINUTE TO SECOND -- Err
+    /// INTERVAL '1:2:3' DAY TO SECOND    -- Err
+    /// ```
+    pub fn fields_match_precision(&self) -> Result<(), ValueError> {
+        let mut errors = vec![];
+        let last_field = self
+            .last_field
+            .as_ref()
+            .unwrap_or_else(|| &self.leading_field);
+        let mut extra_leading_fields = vec![];
+        let mut extra_trailing_fields = vec![];
+        // check for more data in the input string than was requested in <FIELD> TO <FIELD>
+        for field in std::iter::once(DateTimeField::Year).chain(DateTimeField::Year.into_iter()) {
+            if self.units_of(&field).is_none() {
+                continue;
+            }
+
+            if field < self.leading_field {
+                extra_leading_fields.push(field.clone());
+            }
+            if &field > last_field {
+                extra_trailing_fields.push(field.clone());
+            }
+        }
+
+        if !extra_leading_fields.is_empty() {
+            errors.push(format!(
+                "The interval string '{}' specifies {}s but the significance requested is {}",
+                self.value,
+                fields_msg(extra_leading_fields.into_iter()),
+                self.leading_field
+            ));
+        }
+        if !extra_trailing_fields.is_empty() {
+            errors.push(format!(
+                "The interval string '{}' specifies {}s but the requested precision would truncate to {}",
+                self.value, fields_msg(extra_trailing_fields.into_iter()), last_field
+            ));
+        }
+
+        // check for data requested by the <FIELD> TO <FIELD> that does not exist in the data
+        let missing_fields = match (
+            self.units_of(&self.leading_field),
+            self.units_of(&last_field),
+        ) {
+            (Some(_), Some(_)) => vec![],
+            (None, Some(_)) => vec![&self.leading_field],
+            (Some(_), None) => vec![last_field],
+            (None, None) => vec![&self.leading_field, last_field],
+        };
+
+        if !missing_fields.is_empty() {
+            errors.push(format!(
+                "The interval string '{}' provides {} - which does not include the requested field(s) {}",
+                self.value, self.present_fields(), fields_msg(missing_fields.into_iter().cloned())));
+        }
+
+        if !errors.is_empty() {
+            Err(ValueError(errors.join("; ")))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn present_fields(&self) -> String {
+        fields_msg(
+            std::iter::once(DateTimeField::Year)
+                .chain(DateTimeField::Year.into_iter())
+                .filter(|field| self.units_of(&field).is_some()),
+        )
+    }
+
     /// `1` if is_positive, otherwise `-1`
     fn positivity(&self) -> i64 {
         if self.parsed.is_positive {
@@ -136,6 +229,13 @@ impl IntervalValue {
     }
 }
 
+fn fields_msg(fields: impl Iterator<Item = DateTimeField>) -> String {
+    fields
+        .map(|field: DateTimeField| field.to_string())
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
 fn seconds_multiplier(field: &DateTimeField) -> u64 {
     match field {
         DateTimeField::Day => 60 * 60 * 24,
diff --git a/src/parser.rs b/src/parser.rs
index 238f014..eb4f5a5 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -512,8 +512,7 @@ impl Parser {
                 }
             };
 
-        let (value, _warnings) =
-            Self::parse_interval_string(&raw_value, &leading_field, &last_field)?;
+        let value = Self::parse_interval_string(&raw_value, &leading_field)?;
 
         Ok(Expr::Value(Value::Interval(IntervalValue {
             value: raw_value,
@@ -619,15 +618,14 @@ impl Parser {
     pub fn parse_interval_string(
         value: &str,
         leading_field: &DateTimeField,
-        trailing_field: &Option<DateTimeField>,
-    ) -> Result<(ParsedDateTime, Vec<String>), ParserError> {
+    ) -> Result<ParsedDateTime, ParserError> {
         if value.is_empty() {
             return Err(ParserError::ParserError(
                 "Interval date string is empty!".to_string(),
             ));
         }
         let toks = datetime::tokenize_interval(value)?;
-        datetime::build_parsed_datetime(&toks, leading_field, trailing_field)
+        datetime::build_parsed_datetime(&toks, leading_field, value)
     }
 
     /// Parses the parens following the `[ NOT ] IN` operator
diff --git a/src/parser/datetime.rs b/src/parser/datetime.rs
index 7189e57..e589a34 100644
--- a/src/parser/datetime.rs
+++ b/src/parser/datetime.rs
@@ -116,29 +116,13 @@ pub(crate) enum IntervalToken {
 pub(crate) fn build_parsed_datetime(
     tokens: &[IntervalToken],
     leading_field: &DateTimeField,
-    precision: &Option<DateTimeField>,
-) -> Result<(ParsedDateTime, Vec<String>), ParserError> {
+    value: &str,
+) -> Result<ParsedDateTime, ParserError> {
     use IntervalToken::*;
 
-    // if no precision is specified, then you should use the least possible precision
-    let precision = match precision {
-        Some(p) => p,
-        None => leading_field,
-    };
-
     let expected = potential_interval_tokens(&leading_field);
     let mut actual = tokens.iter().peekable();
 
-    let mut warnings = vec![];
-
-    if expected.len() > tokens.len() - 1 {
-        warnings.push(format!(
-            "More precision requested than supplied. Requested {} but only provided {} fields",
-            precision,
-            tokens.len(),
-        ))
-    }
-
     let is_positive = match actual.peek() {
         Some(val) if val == &&IntervalToken::Dash => {
             actual.next();
@@ -152,7 +136,7 @@ pub(crate) fn build_parsed_datetime(
         ..Default::default()
     };
     let mut seconds_seen = 0;
-    for (atok, etok) in actual.zip(&expected) {
+    for (i, (atok, etok)) in actual.zip(&expected).enumerate() {
         match (atok, etok) {
             (Dash, Dash) | (Space, Space) | (Colon, Colon) | (Dot, Dot) => {
                 /* matching punctuation */
@@ -183,7 +167,9 @@ pub(crate) fn build_parsed_datetime(
             (Nanos(val), Nanos(_)) if seconds_seen == 1 => pdt.nano = Some(*val),
             (provided, expected) => {
                 return parser_err!(
-                    "Invalid interval part: string provided {:?} but expected {:?}",
+                    "Invalid interval part at offset {}: '{}' provided {:?} but expected {:?}",
+                    i,
+                    value,
                     provided,
                     expected,
                 )
@@ -191,7 +177,7 @@ pub(crate) fn build_parsed_datetime(
         }
     }
 
-    Ok((pdt, warnings))
+    Ok(pdt)
 }
 
 #[cfg(test)]
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index 2e99e4e..7697135 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -1259,17 +1259,30 @@ fn parse_literal_interval_monthlike() {
         iv,
         Interval::Months(13),
         None,
+        None,
     );
 
     let mut iv = single_iv();
     iv.parsed.year = Some(1);
     iv.leading_field = DateTimeField::Year;
-    verify_interval("SELECT INTERVAL '1' YEAR", iv, Interval::Months(12), None);
+    verify_interval(
+        "SELECT INTERVAL '1' YEAR",
+        iv,
+        Interval::Months(12),
+        None,
+        None,
+    );
 
     let mut iv = single_iv();
     iv.parsed.month = Some(1);
     iv.leading_field = DateTimeField::Month;
-    verify_interval("SELECT INTERVAL '1' MONTH", iv, Interval::Months(1), None);
+    verify_interval(
+        "SELECT INTERVAL '1' MONTH",
+        iv,
+        Interval::Months(1),
+        None,
+        None,
+    );
 
     let mut iv = single_iv();
     iv.parsed.year = Some(1);
@@ -1280,6 +1293,7 @@ fn parse_literal_interval_monthlike() {
         iv.clone(),
         Interval::Months(12),
         None,
+        Some("The interval string '1' provides YEAR - which does not include the requested field(s) MONTH"),
     );
 
     iv.value = "1-1".to_string();
@@ -1289,11 +1303,18 @@ fn parse_literal_interval_monthlike() {
         iv.clone(),
         Interval::Months(13),
         None,
+        None,
     );
 
     // if there is no last field then we only compute the highest significance one
     iv.last_field = None;
-    verify_interval("SELECT INTERVAL '1-1' YEAR", iv, Interval::Months(12), None);
+    verify_interval(
+        "SELECT INTERVAL '1-1' YEAR",
+        iv.clone(),
+        Interval::Months(12),
+        None,
+        Some("The interval string '1-1' specifies MONTHs but the requested precision would truncate to YEAR"),
+    );
 }
 
 #[test]
@@ -1309,6 +1330,24 @@ fn parse_literal_interval_error_messages() {
         ParserError::ParserError("Expected end of statement, found: (".to_string()),
         result.unwrap_err(),
     );
+
+    let result = parse_sql_statements("SELECT INTERVAL '1 1-1' DAY");
+    assert_eq!(
+        ParserError::ParserError(
+            "Invalid interval part at offset 3: '1 1-1' provided Dash but expected Colon"
+                .to_string()
+        ),
+        result.unwrap_err()
+    );
+
+    let result = parse_sql_statements("SELECT INTERVAL '1 1:1' HOUR");
+    assert_eq!(
+        ParserError::ParserError(
+            "Invalid interval part at offset 1: '1 1:1' provided Space but expected Colon"
+                .to_string(),
+        ),
+        result.unwrap_err()
+    );
 }
 
 #[test]
@@ -1335,6 +1374,7 @@ fn parse_literal_interval_with_character_precision() {
             duration: Duration::new(61, 10_000_000),
         },
         Some("61.01s"),
+        None,
     );
 
     verify_interval(
@@ -1355,6 +1395,7 @@ fn parse_literal_interval_with_character_precision() {
             duration: Duration::from_secs(1),
         },
         Some("1s"),
+        None,
     );
 
     // We ignore the (1) precision because that's what postgres/mysql do, and
@@ -1378,6 +1419,7 @@ fn parse_literal_interval_with_character_precision() {
             duration: Duration::from_secs(10 * 60 * 60),
         },
         Some("36000s"),
+        None,
     );
 }
 
@@ -1403,6 +1445,7 @@ fn parse_literal_interval_durationlike() {
             duration: Duration::from_secs(10 * 60 * 60),
         },
         Some("36000s"),
+        None,
     );
 
     let mut iv = single_iv();
@@ -1413,6 +1456,7 @@ fn parse_literal_interval_durationlike() {
         iv,
         dur_secs(3600 * 24),
         Some("86400s"),
+        None,
     );
     let mut iv = single_iv();
     iv.parsed.hour = Some(1);
@@ -1422,15 +1466,57 @@ fn parse_literal_interval_durationlike() {
         iv,
         dur_secs(3600),
         Some("3600s"),
+        None,
     );
     let mut iv = single_iv();
     iv.parsed.minute = Some(1);
     iv.leading_field = DateTimeField::Minute;
-    verify_interval("SELECT INTERVAL '1' MINUTE", iv, dur_secs(60), Some("60s"));
+    verify_interval(
+        "SELECT INTERVAL '1' MINUTE",
+        iv,
+        dur_secs(60),
+        Some("60s"),
+        None,
+    );
     let mut iv = single_iv();
     iv.parsed.second = Some(1);
     iv.leading_field = DateTimeField::Second;
-    verify_interval("SELECT INTERVAL '1' SECOND", iv, dur_secs(1), Some("1s"));
+    verify_interval(
+        "SELECT INTERVAL '1' SECOND",
+        iv,
+        dur_secs(1),
+        Some("1s"),
+        None,
+    );
+
+    let mut iv = single_iv();
+    iv.value = "1 4:5".into();
+    iv.parsed.day = Some(1);
+    iv.parsed.hour = Some(4);
+    iv.parsed.minute = Some(5);
+    iv.leading_field = DateTimeField::Day;
+    iv.last_field = Some(DateTimeField::Hour);
+    verify_interval(
+        "SELECT INTERVAL '1 4:5' DAY TO HOUR",
+        iv.clone(),
+        dur_secs(3600 * 24 + 4 * 3600),
+        Some("100800s"),
+        Some("The interval string '1 4:5' specifies MINUTEs but the requested precision would truncate to HOUR"),
+    );
+    let mut iv = single_iv();
+    iv.value = "1 2:3".into();
+    iv.parsed.day = Some(1);
+    iv.parsed.hour = Some(2);
+    iv.parsed.minute = Some(3);
+    iv.leading_field = DateTimeField::Day;
+    iv.last_field = Some(DateTimeField::Second);
+    verify_interval(
+        "SELECT INTERVAL '1 2:3' DAY TO SECOND",
+        iv.clone(),
+        dur_secs(3600 * 24 + 2 * 3600 + 3 * 60),
+        Some("93780s"),
+        Some("The interval string '1 2:3' provides DAY, HOUR, MINUTE - which does not include the requested field(s) SECOND"),
+    );
 
     let mut iv = single_iv();
     iv.parsed.day = Some(1);
@@ -1441,6 +1527,7 @@ fn parse_literal_interval_durationlike() {
         iv.clone(),
         dur_secs(3600 * 24),
         Some("86400s"),
+        Some("The interval string '1' provides DAY - which does not include the requested field(s) HOUR"),
     );
     iv.last_field = Some(DateTimeField::Minute);
     verify_interval(
@@ -1448,6 +1535,7 @@ fn parse_literal_interval_durationlike() {
         iv.clone(),
         dur_secs(3600 * 24),
         Some("86400s"),
+        Some("The interval string '1' provides DAY - which does not include the requested field(s) MINUTE"),
     );
     iv.last_field = Some(DateTimeField::Second);
     verify_interval(
@@ -1455,6 +1543,7 @@ fn parse_literal_interval_durationlike() {
         iv.clone(),
         dur_secs(3600 * 24),
         Some("86400s"),
+        Some("The interval string '1' provides DAY - which does not include the requested field(s) SECOND"),
     );
     iv.value = "1 1:1:1.1".to_string();
     iv.parsed.hour = Some(1);
@@ -1469,6 +1558,7 @@ fn parse_literal_interval_durationlike() {
             duration: Duration::new(3600 * 24 + 3600 + 60 + 1, 100_000_000),
         },
         Some("90061.1s"),
+        None,
     );
 
     iv.last_field = None;
@@ -1477,6 +1567,7 @@ fn parse_literal_interval_durationlike() {
         iv,
         dur_secs(3600 * 24),
         Some("86400s"),
+        Some("The interval string '1 1:1:1.1' specifies HOUR, MINUTE, SECONDs but the requested precision would truncate to DAY"),
     );
 
     let mut iv = single_iv();
@@ -1487,6 +1578,7 @@ fn parse_literal_interval_durationlike() {
         iv.clone(),
         dur_secs(3600),
         Some("3600s"),
+        Some("The interval string '1' provides HOUR - which does not include the requested field(s) MINUTE"),
     );
     iv.last_field = Some(DateTimeField::Second);
     verify_interval(
@@ -1494,6 +1586,7 @@ fn parse_literal_interval_durationlike() {
         iv,
         dur_secs(3600),
         Some("3600s"),
+        Some("The interval string '1' provides HOUR - which does not include the requested field(s) SECOND"),
     );
 
     let mut iv = single_iv();
@@ -1505,6 +1598,7 @@ fn parse_literal_interval_durationlike() {
         iv.clone(),
         dur_secs(60),
         Some("60s"),
+        None,
     );
     iv.last_field = Some(DateTimeField::Second);
     verify_interval(
@@ -1512,6 +1606,7 @@ fn parse_literal_interval_durationlike() {
         iv,
         dur_secs(60),
         Some("60s"),
+        Some("The interval string '1' provides MINUTE - which does not include the requested field(s) SECOND"),
     );
 
     // Negatives
@@ -1527,6 +1622,7 @@ fn parse_literal_interval_durationlike() {
             duration: Duration::from_secs(3600),
         },
         Some("3600s"),
+        None,
     );
 
     let mut iv = single_iv();
@@ -1535,7 +1631,13 @@ fn parse_literal_interval_durationlike() {
     iv.parsed.is_positive = false;
     iv.parsed.month = Some(1);
 
-    verify_interval("SELECT INTERVAL '-1' MONTH", iv, Interval::Months(-1), None);
+    verify_interval(
+        "SELECT INTERVAL '-1' MONTH",
+        iv,
+        Interval::Months(-1),
+        None,
+        None,
+    );
 }
 
 #[test]
@@ -2968,6 +3070,7 @@ fn verify_interval(
     value: IntervalValue,
     expected_computed: Interval,
     expected_duration_str: Option<&str>,
+    expected_field_match_error: Option<&str>,
 ) {
     // If there's a failure this shows every the statement verified in this
     // test, pointing out which one failed
@@ -2977,7 +3080,7 @@ fn verify_interval(
         Expr::Value(Value::Interval(iv)) => {
             assert_eq!(&value, iv);
 
-            let actually_computed = iv.computed().unwrap();
+            let actually_computed = iv.computed_permissive().unwrap();
             assert_eq!(expected_computed, actually_computed);
 
             if let Some(expected_dur) = expected_duration_str {
@@ -2994,6 +3097,12 @@ fn verify_interval(
         }
         v => panic!("invalid value, expected interval for {}: {:?}", sql, v),
     }
+    match expected_field_match_error {
+        None => value
+            .fields_match_precision()
+            .unwrap_or_else(|e| panic!("unexpected precision error: {}", e)),
+        Some(msg) => assert_eq!(value.fields_match_precision().unwrap_err().to_string(), msg),
+    }
 }
 
 /// Get an `IntervalValue` that has some reasonable defaults for test mocks

From 8fc8d1e14af7c231bdf8e432b1e079eee427d4c2 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Tue, 20 Aug 2019 14:05:33 -0400
Subject: [PATCH 5/6] Parse Dates

This uses some of the infrastructure added for Intervals to support extracting
the fields of `DATE 'yyyy-mm-dd'`.

It has a similar philosophical position -- it just extracts the fields into a
struct that has numeric fields for the dates, and does very little verification
-- the only thing that it does is verify that month and day are not 0 and fit
into a u8, since the exact number of days in any given month are variable.
---
 CHANGELOG.md              |  2 ++
 src/ast/mod.rs            |  2 +-
 src/ast/value.rs          |  6 ++---
 src/ast/value/datetime.rs | 33 ++++++++++++++++----------
 src/parser.rs             | 48 ++++++++++++++++++++++++++++++++++++-
 src/parser/datetime.rs    | 14 +++++++++--
 tests/sqlparser_common.rs | 50 ++++++++++++++++++++++++++++++++++++++-
 7 files changed, 135 insertions(+), 20 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35d331f..e0405f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,8 @@ Nothing here yet! Check https://github.com/andygrove/sqlparser-rs/commits/master
 - Now supports parsing date and time types
     - ast::Value::Interval changed its representation to include an inner
       IntervalValue that includes a `ParsedDateTime` and some useful methods.
+    - ast::Value::Date changed its representation to include an inner
+      `ParsedDate`
 
 ## [0.4.0] - 2019-07-02
 This release brings us closer to SQL-92 support, mainly thanks to the improvements contributed back from @MaterializeInc's fork and other work by @benesch.
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index cf96104..4a35666 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -49,7 +49,7 @@ pub use self::query::{
     Cte, Fetch, Join, JoinConstraint, JoinOperator, OrderByExpr, Query, Select, SelectItem,
     SetExpr, SetOperator, TableAlias, TableFactor, TableWithJoins, Values,
 };
-pub use self::value::{DateTimeField, Interval, IntervalValue, ParsedDateTime, Value};
+pub use self::value::{DateTimeField, Interval, IntervalValue, ParsedDate, ParsedDateTime, Value};
 
 struct DisplaySeparated<'a, T>
 where
diff --git a/src/ast/value.rs b/src/ast/value.rs
index 2b3ecab..b2c1636 100644
--- a/src/ast/value.rs
+++ b/src/ast/value.rs
@@ -14,7 +14,7 @@ use bigdecimal::BigDecimal;
 use std::fmt;
 
 mod datetime;
-pub use datetime::{DateTimeField, Interval, IntervalValue, ParsedDateTime};
+pub use datetime::{DateTimeField, Interval, IntervalValue, ParsedDate, ParsedDateTime};
 
 #[derive(Debug)]
 pub struct ValueError(String);
@@ -43,7 +43,7 @@ pub enum Value {
     /// Boolean value true or false
     Boolean(bool),
     /// `DATE '...'` literals
-    Date(String),
+    Date(String, ParsedDate),
     /// `TIME '...'` literals
     Time(String),
     /// `TIMESTAMP '...'` literals
@@ -74,7 +74,7 @@ impl fmt::Display for Value {
             Value::NationalStringLiteral(v) => write!(f, "N'{}'", v),
             Value::HexStringLiteral(v) => write!(f, "X'{}'", v),
             Value::Boolean(v) => write!(f, "{}", v),
-            Value::Date(v) => write!(f, "DATE '{}'", escape_single_quote_string(v)),
+            Value::Date(v, _) => write!(f, "DATE '{}'", escape_single_quote_string(v)),
             Value::Time(v) => write!(f, "TIME '{}'", escape_single_quote_string(v)),
             Value::Timestamp(v) => write!(f, "TIMESTAMP '{}'", escape_single_quote_string(v)),
             Value::Interval(IntervalValue {
diff --git a/src/ast/value/datetime.rs b/src/ast/value/datetime.rs
index d7f18c2..84be8bc 100644
--- a/src/ast/value/datetime.rs
+++ b/src/ast/value/datetime.rs
@@ -64,14 +64,14 @@ impl IntervalValue {
         match &self.leading_field {
             Year => match &self.last_field {
                 Some(Month) => Ok(Interval::Months(
-                    self.positivity() * self.parsed.year.unwrap_or(0) as i64 * 12
+                    self.parsed.positivity() * self.parsed.year.unwrap_or(0) as i64 * 12
                         + self.parsed.month.unwrap_or(0) as i64,
                 )),
                 Some(Year) | None => self
                     .parsed
                     .year
                     .ok_or_else(|| ValueError("No YEAR provided".into()))
-                    .map(|year| Interval::Months(self.positivity() * year as i64 * 12)),
+                    .map(|year| Interval::Months(self.parsed.positivity() * year as i64 * 12)),
                 Some(invalid) => Err(ValueError(format!(
                     "Invalid specifier for YEAR precision: {}",
                     &invalid
@@ -82,7 +82,7 @@ impl IntervalValue {
                     .parsed
                     .month
                     .ok_or_else(|| ValueError("No MONTH provided".into()))
-                    .map(|m| Interval::Months(self.positivity() * m as i64)),
+                    .map(|m| Interval::Months(self.parsed.positivity() * m as i64)),
                 Some(invalid) => Err(ValueError(format!(
                     "Invalid specifier for MONTH precision: {}",
                     &invalid
@@ -218,15 +218,6 @@ impl IntervalValue {
                 .filter(|field| self.units_of(&field).is_some()),
         )
     }
-
-    /// `1` if is_positive, otherwise `-1`
-    fn positivity(&self) -> i64 {
-        if self.parsed.is_positive {
-            1
-        } else {
-            -1
-        }
-    }
 }
 
 fn fields_msg(fields: impl Iterator<Item = DateTimeField>) -> String {
@@ -265,6 +256,14 @@ pub enum Interval {
     },
 }
 
+/// The fields of a date
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParsedDate {
+    pub year: i64,
+    pub month: u8,
+    pub day: u8,
+}
+
 /// All of the fields that can appear in a literal `TIMESTAMP` or `INTERVAL` string
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParsedDateTime {
@@ -278,6 +277,16 @@ pub struct ParsedDateTime {
     pub nano: Option<u32>,
 }
 
+impl ParsedDateTime {
+    /// `1` if is_positive, else `-1`
+    pub(crate) fn positivity(&self) -> i64 {
+        match self.is_positive {
+            true => 1,
+            false => -1,
+        }
+    }
+}
+
 impl Default for ParsedDateTime {
     fn default() -> ParsedDateTime {
         ParsedDateTime {
diff --git a/src/parser.rs b/src/parser.rs
index eb4f5a5..c5c5181 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -22,6 +22,8 @@ use super::tokenizer::*;
 use std::error::Error;
 use std::fmt;
 
+use crate::ast::ParsedDate;
+
 // Use `Parser::expected` instead, if possible
 macro_rules! parser_err {
     ($MSG:expr) => {
@@ -201,7 +203,7 @@ impl Parser {
                 }
                 "CASE" => self.parse_case_expr(),
                 "CAST" => self.parse_cast_expr(),
-                "DATE" => Ok(Expr::Value(Value::Date(self.parse_literal_string()?))),
+                "DATE" => Ok(Expr::Value(self.parse_date()?)),
                 "EXISTS" => self.parse_exists_expr(),
                 "EXTRACT" => self.parse_extract_expr(),
                 "INTERVAL" => self.parse_literal_interval(),
@@ -458,6 +460,50 @@ impl Parser {
         }
     }
 
+    fn parse_date(&mut self) -> Result<Value, ParserError> {
+        use std::convert::TryInto;
+
+        let value = self.parse_literal_string()?;
+        let pdt = Self::parse_interval_string(&value, &DateTimeField::Year)?;
+
+        match (pdt.year, pdt.month, pdt.day, pdt.hour) {
+            (Some(year), Some(month), Some(day), None) => {
+                let p_err = |e: std::num::TryFromIntError, field: &str| {
+                    ParserError::ParserError(format!(
+                        "{} in date '{}' is invalid: {}",
+                        field, value, e
+                    ))
+                };
+
+                // type inference with try_into() fails so we need to mutate it negative
+                let mut year: i64 = year.try_into().map_err(|e| p_err(e, "Year"))?;
+                year *= pdt.positivity();
+                if month > 12 || month == 0 {
+                    return parser_err!(
+                        "Month in date '{}' must be a number between 1 and 12, got: {}",
+                        value,
+                        month
+                    );
+                }
+                let month: u8 = month.try_into().expect("invalid month");
+                let day: u8 = day.try_into().map_err(|e| p_err(e, "Day"))?;
+                if day == 0 {
+                    parser_err!("Day in date '{}' cannot be zero: {}", value, day)?;
+                }
+                Ok(Value::Date(value, ParsedDate { year, month, day }))
+            }
+            (Some(_), Some(_), Some(_), Some(hours)) => parser_err!(
+                "Hours cannot be supplied for DATE, got {} in '{}'",
+                hours,
+                value
+            ),
+            (_, _, _, _) => Err(ParserError::ParserError(format!(
+                "year, day and month are all required, got: '{}'",
+                value
+            ))),
+        }
+    }
+
     /// Parse an INTERVAL literal.
     ///
     /// Some syntactically valid intervals:
diff --git a/src/parser/datetime.rs b/src/parser/datetime.rs
index e589a34..6d47a82 100644
--- a/src/parser/datetime.rs
+++ b/src/parser/datetime.rs
@@ -145,8 +145,18 @@ pub(crate) fn build_parsed_datetime(
                 let val = *val;
                 match current_field {
                     DateTimeField::Year => pdt.year = Some(val),
-                    DateTimeField::Month => pdt.month = Some(val),
-                    DateTimeField::Day => pdt.day = Some(val),
+                    DateTimeField::Month => {
+                        if val < 1 {
+                            return parser_err!("Invalid Month {} in {}", val, value);
+                        }
+                        pdt.month = Some(val)
+                    }
+                    DateTimeField::Day => {
+                        if val < 1 {
+                            return parser_err!("Invalid Day {} in {}", val, value);
+                        }
+                        pdt.day = Some(val)
+                    }
                     DateTimeField::Hour => pdt.hour = Some(val),
                     DateTimeField::Minute => pdt.minute = Some(val),
                     DateTimeField::Second if seconds_seen == 0 => {
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index 7697135..8964017 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -1221,9 +1221,57 @@ fn parse_literal_date() {
     let sql = "SELECT DATE '1999-01-01'";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Date("1999-01-01".into())),
+        &Expr::Value(Value::Date(
+            "1999-01-01".into(),
+            ParsedDate {
+                year: 1999,
+                month: 1,
+                day: 1,
+            }
+        )),
+        expr_from_projection(only(&select.projection)),
+    );
+
+    let sql = "SELECT DATE '-1-01-01'";
+    let select = verified_only_select(sql);
+    assert_eq!(
+        &Expr::Value(Value::Date(
+            "-1-01-01".into(),
+            ParsedDate {
+                year: -1,
+                month: 1,
+                day: 1,
+            }
+        )),
+        expr_from_projection(only(&select.projection)),
+    );
+
+    let sql = "SELECT DATE '0-01-01'";
+    let select = verified_only_select(sql);
+    assert_eq!(
+        &Expr::Value(Value::Date(
+            "0-01-01".into(),
+            ParsedDate {
+                year: 0,
+                month: 1,
+                day: 1,
+            }
+        )),
         expr_from_projection(only(&select.projection)),
     );
+
+    assert_eq!(
+        ParserError::ParserError("Invalid Month 0 in 0-00-00".into()),
+        parse_sql_statements("SELECT DATE '0-00-00'").unwrap_err(),
+    );
+    assert_eq!(
+        ParserError::ParserError("Invalid Day 0 in 0-01-00".into()),
+        parse_sql_statements("SELECT DATE '0-01-00'").unwrap_err(),
+    );
+    assert_eq!(
+        ParserError::ParserError("Hours cannot be supplied for DATE, got 2 in '1-1-1 2'".into()),
+        parse_sql_statements("SELECT DATE '1-1-1 2").unwrap_err(),
+    );
 }
 
 #[test]

From 6b489dd2abf0648ed78bbf396c94edefc24dde3f Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Mon, 26 Aug 2019 18:02:26 -0400
Subject: [PATCH 6/6] Parse Timestamps

---
 src/ast/mod.rs            |  4 ++-
 src/ast/value.rs          |  8 +++--
 src/ast/value/datetime.rs | 26 ++++++++++++--
 src/parser.rs             | 71 +++++++++++++++++++++++++++++++++++++--
 src/parser/datetime.rs    |  5 +--
 tests/sqlparser_common.rs | 31 ++++++++++++++++-
 6 files changed, 134 insertions(+), 11 deletions(-)

diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index 4a35666..79cc82e 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -49,7 +49,9 @@ pub use self::query::{
     Cte, Fetch, Join, JoinConstraint, JoinOperator, OrderByExpr, Query, Select, SelectItem,
     SetExpr, SetOperator, TableAlias, TableFactor, TableWithJoins, Values,
 };
-pub use self::value::{DateTimeField, Interval, IntervalValue, ParsedDate, ParsedDateTime, Value};
+pub use self::value::{
+    DateTimeField, Interval, IntervalValue, ParsedDate, ParsedDateTime, ParsedTimestamp, Value,
+};
 
 struct DisplaySeparated<'a, T>
 where
diff --git a/src/ast/value.rs b/src/ast/value.rs
index b2c1636..795dced 100644
--- a/src/ast/value.rs
+++ b/src/ast/value.rs
@@ -14,7 +14,9 @@ use bigdecimal::BigDecimal;
 use std::fmt;
 
 mod datetime;
-pub use datetime::{DateTimeField, Interval, IntervalValue, ParsedDate, ParsedDateTime};
+pub use datetime::{
+    DateTimeField, Interval, IntervalValue, ParsedDate, ParsedDateTime, ParsedTimestamp,
+};
 
 #[derive(Debug)]
 pub struct ValueError(String);
@@ -47,7 +49,7 @@ pub enum Value {
     /// `TIME '...'` literals
     Time(String),
     /// `TIMESTAMP '...'` literals
-    Timestamp(String),
+    Timestamp(String, ParsedTimestamp),
     /// INTERVAL literals, roughly in the following format:
     ///
     /// ```text
@@ -76,7 +78,7 @@ impl fmt::Display for Value {
             Value::Boolean(v) => write!(f, "{}", v),
             Value::Date(v, _) => write!(f, "DATE '{}'", escape_single_quote_string(v)),
             Value::Time(v) => write!(f, "TIME '{}'", escape_single_quote_string(v)),
-            Value::Timestamp(v) => write!(f, "TIMESTAMP '{}'", escape_single_quote_string(v)),
+            Value::Timestamp(v, _) => write!(f, "TIMESTAMP '{}'", escape_single_quote_string(v)),
             Value::Interval(IntervalValue {
                 parsed: _,
                 value,
diff --git a/src/ast/value/datetime.rs b/src/ast/value/datetime.rs
index 84be8bc..bb6b7ac 100644
--- a/src/ast/value/datetime.rs
+++ b/src/ast/value/datetime.rs
@@ -256,7 +256,9 @@ pub enum Interval {
     },
 }
 
-/// The fields of a date
+/// The fields of a Date
+///
+/// This is not guaranteed to be a valid date
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParsedDate {
     pub year: i64,
@@ -264,7 +266,27 @@ pub struct ParsedDate {
     pub day: u8,
 }
 
-/// All of the fields that can appear in a literal `TIMESTAMP` or `INTERVAL` string
+/// The fields in a `Timestamp`
+///
+/// Similar to a [`ParsedDateTime`], except that all the fields are required.
+///
+/// This is not guaranteed to be a valid date
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParsedTimestamp {
+    pub year: i64,
+    pub month: u8,
+    pub day: u8,
+    pub hour: u8,
+    pub minute: u8,
+    pub second: u8,
+    pub nano: u32,
+}
+
+/// All of the fields that can appear in a literal `DATE`, `TIMESTAMP` or `INTERVAL` string
+///
+/// This is only used in an `Interval`, which can have any contiguous set of
+/// fields set, otherwise you are probably looking for [`ParsedDate`] or
+/// [`ParsedTimestamp`].
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParsedDateTime {
     pub is_positive: bool,
diff --git a/src/parser.rs b/src/parser.rs
index c5c5181..5647036 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -22,7 +22,7 @@ use super::tokenizer::*;
 use std::error::Error;
 use std::fmt;
 
-use crate::ast::ParsedDate;
+use crate::ast::{ParsedDate, ParsedTimestamp};
 
 // Use `Parser::expected` instead, if possible
 macro_rules! parser_err {
@@ -212,7 +212,7 @@ impl Parser {
                     expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
                 }),
                 "TIME" => Ok(Expr::Value(Value::Time(self.parse_literal_string()?))),
-                "TIMESTAMP" => Ok(Expr::Value(Value::Timestamp(self.parse_literal_string()?))),
+                "TIMESTAMP" => Ok(Expr::Value(self.parse_timestamp()?)),
                 // Here `w` is a word, check if it's a part of a multi-part
                 // identifier, a function call, or a simple identifier:
                 _ => match self.peek_token() {
@@ -504,6 +504,73 @@ impl Parser {
         }
     }
 
+    fn parse_timestamp(&mut self) -> Result<Value, ParserError> {
+        use std::convert::TryInto;
+
+        let value = self.parse_literal_string()?;
+        let pdt = Self::parse_interval_string(&value, &DateTimeField::Year)?;
+
+        match (
+            pdt.year, pdt.month, pdt.day, pdt.hour, pdt.minute, pdt.second, pdt.nano,
+        ) {
+            (Some(year), Some(month), Some(day), Some(hour), Some(minute), Some(second), nano) => {
+                let p_err = |e: std::num::TryFromIntError, field: &str| {
+                    ParserError::ParserError(format!(
+                        "{} in date '{}' is invalid: {}",
+                        field, value, e
+                    ))
+                };
+
+                // type inference with try_into() fails so we need to mutate it negative
+                let mut year: i64 = year.try_into().map_err(|e| p_err(e, "Year"))?;
+                year *= pdt.positivity();
+                if month > 12 || month == 0 {
+                    return parser_err!(
+                        "Month in date '{}' must be a number between 1 and 12, got: {}",
+                        value,
+                        month
+                    );
+                }
+                let month: u8 = month.try_into().expect("invalid month");
+                if month == 0 {
+                    parser_err!("Month in timestamp '{}' cannot be zero: {}", value, day)?;
+                }
+                let day: u8 = day.try_into().map_err(|e| p_err(e, "Day"))?;
+                if day == 0 {
+                    parser_err!("Day in timestamp '{}' cannot be zero: {}", value, day)?;
+                }
+                let hour: u8 = hour.try_into().map_err(|e| p_err(e, "Hour"))?;
+                if hour > 23 {
+                    parser_err!("Hour in timestamp '{}' cannot be > 23: {}", value, hour)?;
+                }
+                let minute: u8 = minute.try_into().map_err(|e| p_err(e, "Minute"))?;
+                if minute > 59 {
+                    parser_err!("Minute in timestamp '{}' cannot be > 59: {}", value, minute)?;
+                }
+                let second: u8 = second.try_into().map_err(|e| p_err(e, "Minute"))?;
+                if second > 60 {
+                    parser_err!("Second in timestamp '{}' cannot be > 60: {}", value, second)?;
+                }
+                Ok(Value::Timestamp(
+                    value,
+                    ParsedTimestamp {
+                        year,
+                        month,
+                        day,
+                        hour,
+                        minute,
+                        second,
+                        nano: nano.unwrap_or(0),
+                    },
+                ))
+            }
+            _ => Err(ParserError::ParserError(format!(
+                "timestamp is missing fields, year through second are all required, got: '{}'",
+                value
+            ))),
+        }
+    }
+
     /// Parse an INTERVAL literal.
     ///
     /// Some syntactically valid intervals:
diff --git a/src/parser/datetime.rs b/src/parser/datetime.rs
index 6d47a82..8ad098b 100644
--- a/src/parser/datetime.rs
+++ b/src/parser/datetime.rs
@@ -58,8 +58,9 @@ pub(crate) fn tokenize_interval(value: &str) -> Result<Vec<IntervalToken>, Parse
                     num_buf, e
                 ))
             })?;
-            let leading_zeroes = num_buf.chars().take_while(|c| c == &'0').count() as u32;
-            let multiplicand = 1_000_000_000 / 10_u32.pow(1 + leading_zeroes);
+            // this is guaranteed to be ascii, so len is fine
+            let chars = num_buf.len() as u32;
+            let multiplicand = 1_000_000_000 / 10_u32.pow(chars);
 
             toks.push(IntervalToken::Nanos(raw * multiplicand));
         }
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index 8964017..63b0e01 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -1289,7 +1289,36 @@ fn parse_literal_timestamp() {
     let sql = "SELECT TIMESTAMP '1999-01-01 01:23:34'";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Timestamp("1999-01-01 01:23:34".into())),
+        &Expr::Value(Value::Timestamp(
+            "1999-01-01 01:23:34".into(),
+            ParsedTimestamp {
+                year: 1999,
+                month: 1,
+                day: 1,
+                hour: 1,
+                minute: 23,
+                second: 34,
+                nano: 0
+            }
+        )),
+        expr_from_projection(only(&select.projection)),
+    );
+
+    let sql = "SELECT TIMESTAMP '1999-01-01 01:23:34.555'";
+    let select = verified_only_select(sql);
+    assert_eq!(
+        &Expr::Value(Value::Timestamp(
+            "1999-01-01 01:23:34.555".into(),
+            ParsedTimestamp {
+                year: 1999,
+                month: 1,
+                day: 1,
+                hour: 1,
+                minute: 23,
+                second: 34,
+                nano: 555_000_000
+            }
+        )),
         expr_from_projection(only(&select.projection)),
     );
 }