polars-df 0.14.0 → 0.15.0

data/LICENSE.txt

@@ -1,5 +1,6 @@
 Copyright (c) 2020 Ritchie Vink
 Copyright (c) 2022-2024 Andrew Kane
+Some portions Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -17,8 +17,7 @@ gem "polars-df"
 This library follows the [Polars Python API](https://pola-rs.github.io/polars/py-polars/html/reference/index.html).
 
 ```ruby
-Polars.read_csv("iris.csv")
-  .lazy
+Polars.scan_csv("iris.csv")
   .filter(Polars.col("sepal_length") > 5)
   .group_by("species")
   .agg(Polars.all.sum)

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars"
-version = "0.14.0"
+version = "0.15.0"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -12,16 +12,20 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ahash = "0.8"
+arrow = { package = "polars-arrow", version = "=0.44.2" }
+bytes = "1"
 chrono = "0.4"
 either = "1.8"
 magnus = "0.7"
-polars-core = "=0.43.1"
-polars-parquet = "=0.43.1"
-polars-utils = "=0.43.1"
+polars-core = "=0.44.2"
+polars-plan = "=0.44.2"
+polars-parquet = "=0.44.2"
+polars-utils = "=0.44.2"
+regex = "1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "=0.43.1"
+version = "=0.44.2"
 features = [
     "abs",
     "approx_unique",
@@ -30,7 +34,11 @@ features = [
     "array_count",
     "asof_join",
     "avro",
+    "aws",
+    "azure",
     "binary_encoding",
+    "business",
+    "cloud",
     "concat_str",
     "cov",
     "cross_join",
@@ -51,6 +59,8 @@ features = [
     "extract_jsonpath",
     "find_many",
     "fmt",
+    "gcp",
+    "http",
     "interpolate",
     "ipc",
     "ipc_streaming",

data/ext/polars/src/batched_csv.rs

@@ -34,8 +34,7 @@ impl RbBatchedCsv {
         let n_threads = Option::<usize>::try_convert(arguments[11])?;
         let path = PathBuf::try_convert(arguments[12])?;
         let overwrite_dtype = Option::<Vec<(String, Wrap<DataType>)>>::try_convert(arguments[13])?;
-        // TODO fix
-        let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::None; // Option::<Vec<Wrap<DataType>>>::try_convert(arguments[14])?;
+        let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::try_convert(arguments[14])?;
         let low_memory = bool::try_convert(arguments[15])?;
         let comment_prefix = Option::<String>::try_convert(arguments[16])?;
         let quote_char = Option::<String>::try_convert(arguments[17])?;
@@ -44,11 +43,10 @@ impl RbBatchedCsv {
         let try_parse_dates = bool::try_convert(arguments[20])?;
         let skip_rows_after_header = usize::try_convert(arguments[21])?;
         let row_index = Option::<(String, IdxSize)>::try_convert(arguments[22])?;
-        let sample_size = usize::try_convert(arguments[23])?;
-        let eol_char = String::try_convert(arguments[24])?;
-        let raise_if_empty = bool::try_convert(arguments[25])?;
-        let truncate_ragged_lines = bool::try_convert(arguments[26])?;
-        let decimal_comma = bool::try_convert(arguments[27])?;
+        let eol_char = String::try_convert(arguments[23])?;
+        let raise_if_empty = bool::try_convert(arguments[24])?;
+        let truncate_ragged_lines = bool::try_convert(arguments[25])?;
+        let decimal_comma = bool::try_convert(arguments[26])?;
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
@@ -84,7 +82,7 @@ impl RbBatchedCsv {
                 .collect::<Vec<_>>()
         });
 
-        let file = std::fs::File::open(path).map_err(RbPolarsErr::io)?;
+        let file = std::fs::File::open(path).map_err(RbPolarsErr::from)?;
         let reader = Box::new(file) as Box<dyn MmapBytesReader>;
         let reader = CsvReadOptions::default()
             .with_infer_schema_length(infer_schema_length)
@@ -101,7 +99,6 @@ impl RbBatchedCsv {
             .with_low_memory(low_memory)
             .with_skip_rows_after_header(skip_rows_after_header)
             .with_row_index(row_index)
-            .with_sample_size(sample_size)
             .with_raise_if_empty(raise_if_empty)
             .with_parse_options(
                 CsvParseOptions::default()
@@ -132,7 +129,7 @@ impl RbBatchedCsv {
         let batches = reader
             .borrow()
             .lock()
-            .map_err(|e| RbPolarsErr::other(e.to_string()))?
+            .map_err(|e| RbPolarsErr::Other(e.to_string()))?
             .next_batches(n)
             .map_err(RbPolarsErr::from)?;
 

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

@@ -7,9 +7,9 @@ use polars_core::utils::any_values_to_supertype_and_n_dtypes;
 
 use super::{struct_dict, ObjectValue, Wrap};
 
-use crate::error::RbOverflowError;
+use crate::exceptions::RbOverflowError;
 use crate::rb_modules::utils;
-use crate::{RbPolarsErr, RbResult, RbSeries};
+use crate::{RbErr, RbPolarsErr, RbResult, RbSeries};
 
 impl IntoValue for Wrap<AnyValue<'_>> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
@@ -47,15 +47,20 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
             };
             s.into_value()
         }
+        AnyValue::CategoricalOwned(idx, rev, arr) | AnyValue::EnumOwned(idx, rev, arr) => {
+            let s = if arr.is_null() {
+                rev.get(idx)
+            } else {
+                unsafe { arr.deref_unchecked().value(idx as usize) }
+            };
+            s.into_value()
+        }
         AnyValue::Date(v) => utils().funcall("_to_ruby_date", (v,)).unwrap(),
         AnyValue::Datetime(v, time_unit, time_zone) => {
-            let time_unit = time_unit.to_ascii();
-            utils()
-                .funcall(
-                    "_to_ruby_datetime",
-                    (v, time_unit, time_zone.as_ref().map(|v| v.to_string())),
-                )
-                .unwrap()
+            datetime_to_rb_object(v, time_unit, time_zone)
+        }
+        AnyValue::DatetimeOwned(v, time_unit, time_zone) => {
+            datetime_to_rb_object(v, time_unit, time_zone.as_ref().map(AsRef::as_ref))
         }
         AnyValue::Duration(v, time_unit) => {
             let time_unit = time_unit.to_ascii();
@@ -69,11 +74,11 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::StructOwned(payload) => struct_dict(payload.0.into_iter(), &payload.1),
         AnyValue::Object(v) => {
             let object = v.as_any().downcast_ref::<ObjectValue>().unwrap();
-            object.to_object()
+            object.to_value()
         }
         AnyValue::ObjectOwned(v) => {
             let object = v.0.as_any().downcast_ref::<ObjectValue>().unwrap();
-            object.to_object()
+            object.to_value()
         }
         AnyValue::Binary(v) => RString::from_slice(v).into_value(),
         AnyValue::BinaryOwned(v) => RString::from_slice(&v).into_value(),
@@ -83,6 +88,13 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
     }
 }
 
+fn datetime_to_rb_object(v: i64, tu: TimeUnit, tz: Option<&TimeZone>) -> Value {
+    let tu = tu.to_ascii();
+    utils()
+        .funcall("_to_ruby_datetime", (v, tu, tz.map(|v| v.to_string())))
+        .unwrap()
+}
+
 pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<AnyValue<'s>> {
     // Conversion functions.
     fn get_null(_ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
@@ -164,9 +176,8 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
         let len = dict.len();
         let mut keys = Vec::with_capacity(len);
         let mut vals = Vec::with_capacity(len);
-        dict.foreach(|k: Value, v: Value| {
-            let key = String::try_convert(k)?;
-            let val = Wrap::<AnyValue>::try_convert(v)?.0;
+        dict.foreach(|key: String, val: Wrap<AnyValue>| {
+            let val = val.0;
             let dtype = DataType::from(&val);
             keys.push(Field::new(key.into(), dtype));
             vals.push(val);
@@ -190,7 +201,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
         let v = sec * 1_000_000_000 + nsec;
         // TODO support time zone when possible
         // https://github.com/pola-rs/polars/issues/9103
-        Ok(AnyValue::Datetime(v, TimeUnit::Nanoseconds, &None))
+        Ok(AnyValue::Datetime(v, TimeUnit::Nanoseconds, None))
     }
 
     fn get_datetime(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
@@ -199,7 +210,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
         Ok(AnyValue::Datetime(
             sec * 1_000_000_000 + nsec,
             TimeUnit::Nanoseconds,
-            &None,
+            None,
         ))
     }
 
@@ -224,7 +235,9 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
 
         let (sign, digits, _, exp): (i8, String, i32, i32) = ob.funcall("split", ()).unwrap();
         let (mut v, scale) = abs_decimal_from_digits(digits, exp).ok_or_else(|| {
-            RbPolarsErr::other("BigDecimal is too large to fit in Decimal128".into())
+            RbErr::from(RbPolarsErr::Other(
+                "BigDecimal is too large to fit in Decimal128".into(),
+            ))
         })?;
         if sign < 0 {
             // TODO better error
@@ -259,9 +272,6 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     } else if ob.is_kind_of(crate::rb_modules::bigdecimal()) {
         get_decimal(ob, strict)
     } else {
-        Err(RbPolarsErr::other(format!(
-            "object type not supported {:?}",
-            ob
-        )))
+        Err(RbPolarsErr::Other(format!("object type not supported {:?}", ob)).into())
     }
 }

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,12 +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 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};
@@ -104,9 +109,10 @@ impl TryConvert for Wrap<NullValues> {
                     .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(),
+            )
         }
     }
 }
@@ -328,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() {
@@ -434,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();
@@ -452,8 +459,7 @@ impl TryConvert for Wrap<StatisticsOptions> {
                 }
             }
             Ok(ForEach::Continue)
-        })
-        .unwrap();
+        })?;
 
         Ok(Wrap(statistics))
     }
@@ -478,13 +484,75 @@ impl TryConvert for Wrap<Schema> {
         dict.foreach(|key: String, val: Wrap<DataType>| {
             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>,
@@ -493,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()
     }
 }
@@ -501,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)
@@ -512,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)
     }
 }
 
@@ -533,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())
     }
 }
 
@@ -561,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)
     }
 }
 
@@ -587,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}",
                 )))
             }
         };
@@ -830,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 {}",
@@ -1001,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,
@@ -1071,7 +1143,7 @@ impl TryConvert for Wrap<NonZeroUsize> {
         let v = usize::try_convert(ob)?;
         NonZeroUsize::new(v)
             .map(Wrap)
-            .ok_or(RbValueError::new_err("must be non-zero".into()))
+            .ok_or(RbValueError::new_err("must be non-zero"))
     }
 }
 
@@ -1085,3 +1157,28 @@ where
         .map(|s| PlSmallStr::from_str(s.as_ref()))
         .collect()
 }
+
+#[derive(Debug, Copy, Clone)]
+pub struct RbCompatLevel(pub CompatLevel);
+
+impl TryConvert for RbCompatLevel {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        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)?;

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

@@ -10,14 +10,14 @@ use crate::map::dataframe::{
     apply_lambda_with_utf8_out_type,
 };
 use crate::prelude::strings_to_pl_smallstr;
-use crate::series::{to_rbseries_collection, to_series_collection};
+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))
@@ -128,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> {
@@ -174,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()
@@ -184,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)
@@ -223,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))
     }
 
@@ -230,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> {
@@ -238,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> {
@@ -411,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>> {
@@ -420,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>> {