Implement support for Postgresql interval syntax

Author: AmrDeveloper

.github/workflows/ci.yaml

@@ -27,3 +27,11 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
       - run: cargo clippy -- -D warnings
+
+  tests:
+    name: Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo test --all --locked

README.md

@@ -41,6 +41,7 @@ SELECT LEN("Git Query Language")
 SELECT "One" IN ("One", "Two", "Three")
 SELECT "Git Query Language" LIKE "%Query%"
 SELECT INTERVAL '1 year 2 mons 3 days 04:05:06.789'
+SELECT INTERVAL '1 millennium 2 centuries 1 decade ago'
 
 SET @arr = [1, 2, 3];
 SELECT [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

crates/gitql-ast/src/interval.rs

@@ -7,7 +7,7 @@ use std::ops::Mul;
 const INTERVAL_MAX_VALUE_I: i64 = 170_000_000;
 const INTERVAL_MAX_VALUE_F: f64 = 170_000_000.0;
 
-#[derive(Default, PartialEq, Clone)]
+#[derive(Default, Debug, PartialEq, Clone)]
 pub struct Interval {
     pub years: i64,
     pub months: i64,
@@ -109,9 +109,18 @@ impl Display for Interval {
             ));
         }
 
-        let (hours, minutes, seconds) = (self.hours, self.minutes, self.seconds);
+        let (mut hours, mut minutes, mut seconds) = (self.hours, self.minutes, self.seconds);
         if hours != 0 || minutes != 0 || seconds != 0f64 {
-            parts.push(format!("{hours:02}:{minutes:02}:{seconds:02}"));
+            let has_minus_sign =
+                hours.is_negative() || minutes.is_negative() || seconds.is_sign_negative();
+            if has_minus_sign {
+                hours = hours.abs();
+                minutes = minutes.abs();
+                seconds = seconds.abs();
+                parts.push(format!("-{hours:02}:{minutes:02}:{seconds:02}"));
+            } else {
+                parts.push(format!("{hours:02}:{minutes:02}:{seconds:02}"));
+            }
         }
 
         if parts.is_empty() {

crates/gitql-parser/src/parse_interval.rs

@@ -37,38 +37,74 @@ pub(crate) fn parse_interval_expression(
     Ok(Box::new(IntervalExpr::new(interval)))
 }
 
-/// Parse string intl Interval expression.
+/// Parse string into Interval expression.
+///
+/// [@] <quantity> <unit> [quantity unit...] <direction>
+///
+/// quantity: is a number (possibly signed)
+/// unit: is
+///     microsecond, millisecond, second,
+///     minute, hour, day, week, month, year,
+///     decade, century, millennium, or abbreviations or plurals of these units
+/// direction: can be ago or empty
+/// The at sign (@) is optional noise
+///
 /// Ref: https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-INTERVAL-INPUT
 fn parse_interval_literal(
     interval_str: &str,
     location: SourceLocation,
 ) -> Result<Interval, Box<Diagnostic>> {
-    if interval_str.is_empty() {
-        return Err(Diagnostic::error("Invalid input syntax for type interval")
+    let tokens = interval_str.split_whitespace().collect::<Vec<&str>>();
+    if tokens.is_empty() {
+        return Err(Diagnostic::error("Interval value can't be empty")
+            .add_help("Please check the documentation for help")
             .with_location(location)
             .as_boxed());
     }
 
     let mut position = 0;
     let mut interval = Interval::default();
-    let tokens = interval_str.split_whitespace().collect::<Vec<&str>>();
 
+    // Date part
+    let mut has_millenniums = false;
+    let mut has_centuries = false;
+    let mut has_decades = false;
     let mut has_years = false;
     let mut has_months = false;
+    let mut has_week = false;
     let mut has_days = false;
+
+    // Time part
     let mut has_any_time_part = false;
     let mut has_hours: bool = false;
     let mut has_minutes = false;
     let mut has_seconds = false;
 
+    let mut has_direction_ago = false;
+
     while position < tokens.len() {
         let token = tokens[position].trim();
         if token.is_empty() {
             position += 1;
             continue;
         }
 
-        // Parse Days, Months or Years
+        if token == "ago" {
+            if has_direction_ago {
+                return Err(
+                    Diagnostic::error("Interval can't contains more than one `ago`")
+                        .add_help("Please keep at most only one `ago` direction")
+                        .with_location(location)
+                        .as_boxed(),
+                );
+            }
+
+            has_direction_ago = true;
+            position += 1;
+            continue;
+        }
+
+        // Parse Millienniums, Centuries, Decades, Years, Weeks, Months and Days
         if let Ok(value) = token.parse::<i64>() {
             // Consume value
             position += 1;
@@ -84,32 +120,101 @@ fn parse_interval_literal(
             // Parse the unit
             let mut maybe_unit = tokens[position];
             let unit_lower = &maybe_unit.to_lowercase();
-            maybe_unit = &unit_lower.as_str();
+            maybe_unit = unit_lower.as_str();
+
+            if matches!(maybe_unit, "millennium" | "millenniums") {
+                check_interval_value_and_unit(&mut has_millenniums, value, maybe_unit, &location)?;
+                interval.years += value * 1000;
+                position += 1;
+                continue;
+            }
+
+            if matches!(maybe_unit, "century" | "centuries") {
+                check_interval_value_and_unit(&mut has_centuries, value, maybe_unit, &location)?;
+                interval.years += value * 100;
+                position += 1;
+                continue;
+            }
+
+            if matches!(maybe_unit, "decade" | "decades") {
+                check_interval_value_and_unit(&mut has_decades, value, maybe_unit, &location)?;
+                interval.years += value * 10;
+                position += 1;
+                continue;
+            }
 
             if matches!(maybe_unit, "y" | "year" | "years") {
-                check_interval_value_and_unit(&mut has_years, value, maybe_unit, location)?;
-                interval.years = value;
+                check_interval_value_and_unit(&mut has_years, value, maybe_unit, &location)?;
+                interval.years += value;
                 position += 1;
                 continue;
             }
 
             if matches!(maybe_unit, "m" | "mon" | "mons" | "months") {
-                check_interval_value_and_unit(&mut has_months, value, maybe_unit, location)?;
-                interval.months = value;
+                check_interval_value_and_unit(&mut has_months, value, maybe_unit, &location)?;
+                interval.months += value;
+                position += 1;
+                continue;
+            }
+
+            if matches!(maybe_unit, "w" | "week" | "weeks") {
+                check_interval_value_and_unit(&mut has_week, value, maybe_unit, &location)?;
+                interval.days += value * 7;
                 position += 1;
                 continue;
             }
 
             if matches!(maybe_unit, "d" | "day" | "days") {
-                check_interval_value_and_unit(&mut has_days, value, maybe_unit, location)?;
-                interval.days = value;
+                check_interval_value_and_unit(&mut has_days, value, maybe_unit, &location)?;
+                interval.days += value;
                 position += 1;
                 continue;
             }
 
             if matches!(maybe_unit, "h" | "hour" | "hours") {
-                check_interval_value_and_unit(&mut has_any_time_part, value, maybe_unit, location)?;
-                interval.hours = value;
+                check_interval_value_and_unit(&mut has_hours, value, maybe_unit, &location)?;
+                has_any_time_part = true;
+                interval.hours += value;
+                position += 1;
+                continue;
+            }
+
+            if matches!(maybe_unit, "minute" | "minutes") {
+                check_interval_value_and_unit(&mut has_minutes, value, maybe_unit, &location)?;
+                has_any_time_part = true;
+                interval.minutes += value;
+                position += 1;
+                continue;
+            }
+        }
+
+        // Parse Seconds
+        if let Ok(value) = token.parse::<f64>() {
+            // Consume value
+            position += 1;
+
+            if position >= tokens.len() {
+                return Err(Diagnostic::error(&format!(
+                    "Missing interval unit after value {value}",
+                ))
+                .with_location(location)
+                .as_boxed());
+            }
+
+            // Parse the unit
+            let mut maybe_unit = tokens[position];
+            let unit_lower = &maybe_unit.to_lowercase();
+            maybe_unit = unit_lower.as_str();
+
+            if matches!(maybe_unit, "second" | "seconds") {
+                check_interval_value_and_unit(
+                    &mut has_seconds,
+                    value as i64,
+                    maybe_unit,
+                    &location,
+                )?;
+                has_any_time_part = true;
+                interval.seconds += value;
                 position += 1;
                 continue;
             }
@@ -124,7 +229,7 @@ fn parse_interval_literal(
             .as_boxed());
         }
 
-        // Parse Seconds, Minutes or Hours
+        // Parse the optional time part without explicit unit markings (Seconds, Minutes or Hours)
         if token.contains(':') {
             if has_any_time_part {
                 return Err(
@@ -135,15 +240,15 @@ fn parse_interval_literal(
             }
 
             let time_parts: Vec<&str> = token.split(':').collect();
-            if time_parts.len() != 3 && time_parts.len() != 2 {
+            if !matches!(time_parts.len(), 2 | 3) {
                 return Err(Diagnostic::error("Invalid input syntax for type interval")
                     .with_location(location)
                     .as_boxed());
             }
 
             match time_parts[0].parse::<i64>() {
                 Ok(hours) => {
-                    check_interval_value_and_unit(&mut has_hours, hours, time_parts[0], location)?;
+                    check_interval_value_and_unit(&mut has_hours, hours, time_parts[0], &location)?;
                     interval.hours = hours;
                 }
                 Err(_) => {
@@ -159,7 +264,7 @@ fn parse_interval_literal(
                         &mut has_minutes,
                         minutes,
                         time_parts[1],
-                        location,
+                        &location,
                     )?;
                     interval.minutes = minutes;
                 }
@@ -177,7 +282,7 @@ fn parse_interval_literal(
                             &mut has_seconds,
                             seconds as i64,
                             time_parts[2],
-                            location,
+                            &location,
                         )?;
                         interval.seconds = seconds;
                     }
@@ -200,14 +305,19 @@ fn parse_interval_literal(
             .as_boxed());
     }
 
+    // ago directon negates all the fields
+    if has_direction_ago {
+        interval = interval.mul(-1).unwrap_or(interval);
+    }
+
     Ok(interval)
 }
 
 fn check_interval_value_and_unit(
     is_used_twice: &mut bool,
     interval_value: i64,
     unit_name: &str,
-    location: SourceLocation,
+    location: &SourceLocation,
 ) -> Result<(), Box<Diagnostic>> {
     if !*is_used_twice {
         *is_used_twice = true;
@@ -219,14 +329,14 @@ fn check_interval_value_and_unit(
             "Interval value for unit `{unit_name}` is out of the range",
         ))
         .add_help("Interval value must be in range from -170_000_000 to 170_000_000")
-        .with_location(location)
+        .with_location(*location)
         .as_boxed());
     }
 
     Err(Diagnostic::error(&format!(
         "Can't use the same interval unit `{unit_name}` twice",
     ))
-    .with_location(location)
+    .with_location(*location)
     .as_boxed())
 }
 
@@ -247,6 +357,56 @@ mod tests {
         }
     }
 
+    #[test]
+    fn valid_weeks() {
+        let inputs = [
+            "2 w",
+            "2 week",
+            "2 weeks",
+            "1 week 7 day",
+            "1 w 7 d",
+            "1 weeks 7 days",
+        ];
+
+        for input in inputs {
+            let parse_result = parse_interval_literal(input, SourceLocation::default());
+            assert!(parse_result.is_ok());
+
+            if let Ok(interval) = parse_result {
+                assert_eq!(interval.days, 14);
+            }
+        }
+    }
+
+    #[test]
+    fn valid_seconds() {
+        let inputs = ["10.1 second"];
+
+        for input in inputs {
+            let parse_result = parse_interval_literal(input, SourceLocation::default());
+            assert!(parse_result.is_ok());
+
+            if let Ok(interval) = parse_result {
+                assert_eq!(interval.seconds, 10.1);
+            }
+        }
+    }
+
+    #[test]
+    fn ago_direction() {
+        let parse_result = parse_interval_literal("1 y 1 m 1 w 1 d", SourceLocation::default());
+        assert!(parse_result.is_ok());
+
+        let parse_result_with_ago =
+            parse_interval_literal("1 y 1 m 1 w 1 d ago", SourceLocation::default());
+        assert!(parse_result_with_ago.is_ok());
+
+        assert_eq!(
+            parse_result.ok().unwrap().mul(-1).unwrap(),
+            parse_result_with_ago.ok().unwrap()
+        );
+    }
+
     #[test]
     fn invalid_time() {
         let inputs = ["1 h 1:00:00", "1 h 1 h"];