Fix tests

common/arrow/Cargo.toml

@@ -15,8 +15,8 @@ simd = ["arrow/simd"]
 # Workspace dependencies
 
 # Github dependencies
-arrow = { package = "arrow2", git="https://github.com/zhyass/arrow2", rev = "2e3de5a" }
-arrow-flight = { git="https://github.com/zhyass/arrow2", rev = "2e3de5a" }
+arrow = { package = "arrow2", git="https://github.com/zhyass/arrow2", rev = "23682f0" }
+arrow-flight = { git="https://github.com/zhyass/arrow2", rev = "23682f0" }
 parquet = {package = "parquet2", git = "https://github.com/datafuse-extras/parquet2", rev = "d28330f"}
 # Crates.io dependencies
 

common/datablocks/src/kernels/data_block_concat_test.rs

@@ -23,7 +23,7 @@ use crate::*;
 fn test_data_block_concat() -> Result<()> {
     let schema = DataSchemaRefExt::create(vec![
         DataField::new("a", DataType::Int64, false),
-        DataField::new("b", DataType::Utf8, false),
+        DataField::new("b", DataType::String, false),
     ]);
 
     let blocks = vec![

common/datablocks/src/kernels/data_block_group_by_hash_test.rs

@@ -23,7 +23,7 @@ fn test_data_block_group_by_hash() -> Result<()> {
         DataField::new("a", DataType::Int8, false),
         DataField::new("b", DataType::Int8, false),
         DataField::new("c", DataType::Int8, false),
-        DataField::new("x", DataType::Utf8, false),
+        DataField::new("x", DataType::String, false),
     ]);
 
     let block = DataBlock::create_by_array(schema.clone(), vec![

common/datablocks/src/kernels/data_block_group_by_test.rs

@@ -21,7 +21,7 @@ use crate::*;
 fn test_data_block_group_by() -> Result<()> {
     let schema = DataSchemaRefExt::create(vec![
         DataField::new("a", DataType::Int8, false),
-        DataField::new("b", DataType::Utf8, false),
+        DataField::new("b", DataType::String, false),
     ]);
 
     let block = DataBlock::create_by_array(schema.clone(), vec![

common/datablocks/src/kernels/data_block_sort_test.rs

@@ -21,7 +21,7 @@ use crate::*;
 fn test_data_block_sort() -> Result<()> {
     let schema = DataSchemaRefExt::create(vec![
         DataField::new("a", DataType::Int64, false),
-        DataField::new("b", DataType::Utf8, false),
+        DataField::new("b", DataType::String, false),
     ]);
 
     let raw = DataBlock::create_by_array(schema.clone(), vec![
@@ -77,7 +77,7 @@ fn test_data_block_sort() -> Result<()> {
 fn test_data_block_merge_sort() -> Result<()> {
     let schema = DataSchemaRefExt::create(vec![
         DataField::new("a", DataType::Int64, false),
-        DataField::new("b", DataType::Utf8, false),
+        DataField::new("b", DataType::String, false),
     ]);
 
     let raw1 = DataBlock::create_by_array(schema.clone(), vec![

common/datablocks/src/kernels/data_block_take_test.rs

@@ -21,7 +21,7 @@ use crate::*;
 fn test_data_block_take() -> Result<()> {
     let schema = DataSchemaRefExt::create(vec![
         DataField::new("a", DataType::Int64, false),
-        DataField::new("b", DataType::Utf8, false),
+        DataField::new("b", DataType::String, false),
     ]);
 
     let raw = DataBlock::create_by_array(schema.clone(), vec![

common/datavalues/src/arrays/ops/agg_test.rs

@@ -76,8 +76,8 @@ fn test_boolean_array_agg() -> Result<()> {
 }
 
 #[test]
-fn test_utf8_array_agg() -> Result<()> {
-    let array = DFUtf8Array::new_from_slice(&vec!["h", "e", "l", "o"]);
+fn test_string_array_agg() -> Result<()> {
+    let array = DFStringArray::new_from_slice(&vec!["h", "e", "l", "o"]);
 
     let value = [
         array.max()?,
@@ -87,15 +87,15 @@ fn test_utf8_array_agg() -> Result<()> {
     ];
 
     let expected = [
-        DataValue::Utf8(Some("o".to_string())),
-        DataValue::Utf8(Some("e".to_string())),
+        DataValue::String(Some("o".as_bytes().to_vec())),
+        DataValue::String(Some("e".as_bytes().to_vec())),
         DataValue::Struct(vec![
             DataValue::UInt64(Some(1)),
-            DataValue::Utf8(Some("e".to_string())),
+            DataValue::String(Some("e".as_bytes().to_vec())),
         ]),
         DataValue::Struct(vec![
             DataValue::UInt64(Some(3)),
-            DataValue::Utf8(Some("o".to_string())),
+            DataValue::String(Some("o".as_bytes().to_vec())),
         ]),
     ];
     let len = value.len();

common/datavalues/src/arrays/ops/apply_test.rs

@@ -46,8 +46,8 @@ fn new_test_boolean_array(cap: usize, begin: i32, end: i32) -> DFBooleanArray {
     builder.finish()
 }
 
-fn new_test_utf8_array(cap: usize, begin: i32, end: i32) -> DFUtf8Array {
-    let mut builder = Utf8ArrayBuilder::with_capacity(cap);
+fn new_test_string_array(cap: usize, begin: i32, end: i32) -> DFStringArray {
+    let mut builder = StringArrayBuilder::with_capacity(cap);
     let s = vec!["ax", "by", "cz", "dm", "13"];
 
     (begin..end).for_each(|index| {
@@ -164,15 +164,15 @@ fn test_boolean_array_apply() -> Result<()> {
 }
 
 #[test]
-fn test_utf8_array_apply() -> Result<()> {
+fn test_string_array_apply() -> Result<()> {
     // array=[null, "by", "cz", null, "13"]
-    let array = new_test_utf8_array(5, 0, 5);
+    let array = new_test_string_array(5, 0, 5);
     let arrays = vec![
         array.apply(|arr| Cow::from(&arr[1..])),
         array.apply_with_idx(|(_, arr)| Cow::from(&arr[..1])),
         array.apply_with_idx_on_opt(|(_, arr)| match arr {
             Some(v) => Some(Cow::from(&v[0..])),
-            None => Some(Cow::from("ff")),
+            None => Some(Cow::from("ff".as_bytes())),
         }),
     ];
 
@@ -190,26 +190,26 @@ fn test_utf8_array_apply() -> Result<()> {
 
     assert_eq!(2, values[0].null_count());
     assert_eq!(true, values[0].is_null(0));
-    assert_eq!("y", values[0].value(1));
-    assert_eq!("z", values[0].value(2));
+    assert_eq!(b"y", values[0].value(1));
+    assert_eq!(b"z", values[0].value(2));
     assert_eq!(true, values[0].is_null(3));
-    assert_eq!("3", values[0].value(4));
+    assert_eq!(b"3", values[0].value(4));
     assert_eq!(true, values[0].is_null(3));
 
     assert_eq!(2, values[1].null_count());
     assert_eq!(true, values[1].is_null(0));
-    assert_eq!("b", values[1].value(1));
-    assert_eq!("c", values[1].value(2));
+    assert_eq!(b"b", values[1].value(1));
+    assert_eq!(b"c", values[1].value(2));
     assert_eq!(true, values[1].is_null(3));
-    assert_eq!("1", values[1].value(4));
+    assert_eq!(b"1", values[1].value(4));
     assert_eq!(true, values[1].is_null(3));
 
     assert_eq!(0, values[2].null_count());
-    assert_eq!("ff", values[2].value(0));
-    assert_eq!("by", values[2].value(1));
-    assert_eq!("cz", values[2].value(2));
-    assert_eq!("ff", values[2].value(3));
-    assert_eq!("13", values[2].value(4));
+    assert_eq!(b"ff", values[2].value(0));
+    assert_eq!(b"by", values[2].value(1));
+    assert_eq!(b"cz", values[2].value(2));
+    assert_eq!(b"ff", values[2].value(3));
+    assert_eq!(b"13", values[2].value(4));
 
     assert_eq!(2, cast_values[0].null_count());
     assert_eq!(true, cast_values[0].is_null(0));

common/datavalues/src/arrays/ops/contain_test.rs

@@ -33,22 +33,22 @@ fn test_contain() -> Result<()> {
     let values = boolean?.collect_values();
     assert_eq!(&[Some(true), Some(false), Some(true)], values.as_slice());
 
-    // Test DFUtf8Array
-    let mut utf8_builder = Utf8ArrayBuilder::with_capacity(3);
-    utf8_builder.append_value("1a");
-    utf8_builder.append_value("2b");
-    utf8_builder.append_value("3c");
-    utf8_builder.append_value("4d");
-    let df_utf8_array = utf8_builder.finish();
-
-    let mut builder = get_list_builder(&DataType::Utf8, 12, 1);
+    // Test DFStringArray
+    let mut string_builder = StringArrayBuilder::with_capacity(3);
+    string_builder.append_value("1a");
+    string_builder.append_value("2b");
+    string_builder.append_value("3c");
+    string_builder.append_value("4d");
+    let df_string_array = string_builder.finish();
+
+    let mut builder = get_list_builder(&DataType::String, 12, 1);
     builder.append_series(&Series::new(vec!["2b", "4d"]));
     builder.append_series(&Series::new(vec!["2b", "4d"]));
     builder.append_series(&Series::new(vec!["2b", "4d"]));
     builder.append_series(&Series::new(vec!["2b", "4d"]));
     let df_list = builder.finish();
 
-    let boolean = df_utf8_array.contain(&df_list);
+    let boolean = df_string_array.contain(&df_list);
     let values = boolean?.collect_values();
     assert_eq!(
         &[Some(false), Some(true), Some(false), Some(true)],

common/datavalues/src/arrays/ops/fill_test.rs

@@ -42,22 +42,22 @@ fn test_array_fill() -> Result<()> {
     assert_eq!(true, df_boolean_array.is_null(1));
     assert_eq!(true, df_boolean_array.is_null(2));
 
-    // Test full for Utf8Array
-    let mut df_utf8_array = DFUtf8Array::full("ab", 3);
-    assert_eq!(0, df_utf8_array.null_count());
-    assert_eq!(false, df_utf8_array.is_null(0));
-    assert_eq!(false, df_utf8_array.is_null(1));
-    assert_eq!(false, df_utf8_array.is_null(2));
-    assert_eq!("ab", df_utf8_array.inner().value(0));
-    assert_eq!("ab", df_utf8_array.inner().value(1));
-    assert_eq!("ab", df_utf8_array.inner().value(2));
-
-    // Test full_null for Utf8Array
-    df_utf8_array = DFUtf8Array::full_null(3);
-    assert_eq!(3, df_utf8_array.null_count());
-    assert_eq!(true, df_utf8_array.is_null(0));
-    assert_eq!(true, df_utf8_array.is_null(1));
-    assert_eq!(true, df_utf8_array.is_null(2));
+    // Test full for StringArray
+    let mut df_string_array = DFStringArray::full("ab".as_bytes(), 3);
+    assert_eq!(0, df_string_array.null_count());
+    assert_eq!(false, df_string_array.is_null(0));
+    assert_eq!(false, df_string_array.is_null(1));
+    assert_eq!(false, df_string_array.is_null(2));
+    assert_eq!("ab".as_bytes(), df_string_array.inner().value(0));
+    assert_eq!("ab".as_bytes(), df_string_array.inner().value(1));
+    assert_eq!("ab".as_bytes(), df_string_array.inner().value(2));
+
+    // Test full_null for StringArray
+    df_string_array = DFStringArray::full_null(3);
+    assert_eq!(3, df_string_array.null_count());
+    assert_eq!(true, df_string_array.is_null(0));
+    assert_eq!(true, df_string_array.is_null(1));
+    assert_eq!(true, df_string_array.is_null(2));
 
     Ok(())
 }

common/datavalues/src/arrays/ops/if_test.rs

@@ -17,6 +17,7 @@ use common_arrow::arrow::array::NullArray;
 use common_arrow::arrow::array::UInt64Array;
 use common_arrow::arrow::compute::comparison::compare_scalar;
 use common_arrow::arrow::compute::comparison::Operator;
+use common_arrow::arrow::datatypes::DataType as ArrowType;
 use common_arrow::arrow::scalar::PrimitiveScalar;
 use common_exception::Result;
 
@@ -58,19 +59,19 @@ fn test_array_if() -> Result<()> {
     assert_eq!(true, res.inner().value(1));
     assert_eq!(true, res.inner().value(2));
 
-    // DFUtf8Array.
-    let lhs = DFUtf8Array::new_from_slice(&["a"]);
-    let rhs = DFUtf8Array::new_from_slice(&["b"]);
+    // DFStringArray.
+    let lhs = DFStringArray::new_from_slice(&["a"]);
+    let rhs = DFStringArray::new_from_slice(&["b"]);
     let res = lhs.if_then_else(&rhs, &conds[0])?;
     assert_eq!(3, res.len());
-    assert_eq!("a", res.inner().value(0));
-    assert_eq!("b", res.inner().value(1));
-    assert_eq!("a", res.inner().value(2));
+    assert_eq!(b"a", res.inner().value(0));
+    assert_eq!(b"b", res.inner().value(1));
+    assert_eq!(b"a", res.inner().value(2));
 
     // DFNullArray.
-    let lhs = NullArray::new_null(2);
+    let lhs = NullArray::new_null(ArrowType::Null, 2);
     let lhs: DFNullArray = lhs.into();
-    let rhs = NullArray::new_null(1);
+    let rhs = NullArray::new_null(ArrowType::Null, 1);
     let rhs: DFNullArray = rhs.into();
     let res = lhs.if_then_else(&rhs, &conds[0])?;
     assert_eq!(2, res.len());

common/datavalues/src/arrays/ops/scatter_test.rs

@@ -33,16 +33,16 @@ fn test_scatter() -> Result<()> {
     assert_eq!(&[2u16, 6], array_vec[2].inner().values().as_slice());
     assert_eq!(&[3u16, 5, 8], array_vec[3].inner().values().as_slice());
 
-    // Test DFUint16Array
-    let df_utf8_array = DFUtf8Array::new_from_slice(&["a", "b", "c", "d"]);
+    // Test DFStringArray
+    let df_string_array = DFStringArray::new_from_slice(&["a", "b", "c", "d"]);
     let indices = vec![1, 0, 1, 1];
-    assert_eq!(df_utf8_array.len(), indices.len());
+    assert_eq!(df_string_array.len(), indices.len());
 
-    let array_vec = unsafe { df_utf8_array.scatter_unchecked(&mut indices.into_iter(), 2)? };
-    let v1: Vec<&str> = array_vec[0].into_no_null_iter().collect();
-    let v2: Vec<&str> = array_vec[1].into_no_null_iter().collect();
-    assert_eq!(vec!["b"], v1);
-    assert_eq!(vec!["a", "c", "d"], v2);
+    let array_vec = unsafe { df_string_array.scatter_unchecked(&mut indices.into_iter(), 2)? };
+    let v1: Vec<&[u8]> = array_vec[0].into_no_null_iter().collect();
+    let v2: Vec<&[u8]> = array_vec[1].into_no_null_iter().collect();
+    assert_eq!(vec![b"b"], v1);
+    assert_eq!(vec![b"a", b"c", b"d"], v2);
 
     // Test BooleanArray
     let df_bool_array = DFBooleanArray::new_from_slice(&[true, false, true, false]);

common/datavalues/src/arrays/ops/take_random_test.rs

@@ -52,18 +52,18 @@ fn test_take_random() -> Result<()> {
     let expected = Series::new(vec![1_u16, 2, 3]);
     assert!(result.series_equal(&expected));
 
-    // Test DFUtf8Array
-    let mut utf8_builder = Utf8ArrayBuilder::with_capacity(3);
-    utf8_builder.append_value("1a");
-    utf8_builder.append_value("2b");
-    utf8_builder.append_value("3c");
-    let df_utf8_array = &utf8_builder.finish();
+    // Test DFStringArray
+    let mut string_builder = StringArrayBuilder::with_capacity(3);
+    string_builder.append_value("1a");
+    string_builder.append_value("2b");
+    string_builder.append_value("3c");
+    let df_string_array = &string_builder.finish();
     // Create TakeRandBranch for the array
-    let taker = df_utf8_array.take_rand();
-    assert_eq!(Some("1a"), taker.get(0));
+    let taker = df_string_array.take_rand();
+    assert_eq!(Some("1a".as_bytes()), taker.get(0));
     // Test get_unchecked
     let result = unsafe { taker.get_unchecked(1) };
-    assert_eq!("2b", result);
+    assert_eq!(b"2b", result);
 
     Ok(())
 }

common/datavalues/src/arrays/ops/take_test.rs

@@ -60,21 +60,21 @@ fn test_take() -> Result<()> {
     let expected = Series::new(vec![7_u16, 8, 9]);
     assert!(vs[0].series_equal(&expected));
 
-    // Test DFUtf8Array
-    let mut utf8_builder = Utf8ArrayBuilder::with_capacity(3);
-    utf8_builder.append_value("1a");
-    utf8_builder.append_value("2b");
-    utf8_builder.append_value("3c");
-    let df_utf8_array = &utf8_builder.finish();
+    // Test DFStringArray
+    let mut string_builder = StringArrayBuilder::with_capacity(3);
+    string_builder.append_value("1a");
+    string_builder.append_value("2b");
+    string_builder.append_value("3c");
+    let df_string_array = &string_builder.finish();
     let index = TakeIdx::from(vec![0, 1].into_iter());
-    let take_res = df_utf8_array.take(index)?;
+    let take_res = df_string_array.take(index)?;
     let vs: Vec<_> = take_res.into_no_null_iter().collect();
-    assert_eq!(&vs, &["1a", "2b"]);
+    assert_eq!(&vs, &[b"1a", b"2b"]);
 
     let index = TakeIdx::from(vec![2, 1].into_iter());
-    let take_res = unsafe { df_utf8_array.take_unchecked(index)? };
+    let take_res = unsafe { df_string_array.take_unchecked(index)? };
     let vs: Vec<_> = take_res.into_no_null_iter().collect();
-    assert_eq!(&vs, &["3c", "2b"]);
+    assert_eq!(&vs, &[b"3c", b"2b"]);
 
     Ok(())
 }