Implemented simplify for the starts_with function to convert it into a LIKE expression.

[jatin510]

Implemented simplify for the starts_with function to convert it into a LIKE expression

Which issue does this PR close?

Closes #14027.

Rationale for this change

Using 'LIKE' expr for 'starts_with' to enable predicate pruning.

What changes are included in this PR?

Implemented simplify for the starts_with function to convert it into a LIKE expression, enabling predicate pruning optimization.

Are these changes tested?

Ues

Are there any user-facing changes?

No

[alamb]

Thank you @jatin510 -- this looks great

Can you please add some tests for this?

Specifically, I think you can use an explain test in sqllogictests, something like the following. The EXPLAIN should show LIKE being used in the physical plan

> create table t(x varchar) as values ('foo'), ('bar');
0 row(s) fetched.
Elapsed 0.013 seconds.

> explain select starts_with(x, 'fo') from t;
+---------------+----------------------------------------------------------------------------+
| plan_type     | plan                                                                       |
+---------------+----------------------------------------------------------------------------+
| logical_plan  | Projection: starts_with(t.x, Utf8("fo"))                                   |
|               |   TableScan: t projection=[x]                                              |
| physical_plan | ProjectionExec: expr=[starts_with(x@0, fo) as starts_with(t.x,Utf8("fo"))] |
|               |   MemoryExec: partitions=1, partition_sizes=[1]                            |
|               |                                                                            |
+---------------+----------------------------------------------------------------------------+
2 row(s) fetched.
Elapsed 0.003 seconds.

[alamb]

I think we probably need to escape any % that appears in the pattern (or avoid doing this replacement when such a pattern exists)

[alamb]

Marking as draft as I think this PR is no longer waiting on feedback. Please mark it as ready for review when it is ready for another look

[alamb]

Thank you @jatin510 -- this looks really nice

cc @adriangb (this should support pruning on starts_with, though it might be good to add some tests for that explicitly)

I merged this PR up from main and added some more test coverage as I had it checked out and was messing with it

[alamb]

this is actually pretty cool -- it figured out that STARTS_WITH(column1_utf8view, '') as c2, is true if column1_utf8view is NOT NULL

[alamb]

I double checked the escaping logic and I think this looks good to me.

[alamb]

This is really sweet. You an see it working to prune parquet files here:

> copy (values ('foo'), ('bar'), ('baz')) to '/tmp/foo.parquet' STORED AS parquet;
+-------+
| count |
+-------+
| 3     |
+-------+
1 row(s) fetched.
Elapsed 0.010 seconds.

> explain select * from '/tmp/foo.parquet' where starts_with(column1, 'f');
+---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| plan_type     | plan                                                                                                                                                                                                                                                  |
+---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| logical_plan  | Filter: /tmp/foo.parquet.column1 LIKE Utf8View("f%")                                                                                                                                                                                                  |
|               |   TableScan: /tmp/foo.parquet projection=[column1], partial_filters=[/tmp/foo.parquet.column1 LIKE Utf8View("f%")]                                                                                                                                    |
| physical_plan | CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                           |
|               |   FilterExec: column1@0 LIKE f%                                                                                                                                                                                                                       |
|               |     RepartitionExec: partitioning=RoundRobinBatch(16), input_partitions=1                                                                                                                                                                             |
|               |       ParquetExec: file_groups={1 group: [[tmp/foo.parquet]]}, projection=[column1], predicate=column1@0 LIKE f%, pruning_predicate=column1_null_count@2 != column1_row_count@3 AND column1_min@0 <= g AND f <= column1_max@1, required_guarantees=[] |
|               |                                                                                                                                                                                                                                                       |
+---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
2 row(s) fetched.
Elapsed 0.019 seconds.

Specifically the predicate AND column1_min@0 <= g AND f <= column1_max@1 shows it has translated the like into a min/max range on column_1 🤯

I will also add a test to this PR demonstrating this too

[alamb]

this is so cool!

[adriangb]

This looks great!