The previous documentation here describes the relationship between expr and interval as being direct, but the idea shouldn't be that expr >= lower and expr < upper, It should be:
udf(expr) <op> literal logically implies that expr can be directly compared with interval.

That is, if udf(expr) <op> literal is true, then there is a transformation involving expr and interval that is logically equivalent.

Specifically:

• if floor(x) < 8, then preimage should return interval: [8, 9) such that the expression can be rewritten to x < 8.
• if floor(x) < 8.3, then preimage should return interval: [8, 9) such that the expression can be rewritten to x < 9.

Notice that both expressions yield the same interval because both 8 and 8.3 are literals in that range, and have equivalent outputs (floor(8) == floor(8.3) == { for y in [8, 9): floor(y) }).

Then, rewrite_with_preimage must accommodate the predicate operator (< in this case) to correctly transform the expression using the preimage interval and a boundary condition (is_boundary = floor(y) == y).

I don't fully understand this logic

For the example floor(x) < 8.3 I would expect there to be no preimage as defined here -- specifically there is no range of inputs for which floor(x) evaluates to 8.3

I agree that it is valid simplificaition to rewrite floor(x) < 8.3 to x < 9.0, but it seems different than "preimage" 🤔

Maybe we just need to give it a different name (maybe that is what you have tried to do with is_boundary)

BTW I checked with datafusion-cli and the floor(x) < 8.3 case is not optimized today (the preimage is not applied here)

> create OR REPLACE table foo(x float) asvalues (1.0), (8.0), (9.0);
0 row(s) fetched.
Elapsed 0.002 seconds.
>select*from foo where floor(x) <8.3;
+-----+
| x |
+-----+
| 1.0 |
| 8.0 |
+-----+2 row(s) fetched.
> explain select*from foo where floor(x) <8.3;
+---------------+-------------------------------+
| plan_type | plan |
+---------------+-------------------------------+
| physical_plan | ┌───────────────────────────┐ |
| | │ FilterExec │ |
| | │ -------------------- │ |
| | │ predicate: │ |
| | │ CAST(floor(x) AS Float64) │ |
| | │ <8.3 │ |
| | └─────────────┬─────────────┘ |
| | ┌─────────────┴─────────────┐ |
| | │ DataSourceExec │ |
| | │ -------------------- │ |
| | │ bytes: 112 │ |
| | │ format: memory │ |
| | │ rows: 1 │ |
| | └───────────────────────────┘ |
| | |
+---------------+-------------------------------+1 row(s) fetched.
Elapsed 0.008 seconds.
> explain format indent select*from foo where floor(x) <8.3;
+---------------+------------------------------------------------------+
| plan_type | plan |
+---------------+------------------------------------------------------+
| logical_plan | Filter: CAST(floor(foo.x) AS Float64) < Float64(8.3) |
| | TableScan: foo projection=[x] |
| physical_plan | FilterExec: CAST(floor(x@0) AS Float64) <8.3 |
| | DataSourceExec: partitions=1, partition_sizes=[1] |
| | |
+---------------+------------------------------------------------------+2 row(s) fetched.
Elapsed 0.002 seconds.

While trying to understand this, I wonder if it might be easier to express by instead of adding a field to Range we could instead add a new variant. Something like this:

enumPreimageResult{/// ...Range{expr:Expr,interval:Box<Interval>},// The original expression UDF(lit) = lit// 1. `<` and `>=` operators:/// if `Some(false)`, expression rewrite should use `interval.upper`/// 2. `=` and `!=` operators:/// if `Some(false)`, expression rewrite can use constant (false and true, respectively)Boundary{expr:Expr,interval:Box<Interval>},}