polars-df 0.13.0 → 0.14.0

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars"
-version = "0.13.0"
+version = "0.14.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -15,14 +15,13 @@ ahash = "0.8"
 chrono = "0.4"
 either = "1.8"
 magnus = "0.7"
-polars-core = "=0.42.0"
-polars-parquet = "=0.42.0"
-polars-utils = "=0.42.0"
+polars-core = "=0.43.1"
+polars-parquet = "=0.43.1"
+polars-utils = "=0.43.1"
 serde_json = "1"
-smartstring = "1"
 
 [dependencies.polars]
-version = "=0.42.0"
+version = "=0.43.1"
 features = [
     "abs",
     "approx_unique",

data/ext/polars/src/batched_csv.rs

@@ -54,7 +54,7 @@ impl RbBatchedCsv {
         let null_values = null_values.map(|w| w.0);
         let eol_char = eol_char.as_bytes()[0];
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
         let quote_char = if let Some(s) = quote_char {
@@ -72,7 +72,7 @@ impl RbBatchedCsv {
                 .iter()
                 .map(|(name, dtype)| {
                     let dtype = dtype.0.clone();
-                    Field::new(name, dtype)
+                    Field::new((&**name).into(), dtype)
                 })
                 .collect::<Schema>()
         });
@@ -95,7 +95,7 @@ impl RbBatchedCsv {
             .with_projection(projection.map(Arc::new))
             .with_rechunk(rechunk)
             .with_chunk_size(chunk_size)
-            .with_columns(columns.map(Arc::from))
+            .with_columns(columns.map(|x| x.into_iter().map(PlSmallStr::from_string).collect()))
             .with_n_threads(n_threads)
             .with_dtype_overwrite(overwrite_dtype_slice.map(Arc::new))
             .with_low_memory(low_memory)

data/ext/polars/src/conversion/any_value.rs

@@ -51,7 +51,10 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::Datetime(v, time_unit, time_zone) => {
             let time_unit = time_unit.to_ascii();
             utils()
-                .funcall("_to_ruby_datetime", (v, time_unit, time_zone.clone()))
+                .funcall(
+                    "_to_ruby_datetime",
+                    (v, time_unit, time_zone.as_ref().map(|v| v.to_string())),
+                )
                 .unwrap()
         }
         AnyValue::Duration(v, time_unit) => {
@@ -122,7 +125,10 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     fn get_list(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
         let v = RArray::from_value(ob).unwrap();
         if v.is_empty() {
-            Ok(AnyValue::List(Series::new_empty("", &DataType::Null)))
+            Ok(AnyValue::List(Series::new_empty(
+                PlSmallStr::EMPTY,
+                &DataType::Null,
+            )))
         } else {
             let list = v;
 
@@ -142,7 +148,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
                 avs.push(Wrap::<AnyValue>::try_convert(item)?.0)
             }
 
-            let s = Series::from_any_values_and_dtype("", &avs, &dtype, true)
+            let s = Series::from_any_values_and_dtype(PlSmallStr::EMPTY, &avs, &dtype, true)
                 .map_err(RbPolarsErr::from)?;
             Ok(AnyValue::List(s))
         }
@@ -162,7 +168,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
             let key = String::try_convert(k)?;
             let val = Wrap::<AnyValue>::try_convert(v)?.0;
             let dtype = DataType::from(&val);
-            keys.push(Field::new(&key, dtype));
+            keys.push(Field::new(key.into(), dtype));
             vals.push(val);
             Ok(ForEach::Continue)
         })?;

data/ext/polars/src/conversion/chunked_array.rs

@@ -9,7 +9,7 @@ use crate::RbResult;
 impl TryConvert for Wrap<StringChunked> {
     fn try_convert(obj: Value) -> RbResult<Self> {
         let (seq, len) = get_rbseq(obj)?;
-        let mut builder = StringChunkedBuilder::new("", len);
+        let mut builder = StringChunkedBuilder::new(PlSmallStr::EMPTY, len);
 
         for res in seq.into_iter() {
             let item = res;
@@ -25,7 +25,7 @@ impl TryConvert for Wrap<StringChunked> {
 impl TryConvert for Wrap<BinaryChunked> {
     fn try_convert(obj: Value) -> RbResult<Self> {
         let (seq, len) = get_rbseq(obj)?;
-        let mut builder = BinaryChunkedBuilder::new("", len);
+        let mut builder = BinaryChunkedBuilder::new(PlSmallStr::EMPTY, len);
 
         for res in seq.into_iter() {
             let item = res;
@@ -90,7 +90,7 @@ impl IntoValue for Wrap<&DatetimeChunked> {
     fn into_value_with(self, _: &Ruby) -> Value {
         let utils = utils();
         let time_unit = Wrap(self.0.time_unit()).into_value();
-        let time_zone = self.0.time_zone().clone().into_value();
+        let time_zone = self.0.time_zone().as_deref().map(|v| v.into_value());
         let iter = self.0.into_iter().map(|opt_v| {
             opt_v.map(|v| {
                 utils

data/ext/polars/src/conversion/mod.rs

@@ -20,7 +20,6 @@ use polars::series::ops::NullBehavior;
 use polars_core::utils::arrow::array::Array;
 use polars_core::utils::materialize_dyn_int;
 use polars_utils::total_ord::{TotalEq, TotalHash};
-use smartstring::alias::String as SmartString;
 
 use crate::object::OBJECT_NAME;
 use crate::rb_modules::series;
@@ -84,14 +83,26 @@ pub(crate) fn to_series(s: RbSeries) -> Value {
         .unwrap()
 }
 
+impl TryConvert for Wrap<PlSmallStr> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        Ok(Wrap((&*String::try_convert(ob)?).into()))
+    }
+}
+
 impl TryConvert for Wrap<NullValues> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         if let Ok(s) = String::try_convert(ob) {
-            Ok(Wrap(NullValues::AllColumnsSingle(s)))
+            Ok(Wrap(NullValues::AllColumnsSingle((&*s).into())))
         } else if let Ok(s) = Vec::<String>::try_convert(ob) {
-            Ok(Wrap(NullValues::AllColumns(s)))
+            Ok(Wrap(NullValues::AllColumns(
+                s.into_iter().map(|x| (&*x).into()).collect(),
+            )))
         } else if let Ok(s) = Vec::<(String, String)>::try_convert(ob) {
-            Ok(Wrap(NullValues::Named(s)))
+            Ok(Wrap(NullValues::Named(
+                s.into_iter()
+                    .map(|(a, b)| ((&*a).into(), (&*b).into()))
+                    .collect(),
+            )))
         } else {
             Err(RbPolarsErr::other(
                 "could not extract value from null_values argument".into(),
@@ -189,7 +200,7 @@ impl IntoValue for Wrap<DataType> {
             DataType::Datetime(tu, tz) => {
                 let datetime_class = pl.const_get::<_, Value>("Datetime").unwrap();
                 datetime_class
-                    .funcall::<_, _, Value>("new", (tu.to_ascii(), tz))
+                    .funcall::<_, _, Value>("new", (tu.to_ascii(), tz.as_deref()))
                     .unwrap()
             }
             DataType::Duration(tu) => {
@@ -210,7 +221,9 @@ impl IntoValue for Wrap<DataType> {
                 // we should always have an initialized rev_map coming from rust
                 let categories = rev_map.as_ref().unwrap().get_categories();
                 let class = pl.const_get::<_, Value>("Enum").unwrap();
-                let s = Series::from_arrow("category", categories.to_boxed()).unwrap();
+                let s =
+                    Series::from_arrow(PlSmallStr::from_static("category"), categories.to_boxed())
+                        .unwrap();
                 let series = to_series(s.into());
                 class.funcall::<_, _, Value>("new", (series,)).unwrap()
             }
@@ -222,7 +235,7 @@ impl IntoValue for Wrap<DataType> {
                 let field_class = pl.const_get::<_, Value>("Field").unwrap();
                 let iter = fields.iter().map(|fld| {
                     let name = fld.name().as_str();
-                    let dtype = Wrap(fld.data_type().clone());
+                    let dtype = Wrap(fld.dtype().clone());
                     field_class
                         .funcall::<_, _, Value>("new", (name, dtype))
                         .unwrap()
@@ -276,7 +289,7 @@ impl TryConvert for Wrap<Field> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let name: String = ob.funcall("name", ())?;
         let dtype: Wrap<DataType> = ob.funcall("dtype", ())?;
-        Ok(Wrap(Field::new(&name, dtype.0)))
+        Ok(Wrap(Field::new((&*name).into(), dtype.0)))
     }
 }
 
@@ -341,7 +354,7 @@ impl TryConvert for Wrap<DataType> {
                     let s = get_series(categories)?;
                     let ca = s.str().map_err(RbPolarsErr::from)?;
                     let categories = ca.downcast_iter().next().unwrap().clone();
-                    create_enum_data_type(categories)
+                    create_enum_dtype(categories)
                 }
                 "Polars::Date" => DataType::Date,
                 "Polars::Time" => DataType::Time,
@@ -357,8 +370,8 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Datetime" => {
                     let time_unit: Value = ob.funcall("time_unit", ()).unwrap();
                     let time_unit = Wrap::<TimeUnit>::try_convert(time_unit)?.0;
-                    let time_zone = ob.funcall("time_zone", ())?;
-                    DataType::Datetime(time_unit, time_zone)
+                    let time_zone: Option<String> = ob.funcall("time_zone", ())?;
+                    DataType::Datetime(time_unit, time_zone.as_deref().map(|x| x.into()))
                 }
                 "Polars::Decimal" => {
                     let precision = ob.funcall("precision", ())?;
@@ -463,7 +476,7 @@ impl TryConvert for Wrap<Schema> {
 
         let mut schema = Vec::new();
         dict.foreach(|key: String, val: Wrap<DataType>| {
-            schema.push(Ok(Field::new(&key, val.0)));
+            schema.push(Ok(Field::new((&*key).into(), val.0)));
             Ok(ForEach::Continue)
         })
         .unwrap();
@@ -1053,14 +1066,6 @@ pub fn parse_parquet_compression(
     Ok(parsed)
 }
 
-pub(crate) fn strings_to_smartstrings<I, S>(container: I) -> Vec<SmartString>
-where
-    I: IntoIterator<Item = S>,
-    S: AsRef<str>,
-{
-    container.into_iter().map(|s| s.as_ref().into()).collect()
-}
-
 impl TryConvert for Wrap<NonZeroUsize> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let v = usize::try_convert(ob)?;
@@ -1069,3 +1074,14 @@ impl TryConvert for Wrap<NonZeroUsize> {
             .ok_or(RbValueError::new_err("must be non-zero".into()))
     }
 }
+
+pub(crate) fn strings_to_pl_smallstr<I, S>(container: I) -> Vec<PlSmallStr>
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<str>,
+{
+    container
+        .into_iter()
+        .map(|s| PlSmallStr::from_str(s.as_ref()))
+        .collect()
+}

data/ext/polars/src/dataframe/construction.rs

@@ -79,7 +79,7 @@ fn update_schema_from_rows(
     rows: &[Row],
     infer_schema_length: Option<usize>,
 ) -> RbResult<()> {
-    let schema_is_complete = schema.iter_dtypes().all(|dtype| dtype.is_known());
+    let schema_is_complete = schema.iter_values().all(|dtype| dtype.is_known());
     if schema_is_complete {
         return Ok(());
     }
@@ -89,7 +89,7 @@ fn update_schema_from_rows(
         rows_to_supertypes(rows, infer_schema_length).map_err(RbPolarsErr::from)?;
     let inferred_dtypes_slice = inferred_dtypes.as_slice();
 
-    for (i, dtype) in schema.iter_dtypes_mut().enumerate() {
+    for (i, dtype) in schema.iter_values_mut().enumerate() {
         if !dtype.is_known() {
             *dtype = inferred_dtypes_slice.get(i).ok_or_else(|| {
                 polars_err!(SchemaMismatch: "the number of columns in the schema does not match the data")
@@ -110,7 +110,7 @@ fn resolve_schema_overrides(schema: &mut Schema, schema_overrides: Option<Schema
 }
 
 fn erase_decimal_precision_scale(schema: &mut Schema) {
-    for dtype in schema.iter_dtypes_mut() {
+    for dtype in schema.iter_values_mut() {
         if let DataType::Decimal(_, _) = dtype {
             *dtype = DataType::Decimal(None, None)
         }
@@ -123,7 +123,7 @@ where
 {
     let fields = column_names
         .into_iter()
-        .map(|c| Field::new(c, DataType::Unknown(Default::default())));
+        .map(|c| Field::new(c.into(), DataType::Unknown(Default::default())));
     Schema::from_iter(fields)
 }
 

data/ext/polars/src/dataframe/general.rs

@@ -9,6 +9,7 @@ use crate::map::dataframe::{
     apply_lambda_unknown, apply_lambda_with_bool_out_type, apply_lambda_with_primitive_out_type,
     apply_lambda_with_utf8_out_type,
 };
+use crate::prelude::strings_to_pl_smallstr;
 use crate::series::{to_rbseries_collection, to_series_collection};
 use crate::{RbDataFrame, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries};
 
@@ -254,7 +255,7 @@ impl RbDataFrame {
     }
 
     pub fn gather(&self, indices: Vec<IdxSize>) -> RbResult<Self> {
-        let indices = IdxCa::from_vec("", indices);
+        let indices = IdxCa::from_vec("".into(), indices);
         let df = self.df.borrow().take(&indices).map_err(RbPolarsErr::from)?;
         Ok(RbDataFrame::new(df))
     }
@@ -332,7 +333,7 @@ impl RbDataFrame {
         let df = self
             .df
             .borrow()
-            .with_row_index(&name, offset)
+            .with_row_index(name.into(), offset)
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
@@ -349,8 +350,8 @@ impl RbDataFrame {
         variable_name: Option<String>,
     ) -> RbResult<Self> {
         let args = UnpivotArgsIR {
-            on: strings_to_smartstrings(on),
-            index: strings_to_smartstrings(index),
+            on: strings_to_pl_smallstr(on),
+            index: strings_to_pl_smallstr(index),
             value_name: value_name.map(|s| s.into()),
             variable_name: variable_name.map(|s| s.into()),
         };
@@ -581,7 +582,7 @@ impl RbDataFrame {
     }
 
     pub fn to_struct(&self, name: String) -> RbSeries {
-        let s = self.df.borrow().clone().into_struct(&name);
+        let s = self.df.borrow().clone().into_struct(name.into());
         s.into_series().into()
     }
 

data/ext/polars/src/dataframe/io.rs

@@ -50,7 +50,7 @@ impl RbDataFrame {
         let null_values = null_values.map(|w| w.0);
         let eol_char = eol_char.as_bytes()[0];
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
         let quote_char = if let Some(s) = quote_char {
@@ -68,7 +68,7 @@ impl RbDataFrame {
                 .iter()
                 .map(|(name, dtype)| {
                     let dtype = dtype.0.clone();
-                    Field::new(name, dtype)
+                    Field::new((&**name).into(), dtype)
                 })
                 .collect::<Schema>()
         });
@@ -91,7 +91,7 @@ impl RbDataFrame {
             .with_projection(projection.map(Arc::new))
             .with_rechunk(rechunk)
             .with_chunk_size(chunk_size)
-            .with_columns(columns.map(Arc::from))
+            .with_columns(columns.map(|x| x.into_iter().map(|x| x.into()).collect()))
             .with_n_threads(n_threads)
             .with_schema_overwrite(overwrite_dtype.map(Arc::new))
             .with_dtype_overwrite(overwrite_dtype_slice.map(Arc::new))
@@ -135,7 +135,7 @@ impl RbDataFrame {
         use EitherRustRubyFile::*;
 
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
         let result = match get_either_file(rb_f, false)? {
@@ -225,7 +225,7 @@ impl RbDataFrame {
         _memory_map: bool,
     ) -> RbResult<Self> {
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
         let mmap_bytes_r = get_mmap_bytes_reader(rb_f)?;
@@ -252,7 +252,7 @@ impl RbDataFrame {
         rechunk: bool,
     ) -> RbResult<Self> {
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
         // rb_f = read_if_bytesio(rb_f);

data/ext/polars/src/expr/datetime.rs

@@ -29,8 +29,12 @@ impl RbExpr {
         self.inner.clone().dt().with_time_unit(tu.0).into()
     }
 
-    pub fn dt_convert_time_zone(&self, tz: TimeZone) -> Self {
-        self.inner.clone().dt().convert_time_zone(tz).into()
+    pub fn dt_convert_time_zone(&self, time_zone: String) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .convert_time_zone(time_zone.into())
+            .into()
     }
 
     pub fn dt_cast_time_unit(&self, tu: Wrap<TimeUnit>) -> Self {
@@ -46,7 +50,11 @@ impl RbExpr {
         self.inner
             .clone()
             .dt()
-            .replace_time_zone(time_zone, ambiguous.inner.clone(), non_existent.0)
+            .replace_time_zone(
+                time_zone.map(|x| x.into()),
+                ambiguous.inner.clone(),
+                non_existent.0,
+            )
             .into()
     }
 

data/ext/polars/src/expr/general.rs

@@ -242,7 +242,7 @@ impl RbExpr {
     pub fn value_counts(&self, sort: bool, parallel: bool, name: String, normalize: bool) -> Self {
         self.inner
             .clone()
-            .value_counts(sort, parallel, name, normalize)
+            .value_counts(sort, parallel, name.as_str(), normalize)
             .into()
     }
 

data/ext/polars/src/expr/name.rs

@@ -1,5 +1,6 @@
 use magnus::{block::Proc, value::Opaque, Ruby};
 use polars::prelude::*;
+use polars_utils::format_pl_smallstr;
 
 use crate::RbExpr;
 
@@ -15,9 +16,9 @@ impl RbExpr {
             .name()
             .map(move |name| {
                 let lambda = Ruby::get().unwrap().get_inner(lambda);
-                let out = lambda.call::<_, String>((name,));
+                let out = lambda.call::<_, String>((name.as_str(),));
                 match out {
-                    Ok(out) => Ok(out),
+                    Ok(out) => Ok(format_pl_smallstr!("{}", out)),
                     Err(e) => Err(PolarsError::ComputeError(
                         format!("Ruby function in 'name.map' produced an error: {}.", e).into(),
                     )),

data/ext/polars/src/expr/string.rs

@@ -19,6 +19,8 @@ impl RbExpr {
         exact: bool,
         cache: bool,
     ) -> Self {
+        let format = format.map(|x| x.into());
+
         let options = StrptimeOptions {
             format,
             strict,
@@ -33,12 +35,15 @@ impl RbExpr {
         &self,
         format: Option<String>,
         time_unit: Option<Wrap<TimeUnit>>,
-        time_zone: Option<TimeZone>,
+        time_zone: Option<Wrap<TimeZone>>,
         strict: bool,
         exact: bool,
         cache: bool,
         ambiguous: &Self,
     ) -> Self {
+        let format = format.map(|x| x.into());
+        let time_zone = time_zone.map(|x| x.0);
+
         let options = StrptimeOptions {
             format,
             strict,
@@ -58,6 +63,8 @@ impl RbExpr {
     }
 
     pub fn str_to_time(&self, format: Option<String>, strict: bool, cache: bool) -> Self {
+        let format = format.map(|x| x.into());
+
         let options = StrptimeOptions {
             format,
             strict,

data/ext/polars/src/functions/io.rs

@@ -11,9 +11,9 @@ pub fn read_ipc_schema(rb_f: Value) -> RbResult<RHash> {
     let metadata = read_file_metadata(&mut r).map_err(RbPolarsErr::from)?;
 
     let dict = RHash::new();
-    for field in &metadata.schema.fields {
-        let dt: Wrap<DataType> = Wrap((&field.data_type).into());
-        dict.aset(field.name.clone(), dt)?;
+    for field in metadata.schema.iter_values() {
+        let dt: Wrap<DataType> = Wrap((&field.dtype).into());
+        dict.aset(field.name.as_str(), dt)?;
     }
     Ok(dict)
 }
@@ -26,9 +26,9 @@ pub fn read_parquet_schema(rb_f: Value) -> RbResult<RHash> {
     let arrow_schema = infer_schema(&metadata).map_err(RbPolarsErr::from)?;
 
     let dict = RHash::new();
-    for field in arrow_schema.fields {
-        let dt: Wrap<DataType> = Wrap((&field.data_type).into());
-        dict.aset(field.name, dt)?;
+    for field in arrow_schema.iter_values() {
+        let dt: Wrap<DataType> = Wrap((&field.dtype).into());
+        dict.aset(field.name.as_str(), dt)?;
     }
     Ok(dict)
 }

data/ext/polars/src/functions/range.rs

@@ -56,13 +56,14 @@ pub fn datetime_range(
     every: String,
     closed: Wrap<ClosedWindow>,
     time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<TimeZone>,
+    time_zone: Option<Wrap<TimeZone>>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
     let every = Duration::parse(&every);
     let closed = closed.0;
     let time_unit = time_unit.map(|x| x.0);
+    let time_zone = time_zone.map(|x| x.0);
     dsl::datetime_range(start, end, every, closed, time_unit, time_zone).into()
 }
 
@@ -72,13 +73,14 @@ pub fn datetime_ranges(
     every: String,
     closed: Wrap<ClosedWindow>,
     time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<TimeZone>,
+    time_zone: Option<Wrap<TimeZone>>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
     let every = Duration::parse(&every);
     let closed = closed.0;
     let time_unit = time_unit.map(|x| x.0);
+    let time_zone = time_zone.map(|x| x.0);
     dsl::datetime_ranges(start, end, every, closed, time_unit, time_zone).into()
 }
 

data/ext/polars/src/lazyframe/mod.rs

@@ -59,7 +59,7 @@ impl RbLazyFrame {
     ) -> RbResult<Self> {
         let batch_size = batch_size.map(|v| v.0);
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
 
@@ -106,14 +106,14 @@ impl RbLazyFrame {
         let separator = separator.as_bytes()[0];
         let eol_char = eol_char.as_bytes()[0];
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
 
         let overwrite_dtype = overwrite_dtype.map(|overwrite_dtype| {
             overwrite_dtype
                 .into_iter()
-                .map(|(name, dtype)| Field::new(&name, dtype.0))
+                .map(|(name, dtype)| Field::new((&*name).into(), dtype.0))
                 .collect::<Schema>()
         });
 
@@ -128,7 +128,7 @@ impl RbLazyFrame {
             .with_dtype_overwrite(overwrite_dtype.map(Arc::new))
             // TODO add with_schema
             .with_low_memory(low_memory)
-            .with_comment_prefix(comment_prefix.as_deref())
+            .with_comment_prefix(comment_prefix.map(|x| x.into()))
             .with_quote_char(quote_char)
             .with_eol_char(eol_char)
             .with_rechunk(rechunk)
@@ -176,7 +176,7 @@ impl RbLazyFrame {
         };
 
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
         let hive_options = HiveOptions {
@@ -197,7 +197,7 @@ impl RbLazyFrame {
             use_statistics,
             hive_options,
             glob,
-            include_file_paths: include_file_paths.map(Arc::from),
+            include_file_paths: include_file_paths.map(|x| x.into()),
         };
 
         let lf = if path.is_some() {
@@ -216,14 +216,13 @@ impl RbLazyFrame {
         cache: bool,
         rechunk: bool,
         row_index: Option<(String, IdxSize)>,
-        memory_map: bool,
         hive_partitioning: Option<bool>,
         hive_schema: Option<Wrap<Schema>>,
         try_parse_hive_dates: bool,
         include_file_paths: Option<String>,
     ) -> RbResult<Self> {
         let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: Arc::from(name.as_str()),
+            name: name.into(),
             offset,
         });
 
@@ -239,10 +238,9 @@ impl RbLazyFrame {
             cache,
             rechunk,
             row_index,
-            memory_map,
             cloud_options: None,
             hive_options,
-            include_file_paths: include_file_paths.map(Arc::from),
+            include_file_paths: include_file_paths.map(|x| x.into()),
         };
         let lf = LazyFrame::scan_ipc(path, args).map_err(RbPolarsErr::from)?;
         Ok(lf.into())
@@ -593,8 +591,8 @@ impl RbLazyFrame {
             .force_parallel(force_parallel)
             .how(JoinType::AsOf(AsOfOptions {
                 strategy: strategy.0,
-                left_by: left_by.map(strings_to_smartstrings),
-                right_by: right_by.map(strings_to_smartstrings),
+                left_by: left_by.map(strings_to_pl_smallstr),
+                right_by: right_by.map(strings_to_pl_smallstr),
                 tolerance: tolerance.map(|t| t.0.into_static().unwrap()),
                 tolerance_str: tolerance_str.map(|s| s.into()),
             }))
@@ -744,8 +742,8 @@ impl RbLazyFrame {
     ) -> RbResult<Self> {
         let ldf = self.ldf.borrow().clone();
         Ok(match maintain_order {
-            true => ldf.unique_stable(subset, keep.0),
-            false => ldf.unique(subset, keep.0),
+            true => ldf.unique_stable_generic(subset, keep.0),
+            false => ldf.unique_generic(subset, keep.0),
         }
         .into())
     }
@@ -805,7 +803,11 @@ impl RbLazyFrame {
     }
 
     pub fn collect_schema(&self) -> RbResult<RHash> {
-        let schema = self.ldf.borrow_mut().schema().map_err(RbPolarsErr::from)?;
+        let schema = self
+            .ldf
+            .borrow_mut()
+            .collect_schema()
+            .map_err(RbPolarsErr::from)?;
 
         let schema_dict = RHash::new();
         schema.iter_fields().for_each(|fld| {
@@ -813,7 +815,7 @@ impl RbLazyFrame {
             schema_dict
                 .aset::<String, Value>(
                     fld.name().to_string(),
-                    Wrap(fld.data_type().clone()).into_value(),
+                    Wrap(fld.dtype().clone()).into_value(),
                 )
                 .unwrap();
         });

data/ext/polars/src/lib.rs

@@ -711,7 +711,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "new_from_parquet",
         function!(RbLazyFrame::new_from_parquet, 14),
     )?;
-    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 10))?;
+    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 9))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
     class.define_method("describe_plan", method!(RbLazyFrame::describe_plan, 0))?;
     class.define_method(