Apache DataFusion SQL Query Engine
Rename boolean `Interval` constants to match `NullableInterval` (#18654)
Pepijn Van Eeckhoudtbd30fe237531
diff --git a/datafusion/expr-common/src/interval_arithmetic.rs b/datafusion/expr-common/src/interval_arithmetic.rsindex 9ea9d9275f..a04005072e 100644--- a/datafusion/expr-common/src/interval_arithmetic.rs+++ b/datafusion/expr-common/src/interval_arithmetic.rs@@ -432,21 +432,33 @@ impl Interval {)}- pub const CERTAINLY_FALSE: Self = Self {+ /// An interval containing only the 'false' truth value.+ pub const FALSE: Self = Self {lower: ScalarValue::Boolean(Some(false)),upper: ScalarValue::Boolean(Some(false)),};- pub const UNCERTAIN: Self = Self {+ #[deprecated(since = "52.0.0", note = "Use `FALSE` instead")]+ pub const CERTAINLY_FALSE: Self = Self::FALSE;++ /// An interval containing both the 'true', and 'false' truth values.+ pub const TRUE_OR_FALSE: Self = Self {lower: ScalarValue::Boolean(Some(false)),upper: ScalarValue::Boolean(Some(true)),};- pub const CERTAINLY_TRUE: Self = Self {+ #[deprecated(since = "52.0.0", note = "Use `TRUE_OR_FALSE` instead")]+ pub const UNCERTAIN: Self = Self::TRUE_OR_FALSE;++ /// An interval containing only the 'true' truth value.+ pub const TRUE: Self = Self {lower: ScalarValue::Boolean(Some(true)),upper: ScalarValue::Boolean(Some(true)),};+ #[deprecated(since = "52.0.0", note = "Use `TRUE` instead")]+ pub const CERTAINLY_TRUE: Self = Self::TRUE;+/// Decide if this interval is certainly greater than, possibly greater than,/// or can't be greater than `other` by returning `[true, true]`,/// `[false, true]` or `[false, false]` respectively.@@ -468,16 +480,16 @@ impl Interval {if !(self.upper.is_null() || rhs.lower.is_null()) && self.upper <= rhs.lower {// Values in this interval are certainly less than or equal to// those in the given interval.- Ok(Self::CERTAINLY_FALSE)+ Ok(Self::FALSE)} else if !(self.lower.is_null() || rhs.upper.is_null())&& (self.lower > rhs.upper){// Values in this interval are certainly greater than those in the// given interval.- Ok(Self::CERTAINLY_TRUE)+ Ok(Self::TRUE)} else {// All outcomes are possible.- Ok(Self::UNCERTAIN)+ Ok(Self::TRUE_OR_FALSE)}}@@ -502,16 +514,16 @@ impl Interval {if !(self.lower.is_null() || rhs.upper.is_null()) && self.lower >= rhs.upper {// Values in this interval are certainly greater than or equal to// those in the given interval.- Ok(Self::CERTAINLY_TRUE)+ Ok(Self::TRUE)} else if !(self.upper.is_null() || rhs.lower.is_null())&& (self.upper < rhs.lower){// Values in this interval are certainly less than those in the// given interval.- Ok(Self::CERTAINLY_FALSE)+ Ok(Self::FALSE)} else {// All outcomes are possible.- Ok(Self::UNCERTAIN)+ Ok(Self::TRUE_OR_FALSE)}}@@ -561,11 +573,11 @@ impl Interval {&& (rhs.lower == rhs.upper)&& (self.lower == rhs.lower){- Ok(Self::CERTAINLY_TRUE)+ Ok(Self::TRUE)} else if self.intersect(rhs)?.is_none() {- Ok(Self::CERTAINLY_FALSE)+ Ok(Self::FALSE)} else {- Ok(Self::UNCERTAIN)+ Ok(Self::TRUE_OR_FALSE)}}@@ -589,8 +601,8 @@ impl Interval {})}- // Return UNCERTAIN when intervals don't have concrete boolean bounds- _ => Ok(Self::UNCERTAIN),+ // Return TRUE_OR_FALSE when intervals don't have concrete boolean bounds+ _ => Ok(Self::TRUE_OR_FALSE),}}@@ -614,8 +626,8 @@ impl Interval {})}- // Return UNCERTAIN when intervals don't have concrete boolean bounds- _ => Ok(Self::UNCERTAIN),+ // Return TRUE_OR_FALSE when intervals don't have concrete boolean bounds+ _ => Ok(Self::TRUE_OR_FALSE),}}@@ -626,12 +638,12 @@ impl Interval {DataType::Boolean,"Cannot apply logical negation to a non-boolean interval");- if self == &Self::CERTAINLY_TRUE {- Ok(Self::CERTAINLY_FALSE)- } else if self == &Self::CERTAINLY_FALSE {- Ok(Self::CERTAINLY_TRUE)+ if self == &Self::TRUE {+ Ok(Self::FALSE)+ } else if self == &Self::FALSE {+ Ok(Self::TRUE)} else {- Ok(Self::UNCERTAIN)+ Ok(Self::TRUE_OR_FALSE)}}@@ -764,12 +776,12 @@ impl Interval {match self.intersect(rhs)? {Some(intersection) => {if &intersection == rhs {- Ok(Self::CERTAINLY_TRUE)+ Ok(Self::TRUE)} else {- Ok(Self::UNCERTAIN)+ Ok(Self::TRUE_OR_FALSE)}}- None => Ok(Self::CERTAINLY_FALSE),+ None => Ok(Self::FALSE),}}@@ -780,8 +792,7 @@ impl Interval {/// Attempting to compare intervals of different data types will lead/// to an error.pub fn is_superset(&self, other: &Interval, strict: bool) -> Result<bool> {- Ok(!(strict && self.eq(other))- && (self.contains(other)? == Interval::CERTAINLY_TRUE))+ Ok(!(strict && self.eq(other)) && (self.contains(other)? == Interval::TRUE))}/// Add the given interval (`other`) to this interval. Say we have intervals@@ -890,15 +901,12 @@ impl Interval {// Exit early with an unbounded interval if zero is strictly inside the// right hand side:- if rhs.contains(&zero_point)? == Self::CERTAINLY_TRUE && !dt.is_unsigned_integer()- {+ if rhs.contains(&zero_point)? == Self::TRUE && !dt.is_unsigned_integer() {Self::make_unbounded(&dt)}// At this point, we know that only one endpoint of the right hand side// can be zero.- else if self.contains(&zero_point)? == Self::CERTAINLY_TRUE- && !dt.is_unsigned_integer()- {+ else if self.contains(&zero_point)? == Self::TRUE && !dt.is_unsigned_integer() {Ok(div_helper_lhs_zero_inclusive(&dt, self, rhs, &zero_point))} else {Ok(div_helper_zero_exclusive(&dt, self, rhs, &zero_point))@@ -1755,42 +1763,42 @@ impl From<ScalarValue> for NullableInterval {}impl NullableInterval {- /// An interval that only contains 'false'.+ /// An interval containing only the 'false' truth value.+ /// This interval is semantically equivalent to [Interval::FALSE].pub const FALSE: Self = NullableInterval::NotNull {- values: Interval::CERTAINLY_FALSE,+ values: Interval::FALSE,};- /// An interval that only contains 'true'.+ /// An interval containing only the 'true' truth value.+ /// This interval is semantically equivalent to [Interval::TRUE].pub const TRUE: Self = NullableInterval::NotNull {- values: Interval::CERTAINLY_TRUE,+ values: Interval::TRUE,};- /// An interval that only contains 'unknown' (boolean null).+ /// An interval containing only the 'unknown' truth value.pub const UNKNOWN: Self = NullableInterval::Null {datatype: DataType::Boolean,};- /// An interval that only contains 'true' and 'false'.- /// This interval is equivalent to [Interval::UNCERTAIN].+ /// An interval containing both the 'true', and 'false' truth values.+ /// This interval is semantically equivalent to [Interval::TRUE_OR_FALSE].pub const TRUE_OR_FALSE: Self = NullableInterval::NotNull {- values: Interval::UNCERTAIN,+ values: Interval::TRUE_OR_FALSE,};- /// An interval that only contains 'true' and 'unknown'.+ /// An interval containing both the 'true' and 'unknown' truth values.pub const TRUE_OR_UNKNOWN: Self = NullableInterval::MaybeNull {- values: Interval::CERTAINLY_TRUE,+ values: Interval::TRUE,};- /// An interval that only contains 'false' and 'unknown'.+ /// An interval containing both the 'false' and 'unknown' truth values.pub const FALSE_OR_UNKNOWN: Self = NullableInterval::MaybeNull {- values: Interval::CERTAINLY_FALSE,+ values: Interval::FALSE,};- /// An interval that contains all possible boolean values: 'true', 'false' and 'unknown'.- ///- /// Note that this is different from [Interval::UNCERTAIN] which only contains 'true' and 'false'.- pub const UNCERTAIN: Self = NullableInterval::MaybeNull {- values: Interval::UNCERTAIN,+ /// An interval that contains all possible truth values: 'true', 'false' and 'unknown'.+ pub const ANY_TRUTH_VALUE: Self = NullableInterval::MaybeNull {+ values: Interval::TRUE_OR_FALSE,};/// Get the values interval, or None if this interval is definitely null.@@ -1952,7 +1960,7 @@ impl NullableInterval {/// result,/// NullableInterval::NotNull {/// // Uncertain whether inequality is true or false- /// values: Interval::UNCERTAIN,+ /// values: Interval::TRUE_OR_FALSE,/// }/// );/// ```@@ -1961,7 +1969,7 @@ impl NullableInterval {Operator::IsDistinctFrom => {let values = match (self, rhs) {// NULL is distinct from NULL -> False- (Self::Null { .. }, Self::Null { .. }) => Interval::CERTAINLY_FALSE,+ (Self::Null { .. }, Self::Null { .. }) => Interval::FALSE,// x is distinct from y -> x != y,// if at least one of them is never null.(Self::NotNull { .. }, _) | (_, Self::NotNull { .. }) => {@@ -1971,11 +1979,11 @@ impl NullableInterval {(Some(lhs_values), Some(rhs_values)) => {lhs_values.equal(rhs_values)?.not()?}- (Some(_), None) | (None, Some(_)) => Interval::CERTAINLY_TRUE,+ (Some(_), None) | (None, Some(_)) => Interval::TRUE,(None, None) => unreachable!("Null case handled above"),}}- _ => Interval::UNCERTAIN,+ _ => Interval::TRUE_OR_FALSE,};// IsDistinctFrom never returns null.Ok(Self::NotNull { values })@@ -2305,8 +2313,8 @@ mod tests {),];for (first, second) in exactly_gt_cases {- assert_eq!(first.gt(second.clone())?, Interval::CERTAINLY_TRUE);- assert_eq!(second.lt(first)?, Interval::CERTAINLY_TRUE);+ assert_eq!(first.gt(second.clone())?, Interval::TRUE);+ assert_eq!(second.lt(first)?, Interval::TRUE);}let possibly_gt_cases = vec![@@ -2342,8 +2350,8 @@ mod tests {),];for (first, second) in possibly_gt_cases {- assert_eq!(first.gt(second.clone())?, Interval::UNCERTAIN);- assert_eq!(second.lt(first)?, Interval::UNCERTAIN);+ assert_eq!(first.gt(second.clone())?, Interval::TRUE_OR_FALSE);+ assert_eq!(second.lt(first)?, Interval::TRUE_OR_FALSE);}let not_gt_cases = vec![@@ -2379,8 +2387,8 @@ mod tests {),];for (first, second) in not_gt_cases {- assert_eq!(first.gt(second.clone())?, Interval::CERTAINLY_FALSE);- assert_eq!(second.lt(first)?, Interval::CERTAINLY_FALSE);+ assert_eq!(first.gt(second.clone())?, Interval::FALSE);+ assert_eq!(second.lt(first)?, Interval::FALSE);}Ok(())@@ -2425,8 +2433,8 @@ mod tests {),];for (first, second) in exactly_gteq_cases {- assert_eq!(first.gt_eq(second.clone())?, Interval::CERTAINLY_TRUE);- assert_eq!(second.lt_eq(first)?, Interval::CERTAINLY_TRUE);+ assert_eq!(first.gt_eq(second.clone())?, Interval::TRUE);+ assert_eq!(second.lt_eq(first)?, Interval::TRUE);}let possibly_gteq_cases = vec![@@ -2462,8 +2470,8 @@ mod tests {),];for (first, second) in possibly_gteq_cases {- assert_eq!(first.gt_eq(second.clone())?, Interval::UNCERTAIN);- assert_eq!(second.lt_eq(first)?, Interval::UNCERTAIN);+ assert_eq!(first.gt_eq(second.clone())?, Interval::TRUE_OR_FALSE);+ assert_eq!(second.lt_eq(first)?, Interval::TRUE_OR_FALSE);}let not_gteq_cases = vec![@@ -2495,8 +2503,8 @@ mod tests {),];for (first, second) in not_gteq_cases {- assert_eq!(first.gt_eq(second.clone())?, Interval::CERTAINLY_FALSE);- assert_eq!(second.lt_eq(first)?, Interval::CERTAINLY_FALSE);+ assert_eq!(first.gt_eq(second.clone())?, Interval::FALSE);+ assert_eq!(second.lt_eq(first)?, Interval::FALSE);}Ok(())@@ -2523,8 +2531,8 @@ mod tests {),];for (first, second) in exactly_eq_cases {- assert_eq!(first.equal(second.clone())?, Interval::CERTAINLY_TRUE);- assert_eq!(second.equal(first)?, Interval::CERTAINLY_TRUE);+ assert_eq!(first.equal(second.clone())?, Interval::TRUE);+ assert_eq!(second.equal(first)?, Interval::TRUE);}let possibly_eq_cases = vec![@@ -2560,8 +2568,8 @@ mod tests {),];for (first, second) in possibly_eq_cases {- assert_eq!(first.equal(second.clone())?, Interval::UNCERTAIN);- assert_eq!(second.equal(first)?, Interval::UNCERTAIN);+ assert_eq!(first.equal(second.clone())?, Interval::TRUE_OR_FALSE);+ assert_eq!(second.equal(first)?, Interval::TRUE_OR_FALSE);}let not_eq_cases = vec![@@ -2593,8 +2601,8 @@ mod tests {),];for (first, second) in not_eq_cases {- assert_eq!(first.equal(second.clone())?, Interval::CERTAINLY_FALSE);- assert_eq!(second.equal(first)?, Interval::CERTAINLY_FALSE);+ assert_eq!(first.equal(second.clone())?, Interval::FALSE);+ assert_eq!(second.equal(first)?, Interval::FALSE);}Ok(())@@ -2603,51 +2611,27 @@ mod tests {#[test]fn and_test() -> Result<()> {let cases = vec![+ (Interval::TRUE_OR_FALSE, Interval::FALSE, Interval::FALSE),(- Interval::UNCERTAIN,- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_FALSE,- ),- (- Interval::UNCERTAIN,- Interval::UNCERTAIN,- Interval::UNCERTAIN,+ Interval::TRUE_OR_FALSE,+ Interval::TRUE_OR_FALSE,+ Interval::TRUE_OR_FALSE,),(- Interval::UNCERTAIN,- Interval::CERTAINLY_TRUE,- Interval::UNCERTAIN,+ Interval::TRUE_OR_FALSE,+ Interval::TRUE,+ Interval::TRUE_OR_FALSE,),+ (Interval::FALSE, Interval::FALSE, Interval::FALSE),+ (Interval::FALSE, Interval::TRUE_OR_FALSE, Interval::FALSE),+ (Interval::FALSE, Interval::TRUE, Interval::FALSE),+ (Interval::TRUE, Interval::FALSE, Interval::FALSE),(- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_FALSE,- ),- (- Interval::CERTAINLY_FALSE,- Interval::UNCERTAIN,- Interval::CERTAINLY_FALSE,- ),- (- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_FALSE,- ),- (- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_FALSE,- ),- (- Interval::CERTAINLY_TRUE,- Interval::UNCERTAIN,- Interval::UNCERTAIN,- ),- (- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_TRUE,+ Interval::TRUE,+ Interval::TRUE_OR_FALSE,+ Interval::TRUE_OR_FALSE,),+ (Interval::TRUE, Interval::TRUE, Interval::TRUE),];for case in cases {@@ -2666,50 +2650,26 @@ mod tests {fn or_test() -> Result<()> {let cases = vec![(- Interval::UNCERTAIN,- Interval::CERTAINLY_FALSE,- Interval::UNCERTAIN,- ),- (- Interval::UNCERTAIN,- Interval::UNCERTAIN,- Interval::UNCERTAIN,- ),- (- Interval::UNCERTAIN,- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_TRUE,- ),- (- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_FALSE,- ),- (- Interval::CERTAINLY_FALSE,- Interval::UNCERTAIN,- Interval::UNCERTAIN,- ),- (- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_TRUE,- ),- (- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_TRUE,+ Interval::TRUE_OR_FALSE,+ Interval::FALSE,+ Interval::TRUE_OR_FALSE,),(- Interval::CERTAINLY_TRUE,- Interval::UNCERTAIN,- Interval::CERTAINLY_TRUE,+ Interval::TRUE_OR_FALSE,+ Interval::TRUE_OR_FALSE,+ Interval::TRUE_OR_FALSE,),+ (Interval::TRUE_OR_FALSE, Interval::TRUE, Interval::TRUE),+ (Interval::FALSE, Interval::FALSE, Interval::FALSE),(- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_TRUE,+ Interval::FALSE,+ Interval::TRUE_OR_FALSE,+ Interval::TRUE_OR_FALSE,),+ (Interval::FALSE, Interval::TRUE, Interval::TRUE),+ (Interval::TRUE, Interval::FALSE, Interval::TRUE),+ (Interval::TRUE, Interval::TRUE_OR_FALSE, Interval::TRUE),+ (Interval::TRUE, Interval::TRUE, Interval::TRUE),];for case in cases {@@ -2727,9 +2687,9 @@ mod tests {#[test]fn not_test() -> Result<()> {let cases = vec![- (Interval::UNCERTAIN, Interval::UNCERTAIN),- (Interval::CERTAINLY_FALSE, Interval::CERTAINLY_TRUE),- (Interval::CERTAINLY_TRUE, Interval::CERTAINLY_FALSE),+ (Interval::TRUE_OR_FALSE, Interval::TRUE_OR_FALSE),+ (Interval::FALSE, Interval::TRUE),+ (Interval::TRUE, Interval::FALSE),];for case in cases {@@ -2744,77 +2704,77 @@ mod tests {let from_nulls =Interval::try_new(ScalarValue::Boolean(None), ScalarValue::Boolean(None))?;- assert!(from_nulls.or(&Interval::CERTAINLY_TRUE).is_ok());- assert!(from_nulls.and(&Interval::CERTAINLY_FALSE).is_ok());+ assert!(from_nulls.or(&Interval::TRUE).is_ok());+ assert!(from_nulls.and(&Interval::FALSE).is_ok());Ok(())}// Tests that there's no such thing as a 'null' boolean interval.- // An interval with two `Boolean(None)` boundaries is normalised to `Interval::UNCERTAIN`.+ // An interval with two `Boolean(None)` boundaries is normalised to `Interval::TRUE_OR_FALSE`.#[test]fn test_null_boolean_interval() {let null_interval =Interval::try_new(ScalarValue::Boolean(None), ScalarValue::Boolean(None)).unwrap();- assert_eq!(null_interval, Interval::UNCERTAIN);+ assert_eq!(null_interval, Interval::TRUE_OR_FALSE);}- // Asserts that `Interval::UNCERTAIN` represents a set that contains `true`, `false`, and does+ // Asserts that `Interval::TRUE_OR_FALSE` represents a set that contains `true`, `false`, and does// not contain `null`.#[test]fn test_uncertain_boolean_interval() {- assert!(Interval::UNCERTAIN+ assert!(Interval::TRUE_OR_FALSE.contains_value(ScalarValue::Boolean(Some(true))).unwrap());- assert!(Interval::UNCERTAIN+ assert!(Interval::TRUE_OR_FALSE.contains_value(ScalarValue::Boolean(Some(false))).unwrap());- assert!(!Interval::UNCERTAIN+ assert!(!Interval::TRUE_OR_FALSE.contains_value(ScalarValue::Boolean(None)).unwrap());- assert!(!Interval::UNCERTAIN+ assert!(!Interval::TRUE_OR_FALSE.contains_value(ScalarValue::Null).unwrap());}#[test]fn test_and_uncertain_boolean_intervals() -> Result<()> {- let and_result = Interval::UNCERTAIN.and(&Interval::CERTAINLY_FALSE)?;- assert_eq!(and_result, Interval::CERTAINLY_FALSE);+ let and_result = Interval::TRUE_OR_FALSE.and(&Interval::FALSE)?;+ assert_eq!(and_result, Interval::FALSE);- let and_result = Interval::CERTAINLY_FALSE.and(&Interval::UNCERTAIN)?;- assert_eq!(and_result, Interval::CERTAINLY_FALSE);+ let and_result = Interval::FALSE.and(&Interval::TRUE_OR_FALSE)?;+ assert_eq!(and_result, Interval::FALSE);- let and_result = Interval::UNCERTAIN.and(&Interval::CERTAINLY_TRUE)?;- assert_eq!(and_result, Interval::UNCERTAIN);+ let and_result = Interval::TRUE_OR_FALSE.and(&Interval::TRUE)?;+ assert_eq!(and_result, Interval::TRUE_OR_FALSE);- let and_result = Interval::CERTAINLY_TRUE.and(&Interval::UNCERTAIN)?;- assert_eq!(and_result, Interval::UNCERTAIN);+ let and_result = Interval::TRUE.and(&Interval::TRUE_OR_FALSE)?;+ assert_eq!(and_result, Interval::TRUE_OR_FALSE);- let and_result = Interval::UNCERTAIN.and(&Interval::UNCERTAIN)?;- assert_eq!(and_result, Interval::UNCERTAIN);+ let and_result = Interval::TRUE_OR_FALSE.and(&Interval::TRUE_OR_FALSE)?;+ assert_eq!(and_result, Interval::TRUE_OR_FALSE);Ok(())}#[test]fn test_or_uncertain_boolean_intervals() -> Result<()> {- let or_result = Interval::UNCERTAIN.or(&Interval::CERTAINLY_FALSE)?;- assert_eq!(or_result, Interval::UNCERTAIN);+ let or_result = Interval::TRUE_OR_FALSE.or(&Interval::FALSE)?;+ assert_eq!(or_result, Interval::TRUE_OR_FALSE);- let or_result = Interval::CERTAINLY_FALSE.or(&Interval::UNCERTAIN)?;- assert_eq!(or_result, Interval::UNCERTAIN);+ let or_result = Interval::FALSE.or(&Interval::TRUE_OR_FALSE)?;+ assert_eq!(or_result, Interval::TRUE_OR_FALSE);- let or_result = Interval::UNCERTAIN.or(&Interval::CERTAINLY_TRUE)?;- assert_eq!(or_result, Interval::CERTAINLY_TRUE);+ let or_result = Interval::TRUE_OR_FALSE.or(&Interval::TRUE)?;+ assert_eq!(or_result, Interval::TRUE);- let or_result = Interval::CERTAINLY_TRUE.or(&Interval::UNCERTAIN)?;- assert_eq!(or_result, Interval::CERTAINLY_TRUE);+ let or_result = Interval::TRUE.or(&Interval::TRUE_OR_FALSE)?;+ assert_eq!(or_result, Interval::TRUE);- let or_result = Interval::UNCERTAIN.or(&Interval::UNCERTAIN)?;- assert_eq!(or_result, Interval::UNCERTAIN);+ let or_result = Interval::TRUE_OR_FALSE.or(&Interval::TRUE_OR_FALSE)?;+ assert_eq!(or_result, Interval::TRUE_OR_FALSE);Ok(())}@@ -3057,37 +3017,37 @@ mod tests {(Interval::make::<i64>(None, None)?,Interval::make::<i64>(None, None)?,- Interval::CERTAINLY_TRUE,+ Interval::TRUE,),(Interval::make(Some(1500_i64), Some(2000_i64))?,Interval::make(Some(1501_i64), Some(1999_i64))?,- Interval::CERTAINLY_TRUE,+ Interval::TRUE,),(Interval::make(Some(1000_i64), None)?,Interval::make::<i64>(None, None)?,- Interval::UNCERTAIN,+ Interval::TRUE_OR_FALSE,),(Interval::make(Some(1000_i64), Some(2000_i64))?,Interval::make(Some(500), Some(1500_i64))?,- Interval::UNCERTAIN,+ Interval::TRUE_OR_FALSE,),(Interval::make(Some(16.0), Some(32.0))?,Interval::make(Some(32.0), Some(64.0))?,- Interval::UNCERTAIN,+ Interval::TRUE_OR_FALSE,),(Interval::make(Some(1000_i64), None)?,Interval::make(None, Some(0_i64))?,- Interval::CERTAINLY_FALSE,+ Interval::FALSE,),(Interval::make(Some(1500_i64), Some(2000_i64))?,Interval::make(Some(1000_i64), Some(1499_i64))?,- Interval::CERTAINLY_FALSE,+ Interval::FALSE,),(Interval::try_new(@@ -3095,7 +3055,7 @@ mod tests {prev_value(ScalarValue::Float32(Some(1.0))),)?,Interval::make(Some(1.0_f32), Some(1.0_f32))?,- Interval::CERTAINLY_FALSE,+ Interval::FALSE,),(Interval::try_new(@@ -3103,7 +3063,7 @@ mod tests {next_value(ScalarValue::Float32(Some(1.0))),)?,Interval::make(Some(1.0_f32), Some(1.0_f32))?,- Interval::CERTAINLY_FALSE,+ Interval::FALSE,),];for (first, second, expected) in possible_cases {@@ -4346,252 +4306,58 @@ mod tests {#[test]fn nullable_and_test() -> Result<()> {+ // Test cases: (lhs, rhs, expected) => lhs AND rhs = expected+ #[rustfmt::skip]let cases = vec![- (- NullableInterval::TRUE,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::TRUE,- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::TRUE,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_FALSE,- ),- (- NullableInterval::TRUE,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::FALSE,- NullableInterval::TRUE,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::UNKNOWN,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::UNCERTAIN,- NullableInterval::FALSE,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::TRUE,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::UNCERTAIN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::TRUE,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE,- NullableInterval::TRUE_OR_FALSE,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_FALSE,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- NullableInterval::FALSE_OR_UNKNOWN,- ),+ (NullableInterval::TRUE, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::TRUE, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::TRUE, NullableInterval::UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::TRUE, NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_FALSE),+ (NullableInterval::TRUE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::TRUE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::FALSE, NullableInterval::TRUE, NullableInterval::FALSE),+ (NullableInterval::FALSE, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::FALSE, NullableInterval::UNKNOWN, NullableInterval::FALSE),+ (NullableInterval::FALSE, NullableInterval::TRUE_OR_FALSE, NullableInterval::FALSE),+ (NullableInterval::FALSE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::FALSE),+ (NullableInterval::FALSE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE),+ (NullableInterval::FALSE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::FALSE),+ (NullableInterval::UNKNOWN, NullableInterval::TRUE, NullableInterval::UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::UNKNOWN, NullableInterval::UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::TRUE_OR_FALSE, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE_OR_FALSE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE, NullableInterval::TRUE_OR_FALSE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_FALSE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_FALSE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE_OR_FALSE, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::FALSE_OR_UNKNOWN),];for case in cases {@@ -4608,252 +4374,58 @@ mod tests {#[test]fn nullable_or_test() -> Result<()> {+ // Test cases: (lhs, rhs, expected) => lhs OR rhs = expected+ #[rustfmt::skip]let cases = vec![- (- NullableInterval::TRUE,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE,- NullableInterval::FALSE,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE,- NullableInterval::UNKNOWN,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE,- NullableInterval::UNCERTAIN,- NullableInterval::TRUE,- ),- (- NullableInterval::FALSE,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::FALSE,- NullableInterval::FALSE,- NullableInterval::FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::FALSE,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_FALSE,- ),- (- NullableInterval::FALSE,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::FALSE,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::UNKNOWN,- NullableInterval::UNCERTAIN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::FALSE,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::FALSE,- NullableInterval::TRUE_OR_FALSE,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_FALSE,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::FALSE,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE,- NullableInterval::TRUE,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::UNKNOWN,- NullableInterval::UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE_OR_FALSE,- NullableInterval::UNCERTAIN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::UNCERTAIN,- NullableInterval::UNCERTAIN,- ),+ (NullableInterval::TRUE, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::TRUE, NullableInterval::FALSE, NullableInterval::TRUE),+ (NullableInterval::TRUE, NullableInterval::UNKNOWN, NullableInterval::TRUE),+ (NullableInterval::TRUE, NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE),+ (NullableInterval::TRUE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE),+ (NullableInterval::TRUE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE),+ (NullableInterval::TRUE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE),+ (NullableInterval::FALSE, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::FALSE, NullableInterval::FALSE, NullableInterval::FALSE),+ (NullableInterval::FALSE, NullableInterval::UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::FALSE, NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_FALSE),+ (NullableInterval::FALSE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::FALSE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::UNKNOWN, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::UNKNOWN, NullableInterval::FALSE, NullableInterval::UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::UNKNOWN, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::FALSE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE_OR_FALSE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::FALSE, NullableInterval::TRUE_OR_FALSE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_FALSE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::TRUE_OR_FALSE, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::FALSE, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_FALSE, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE, NullableInterval::TRUE),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::UNKNOWN, NullableInterval::UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE_OR_FALSE, NullableInterval::ANY_TRUTH_VALUE),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN, NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN, NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),];for case in cases {@@ -4870,23 +4442,16 @@ mod tests {#[test]fn nullable_not_test() -> Result<()> {+ // Test cases: (interval, expected) => NOT interval = expected+ #[rustfmt::skip]let cases = vec![(NullableInterval::TRUE, NullableInterval::FALSE),(NullableInterval::FALSE, NullableInterval::TRUE),(NullableInterval::UNKNOWN, NullableInterval::UNKNOWN),- (- NullableInterval::TRUE_OR_FALSE,- NullableInterval::TRUE_OR_FALSE,- ),- (- NullableInterval::TRUE_OR_UNKNOWN,- NullableInterval::FALSE_OR_UNKNOWN,- ),- (- NullableInterval::FALSE_OR_UNKNOWN,- NullableInterval::TRUE_OR_UNKNOWN,- ),- (NullableInterval::UNCERTAIN, NullableInterval::UNCERTAIN),+ (NullableInterval::TRUE_OR_FALSE,NullableInterval::TRUE_OR_FALSE),+ (NullableInterval::TRUE_OR_UNKNOWN,NullableInterval::FALSE_OR_UNKNOWN),+ (NullableInterval::FALSE_OR_UNKNOWN,NullableInterval::TRUE_OR_UNKNOWN),+ (NullableInterval::ANY_TRUTH_VALUE, NullableInterval::ANY_TRUTH_VALUE),];for case in cases {diff --git a/datafusion/expr-common/src/statistics.rs b/datafusion/expr-common/src/statistics.rsindex c5c3355983..7961bf0872 100644--- a/datafusion/expr-common/src/statistics.rs+++ b/datafusion/expr-common/src/statistics.rs@@ -162,9 +162,9 @@ impl Distribution {/// - A [`Uniform`] distribution's range is simply its interval./// - An [`Exponential`] distribution's range is `[offset, +∞)`./// - A [`Gaussian`] distribution's range is unbounded.- /// - A [`Bernoulli`] distribution's range is [`Interval::UNCERTAIN`], if- /// `p` is neither `0` nor `1`. Otherwise, it is [`Interval::CERTAINLY_FALSE`]- /// and [`Interval::CERTAINLY_TRUE`], respectively.+ /// - A [`Bernoulli`] distribution's range is [`Interval::TRUE_OR_FALSE`], if+ /// `p` is neither `0` nor `1`. Otherwise, it is [`Interval::FALSE`]+ /// and [`Interval::TRUE`], respectively./// - A [`Generic`] distribution is unbounded by default, but more information/// may be present.pub fn range(&self) -> Result<Interval> {@@ -519,11 +519,11 @@ impl BernoulliDistribution {// Unwraps are safe as the constructor guarantees that the data type// supports zero and one values.if ScalarValue::new_zero(&dt).unwrap().eq(&self.p) {- Interval::CERTAINLY_FALSE+ Interval::FALSE} else if ScalarValue::new_one(&dt).unwrap().eq(&self.p) {- Interval::CERTAINLY_TRUE+ Interval::TRUE} else {- Interval::UNCERTAIN+ Interval::TRUE_OR_FALSE}}}@@ -736,11 +736,11 @@ pub fn create_bernoulli_from_comparison(}let (li, ri) = (left.range()?, right.range()?);let range_evaluation = apply_operator(op, &li, &ri)?;- if range_evaluation.eq(&Interval::CERTAINLY_FALSE) {+ if range_evaluation.eq(&Interval::FALSE) {Distribution::new_bernoulli(ScalarValue::from(0.0))- } else if range_evaluation.eq(&Interval::CERTAINLY_TRUE) {+ } else if range_evaluation.eq(&Interval::TRUE) {Distribution::new_bernoulli(ScalarValue::from(1.0))- } else if range_evaluation.eq(&Interval::UNCERTAIN) {+ } else if range_evaluation.eq(&Interval::TRUE_OR_FALSE) {Distribution::new_bernoulli(ScalarValue::try_from(&DataType::Float64)?)} else {internal_err!("This function must be called with a comparison operator")@@ -897,7 +897,7 @@ mod tests {}));- assert!(Distribution::new_uniform(Interval::UNCERTAIN).is_err());+ assert!(Distribution::new_uniform(Interval::TRUE_OR_FALSE).is_err());Ok(())}@@ -1010,7 +1010,7 @@ mod tests {ScalarValue::Null,ScalarValue::Null,ScalarValue::Null,- Interval::UNCERTAIN,+ Interval::TRUE_OR_FALSE,),false,),diff --git a/datafusion/functions/src/math/abs.rs b/datafusion/functions/src/math/abs.rsindex b3dc2b2eb6..8049ef85ac 100644--- a/datafusion/functions/src/math/abs.rs+++ b/datafusion/functions/src/math/abs.rs@@ -175,9 +175,9 @@ impl ScalarUDFImpl for AbsFunc {let range = &arg.range;let zero_point = Interval::make_zero(&range.lower().data_type())?;- if range.gt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ if range.gt_eq(&zero_point)? == Interval::TRUE {Ok(arg.sort_properties)- } else if range.lt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ } else if range.lt_eq(&zero_point)? == Interval::TRUE {Ok(-arg.sort_properties)} else {Ok(SortProperties::Unordered)diff --git a/datafusion/functions/src/math/monotonicity.rs b/datafusion/functions/src/math/monotonicity.rsindex 5b8252137b..ffb3df4196 100644--- a/datafusion/functions/src/math/monotonicity.rs+++ b/datafusion/functions/src/math/monotonicity.rs@@ -31,7 +31,7 @@ pub fn acos_order(input: &[ExprProperties]) -> Result<SortProperties> {let valid_domain =Interval::make_symmetric_unit_interval(&range.lower().data_type())?;- if valid_domain.contains(range)? == Interval::CERTAINLY_TRUE {+ if valid_domain.contains(range)? == Interval::TRUE {Ok(-arg.sort_properties)} else {exec_err!("Input range of ACOS contains out-of-domain values")@@ -72,7 +72,7 @@ pub fn acosh_order(input: &[ExprProperties]) -> Result<SortProperties> {ScalarValue::try_from(&range.upper().data_type())?,)?;- if valid_domain.contains(range)? == Interval::CERTAINLY_TRUE {+ if valid_domain.contains(range)? == Interval::TRUE {Ok(arg.sort_properties)} else {exec_err!("Input range of ACOSH contains out-of-domain values")@@ -110,7 +110,7 @@ pub fn asin_order(input: &[ExprProperties]) -> Result<SortProperties> {let valid_domain =Interval::make_symmetric_unit_interval(&range.lower().data_type())?;- if valid_domain.contains(range)? == Interval::CERTAINLY_TRUE {+ if valid_domain.contains(range)? == Interval::TRUE {Ok(arg.sort_properties)} else {exec_err!("Input range of ASIN contains out-of-domain values")@@ -207,7 +207,7 @@ pub fn atanh_order(input: &[ExprProperties]) -> Result<SortProperties> {let valid_domain =Interval::make_symmetric_unit_interval(&range.lower().data_type())?;- if valid_domain.contains(range)? == Interval::CERTAINLY_TRUE {+ if valid_domain.contains(range)? == Interval::TRUE {Ok(arg.sort_properties)} else {exec_err!("Input range of ATANH contains out-of-domain values")@@ -371,9 +371,9 @@ pub fn cosh_order(input: &[ExprProperties]) -> Result<SortProperties> {let zero_point = Interval::make_zero(&range.lower().data_type())?;- if range.gt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ if range.gt_eq(&zero_point)? == Interval::TRUE {Ok(arg.sort_properties)- } else if range.lt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ } else if range.lt_eq(&zero_point)? == Interval::TRUE {Ok(-arg.sort_properties)} else {Ok(SortProperties::Unordered)@@ -498,7 +498,7 @@ pub fn ln_order(input: &[ExprProperties]) -> Result<SortProperties> {let zero_point = Interval::make_zero(&range.lower().data_type())?;- if range.gt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ if range.gt_eq(&zero_point)? == Interval::TRUE {Ok(arg.sort_properties)} else {exec_err!("Input range of LN contains out-of-domain values")@@ -536,7 +536,7 @@ pub fn log2_order(input: &[ExprProperties]) -> Result<SortProperties> {let zero_point = Interval::make_zero(&range.lower().data_type())?;- if range.gt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ if range.gt_eq(&zero_point)? == Interval::TRUE {Ok(arg.sort_properties)} else {exec_err!("Input range of LOG2 contains out-of-domain values")@@ -574,7 +574,7 @@ pub fn log10_order(input: &[ExprProperties]) -> Result<SortProperties> {let zero_point = Interval::make_zero(&range.lower().data_type())?;- if range.gt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ if range.gt_eq(&zero_point)? == Interval::TRUE {Ok(arg.sort_properties)} else {exec_err!("Input range of LOG10 contains out-of-domain values")@@ -701,7 +701,7 @@ pub fn sqrt_order(input: &[ExprProperties]) -> Result<SortProperties> {let zero_point = Interval::make_zero(&range.lower().data_type())?;- if range.gt_eq(&zero_point)? == Interval::CERTAINLY_TRUE {+ if range.gt_eq(&zero_point)? == Interval::TRUE {Ok(arg.sort_properties)} else {exec_err!("Input range of SQRT contains out-of-domain values")diff --git a/datafusion/physical-expr-common/src/physical_expr.rs b/datafusion/physical-expr-common/src/physical_expr.rsindex efa08cc377..efdd6fcb62 100644--- a/datafusion/physical-expr-common/src/physical_expr.rs+++ b/datafusion/physical-expr-common/src/physical_expr.rs@@ -250,9 +250,9 @@ pub trait PhysicalExpr: Any + Send + Sync + Display + Debug + DynEq + DynHash {let output_interval = self.evaluate_bounds(children_ranges_refs.as_slice())?;let dt = output_interval.data_type();if dt.eq(&DataType::Boolean) {- let p = if output_interval.eq(&Interval::CERTAINLY_TRUE) {+ let p = if output_interval.eq(&Interval::TRUE) {ScalarValue::new_one(&dt)- } else if output_interval.eq(&Interval::CERTAINLY_FALSE) {+ } else if output_interval.eq(&Interval::FALSE) {ScalarValue::new_zero(&dt)} else {ScalarValue::try_from(&dt)@@ -312,9 +312,9 @@ pub trait PhysicalExpr: Any + Send + Sync + Display + Debug + DynEq + DynHash {Ok((*child).clone())} else if new_interval.data_type().eq(&DataType::Boolean) {let dt = old_interval.data_type();- let p = if new_interval.eq(&Interval::CERTAINLY_TRUE) {+ let p = if new_interval.eq(&Interval::TRUE) {ScalarValue::new_one(&dt)- } else if new_interval.eq(&Interval::CERTAINLY_FALSE) {+ } else if new_interval.eq(&Interval::FALSE) {ScalarValue::new_zero(&dt)} else {unreachable!("Given that we have a range reduction for a boolean interval, we should have certainty")diff --git a/datafusion/physical-expr/src/analysis.rs b/datafusion/physical-expr/src/analysis.rsindex d85fab9db0..981acbb779 100644--- a/datafusion/physical-expr/src/analysis.rs+++ b/datafusion/physical-expr/src/analysis.rs@@ -212,9 +212,7 @@ pub fn analyze(}}- match graph- .update_ranges(&mut target_indices_and_boundaries, Interval::CERTAINLY_TRUE)?- {+ match graph.update_ranges(&mut target_indices_and_boundaries, Interval::TRUE)? {PropagationResult::Success => {shrink_boundaries(&graph, target_boundaries, &target_expr_and_indices)}diff --git a/datafusion/physical-expr/src/expressions/binary.rs b/datafusion/physical-expr/src/expressions/binary.rsindex f3a71cbea4..1e5c7e7024 100644--- a/datafusion/physical-expr/src/expressions/binary.rs+++ b/datafusion/physical-expr/src/expressions/binary.rs@@ -333,33 +333,27 @@ impl PhysicalExpr for BinaryExpr {let right_interval = children[1];if self.op.eq(&Operator::And) {- if interval.eq(&Interval::CERTAINLY_TRUE) {+ if interval.eq(&Interval::TRUE) {// A certainly true logical conjunction can only derive from possibly// true operands. Otherwise, we prove infeasibility.- Ok((!left_interval.eq(&Interval::CERTAINLY_FALSE)- && !right_interval.eq(&Interval::CERTAINLY_FALSE))- .then(|| vec![Interval::CERTAINLY_TRUE, Interval::CERTAINLY_TRUE]))- } else if interval.eq(&Interval::CERTAINLY_FALSE) {+ Ok((!left_interval.eq(&Interval::FALSE)+ && !right_interval.eq(&Interval::FALSE))+ .then(|| vec![Interval::TRUE, Interval::TRUE]))+ } else if interval.eq(&Interval::FALSE) {// If the logical conjunction is certainly false, one of the// operands must be false. However, it's not always possible to// determine which operand is false, leading to different scenarios.// If one operand is certainly true and the other one is uncertain,// then the latter must be certainly false.- if left_interval.eq(&Interval::CERTAINLY_TRUE)- && right_interval.eq(&Interval::UNCERTAIN)+ if left_interval.eq(&Interval::TRUE)+ && right_interval.eq(&Interval::TRUE_OR_FALSE){- Ok(Some(vec![- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_FALSE,- ]))- } else if right_interval.eq(&Interval::CERTAINLY_TRUE)- && left_interval.eq(&Interval::UNCERTAIN)+ Ok(Some(vec![Interval::TRUE, Interval::FALSE]))+ } else if right_interval.eq(&Interval::TRUE)+ && left_interval.eq(&Interval::TRUE_OR_FALSE){- Ok(Some(vec![- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_TRUE,- ]))+ Ok(Some(vec![Interval::FALSE, Interval::TRUE]))}// If both children are uncertain, or if one is certainly false,// we cannot conclusively refine their intervals. In this case,@@ -373,33 +367,27 @@ impl PhysicalExpr for BinaryExpr {Ok(Some(vec![]))}} else if self.op.eq(&Operator::Or) {- if interval.eq(&Interval::CERTAINLY_FALSE) {+ if interval.eq(&Interval::FALSE) {// A certainly false logical disjunction can only derive from certainly// false operands. Otherwise, we prove infeasibility.- Ok((!left_interval.eq(&Interval::CERTAINLY_TRUE)- && !right_interval.eq(&Interval::CERTAINLY_TRUE))- .then(|| vec![Interval::CERTAINLY_FALSE, Interval::CERTAINLY_FALSE]))- } else if interval.eq(&Interval::CERTAINLY_TRUE) {+ Ok((!left_interval.eq(&Interval::TRUE)+ && !right_interval.eq(&Interval::TRUE))+ .then(|| vec![Interval::FALSE, Interval::FALSE]))+ } else if interval.eq(&Interval::TRUE) {// If the logical disjunction is certainly true, one of the// operands must be true. However, it's not always possible to// determine which operand is true, leading to different scenarios.// If one operand is certainly false and the other one is uncertain,// then the latter must be certainly true.- if left_interval.eq(&Interval::CERTAINLY_FALSE)- && right_interval.eq(&Interval::UNCERTAIN)+ if left_interval.eq(&Interval::FALSE)+ && right_interval.eq(&Interval::TRUE_OR_FALSE){- Ok(Some(vec![- Interval::CERTAINLY_FALSE,- Interval::CERTAINLY_TRUE,- ]))- } else if right_interval.eq(&Interval::CERTAINLY_FALSE)- && left_interval.eq(&Interval::UNCERTAIN)+ Ok(Some(vec![Interval::FALSE, Interval::TRUE]))+ } else if right_interval.eq(&Interval::FALSE)+ && left_interval.eq(&Interval::TRUE_OR_FALSE){- Ok(Some(vec![- Interval::CERTAINLY_TRUE,- Interval::CERTAINLY_FALSE,- ]))+ Ok(Some(vec![Interval::TRUE, Interval::FALSE]))}// If both children are uncertain, or if one is certainly true,// we cannot conclusively refine their intervals. In this case,diff --git a/datafusion/physical-expr/src/expressions/not.rs b/datafusion/physical-expr/src/expressions/not.rsindex 8184ef601e..655fc7f92e 100644--- a/datafusion/physical-expr/src/expressions/not.rs+++ b/datafusion/physical-expr/src/expressions/not.rs@@ -155,16 +155,16 @@ impl PhysicalExpr for NotExpr {match (parent, children[0]) {(Bernoulli(parent), Bernoulli(child)) => {let parent_range = parent.range();- let result = if parent_range == Interval::CERTAINLY_TRUE {- if child.range() == Interval::CERTAINLY_TRUE {+ let result = if parent_range == Interval::TRUE {+ if child.range() == Interval::TRUE {None} else {Some(vec![Distribution::new_bernoulli(ScalarValue::new_zero(&child.data_type(),)?)?])}- } else if parent_range == Interval::CERTAINLY_FALSE {- if child.range() == Interval::CERTAINLY_FALSE {+ } else if parent_range == Interval::FALSE {+ if child.range() == Interval::FALSE {None} else {Some(vec![Distribution::new_bernoulli(ScalarValue::new_one(diff --git a/datafusion/physical-expr/src/intervals/cp_solver.rs b/datafusion/physical-expr/src/intervals/cp_solver.rsindex 573cc88db7..b1fe75a223 100644--- a/datafusion/physical-expr/src/intervals/cp_solver.rs+++ b/datafusion/physical-expr/src/intervals/cp_solver.rs@@ -345,7 +345,7 @@ pub fn propagate_comparison(left_child: &Interval,right_child: &Interval,) -> Result<Option<(Interval, Interval)>> {- if parent == &Interval::CERTAINLY_TRUE {+ if parent == &Interval::TRUE {match op {Operator::Eq => left_child.intersect(right_child).map(|result| {result.map(|intersection| (intersection.clone(), intersection))@@ -360,7 +360,7 @@ pub fn propagate_comparison("The operator must be a comparison operator to propagate intervals"),}- } else if parent == &Interval::CERTAINLY_FALSE {+ } else if parent == &Interval::FALSE {match op {Operator::Eq => {// TODO: Propagation is not possible until we support interval sets.@@ -518,10 +518,10 @@ impl ExprIntervalGraph {// (1) given_range ⊇ bounds => Nothing to propagate// (2) ∅ ⊂ (given_range ∩ bounds) ⊂ bounds => Can propagate// (3) Disjoint sets => Infeasible- if given_range.contains(bounds)? == Interval::CERTAINLY_TRUE {+ if given_range.contains(bounds)? == Interval::TRUE {// First case:Ok(PropagationResult::CannotPropagate)- } else if bounds.contains(&given_range)? != Interval::CERTAINLY_FALSE {+ } else if bounds.contains(&given_range)? != Interval::FALSE {// Second case:let result = self.propagate_constraints(given_range);self.update_intervals(leaf_bounds);@@ -643,7 +643,7 @@ impl ExprIntervalGraph {let node_interval = self.graph[node].interval();// Special case: true OR could in principle be propagated by 3 interval sets,// (i.e. left true, or right true, or both true) however we do not support this yet.- if node_interval == &Interval::CERTAINLY_TRUE+ if node_interval == &Interval::TRUE&& self.graph[node].expr.as_any()@@ -815,8 +815,7 @@ mod tests {.map(|((_, interval), (_, index))| (*index, interval.clone())).collect_vec();- let exp_result =- graph.update_ranges(&mut col_stat_nodes[..], Interval::CERTAINLY_TRUE)?;+ let exp_result = graph.update_ranges(&mut col_stat_nodes[..], Interval::TRUE)?;assert_eq!(exp_result, result);col_stat_nodes.iter().zip(expected_nodes.iter()).for_each(|((_, calculated_interval_node), (_, expected))| {@@ -1575,12 +1574,7 @@ mod tests {Interval::make(None, Some(999_i64))?,Interval::make(Some(1000_i64), Some(1000_i64))?,))),- propagate_comparison(- &Operator::Lt,- &Interval::CERTAINLY_TRUE,- &left,- &right- )?+ propagate_comparison(&Operator::Lt, &Interval::TRUE, &left, &right)?);let left =@@ -1604,12 +1598,7 @@ mod tests {ScalarValue::TimestampNanosecond(Some(1000), None),)?))),- propagate_comparison(- &Operator::Lt,- &Interval::CERTAINLY_TRUE,- &left,- &right- )?+ propagate_comparison(&Operator::Lt, &Interval::TRUE, &left, &right)?);let left = Interval::make_unbounded(&DataType::Timestamp(@@ -1635,12 +1624,7 @@ mod tests {ScalarValue::TimestampNanosecond(Some(1000), Some("+05:00".into())),)?))),- propagate_comparison(- &Operator::Lt,- &Interval::CERTAINLY_TRUE,- &left,- &right- )?+ propagate_comparison(&Operator::Lt, &Interval::TRUE, &left, &right)?);Ok(())@@ -1653,38 +1637,38 @@ mod tests {Operator::Or,Arc::new(Column::new("b", 1)),));- let parent = Interval::CERTAINLY_FALSE;+ let parent = Interval::FALSE;let children_set = vec![- vec![&Interval::CERTAINLY_FALSE, &Interval::UNCERTAIN],- vec![&Interval::UNCERTAIN, &Interval::CERTAINLY_FALSE],- vec![&Interval::CERTAINLY_FALSE, &Interval::CERTAINLY_FALSE],- vec![&Interval::UNCERTAIN, &Interval::UNCERTAIN],+ vec![&Interval::FALSE, &Interval::TRUE_OR_FALSE],+ vec![&Interval::TRUE_OR_FALSE, &Interval::FALSE],+ vec![&Interval::FALSE, &Interval::FALSE],+ vec![&Interval::TRUE_OR_FALSE, &Interval::TRUE_OR_FALSE],];for children in children_set {assert_eq!(expr.propagate_constraints(&parent, &children)?.unwrap(),- vec![Interval::CERTAINLY_FALSE, Interval::CERTAINLY_FALSE],+ vec![Interval::FALSE, Interval::FALSE],);}- let parent = Interval::CERTAINLY_FALSE;+ let parent = Interval::FALSE;let children_set = vec![- vec![&Interval::CERTAINLY_TRUE, &Interval::UNCERTAIN],- vec![&Interval::UNCERTAIN, &Interval::CERTAINLY_TRUE],+ vec![&Interval::TRUE, &Interval::TRUE_OR_FALSE],+ vec![&Interval::TRUE_OR_FALSE, &Interval::TRUE],];for children in children_set {assert_eq!(expr.propagate_constraints(&parent, &children)?, None,);}- let parent = Interval::CERTAINLY_TRUE;- let children = vec![&Interval::CERTAINLY_FALSE, &Interval::UNCERTAIN];+ let parent = Interval::TRUE;+ let children = vec![&Interval::FALSE, &Interval::TRUE_OR_FALSE];assert_eq!(expr.propagate_constraints(&parent, &children)?.unwrap(),- vec![Interval::CERTAINLY_FALSE, Interval::CERTAINLY_TRUE]+ vec![Interval::FALSE, Interval::TRUE]);- let parent = Interval::CERTAINLY_TRUE;- let children = vec![&Interval::UNCERTAIN, &Interval::UNCERTAIN];+ let parent = Interval::TRUE;+ let children = vec![&Interval::TRUE_OR_FALSE, &Interval::TRUE_OR_FALSE];assert_eq!(expr.propagate_constraints(&parent, &children)?.unwrap(),// Empty means unchanged intervals.@@ -1701,25 +1685,22 @@ mod tests {Operator::And,Arc::new(Column::new("b", 1)),));- let parent = Interval::CERTAINLY_FALSE;+ let parent = Interval::FALSE;let children_and_results_set = vec![(- vec![&Interval::CERTAINLY_TRUE, &Interval::UNCERTAIN],- vec![Interval::CERTAINLY_TRUE, Interval::CERTAINLY_FALSE],+ vec![&Interval::TRUE, &Interval::TRUE_OR_FALSE],+ vec![Interval::TRUE, Interval::FALSE],),(- vec![&Interval::UNCERTAIN, &Interval::CERTAINLY_TRUE],- vec![Interval::CERTAINLY_FALSE, Interval::CERTAINLY_TRUE],+ vec![&Interval::TRUE_OR_FALSE, &Interval::TRUE],+ vec![Interval::FALSE, Interval::TRUE],),(- vec![&Interval::UNCERTAIN, &Interval::UNCERTAIN],+ vec![&Interval::TRUE_OR_FALSE, &Interval::TRUE_OR_FALSE],// Empty means unchanged intervals.vec![],),- (- vec![&Interval::CERTAINLY_FALSE, &Interval::UNCERTAIN],- vec![],- ),+ (vec![&Interval::FALSE, &Interval::TRUE_OR_FALSE], vec![]),];for (children, result) in children_and_results_set {assert_eq!(diff --git a/datafusion/physical-expr/src/statistics/stats_solver.rs b/datafusion/physical-expr/src/statistics/stats_solver.rsindex ec58076caf..fae6996646 100644--- a/datafusion/physical-expr/src/statistics/stats_solver.rs+++ b/datafusion/physical-expr/src/statistics/stats_solver.rs@@ -156,7 +156,7 @@ impl ExprStatisticsGraph {// If the given statistics enable us to obtain a more precise// range for the root, update it:let subset = root_range.contains(given_range)?;- self.graph[self.root].dist = if subset == Interval::CERTAINLY_TRUE {+ self.graph[self.root].dist = if subset == Interval::TRUE {// Given statistics is strictly more informative, use it as is:given_stats} else {diff --git a/datafusion/physical-plan/src/joins/symmetric_hash_join.rs b/datafusion/physical-plan/src/joins/symmetric_hash_join.rsindex 5a2c80e8fd..8b1d1d2e11 100644--- a/datafusion/physical-plan/src/joins/symmetric_hash_join.rs+++ b/datafusion/physical-plan/src/joins/symmetric_hash_join.rs@@ -1241,7 +1241,7 @@ impl OneSideHashJoiner {filter_intervals.push((expr.node_index(), expr.interval().clone()))}// Update the physical expression graph using the join filter intervals:- graph.update_ranges(&mut filter_intervals, Interval::CERTAINLY_TRUE)?;+ graph.update_ranges(&mut filter_intervals, Interval::TRUE)?;// Extract the new join filter interval for the build side:let calculated_build_side_interval = filter_intervals.remove(0).1;// If the intervals have not changed, return early without pruning: