VTX-7456 Add support for temporal data types in interval arithmetics

datafusion/common/src/scalar/mod.rs

@@ -1205,6 +1205,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/core/src/physical_optimizer/join_selection.rs

@@ -1578,7 +1578,6 @@ mod util_tests {
     use arrow_schema::{DataType, Field, Schema};
     use datafusion_expr::Operator;
     use datafusion_physical_expr::expressions::{BinaryExpr, Column, NegativeExpr};
-    use datafusion_physical_expr::intervals::utils::check_support;
     use datafusion_physical_expr::PhysicalExpr;
 
     #[test]
@@ -1592,21 +1591,24 @@ mod util_tests {
             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));
     }
 }
 

datafusion/core/src/physical_optimizer/pipeline_checker.rs

@@ -29,7 +29,7 @@ use crate::physical_plan::{ExecutionPlan, ExecutionPlanProperties};
 use datafusion_common::config::OptimizerOptions;
 use datafusion_common::plan_err;
 use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode};
-use datafusion_physical_expr::intervals::utils::{check_support, is_datatype_supported};
+use datafusion_physical_expr_common::utils::is_supported_datatype_for_bounds_eval;
 use datafusion_physical_plan::joins::SymmetricHashJoinExec;
 
 /// The PipelineChecker rule rejects non-runnable query plans that use
@@ -96,12 +96,14 @@ pub fn check_finiteness_requirements(
 /// [`Operator`]: datafusion_expr::Operator
 fn is_prunable(join: &SymmetricHashJoinExec) -> bool {
     join.filter().map_or(false, |filter| {
-        check_support(filter.expression(), &join.schema())
+        filter
+            .expression()
+            .supports_bounds_evaluation(&join.schema())
             && filter
                 .schema()
                 .fields()
                 .iter()
-                .all(|f| is_datatype_supported(f.data_type()))
+                .all(|f| is_supported_datatype_for_bounds_eval(f.data_type()))
     })
 }