polars-df 0.9.0 → 0.11.0

data/ext/polars/src/lib.rs

@@ -5,6 +5,7 @@ mod error;
 mod expr;
 mod file;
 mod functions;
+mod interop;
 mod lazyframe;
 mod lazygroupby;
 mod map;
@@ -23,7 +24,7 @@ use error::{RbPolarsErr, RbTypeError, RbValueError};
 use expr::rb_exprs_to_exprs;
 use expr::RbExpr;
 use functions::string_cache::RbStringCacheHolder;
-use functions::whenthen::{RbThen, RbWhen};
+use functions::whenthen::{RbChainedThen, RbChainedWhen, RbThen, RbWhen};
 use lazyframe::RbLazyFrame;
 use lazygroupby::RbLazyGroupBy;
 use magnus::{define_module, function, method, prelude::*, Error, Ruby};
@@ -59,22 +60,27 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
     class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 9))?;
     class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
+    class.define_singleton_method("read_ipc_stream", function!(RbDataFrame::read_ipc_stream, 6))?;
     class.define_singleton_method("read_avro", function!(RbDataFrame::read_avro, 4))?;
-    class.define_singleton_method("read_rows", function!(RbDataFrame::read_rows, 3))?;
-    class.define_singleton_method("read_hashes", function!(RbDataFrame::read_hashes, 4))?;
-    class.define_singleton_method("read_hash", function!(RbDataFrame::read_hash, 1))?;
+    class.define_singleton_method("from_rows", function!(RbDataFrame::from_rows, 3))?;
+    class.define_singleton_method("from_hashes", function!(RbDataFrame::from_hashes, 5))?;
     class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 1))?;
     class.define_singleton_method("read_ndjson", function!(RbDataFrame::read_ndjson, 1))?;
     class.define_method("estimated_size", method!(RbDataFrame::estimated_size, 0))?;
+    class.define_method("dtype_strings", method!(RbDataFrame::dtype_strings, 0))?;
     class.define_method("write_avro", method!(RbDataFrame::write_avro, 2))?;
     class.define_method("write_json", method!(RbDataFrame::write_json, 3))?;
     class.define_method("write_ndjson", method!(RbDataFrame::write_ndjson, 1))?;
     class.define_method("write_csv", method!(RbDataFrame::write_csv, 10))?;
     class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 2))?;
+    class.define_method(
+        "write_ipc_stream",
+        method!(RbDataFrame::write_ipc_stream, 2),
+    )?;
     class.define_method("row_tuple", method!(RbDataFrame::row_tuple, 1))?;
     class.define_method("row_tuples", method!(RbDataFrame::row_tuples, 0))?;
     class.define_method("to_numo", method!(RbDataFrame::to_numo, 0))?;
-    class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 5))?;
+    class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 6))?;
     class.define_method("add", method!(RbDataFrame::add, 1))?;
     class.define_method("sub", method!(RbDataFrame::sub, 1))?;
     class.define_method("div", method!(RbDataFrame::div, 1))?;
@@ -88,7 +94,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sample_n", method!(RbDataFrame::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbDataFrame::sample_frac, 4))?;
     class.define_method("rechunk", method!(RbDataFrame::rechunk, 0))?;
-    class.define_method("to_s", method!(RbDataFrame::to_s, 0))?;
+    class.define_method("to_s", method!(RbDataFrame::as_str, 0))?;
     class.define_method("get_columns", method!(RbDataFrame::get_columns, 0))?;
     class.define_method("columns", method!(RbDataFrame::columns, 0))?;
     class.define_method(
@@ -106,8 +112,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("vstack_mut", method!(RbDataFrame::vstack_mut, 1))?;
     class.define_method("vstack", method!(RbDataFrame::vstack, 1))?;
     class.define_method("drop_in_place", method!(RbDataFrame::drop_in_place, 1))?;
-    class.define_method("drop_nulls", method!(RbDataFrame::drop_nulls, 1))?;
-    class.define_method("drop", method!(RbDataFrame::drop, 1))?;
     class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
     class.define_method(
         "get_column_index",
@@ -115,7 +119,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("get_column", method!(RbDataFrame::get_column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
-    class.define_method("take", method!(RbDataFrame::take, 1))?;
+    class.define_method("take", method!(RbDataFrame::gather, 1))?;
     class.define_method(
         "take_with_series",
         method!(RbDataFrame::take_with_series, 1),
@@ -134,7 +138,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
-    class.define_method("shift", method!(RbDataFrame::shift, 1))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
     class.define_method("mean_horizontal", method!(RbDataFrame::mean_horizontal, 1))?;
     class.define_method("max_horizontal", method!(RbDataFrame::max_horizontal, 0))?;
@@ -142,7 +145,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sum_horizontal", method!(RbDataFrame::sum_horizontal, 1))?;
     class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
-    class.define_method("apply", method!(RbDataFrame::apply, 3))?;
+    class.define_method("map_rows", method!(RbDataFrame::map_rows, 3))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
     class.define_method("hash_rows", method!(RbDataFrame::hash_rows, 4))?;
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
@@ -205,15 +208,15 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("cast", method!(RbExpr::cast, 2))?;
     class.define_method("sort_with", method!(RbExpr::sort_with, 2))?;
     class.define_method("arg_sort", method!(RbExpr::arg_sort, 2))?;
-    class.define_method("top_k", method!(RbExpr::top_k, 1))?;
-    class.define_method("bottom_k", method!(RbExpr::bottom_k, 1))?;
+    class.define_method("top_k", method!(RbExpr::top_k, 3))?;
+    class.define_method("bottom_k", method!(RbExpr::bottom_k, 3))?;
     class.define_method("peak_min", method!(RbExpr::peak_min, 0))?;
     class.define_method("peak_max", method!(RbExpr::peak_max, 0))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
     class.define_method("search_sorted", method!(RbExpr::search_sorted, 2))?;
     class.define_method("gather", method!(RbExpr::gather, 1))?;
-    class.define_method("sort_by", method!(RbExpr::sort_by, 2))?;
+    class.define_method("sort_by", method!(RbExpr::sort_by, 5))?;
     class.define_method("backward_fill", method!(RbExpr::backward_fill, 1))?;
     class.define_method("forward_fill", method!(RbExpr::forward_fill, 1))?;
     class.define_method("shift", method!(RbExpr::shift, 2))?;
@@ -312,7 +315,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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, 1))?;
+    class.define_method("arr_get", method!(RbExpr::arr_get, 2))?;
     class.define_method("arr_join", method!(RbExpr::arr_join, 2))?;
     class.define_method("arr_contains", method!(RbExpr::arr_contains, 1))?;
     class.define_method("arr_count_matches", method!(RbExpr::arr_count_matches, 1))?;
@@ -406,7 +409,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_cast_time_unit", method!(RbExpr::dt_cast_time_unit, 1))?;
     class.define_method(
         "dt_replace_time_zone",
-        method!(RbExpr::dt_replace_time_zone, 2),
+        method!(RbExpr::dt_replace_time_zone, 3),
     )?;
     class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 2))?;
     class.define_method("dt_month_start", method!(RbExpr::dt_month_start, 0))?;
@@ -415,20 +418,31 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_dst_offset", method!(RbExpr::dt_dst_offset, 0))?;
     class.define_method("dt_round", method!(RbExpr::dt_round, 2))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
-    class.define_method("map", method!(RbExpr::map, 3))?;
+    class.define_method("map_batches", method!(RbExpr::map_batches, 4))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
     class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
     class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
-    class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 6))?;
-    class.define_method("rolling_min", method!(RbExpr::rolling_min, 6))?;
-    class.define_method("rolling_max", method!(RbExpr::rolling_max, 6))?;
-    class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 6))?;
-    class.define_method("rolling_std", method!(RbExpr::rolling_std, 8))?;
-    class.define_method("rolling_var", method!(RbExpr::rolling_var, 8))?;
-    class.define_method("rolling_median", method!(RbExpr::rolling_median, 7))?;
-    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 9))?;
+    class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 4))?;
+    class.define_method("rolling_sum_by", method!(RbExpr::rolling_sum_by, 4))?;
+    class.define_method("rolling_min", method!(RbExpr::rolling_min, 4))?;
+    class.define_method("rolling_min_by", method!(RbExpr::rolling_min_by, 4))?;
+    class.define_method("rolling_max", method!(RbExpr::rolling_max, 4))?;
+    class.define_method("rolling_max_by", method!(RbExpr::rolling_max_by, 4))?;
+    class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 4))?;
+    class.define_method("rolling_mean_by", method!(RbExpr::rolling_mean_by, 4))?;
+    class.define_method("rolling_std", method!(RbExpr::rolling_std, 5))?;
+    class.define_method("rolling_std_by", method!(RbExpr::rolling_std_by, 5))?;
+    class.define_method("rolling_var", method!(RbExpr::rolling_var, 5))?;
+    class.define_method("rolling_var_by", method!(RbExpr::rolling_var_by, 5))?;
+    class.define_method("rolling_median", method!(RbExpr::rolling_median, 4))?;
+    class.define_method("rolling_median_by", method!(RbExpr::rolling_median_by, 4))?;
+    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 6))?;
+    class.define_method(
+        "rolling_quantile_by",
+        method!(RbExpr::rolling_quantile_by, 6),
+    )?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
@@ -448,7 +462,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_sort", method!(RbExpr::list_sort, 1))?;
     class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
     class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
-    class.define_method("list_get", method!(RbExpr::list_get, 1))?;
+    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))?;
@@ -554,7 +568,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("arctan2d", function!(functions::lazy::arctan2d, 2))?;
     class.define_singleton_method("rolling_corr", function!(functions::lazy::rolling_corr, 5))?;
     class.define_singleton_method("rolling_cov", function!(functions::lazy::rolling_cov, 5))?;
-    class.define_singleton_method("arg_sort_by", function!(functions::lazy::arg_sort_by, 2))?;
+    class.define_singleton_method("arg_sort_by", function!(functions::lazy::arg_sort_by, 5))?;
     class.define_singleton_method("when", function!(functions::whenthen::when, 1))?;
     class.define_singleton_method("concat_str", function!(functions::lazy::concat_str, 3))?;
     class.define_singleton_method("concat_list", function!(functions::lazy::concat_list, 1))?;
@@ -611,6 +625,17 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method("collect_all", function!(functions::lazy::collect_all, 1))?;
     class.define_singleton_method("date_range", function!(functions::range::date_range, 6))?;
+    class.define_singleton_method("date_ranges", function!(functions::range::date_ranges, 6))?;
+    class.define_singleton_method(
+        "datetime_range",
+        function!(functions::range::datetime_range, 6),
+    )?;
+    class.define_singleton_method(
+        "datetime_ranges",
+        function!(functions::range::datetime_ranges, 6),
+    )?;
+    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(
         "dtype_str_repr",
         function!(functions::misc::dtype_str_repr, 1),
@@ -689,7 +714,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, 9),
+        function!(RbLazyFrame::new_from_parquet, 12),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -702,8 +727,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "optimization_toggle",
         method!(RbLazyFrame::optimization_toggle, 9),
     )?;
-    class.define_method("sort", method!(RbLazyFrame::sort, 4))?;
-    class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 4))?;
+    class.define_method("sort", method!(RbLazyFrame::sort, 5))?;
+    class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 5))?;
     class.define_method("cache", method!(RbLazyFrame::cache, 0))?;
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
     class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 7))?;
@@ -835,7 +860,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("mul", method!(RbSeries::mul, 1))?;
     class.define_method("div", method!(RbSeries::div, 1))?;
     class.define_method("rem", method!(RbSeries::rem, 1))?;
-    class.define_method("sort", method!(RbSeries::sort, 2))?;
+    class.define_method("sort", method!(RbSeries::sort, 3))?;
     class.define_method("value_counts", method!(RbSeries::value_counts, 1))?;
     class.define_method("any", method!(RbSeries::any, 1))?;
     class.define_method("all", method!(RbSeries::all, 1))?;
@@ -1032,11 +1057,20 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     // extra
     class.define_method("extend_constant", method!(RbSeries::extend_constant, 2))?;
 
+    // when then
     let class = module.define_class("RbWhen", ruby.class_object())?;
-    class.define_method("_then", method!(RbWhen::then, 1))?;
+    class.define_method("then", method!(RbWhen::then, 1))?;
+
+    let class = module.define_class("RbThen", ruby.class_object())?;
+    class.define_method("when", method!(RbThen::when, 1))?;
+    class.define_method("otherwise", method!(RbThen::otherwise, 1))?;
+
+    let class = module.define_class("RbChainedWhen", ruby.class_object())?;
+    class.define_method("then", method!(RbChainedWhen::then, 1))?;
 
-    let class = module.define_class("RbWhenThen", ruby.class_object())?;
-    class.define_method("otherwise", method!(RbThen::overwise, 1))?;
+    let class = module.define_class("RbChainedThen", ruby.class_object())?;
+    class.define_method("when", method!(RbChainedThen::when, 1))?;
+    class.define_method("otherwise", method!(RbChainedThen::otherwise, 1))?;
 
     // sql
     let class = module.define_class("RbSQLContext", ruby.class_object())?;

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

@@ -265,9 +265,9 @@ pub fn apply_lambda_with_rows_output<'a>(
                         // to the row. Before we mutate the row buf again, the reference is dropped.
                         // we only cannot prove it to the compiler.
                         // we still do this because it saves a Vec allocation in a hot loop.
-                        unsafe { &*ptr }
+                        Ok(unsafe { &*ptr })
                     }
-                    None => &null_row,
+                    None => Ok(&null_row),
                 }
             }
             Err(e) => panic!("ruby function failed {}", e),
@@ -277,22 +277,30 @@ pub fn apply_lambda_with_rows_output<'a>(
     // first rows for schema inference
     let mut buf = Vec::with_capacity(inference_size);
     buf.push(first_value);
-    buf.extend((&mut row_iter).take(inference_size).cloned());
-    let schema = rows_to_schema_first_non_null(&buf, Some(50));
+    for v in (&mut row_iter).take(inference_size) {
+        buf.push(v?.clone());
+    }
+
+    let schema = rows_to_schema_first_non_null(&buf, Some(50))?;
 
     if init_null_count > 0 {
         // Safety: we know the iterators size
         let iter = unsafe {
             (0..init_null_count)
-                .map(|_| &null_row)
-                .chain(buf.iter())
+                .map(|_| Ok(&null_row))
+                .chain(buf.iter().map(Ok))
                 .chain(row_iter)
                 .trust_my_length(df.height())
         };
-        DataFrame::from_rows_iter_and_schema(iter, &schema)
+        DataFrame::try_from_rows_iter_and_schema(iter, &schema)
     } else {
         // Safety: we know the iterators size
-        let iter = unsafe { buf.iter().chain(row_iter).trust_my_length(df.height()) };
-        DataFrame::from_rows_iter_and_schema(iter, &schema)
+        let iter = unsafe {
+            buf.iter()
+                .map(Ok)
+                .chain(row_iter)
+                .trust_my_length(df.height())
+        };
+        DataFrame::try_from_rows_iter_and_schema(iter, &schema)
     }
 }

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

@@ -8,31 +8,11 @@ pub fn binary_lambda(_lambda: Value, _a: Series, _b: Series) -> PolarsResult<Opt
 }
 
 pub fn map_single(
-    rbexpr: &RbExpr,
+    _rbexpr: &RbExpr,
     _lambda: Value,
-    output_type: Option<Wrap<DataType>>,
-    agg_list: bool,
+    _output_type: Option<Wrap<DataType>>,
+    _agg_list: bool,
+    _is_elementwise: bool,
 ) -> RbExpr {
-    let output_type = output_type.map(|wrap| wrap.0);
-
-    let output_type2 = output_type.clone();
-    let function = move |_s: Series| {
-        let _output_type = output_type2.clone().unwrap_or(DataType::Unknown);
-
-        todo!();
-    };
-
-    let output_map = GetOutput::map_field(move |fld| match output_type {
-        Some(ref dt) => Field::new(fld.name(), dt.clone()),
-        None => {
-            let mut fld = fld.clone();
-            fld.coerce(DataType::Unknown);
-            fld
-        }
-    });
-    if agg_list {
-        rbexpr.clone().inner.map_list(function, output_map).into()
-    } else {
-        rbexpr.clone().inner.map(function, output_map).into()
-    }
+    todo!();
 }

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

@@ -33,7 +33,12 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
             .apply_lambda_with_utf8_out_type(lambda, null_count, Some(first_value.as_str()))
             .map(|ca| ca.into_series().into())
     } else if out.respond_to("_s", true)? {
-        todo!()
+        let rb_rbseries: &RbSeries = out.funcall("_s", ()).unwrap();
+        let series = rb_rbseries.series.borrow();
+        let dt = series.dtype();
+        applyer
+            .apply_lambda_with_list_out_type(lambda, null_count, &series, dt)
+            .map(|ca| ca.into_series().into())
     } else if out.is_kind_of(class::array()) {
         todo!()
     } else if out.is_kind_of(class::hash()) {
@@ -66,6 +71,7 @@ pub trait ApplyLambda<'a> {
     fn apply_lambda_unknown(&'a self, _lambda: Value) -> RbResult<RbSeries>;
 
     /// Apply a lambda that doesn't change output types
+    #[allow(dead_code)]
     fn apply_lambda(&'a self, _lambda: Value) -> RbResult<RbSeries>;
 
     // Used to store a struct type

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

@@ -1,6 +1,6 @@
 use crate::error::RbPolarsErr;
 use crate::prelude::*;
-use crate::{RbResult, RbSeries, RbValueError};
+use crate::{RbResult, RbSeries};
 use magnus::{IntoValue, Value};
 
 impl RbSeries {
@@ -36,31 +36,52 @@ impl RbSeries {
         Ok(Wrap(
             self.series
                 .borrow()
-                .max_as_series()
+                .max_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }
 
-    pub fn mean(&self) -> Option<f64> {
+    pub fn mean(&self) -> RbResult<Value> {
         match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.mean()
+            DataType::Boolean => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .cast(&DataType::UInt8)
+                    .unwrap()
+                    .mean_reduce()
+                    .as_any_value(),
+            )
+            .into_value()),
+            DataType::Datetime(_, _) | DataType::Duration(_) | DataType::Time => {
+                Ok(Wrap(self.series.borrow().mean_reduce().as_any_value()).into_value())
             }
-            _ => self.series.borrow().mean(),
+            _ => Ok(self.series.borrow().mean().into_value()),
         }
     }
 
-    pub fn median(&self) -> Option<f64> {
+    pub fn median(&self) -> RbResult<Value> {
         match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.median()
-            }
-            _ => self.series.borrow().median(),
+            DataType::Boolean => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .cast(&DataType::UInt8)
+                    .unwrap()
+                    .median_reduce()
+                    .map_err(RbPolarsErr::from)?
+                    .as_any_value(),
+            )
+            .into_value()),
+            DataType::Datetime(_, _) | DataType::Duration(_) | DataType::Time => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .median_reduce()
+                    .map_err(RbPolarsErr::from)?
+                    .as_any_value(),
+            )
+            .into_value()),
+            _ => Ok(self.series.borrow().median().into_value()),
         }
     }
 
@@ -68,10 +89,9 @@ impl RbSeries {
         Ok(Wrap(
             self.series
                 .borrow()
-                .min_as_series()
+                .min_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }
@@ -81,25 +101,22 @@ impl RbSeries {
         quantile: f64,
         interpolation: Wrap<QuantileInterpolOptions>,
     ) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .quantile_as_series(quantile, interpolation.0)
-                .map_err(|_| RbValueError::new_err("invalid quantile".into()))?
-                .get(0)
-                .unwrap_or(AnyValue::Null),
-        )
-        .into_value())
+        let bind = self
+            .series
+            .borrow()
+            .quantile_reduce(quantile, interpolation.0);
+        let sc = bind.map_err(RbPolarsErr::from)?;
+
+        Ok(Wrap(sc.as_any_value()).into_value())
     }
 
     pub fn sum(&self) -> RbResult<Value> {
         Ok(Wrap(
             self.series
                 .borrow()
-                .sum_as_series()
+                .sum_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }