masonh22 commented on code in PR #20059:
URL: https://github.com/apache/datafusion/pull/20059#discussion_r2746652875
##########
datafusion/functions/src/math/floor.rs:
##########
@@ -200,7 +203,242 @@ impl ScalarUDFImpl for FloorFunc {
Interval::make_unbounded(&data_type)
}
+ /// Compute the preimage for floor function.
+ ///
+ /// For `floor(x) = N`, the preimage is `x >= N AND x < N + 1`
+ /// because floor(x) = N for all x in [N, N+1).
+ ///
+ /// This enables predicate pushdown optimizations, transforming:
+ /// `floor(col) = 100` into `col >= 100 AND col < 101`
+ fn preimage(
+ &self,
+ args: &[Expr],
+ lit_expr: &Expr,
+ _info: &SimplifyContext,
+ ) -> Result<PreimageResult> {
+ // floor takes exactly one argument
+ if args.len() != 1 {
+ return Ok(PreimageResult::None);
+ }
+
+ let arg = args[0].clone();
+
+ // Extract the literal value being compared to
+ let Expr::Literal(lit_value, _) = lit_expr else {
+ return Ok(PreimageResult::None);
+ };
+
+ // Compute lower bound (N) and upper bound (N + 1) using helper
functions
+ let Some((lower, upper)) = (match lit_value {
+ // Floating-point types
+ ScalarValue::Float64(Some(n)) =>
float_preimage_bounds(*n).map(|(lo, hi)| {
+ (
+ ScalarValue::Float64(Some(lo)),
+ ScalarValue::Float64(Some(hi)),
+ )
+ }),
+ ScalarValue::Float32(Some(n)) =>
float_preimage_bounds(*n).map(|(lo, hi)| {
+ (
+ ScalarValue::Float32(Some(lo)),
+ ScalarValue::Float32(Some(hi)),
+ )
+ }),
+
+ // Integer types
+ ScalarValue::Int8(Some(n)) => int_preimage_bounds(*n).map(|(lo,
hi)| {
+ (ScalarValue::Int8(Some(lo)), ScalarValue::Int8(Some(hi)))
+ }),
+ ScalarValue::Int16(Some(n)) => int_preimage_bounds(*n).map(|(lo,
hi)| {
+ (ScalarValue::Int16(Some(lo)), ScalarValue::Int16(Some(hi)))
+ }),
+ ScalarValue::Int32(Some(n)) => int_preimage_bounds(*n).map(|(lo,
hi)| {
+ (ScalarValue::Int32(Some(lo)), ScalarValue::Int32(Some(hi)))
+ }),
+ ScalarValue::Int64(Some(n)) => int_preimage_bounds(*n).map(|(lo,
hi)| {
+ (ScalarValue::Int64(Some(lo)), ScalarValue::Int64(Some(hi)))
+ }),
+
+ // Unsupported types
+ _ => None,
+ }) else {
+ return Ok(PreimageResult::None);
+ };
+
+ Ok(PreimageResult::Range {
+ expr: arg,
+ interval: Box::new(Interval::try_new(lower, upper)?),
+ })
+ }
+
fn documentation(&self) -> Option<&Documentation> {
self.doc()
}
}
+
+// ============ Helper functions for preimage bounds ============
+
+/// Compute preimage bounds for floor function on floating-point types.
+/// For floor(x) = n, the preimage is [n, n+1).
Review Comment:
Now that I think about it some more, this is wrong. e.g. if `n=1.3`, this
says that the preimage is `[1.3, 2.3)`. That's clearly wrong because there is
no input `x` such that `floor(x) = 1.3`.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
