Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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: