Add support for Range lower and upper bounds

Author: AmrDeveloper

crates/gitql-ast/src/types/range.rs

@@ -39,11 +39,11 @@ impl DataType for RangeType {
         vec![Box::new(self.clone()), self.base.clone()]
     }
 
-    fn can_perform_logical_or_op_with(&self) -> Vec<Box<dyn DataType>> {
+    fn can_perform_logical_and_op_with(&self) -> Vec<Box<dyn DataType>> {
         vec![Box::new(self.clone())]
     }
 
-    fn logical_or_op_result_type(&self, _other: &Box<dyn DataType>) -> Box<dyn DataType> {
+    fn logical_and_op_result_type(&self, _other: &Box<dyn DataType>) -> Box<dyn DataType> {
         Box::new(BoolType)
     }
 }

crates/gitql-core/src/values/base.rs

@@ -484,7 +484,7 @@ impl dyn Value {
     /// or None if this type it's called from wrong [`Value`]
     pub fn as_range(&self) -> Option<(Box<dyn Value>, Box<dyn Value>)> {
         if let Some(range_value) = self.as_any().downcast_ref::<RangeValue>() {
-            return Some((range_value.start.clone(), range_value.end.clone()));
+            return Some((range_value.lower.clone(), range_value.upper.clone()));
         }
         None
     }

crates/gitql-core/src/values/range.rs

@@ -9,31 +9,53 @@ use super::boolean::BoolValue;
 
 #[derive(Clone)]
 pub struct RangeValue {
-    pub start: Box<dyn Value>,
-    pub end: Box<dyn Value>,
+    pub lower: Box<dyn Value>,
+    pub upper: Box<dyn Value>,
     pub base_type: Box<dyn DataType>,
+    pub is_lower_bound_inclusive: bool,
+    pub is_upper_bound_inclusive: bool,
 }
 
 impl RangeValue {
-    pub fn new(start: Box<dyn Value>, end: Box<dyn Value>, base_type: Box<dyn DataType>) -> Self {
+    pub fn new(lower: Box<dyn Value>, upper: Box<dyn Value>, base_type: Box<dyn DataType>) -> Self {
         RangeValue {
-            start,
-            end,
+            lower,
+            upper,
             base_type,
+            is_lower_bound_inclusive: true,
+            is_upper_bound_inclusive: false,
         }
     }
 }
 
 impl Value for RangeValue {
     fn literal(&self) -> String {
-        format!("{}..{}", self.start.literal(), self.end.literal())
+        let lower_bound = if self.is_lower_bound_inclusive {
+            '['
+        } else {
+            '('
+        };
+
+        let upper_bound = if self.is_upper_bound_inclusive {
+            ']'
+        } else {
+            ')'
+        };
+
+        format!(
+            "{lower_bound}{}..{}{upper_bound}",
+            self.lower.literal(),
+            self.upper.literal()
+        )
     }
 
     fn equals(&self, other: &Box<dyn Value>) -> bool {
         if let Some(other_range) = other.as_any().downcast_ref::<RangeValue>() {
             return self.base_type.equals(&other_range.base_type)
-                && self.start.equals(&other_range.start)
-                && self.end.equals(&other_range.end);
+                && self.lower.equals(&other_range.lower)
+                && self.upper.equals(&other_range.upper)
+                && self.is_lower_bound_inclusive == other_range.is_lower_bound_inclusive
+                && self.is_upper_bound_inclusive == other_range.is_upper_bound_inclusive;
         }
         false
     }
@@ -43,50 +65,94 @@ impl Value for RangeValue {
     }
 
     fn data_type(&self) -> Box<dyn DataType> {
-        Box::new(RangeType {
-            base: self.base_type.clone(),
-        })
+        Box::new(RangeType::new(self.base_type.clone()))
     }
 
     fn as_any(&self) -> &dyn Any {
         self
     }
 
-    fn logical_or_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
+    fn logical_and_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
         if let Some(other_range) = other.as_any().downcast_ref::<RangeValue>() {
-            if !self.equals(other) {
-                return Err("Overlap operator expect both Ranges to have same type".to_string());
+            if !self.data_type().equals(&other.data_type()) {
+                return Err("Overlap operator expect both Ranges to have the same type".to_string());
             }
 
-            let max_start = if self.start.compare(&other_range.start).unwrap().is_ge() {
-                &self.start
+            let compare_lowers = self.lower.compare(&other_range.lower).unwrap();
+            let max_lower = if (self.is_lower_bound_inclusive
+                == other_range.is_lower_bound_inclusive
+                && compare_lowers.is_ge())
+                || compare_lowers.is_gt()
+            {
+                &self.lower
             } else {
-                &other_range.start
+                &other_range.lower
             };
 
-            let max_end = if self.end.compare(&other_range.end).unwrap().is_lt() {
-                &self.end
+            let compare_uppers = self.upper.compare(&other_range.upper).unwrap();
+            let max_upper = if (self.is_lower_bound_inclusive
+                == other_range.is_lower_bound_inclusive
+                && compare_uppers.is_le())
+                || compare_uppers.is_lt()
+            {
+                &self.upper
             } else {
-                &other_range.end
+                &other_range.upper
             };
 
-            let is_overlap = max_end.compare(max_start).unwrap().is_ge();
-            return Ok(Box::new(BoolValue { value: is_overlap }));
+            let is_overlap = max_upper.compare(max_lower).unwrap().is_gt();
+            return Ok(Box::new(BoolValue::new(is_overlap)));
         }
         Err("Unexpected type to perform `Range Overlap &&` with".to_string())
     }
 
     fn contains_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
         if let Some(other_range) = other.as_any().downcast_ref::<RangeValue>() {
-            let is_in_range = other_range.start.compare(&self.start).unwrap().is_ge()
-                && other_range.end.compare(&self.end).unwrap().is_le();
-            return Ok(Box::new(BoolValue { value: is_in_range }));
+            let is_lower_in_range =
+            // Current range has no lower boundraies
+            if self.lower.is_null() {
+                true
+            }
+            // Current range has lower boundraies, but the other range hasn't
+            else if other_range.lower.is_null() {
+                false
+            } else {
+                let compare_lowers = other_range.lower.compare(&self.lower).unwrap();
+                if self.is_lower_bound_inclusive || (self.is_upper_bound_inclusive == other_range.is_upper_bound_inclusive)
+                    { compare_lowers.is_ge() } else  { compare_lowers.is_gt() }
+            };
+
+            let is_range_contains = is_lower_in_range &&
+            // Current range has no upper boundraies
+            if self.upper.is_null() {
+                true
+            }
+            // Current range has upper boundraies, but the other range hasn't
+            else if other_range.upper.is_null() {
+                false
+            } else {
+                let compare_uppers = other_range.upper.compare(&self.upper).unwrap();
+                if self.is_upper_bound_inclusive || (self.is_upper_bound_inclusive == other_range.is_upper_bound_inclusive)
+                    { compare_uppers.is_le() } else  { compare_uppers.is_lt() }
+            };
+
+            return Ok(Box::new(BoolValue::new(is_range_contains)));
         }
 
         if self.base_type.equals(&other.data_type()) {
-            let is_in_range = other.compare(&self.start).unwrap().is_ge()
-                && other.compare(&self.end).unwrap().is_le();
-            return Ok(Box::new(BoolValue { value: is_in_range }));
+            let is_lower_in = self.lower.is_null()
+                || if self.is_lower_bound_inclusive {
+                    other.compare(&self.lower).unwrap().is_ge()
+                } else {
+                    other.compare(&self.lower).unwrap().is_gt()
+                };
+            let is_upper_in = self.upper.is_null()
+                || if self.is_upper_bound_inclusive {
+                    other.compare(&self.upper).unwrap().is_le()
+                } else {
+                    other.compare(&self.upper).unwrap().is_lt()
+                };
+            return Ok(Box::new(BoolValue::new(is_lower_in && is_upper_in)));
         }
 
         Err("Unexpected type to perform `Range contains @>` with".to_string())

crates/gitql-std/src/range/mod.rs

@@ -61,27 +61,27 @@ pub fn register_std_range_function_signatures(map: &mut HashMap<&'static str, Si
 }
 
 pub fn int4range(inputs: &[Box<dyn Value>]) -> Box<dyn Value> {
-    Box::new(RangeValue {
-        start: inputs[0].clone(),
-        end: inputs[1].clone(),
-        base_type: Box::new(IntType),
-    })
+    Box::new(RangeValue::new(
+        inputs[0].clone(),
+        inputs[1].clone(),
+        Box::new(IntType),
+    ))
 }
 
 pub fn daterange(inputs: &[Box<dyn Value>]) -> Box<dyn Value> {
-    Box::new(RangeValue {
-        start: inputs[0].clone(),
-        end: inputs[1].clone(),
-        base_type: Box::new(DateType),
-    })
+    Box::new(RangeValue::new(
+        inputs[0].clone(),
+        inputs[1].clone(),
+        Box::new(DateType),
+    ))
 }
 
 pub fn tsrange(inputs: &[Box<dyn Value>]) -> Box<dyn Value> {
-    Box::new(RangeValue {
-        start: inputs[0].clone(),
-        end: inputs[1].clone(),
-        base_type: Box::new(DateTimeType),
-    })
+    Box::new(RangeValue::new(
+        inputs[0].clone(),
+        inputs[1].clone(),
+        Box::new(DateTimeType),
+    ))
 }
 
 pub fn isempty(inputs: &[Box<dyn Value>]) -> Box<dyn Value> {