polars-df 0.22.0 → 0.23.0

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

@@ -3,6 +3,7 @@ use magnus::{
     IntoValue, RArray, RHash, RString, Ruby, TryConvert, Value, prelude::*, r_hash::ForEach,
 };
 use polars::prelude::*;
+use polars_compute::decimal::{DEC128_MAX_PREC, DecimalFmtBuffer, dec128_fits};
 use polars_core::utils::any_values_to_supertype_and_n_dtypes;
 
 use super::datetime::datetime_to_rb_object;
@@ -30,6 +31,7 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::UInt16(v) => ruby.into_value(v),
         AnyValue::UInt32(v) => ruby.into_value(v),
         AnyValue::UInt64(v) => ruby.into_value(v),
+        AnyValue::UInt128(v) => ruby.into_value(v),
         AnyValue::Int8(v) => ruby.into_value(v),
         AnyValue::Int16(v) => ruby.into_value(v),
         AnyValue::Int32(v) => ruby.into_value(v),
@@ -74,9 +76,11 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         }
         AnyValue::Binary(v) => ruby.str_from_slice(v).as_value(),
         AnyValue::BinaryOwned(v) => ruby.str_from_slice(&v).as_value(),
-        AnyValue::Decimal(v, scale) => pl_utils()
-            .funcall("_to_ruby_decimal", (v.to_string(), -(scale as i32)))
-            .unwrap(),
+        AnyValue::Decimal(v, prec, scale) => {
+            let mut buf = DecimalFmtBuffer::new();
+            let s = buf.format_dec128(v, scale, false, false);
+            pl_utils().funcall("_to_ruby_decimal", (prec, s)).unwrap()
+        }
     }
 }
 
@@ -94,8 +98,12 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     fn get_int(ob: Value, strict: bool) -> RbResult<AnyValue<'static>> {
         if let Ok(v) = i64::try_convert(ob) {
             Ok(AnyValue::Int64(v))
+        } else if let Ok(v) = i128::try_convert(ob) {
+            Ok(AnyValue::Int128(v))
         } else if let Ok(v) = u64::try_convert(ob) {
             Ok(AnyValue::UInt64(v))
+        } else if let Ok(v) = u128::try_convert(ob) {
+            Ok(AnyValue::UInt128(v))
         } else if !strict {
             let f = f64::try_convert(ob)?;
             Ok(AnyValue::Float64(f))
@@ -206,14 +214,12 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
             match digits.parse::<i128>() {
                 Ok(mut v) => {
                     let scale = if exp > 0 {
-                        v = 10_i128
-                            .checked_pow(exp as u32)
-                            .and_then(|factor| v.checked_mul(factor))?;
+                        v = 10_i128.checked_pow(exp as u32)?.checked_mul(v)?;
                         0
                     } else {
                         (-exp) as usize
                     };
-                    Some((v, scale))
+                    dec128_fits(v, DEC128_MAX_PREC).then_some((v, scale))
                 }
                 Err(_) => None,
             }
@@ -229,7 +235,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
             // TODO better error
             v = v.checked_neg().unwrap();
         }
-        Ok(AnyValue::Decimal(v, scale))
+        Ok(AnyValue::Decimal(v, DEC128_MAX_PREC, scale))
     }
 
     let ruby = Ruby::get_with(ob);

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

@@ -1,5 +1,6 @@
 use magnus::{IntoValue, RString, Ruby, TryConvert, Value, prelude::*};
 use polars::prelude::*;
+use polars_compute::decimal::DecimalFmtBuffer;
 
 use super::{Wrap, get_rbseq, struct_dict};
 
@@ -129,11 +130,13 @@ impl IntoValue for Wrap<&DateChunked> {
 impl IntoValue for Wrap<&DecimalChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
         let utils = pl_utils();
-        let rb_scale = (-(self.0.scale() as i32)).into_value_with(ruby);
+        let rb_precision = self.0.precision().into_value_with(ruby);
+        let mut buf = DecimalFmtBuffer::new();
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| {
+                let s = buf.format_dec128(v, self.0.scale(), false, false);
                 utils
-                    .funcall::<_, _, Value>("_to_ruby_decimal", (v.to_string(), rb_scale))
+                    .funcall::<_, _, Value>("_to_ruby_decimal", (rb_precision, s))
                     .unwrap()
             })
         });

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

@@ -25,6 +25,7 @@ use polars::prelude::default_values::{
 use polars::prelude::deletion::DeletionFilesList;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
+use polars_compute::decimal::dec128_verify_prec_scale;
 use polars_core::schema::iceberg::IcebergSchema;
 use polars_core::utils::arrow::array::Array;
 use polars_core::utils::materialize_dyn_int;
@@ -174,6 +175,10 @@ impl IntoValue for Wrap<DataType> {
                 let class = pl.const_get::<_, Value>("UInt64").unwrap();
                 class.funcall("new", ()).unwrap()
             }
+            DataType::UInt128 => {
+                let class = pl.const_get::<_, Value>("UInt128").unwrap();
+                class.funcall("new", ()).unwrap()
+            }
             DataType::Float32 => {
                 let class = pl.const_get::<_, Value>("Float32").unwrap();
                 class.funcall("new", ()).unwrap()
@@ -350,7 +355,11 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Time" => DataType::Time,
                 "Polars::Datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
                 "Polars::Duration" => DataType::Duration(TimeUnit::Microseconds),
-                "Polars::Decimal" => DataType::Decimal(None, None),
+                "Polars::Decimal" => {
+                    return Err(RbTypeError::new_err(
+                        "Decimal without precision/scale set is not a valid Polars datatype",
+                    ));
+                }
                 "Polars::List" => DataType::List(Box::new(DataType::Null)),
                 "Polars::Array" => DataType::Array(Box::new(DataType::Null), 0),
                 "Polars::Struct" => DataType::Struct(vec![]),
@@ -415,7 +424,8 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Decimal" => {
                     let precision = ob.funcall("precision", ())?;
                     let scale = ob.funcall("scale", ())?;
-                    DataType::Decimal(precision, Some(scale))
+                    dec128_verify_prec_scale(precision, scale).map_err(to_rb_err)?;
+                    DataType::Decimal(precision, scale)
                 }
                 "Polars::List" => {
                     let inner: Value = ob.funcall("inner", ()).unwrap();
@@ -882,7 +892,7 @@ impl TryConvert for Wrap<Option<IpcCompression>> {
         let parsed = match String::try_convert(ob)?.as_str() {
             "uncompressed" => None,
             "lz4" => Some(IpcCompression::LZ4),
-            "zstd" => Some(IpcCompression::ZSTD),
+            "zstd" => Some(IpcCompression::ZSTD(Default::default())),
             v => {
                 return Err(RbValueError::new_err(format!(
                     "compression must be one of {{'uncompressed', 'lz4', 'zstd'}}, got {v}"
@@ -1091,21 +1101,6 @@ impl TryConvert for Wrap<UniqueKeepStrategy> {
     }
 }
 
-impl TryConvert for Wrap<IpcCompression> {
-    fn try_convert(ob: Value) -> RbResult<Self> {
-        let parsed = match String::try_convert(ob)?.as_str() {
-            "lz4" => IpcCompression::LZ4,
-            "zstd" => IpcCompression::ZSTD,
-            v => {
-                return Err(RbValueError::new_err(format!(
-                    "compression must be one of {{'lz4', 'zstd'}}, got {v}"
-                )));
-            }
-        };
-        Ok(Wrap(parsed))
-    }
-}
-
 impl TryConvert for Wrap<SearchSortedSide> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
@@ -1208,7 +1203,8 @@ 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)?;
+    let out = CloudOptions::from_untyped_config(CloudScheme::from_uri(uri).as_ref(), kv)
+        .map_err(RbPolarsErr::from)?;
     Ok(out)
 }
 
@@ -1307,6 +1303,17 @@ impl TryConvert for Wrap<CastColumnsPolicy> {
             }
         };
 
+        let categorical_to_string =
+            match &*ob.funcall::<_, _, String>("categorical_to_string", ())? {
+                "allow" => true,
+                "forbid" => false,
+                v => {
+                    return Err(RbValueError::new_err(format!(
+                        "unknown option for categorical_to_string: {v}"
+                    )));
+                }
+            };
+
         return Ok(Wrap(CastColumnsPolicy {
             integer_upcast,
             float_upcast,
@@ -1315,6 +1322,7 @@ impl TryConvert for Wrap<CastColumnsPolicy> {
             datetime_microseconds_downcast: false,
             datetime_convert_timezone,
             null_upcast: true,
+            categorical_to_string,
             missing_struct_fields,
             extra_struct_fields,
         }));

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

@@ -54,7 +54,7 @@ fn finish_from_rows(
     schema_overrides: Option<Schema>,
     infer_schema_length: Option<usize>,
 ) -> RbResult<RbDataFrame> {
-    let mut schema = if let Some(mut schema) = schema {
+    let schema = if let Some(mut schema) = schema {
         resolve_schema_overrides(&mut schema, schema_overrides);
         update_schema_from_rows(&mut schema, &rows, infer_schema_length)?;
         schema
@@ -62,11 +62,6 @@ fn finish_from_rows(
         rows_to_schema_supertypes(&rows, infer_schema_length).map_err(RbPolarsErr::from)?
     };
 
-    // TODO: Remove this step when Decimals are supported properly.
-    // Erasing the decimal precision/scale here will just require us to infer it again later.
-    // https://github.com/pola-rs/polars/issues/14427
-    erase_decimal_precision_scale(&mut schema);
-
     let df = DataFrame::from_rows_and_schema(&rows, &schema).map_err(RbPolarsErr::from)?;
     Ok(df.into())
 }
@@ -106,14 +101,6 @@ fn resolve_schema_overrides(schema: &mut Schema, schema_overrides: Option<Schema
     }
 }
 
-fn erase_decimal_precision_scale(schema: &mut Schema) {
-    for dtype in schema.iter_values_mut() {
-        if let DataType::Decimal(_, _) = dtype {
-            *dtype = DataType::Decimal(None, None)
-        }
-    }
-}
-
 fn columns_names_to_empty_schema<'a, I>(column_names: I) -> Schema
 where
     I: IntoIterator<Item = &'a str>,

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

@@ -552,11 +552,6 @@ impl RbDataFrame {
         s.into_series().into()
     }
 
-    pub fn unnest(&self, names: Vec<String>) -> RbResult<Self> {
-        let df = self.df.borrow().unnest(names).map_err(RbPolarsErr::from)?;
-        Ok(df.into())
-    }
-
     pub fn clear(&self) -> Self {
         self.df.borrow().clear().into()
     }

data/ext/polars/src/expr/datetime.rs

@@ -218,31 +218,39 @@ impl RbExpr {
         self.inner.clone().dt().timestamp(tu.0).into()
     }
 
-    pub fn dt_total_days(&self) -> Self {
-        self.inner.clone().dt().total_days().into()
+    pub fn dt_total_days(&self, fractional: bool) -> Self {
+        self.inner.clone().dt().total_days(fractional).into()
     }
 
-    pub fn dt_total_hours(&self) -> Self {
-        self.inner.clone().dt().total_hours().into()
+    pub fn dt_total_hours(&self, fractional: bool) -> Self {
+        self.inner.clone().dt().total_hours(fractional).into()
     }
 
-    pub fn dt_total_minutes(&self) -> Self {
-        self.inner.clone().dt().total_minutes().into()
+    pub fn dt_total_minutes(&self, fractional: bool) -> Self {
+        self.inner.clone().dt().total_minutes(fractional).into()
     }
 
-    pub fn dt_total_seconds(&self) -> Self {
-        self.inner.clone().dt().total_seconds().into()
+    pub fn dt_total_seconds(&self, fractional: bool) -> Self {
+        self.inner.clone().dt().total_seconds(fractional).into()
     }
 
-    pub fn dt_total_milliseconds(&self) -> Self {
-        self.inner.clone().dt().total_milliseconds().into()
+    pub fn dt_total_milliseconds(&self, fractional: bool) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .total_milliseconds(fractional)
+            .into()
     }
 
-    pub fn dt_total_microseconds(&self) -> Self {
-        self.inner.clone().dt().total_microseconds().into()
+    pub fn dt_total_microseconds(&self, fractional: bool) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .total_microseconds(fractional)
+            .into()
     }
 
-    pub fn dt_total_nanoseconds(&self) -> Self {
-        self.inner.clone().dt().total_nanoseconds().into()
+    pub fn dt_total_nanoseconds(&self, fractional: bool) -> Self {
+        self.inner.clone().dt().total_nanoseconds(fractional).into()
     }
 }

data/ext/polars/src/file.rs

@@ -145,13 +145,13 @@ impl Seek for RbFileLikeObject {
             SeekFrom::End(i) => (2, i),
         };
 
-        let new_position = Ruby::get()
-            .unwrap()
-            .get_inner(self.inner)
-            .funcall("seek", (offset, whence))
+        let inner = Ruby::get().unwrap().get_inner(self.inner);
+
+        inner
+            .funcall::<_, _, Value>("seek", (offset, whence))
             .map_err(rberr_to_io_err)?;
 
-        Ok(new_position)
+        inner.funcall("tell", ()).map_err(rberr_to_io_err)
     }
 }
 

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

@@ -5,7 +5,7 @@ use polars::prelude::default_values::DefaultFieldValues;
 use polars::prelude::deletion::DeletionFilesList;
 use polars::prelude::{
     CastColumnsPolicy, ColumnMapping, ExtraColumnsPolicy, MissingColumnsPolicy, PlSmallStr, Schema,
-    UnifiedScanArgs,
+    TableStatistics, UnifiedScanArgs,
 };
 use polars_io::{HiveOptions, RowIndex};
 use polars_utils::IdxSize;
@@ -24,6 +24,12 @@ impl TryConvert for RbScanOptions {
     }
 }
 
+impl TryConvert for Wrap<TableStatistics> {
+    fn try_convert(_ob: Value) -> RbResult<Self> {
+        todo!();
+    }
+}
+
 impl RbScanOptions {
     pub fn extract_unified_scan_args(
         &self,
@@ -38,6 +44,10 @@ impl RbScanOptions {
         let include_file_paths: Option<Wrap<PlSmallStr>> =
             self.0.funcall("include_file_paths", ())?;
         let glob: bool = self.0.funcall("glob", ())?;
+        let hidden_file_prefix: Option<Vec<String>> = self.0.funcall("hidden_file_prefix", ())?;
+        let column_mapping: Option<Wrap<ColumnMapping>> = self.0.funcall("column_mapping", ())?;
+        let default_values: Option<Wrap<DefaultFieldValues>> =
+            self.0.funcall("default_values", ())?;
         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", ())?;
@@ -48,9 +58,9 @@ impl RbScanOptions {
         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 default_values: Option<Wrap<DefaultFieldValues>> =
-            self.0.funcall("default_values", ())?;
+        let table_statistics: Option<Wrap<TableStatistics>> =
+            self.0.funcall("table_statistics", ())?;
+        let row_count: Option<(u64, u64)> = self.0.funcall("row_count", ())?;
 
         let cloud_options = storage_options;
 
@@ -89,7 +99,13 @@ impl RbScanOptions {
             rechunk,
             cache,
             glob,
+            hidden_file_prefix: hidden_file_prefix
+                .map(|x| x.into_iter().map(|x| (*x).into()).collect()),
             projection: None,
+            column_mapping: column_mapping.map(|x| x.0),
+            default_values: default_values
+                .map(|x| x.0)
+                .filter(|DefaultFieldValues::Iceberg(v)| !v.is_empty()),
             row_index,
             pre_slice: pre_slice.map(Slice::from),
             cast_columns_policy: cast_options.0,
@@ -97,10 +113,8 @@ impl RbScanOptions {
             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),
-            default_values: default_values
-                .map(|x| x.0)
-                .filter(|DefaultFieldValues::Iceberg(v)| !v.is_empty()),
+            table_statistics: table_statistics.map(|x| x.0),
+            row_count,
         };
 
         Ok(unified_scan_args)

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

@@ -1,5 +1,5 @@
 use magnus::{IntoValue, RArray, RHash, Ruby, TryConvert, Value, r_hash::ForEach, typed_data::Obj};
-use polars::io::{HiveOptions, RowIndex};
+use polars::io::RowIndex;
 use polars::lazy::frame::LazyFrame;
 use polars::prelude::*;
 use polars_plan::dsl::ScanSources;
@@ -18,7 +18,10 @@ use crate::{RbDataFrame, RbExpr, RbLazyFrame, RbLazyGroupBy, RbPolarsErr, RbResu
 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::Path(path) => (
+            Some(path.clone()),
+            ScanSources::Paths(FromIterator::from_iter([path])),
+        ),
         RubyScanSourceInput::File(file) => (None, ScanSources::Files([file].into())),
         RubyScanSourceInput::Buffer(buff) => (None, ScanSources::Buffers([buff].into())),
     })
@@ -180,48 +183,28 @@ impl RbLazyFrame {
         Ok(lf.into())
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn new_from_ipc(
-        source: Option<Value>,
         sources: Wrap<ScanSources>,
-        n_rows: Option<usize>,
-        cache: bool,
-        rechunk: bool,
-        row_index: Option<(String, IdxSize)>,
-        hive_partitioning: Option<bool>,
-        hive_schema: Option<Wrap<Schema>>,
-        try_parse_hive_dates: bool,
-        include_file_paths: Option<String>,
+        scan_options: RbScanOptions,
+        file_cache_ttl: Option<u64>,
     ) -> RbResult<Self> {
-        let row_index = row_index.map(|(name, offset)| RowIndex {
-            name: name.into(),
-            offset,
-        });
+        let options = IpcScanOptions;
 
-        let hive_options = HiveOptions {
-            enabled: hive_partitioning,
-            hive_start_idx: 0,
-            schema: hive_schema.map(|x| Arc::new(x.0)),
-            try_parse_dates: try_parse_hive_dates,
-        };
+        let sources = sources.0;
+        let first_path = sources.first_path().map(|p| p.into_owned());
 
-        let args = ScanArgsIpc {
-            n_rows,
-            cache,
-            rechunk,
-            row_index,
-            cloud_options: None,
-            hive_options,
-            include_file_paths: include_file_paths.map(|x| x.into()),
-        };
+        let mut unified_scan_args =
+            scan_options.extract_unified_scan_args(first_path.as_ref().map(|p| p.as_ref()))?;
 
-        let sources = sources.0;
-        let (_first_path, sources) = match source {
-            None => (sources.first_path().map(|p| p.into_owned()), sources),
-            Some(source) => rbobject_to_first_path_and_scan_sources(source)?,
-        };
+        if let Some(file_cache_ttl) = file_cache_ttl {
+            unified_scan_args
+                .cloud_options
+                .get_or_insert_default()
+                .file_cache_ttl = file_cache_ttl;
+        }
 
-        let lf = LazyFrame::scan_ipc_sources(sources, args).map_err(RbPolarsErr::from)?;
+        let lf = LazyFrame::scan_ipc_sources(sources, options, unified_scan_args)
+            .map_err(RbPolarsErr::from)?;
         Ok(lf.into())
     }
 
@@ -406,13 +389,13 @@ impl RbLazyFrame {
     pub fn sink_ipc(
         &self,
         target: SinkTarget,
-        compression: Option<Wrap<IpcCompression>>,
+        compression: Wrap<Option<IpcCompression>>,
         cloud_options: Option<Vec<(String, String)>>,
         retries: usize,
         sink_options: Wrap<SinkOptions>,
     ) -> RbResult<RbLazyFrame> {
         let options = IpcWriterOptions {
-            compression: compression.map(|c| c.0),
+            compression: compression.0,
             ..Default::default()
         };
 
@@ -949,11 +932,14 @@ impl RbLazyFrame {
         Ok(schema_dict)
     }
 
-    pub fn unnest(&self, columns: &RbSelector) -> Self {
+    pub fn unnest(&self, columns: &RbSelector, separator: Option<String>) -> Self {
         self.ldf
             .borrow()
             .clone()
-            .unnest(columns.inner.clone())
+            .unnest(
+                columns.inner.clone(),
+                separator.as_deref().map(PlSmallStr::from_str),
+            )
             .into()
     }
 

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

@@ -49,7 +49,6 @@ flag_getter_setters! {
     (SLICE_PUSHDOWN, get_slice_pushdown, set_slice_pushdown, clear=true)
     (COMM_SUBPLAN_ELIM, get_comm_subplan_elim, set_comm_subplan_elim, clear=true)
     (COMM_SUBEXPR_ELIM, get_comm_subexpr_elim, set_comm_subexpr_elim, clear=true)
-    (COLLAPSE_JOINS, get_collapse_joins, set_collapse_joins, clear=true)
     (CHECK_ORDER_OBSERVE, get_check_order_observe, set_check_order_observe, clear=true)
     (FAST_PROJECTION, get_fast_projection, set_fast_projection, clear=true)
 

data/ext/polars/src/lib.rs

@@ -156,7 +156,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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("unnest", method!(RbDataFrame::unnest, 1))?;
     class.define_method("clear", method!(RbDataFrame::clear, 0))?;
     class.define_method(
         "serialize_binary",
@@ -432,21 +431,21 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_millisecond", method!(RbExpr::dt_millisecond, 0))?;
     class.define_method("dt_microsecond", method!(RbExpr::dt_microsecond, 0))?;
     class.define_method("dt_nanosecond", method!(RbExpr::dt_nanosecond, 0))?;
-    class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 0))?;
-    class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 0))?;
-    class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 0))?;
-    class.define_method("dt_total_seconds", method!(RbExpr::dt_total_seconds, 0))?;
+    class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 1))?;
+    class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 1))?;
+    class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 1))?;
+    class.define_method("dt_total_seconds", method!(RbExpr::dt_total_seconds, 1))?;
     class.define_method(
         "dt_total_nanoseconds",
-        method!(RbExpr::dt_total_nanoseconds, 0),
+        method!(RbExpr::dt_total_nanoseconds, 1),
     )?;
     class.define_method(
         "dt_total_microseconds",
-        method!(RbExpr::dt_total_microseconds, 0),
+        method!(RbExpr::dt_total_microseconds, 1),
     )?;
     class.define_method(
         "dt_total_milliseconds",
-        method!(RbExpr::dt_total_milliseconds, 0),
+        method!(RbExpr::dt_total_milliseconds, 1),
     )?;
     class.define_method("dt_timestamp", method!(RbExpr::dt_timestamp, 1))?;
     class.define_method("dt_to_string", method!(RbExpr::dt_to_string, 1))?;
@@ -845,7 +844,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "new_from_parquet",
         function!(RbLazyFrame::new_from_parquet, 6),
     )?;
-    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 10))?;
+    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 3))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
     class.define_method("describe_plan", method!(RbLazyFrame::describe_plan, 0))?;
     class.define_method(
@@ -912,7 +911,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("cast_all", method!(RbLazyFrame::cast_all, 2))?;
     class.define_method("_clone", method!(RbLazyFrame::clone, 0))?;
     class.define_method("collect_schema", method!(RbLazyFrame::collect_schema, 0))?;
-    class.define_method("unnest", method!(RbLazyFrame::unnest, 1))?;
+    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))?;
 
@@ -927,6 +926,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_opt_u16", function!(RbSeries::new_opt_u16, 3))?;
     class.define_singleton_method("new_opt_u32", function!(RbSeries::new_opt_u32, 3))?;
     class.define_singleton_method("new_opt_u64", function!(RbSeries::new_opt_u64, 3))?;
+    class.define_singleton_method("new_opt_u128", function!(RbSeries::new_opt_u128, 3))?;
     class.define_singleton_method("new_opt_i8", function!(RbSeries::new_opt_i8, 3))?;
     class.define_singleton_method("new_opt_i16", function!(RbSeries::new_opt_i16, 3))?;
     class.define_singleton_method("new_opt_i32", function!(RbSeries::new_opt_i32, 3))?;
@@ -1402,14 +1402,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "set_comm_subexpr_elim",
         method!(RbOptFlags::set_comm_subexpr_elim, 1),
     )?;
-    class.define_method(
-        "get_collapse_joins",
-        method!(RbOptFlags::get_collapse_joins, 0),
-    )?;
-    class.define_method(
-        "set_collapse_joins",
-        method!(RbOptFlags::set_collapse_joins, 1),
-    )?;
     class.define_method(
         "get_check_order_observe",
         method!(RbOptFlags::get_check_order_observe, 0),

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

@@ -1,5 +1,6 @@
 use crate::error::RbPolarsErr;
 use crate::prelude::*;
+use crate::utils::to_rb_err;
 use crate::{RbResult, RbSeries};
 use magnus::{IntoValue, Ruby, Value};
 
@@ -58,12 +59,18 @@ impl RbSeries {
                     .cast(&DataType::UInt8)
                     .unwrap()
                     .mean_reduce()
+                    .map_err(to_rb_err)?
                     .as_any_value(),
             )
             .into_value_with(ruby)),
             // For non-numeric output types we require mean_reduce.
             dt if dt.is_temporal() => Ok(Wrap(
-                rb_self.series.borrow().mean_reduce().as_any_value(),
+                rb_self
+                    .series
+                    .borrow()
+                    .mean_reduce()
+                    .map_err(to_rb_err)?
+                    .as_any_value(),
             )
             .into_value_with(ruby)),
             _ => Ok(rb_self.series.borrow().mean().into_value_with(ruby)),

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

@@ -75,6 +75,7 @@ init_method_opt!(new_opt_u8, UInt8Type, u8);
 init_method_opt!(new_opt_u16, UInt16Type, u16);
 init_method_opt!(new_opt_u32, UInt32Type, u32);
 init_method_opt!(new_opt_u64, UInt64Type, u64);
+init_method_opt!(new_opt_u128, UInt128Type, u128);
 init_method_opt!(new_opt_i8, Int8Type, i8);
 init_method_opt!(new_opt_i16, Int16Type, i16);
 init_method_opt!(new_opt_i32, Int32Type, i32);

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

@@ -18,6 +18,7 @@ impl RbSeries {
                 DataType::UInt16 => ruby.ary_from_iter(series.u16().unwrap()).as_value(),
                 DataType::UInt32 => ruby.ary_from_iter(series.u32().unwrap()).as_value(),
                 DataType::UInt64 => ruby.ary_from_iter(series.u64().unwrap()).as_value(),
+                DataType::UInt128 => ruby.ary_from_iter(series.u128().unwrap()).as_value(),
                 DataType::Int8 => ruby.ary_from_iter(series.i8().unwrap()).as_value(),
                 DataType::Int16 => ruby.ary_from_iter(series.i16().unwrap()).as_value(),
                 DataType::Int32 => ruby.ary_from_iter(series.i32().unwrap()).as_value(),

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

@@ -340,7 +340,6 @@ impl RbSeries {
         let s = self.series.borrow();
         let ca = s.str().map_err(RbPolarsErr::from)?;
         ca.to_decimal_infer(inference_length)
-            .map(Series::from)
             .map(Into::into)
             .map_err(RbPolarsErr::from)
             .map_err(RbErr::from)