Method intersect

datafusion/expr-common/src/interval_arithmetic.rs:652–676

Compute the intersection of this interval with the given interval. If the intersection is empty, return `None`. If the two intervals have different data types, both are coerced to a common comparison type via [`comparison_coercion`] before computing the intersection.

(&self, other: T)

    /// common comparison type via [`comparison_coercion`] before computing the
    /// intersection.
    pub fn intersect<T: Borrow<Self>>(&self, other: T) -> Result<Option<Self>> {
        let rhs = other.borrow();
        let (lhs_owned, rhs_owned) = coerce_for_comparison(self, rhs)?;
        let lhs = lhs_owned.as_ref().unwrap_or(self);
        let rhs = rhs_owned.as_ref().unwrap_or(rhs);

        // If it is evident that the result is an empty interval, short-circuit
        // and directly return `None`.
        if (!(lhs.lower.is_null() || rhs.upper.is_null()) && lhs.lower > rhs.upper)
            || (!(lhs.upper.is_null() || rhs.lower.is_null()) && lhs.upper < rhs.lower)
        {
            return Ok(None);
        }

        let lower = max_of_bounds(&lhs.lower, &rhs.lower);
        let upper = min_of_bounds(&lhs.upper, &rhs.upper);

        // New lower and upper bounds must always construct a valid interval.
        debug_assert!(
            (lower.is_null() || upper.is_null() || (lower <= upper)),
            "The intersection of two intervals can not be an invalid interval"
        );

        Ok(Some(Self { lower, upper }))
    }

    /// Compute the union of this interval with the given interval.
    ///