Parse Timestamps

Author: quodlibetor

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

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,

src/ast/value/datetime.rs

@@ -256,15 +256,37 @@ 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,
     pub month: u8,
     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,

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:

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));
         }

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)),
     );
 }