use cast wrapper in starts_with

Author: zjregee

datafusion/functions/src/string/starts_with.rs

@@ -26,7 +26,7 @@ use crate::utils::make_scalar_function;
 use datafusion_common::types::logical_string;
 use datafusion_common::{internal_err, Result, ScalarValue};
 use datafusion_expr::{
-    Coercion, ColumnarValue, Documentation, Expr, Like, ScalarFunctionArgs,
+    cast, Coercion, ColumnarValue, Documentation, Expr, Like, ScalarFunctionArgs,
     ScalarUDFImpl, Signature, TypeSignatureClass, Volatility,
 };
 use datafusion_macros::user_doc;
@@ -137,7 +137,7 @@ impl ScalarUDFImpl for StartsWithFunc {
 
             return Ok(ExprSimplifyResult::Simplified(Expr::Like(Like {
                 negated: false,
-                expr: Box::new(args[0].clone()),
+                expr: Box::new(cast(args[0].clone(), scalar_value.data_type())),
                 pattern: Box::new(like_expr),
                 escape_char: None,
                 case_insensitive: false,

datafusion/physical-expr/src/expressions/like.rs

@@ -19,7 +19,6 @@ use std::hash::Hash;
 use std::{any::Any, sync::Arc};
 
 use crate::PhysicalExpr;
-use arrow::compute::can_cast_types;
 use arrow::datatypes::{DataType, Schema};
 use arrow::record_batch::RecordBatch;
 use datafusion_common::{internal_err, Result};
@@ -122,10 +121,7 @@ impl PhysicalExpr for LikeExpr {
     fn evaluate(&self, batch: &RecordBatch) -> Result<ColumnarValue> {
         use arrow::compute::*;
         let lhs = self.expr.evaluate(batch)?;
-        let rhs = self
-            .pattern
-            .evaluate(batch)?
-            .cast_to(&lhs.data_type(), None)?;
+        let rhs = self.pattern.evaluate(batch)?;
         match (self.negated, self.case_insensitive) {
             (false, false) => apply_cmp(&lhs, &rhs, like),
             (false, true) => apply_cmp(&lhs, &rhs, ilike),
@@ -169,10 +165,7 @@ pub fn like(
 ) -> Result<Arc<dyn PhysicalExpr>> {
     let expr_type = &expr.data_type(input_schema)?;
     let pattern_type = &pattern.data_type(input_schema)?;
-    if !expr_type.eq(pattern_type)
-        && !can_cast_types(expr_type, pattern_type)
-        && !can_like_type(expr_type)
-    {
+    if !expr_type.eq(pattern_type) && !can_like_type(expr_type) {
         return internal_err!(
             "The type of {expr_type} AND {pattern_type} of like physical should be same"
         );

datafusion/sqllogictest/test_files/parquet.slt

@@ -619,13 +619,13 @@ query TT
 explain select * from foo where starts_with(column1, 'f');
 ----
 logical_plan
-01)Filter: foo.column1 LIKE Utf8("f%")
-02)--TableScan: foo projection=[column1], partial_filters=[foo.column1 LIKE Utf8("f%")]
+01)Filter: CAST(foo.column1 AS Utf8) LIKE Utf8("f%")
+02)--TableScan: foo projection=[column1], partial_filters=[CAST(foo.column1 AS Utf8) LIKE Utf8("f%")]
 physical_plan
 01)CoalesceBatchesExec: target_batch_size=8192
-02)--FilterExec: column1@0 LIKE f%
+02)--FilterExec: CAST(column1@0 AS Utf8) LIKE f%
 03)----RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=1
-04)------DataSourceExec: file_groups={1 group: [[WORKSPACE_ROOT/datafusion/sqllogictest/test_files/scratch/parquet/foo.parquet]]}, projection=[column1], file_type=parquet, predicate=column1@0 LIKE f%, pruning_predicate=column1_null_count@2 != row_count@3 AND column1_min@0 <= g AND f <= column1_max@1, required_guarantees=[]
+04)------DataSourceExec: file_groups={1 group: [[WORKSPACE_ROOT/datafusion/sqllogictest/test_files/scratch/parquet/foo.parquet]]}, projection=[column1], file_type=parquet, predicate=CAST(column1@0 AS Utf8) LIKE f%
 
 statement ok
 drop table foo

datafusion/sqllogictest/test_files/string/string_view.slt

@@ -355,8 +355,9 @@ EXPLAIN SELECT
 FROM test;
 ----
 logical_plan
-01)Projection: test.column1_utf8view LIKE Utf8("äöüß%") AS c1, CASE test.column1_utf8view IS NOT NULL WHEN Boolean(true) THEN Boolean(true) END AS c2, starts_with(test.column1_utf8view, Utf8View(NULL)) AS c3, starts_with(Utf8View(NULL), test.column1_utf8view) AS c4
-02)--TableScan: test projection=[column1_utf8view]
+01)Projection: __common_expr_1 LIKE Utf8("äöüß%") AS c1, CASE __common_expr_1 IS NOT NULL WHEN Boolean(true) THEN Boolean(true) END AS c2, starts_with(test.column1_utf8view, Utf8View(NULL)) AS c3, starts_with(Utf8View(NULL), test.column1_utf8view) AS c4
+02)--Projection: CAST(test.column1_utf8view AS Utf8) AS __common_expr_1, test.column1_utf8view
+03)----TableScan: test projection=[column1_utf8view]
 
 ## Test STARTS_WITH is rewitten to LIKE when the pattern is a constant
 query TT
@@ -370,8 +371,9 @@ EXPLAIN SELECT
 FROM test;
 ----
 logical_plan
-01)Projection: test.column1_utf8 LIKE Utf8("foo\%%") AS c1, test.column1_large_utf8 LIKE Utf8("foo\%%") AS c2, test.column1_utf8view LIKE Utf8("foo\%%") AS c3, test.column1_utf8 LIKE Utf8("f_o%") AS c4, test.column1_large_utf8 LIKE Utf8("f_o%") AS c5, test.column1_utf8view LIKE Utf8("f_o%") AS c6
-02)--TableScan: test projection=[column1_utf8, column1_large_utf8, column1_utf8view]
+01)Projection: __common_expr_1 LIKE Utf8("foo\%%") AS c1, __common_expr_2 LIKE Utf8("foo\%%") AS c2, __common_expr_3 LIKE Utf8("foo\%%") AS c3, __common_expr_1 LIKE Utf8("f_o%") AS c4, __common_expr_2 LIKE Utf8("f_o%") AS c5, __common_expr_3 LIKE Utf8("f_o%") AS c6
+02)--Projection: CAST(test.column1_utf8 AS Utf8) AS __common_expr_1, CAST(test.column1_large_utf8 AS Utf8) AS __common_expr_2, CAST(test.column1_utf8view AS Utf8) AS __common_expr_3
+03)----TableScan: test projection=[column1_utf8, column1_large_utf8, column1_utf8view]
 
 ## Test STARTS_WITH works with column arguments
 query TT
@@ -940,7 +942,7 @@ EXPLAIN SELECT
 FROM test;
 ----
 logical_plan
-01)Projection: test.column1_utf8view LIKE Utf8("foo%") AS c, starts_with(test.column1_utf8view, test.column2_utf8view) AS c2
+01)Projection: CAST(test.column1_utf8view AS Utf8) LIKE Utf8("foo%") AS c, starts_with(test.column1_utf8view, test.column2_utf8view) AS c2
 02)--TableScan: test projection=[column1_utf8view, column2_utf8view]
 
 ## Ensure no casts for TRANSLATE