polars-df 0.20.0 → 0.21.0

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

@@ -1,13 +1,13 @@
 use magnus::encoding::{self, EncodingCapable};
 use magnus::{
-    class, prelude::*, typed_data::Obj, value::Opaque, Float, Integer, RArray, RString, Ruby, Value,
+    Float, Integer, RArray, RString, Ruby, Value, class, prelude::*, typed_data::Obj, value::Opaque,
 };
 use polars::lazy::dsl;
 use polars::prelude::*;
 
-use crate::conversion::{get_lf, get_rbseq, Wrap};
+use crate::conversion::{Wrap, get_lf, get_rbseq};
+use crate::expr::datatype::RbDataTypeExpr;
 use crate::map::lazy::binary_lambda;
-use crate::prelude::vec_extract_wrapped;
 use crate::rb_exprs_to_exprs;
 use crate::{RbDataFrame, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbValueError};
 
@@ -103,10 +103,6 @@ pub fn collect_all(lfs: RArray) -> RbResult<RArray> {
     })))
 }
 
-pub fn cols(names: Vec<String>) -> RbExpr {
-    dsl::cols(names).into()
-}
-
 pub fn concat_lf(
     lfs: Value,
     rechunk: bool,
@@ -166,20 +162,24 @@ pub fn cum_fold(
     acc: &RbExpr,
     lambda: Value,
     exprs: RArray,
+    returns_scalar: bool,
+    return_dtype: Option<&RbDataTypeExpr>,
     include_init: bool,
 ) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
     let lambda = Opaque::from(lambda);
-
-    let func = move |a: Column, b: Column| {
-        binary_lambda(
-            Ruby::get().unwrap().get_inner(lambda),
-            a.take_materialized_series(),
-            b.take_materialized_series(),
-        )
-        .map(|v| v.map(Column::from))
-    };
-    Ok(dsl::cum_fold_exprs(acc.inner.clone(), func, exprs, include_init).into())
+    let func = PlanCallback::new(move |(a, b): (Series, Series)| {
+        binary_lambda(Ruby::get().unwrap().get_inner(lambda), a, b).map(|v| v.unwrap())
+    });
+    Ok(dsl::cum_fold_exprs(
+        acc.inner.clone(),
+        func,
+        exprs,
+        returns_scalar,
+        return_dtype.map(|v| v.inner.clone()),
+        include_init,
+    )
+    .into())
 }
 
 pub fn concat_lf_diagonal(
@@ -220,24 +220,6 @@ pub fn concat_lf_horizontal(lfs: RArray, parallel: bool) -> RbResult<RbLazyFrame
     Ok(lf.into())
 }
 
-pub fn dtype_cols(dtypes: RArray) -> RbResult<RbExpr> {
-    let dtypes = dtypes
-        .into_iter()
-        .map(Wrap::<DataType>::try_convert)
-        .collect::<RbResult<Vec<Wrap<DataType>>>>()?;
-    let dtypes = vec_extract_wrapped(dtypes);
-    Ok(dsl::dtype_cols(dtypes).into())
-}
-
-pub fn index_cols(indices: Vec<i64>) -> RbExpr {
-    if indices.len() == 1 {
-        dsl::nth(indices[0])
-    } else {
-        dsl::index_cols(indices)
-    }
-    .into()
-}
-
 #[allow(clippy::too_many_arguments)]
 pub fn duration(
     weeks: Option<&RbExpr>,
@@ -274,42 +256,28 @@ pub fn duration(
     dsl::duration(args).into()
 }
 
-pub fn first() -> RbExpr {
-    dsl::first().into()
-}
-
 pub fn fold(
     acc: &RbExpr,
     lambda: Value,
     exprs: RArray,
     returns_scalar: bool,
-    return_dtype: Option<Wrap<DataType>>,
+    return_dtype: Option<&RbDataTypeExpr>,
 ) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
     let lambda = Opaque::from(lambda);
-
-    let func = move |a: Column, b: Column| {
-        binary_lambda(
-            Ruby::get().unwrap().get_inner(lambda),
-            a.take_materialized_series(),
-            b.take_materialized_series(),
-        )
-        .map(|v| v.map(Column::from))
-    };
+    let func = PlanCallback::new(move |(a, b): (Series, Series)| {
+        binary_lambda(Ruby::get().unwrap().get_inner(lambda), a, b).map(|v| v.unwrap())
+    });
     Ok(dsl::fold_exprs(
         acc.inner.clone(),
         func,
         exprs,
         returns_scalar,
-        return_dtype.map(|w| w.0),
+        return_dtype.map(|w| w.inner.clone()),
     )
     .into())
 }
 
-pub fn last() -> RbExpr {
-    dsl::last().into()
-}
-
 pub fn lit(value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr> {
     if value.is_kind_of(class::true_class()) || value.is_kind_of(class::false_class()) {
         Ok(dsl::lit(bool::try_convert(value)?).into())

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

@@ -1,8 +1,8 @@
 use magnus::{IntoValue, Value};
 use polars_core;
+use polars_core::POOL;
 use polars_core::fmt::FloatFmt;
 use polars_core::prelude::IDX_DTYPE;
-use polars_core::POOL;
 
 use crate::conversion::Wrap;
 use crate::{RbResult, RbValueError};
@@ -22,7 +22,7 @@ pub fn set_float_fmt(fmt: String) -> RbResult<()> {
         e => {
             return Err(RbValueError::new_err(format!(
                 "fmt must be one of {{'full', 'mixed'}}, got {e}",
-            )))
+            )));
         }
     };
     polars_core::fmt::set_float_fmt(fmt);

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

@@ -1,6 +1,6 @@
+use crate::RbResult;
 use crate::conversion::Wrap;
 use crate::prelude::DataType;
-use crate::RbResult;
 
 pub fn dtype_str_repr(dtype: Wrap<DataType>) -> RbResult<String> {
     let dtype = dtype.0;

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

@@ -1,17 +1,17 @@
 use crate::RbResult;
 use magnus::{RArray, Ruby, Value};
-use polars_core::StringCacheHolder;
 
 pub fn enable_string_cache() {
-    polars_core::enable_string_cache()
+    // The string cache no longer exists.
 }
 
 pub fn disable_string_cache() {
-    polars_core::disable_string_cache()
+    // The string cache no longer exists.
 }
 
 pub fn using_string_cache() -> bool {
-    polars_core::using_string_cache()
+    // The string cache no longer exists.
+    true
 }
 
 #[magnus::wrap(class = "Polars::RbStringCacheHolder")]
@@ -19,7 +19,6 @@ pub struct RbStringCacheHolder {}
 
 impl RbStringCacheHolder {
     pub fn hold() -> RbResult<Value> {
-        let _hold = StringCacheHolder::hold();
         Ruby::get().unwrap().yield_splat(RArray::new())
     }
 }

data/ext/polars/src/interop/numo/numo_rs.rs

@@ -1,4 +1,4 @@
-use magnus::{class, prelude::*, IntoValue, Module, RArray, RClass, RModule, Value};
+use magnus::{IntoValue, Module, RArray, RClass, RModule, Value, class, prelude::*};
 
 use crate::RbResult;
 

data/ext/polars/src/interop/numo/to_numo_series.rs

@@ -3,10 +3,10 @@ use num_traits::{Float, NumCast};
 use polars_core::prelude::*;
 
 use super::numo_rs::{Element, RbArray1};
+use crate::RbResult;
 use crate::error::RbPolarsErr;
 use crate::raise_err;
 use crate::series::RbSeries;
-use crate::RbResult;
 
 impl RbSeries {
     /// Convert this Series to a Numo array.

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

@@ -0,0 +1,102 @@
+use std::sync::Arc;
+
+use magnus::{TryConvert, Value, value::ReprValue};
+use polars::prelude::deletion::DeletionFilesList;
+use polars::prelude::{
+    CastColumnsPolicy, ColumnMapping, ExtraColumnsPolicy, MissingColumnsPolicy, PlSmallStr, Schema,
+    UnifiedScanArgs,
+};
+use polars_io::{HiveOptions, RowIndex};
+use polars_utils::IdxSize;
+use polars_utils::plpath::PlPathRef;
+use polars_utils::slice_enum::Slice;
+
+use crate::RbResult;
+use crate::prelude::Wrap;
+
+/// Interface to `class ScanOptions` on the Ruby side
+pub struct RbScanOptions(Value);
+
+impl TryConvert for RbScanOptions {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        Ok(Self(ob))
+    }
+}
+
+impl RbScanOptions {
+    pub fn extract_unified_scan_args(
+        &self,
+        // For cloud_options init
+        first_path: Option<PlPathRef>,
+    ) -> RbResult<UnifiedScanArgs> {
+        let row_index: Option<(Wrap<PlSmallStr>, IdxSize)> = self.0.funcall("row_index", ())?;
+        let pre_slice: Option<(i64, usize)> = self.0.funcall("pre_slice", ())?;
+        let cast_options: Wrap<CastColumnsPolicy> = self.0.funcall("cast_options", ())?;
+        let extra_columns: Wrap<ExtraColumnsPolicy> = self.0.funcall("extra_columns", ())?;
+        let missing_columns: Wrap<MissingColumnsPolicy> = self.0.funcall("missing_columns", ())?;
+        let include_file_paths: Option<Wrap<PlSmallStr>> =
+            self.0.funcall("include_file_paths", ())?;
+        let glob: bool = self.0.funcall("glob", ())?;
+        let hive_partitioning: Option<bool> = self.0.funcall("hive_partitioning", ())?;
+        let hive_schema: Option<Wrap<Schema>> = self.0.funcall("hive_schema", ())?;
+        let try_parse_hive_dates: bool = self.0.funcall("try_parse_hive_dates", ())?;
+        let rechunk: bool = self.0.funcall("rechunk", ())?;
+        let cache: bool = self.0.funcall("cache", ())?;
+        let storage_options: Option<Vec<(String, String)>> =
+            self.0.funcall("storage_options", ())?;
+        let retries: usize = self.0.funcall("retries", ())?;
+        let deletion_files: Option<Wrap<DeletionFilesList>> =
+            self.0.funcall("deletion_files", ())?;
+        let column_mapping: Option<Wrap<ColumnMapping>> = self.0.funcall("column_mapping", ())?;
+
+        let cloud_options = storage_options;
+
+        let cloud_options = if let Some(first_path) = first_path {
+            use crate::prelude::parse_cloud_options;
+
+            let first_path_url = first_path.to_str();
+            let cloud_options =
+                parse_cloud_options(first_path_url, cloud_options.unwrap_or_default())?;
+
+            Some(cloud_options.with_max_retries(retries))
+        } else {
+            None
+        };
+
+        let hive_schema = hive_schema.map(|s| Arc::new(s.0));
+
+        let row_index = row_index.map(|(name, offset)| RowIndex {
+            name: name.0,
+            offset,
+        });
+
+        let hive_options = HiveOptions {
+            enabled: hive_partitioning,
+            hive_start_idx: 0,
+            schema: hive_schema,
+            try_parse_dates: try_parse_hive_dates,
+        };
+
+        let unified_scan_args = UnifiedScanArgs {
+            // Schema is currently still stored inside the options per scan type, but we do eventually
+            // want to put it here instead.
+            schema: None,
+            cloud_options,
+            hive_options,
+            rechunk,
+            cache,
+            glob,
+            projection: None,
+            row_index,
+            pre_slice: pre_slice.map(Slice::from),
+            cast_columns_policy: cast_options.0,
+            missing_columns_policy: missing_columns.0,
+            extra_columns_policy: extra_columns.0,
+            include_file_paths: include_file_paths.map(|x| x.0),
+            deletion_files: DeletionFilesList::filter_empty(deletion_files.map(|x| x.0)),
+            column_mapping: column_mapping.map(|x| x.0),
+        };
+
+        Ok(unified_scan_args)
+    }
+}

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

@@ -1,4 +1,4 @@
-use magnus::{r_hash::ForEach, typed_data::Obj, IntoValue, RArray, RHash, TryConvert, Value};
+use magnus::{IntoValue, RArray, RHash, TryConvert, Value, r_hash::ForEach, typed_data::Obj};
 use polars::io::{HiveOptions, RowIndex};
 use polars::lazy::frame::LazyFrame;
 use polars::prelude::*;
@@ -6,16 +6,17 @@ use polars_plan::dsl::ScanSources;
 use std::cell::RefCell;
 use std::io::BufWriter;
 use std::num::NonZeroUsize;
-use std::path::PathBuf;
 
 use super::SinkTarget;
 use crate::conversion::*;
 use crate::expr::rb_exprs_to_exprs;
+use crate::expr::selector::RbSelector;
 use crate::file::get_file_like;
+use crate::io::RbScanOptions;
 use crate::{RbDataFrame, RbExpr, RbLazyFrame, RbLazyGroupBy, RbPolarsErr, RbResult, RbValueError};
 
-fn rbobject_to_first_path_and_scan_sources(obj: Value) -> RbResult<(Option<PathBuf>, ScanSources)> {
-    use crate::file::{get_ruby_scan_source_input, RubyScanSourceInput};
+fn rbobject_to_first_path_and_scan_sources(obj: Value) -> RbResult<(Option<PlPath>, ScanSources)> {
+    use crate::file::{RubyScanSourceInput, get_ruby_scan_source_input};
     Ok(match get_ruby_scan_source_input(obj, false)? {
         RubyScanSourceInput::Path(path) => (Some(path.clone()), ScanSources::Paths([path].into())),
         RubyScanSourceInput::File(file) => (None, ScanSources::Files([file].into())),
@@ -43,7 +44,7 @@ impl RbLazyFrame {
 
         let sources = sources.0;
         let (_first_path, sources) = match source {
-            None => (sources.first_path().map(|p| p.to_path_buf()), sources),
+            None => (sources.first_path().map(|p| p.into_owned()), sources),
             Some(source) => rbobject_to_first_path_and_scan_sources(source)?,
         };
 
@@ -111,7 +112,7 @@ impl RbLazyFrame {
 
         let sources = sources.0;
         let (_first_path, sources) = match source {
-            None => (sources.first_path().map(|p| p.to_path_buf()), sources),
+            None => (sources.first_path().map(|p| p.into_owned()), sources),
             Some(source) => rbobject_to_first_path_and_scan_sources(source)?,
         };
 
@@ -147,72 +148,35 @@ impl RbLazyFrame {
         Ok(r.finish().map_err(RbPolarsErr::from)?.into())
     }
 
-    pub fn new_from_parquet(arguments: &[Value]) -> RbResult<Self> {
-        let source = Option::<Value>::try_convert(arguments[0])?;
-        let sources = Wrap::<ScanSources>::try_convert(arguments[1])?;
-        let n_rows = Option::<usize>::try_convert(arguments[2])?;
-        let cache = bool::try_convert(arguments[3])?;
-        let parallel = Wrap::<ParallelStrategy>::try_convert(arguments[4])?;
-        let rechunk = bool::try_convert(arguments[5])?;
-        let row_index = Option::<(String, IdxSize)>::try_convert(arguments[6])?;
-        let low_memory = bool::try_convert(arguments[7])?;
-        let cloud_options = Option::<Vec<(String, String)>>::try_convert(arguments[8])?;
-        let _credential_provider = Option::<Value>::try_convert(arguments[9])?;
-        let use_statistics = bool::try_convert(arguments[10])?;
-        let hive_partitioning = Option::<bool>::try_convert(arguments[11])?;
-        let schema = Option::<Wrap<Schema>>::try_convert(arguments[12])?;
-        let hive_schema = Option::<Wrap<Schema>>::try_convert(arguments[13])?;
-        let try_parse_hive_dates = bool::try_convert(arguments[14])?;
-        let retries = usize::try_convert(arguments[15])?;
-        let glob = bool::try_convert(arguments[16])?;
-        let include_file_paths = Option::<String>::try_convert(arguments[17])?;
-        let allow_missing_columns = bool::try_convert(arguments[18])?;
+    pub fn new_from_parquet(
+        sources: Wrap<ScanSources>,
+        schema: Option<Wrap<Schema>>,
+        scan_options: RbScanOptions,
+        parallel: Wrap<ParallelStrategy>,
+        low_memory: bool,
+        use_statistics: bool,
+    ) -> RbResult<Self> {
+        use crate::utils::to_rb_err;
 
         let parallel = parallel.0;
-        let hive_schema = hive_schema.map(|s| Arc::new(s.0));
-
-        let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: name.into(),
-            offset,
-        });
 
-        let hive_options = HiveOptions {
-            enabled: hive_partitioning,
-            hive_start_idx: 0,
-            schema: hive_schema,
-            try_parse_dates: try_parse_hive_dates,
-        };
-
-        let mut args = ScanArgsParquet {
-            n_rows,
-            cache,
+        let options = ParquetOptions {
+            schema: schema.map(|x| Arc::new(x.0)),
             parallel,
-            rechunk,
-            row_index,
             low_memory,
-            cloud_options: None,
             use_statistics,
-            schema: schema.map(|x| Arc::new(x.0)),
-            hive_options,
-            glob,
-            include_file_paths: include_file_paths.map(|x| x.into()),
-            allow_missing_columns,
         };
 
         let sources = sources.0;
-        let (first_path, sources) = match source {
-            None => (sources.first_path().map(|p| p.to_path_buf()), sources),
-            Some(source) => rbobject_to_first_path_and_scan_sources(source)?,
-        };
+        let first_path = sources.first_path().map(|p| p.into_owned());
 
-        if let Some(first_path) = first_path {
-            let first_path_url = first_path.to_string_lossy();
-            let cloud_options =
-                parse_cloud_options(&first_path_url, cloud_options.unwrap_or_default())?;
-            args.cloud_options = Some(cloud_options.with_max_retries(retries));
-        }
+        let unified_scan_args =
+            scan_options.extract_unified_scan_args(first_path.as_ref().map(|p| p.as_ref()))?;
 
-        let lf = LazyFrame::scan_parquet_sources(sources, args).map_err(RbPolarsErr::from)?;
+        let lf: LazyFrame = DslBuilder::scan_parquet(sources, options, unified_scan_args)
+            .map_err(to_rb_err)?
+            .build()
+            .into();
 
         Ok(lf.into())
     }
@@ -254,7 +218,7 @@ impl RbLazyFrame {
 
         let sources = sources.0;
         let (_first_path, sources) = match source {
-            None => (sources.first_path().map(|p| p.to_path_buf()), sources),
+            None => (sources.first_path().map(|p| p.into_owned()), sources),
             Some(source) => rbobject_to_first_path_and_scan_sources(source)?,
         };
 
@@ -265,7 +229,7 @@ impl RbLazyFrame {
     pub fn write_json(&self, rb_f: Value) -> RbResult<()> {
         let file = BufWriter::new(get_file_like(rb_f, true)?);
         serde_json::to_writer(file, &self.ldf.borrow().logical_plan)
-            .map_err(|err| RbValueError::new_err(format!("{:?}", err)))?;
+            .map_err(|err| RbValueError::new_err(format!("{err:?}")))?;
         Ok(())
     }
 
@@ -399,10 +363,8 @@ impl RbLazyFrame {
         let cloud_options = match target.base_path() {
             None => None,
             Some(base_path) => {
-                let cloud_options = parse_cloud_options(
-                    base_path.to_str().unwrap(),
-                    cloud_options.unwrap_or_default(),
-                )?;
+                let cloud_options =
+                    parse_cloud_options(base_path.to_str(), cloud_options.unwrap_or_default())?;
                 Some(cloud_options.with_max_retries(retries))
             }
         };
@@ -434,10 +396,8 @@ impl RbLazyFrame {
         let cloud_options = match target.base_path() {
             None => None,
             Some(base_path) => {
-                let cloud_options = parse_cloud_options(
-                    base_path.to_str().unwrap(),
-                    cloud_options.unwrap_or_default(),
-                )?;
+                let cloud_options =
+                    parse_cloud_options(base_path.to_str(), cloud_options.unwrap_or_default())?;
                 Some(cloud_options.with_max_retries(retries))
             }
         };
@@ -466,11 +426,12 @@ impl RbLazyFrame {
         let time_format = Option::<String>::try_convert(arguments[9])?;
         let float_scientific = Option::<bool>::try_convert(arguments[10])?;
         let float_precision = Option::<usize>::try_convert(arguments[11])?;
-        let null_value = Option::<String>::try_convert(arguments[12])?;
-        let quote_style = Option::<Wrap<QuoteStyle>>::try_convert(arguments[13])?;
-        let cloud_options = Option::<Vec<(String, String)>>::try_convert(arguments[14])?;
-        let retries = usize::try_convert(arguments[15])?;
-        let sink_options = Wrap::<SinkOptions>::try_convert(arguments[16])?;
+        let decimal_comma = bool::try_convert(arguments[12])?;
+        let null_value = Option::<String>::try_convert(arguments[13])?;
+        let quote_style = Option::<Wrap<QuoteStyle>>::try_convert(arguments[14])?;
+        let cloud_options = Option::<Vec<(String, String)>>::try_convert(arguments[15])?;
+        let retries = usize::try_convert(arguments[16])?;
+        let sink_options = Wrap::<SinkOptions>::try_convert(arguments[17])?;
 
         let quote_style = quote_style.map_or(QuoteStyle::default(), |wrap| wrap.0);
         let null_value = null_value.unwrap_or(SerializeOptions::default().null);
@@ -481,6 +442,7 @@ impl RbLazyFrame {
             datetime_format,
             float_scientific,
             float_precision,
+            decimal_comma,
             separator,
             quote_char,
             null: null_value,
@@ -498,10 +460,8 @@ impl RbLazyFrame {
         let cloud_options = match target.base_path() {
             None => None,
             Some(base_path) => {
-                let cloud_options = parse_cloud_options(
-                    base_path.to_str().unwrap(),
-                    cloud_options.unwrap_or_default(),
-                )?;
+                let cloud_options =
+                    parse_cloud_options(base_path.to_str(), cloud_options.unwrap_or_default())?;
                 Some(cloud_options.with_max_retries(retries))
             }
         };
@@ -529,10 +489,8 @@ impl RbLazyFrame {
         let cloud_options = match target.base_path() {
             None => None,
             Some(base_path) => {
-                let cloud_options = parse_cloud_options(
-                    base_path.to_str().unwrap(),
-                    cloud_options.unwrap_or_default(),
-                )?;
+                let cloud_options =
+                    parse_cloud_options(base_path.to_str(), cloud_options.unwrap_or_default())?;
                 Some(cloud_options.with_max_retries(retries))
             }
         };
@@ -546,12 +504,6 @@ impl RbLazyFrame {
         .map_err(Into::into)
     }
 
-    pub fn fetch(&self, n_rows: usize) -> RbResult<RbDataFrame> {
-        let ldf = self.ldf.borrow().clone();
-        let df = ldf.fetch(n_rows).map_err(RbPolarsErr::from)?;
-        Ok(df.into())
-    }
-
     pub fn filter(&self, predicate: &RbExpr) -> Self {
         let ldf = self.ldf.borrow().clone();
         ldf.filter(predicate.inner.clone()).into()
@@ -689,15 +641,19 @@ impl RbLazyFrame {
             .allow_parallel(allow_parallel)
             .force_parallel(force_parallel)
             .coalesce(coalesce)
-            .how(JoinType::AsOf(AsOfOptions {
+            .how(JoinType::AsOf(Box::new(AsOfOptions {
                 strategy: strategy.0,
                 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()),
+                tolerance: tolerance.map(|t| {
+                    let av = t.0.into_static();
+                    let dtype = av.dtype();
+                    Scalar::new(dtype, av)
+                }),
                 tolerance_str: tolerance_str.map(|s| s.into()),
                 allow_eq,
                 check_sortedness,
-            }))
+            })))
             .suffix(suffix)
             .finish()
             .into())
@@ -832,10 +788,12 @@ impl RbLazyFrame {
         out.into()
     }
 
-    pub fn explode(&self, column: RArray) -> RbResult<Self> {
-        let ldf = self.ldf.borrow().clone();
-        let column = rb_exprs_to_exprs(column)?;
-        Ok(ldf.explode(column).into())
+    pub fn explode(&self, subset: &RbSelector) -> Self {
+        self.ldf
+            .borrow()
+            .clone()
+            .explode(subset.inner.clone())
+            .into()
     }
 
     pub fn null_count(&self) -> Self {
@@ -846,10 +804,11 @@ impl RbLazyFrame {
     pub fn unique(
         &self,
         maintain_order: bool,
-        subset: Option<Vec<String>>,
+        subset: Option<&RbSelector>,
         keep: Wrap<UniqueKeepStrategy>,
     ) -> RbResult<Self> {
         let ldf = self.ldf.borrow().clone();
+        let subset = subset.map(|e| e.inner.clone());
         Ok(match maintain_order {
             true => ldf.unique_stable_generic(subset, keep.0),
             false => ldf.unique_generic(subset, keep.0),
@@ -857,9 +816,11 @@ impl RbLazyFrame {
         .into())
     }
 
-    pub fn drop_nulls(&self, subset: Option<Vec<String>>) -> Self {
-        let ldf = self.ldf.borrow().clone();
-        ldf.drop_nulls(subset.map(|v| v.into_iter().map(|s| col(&s)).collect()))
+    pub fn drop_nulls(&self, subset: Option<&RbSelector>) -> Self {
+        self.ldf
+            .borrow()
+            .clone()
+            .drop_nulls(subset.map(|e| e.inner.clone()))
             .into()
     }
 
@@ -875,16 +836,14 @@ impl RbLazyFrame {
 
     pub fn unpivot(
         &self,
-        on: RArray,
-        index: RArray,
+        on: &RbSelector,
+        index: &RbSelector,
         value_name: Option<String>,
         variable_name: Option<String>,
     ) -> RbResult<Self> {
-        let on = rb_exprs_to_exprs(on)?;
-        let index = rb_exprs_to_exprs(index)?;
         let args = UnpivotArgsDSL {
-            on: on.into_iter().map(|e| e.into()).collect(),
-            index: index.into_iter().map(|e| e.into()).collect(),
+            on: on.inner.clone(),
+            index: index.inner.clone(),
             value_name: value_name.map(|s| s.into()),
             variable_name: variable_name.map(|s| s.into()),
         };
@@ -898,9 +857,8 @@ impl RbLazyFrame {
         ldf.with_row_index(&name, offset).into()
     }
 
-    pub fn drop(&self, cols: Vec<String>) -> Self {
-        let ldf = self.ldf.borrow().clone();
-        ldf.drop(cols).into()
+    pub fn drop(&self, columns: &RbSelector) -> Self {
+        self.ldf.borrow().clone().drop(columns.inner.clone()).into()
     }
 
     pub fn cast(&self, rb_dtypes: RHash, strict: bool) -> RbResult<Self> {
@@ -941,8 +899,12 @@ impl RbLazyFrame {
         Ok(schema_dict)
     }
 
-    pub fn unnest(&self, cols: Vec<String>) -> Self {
-        self.ldf.borrow().clone().unnest(cols).into()
+    pub fn unnest(&self, columns: &RbSelector) -> Self {
+        self.ldf
+            .borrow()
+            .clone()
+            .unnest(columns.inner.clone())
+            .into()
     }
 
     pub fn count(&self) -> Self {

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

@@ -25,7 +25,7 @@ impl RbLazyFrame {
         let json = unsafe { std::mem::transmute::<&'_ str, &'static str>(json.as_str()) };
 
         let lp = serde_json::from_str::<DslPlan>(json)
-            .map_err(|err| RbValueError::new_err(format!("{:?}", err)))?;
+            .map_err(|err| RbValueError::new_err(format!("{err:?}")))?;
         Ok(LazyFrame::from(lp).into())
     }
 }