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.

Author: quodlibetor

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.

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

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 {

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 {

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:

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 => {

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]