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]: #8 (comment)

Author: quodlibetor

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

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,

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

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,15 +167,17 @@ 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,
                 )
             }
         }
     }
 
-    Ok((pdt, warnings))
+    Ok(pdt)
 }
 
 #[cfg(test)]