refactor: Changes for new benchmark setup

Cargo.toml

@@ -75,12 +75,11 @@ recursive = "0.1"
 regex = "1.9"
 reqwest = { version = "0.12", default-features = false }
 ryu = "1.0.13"
-serde = { version = "1.0.188", features = ["derive"] }
+serde = { version = "1.0.188", features = ["derive", "rc"] }
 serde_json = "1"
 simd-json = { version = "0.13", features = ["known-key"] }
 simdutf8 = "0.1.4"
 slotmap = "1"
-smartstring = "1"
 sqlparser = "0.49"
 stacker = "0.1"
 streaming-iterator = "0.1.9"

README.md

@@ -157,7 +157,7 @@ Refer to the [Polars CLI repository](https://github.com/pola-rs/polars-cli) for
 
 ### Blazingly fast
 
-Polars is very fast. In fact, it is one of the best performing solutions available. See the [TPC-H benchmarks](https://www.pola.rs/benchmarks.html) results.
+Polars is very fast. In fact, it is one of the best performing solutions available. See the [PDS-H benchmarks](https://www.pola.rs/benchmarks.html) results.
 
 ### Lightweight
 
@@ -247,9 +247,9 @@ can `pip install polars` and `import polars`.
 ## Using custom Rust functions in Python
 
 Extending Polars with UDFs compiled in Rust is easy. We expose PyO3 extensions for `DataFrame` and `Series`
-data structures. See more in https://github.com/pola-rs/pyo3-polars.
+data structures. See more in <https://github.com/pola-rs/pyo3-polars>.
 
-## Going big...
+## Going big
 
 Do you expect more than 2^32 (~4.2 billion) rows? Compile Polars with the `bigidx` feature
 flag or, for Python users, install `pip install polars-u64-idx`.

crates/polars-arrow/src/array/fixed_size_list/mod.rs

@@ -11,6 +11,7 @@ mod iterator;
 mod mutable;
 pub use mutable::*;
 use polars_error::{polars_bail, PolarsResult};
+use polars_utils::pl_str::PlSmallStr;
 
 /// The Arrow's equivalent to an immutable `Vec<Option<[T; size]>>` where `T` is an Arrow type.
 /// Cloning and slicing this struct is `O(1)`.
@@ -199,7 +200,7 @@ impl FixedSizeListArray {
 
     /// Returns a [`ArrowDataType`] consistent with [`FixedSizeListArray`].
     pub fn default_datatype(data_type: ArrowDataType, size: usize) -> ArrowDataType {
-        let field = Box::new(Field::new("item", data_type, true));
+        let field = Box::new(Field::new(PlSmallStr::from_static("item"), data_type, true));
         ArrowDataType::FixedSizeList(field, size)
     }
 }

crates/polars-arrow/src/array/fixed_size_list/mutable.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use polars_error::{polars_bail, PolarsResult};
+use polars_utils::pl_str::PlSmallStr;
 
 use super::FixedSizeListArray;
 use crate::array::physical_binary::extend_validity;
@@ -35,7 +36,7 @@ impl<M: MutableArray> MutableFixedSizeListArray<M> {
     }
 
     /// Creates a new [`MutableFixedSizeListArray`] from a [`MutableArray`] and size.
-    pub fn new_with_field(values: M, name: &str, nullable: bool, size: usize) -> Self {
+    pub fn new_with_field(values: M, name: PlSmallStr, nullable: bool, size: usize) -> Self {
         let data_type = ArrowDataType::FixedSizeList(
             Box::new(Field::new(name, values.data_type().clone(), nullable)),
             size,

crates/polars-arrow/src/array/list/mod.rs

@@ -13,6 +13,7 @@ pub use iterator::*;
 mod mutable;
 pub use mutable::*;
 use polars_error::{polars_bail, PolarsResult};
+use polars_utils::pl_str::PlSmallStr;
 
 /// An [`Array`] semantically equivalent to `Vec<Option<Vec<Option<T>>>>` with Arrow's in-memory.
 #[derive(Clone)]
@@ -185,7 +186,7 @@ impl<O: Offset> ListArray<O> {
 impl<O: Offset> ListArray<O> {
     /// Returns a default [`ArrowDataType`]: inner field is named "item" and is nullable
     pub fn default_datatype(data_type: ArrowDataType) -> ArrowDataType {
-        let field = Box::new(Field::new("item", data_type, true));
+        let field = Box::new(Field::new(PlSmallStr::from_static("item"), data_type, true));
         if O::IS_LARGE {
             ArrowDataType::LargeList(field)
         } else {

crates/polars-arrow/src/array/list/mutable.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use polars_error::{polars_err, PolarsResult};
+use polars_utils::pl_str::PlSmallStr;
 
 use super::ListArray;
 use crate::array::physical_binary::extend_validity;
@@ -122,7 +123,7 @@ impl<O: Offset, M: MutableArray> MutableListArray<O, M> {
     }
 
     /// Creates a new [`MutableListArray`] from a [`MutableArray`].
-    pub fn new_with_field(values: M, name: &str, nullable: bool) -> Self {
+    pub fn new_with_field(values: M, name: PlSmallStr, nullable: bool) -> Self {
         let field = Box::new(Field::new(name, values.data_type().clone(), nullable));
         let data_type = if O::IS_LARGE {
             ArrowDataType::LargeList(field)

crates/polars-arrow/src/array/primitive/fmt.rs

@@ -56,7 +56,7 @@ pub fn get_write_value<'a, T: NativeType, F: Write>(
         Time64(_) => unreachable!(), // remaining are not valid
         Timestamp(time_unit, tz) => {
             if let Some(tz) = tz {
-                let timezone = temporal_conversions::parse_offset(tz);
+                let timezone = temporal_conversions::parse_offset(tz.as_str());
                 match timezone {
                     Ok(timezone) => {
                         dyn_primitive!(array, i64, |time| {
@@ -65,7 +65,7 @@ pub fn get_write_value<'a, T: NativeType, F: Write>(
                     },
                     #[cfg(feature = "chrono-tz")]
                     Err(_) => {
-                        let timezone = temporal_conversions::parse_offset_tz(tz);
+                        let timezone = temporal_conversions::parse_offset_tz(tz.as_str());
                         match timezone {
                             Ok(timezone) => dyn_primitive!(array, i64, |time| {
                                 temporal_conversions::timestamp_to_datetime(

crates/polars-arrow/src/array/struct_/mod.rs

@@ -23,8 +23,8 @@ use crate::compute::utils::combine_validities_and;
 /// let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed();
 ///
 /// let fields = vec![
-///     Field::new("b", ArrowDataType::Boolean, false),
-///     Field::new("c", ArrowDataType::Int32, false),
+///     Field::new("b".into(), ArrowDataType::Boolean, false),
+///     Field::new("c".into(), ArrowDataType::Int32, false),
 /// ];
 ///
 /// let array = StructArray::new(ArrowDataType::Struct(fields), vec![boolean, int], None);

crates/polars-arrow/src/bitmap/bitmap_ops.rs

@@ -300,6 +300,22 @@ pub fn intersects_with_mut(lhs: &MutableBitmap, rhs: &MutableBitmap) -> bool {
     )
 }
 
+pub fn num_edges(lhs: &Bitmap) -> usize {
+    if lhs.is_empty() {
+        return 0;
+    }
+
+    // @TODO: If is probably quite inefficient to do it like this because now either one is not
+    // aligned. Maybe, we can implement a smarter way to do this.
+    binary_fold(
+        &unsafe { lhs.clone().sliced_unchecked(0, lhs.len() - 1) },
+        &unsafe { lhs.clone().sliced_unchecked(1, lhs.len() - 1) },
+        |l, r| (l ^ r).count_ones() as usize,
+        0,
+        |acc, v| acc + v,
+    )
+}
+
 /// Compute `out[i] = if selector[i] { truthy[i] } else { falsy }`.
 pub fn select_constant(selector: &Bitmap, truthy: &Bitmap, falsy: bool) -> Bitmap {
     let falsy_mask: u64 = if falsy {

crates/polars-arrow/src/bitmap/immutable.rs

@@ -555,6 +555,11 @@ impl Bitmap {
     pub fn select_constant(&self, truthy: &Self, falsy: bool) -> Self {
         super::bitmap_ops::select_constant(self, truthy, falsy)
     }
+
+    /// Calculates the number of edges from `0 -> 1` and `1 -> 0`.
+    pub fn num_edges(&self) -> usize {
+        super::bitmap_ops::num_edges(self)
+    }
 }
 
 impl<P: AsRef<[bool]>> From<P> for Bitmap {

crates/polars-arrow/src/compute/cast/primitive_to.rs

@@ -2,6 +2,7 @@ use std::hash::Hash;
 
 use num_traits::{AsPrimitive, Float, ToPrimitive};
 use polars_error::PolarsResult;
+use polars_utils::pl_str::PlSmallStr;
 
 use super::CastOptionsImpl;
 use crate::array::*;
@@ -434,7 +435,7 @@ pub fn timestamp_to_timestamp(
     from: &PrimitiveArray<i64>,
     from_unit: TimeUnit,
     to_unit: TimeUnit,
-    tz: &Option<String>,
+    tz: &Option<PlSmallStr>,
 ) -> PrimitiveArray<i64> {
     let from_size = time_unit_multiple(from_unit);
     let to_size = time_unit_multiple(to_unit);

crates/polars-arrow/src/compute/temporal.rs

@@ -59,12 +59,12 @@ macro_rules! date_like {
             ArrowDataType::Timestamp(time_unit, Some(timezone_str)) => {
                 let array = $array.as_any().downcast_ref().unwrap();
 
-                if let Ok(timezone) = parse_offset(timezone_str) {
+                if let Ok(timezone) = parse_offset(timezone_str.as_str()) {
                     Ok(extract_impl(array, *time_unit, timezone, |x| {
                         x.$extract().try_into().unwrap()
                     }))
                 } else {
-                    chrono_tz(array, *time_unit, timezone_str, |x| {
+                    chrono_tz(array, *time_unit, timezone_str.as_str(), |x| {
                         x.$extract().try_into().unwrap()
                     })
                 }
@@ -129,12 +129,12 @@ macro_rules! time_like {
             ArrowDataType::Timestamp(time_unit, Some(timezone_str)) => {
                 let array = $array.as_any().downcast_ref().unwrap();
 
-                if let Ok(timezone) = parse_offset(timezone_str) {
+                if let Ok(timezone) = parse_offset(timezone_str.as_str()) {
                     Ok(extract_impl(array, *time_unit, timezone, |x| {
                         x.$extract().try_into().unwrap()
                     }))
                 } else {
-                    chrono_tz(array, *time_unit, timezone_str, |x| {
+                    chrono_tz(array, *time_unit, timezone_str.as_str(), |x| {
                         x.$extract().try_into().unwrap()
                     })
                 }

crates/polars-arrow/src/datatypes/field.rs

@@ -1,3 +1,4 @@
+use polars_utils::pl_str::PlSmallStr;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -15,7 +16,7 @@ use super::{ArrowDataType, Metadata};
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Field {
     /// Its name
-    pub name: String,
+    pub name: PlSmallStr,
     /// Its logical [`ArrowDataType`]
     pub data_type: ArrowDataType,
     /// Its nullability
@@ -26,9 +27,9 @@ pub struct Field {
 
 impl Field {
     /// Creates a new [`Field`].
-    pub fn new<T: Into<String>>(name: T, data_type: ArrowDataType, is_nullable: bool) -> Self {
+    pub fn new(name: PlSmallStr, data_type: ArrowDataType, is_nullable: bool) -> Self {
         Field {
-            name: name.into(),
+            name,
             data_type,
             is_nullable,
             metadata: Default::default(),
@@ -56,8 +57,18 @@ impl Field {
 #[cfg(feature = "arrow_rs")]
 impl From<Field> for arrow_schema::Field {
     fn from(value: Field) -> Self {
-        Self::new(value.name, value.data_type.into(), value.is_nullable)
-            .with_metadata(value.metadata.into_iter().collect())
+        Self::new(
+            value.name.to_string(),
+            value.data_type.into(),
+            value.is_nullable,
+        )
+        .with_metadata(
+            value
+                .metadata
+                .into_iter()
+                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .collect(),
+        )
     }
 }
 
@@ -75,9 +86,14 @@ impl From<&arrow_schema::Field> for Field {
         let metadata = value
             .metadata()
             .iter()
-            .map(|(k, v)| (k.clone(), v.clone()))
+            .map(|(k, v)| (PlSmallStr::from_str(k), PlSmallStr::from_str(v)))
             .collect();
-        Self::new(value.name(), data_type, value.is_nullable()).with_metadata(metadata)
+        Self::new(
+            PlSmallStr::from_str(value.name().as_str()),
+            data_type,
+            value.is_nullable(),
+        )
+        .with_metadata(metadata)
     }
 }