polars-df 0.13.0 → 0.15.0

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

@@ -2,12 +2,14 @@ pub(crate) mod any_value;
 mod chunked_array;
 
 use std::fmt::{Debug, Display, Formatter};
+use std::fs::File;
 use std::hash::{Hash, Hasher};
 use std::num::NonZeroUsize;
+use std::path::PathBuf;
 
 use magnus::{
-    class, exception, prelude::*, r_hash::ForEach, value::Opaque, IntoValue, Module, RArray, RHash,
-    Ruby, Symbol, TryConvert, Value,
+    class, exception, prelude::*, r_hash::ForEach, try_convert::TryConvertOwned, value::Opaque,
+    IntoValue, Module, RArray, RHash, Ruby, Symbol, TryConvert, Value,
 };
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
@@ -15,13 +17,15 @@ use polars::datatypes::AnyValue;
 use polars::frame::row::Row;
 use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
+use polars::io::cloud::CloudOptions;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
 use polars_core::utils::arrow::array::Array;
 use polars_core::utils::materialize_dyn_int;
+use polars_plan::plans::ScanSources;
 use polars_utils::total_ord::{TotalEq, TotalHash};
-use smartstring::alias::String as SmartString;
 
+use crate::file::{get_ruby_scan_source_input, RubyScanSourceInput};
 use crate::object::OBJECT_NAME;
 use crate::rb_modules::series;
 use crate::{RbDataFrame, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
@@ -84,18 +88,31 @@ 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(),
-            ))
+            Err(
+                RbPolarsErr::Other("could not extract value from null_values argument".into())
+                    .into(),
+            )
         }
     }
 }
@@ -189,7 +206,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 +227,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 +241,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 +295,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)))
     }
 }
 
@@ -315,7 +334,6 @@ impl TryConvert for Wrap<DataType> {
                     )))
                 }
             }
-        // TODO improve
         } else if String::try_convert(ob).is_err() {
             let name = unsafe { ob.class().name() }.into_owned();
             match name.as_str() {
@@ -341,7 +359,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 +375,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", ())?;
@@ -421,6 +439,8 @@ impl TryConvert for Wrap<DataType> {
     }
 }
 
+unsafe impl TryConvertOwned for Wrap<DataType> {}
+
 impl TryConvert for Wrap<StatisticsOptions> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let mut statistics = StatisticsOptions::empty();
@@ -439,8 +459,7 @@ impl TryConvert for Wrap<StatisticsOptions> {
                 }
             }
             Ok(ForEach::Continue)
-        })
-        .unwrap();
+        })?;
 
         Ok(Wrap(statistics))
     }
@@ -463,15 +482,77 @@ 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();
+        })?;
 
         Ok(Wrap(schema.into_iter().collect::<RbResult<Schema>>()?))
     }
 }
 
+impl TryConvert for Wrap<ScanSources> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let list = RArray::try_convert(ob)?;
+
+        if list.is_empty() {
+            return Ok(Wrap(ScanSources::default()));
+        }
+
+        enum MutableSources {
+            Paths(Vec<PathBuf>),
+            Files(Vec<File>),
+            Buffers(Vec<bytes::Bytes>),
+        }
+
+        let num_items = list.len();
+        let mut iter = list
+            .into_iter()
+            .map(|val| get_ruby_scan_source_input(val, false));
+
+        let Some(first) = iter.next() else {
+            return Ok(Wrap(ScanSources::default()));
+        };
+
+        let mut sources = match first? {
+            RubyScanSourceInput::Path(path) => {
+                let mut sources = Vec::with_capacity(num_items);
+                sources.push(path);
+                MutableSources::Paths(sources)
+            }
+            RubyScanSourceInput::File(file) => {
+                let mut sources = Vec::with_capacity(num_items);
+                sources.push(file);
+                MutableSources::Files(sources)
+            }
+            RubyScanSourceInput::Buffer(buffer) => {
+                let mut sources = Vec::with_capacity(num_items);
+                sources.push(buffer);
+                MutableSources::Buffers(sources)
+            }
+        };
+
+        for source in iter {
+            match (&mut sources, source?) {
+                (MutableSources::Paths(v), RubyScanSourceInput::Path(p)) => v.push(p),
+                (MutableSources::Files(v), RubyScanSourceInput::File(f)) => v.push(f),
+                (MutableSources::Buffers(v), RubyScanSourceInput::Buffer(f)) => v.push(f),
+                _ => {
+                    return Err(RbTypeError::new_err(
+                        "Cannot combine in-memory bytes, paths and files for scan sources"
+                            .to_string(),
+                    ))
+                }
+            }
+        }
+
+        Ok(Wrap(match sources {
+            MutableSources::Paths(i) => ScanSources::Paths(i.into()),
+            MutableSources::Files(i) => ScanSources::Files(i.into()),
+            MutableSources::Buffers(i) => ScanSources::Buffers(i.into()),
+        }))
+    }
+}
+
 #[derive(Clone)]
 pub struct ObjectValue {
     pub inner: Opaque<Value>,
@@ -480,7 +561,7 @@ pub struct ObjectValue {
 impl Debug for ObjectValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ObjectValue")
-            .field("inner", &self.to_object())
+            .field("inner", &self.to_value())
             .finish()
     }
 }
@@ -488,7 +569,7 @@ impl Debug for ObjectValue {
 impl Hash for ObjectValue {
     fn hash<H: Hasher>(&self, state: &mut H) {
         let h = self
-            .to_object()
+            .to_value()
             .funcall::<_, _, isize>("hash", ())
             .expect("should be hashable");
         state.write_isize(h)
@@ -499,7 +580,7 @@ impl Eq for ObjectValue {}
 
 impl PartialEq for ObjectValue {
     fn eq(&self, other: &Self) -> bool {
-        self.to_object().eql(other.to_object()).unwrap_or(false)
+        self.to_value().eql(other.to_value()).unwrap_or(false)
     }
 }
 
@@ -520,7 +601,7 @@ impl TotalHash for ObjectValue {
 
 impl Display for ObjectValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.to_object())
+        write!(f, "{}", self.to_value())
     }
 }
 
@@ -548,16 +629,15 @@ impl From<&dyn PolarsObjectSafe> for &ObjectValue {
     }
 }
 
-// TODO remove
 impl ObjectValue {
-    pub fn to_object(&self) -> Value {
-        Ruby::get().unwrap().get_inner(self.inner)
+    pub fn to_value(&self) -> Value {
+        self.clone().into_value()
     }
 }
 
 impl IntoValue for ObjectValue {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        self.to_object()
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        ruby.get_inner(self.inner)
     }
 }
 
@@ -574,10 +654,10 @@ impl TryConvert for Wrap<AsofStrategy> {
         let parsed = match String::try_convert(ob)?.as_str() {
             "backward" => AsofStrategy::Backward,
             "forward" => AsofStrategy::Forward,
+            "nearest" => AsofStrategy::Nearest,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "strategy must be one of {{'backward', 'forward'}}, got {}",
-                    v
+                    "asof `strategy` must be one of {{'backward', 'forward', 'nearest'}}, got {v}",
                 )))
             }
         };
@@ -817,14 +897,14 @@ impl TryConvert for Wrap<ParallelStrategy> {
     }
 }
 
-impl TryConvert for Wrap<QuantileInterpolOptions> {
+impl TryConvert for Wrap<QuantileMethod> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
-            "lower" => QuantileInterpolOptions::Lower,
-            "higher" => QuantileInterpolOptions::Higher,
-            "nearest" => QuantileInterpolOptions::Nearest,
-            "linear" => QuantileInterpolOptions::Linear,
-            "midpoint" => QuantileInterpolOptions::Midpoint,
+            "lower" => QuantileMethod::Lower,
+            "higher" => QuantileMethod::Higher,
+            "nearest" => QuantileMethod::Nearest,
+            "linear" => QuantileMethod::Linear,
+            "midpoint" => QuantileMethod::Midpoint,
             v => {
                 return Err(RbValueError::new_err(format!(
                     "interpolation must be one of {{'lower', 'higher', 'nearest', 'linear', 'midpoint'}}, got {}",
@@ -988,6 +1068,11 @@ impl TryConvert for Wrap<QuoteStyle> {
     }
 }
 
+pub(crate) fn parse_cloud_options(uri: &str, kv: Vec<(String, String)>) -> RbResult<CloudOptions> {
+    let out = CloudOptions::from_untyped_config(uri, kv).map_err(RbPolarsErr::from)?;
+    Ok(out)
+}
+
 pub fn parse_fill_null_strategy(
     strategy: &str,
     limit: FillNullLimit,
@@ -1053,19 +1138,47 @@ pub fn parse_parquet_compression(
     Ok(parsed)
 }
 
-pub(crate) fn strings_to_smartstrings<I, S>(container: I) -> Vec<SmartString>
+impl TryConvert for Wrap<NonZeroUsize> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let v = usize::try_convert(ob)?;
+        NonZeroUsize::new(v)
+            .map(Wrap)
+            .ok_or(RbValueError::new_err("must be non-zero"))
+    }
+}
+
+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| s.as_ref().into()).collect()
+    container
+        .into_iter()
+        .map(|s| PlSmallStr::from_str(s.as_ref()))
+        .collect()
 }
 
-impl TryConvert for Wrap<NonZeroUsize> {
+#[derive(Debug, Copy, Clone)]
+pub struct RbCompatLevel(pub CompatLevel);
+
+impl TryConvert for RbCompatLevel {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let v = usize::try_convert(ob)?;
-        NonZeroUsize::new(v)
-            .map(Wrap)
-            .ok_or(RbValueError::new_err("must be non-zero".into()))
+        Ok(RbCompatLevel(if let Ok(level) = u16::try_convert(ob) {
+            if let Ok(compat_level) = CompatLevel::with_level(level) {
+                compat_level
+            } else {
+                return Err(RbValueError::new_err("invalid compat level".to_string()));
+            }
+        } else if let Ok(future) = bool::try_convert(ob) {
+            if future {
+                CompatLevel::newest()
+            } else {
+                CompatLevel::oldest()
+            }
+        } else {
+            return Err(RbTypeError::new_err(
+                "'compat_level' argument accepts int or bool".to_string(),
+            ));
+        }))
     }
 }

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

@@ -54,9 +54,6 @@ fn finish_from_rows(
     schema_overrides: Option<Schema>,
     infer_schema_length: Option<usize>,
 ) -> RbResult<RbDataFrame> {
-    // Object builder must be registered
-    crate::on_startup::register_object_builder();
-
     let mut schema = if let Some(mut schema) = schema {
         resolve_schema_overrides(&mut schema, schema_overrides);
         update_schema_from_rows(&mut schema, &rows, infer_schema_length)?;
@@ -79,7 +76,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 +86,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 +107,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 +120,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/export.rs

@@ -2,6 +2,8 @@ use magnus::{prelude::*, IntoValue, RArray, Value};
 
 use super::*;
 use crate::conversion::{ObjectValue, Wrap};
+use crate::interop::arrow::to_ruby::dataframe_to_stream;
+use crate::RbResult;
 
 impl RbDataFrame {
     pub fn row_tuple(&self, idx: i64) -> Value {
@@ -18,7 +20,7 @@ impl RbDataFrame {
                 .map(|s| match s.dtype() {
                     DataType::Object(_, _) => {
                         let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
-                        obj.unwrap().to_object()
+                        obj.unwrap().to_value()
                     }
                     _ => Wrap(s.get(idx).unwrap()).into_value(),
                 }),
@@ -37,7 +39,7 @@ impl RbDataFrame {
                     .map(|s| match s.dtype() {
                         DataType::Object(_, _) => {
                             let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
-                            obj.unwrap().to_object()
+                            obj.unwrap().to_value()
                         }
                         _ => Wrap(s.get(idx).unwrap()).into_value(),
                     }),
@@ -45,4 +47,9 @@ impl RbDataFrame {
         }))
         .as_value()
     }
+
+    pub fn __arrow_c_stream__(&self) -> RbResult<Value> {
+        self.df.borrow_mut().align_chunks();
+        dataframe_to_stream(&self.df.borrow())
+    }
 }

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

@@ -9,14 +9,15 @@ 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::series::{to_rbseries_collection, to_series_collection};
+use crate::prelude::strings_to_pl_smallstr;
+use crate::series::{to_rbseries, to_series};
 use crate::{RbDataFrame, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries};
 
 impl RbDataFrame {
     pub fn init(columns: RArray) -> RbResult<Self> {
         let mut cols = Vec::new();
         for i in columns.into_iter() {
-            cols.push(<&RbSeries>::try_convert(i)?.series.borrow().clone());
+            cols.push(<&RbSeries>::try_convert(i)?.series.borrow().clone().into());
         }
         let df = DataFrame::new(cols).map_err(RbPolarsErr::from)?;
         Ok(RbDataFrame::new(df))
@@ -127,7 +128,7 @@ impl RbDataFrame {
 
     pub fn get_columns(&self) -> RArray {
         let cols = self.df.borrow().get_columns().to_vec();
-        to_rbseries_collection(cols)
+        to_rbseries(cols)
     }
 
     pub fn columns(&self) -> Vec<String> {
@@ -173,7 +174,8 @@ impl RbDataFrame {
     }
 
     pub fn hstack(&self, columns: RArray) -> RbResult<Self> {
-        let columns = to_series_collection(columns)?;
+        let columns = to_series(columns)?;
+        let columns = columns.into_iter().map(Into::into).collect::<Vec<_>>();
         let df = self
             .df
             .borrow()
@@ -183,7 +185,8 @@ impl RbDataFrame {
     }
 
     pub fn hstack_mut(&self, columns: RArray) -> RbResult<()> {
-        let columns = to_series_collection(columns)?;
+        let columns = to_series(columns)?;
+        let columns = columns.into_iter().map(Into::into).collect::<Vec<_>>();
         self.df
             .borrow_mut()
             .hstack_mut(&columns)
@@ -222,6 +225,7 @@ impl RbDataFrame {
             .borrow_mut()
             .drop_in_place(&name)
             .map_err(RbPolarsErr::from)?;
+        let s = s.take_materialized_series();
         Ok(RbSeries::new(s))
     }
 
@@ -229,7 +233,7 @@ impl RbDataFrame {
         self.df
             .borrow()
             .select_at_idx(idx)
-            .map(|s| RbSeries::new(s.clone()))
+            .map(|s| RbSeries::new(s.as_materialized_series().clone()))
     }
 
     pub fn get_column_index(&self, name: String) -> Option<usize> {
@@ -237,11 +241,13 @@ impl RbDataFrame {
     }
 
     pub fn get_column(&self, name: String) -> RbResult<RbSeries> {
-        self.df
+        let series = self
+            .df
             .borrow()
             .column(&name)
-            .map(|s| RbSeries::new(s.clone()))
-            .map_err(RbPolarsErr::from)
+            .map(|s| RbSeries::new(s.as_materialized_series().clone()))
+            .map_err(RbPolarsErr::from)?;
+        Ok(series)
     }
 
     pub fn select(&self, selection: Vec<String>) -> RbResult<Self> {
@@ -254,7 +260,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 +338,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 +355,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()),
         };
@@ -410,7 +416,7 @@ impl RbDataFrame {
             .borrow()
             .max_horizontal()
             .map_err(RbPolarsErr::from)?;
-        Ok(s.map(|s| s.into()))
+        Ok(s.map(|s| s.take_materialized_series().into()))
     }
 
     pub fn min_horizontal(&self) -> RbResult<Option<RbSeries>> {
@@ -419,7 +425,7 @@ impl RbDataFrame {
             .borrow()
             .min_horizontal()
             .map_err(RbPolarsErr::from)?;
-        Ok(s.map(|s| s.into()))
+        Ok(s.map(|s| s.take_materialized_series().into()))
     }
 
     pub fn sum_horizontal(&self, ignore_nulls: bool) -> RbResult<Option<RbSeries>> {
@@ -581,7 +587,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()
     }