polars-df 0.25.0 → 0.26.0

data/ext/polars/src/lib.rs

@@ -25,6 +25,10 @@ mod testing;
 mod timeout;
 mod utils;
 
+use crate::conversion::Wrap;
+
+pub type RbDataType = Wrap<polars_core::datatypes::DataType>;
+
 use catalog::unity::RbCatalogClient;
 use conversion::*;
 use dataframe::RbDataFrame;
@@ -32,7 +36,6 @@ use error::RbPolarsErr;
 use expr::RbExpr;
 use expr::datatype::RbDataTypeExpr;
 use expr::selector::RbSelector;
-use functions::string_cache::RbStringCacheHolder;
 use functions::whenthen::{RbChainedThen, RbChainedWhen, RbThen, RbWhen};
 use interop::arrow::to_rb::{RbArrowArrayStream, RbArrowSchema};
 use lazyframe::{RbCollectBatches, RbInProcessQuery, RbLazyFrame, RbOptFlags};
@@ -151,7 +154,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("hash_rows", method!(RbDataFrame::hash_rows, 4))?;
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
     class.define_method("upsample", method!(RbDataFrame::upsample, 4))?;
-    class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
+    class.define_method("to_struct", method!(RbDataFrame::to_struct, 2))?;
     class.define_method("clear", method!(RbDataFrame::clear, 0))?;
     class.define_method(
         "serialize_binary",
@@ -189,6 +192,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("is_not_nan", method!(RbExpr::is_not_nan, 0))?;
     class.define_method("min", method!(RbExpr::min, 0))?;
     class.define_method("max", method!(RbExpr::max, 0))?;
+    class.define_method("min_by", method!(RbExpr::min_by, 1))?;
+    class.define_method("max_by", method!(RbExpr::max_by, 1))?;
     class.define_method("nan_max", method!(RbExpr::nan_max, 0))?;
     class.define_method("nan_min", method!(RbExpr::nan_min, 0))?;
     class.define_method("mean", method!(RbExpr::mean, 0))?;
@@ -201,7 +206,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("first", method!(RbExpr::first, 1))?;
     class.define_method("last", method!(RbExpr::last, 1))?;
     class.define_method("item", method!(RbExpr::item, 1))?;
-    class.define_method("implode", method!(RbExpr::implode, 0))?;
+    class.define_method("implode", method!(RbExpr::implode, 1))?;
     class.define_method("quantile", method!(RbExpr::quantile, 2))?;
     class.define_method("cut", method!(RbExpr::cut, 4))?;
     class.define_method("qcut", method!(RbExpr::qcut, 5))?;
@@ -227,7 +232,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
     class.define_method("index_of", method!(RbExpr::index_of, 1))?;
     class.define_method("search_sorted", method!(RbExpr::search_sorted, 3))?;
-    class.define_method("gather", method!(RbExpr::gather, 1))?;
+    class.define_method("gather", method!(RbExpr::gather, 2))?;
     class.define_method("get", method!(RbExpr::get, 2))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 5))?;
     class.define_method("shift", method!(RbExpr::shift, 2))?;
@@ -258,6 +263,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("rechunk", method!(RbExpr::rechunk, 0))?;
     class.define_method("round", method!(RbExpr::round, 2))?;
     class.define_method("round_sig_figs", method!(RbExpr::round_sig_figs, 1))?;
+    class.define_method("truncate", method!(RbExpr::truncate, 1))?;
     class.define_method("floor", method!(RbExpr::floor, 0))?;
     class.define_method("ceil", method!(RbExpr::ceil, 0))?;
     class.define_method("clip", method!(RbExpr::clip, 2))?;
@@ -335,13 +341,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arr_var", method!(RbExpr::arr_var, 1))?;
     class.define_method("arr_mean", method!(RbExpr::arr_mean, 0))?;
     class.define_method("arr_median", method!(RbExpr::arr_median, 0))?;
-    class.define_method("arr_unique", method!(RbExpr::arr_unique, 1))?;
-    class.define_method("arr_n_unique", method!(RbExpr::arr_n_unique, 0))?;
     class.define_method("arr_to_list", method!(RbExpr::arr_to_list, 0))?;
-    class.define_method("arr_all", method!(RbExpr::arr_all, 0))?;
-    class.define_method("arr_any", method!(RbExpr::arr_any, 0))?;
     class.define_method("arr_sort", method!(RbExpr::arr_sort, 2))?;
-    class.define_method("arr_reverse", method!(RbExpr::arr_reverse, 0))?;
     class.define_method("arr_arg_min", method!(RbExpr::arr_arg_min, 0))?;
     class.define_method("arr_arg_max", method!(RbExpr::arr_arg_max, 0))?;
     class.define_method("arr_get", method!(RbExpr::arr_get, 2))?;
@@ -477,7 +478,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_replace", method!(RbExpr::dt_replace, 8))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
-    class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
+    class.define_method("reinterpret", method!(RbExpr::reinterpret, 2))?;
     class.define_method("mode", method!(RbExpr::mode, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
     class.define_method("interpolate_by", method!(RbExpr::interpolate_by, 1))?;
@@ -504,6 +505,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("rolling_rank_by", method!(RbExpr::rolling_rank_by, 6))?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 4))?;
     class.define_method("rolling_kurtosis", method!(RbExpr::rolling_kurtosis, 5))?;
+    class.define_method("rolling_map", method!(RbExpr::rolling_map, 5))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
     class.define_method("list_max", method!(RbExpr::list_max, 0))?;
@@ -524,16 +526,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_var", method!(RbExpr::list_var, 1))?;
     class.define_method("list_tail", method!(RbExpr::list_tail, 1))?;
     class.define_method("list_sort", method!(RbExpr::list_sort, 2))?;
-    class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
-    class.define_method("list_n_unique", method!(RbExpr::list_n_unique, 0))?;
-    class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
     class.define_method("list_set_operation", method!(RbExpr::list_set_operation, 2))?;
     class.define_method("list_get", method!(RbExpr::list_get, 2))?;
     class.define_method("list_join", method!(RbExpr::list_join, 2))?;
     class.define_method("list_arg_min", method!(RbExpr::list_arg_min, 0))?;
     class.define_method("list_arg_max", method!(RbExpr::list_arg_max, 0))?;
-    class.define_method("list_all", method!(RbExpr::list_all, 0))?;
-    class.define_method("list_any", method!(RbExpr::list_any, 0))?;
     class.define_method("list_diff", method!(RbExpr::list_diff, 2))?;
     class.define_method("list_shift", method!(RbExpr::list_shift, 1))?;
     class.define_method("list_slice", method!(RbExpr::list_slice, 2))?;
@@ -567,6 +564,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("extend_constant", method!(RbExpr::extend_constant, 2))?;
     class.define_method("any", method!(RbExpr::any, 1))?;
     class.define_method("all", method!(RbExpr::all, 1))?;
+    class.define_method("is_empty", method!(RbExpr::is_empty, 1))?;
     class.define_method(
         "struct_field_by_name",
         method!(RbExpr::struct_field_by_name, 1),
@@ -590,7 +588,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("exp", method!(RbExpr::exp, 0))?;
     class.define_method("entropy", method!(RbExpr::entropy, 2))?;
     class.define_method("_hash", method!(RbExpr::hash, 4))?;
-    class.define_method("set_sorted_flag", method!(RbExpr::set_sorted_flag, 1))?;
+    class.define_method("set_sorted_flag", method!(RbExpr::set_sorted_flag, 2))?;
     class.define_method("replace", method!(RbExpr::replace, 2))?;
     class.define_method("replace_strict", method!(RbExpr::replace_strict, 4))?;
     class.define_method("hist", method!(RbExpr::hist, 4))?;
@@ -764,6 +762,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(functions::io::read_parquet_schema, 1),
     )?;
     class.define_singleton_method("collect_all", function!(functions::lazy::collect_all, 3))?;
+    class.define_singleton_method("explain_all", function!(functions::lazy::explain_all, 2))?;
     class.define_singleton_method(
         "collect_all_lazy",
         function!(functions::lazy::collect_all_lazy, 2),
@@ -780,6 +779,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method("time_range", function!(functions::range::time_range, 4))?;
     class.define_singleton_method("time_ranges", function!(functions::range::time_ranges, 4))?;
+    class.define_singleton_method("linear_space", function!(functions::range::linear_space, 4))?;
     class.define_singleton_method(
         "linear_spaces",
         function!(functions::range::linear_spaces, 5),
@@ -796,18 +796,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "thread_pool_size",
         function!(functions::meta::thread_pool_size, 0),
     )?;
-    class.define_singleton_method(
-        "enable_string_cache",
-        function!(functions::string_cache::enable_string_cache, 0),
-    )?;
-    class.define_singleton_method(
-        "disable_string_cache",
-        function!(functions::string_cache::disable_string_cache, 0),
-    )?;
-    class.define_singleton_method(
-        "using_string_cache",
-        function!(functions::string_cache::using_string_cache, 0),
-    )?;
     class.define_singleton_method(
         "set_float_fmt",
         function!(functions::meta::set_float_fmt, 1),
@@ -904,6 +892,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(RbLazyFrame::new_from_parquet, 6),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 3))?;
+    class.define_singleton_method(
+        "new_from_scan_lines",
+        function!(RbLazyFrame::new_from_scan_lines, 3),
+    )?;
     class.define_method("describe_plan", method!(RbLazyFrame::describe_plan, 0))?;
     class.define_method(
         "describe_optimized_plan",
@@ -938,6 +930,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 6))?;
     class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, -1))?;
     class.define_method("sink_ndjson", method!(RbLazyFrame::sink_ndjson, 5))?;
+    class.define_method("sink_batches", method!(RbLazyFrame::sink_batches, 3))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
     class.define_method("remove", method!(RbLazyFrame::remove, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
@@ -951,12 +944,18 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 14))?;
     class.define_method("join", method!(RbLazyFrame::join, 11))?;
     class.define_method("join_where", method!(RbLazyFrame::join_where, 3))?;
+    class.define_method("gather", method!(RbLazyFrame::gather, 2))?;
     class.define_method("with_column", method!(RbLazyFrame::with_column, 1))?;
     class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
     class.define_method(
         "with_columns_seq",
         method!(RbLazyFrame::with_columns_seq, 1),
     )?;
+    class.define_method("match_to_schema", method!(RbLazyFrame::match_to_schema, 7))?;
+    class.define_method(
+        "pipe_with_schema",
+        method!(RbLazyFrame::pipe_with_schema, 1),
+    )?;
     class.define_method("rename", method!(RbLazyFrame::rename, 3))?;
     class.define_method("reverse", method!(RbLazyFrame::reverse, 0))?;
     class.define_method("shift", method!(RbLazyFrame::shift, 2))?;
@@ -976,7 +975,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("drop_nulls", method!(RbLazyFrame::drop_nulls, 1))?;
     class.define_method("slice", method!(RbLazyFrame::slice, 2))?;
     class.define_method("tail", method!(RbLazyFrame::tail, 1))?;
-    class.define_method("pivot", method!(RbLazyFrame::pivot, 7))?;
+    class.define_method("pivot", method!(RbLazyFrame::pivot, 8))?;
     class.define_method("unpivot", method!(RbLazyFrame::unpivot, 4))?;
     class.define_method("with_row_index", method!(RbLazyFrame::with_row_index, 2))?;
     class.define_method("map_batches", method!(RbLazyFrame::map_batches, 7))?;
@@ -987,7 +986,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("collect_schema", method!(RbLazyFrame::collect_schema, 0))?;
     class.define_method("unnest", method!(RbLazyFrame::unnest, 2))?;
     class.define_method("count", method!(RbLazyFrame::count, 0))?;
-    class.define_method("merge_sorted", method!(RbLazyFrame::merge_sorted, 2))?;
+    class.define_method("merge_sorted", method!(RbLazyFrame::merge_sorted, 3))?;
     class.define_method("hint_sorted", method!(RbLazyFrame::hint_sorted, 3))?;
     class.define_method(
         "collect_concurrently",
@@ -996,6 +995,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
 
     let class = module.define_class("RbCollectBatches", ruby.class_object())?;
     class.define_method("next", method!(RbCollectBatches::next, 0))?;
+    class.define_method(
+        "arrow_c_stream",
+        method!(RbCollectBatches::__arrow_c_stream__, 0),
+    )?;
 
     let class = module.define_class("RbInProcessQuery", ruby.class_object())?;
     class.define_method("cancel", method!(RbInProcessQuery::cancel, 0))?;
@@ -1040,7 +1043,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_null", function!(RbSeries::new_null, 3))?;
     class.define_singleton_method("new_object", function!(RbSeries::new_object, 3))?;
     class.define_singleton_method("new_series_list", function!(RbSeries::new_series_list, 3))?;
-    class.define_singleton_method("new_array", function!(RbSeries::new_array, 5))?;
+    class.define_singleton_method("new_array", function!(RbSeries::new_array, 4))?;
     class.define_singleton_method("new_decimal", function!(RbSeries::new_decimal, 3))?;
     class.define_singleton_method(
         "from_arrow_c_stream",
@@ -1105,6 +1108,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("slice", method!(RbSeries::slice, 2))?;
     class.define_method("any", method!(RbSeries::any, 1))?;
     class.define_method("all", method!(RbSeries::all, 1))?;
+    class.define_method("is_empty", method!(RbSeries::is_empty, 1))?;
     class.define_method("arg_min", method!(RbSeries::arg_min, 0))?;
     class.define_method("arg_max", method!(RbSeries::arg_max, 0))?;
     class.define_method(
@@ -1336,10 +1340,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("register", method!(RbSQLContext::register, 2))?;
     class.define_method("unregister", method!(RbSQLContext::unregister, 1))?;
 
-    // string cache
-    let class = module.define_class("RbStringCacheHolder", ruby.class_object())?;
-    class.define_singleton_method("hold", function!(RbStringCacheHolder::hold, 0))?;
-
     // arrow array stream
     let class = module.define_class("ArrowArrayStream", ruby.class_object())?;
     class.define_method("to_i", method!(RbArrowArrayStream::to_i, 0))?;
@@ -1397,6 +1397,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("of_expr", function!(RbDataTypeExpr::of_expr, 1))?;
     class.define_singleton_method("self_dtype", function!(RbDataTypeExpr::self_dtype, 0))?;
     class.define_method("collect_dtype", method!(RbDataTypeExpr::collect_dtype, 1))?;
+    class.define_singleton_method(
+        "struct_with_fields",
+        function!(RbDataTypeExpr::struct_with_fields, 1),
+    )?;
 
     // selector
     let class = module.define_class("RbSelector", ruby.class_object())?;

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

@@ -4,7 +4,7 @@ use polars::prelude::*;
 use crate::expr::ToExprs;
 use crate::expr::datatype::RbDataTypeExpr;
 use crate::ruby::ruby_udf::{RubyUdfExpression, RubyUdfExt};
-use crate::ruby::utils::to_pl_err;
+use crate::ruby::utils::{TryIntoValue, to_pl_err};
 use crate::{RbExpr, RbResult, RbSeries, Wrap};
 
 pub(crate) fn call_lambda_with_series(
@@ -17,7 +17,10 @@ pub(crate) fn call_lambda_with_series(
 
     // Set return_dtype in kwargs
     let dict = rb.hash_new();
-    let output_dtype = output_dtype.map(Wrap);
+    let output_dtype = output_dtype
+        .map(|v| Wrap(v).try_into_value_with(rb))
+        .transpose()
+        .map_err(to_pl_err)?;
     dict.aset(rb.sym_new("return_dtype"), output_dtype)
         .map_err(to_pl_err)?;
 

data/ext/polars/src/map/series.rs

@@ -4,6 +4,7 @@ use super::*;
 use crate::Wrap;
 use crate::error::RbPolarsErr;
 use crate::prelude::ObjectValue;
+use crate::ruby::utils::TryIntoValue;
 
 pub trait ApplyLambdaGeneric {
     fn apply_generic(&self, rb: &Ruby, lambda: Value, skip_nulls: bool) -> RbResult<Series>;
@@ -25,7 +26,7 @@ fn call_and_collect_anyvalues<T, I>(
     skip_nulls: bool,
 ) -> RbResult<Vec<AnyValue<'static>>>
 where
-    T: IntoValue,
+    T: TryIntoValue,
     I: Iterator<Item = Option<T>>,
 {
     let mut avs = Vec::with_capacity(len);
@@ -36,7 +37,7 @@ where
                 continue;
             }
             None => rb.qnil().into_value_with(rb),
-            Some(val) => val.into_value_with(rb),
+            Some(val) => val.try_into_value_with(rb)?,
         };
         let av: Option<Wrap<AnyValue>> = lambda.funcall("call", (arg,))?;
         avs.push(av.map(|w| w.0).unwrap_or(AnyValue::Null));
@@ -46,7 +47,7 @@ where
 
 impl ApplyLambdaGeneric for BooleanChunked {
     fn apply_generic(&self, rb: &Ruby, lambda: Value, skip_nulls: bool) -> RbResult<Series> {
-        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.into_iter(), skip_nulls)?;
+        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.iter(), skip_nulls)?;
         Ok(Series::from_any_values(self.name().clone(), &avs, true).map_err(RbPolarsErr::from)?)
     }
 
@@ -57,7 +58,7 @@ impl ApplyLambdaGeneric for BooleanChunked {
         datatype: &DataType,
         skip_nulls: bool,
     ) -> RbResult<Series> {
-        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.into_iter(), skip_nulls)?;
+        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.iter(), skip_nulls)?;
         Ok(
             Series::from_any_values_and_dtype(self.name().clone(), &avs, datatype, true)
                 .map_err(RbPolarsErr::from)?,
@@ -71,7 +72,7 @@ where
     T::Native: IntoValue + TryConvert,
 {
     fn apply_generic(&self, rb: &Ruby, lambda: Value, skip_nulls: bool) -> RbResult<Series> {
-        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.into_iter(), skip_nulls)?;
+        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.iter(), skip_nulls)?;
         Ok(Series::from_any_values(self.name().clone(), &avs, true).map_err(RbPolarsErr::from)?)
     }
 
@@ -82,7 +83,7 @@ where
         datatype: &DataType,
         skip_nulls: bool,
     ) -> RbResult<Series> {
-        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.into_iter(), skip_nulls)?;
+        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.iter(), skip_nulls)?;
         Ok(
             Series::from_any_values_and_dtype(self.name().clone(), &avs, datatype, true)
                 .map_err(RbPolarsErr::from)?,
@@ -92,7 +93,7 @@ where
 
 impl ApplyLambdaGeneric for StringChunked {
     fn apply_generic(&self, rb: &Ruby, lambda: Value, skip_nulls: bool) -> RbResult<Series> {
-        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.into_iter(), skip_nulls)?;
+        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.iter(), skip_nulls)?;
         Ok(Series::from_any_values(self.name().clone(), &avs, true).map_err(RbPolarsErr::from)?)
     }
 
@@ -103,7 +104,7 @@ impl ApplyLambdaGeneric for StringChunked {
         datatype: &DataType,
         skip_nulls: bool,
     ) -> RbResult<Series> {
-        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.into_iter(), skip_nulls)?;
+        let avs = call_and_collect_anyvalues(rb, lambda, self.len(), self.iter(), skip_nulls)?;
         Ok(
             Series::from_any_values_and_dtype(self.name().clone(), &avs, datatype, true)
                 .map_err(RbPolarsErr::from)?,
@@ -113,7 +114,7 @@ impl ApplyLambdaGeneric for StringChunked {
 
 impl ApplyLambdaGeneric for ListChunked {
     fn apply_generic(&self, rb: &Ruby, lambda: Value, skip_nulls: bool) -> RbResult<Series> {
-        let it = self.into_iter().map(|opt_s| opt_s.map(Wrap));
+        let it = self.series_iter().map(|opt_s| opt_s.map(Wrap));
         let avs = call_and_collect_anyvalues(rb, lambda, self.len(), it, skip_nulls)?;
         Ok(Series::from_any_values(self.name().clone(), &avs, true).map_err(RbPolarsErr::from)?)
     }
@@ -125,7 +126,7 @@ impl ApplyLambdaGeneric for ListChunked {
         datatype: &DataType,
         skip_nulls: bool,
     ) -> RbResult<Series> {
-        let it = self.into_iter().map(|opt_s| opt_s.map(Wrap));
+        let it = self.series_iter().map(|opt_s| opt_s.map(Wrap));
         let avs = call_and_collect_anyvalues(rb, lambda, self.len(), it, skip_nulls)?;
         Ok(
             Series::from_any_values_and_dtype(self.name().clone(), &avs, datatype, true)
@@ -136,7 +137,7 @@ impl ApplyLambdaGeneric for ListChunked {
 
 impl ApplyLambdaGeneric for ArrayChunked {
     fn apply_generic(&self, rb: &Ruby, lambda: Value, skip_nulls: bool) -> RbResult<Series> {
-        let it = self.into_iter().map(|opt_s| Some(RbSeries::new(opt_s?)));
+        let it = self.series_iter().map(|opt_s| Some(RbSeries::new(opt_s?)));
         let avs = call_and_collect_anyvalues(rb, lambda, self.len(), it, skip_nulls)?;
         Ok(Series::from_any_values(self.name().clone(), &avs, true).map_err(RbPolarsErr::from)?)
     }
@@ -148,7 +149,7 @@ impl ApplyLambdaGeneric for ArrayChunked {
         datatype: &DataType,
         skip_nulls: bool,
     ) -> RbResult<Series> {
-        let it = self.into_iter().map(|opt_s| Some(RbSeries::new(opt_s?)));
+        let it = self.series_iter().map(|opt_s| Some(RbSeries::new(opt_s?)));
         let avs = call_and_collect_anyvalues(rb, lambda, self.len(), it, skip_nulls)?;
         Ok(
             Series::from_any_values_and_dtype(self.name().clone(), &avs, datatype, true)
@@ -159,12 +160,12 @@ impl ApplyLambdaGeneric for ArrayChunked {
 
 impl ApplyLambdaGeneric for ObjectChunked<ObjectValue> {
     fn apply_generic(&self, rb: &Ruby, lambda: Value, skip_nulls: bool) -> RbResult<Series> {
-        // TODO improve into_iter
+        // TODO improve iter
         let avs = call_and_collect_anyvalues(
             rb,
             lambda,
             self.len(),
-            self.into_iter().map(|v| v.cloned()),
+            self.iter().map(|v| v.cloned()),
             skip_nulls,
         )?;
         Ok(Series::from_any_values(self.name().clone(), &avs, true).map_err(RbPolarsErr::from)?)
@@ -177,12 +178,12 @@ impl ApplyLambdaGeneric for ObjectChunked<ObjectValue> {
         datatype: &DataType,
         skip_nulls: bool,
     ) -> RbResult<Series> {
-        // TODO improve into_iter
+        // TODO improve iter
         let avs = call_and_collect_anyvalues(
             rb,
             lambda,
             self.len(),
-            self.into_iter().map(|v| v.cloned()),
+            self.iter().map(|v| v.cloned()),
             skip_nulls,
         )?;
         Ok(
@@ -223,7 +224,7 @@ impl ApplyLambdaGeneric for BinaryChunked {
             rb,
             lambda,
             self.len(),
-            self.into_iter().map(|v| v.map(|v2| rb.str_from_slice(v2))),
+            self.iter().map(|v| v.map(|v2| rb.str_from_slice(v2))),
             skip_nulls,
         )?;
         Ok(Series::from_any_values(self.name().clone(), &avs, true).map_err(RbPolarsErr::from)?)
@@ -240,7 +241,7 @@ impl ApplyLambdaGeneric for BinaryChunked {
             rb,
             lambda,
             self.len(),
-            self.into_iter().map(|v| v.map(|v2| rb.str_from_slice(v2))),
+            self.iter().map(|v| v.map(|v2| rb.str_from_slice(v2))),
             skip_nulls,
         )?;
         Ok(

data/ext/polars/src/on_startup.rs

@@ -5,6 +5,7 @@ use std::sync::OnceLock;
 
 use arrow::array::Array;
 use magnus::{IntoValue, Ruby, Value, prelude::*, value::Opaque};
+use polars::chunked_array::object::ObjectArray;
 use polars::prelude::*;
 use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
 use polars_core::chunked_array::object::registry;
@@ -23,7 +24,7 @@ use crate::ruby::gvl::GvlExt;
 use crate::ruby::ruby_convert_registry::{FromRubyConvertRegistry, RubyConvertRegistry};
 use crate::ruby::ruby_udf;
 use crate::ruby::thread::{is_non_ruby_thread, run_in_ruby_thread};
-use crate::ruby::utils::to_pl_err;
+use crate::ruby::utils::{TryIntoValue, to_pl_err};
 use crate::series::RbSeries;
 
 fn ruby_function_caller_series(
@@ -86,16 +87,23 @@ pub unsafe fn register_startup_deps(catch_keyboard_interrupt: bool) {
 
         let object_converter = Arc::new(|av: AnyValue| {
             let object = Ruby::attach(|rb| ObjectValue {
-                inner: Wrap(av).into_value_with(rb).into(),
+                inner: Wrap(av).try_into_value_with(rb).unwrap().into(),
             });
             Box::new(object) as Box<dyn Any>
         });
         let rbobject_converter = Arc::new(|av: AnyValue| {
-            let object = Ruby::attach(|rb| Wrap(av).into_value_with(rb));
+            let object = Ruby::attach(|rb| Wrap(av).try_into_value_with(rb).unwrap());
             Box::new(object) as Box<dyn Any>
         });
-        fn object_array_getter(_arr: &dyn Array, _idx: usize) -> Option<AnyValue<'_>> {
-            todo!();
+        fn object_array_getter(arr: &dyn Array, idx: usize) -> Option<AnyValue<'_>> {
+            let arr = arr
+                .as_any()
+                .downcast_ref::<ObjectArray<ObjectValue>>()
+                .unwrap();
+            arr.get(idx).map(|v| AnyValue::Object(v))
+        }
+        fn with_gil(f: &mut dyn FnMut()) {
+            Ruby::attach(|_| f())
         }
 
         crate::ruby::ruby_convert_registry::register_converters(RubyConvertRegistry {
@@ -168,7 +176,17 @@ pub unsafe fn register_startup_deps(catch_keyboard_interrupt: bool) {
                         .into_value_with(rb))
                     })
                 }),
-                schema: Arc::new(|_schema| Ruby::attach(|_rb| todo!())),
+                schema: Arc::new(|schema| {
+                    Ruby::attach(|rb| {
+                        Wrap(
+                            schema
+                                .downcast_ref::<polars_core::schema::Schema>()
+                                .unwrap()
+                                .clone(),
+                        )
+                        .try_into_value_with(rb)
+                    })
+                }),
             },
         });
 
@@ -180,6 +198,7 @@ pub unsafe fn register_startup_deps(catch_keyboard_interrupt: bool) {
             rbobject_converter,
             physical_dtype,
             Arc::new(object_array_getter),
+            Arc::new(with_gil),
         );
 
         // Register SERIES UDF.

data/ext/polars/src/ruby/numo.rs

@@ -40,14 +40,13 @@ where
 pub struct RbArray1<T>(T);
 
 impl<T: Element> RbArray1<T> {
-    pub fn from_iter<I>(values: I) -> RbResult<Value>
+    pub fn from_iter<I>(rb: &Ruby, values: I) -> RbResult<Value>
     where
         I: IntoIterator<Item = T>,
     {
-        let ruby = Ruby::get().unwrap();
-        ruby.class_object()
+        rb.class_object()
             .const_get::<_, RModule>("Numo")?
             .const_get::<_, RClass>(T::class_name())?
-            .funcall("cast", (ruby.ary_from_iter(values),))
+            .funcall("cast", (rb.ary_from_iter(values),))
     }
 }

data/ext/polars/src/ruby/plan_callback.rs

@@ -1,7 +1,4 @@
-use std::sync::Arc;
-
 use magnus::{Ruby, Value, value::Opaque, value::ReprValue};
-use polars_plan::dsl::SpecialEq;
 use polars_plan::prelude::PlanCallback;
 
 use crate::RbResult;
@@ -196,6 +193,6 @@ impl<Args: PlanCallbackArgs + Send + 'static, Out: PlanCallbackOut + Send + 'sta
             f(args, *udf.0)
         };
 
-        Self::Rust(SpecialEq::new(Arc::new(f) as _))
+        Self::new(f)
     }
 }

data/ext/polars/src/ruby/rb_modules.rs

@@ -1,12 +1,10 @@
 use magnus::{Module, RClass, Ruby, value::Lazy};
 
-static BIGDECIMAL: Lazy<RClass> =
-    Lazy::new(|rb| rb.class_object().const_get("BigDecimal").unwrap());
 static DATE: Lazy<RClass> = Lazy::new(|rb| rb.class_object().const_get("Date").unwrap());
 static DATETIME: Lazy<RClass> = Lazy::new(|rb| rb.class_object().const_get("DateTime").unwrap());
 
-pub(crate) fn bigdecimal(rb: &Ruby) -> RClass {
-    rb.get_inner(&BIGDECIMAL)
+pub(crate) fn bigdecimal(rb: &Ruby) -> Option<RClass> {
+    rb.class_object().const_get("BigDecimal").ok()
 }
 
 pub(crate) fn date(rb: &Ruby) -> RClass {

data/ext/polars/src/ruby/ruby_udf.rs

@@ -82,15 +82,13 @@ impl AnonymousColumnsUdf for RubyUdfExpression {
 
     fn deep_clone(self: Arc<Self>) -> Arc<dyn AnonymousColumnsUdf> {
         Arc::new(Self {
-            ruby_function: ArcValue::new(
-                Ruby::attach(|rb| {
-                    // TODO fix
-                    rb.get_inner(*self.ruby_function.0)
-                        .funcall::<_, _, Value>("dup", ())
-                        .map(Opaque::from)
-                })
-                .unwrap(),
-            ),
+            ruby_function: ArcValue::new(Ruby::attach(|rb| {
+                // TODO fix
+                rb.get_inner(*self.ruby_function.0)
+                    .funcall::<_, _, Value>("dup", ())
+                    .map(Opaque::from)
+                    .unwrap()
+            })),
             output_type: self.output_type.clone(),
             materialized_field: OnceLock::new(),
             is_elementwise: self.is_elementwise,

data/ext/polars/src/ruby/utils.rs

@@ -1,8 +1,9 @@
 use std::sync::Arc;
 
-use magnus::{Error, Ruby, Value, gc, value::Opaque};
+use magnus::{Error, IntoValue, Ruby, Value, gc, value::Opaque};
 use polars::error::PolarsError;
 
+use crate::RbResult;
 use crate::ruby::gvl::GvlExt;
 
 pub(crate) fn to_pl_err(e: Error) -> PolarsError {
@@ -26,3 +27,13 @@ impl Drop for ArcValue {
         Ruby::attach(|_| gc::unregister_address(&*self.0));
     }
 }
+
+pub trait TryIntoValue {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value>;
+}
+
+impl<T: IntoValue> TryIntoValue for T {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        Ok(self.into_value_with(ruby))
+    }
+}

data/ext/polars/src/series/aggregation.rs

@@ -3,11 +3,12 @@ use magnus::{IntoValue, Ruby, Value};
 use polars::prelude::*;
 
 use crate::prelude::*;
+use crate::ruby::utils::TryIntoValue;
 use crate::utils::EnterPolarsExt;
 use crate::{RbResult, RbSeries};
 
 fn scalar_to_rb(scalar: RbResult<Scalar>, rb: &Ruby) -> RbResult<Value> {
-    Ok(Wrap(scalar?.as_any_value()).into_value_with(rb))
+    Wrap(scalar?.as_any_value()).try_into_value_with(rb)
 }
 
 impl RbSeries {
@@ -35,6 +36,17 @@ impl RbSeries {
         })
     }
 
+    pub fn is_empty(rb: &Ruby, self_: &Self, ignore_nulls: bool) -> RbResult<bool> {
+        rb.enter_polars(|| {
+            let s = self_.series.read();
+            PolarsResult::Ok(if ignore_nulls {
+                s.is_full_null()
+            } else {
+                s.is_empty()
+            })
+        })
+    }
+
     pub fn arg_max(rb: &Ruby, self_: &Self) -> RbResult<Option<usize>> {
         rb.enter_polars_ok(|| self_.series.read().arg_max())
     }