refactor(rust!): Rename Utf8 data type to String

crates/polars-core/Cargo.toml

@@ -62,7 +62,7 @@ lazy = []
 # more fast paths, slower compilation
 performant = ["arrow/performant", "reinterpret"]
 
-# extra utilities for Utf8Chunked
+# extra utilities for StringChunked
 strings = ["regex", "arrow/strings", "polars-error/regex"]
 # support for ObjectChunked<T> (downcastable Series of any type)
 object = ["serde_json"]

crates/polars-core/src/chunked_array/arithmetic/mod.rs

@@ -71,27 +71,27 @@ fn concat_binary_arrs(l: &[u8], r: &[u8], buf: &mut Vec<u8>) {
     buf.extend_from_slice(r);
 }
 
-impl Add for &Utf8Chunked {
-    type Output = Utf8Chunked;
+impl Add for &StringChunked {
+    type Output = StringChunked;
 
     fn add(self, rhs: Self) -> Self::Output {
-        unsafe { (self.as_binary() + rhs.as_binary()).to_utf8() }
+        unsafe { (self.as_binary() + rhs.as_binary()).to_string() }
     }
 }
 
-impl Add for Utf8Chunked {
-    type Output = Utf8Chunked;
+impl Add for StringChunked {
+    type Output = StringChunked;
 
     fn add(self, rhs: Self) -> Self::Output {
         (&self).add(&rhs)
     }
 }
 
-impl Add<&str> for &Utf8Chunked {
-    type Output = Utf8Chunked;
+impl Add<&str> for &StringChunked {
+    type Output = StringChunked;
 
     fn add(self, rhs: &str) -> Self::Output {
-        unsafe { ((&self.as_binary()) + rhs.as_bytes()).to_utf8() }
+        unsafe { ((&self.as_binary()) + rhs.as_bytes()).to_string() }
     }
 }
 

crates/polars-core/src/chunked_array/builder/list/binary.rs

@@ -1,18 +1,18 @@
 use super::*;
 
-pub struct ListUtf8ChunkedBuilder {
+pub struct ListStringChunkedBuilder {
     builder: LargeListUtf8Builder,
     field: Field,
     fast_explode: bool,
 }
 
-impl ListUtf8ChunkedBuilder {
+impl ListStringChunkedBuilder {
     pub fn new(name: &str, capacity: usize, values_capacity: usize) -> Self {
         let values = MutableUtf8Array::<i64>::with_capacity(values_capacity);
         let builder = LargeListUtf8Builder::new_with_capacity(values, capacity);
-        let field = Field::new(name, DataType::List(Box::new(DataType::Utf8)));
+        let field = Field::new(name, DataType::List(Box::new(DataType::String)));
 
-        ListUtf8ChunkedBuilder {
+        ListStringChunkedBuilder {
             builder,
             field,
             fast_explode: true,
@@ -47,7 +47,7 @@ impl ListUtf8ChunkedBuilder {
     }
 
     #[inline]
-    pub(crate) fn append(&mut self, ca: &Utf8Chunked) {
+    pub(crate) fn append(&mut self, ca: &StringChunked) {
         if ca.is_empty() {
             self.fast_explode = false;
         }
@@ -57,7 +57,7 @@ impl ListUtf8ChunkedBuilder {
     }
 }
 
-impl ListBuilderTrait for ListUtf8ChunkedBuilder {
+impl ListBuilderTrait for ListStringChunkedBuilder {
     #[inline]
     fn append_null(&mut self) {
         self.fast_explode = false;
@@ -69,7 +69,7 @@ impl ListBuilderTrait for ListUtf8ChunkedBuilder {
         if s.is_empty() {
             self.fast_explode = false;
         }
-        let ca = s.utf8()?;
+        let ca = s.str()?;
         self.append(ca);
         Ok(())
     }

crates/polars-core/src/chunked_array/builder/list/mod.rs

@@ -150,10 +150,10 @@ pub fn get_list_builder(
                     Box::new(builder)
                 }};
             }
-            macro_rules! get_utf8_builder {
+            macro_rules! get_string_builder {
                 () => {{
                     let builder =
-                        ListUtf8ChunkedBuilder::new(&name, list_capacity, 5 * value_capacity);
+                        ListStringChunkedBuilder::new(&name, list_capacity, 5 * value_capacity);
                     Box::new(builder)
                 }};
             }
@@ -167,7 +167,7 @@ pub fn get_list_builder(
             Ok(match_dtype_to_logical_apply_macro!(
                 physical_type,
                 get_primitive_builder,
-                get_utf8_builder,
+                get_string_builder,
                 get_binary_builder,
                 get_bool_builder
             ))

crates/polars-core/src/chunked_array/builder/mod.rs

@@ -5,7 +5,7 @@ pub mod fixed_size_list;
 pub mod list;
 mod null;
 mod primitive;
-mod utf8;
+mod string;
 
 use std::borrow::Cow;
 use std::iter::FromIterator;
@@ -21,7 +21,7 @@ pub(crate) use fixed_size_list::*;
 pub use list::*;
 pub use null::*;
 pub use primitive::*;
-pub use utf8::*;
+pub use string::*;
 
 use crate::chunked_array::to_primitive;
 use crate::prelude::*;
@@ -123,7 +123,7 @@ impl NewChunkedArray<BooleanType, bool> for BooleanChunked {
     }
 }
 
-impl<S> NewChunkedArray<Utf8Type, S> for Utf8Chunked
+impl<S> NewChunkedArray<StringType, S> for StringChunked
 where
     S: AsRef<str>,
 {
@@ -148,15 +148,15 @@ where
 
     fn from_iter_options(name: &str, it: impl Iterator<Item = Option<S>>) -> Self {
         let cap = get_iter_capacity(&it);
-        let mut builder = Utf8ChunkedBuilder::new(name, cap, cap * 5);
+        let mut builder = StringChunkedBuilder::new(name, cap, cap * 5);
         it.for_each(|opt| builder.append_option(opt));
         builder.finish()
     }
 
     /// Create a new ChunkedArray from an iterator.
     fn from_iter_values(name: &str, it: impl Iterator<Item = S>) -> Self {
         let cap = get_iter_capacity(&it);
-        let mut builder = Utf8ChunkedBuilder::new(name, cap, cap * 5);
+        let mut builder = StringChunkedBuilder::new(name, cap, cap * 5);
         it.for_each(|v| builder.append_value(v));
         builder.finish()
     }

crates/polars-core/src/chunked_array/builder/utf8.rs → crates/polars-core/src/chunked_array/builder/string.rs

@@ -1,24 +1,24 @@
 use super::*;
 
 #[derive(Clone)]
-pub struct Utf8ChunkedBuilder {
+pub struct StringChunkedBuilder {
     pub(crate) builder: MutableUtf8Array<i64>,
     pub capacity: usize,
     pub(crate) field: Field,
 }
 
-impl Utf8ChunkedBuilder {
-    /// Create a new UtfChunkedBuilder
+impl StringChunkedBuilder {
+    /// Create a new StringChunkedBuilder
     ///
     /// # Arguments
     ///
     /// * `capacity` - Number of string elements in the final array.
     /// * `bytes_capacity` - Number of bytes needed to store the string values.
     pub fn new(name: &str, capacity: usize, bytes_capacity: usize) -> Self {
-        Utf8ChunkedBuilder {
+        StringChunkedBuilder {
             builder: MutableUtf8Array::<i64>::with_capacities(capacity, bytes_capacity),
             capacity,
-            field: Field::new(name, DataType::Utf8),
+            field: Field::new(name, DataType::String),
         }
     }
 
@@ -39,7 +39,7 @@ impl Utf8ChunkedBuilder {
         self.builder.push(opt);
     }
 
-    pub fn finish(mut self) -> Utf8Chunked {
+    pub fn finish(mut self) -> StringChunked {
         let arr = self.builder.as_box();
 
         let mut ca = ChunkedArray {
@@ -59,19 +59,19 @@ impl Utf8ChunkedBuilder {
     }
 }
 
-pub struct Utf8ChunkedBuilderCow {
-    builder: Utf8ChunkedBuilder,
+pub struct StringChunkedBuilderCow {
+    builder: StringChunkedBuilder,
 }
 
-impl Utf8ChunkedBuilderCow {
+impl StringChunkedBuilderCow {
     pub fn new(name: &str, capacity: usize) -> Self {
-        Utf8ChunkedBuilderCow {
-            builder: Utf8ChunkedBuilder::new(name, capacity, capacity),
+        StringChunkedBuilderCow {
+            builder: StringChunkedBuilder::new(name, capacity, capacity),
         }
     }
 }
 
-impl ChunkedBuilder<Cow<'_, str>, Utf8Type> for Utf8ChunkedBuilderCow {
+impl ChunkedBuilder<Cow<'_, str>, StringType> for StringChunkedBuilderCow {
     #[inline]
     fn append_value(&mut self, val: Cow<'_, str>) {
         self.builder.append_value(val.as_ref())
@@ -82,7 +82,7 @@ impl ChunkedBuilder<Cow<'_, str>, Utf8Type> for Utf8ChunkedBuilderCow {
         self.builder.append_null()
     }
 
-    fn finish(self) -> ChunkedArray<Utf8Type> {
+    fn finish(self) -> ChunkedArray<StringType> {
         self.builder.finish()
     }
 

crates/polars-core/src/chunked_array/cast.rs

@@ -193,7 +193,7 @@ where
     }
 }
 
-impl ChunkCast for Utf8Chunked {
+impl ChunkCast for StringChunked {
     fn cast(&self, data_type: &DataType) -> PolarsResult<Series> {
         match data_type {
             #[cfg(feature = "dtype-categorical")]
@@ -210,12 +210,16 @@ impl ChunkCast for Utf8Chunked {
                 },
                 Some(rev_map) => {
                     polars_ensure!(rev_map.is_enum(), InvalidOperation: "casting to a non-enum variant with rev map is not supported for the user");
-                    CategoricalChunked::from_utf8_to_enum(self, rev_map.get_categories(), *ordering)
-                        .map(|ca| {
-                            let mut s = ca.into_series();
-                            s.rename(self.name());
-                            s
-                        })
+                    CategoricalChunked::from_string_to_enum(
+                        self,
+                        rev_map.get_categories(),
+                        *ordering,
+                    )
+                    .map(|ca| {
+                        let mut s = ca.into_series();
+                        s.rename(self.name());
+                        s
+                    })
                 },
             },
             #[cfg(feature = "dtype-struct")]
@@ -284,18 +288,18 @@ unsafe fn binary_to_utf8_unchecked(from: &BinaryArray<i64>) -> Utf8Array<i64> {
 
 impl BinaryChunked {
     /// # Safety
-    /// Utf8 is not validated
-    pub unsafe fn to_utf8(&self) -> Utf8Chunked {
+    /// String is not validated
+    pub unsafe fn to_string(&self) -> StringChunked {
         let chunks = self
             .downcast_iter()
             .map(|arr| Box::new(binary_to_utf8_unchecked(arr)) as ArrayRef)
             .collect();
-        let field = Arc::new(Field::new(self.name(), DataType::Utf8));
-        Utf8Chunked::from_chunks_and_metadata(chunks, field, self.bit_settings, true, true)
+        let field = Arc::new(Field::new(self.name(), DataType::String));
+        StringChunked::from_chunks_and_metadata(chunks, field, self.bit_settings, true, true)
     }
 }
 
-impl Utf8Chunked {
+impl StringChunked {
     pub fn as_binary(&self) -> BinaryChunked {
         let chunks = self
             .downcast_iter()
@@ -324,13 +328,13 @@ impl ChunkCast for BinaryChunked {
 
     unsafe fn cast_unchecked(&self, data_type: &DataType) -> PolarsResult<Series> {
         match data_type {
-            DataType::Utf8 => unsafe { Ok(self.to_utf8().into_series()) },
+            DataType::String => unsafe { Ok(self.to_string().into_series()) },
             _ => self.cast(data_type),
         }
     }
 }
 
-fn boolean_to_utf8(ca: &BooleanChunked) -> Utf8Chunked {
+fn boolean_to_string(ca: &BooleanChunked) -> StringChunked {
     ca.into_iter()
         .map(|opt_b| match opt_b {
             Some(true) => Some("true"),
@@ -343,8 +347,8 @@ fn boolean_to_utf8(ca: &BooleanChunked) -> Utf8Chunked {
 impl ChunkCast for BooleanChunked {
     fn cast(&self, data_type: &DataType) -> PolarsResult<Series> {
         match data_type {
-            DataType::Utf8 => {
-                let mut ca = boolean_to_utf8(self);
+            DataType::String => {
+                let mut ca = boolean_to_string(self);
                 ca.rename(self.name());
                 Ok(ca.into_series())
             },
@@ -369,7 +373,7 @@ impl ChunkCast for ListChunked {
                 match (self.inner_dtype(), &**child_type) {
                     #[cfg(feature = "dtype-categorical")]
                     (dt, Categorical(None, _))
-                        if !matches!(dt, Categorical(_, _) | Utf8 | Null) =>
+                        if !matches!(dt, Categorical(_, _) | String | Null) =>
                     {
                         polars_bail!(ComputeError: "cannot cast List inner type: '{:?}' to Categorical", dt)
                     },
@@ -423,7 +427,7 @@ impl ChunkCast for ArrayChunked {
             Array(child_type, width) => {
                 match (self.inner_dtype(), &**child_type) {
                     #[cfg(feature = "dtype-categorical")]
-                    (dt, Categorical(None, _)) if !matches!(dt, Utf8) => {
+                    (dt, Categorical(None, _)) if !matches!(dt, String) => {
                         polars_bail!(ComputeError: "cannot cast fixed-size-list inner type: '{:?}' to Categorical", dt)
                     },
                     _ => {
@@ -557,7 +561,7 @@ mod test {
     #[cfg(feature = "dtype-categorical")]
     fn test_cast_noop() {
         // check if we can cast categorical twice without panic
-        let ca = Utf8Chunked::new("foo", &["bar", "ham"]);
+        let ca = StringChunked::new("foo", &["bar", "ham"]);
         let out = ca
             .cast(&DataType::Categorical(None, Default::default()))
             .unwrap();