From 837f896908d8b92766b3a1b8fdc913daeedd9fdc Mon Sep 17 00:00:00 2001 From: Kumar Ujjawal Date: Sat, 28 Feb 2026 13:31:30 +0530 Subject: [PATCH 1/6] Make lower emit Utf8View for Utf8View input --- datafusion/functions/src/string/common.rs | 74 +++++++++++++++---- datafusion/functions/src/string/lower.rs | 28 ++++++- .../sqllogictest/test_files/functions.slt | 15 ++++ 3 files changed, 97 insertions(+), 20 deletions(-) diff --git a/datafusion/functions/src/string/common.rs b/datafusion/functions/src/string/common.rs index 77af82e25c483..50eb3cad90bb8 100644 --- a/datafusion/functions/src/string/common.rs +++ b/datafusion/functions/src/string/common.rs @@ -22,7 +22,7 @@ use std::sync::Arc; use crate::strings::make_and_append_view; use arrow::array::{ Array, ArrayRef, GenericStringArray, GenericStringBuilder, NullBufferBuilder, - OffsetSizeTrait, StringBuilder, StringViewArray, new_null_array, + OffsetSizeTrait, StringBuilder, StringViewArray, StringViewBuilder, new_null_array, }; use arrow::buffer::{Buffer, ScalarBuffer}; use arrow::datatypes::DataType; @@ -332,17 +332,34 @@ fn string_trim(args: &[ArrayRef]) -> Result Result { - case_conversion(args, |string| string.to_lowercase(), name) + case_conversion( + args, + |string| string.to_lowercase(), + name, + Utf8ViewOutput::Utf8View, + ) } pub(crate) fn to_upper(args: &[ColumnarValue], name: &str) -> Result { - case_conversion(args, |string| string.to_uppercase(), name) + case_conversion( + args, + |string| string.to_uppercase(), + name, + Utf8ViewOutput::Utf8, + ) +} + +#[derive(Debug, Clone, Copy)] +enum Utf8ViewOutput { + Utf8, + Utf8View, } fn case_conversion<'a, F>( args: &'a [ColumnarValue], op: F, name: &str, + utf8view_output: Utf8ViewOutput, ) -> Result where F: Fn(&'a str) -> String, @@ -358,20 +375,38 @@ where >(array, op)?)), DataType::Utf8View => { let string_array = as_string_view_array(array)?; - let mut string_builder = StringBuilder::with_capacity( - string_array.len(), - string_array.get_array_memory_size(), - ); - - for str in string_array.iter() { - if let Some(str) = str { - string_builder.append_value(op(str)); - } else { - string_builder.append_null(); + match utf8view_output { + Utf8ViewOutput::Utf8 => { + let mut string_builder = StringBuilder::with_capacity( + string_array.len(), + string_array.get_array_memory_size(), + ); + + for str in string_array.iter() { + if let Some(str) = str { + string_builder.append_value(op(str)); + } else { + string_builder.append_null(); + } + } + + Ok(ColumnarValue::Array(Arc::new(string_builder.finish()))) + } + Utf8ViewOutput::Utf8View => { + let mut string_builder = + StringViewBuilder::with_capacity(string_array.len()); + + for str in string_array.iter() { + if let Some(str) = str { + string_builder.append_value(op(str)); + } else { + string_builder.append_null(); + } + } + + Ok(ColumnarValue::Array(Arc::new(string_builder.finish()))) } } - - Ok(ColumnarValue::Array(Arc::new(string_builder.finish()))) } other => exec_err!("Unsupported data type {other:?} for function {name}"), }, @@ -386,7 +421,14 @@ where } ScalarValue::Utf8View(a) => { let result = a.as_ref().map(|x| op(x)); - Ok(ColumnarValue::Scalar(ScalarValue::Utf8(result))) + match utf8view_output { + Utf8ViewOutput::Utf8 => { + Ok(ColumnarValue::Scalar(ScalarValue::Utf8(result))) + } + Utf8ViewOutput::Utf8View => { + Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(result))) + } + } } other => exec_err!("Unsupported data type {other:?} for function {name}"), }, diff --git a/datafusion/functions/src/string/lower.rs b/datafusion/functions/src/string/lower.rs index 3750d3d290a9c..a11b4de2355d5 100644 --- a/datafusion/functions/src/string/lower.rs +++ b/datafusion/functions/src/string/lower.rs @@ -82,7 +82,11 @@ impl ScalarUDFImpl for LowerFunc { } fn return_type(&self, arg_types: &[DataType]) -> Result { - utf8_to_str_type(&arg_types[0], "lower") + if arg_types[0] == DataType::Utf8View { + Ok(DataType::Utf8View) + } else { + utf8_to_str_type(&arg_types[0], "lower") + } } fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result { @@ -97,8 +101,7 @@ impl ScalarUDFImpl for LowerFunc { #[cfg(test)] mod tests { use super::*; - use arrow::array::{Array, ArrayRef, StringArray}; - use arrow::datatypes::DataType::Utf8; + use arrow::array::{Array, ArrayRef, StringArray, StringViewArray}; use arrow::datatypes::Field; use datafusion_common::config::ConfigOptions; use std::sync::Arc; @@ -111,7 +114,7 @@ mod tests { number_rows: input.len(), args: vec![ColumnarValue::Array(input)], arg_fields, - return_field: Field::new("f", Utf8, true).into(), + return_field: Field::new("f", expected.data_type().clone(), true).into(), config_options: Arc::new(ConfigOptions::default()), }; @@ -197,4 +200,21 @@ mod tests { to_lower(input, expected) } + + #[test] + fn lower_utf8view() -> Result<()> { + let input = Arc::new(StringViewArray::from(vec![ + Some("ARROW"), + None, + Some("TSCHÜSS"), + ])) as ArrayRef; + + let expected = Arc::new(StringViewArray::from(vec![ + Some("arrow"), + None, + Some("tschüss"), + ])) as ArrayRef; + + to_lower(input, expected) + } } diff --git a/datafusion/sqllogictest/test_files/functions.slt b/datafusion/sqllogictest/test_files/functions.slt index 5a43d18e23879..5747c270050a5 100644 --- a/datafusion/sqllogictest/test_files/functions.slt +++ b/datafusion/sqllogictest/test_files/functions.slt @@ -500,6 +500,21 @@ SELECT lower(arrow_cast('ÁRVORE AÇÃO ΑΒΓ', 'Dictionary(Int32, Utf8)')) ---- árvore ação αβγ +query T +SELECT arrow_typeof(lower('FOObar')) +---- +Utf8 + +query T +SELECT arrow_typeof(lower(arrow_cast('FOObar', 'LargeUtf8'))) +---- +LargeUtf8 + +query T +SELECT arrow_typeof(lower(arrow_cast('FOObar', 'Utf8View'))) +---- +Utf8View + query T SELECT ltrim(' foo') ---- From d92a711b6257ffe9715a5911002b6a856842fb10 Mon Sep 17 00:00:00 2001 From: Kumar Ujjawal Date: Mon, 2 Mar 2026 13:53:16 +0530 Subject: [PATCH 2/6] Make lower and upper emit Utf8View for Utf8View input --- datafusion/functions/src/string/common.rs | 82 ++++++------------- datafusion/functions/src/string/lower.rs | 9 +- datafusion/functions/src/string/upper.rs | 27 ++++-- .../sqllogictest/test_files/functions.slt | 15 ++++ 4 files changed, 63 insertions(+), 70 deletions(-) diff --git a/datafusion/functions/src/string/common.rs b/datafusion/functions/src/string/common.rs index 50eb3cad90bb8..31e2f5ee798a2 100644 --- a/datafusion/functions/src/string/common.rs +++ b/datafusion/functions/src/string/common.rs @@ -20,9 +20,10 @@ use std::sync::Arc; use crate::strings::make_and_append_view; +use crate::utils::utf8_to_str_type; use arrow::array::{ Array, ArrayRef, GenericStringArray, GenericStringBuilder, NullBufferBuilder, - OffsetSizeTrait, StringBuilder, StringViewArray, StringViewBuilder, new_null_array, + OffsetSizeTrait, StringViewArray, StringViewBuilder, new_null_array, }; use arrow::buffer::{Buffer, ScalarBuffer}; use arrow::datatypes::DataType; @@ -331,35 +332,29 @@ fn string_trim(args: &[ArrayRef]) -> Result Result { - case_conversion( - args, - |string| string.to_lowercase(), - name, - Utf8ViewOutput::Utf8View, - ) +pub(crate) fn case_conversion_return_type( + arg_type: &DataType, + name: &str, +) -> Result { + if arg_type == &DataType::Utf8View { + Ok(DataType::Utf8View) + } else { + utf8_to_str_type(arg_type, name) + } } -pub(crate) fn to_upper(args: &[ColumnarValue], name: &str) -> Result { - case_conversion( - args, - |string| string.to_uppercase(), - name, - Utf8ViewOutput::Utf8, - ) +pub(crate) fn to_lower(args: &[ColumnarValue], name: &str) -> Result { + case_conversion(args, |string| string.to_lowercase(), name) } -#[derive(Debug, Clone, Copy)] -enum Utf8ViewOutput { - Utf8, - Utf8View, +pub(crate) fn to_upper(args: &[ColumnarValue], name: &str) -> Result { + case_conversion(args, |string| string.to_uppercase(), name) } fn case_conversion<'a, F>( args: &'a [ColumnarValue], op: F, name: &str, - utf8view_output: Utf8ViewOutput, ) -> Result where F: Fn(&'a str) -> String, @@ -375,38 +370,18 @@ where >(array, op)?)), DataType::Utf8View => { let string_array = as_string_view_array(array)?; - match utf8view_output { - Utf8ViewOutput::Utf8 => { - let mut string_builder = StringBuilder::with_capacity( - string_array.len(), - string_array.get_array_memory_size(), - ); + let mut string_builder = + StringViewBuilder::with_capacity(string_array.len()); - for str in string_array.iter() { - if let Some(str) = str { - string_builder.append_value(op(str)); - } else { - string_builder.append_null(); - } - } - - Ok(ColumnarValue::Array(Arc::new(string_builder.finish()))) - } - Utf8ViewOutput::Utf8View => { - let mut string_builder = - StringViewBuilder::with_capacity(string_array.len()); - - for str in string_array.iter() { - if let Some(str) = str { - string_builder.append_value(op(str)); - } else { - string_builder.append_null(); - } - } - - Ok(ColumnarValue::Array(Arc::new(string_builder.finish()))) + for str in string_array.iter() { + if let Some(str) = str { + string_builder.append_value(op(str)); + } else { + string_builder.append_null(); } } + + Ok(ColumnarValue::Array(Arc::new(string_builder.finish()))) } other => exec_err!("Unsupported data type {other:?} for function {name}"), }, @@ -421,14 +396,7 @@ where } ScalarValue::Utf8View(a) => { let result = a.as_ref().map(|x| op(x)); - match utf8view_output { - Utf8ViewOutput::Utf8 => { - Ok(ColumnarValue::Scalar(ScalarValue::Utf8(result))) - } - Utf8ViewOutput::Utf8View => { - Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(result))) - } - } + Ok(ColumnarValue::Scalar(ScalarValue::Utf8View(result))) } other => exec_err!("Unsupported data type {other:?} for function {name}"), }, diff --git a/datafusion/functions/src/string/lower.rs b/datafusion/functions/src/string/lower.rs index a11b4de2355d5..18ce660de85c7 100644 --- a/datafusion/functions/src/string/lower.rs +++ b/datafusion/functions/src/string/lower.rs @@ -18,8 +18,7 @@ use arrow::datatypes::DataType; use std::any::Any; -use crate::string::common::to_lower; -use crate::utils::utf8_to_str_type; +use crate::string::common::{case_conversion_return_type, to_lower}; use datafusion_common::Result; use datafusion_common::types::logical_string; use datafusion_expr::{ @@ -82,11 +81,7 @@ impl ScalarUDFImpl for LowerFunc { } fn return_type(&self, arg_types: &[DataType]) -> Result { - if arg_types[0] == DataType::Utf8View { - Ok(DataType::Utf8View) - } else { - utf8_to_str_type(&arg_types[0], "lower") - } + case_conversion_return_type(&arg_types[0], "lower") } fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result { diff --git a/datafusion/functions/src/string/upper.rs b/datafusion/functions/src/string/upper.rs index a2a7db1848f59..084b0c1d5700d 100644 --- a/datafusion/functions/src/string/upper.rs +++ b/datafusion/functions/src/string/upper.rs @@ -15,8 +15,7 @@ // specific language governing permissions and limitations // under the License. -use crate::string::common::to_upper; -use crate::utils::utf8_to_str_type; +use crate::string::common::{case_conversion_return_type, to_upper}; use arrow::datatypes::DataType; use datafusion_common::Result; use datafusion_common::types::logical_string; @@ -81,7 +80,7 @@ impl ScalarUDFImpl for UpperFunc { } fn return_type(&self, arg_types: &[DataType]) -> Result { - utf8_to_str_type(&arg_types[0], "upper") + case_conversion_return_type(&arg_types[0], "upper") } fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result { @@ -96,8 +95,7 @@ impl ScalarUDFImpl for UpperFunc { #[cfg(test)] mod tests { use super::*; - use arrow::array::{Array, ArrayRef, StringArray}; - use arrow::datatypes::DataType::Utf8; + use arrow::array::{Array, ArrayRef, StringArray, StringViewArray}; use arrow::datatypes::Field; use datafusion_common::config::ConfigOptions; use std::sync::Arc; @@ -110,7 +108,7 @@ mod tests { number_rows: input.len(), args: vec![ColumnarValue::Array(input)], arg_fields: vec![arg_field], - return_field: Field::new("f", Utf8, true).into(), + return_field: Field::new("f", expected.data_type().clone(), true).into(), config_options: Arc::new(ConfigOptions::default()), }; @@ -196,4 +194,21 @@ mod tests { to_upper(input, expected) } + + #[test] + fn upper_utf8view() -> Result<()> { + let input = Arc::new(StringViewArray::from(vec![ + Some("arrow"), + None, + Some("tschüß"), + ])) as ArrayRef; + + let expected = Arc::new(StringViewArray::from(vec![ + Some("ARROW"), + None, + Some("TSCHÜSS"), + ])) as ArrayRef; + + to_upper(input, expected) + } } diff --git a/datafusion/sqllogictest/test_files/functions.slt b/datafusion/sqllogictest/test_files/functions.slt index 5747c270050a5..9ffbbfb8a2a47 100644 --- a/datafusion/sqllogictest/test_files/functions.slt +++ b/datafusion/sqllogictest/test_files/functions.slt @@ -445,6 +445,21 @@ SELECT upper(arrow_cast('árvore ação αβγ', 'Dictionary(Int32, Utf8)')) ---- ÁRVORE AÇÃO ΑΒΓ +query T +SELECT arrow_typeof(upper('foo')) +---- +Utf8 + +query T +SELECT arrow_typeof(upper(arrow_cast('foo', 'LargeUtf8'))) +---- +LargeUtf8 + +query T +SELECT arrow_typeof(upper(arrow_cast('foo', 'Utf8View'))) +---- +Utf8View + query T SELECT btrim(' foo ') ---- From d553ac1f4e70a861194a83b28418ab54bca53570 Mon Sep 17 00:00:00 2001 From: Kumar Ujjawal Date: Mon, 2 Mar 2026 14:30:36 +0530 Subject: [PATCH 3/6] Handle dictionary Utf8View return type in case conversion --- datafusion/functions/src/string/common.rs | 13 +++++++++---- datafusion/functions/src/string/lower.rs | 10 ++++++++++ 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/datafusion/functions/src/string/common.rs b/datafusion/functions/src/string/common.rs index 31e2f5ee798a2..d56d2e7fe404f 100644 --- a/datafusion/functions/src/string/common.rs +++ b/datafusion/functions/src/string/common.rs @@ -336,10 +336,15 @@ pub(crate) fn case_conversion_return_type( arg_type: &DataType, name: &str, ) -> Result { - if arg_type == &DataType::Utf8View { - Ok(DataType::Utf8View) - } else { - utf8_to_str_type(arg_type, name) + match arg_type { + DataType::Utf8View | DataType::BinaryView => Ok(DataType::Utf8View), + DataType::Dictionary(_, value_type) + if **value_type == DataType::Utf8View + || **value_type == DataType::BinaryView => + { + Ok(DataType::Utf8View) + } + _ => utf8_to_str_type(arg_type, name), } } diff --git a/datafusion/functions/src/string/lower.rs b/datafusion/functions/src/string/lower.rs index 18ce660de85c7..0f2783c0848cb 100644 --- a/datafusion/functions/src/string/lower.rs +++ b/datafusion/functions/src/string/lower.rs @@ -212,4 +212,14 @@ mod tests { to_lower(input, expected) } + + #[test] + fn lower_return_type_dictionary_utf8view() -> Result<()> { + let return_type = LowerFunc::new().return_type(&[DataType::Dictionary( + Box::new(DataType::Int32), + Box::new(DataType::Utf8View), + )])?; + assert_eq!(return_type, DataType::Utf8View); + Ok(()) + } } From 825b423be2e794e9cc6f1719a825974dbb7650d9 Mon Sep 17 00:00:00 2001 From: Kumar Ujjawal Date: Tue, 3 Mar 2026 12:25:05 +0530 Subject: [PATCH 4/6] Refine lower/upper Utf8View tests and return typing --- datafusion/functions/src/string/common.rs | 7 ++----- datafusion/functions/src/string/upper.rs | 10 ++++++++++ 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/datafusion/functions/src/string/common.rs b/datafusion/functions/src/string/common.rs index d56d2e7fe404f..6ed9363616171 100644 --- a/datafusion/functions/src/string/common.rs +++ b/datafusion/functions/src/string/common.rs @@ -337,11 +337,8 @@ pub(crate) fn case_conversion_return_type( name: &str, ) -> Result { match arg_type { - DataType::Utf8View | DataType::BinaryView => Ok(DataType::Utf8View), - DataType::Dictionary(_, value_type) - if **value_type == DataType::Utf8View - || **value_type == DataType::BinaryView => - { + DataType::Utf8View => Ok(DataType::Utf8View), + DataType::Dictionary(_, value_type) if **value_type == DataType::Utf8View => { Ok(DataType::Utf8View) } _ => utf8_to_str_type(arg_type, name), diff --git a/datafusion/functions/src/string/upper.rs b/datafusion/functions/src/string/upper.rs index 084b0c1d5700d..92c3d861b7bd1 100644 --- a/datafusion/functions/src/string/upper.rs +++ b/datafusion/functions/src/string/upper.rs @@ -211,4 +211,14 @@ mod tests { to_upper(input, expected) } + + #[test] + fn upper_return_type_dictionary_utf8view() -> Result<()> { + let return_type = UpperFunc::new().return_type(&[DataType::Dictionary( + Box::new(DataType::Int32), + Box::new(DataType::Utf8View), + )])?; + assert_eq!(return_type, DataType::Utf8View); + Ok(()) + } } From 5adb958f9e8afcf2642ab5a618fcf6b54401064f Mon Sep 17 00:00:00 2001 From: Kumar Ujjawal Date: Tue, 3 Mar 2026 13:07:34 +0530 Subject: [PATCH 5/6] add dictionary slt tests --- .../sqllogictest/test_files/functions.slt | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/datafusion/sqllogictest/test_files/functions.slt b/datafusion/sqllogictest/test_files/functions.slt index 9ffbbfb8a2a47..9dcfd83ab7f92 100644 --- a/datafusion/sqllogictest/test_files/functions.slt +++ b/datafusion/sqllogictest/test_files/functions.slt @@ -435,6 +435,11 @@ SELECT upper(arrow_cast('foo', 'Dictionary(Int32, Utf8)')) ---- FOO +query T +SELECT upper(arrow_cast(arrow_cast('foo', 'Dictionary(Int32, Utf8)'), 'Dictionary(Int32, Utf8View)')) +---- +FOO + query T SELECT upper('árvore ação αβγ') ---- @@ -460,6 +465,11 @@ SELECT arrow_typeof(upper(arrow_cast('foo', 'Utf8View'))) ---- Utf8View +query T +SELECT arrow_typeof(upper(arrow_cast(arrow_cast('foo', 'Dictionary(Int32, Utf8)'), 'Dictionary(Int32, Utf8View)'))) +---- +Utf8View + query T SELECT btrim(' foo ') ---- @@ -505,6 +515,11 @@ SELECT lower(arrow_cast('FOObar', 'Dictionary(Int32, Utf8)')) ---- foobar +query T +SELECT lower(arrow_cast(arrow_cast('FOObar', 'Dictionary(Int32, Utf8)'), 'Dictionary(Int32, Utf8View)')) +---- +foobar + query T SELECT lower('ÁRVORE AÇÃO ΑΒΓ') ---- @@ -530,6 +545,11 @@ SELECT arrow_typeof(lower(arrow_cast('FOObar', 'Utf8View'))) ---- Utf8View +query T +SELECT arrow_typeof(lower(arrow_cast(arrow_cast('FOObar', 'Dictionary(Int32, Utf8)'), 'Dictionary(Int32, Utf8View)'))) +---- +Utf8View + query T SELECT ltrim(' foo') ---- From 4ddfc61b238881115f11b75dc46d2b7831c4db84 Mon Sep 17 00:00:00 2001 From: Kumar Ujjawal Date: Fri, 6 Mar 2026 12:26:25 +0530 Subject: [PATCH 6/6] remove case_conversion block --- datafusion/functions/src/string/common.rs | 14 -------------- datafusion/functions/src/string/lower.rs | 14 ++------------ datafusion/functions/src/string/upper.rs | 14 ++------------ 3 files changed, 4 insertions(+), 38 deletions(-) diff --git a/datafusion/functions/src/string/common.rs b/datafusion/functions/src/string/common.rs index 6ed9363616171..cc97c1b2c1957 100644 --- a/datafusion/functions/src/string/common.rs +++ b/datafusion/functions/src/string/common.rs @@ -20,7 +20,6 @@ use std::sync::Arc; use crate::strings::make_and_append_view; -use crate::utils::utf8_to_str_type; use arrow::array::{ Array, ArrayRef, GenericStringArray, GenericStringBuilder, NullBufferBuilder, OffsetSizeTrait, StringViewArray, StringViewBuilder, new_null_array, @@ -332,19 +331,6 @@ fn string_trim(args: &[ArrayRef]) -> Result Result { - match arg_type { - DataType::Utf8View => Ok(DataType::Utf8View), - DataType::Dictionary(_, value_type) if **value_type == DataType::Utf8View => { - Ok(DataType::Utf8View) - } - _ => utf8_to_str_type(arg_type, name), - } -} - pub(crate) fn to_lower(args: &[ColumnarValue], name: &str) -> Result { case_conversion(args, |string| string.to_lowercase(), name) } diff --git a/datafusion/functions/src/string/lower.rs b/datafusion/functions/src/string/lower.rs index 0f2783c0848cb..d91e4595c58ac 100644 --- a/datafusion/functions/src/string/lower.rs +++ b/datafusion/functions/src/string/lower.rs @@ -18,7 +18,7 @@ use arrow::datatypes::DataType; use std::any::Any; -use crate::string::common::{case_conversion_return_type, to_lower}; +use crate::string::common::to_lower; use datafusion_common::Result; use datafusion_common::types::logical_string; use datafusion_expr::{ @@ -81,7 +81,7 @@ impl ScalarUDFImpl for LowerFunc { } fn return_type(&self, arg_types: &[DataType]) -> Result { - case_conversion_return_type(&arg_types[0], "lower") + Ok(arg_types[0].clone()) } fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result { @@ -212,14 +212,4 @@ mod tests { to_lower(input, expected) } - - #[test] - fn lower_return_type_dictionary_utf8view() -> Result<()> { - let return_type = LowerFunc::new().return_type(&[DataType::Dictionary( - Box::new(DataType::Int32), - Box::new(DataType::Utf8View), - )])?; - assert_eq!(return_type, DataType::Utf8View); - Ok(()) - } } diff --git a/datafusion/functions/src/string/upper.rs b/datafusion/functions/src/string/upper.rs index 92c3d861b7bd1..80375f58c87be 100644 --- a/datafusion/functions/src/string/upper.rs +++ b/datafusion/functions/src/string/upper.rs @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -use crate::string::common::{case_conversion_return_type, to_upper}; +use crate::string::common::to_upper; use arrow::datatypes::DataType; use datafusion_common::Result; use datafusion_common::types::logical_string; @@ -80,7 +80,7 @@ impl ScalarUDFImpl for UpperFunc { } fn return_type(&self, arg_types: &[DataType]) -> Result { - case_conversion_return_type(&arg_types[0], "upper") + Ok(arg_types[0].clone()) } fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result { @@ -211,14 +211,4 @@ mod tests { to_upper(input, expected) } - - #[test] - fn upper_return_type_dictionary_utf8view() -> Result<()> { - let return_type = UpperFunc::new().return_type(&[DataType::Dictionary( - Box::new(DataType::Int32), - Box::new(DataType::Utf8View), - )])?; - assert_eq!(return_type, DataType::Utf8View); - Ok(()) - } }