Apache DataFusion SQL Query Engine
Add Decimal support for floor preimage (#20099)
Devanshu43977dada6d4
diff --git a/datafusion/functions/src/math/floor.rs b/datafusion/functions/src/math/floor.rsindex 7c7604b7fd..d4f25716ff 100644--- a/datafusion/functions/src/math/floor.rs+++ b/datafusion/functions/src/math/floor.rs@@ -19,9 +19,10 @@ use std::any::Any;use std::sync::Arc;use arrow::array::{ArrayRef, AsArray};+use arrow::compute::{DecimalCast, rescale_decimal};use arrow::datatypes::{- DataType, Decimal32Type, Decimal64Type, Decimal128Type, Decimal256Type, Float32Type,- Float64Type,+ ArrowNativeTypeOp, DataType, Decimal32Type, Decimal64Type, Decimal128Type,+ Decimal256Type, DecimalType, Float32Type, Float64Type,};use datafusion_common::{Result, ScalarValue, exec_err};use datafusion_expr::interval_arithmetic::Interval;@@ -77,6 +78,42 @@ impl FloorFunc {}}+// ============ Macro for preimage bounds ============+/// Generates the code to call the appropriate bounds function and wrap results.+macro_rules! preimage_bounds {+ // Float types: call float_preimage_bounds and wrap in ScalarValue+ (float: $variant:ident, $value:expr) => {+ float_preimage_bounds($value).map(|(lo, hi)| {+ (+ ScalarValue::$variant(Some(lo)),+ ScalarValue::$variant(Some(hi)),+ )+ })+ };++ // Integer types: call int_preimage_bounds and wrap in ScalarValue+ (int: $variant:ident, $value:expr) => {+ int_preimage_bounds($value).map(|(lo, hi)| {+ (+ ScalarValue::$variant(Some(lo)),+ ScalarValue::$variant(Some(hi)),+ )+ })+ };++ // Decimal types: call decimal_preimage_bounds with precision/scale and wrap in ScalarValue+ (decimal: $variant:ident, $decimal_type:ty, $value:expr, $precision:expr, $scale:expr) => {+ decimal_preimage_bounds::<$decimal_type>($value, $precision, $scale).map(+ |(lo, hi)| {+ (+ ScalarValue::$variant(Some(lo), $precision, $scale),+ ScalarValue::$variant(Some(hi), $precision, $scale),+ )+ },+ )+ };+}+impl ScalarUDFImpl for FloorFunc {fn as_any(&self) -> &dyn Any {self@@ -216,10 +253,8 @@ impl ScalarUDFImpl for FloorFunc {lit_expr: &Expr,_info: &SimplifyContext,) -> Result<PreimageResult> {- // floor takes exactly one argument- if args.len() != 1 {- return Ok(PreimageResult::None);- }+ // floor takes exactly one argument and we do not expect to reach here with multiple arguments.+ debug_assert!(args.len() == 1, "floor() takes exactly one argument");let arg = args[0].clone();@@ -230,35 +265,34 @@ impl ScalarUDFImpl for FloorFunc {// Compute lower bound (N) and upper bound (N + 1) using helper functionslet Some((lower, upper)) = (match lit_value {- // Decimal types should be supported and tracked in- // https://github.com/apache/datafusion/issues/20080// 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)))- }),+ ScalarValue::Float64(Some(n)) => preimage_bounds!(float: Float64, *n),+ ScalarValue::Float32(Some(n)) => preimage_bounds!(float: Float32, *n),++ // Integer types (not reachable from SQL/SLT: floor() only accepts Float64/Float32/Decimal,+ // so the RHS literal is always coerced to one of those before preimage runs; kept for+ // programmatic use and unit tests)+ ScalarValue::Int8(Some(n)) => preimage_bounds!(int: Int8, *n),+ ScalarValue::Int16(Some(n)) => preimage_bounds!(int: Int16, *n),+ ScalarValue::Int32(Some(n)) => preimage_bounds!(int: Int32, *n),+ ScalarValue::Int64(Some(n)) => preimage_bounds!(int: Int64, *n),++ // Decimal types+ // DECIMAL(precision, scale) where precision ≤ 38 -> Decimal128(precision, scale)+ // DECIMAL(precision, scale) where precision > 38 -> Decimal256(precision, scale)+ // Decimal32 and Decimal64 are unreachable from SQL/SLT.+ ScalarValue::Decimal32(Some(n), precision, scale) => {+ preimage_bounds!(decimal: Decimal32, Decimal32Type, *n, *precision, *scale)+ }+ ScalarValue::Decimal64(Some(n), precision, scale) => {+ preimage_bounds!(decimal: Decimal64, Decimal64Type, *n, *precision, *scale)+ }+ ScalarValue::Decimal128(Some(n), precision, scale) => {+ preimage_bounds!(decimal: Decimal128, Decimal128Type, *n, *precision, *scale)+ }+ ScalarValue::Decimal256(Some(n), precision, scale) => {+ preimage_bounds!(decimal: Decimal256, Decimal256Type, *n, *precision, *scale)+ }// Unsupported types_ => None,@@ -310,9 +344,49 @@ fn int_preimage_bounds<I: CheckedAdd + One + Copy>(n: I) -> Option<(I, I)> {Some((n, upper))}+/// Compute preimage bounds for floor function on decimal types.+/// For floor(x) = n, the preimage is [n, n+1).+/// Returns None if:+/// - The value has a fractional part (floor always returns integers)+/// - Adding 1 would overflow+fn decimal_preimage_bounds<D: DecimalType>(+ value: D::Native,+ precision: u8,+ scale: i8,+) -> Option<(D::Native, D::Native)>+where+ D::Native: DecimalCast + ArrowNativeTypeOp + std::ops::Rem<Output = D::Native>,+{+ // Use rescale_decimal to compute "1" at target scale (avoids manual pow)+ // Convert integer 1 (scale=0) to the target scale+ let one_scaled: D::Native = rescale_decimal::<D, D>(+ D::Native::ONE, // value = 1+ 1, // input_precision = 1+ 0, // input_scale = 0 (integer)+ precision, // output_precision+ scale, // output_scale+ )?;++ // floor always returns an integer, so if value has a fractional part, there's no solution+ // Check: value % one_scaled != 0 means fractional part exists+ if scale > 0 && value % one_scaled != D::Native::ZERO {+ return None;+ }++ // Compute upper bound using checked addition+ // Before preimage stage, the internal i128/i256(value) is validated based on the precision and scale.+ // MAX_DECIMAL128_FOR_EACH_PRECISION and MAX_DECIMAL256_FOR_EACH_PRECISION are used to validate the internal i128/i256.+ // Any invalid i128/i256 will not reach here.+ // Therefore, the add_checked will always succeed if tested via SQL/SLT path.+ let upper = value.add_checked(one_scaled).ok()?;++ Some((value, upper))+}+#[cfg(test)]mod tests {use super::*;+ use arrow_buffer::i256;use datafusion_expr::col;/// Helper to test valid preimage cases that should return a Range@@ -434,33 +508,182 @@ mod tests {assert_preimage_none(ScalarValue::Int64(None));}+ // ============ Decimal32 Tests (mirrors float/int tests) ============+#[test]- fn test_floor_preimage_invalid_inputs() {- let floor_func = FloorFunc::new();- let info = SimplifyContext::default();+ fn test_floor_preimage_decimal_valid_cases() {+ // ===== Decimal32 =====+ // Positive integer decimal: 100.00 (scale=2, so raw=10000)+ // floor(x) = 100.00 -> x in [100.00, 101.00)+ assert_preimage_range(+ ScalarValue::Decimal32(Some(10000), 9, 2),+ ScalarValue::Decimal32(Some(10000), 9, 2), // 100.00+ ScalarValue::Decimal32(Some(10100), 9, 2), // 101.00+ );- // Non-literal comparison value- let result = floor_func.preimage(&[col("x")], &col("y"), &info).unwrap();- assert!(- matches!(result, PreimageResult::None),- "Expected None for non-literal"+ // Smaller positive: 50.00+ assert_preimage_range(+ ScalarValue::Decimal32(Some(5000), 9, 2),+ ScalarValue::Decimal32(Some(5000), 9, 2), // 50.00+ ScalarValue::Decimal32(Some(5100), 9, 2), // 51.00);- // Wrong argument count (too many)- let lit = Expr::Literal(ScalarValue::Float64(Some(100.0)), None);- let result = floor_func- .preimage(&[col("x"), col("y")], &lit, &info)- .unwrap();- assert!(- matches!(result, PreimageResult::None),- "Expected None for wrong arg count"+ // Negative integer decimal: -5.00+ assert_preimage_range(+ ScalarValue::Decimal32(Some(-500), 9, 2),+ ScalarValue::Decimal32(Some(-500), 9, 2), // -5.00+ ScalarValue::Decimal32(Some(-400), 9, 2), // -4.00);- // Wrong argument count (zero)- let result = floor_func.preimage(&[], &lit, &info).unwrap();- assert!(- matches!(result, PreimageResult::None),- "Expected None for zero args"+ // Zero: 0.00+ assert_preimage_range(+ ScalarValue::Decimal32(Some(0), 9, 2),+ ScalarValue::Decimal32(Some(0), 9, 2), // 0.00+ ScalarValue::Decimal32(Some(100), 9, 2), // 1.00);++ // Scale 0 (pure integer): 42+ assert_preimage_range(+ ScalarValue::Decimal32(Some(42), 9, 0),+ ScalarValue::Decimal32(Some(42), 9, 0),+ ScalarValue::Decimal32(Some(43), 9, 0),+ );++ // ===== Decimal64 =====+ assert_preimage_range(+ ScalarValue::Decimal64(Some(10000), 18, 2),+ ScalarValue::Decimal64(Some(10000), 18, 2), // 100.00+ ScalarValue::Decimal64(Some(10100), 18, 2), // 101.00+ );++ // Negative+ assert_preimage_range(+ ScalarValue::Decimal64(Some(-500), 18, 2),+ ScalarValue::Decimal64(Some(-500), 18, 2), // -5.00+ ScalarValue::Decimal64(Some(-400), 18, 2), // -4.00+ );++ // Zero+ assert_preimage_range(+ ScalarValue::Decimal64(Some(0), 18, 2),+ ScalarValue::Decimal64(Some(0), 18, 2),+ ScalarValue::Decimal64(Some(100), 18, 2),+ );++ // ===== Decimal128 =====+ assert_preimage_range(+ ScalarValue::Decimal128(Some(10000), 38, 2),+ ScalarValue::Decimal128(Some(10000), 38, 2), // 100.00+ ScalarValue::Decimal128(Some(10100), 38, 2), // 101.00+ );++ // Negative+ assert_preimage_range(+ ScalarValue::Decimal128(Some(-500), 38, 2),+ ScalarValue::Decimal128(Some(-500), 38, 2), // -5.00+ ScalarValue::Decimal128(Some(-400), 38, 2), // -4.00+ );++ // Zero+ assert_preimage_range(+ ScalarValue::Decimal128(Some(0), 38, 2),+ ScalarValue::Decimal128(Some(0), 38, 2),+ ScalarValue::Decimal128(Some(100), 38, 2),+ );++ // ===== Decimal256 =====+ assert_preimage_range(+ ScalarValue::Decimal256(Some(i256::from(10000)), 76, 2),+ ScalarValue::Decimal256(Some(i256::from(10000)), 76, 2), // 100.00+ ScalarValue::Decimal256(Some(i256::from(10100)), 76, 2), // 101.00+ );++ // Negative+ assert_preimage_range(+ ScalarValue::Decimal256(Some(i256::from(-500)), 76, 2),+ ScalarValue::Decimal256(Some(i256::from(-500)), 76, 2), // -5.00+ ScalarValue::Decimal256(Some(i256::from(-400)), 76, 2), // -4.00+ );++ // Zero+ assert_preimage_range(+ ScalarValue::Decimal256(Some(i256::ZERO), 76, 2),+ ScalarValue::Decimal256(Some(i256::ZERO), 76, 2),+ ScalarValue::Decimal256(Some(i256::from(100)), 76, 2),+ );+ }++ #[test]+ fn test_floor_preimage_decimal_non_integer() {+ // floor(x) = 1.30 has NO SOLUTION because floor always returns an integer+ // Therefore preimage should return None for non-integer decimals++ // Decimal32+ assert_preimage_none(ScalarValue::Decimal32(Some(130), 9, 2)); // 1.30+ assert_preimage_none(ScalarValue::Decimal32(Some(-250), 9, 2)); // -2.50+ assert_preimage_none(ScalarValue::Decimal32(Some(370), 9, 2)); // 3.70+ assert_preimage_none(ScalarValue::Decimal32(Some(1), 9, 2)); // 0.01++ // Decimal64+ assert_preimage_none(ScalarValue::Decimal64(Some(130), 18, 2)); // 1.30+ assert_preimage_none(ScalarValue::Decimal64(Some(-250), 18, 2)); // -2.50++ // Decimal128+ assert_preimage_none(ScalarValue::Decimal128(Some(130), 38, 2)); // 1.30+ assert_preimage_none(ScalarValue::Decimal128(Some(-250), 38, 2)); // -2.50++ // Decimal256+ assert_preimage_none(ScalarValue::Decimal256(Some(i256::from(130)), 76, 2)); // 1.30+ assert_preimage_none(ScalarValue::Decimal256(Some(i256::from(-250)), 76, 2)); // -2.50++ // Decimal32: i32::MAX - 50+ // This return None because the value is not an integer, not because it is out of range.+ assert_preimage_none(ScalarValue::Decimal32(Some(i32::MAX - 50), 10, 2));++ // Decimal64: i64::MAX - 50+ // This return None because the value is not an integer, not because it is out of range.+ assert_preimage_none(ScalarValue::Decimal64(Some(i64::MAX - 50), 19, 2));+ }++ #[test]+ fn test_floor_preimage_decimal_overflow() {+ // Test near MAX where adding scale_factor would overflow++ // Decimal32: i32::MAX+ assert_preimage_none(ScalarValue::Decimal32(Some(i32::MAX), 10, 0));++ // Decimal64: i64::MAX+ assert_preimage_none(ScalarValue::Decimal64(Some(i64::MAX), 19, 0));+ }++ #[test]+ fn test_floor_preimage_decimal_edge_cases() {+ // ===== Decimal32 =====+ // Large value that doesn't overflow+ // Decimal(9,2) max value is 9,999,999.99 (stored as 999,999,999)+ // Use a large value that fits Decimal(9,2) and is divisible by 100+ let safe_max_aligned_32 = 999_999_900; // 9,999,999.00+ assert_preimage_range(+ ScalarValue::Decimal32(Some(safe_max_aligned_32), 9, 2),+ ScalarValue::Decimal32(Some(safe_max_aligned_32), 9, 2),+ ScalarValue::Decimal32(Some(safe_max_aligned_32 + 100), 9, 2),+ );++ // Negative edge: use a large negative value that fits Decimal(9,2)+ // Decimal(9,2) min value is -9,999,999.99 (stored as -999,999,999)+ let min_aligned_32 = -999_999_900; // -9,999,999.00+ assert_preimage_range(+ ScalarValue::Decimal32(Some(min_aligned_32), 9, 2),+ ScalarValue::Decimal32(Some(min_aligned_32), 9, 2),+ ScalarValue::Decimal32(Some(min_aligned_32 + 100), 9, 2),+ );+ }++ #[test]+ fn test_floor_preimage_decimal_null() {+ assert_preimage_none(ScalarValue::Decimal32(None, 9, 2));+ assert_preimage_none(ScalarValue::Decimal64(None, 18, 2));+ assert_preimage_none(ScalarValue::Decimal128(None, 38, 2));+ assert_preimage_none(ScalarValue::Decimal256(None, 76, 2));}}diff --git a/datafusion/sqllogictest/test_files/floor_preimage.slt b/datafusion/sqllogictest/test_files/floor_preimage.sltnew file mode 100644index 0000000000..86d15ad1a6--- /dev/null+++ b/datafusion/sqllogictest/test_files/floor_preimage.slt@@ -0,0 +1,285 @@+# Licensed to the Apache Software Foundation (ASF) under one+# or more contributor license agreements. See the NOTICE file+# distributed with this work for additional information+# regarding copyright ownership. The ASF licenses this file+# to you under the Apache License, Version 2.0 (the+# "License"); you may not use this file except in compliance+# with the License. You may obtain a copy of the License at++# http://www.apache.org/licenses/LICENSE-2.0++# Unless required by applicable law or agreed to in writing,+# software distributed under the License is distributed on an+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY+# KIND, either express or implied. See the License for the+# specific language governing permissions and limitations+# under the License.++##########+## Floor Preimage Tests+##+## Tests for floor function preimage optimization:+## floor(col) = N transforms to col >= N AND col < N + 1+##+## Uses representative types only (Float64, Int32, Decimal128).+## Unit tests cover all type variants.+##########++# Setup: Single table with representative types+statement ok+CREATE TABLE test_data (+ id INT,+ float_val DOUBLE,+ int_val INT,+ decimal_val DECIMAL(10,2)+) AS VALUES+ (1, 5.3, 100, 100.00),+ (2, 5.7, 101, 100.50),+ (3, 6.0, 102, 101.00),+ (4, 6.5, -5, 101.99),+ (5, 7.0, 0, 102.00),+ (6, NULL, NULL, NULL);++##########+## Data Correctness Tests+##########++# Float64: floor(x) = 5 matches values in [5.0, 6.0)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) = arrow_cast(5, 'Float64');+----+1+2++# Int32: floor(x) = 100 matches values in [100, 101)+query I rowsort+SELECT id FROM test_data WHERE floor(int_val) = 100;+----+1++# Decimal128: floor(x) = 100 matches values in [100.00, 101.00)+query I rowsort+SELECT id FROM test_data WHERE floor(decimal_val) = arrow_cast(100, 'Decimal128(10,2)');+----+1+2++# Negative value: floor(x) = -5 matches values in [-5, -4)+query I rowsort+SELECT id FROM test_data WHERE floor(int_val) = -5;+----+4++# Zero value: floor(x) = 0 matches values in [0, 1)+query I rowsort+SELECT id FROM test_data WHERE floor(int_val) = 0;+----+5++# Column on RHS (same result as LHS)+query I rowsort+SELECT id FROM test_data WHERE arrow_cast(5, 'Float64') = floor(float_val);+----+1+2++# IS NOT DISTINCT FROM (excludes NULLs)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) IS NOT DISTINCT FROM arrow_cast(5, 'Float64');+----+1+2++# IS DISTINCT FROM (includes NULLs)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) IS DISTINCT FROM arrow_cast(5, 'Float64');+----+3+4+5+6++# Non-integer literal (empty result - floor returns integers)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) = arrow_cast(5.5, 'Float64');+----++##########+## EXPLAIN Tests - Plan Optimization+##########++statement ok+set datafusion.explain.logical_plan_only = true;++# 1. Basic: Float64 - floor(col) = N transforms to col >= N AND col < N+1+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) = arrow_cast(5, 'Float64');+----+logical_plan+01)Filter: test_data.float_val >= Float64(5) AND test_data.float_val < Float64(6)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# 2. Basic: Int32 - transformed (coerced to Float64)+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(int_val) = 100;+----+logical_plan+01)Projection: test_data.id, test_data.float_val, test_data.int_val, test_data.decimal_val+02)--Filter: __common_expr_3 >= Float64(100) AND __common_expr_3 < Float64(101)+03)----Projection: CAST(test_data.int_val AS Float64) AS __common_expr_3, test_data.id, test_data.float_val, test_data.int_val, test_data.decimal_val+04)------TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# 3. Basic: Decimal128 - same transformation+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(decimal_val) = arrow_cast(100, 'Decimal128(10,2)');+----+logical_plan+01)Filter: test_data.decimal_val >= Decimal128(Some(10000),10,2) AND test_data.decimal_val < Decimal128(Some(10100),10,2)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# 4. Column on RHS - same transformation+query TT+EXPLAIN SELECT * FROM test_data WHERE arrow_cast(5, 'Float64') = floor(float_val);+----+logical_plan+01)Filter: test_data.float_val >= Float64(5) AND test_data.float_val < Float64(6)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# 5. IS NOT DISTINCT FROM - adds IS NOT NULL+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) IS NOT DISTINCT FROM arrow_cast(5, 'Float64');+----+logical_plan+01)Filter: test_data.float_val IS NOT NULL AND test_data.float_val >= Float64(5) AND test_data.float_val < Float64(6)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# 6. IS DISTINCT FROM - includes NULL check+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) IS DISTINCT FROM arrow_cast(5, 'Float64');+----+logical_plan+01)Filter: test_data.float_val < Float64(5) OR test_data.float_val >= Float64(6) OR test_data.float_val IS NULL+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# 7. Non-optimizable: non-integer literal (original predicate preserved)+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) = arrow_cast(5.5, 'Float64');+----+logical_plan+01)Filter: floor(test_data.float_val) = Float64(5.5)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# 8. Non-optimizable: extreme float literal (2^53) where n+1 loses precision, so preimage returns None+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) = 9007199254740992;+----+logical_plan+01)Filter: floor(test_data.float_val) = Float64(9007199254740992)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# Data correctness: floor(col) = 2^53 returns no rows (no value in test_data has floor exactly 2^53)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) = 9007199254740992;+----++##########+## Other Comparison Operators+##+## The preimage framework automatically handles all comparison operators:+## floor(x) <> N -> x < N OR x >= N+1+## floor(x) > N -> x >= N+1+## floor(x) < N -> x < N+## floor(x) >= N -> x >= N+## floor(x) <= N -> x < N+1+##########++# Data correctness tests for other operators++# Not equals: floor(x) <> 5 matches values outside [5.0, 6.0)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) <> arrow_cast(5, 'Float64');+----+3+4+5++# Greater than: floor(x) > 5 matches values in [6.0, inf)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) > arrow_cast(5, 'Float64');+----+3+4+5++# Less than: floor(x) < 6 matches values in (-inf, 6.0)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) < arrow_cast(6, 'Float64');+----+1+2++# Greater than or equal: floor(x) >= 5 matches values in [5.0, inf)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) >= arrow_cast(5, 'Float64');+----+1+2+3+4+5++# Less than or equal: floor(x) <= 5 matches values in (-inf, 6.0)+query I rowsort+SELECT id FROM test_data WHERE floor(float_val) <= arrow_cast(5, 'Float64');+----+1+2++# EXPLAIN tests showing optimized transformations++# Not equals: floor(x) <> 5 -> x < 5 OR x >= 6+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) <> arrow_cast(5, 'Float64');+----+logical_plan+01)Filter: test_data.float_val < Float64(5) OR test_data.float_val >= Float64(6)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# Greater than: floor(x) > 5 -> x >= 6+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) > arrow_cast(5, 'Float64');+----+logical_plan+01)Filter: test_data.float_val >= Float64(6)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# Less than: floor(x) < 6 -> x < 6+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) < arrow_cast(6, 'Float64');+----+logical_plan+01)Filter: test_data.float_val < Float64(6)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# Greater than or equal: floor(x) >= 5 -> x >= 5+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) >= arrow_cast(5, 'Float64');+----+logical_plan+01)Filter: test_data.float_val >= Float64(5)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++# Less than or equal: floor(x) <= 5 -> x < 6+query TT+EXPLAIN SELECT * FROM test_data WHERE floor(float_val) <= arrow_cast(5, 'Float64');+----+logical_plan+01)Filter: test_data.float_val < Float64(6)+02)--TableScan: test_data projection=[id, float_val, int_val, decimal_val]++##########+## Cleanup+##########++statement ok+DROP TABLE test_data;