Support bounds evaluation for temporal data types

datafusion-examples/examples/expr_api.rs

@@ -24,7 +24,7 @@ use arrow::record_batch::RecordBatch;
 use datafusion::arrow::datatypes::{DataType, Field, Schema, TimeUnit};
 use datafusion::common::stats::Precision;
 use datafusion::common::tree_node::{Transformed, TreeNode};
-use datafusion::common::{ColumnStatistics, DFSchema};
+use datafusion::common::{internal_datafusion_err, ColumnStatistics, DFSchema};
 use datafusion::common::{ScalarValue, ToDFSchema};
 use datafusion::error::Result;
 use datafusion::functions_aggregate::first_last::first_value_udaf;
@@ -302,10 +302,17 @@ fn boundary_analysis_and_selectivity_demo() -> Result<()> {
         distinct_count: Precision::Absent,
     };
 
+    let field = schema.fields().first().ok_or_else(|| {
+        internal_datafusion_err!("schema does not have a field at index 0")
+    })?;
+
     // We can then build our expression boundaries from the column statistics
     // allowing the analysis to be more precise.
-    let initial_boundaries =
-        vec![ExprBoundaries::try_from_column(&schema, &column_stats, 0)?];
+    let initial_boundaries = vec![ExprBoundaries::try_from_column(
+        field.as_ref(),
+        &column_stats,
+        0,
+    )?];
 
     // With the above we can perform the boundary analysis similar to the previous
     // example.

datafusion/common/src/scalar/mod.rs

@@ -1583,6 +1583,17 @@ impl ScalarValue {
         }
     }
 
+    /// Returns negation for a boolean scalar value
+    pub fn boolean_negate(&self) -> Result<Self> {
+        match self {
+            ScalarValue::Boolean(None) => Ok(self.clone()),
+            ScalarValue::Boolean(Some(value)) => Ok(ScalarValue::Boolean(Some(!value))),
+            value => {
+                _internal_err!("Can not run boolean negative on scalar value {value:?}")
+            }
+        }
+    }
+
     /// Wrapping addition of `ScalarValue`
     ///
     /// NB: operating on `ScalarValue` directly is not efficient, performance sensitive code

datafusion/common/src/stats.rs

@@ -158,7 +158,7 @@ impl Precision<usize> {
     /// rows are selected. A selectivity of `0.5` means half the rows are
     /// selected. Will always return inexact statistics.
     pub fn with_estimated_selectivity(self, selectivity: f64) -> Self {
-        self.map(|v| ((v as f64 * selectivity).ceil()) as usize)
+        self.map(|v| (v as f64 * selectivity).ceil() as usize)
             .to_inexact()
     }
 }

datafusion/core/tests/physical_optimizer/join_selection.rs

@@ -32,7 +32,6 @@ use datafusion_execution::{RecordBatchStream, SendableRecordBatchStream, TaskCon
 use datafusion_expr::Operator;
 use datafusion_physical_expr::expressions::col;
 use datafusion_physical_expr::expressions::{BinaryExpr, Column, NegativeExpr};
-use datafusion_physical_expr::intervals::utils::check_support;
 use datafusion_physical_expr::PhysicalExprRef;
 use datafusion_physical_expr::{EquivalenceProperties, Partitioning, PhysicalExpr};
 use datafusion_physical_optimizer::join_selection::{
@@ -1071,21 +1070,21 @@ fn check_expr_supported() {
         Operator::Plus,
         Arc::new(Column::new("a", 0)),
     )) as Arc<dyn PhysicalExpr>;
-    assert!(check_support(&supported_expr, &schema));
+    assert!(&supported_expr.supports_bounds_evaluation(&schema));
     let supported_expr_2 = Arc::new(Column::new("a", 0)) as Arc<dyn PhysicalExpr>;
-    assert!(check_support(&supported_expr_2, &schema));
+    assert!(&supported_expr_2.supports_bounds_evaluation(&schema));
     let unsupported_expr = Arc::new(BinaryExpr::new(
         Arc::new(Column::new("a", 0)),
         Operator::Or,
         Arc::new(Column::new("a", 0)),
     )) as Arc<dyn PhysicalExpr>;
-    assert!(!check_support(&unsupported_expr, &schema));
+    assert!(!&unsupported_expr.supports_bounds_evaluation(&schema));
     let unsupported_expr_2 = Arc::new(BinaryExpr::new(
         Arc::new(Column::new("a", 0)),
         Operator::Or,
         Arc::new(NegativeExpr::new(Arc::new(Column::new("a", 0)))),
     )) as Arc<dyn PhysicalExpr>;
-    assert!(!check_support(&unsupported_expr_2, &schema));
+    assert!(!&unsupported_expr_2.supports_bounds_evaluation(&schema));
 }
 
 struct TestCase {

datafusion/expr-common/Cargo.toml

@@ -42,3 +42,6 @@ datafusion-common = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 paste = "^1.0"
+
+[dev-dependencies]
+arrow-buffer = { workspace = true }