polars-df 0.15.0 → 0.26.0

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

@@ -1,101 +1,98 @@
-use magnus::encoding::{EncodingCapable, Index};
+use magnus::encoding::EncodingCapable;
 use magnus::{
-    class, prelude::*, r_hash::ForEach, IntoValue, RArray, RHash, RString, Ruby, TryConvert, Value,
+    IntoValue, RArray, RHash, RString, Ruby, Symbol, TryConvert, Value, prelude::*,
+    r_hash::ForEach, value::Opaque,
 };
+use num_traits::ToPrimitive;
+use polars::chunked_array::object::PolarsObjectSafe;
 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::{struct_dict, ObjectValue, Wrap};
+use super::datetime::datetime_to_rb_object;
+use super::{ObjectValue, Wrap, struct_dict};
 
-use crate::exceptions::RbOverflowError;
-use crate::rb_modules::utils;
-use crate::{RbErr, RbPolarsErr, RbResult, RbSeries};
+use crate::rb_modules::pl_utils;
+use crate::ruby::exceptions::RbOverflowError;
+use crate::ruby::utils::TryIntoValue;
+use crate::{RbErr, RbPolarsErr, RbResult, RbSeries, RbValueError};
 
-impl IntoValue for Wrap<AnyValue<'_>> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<AnyValue<'_>> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         any_value_into_rb_object(self.0, ruby)
     }
 }
 
-impl<'s> TryConvert for Wrap<AnyValue<'s>> {
+impl TryConvert for Wrap<AnyValue<'_>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        rb_object_to_any_value(ob, true).map(Wrap)
+        rb_object_to_any_value(ob, true, true).map(Wrap)
     }
 }
 
-pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
-    match av {
+pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> RbResult<Value> {
+    let rb_object = match av {
         AnyValue::UInt8(v) => ruby.into_value(v),
         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),
         AnyValue::Int64(v) => ruby.into_value(v),
+        AnyValue::Int128(v) => ruby.into_value(v),
+        AnyValue::Float16(v) => ruby.into_value(v.to_f32()),
         AnyValue::Float32(v) => ruby.into_value(v),
         AnyValue::Float64(v) => ruby.into_value(v),
         AnyValue::Null => ruby.qnil().as_value(),
         AnyValue::Boolean(v) => ruby.into_value(v),
         AnyValue::String(v) => ruby.into_value(v),
         AnyValue::StringOwned(v) => ruby.into_value(v.as_str()),
-        AnyValue::Categorical(idx, rev, arr) | AnyValue::Enum(idx, rev, arr) => {
-            let s = if arr.is_null() {
-                rev.get(idx)
-            } else {
-                unsafe { arr.deref_unchecked().value(idx as usize) }
-            };
-            s.into_value()
-        }
-        AnyValue::CategoricalOwned(idx, rev, arr) | AnyValue::EnumOwned(idx, rev, arr) => {
-            let s = if arr.is_null() {
-                rev.get(idx)
-            } else {
-                unsafe { arr.deref_unchecked().value(idx as usize) }
-            };
-            s.into_value()
-        }
-        AnyValue::Date(v) => utils().funcall("_to_ruby_date", (v,)).unwrap(),
+        AnyValue::Categorical(cat, map) | AnyValue::Enum(cat, map) => unsafe {
+            map.cat_to_str_unchecked(cat).into_value_with(ruby)
+        },
+        AnyValue::CategoricalOwned(cat, map) | AnyValue::EnumOwned(cat, map) => unsafe {
+            map.cat_to_str_unchecked(cat).into_value_with(ruby)
+        },
+        AnyValue::Date(v) => pl_utils(ruby).funcall("_to_ruby_date", (v,))?,
         AnyValue::Datetime(v, time_unit, time_zone) => {
-            datetime_to_rb_object(v, time_unit, time_zone)
+            datetime_to_rb_object(ruby, v, time_unit, time_zone)?
         }
         AnyValue::DatetimeOwned(v, time_unit, time_zone) => {
-            datetime_to_rb_object(v, time_unit, time_zone.as_ref().map(AsRef::as_ref))
+            datetime_to_rb_object(ruby, v, time_unit, time_zone.as_ref().map(AsRef::as_ref))?
         }
         AnyValue::Duration(v, time_unit) => {
             let time_unit = time_unit.to_ascii();
-            utils()
-                .funcall("_to_ruby_duration", (v, time_unit))
-                .unwrap()
+            pl_utils(ruby).funcall("_to_ruby_duration", (v, time_unit))?
         }
-        AnyValue::Time(v) => utils().funcall("_to_ruby_time", (v,)).unwrap(),
-        AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().into_value(),
-        ref av @ AnyValue::Struct(_, _, flds) => struct_dict(av._iter_struct_av(), flds),
-        AnyValue::StructOwned(payload) => struct_dict(payload.0.into_iter(), &payload.1),
+        AnyValue::Time(v) => pl_utils(ruby).funcall("_to_ruby_time", (v,))?,
+        AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::to_a(ruby, &RbSeries::new(v))?,
+        ref av @ AnyValue::Struct(_, _, flds) => struct_dict(ruby, av._iter_struct_av(), flds)?,
+        AnyValue::StructOwned(payload) => struct_dict(ruby, payload.0.into_iter(), &payload.1)?,
         AnyValue::Object(v) => {
             let object = v.as_any().downcast_ref::<ObjectValue>().unwrap();
-            object.to_value()
+            object.clone().into_value_with(ruby)
         }
         AnyValue::ObjectOwned(v) => {
             let object = v.0.as_any().downcast_ref::<ObjectValue>().unwrap();
-            object.to_value()
+            object.clone().into_value_with(ruby)
         }
-        AnyValue::Binary(v) => RString::from_slice(v).into_value(),
-        AnyValue::BinaryOwned(v) => RString::from_slice(&v).into_value(),
-        AnyValue::Decimal(v, scale) => utils()
-            .funcall("_to_ruby_decimal", (v.to_string(), -(scale as i32)))
-            .unwrap(),
-    }
-}
-
-fn datetime_to_rb_object(v: i64, tu: TimeUnit, tz: Option<&TimeZone>) -> Value {
-    let tu = tu.to_ascii();
-    utils()
-        .funcall("_to_ruby_datetime", (v, tu, tz.map(|v| v.to_string())))
-        .unwrap()
+        AnyValue::Binary(v) => ruby.str_from_slice(v).as_value(),
+        AnyValue::BinaryOwned(v) => ruby.str_from_slice(&v).as_value(),
+        AnyValue::Decimal(v, prec, scale) => {
+            let mut buf = DecimalFmtBuffer::new();
+            let s = buf.format_dec128(v, scale, false, false);
+            pl_utils(ruby).funcall("_to_ruby_decimal", (prec, s))?
+        }
+    };
+    Ok(rb_object)
 }
 
-pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<AnyValue<'s>> {
+pub(crate) fn rb_object_to_any_value<'s>(
+    ob: Value,
+    strict: bool,
+    allow_object: bool,
+) -> RbResult<AnyValue<'s>> {
     // Conversion functions.
     fn get_null(_ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
         Ok(AnyValue::Null)
@@ -109,8 +106,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))
@@ -126,8 +127,9 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     }
 
     fn get_str(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let v = RString::from_value(ob).unwrap();
-        if v.enc_get() == Index::utf8() {
+        let ruby = Ruby::get_with(ob);
+        let v = RString::try_convert(ob)?;
+        if v.enc_get() == ruby.utf8_encindex() {
             Ok(AnyValue::StringOwned(v.to_string()?.into()))
         } else {
             Ok(AnyValue::BinaryOwned(unsafe { v.as_slice() }.to_vec()))
@@ -135,7 +137,7 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     }
 
     fn get_list(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let v = RArray::from_value(ob).unwrap();
+        let v = RArray::try_convert(ob)?;
         if v.is_empty() {
             Ok(AnyValue::List(Series::new_empty(
                 PlSmallStr::EMPTY,
@@ -172,11 +174,16 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     }
 
     fn get_struct(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let dict = RHash::from_value(ob).unwrap();
+        let dict = RHash::try_convert(ob)?;
         let len = dict.len();
         let mut keys = Vec::with_capacity(len);
         let mut vals = Vec::with_capacity(len);
-        dict.foreach(|key: String, val: Wrap<AnyValue>| {
+        dict.foreach(|key: Value, val: Wrap<AnyValue>| {
+            let key = if let Some(s) = Symbol::from_value(key) {
+                s.name()?.to_string()
+            } else {
+                String::try_convert(key)?
+            };
             let val = val.0;
             let dtype = DataType::from(&val);
             keys.push(Field::new(key.into(), dtype));
@@ -186,6 +193,14 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
         Ok(AnyValue::StructOwned(Box::new((vals, keys))))
     }
 
+    fn get_object(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
+        // This is slow, but hey don't use objects.
+        let v = &ObjectValue {
+            inner: Opaque::from(ob),
+        };
+        Ok(AnyValue::ObjectOwned(OwnedObject(v.to_boxed())))
+    }
+
     fn get_date(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
         // convert to DateTime for UTC
         let v = ob
@@ -204,14 +219,8 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
         Ok(AnyValue::Datetime(v, TimeUnit::Nanoseconds, None))
     }
 
-    fn get_datetime(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let sec: i64 = ob.funcall("to_i", ())?;
-        let nsec: i64 = ob.funcall("nsec", ())?;
-        Ok(AnyValue::Datetime(
-            sec * 1_000_000_000 + nsec,
-            TimeUnit::Nanoseconds,
-            None,
-        ))
+    fn get_datetime(ob: Value, strict: bool) -> RbResult<AnyValue<'static>> {
+        get_time(ob.funcall("to_time", ())?, strict)
     }
 
     fn get_decimal(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
@@ -220,20 +229,18 @@ 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,
             }
         }
 
-        let (sign, digits, _, exp): (i8, String, i32, i32) = ob.funcall("split", ()).unwrap();
+        let (sign, digits, _, exp): (i8, String, i32, i32) = ob.funcall("split", ())?;
         let (mut v, scale) = abs_decimal_from_digits(digits, exp).ok_or_else(|| {
             RbErr::from(RbPolarsErr::Other(
                 "BigDecimal is too large to fit in Decimal128".into(),
@@ -243,35 +250,43 @@ 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);
     if ob.is_nil() {
         get_null(ob, strict)
-    } else if ob.is_kind_of(class::true_class()) || ob.is_kind_of(class::false_class()) {
+    } else if ob.is_kind_of(ruby.class_true_class()) || ob.is_kind_of(ruby.class_false_class()) {
         get_bool(ob, strict)
-    } else if ob.is_kind_of(class::integer()) {
+    } else if ob.is_kind_of(ruby.class_integer()) {
         get_int(ob, strict)
-    } else if ob.is_kind_of(class::float()) {
+    } else if ob.is_kind_of(ruby.class_float()) {
         get_float(ob, strict)
-    } else if ob.is_kind_of(class::string()) {
+    } else if ob.is_kind_of(ruby.class_string()) {
         get_str(ob, strict)
-    } else if ob.is_kind_of(class::array()) {
+    } else if ob.is_kind_of(ruby.class_array()) {
         get_list(ob, strict)
-    } else if ob.is_kind_of(class::hash()) {
+    } else if ob.is_kind_of(ruby.class_hash()) {
         get_struct(ob, strict)
     } else if ob.respond_to("_s", true)? {
         get_list_from_series(ob, strict)
     // call is_a? for ActiveSupport::TimeWithZone
-    } else if ob.funcall::<_, _, bool>("is_a?", (class::time(),))? {
+    } else if ob.funcall::<_, _, bool>("is_a?", (ruby.class_time(),))? {
         get_time(ob, strict)
-    } else if ob.is_kind_of(crate::rb_modules::datetime()) {
+    } else if ob.is_kind_of(crate::ruby::rb_modules::datetime(&ruby)) {
         get_datetime(ob, strict)
-    } else if ob.is_kind_of(crate::rb_modules::date()) {
+    } else if ob.is_kind_of(crate::ruby::rb_modules::date(&ruby)) {
         get_date(ob, strict)
-    } else if ob.is_kind_of(crate::rb_modules::bigdecimal()) {
+    } else if crate::ruby::rb_modules::bigdecimal(&ruby)
+        .map(|cls| ob.is_kind_of(cls))
+        .unwrap_or(false)
+    {
         get_decimal(ob, strict)
     } else {
-        Err(RbPolarsErr::Other(format!("object type not supported {:?}", ob)).into())
+        if allow_object {
+            get_object(ob, strict)
+        } else {
+            Err(RbValueError::new_err(format!("Cannot convert {ob}")))
+        }
     }
 }

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

@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use polars_dtype::categorical::Categories;
+
+#[magnus::wrap(class = "Polars::RbCategories")]
+#[repr(transparent)]
+#[derive(Clone)]
+pub struct RbCategories {
+    categories: Arc<Categories>,
+}
+
+impl RbCategories {
+    pub fn categories(&self) -> &Arc<Categories> {
+        &self.categories
+    }
+}
+
+impl RbCategories {
+    pub fn global_categories() -> Self {
+        Self {
+            categories: Categories::global(),
+        }
+    }
+}
+
+impl From<Arc<Categories>> for RbCategories {
+    fn from(categories: Arc<Categories>) -> Self {
+        Self { categories }
+    }
+}

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

@@ -1,10 +1,13 @@
-use magnus::{prelude::*, IntoValue, RArray, RString, Ruby, TryConvert, Value};
+use magnus::{IntoValue, RArray, RString, Ruby, TryConvert, Value, prelude::*};
 use polars::prelude::*;
+use polars_compute::decimal::DecimalFmtBuffer;
 
-use super::{get_rbseq, struct_dict, Wrap};
+use super::datetime::datetime_to_rb_object;
+use super::{Wrap, get_rbseq, struct_dict};
 
-use crate::rb_modules::utils;
 use crate::RbResult;
+use crate::rb_modules::pl_utils;
+use crate::ruby::utils::TryIntoValue;
 
 impl TryConvert for Wrap<StringChunked> {
     fn try_convert(obj: Value) -> RbResult<Self> {
@@ -39,100 +42,106 @@ impl TryConvert for Wrap<BinaryChunked> {
 }
 
 impl IntoValue for Wrap<&StringChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let iter = self.0.into_iter();
-        RArray::from_iter(iter).into_value()
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        let iter = self.0.iter();
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
 impl IntoValue for Wrap<&BinaryChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
+    fn into_value_with(self, ruby: &Ruby) -> Value {
         let iter = self
             .0
-            .into_iter()
-            .map(|opt_bytes| opt_bytes.map(RString::from_slice));
-        RArray::from_iter(iter).into_value()
+            .iter()
+            .map(|opt_bytes| opt_bytes.map(|v| ruby.str_from_slice(v)));
+        ruby.ary_from_iter(iter).as_value()
     }
 }
 
-impl IntoValue for Wrap<&StructChunked> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
+impl TryIntoValue for Wrap<&StructChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
         let s = self.0.clone().into_series();
         // todo! iterate its chunks and flatten.
         // make series::iter() accept a chunk index.
         let s = s.rechunk();
         let iter = s.iter().map(|av| match av {
-            AnyValue::Struct(_, _, flds) => struct_dict(av._iter_struct_av(), flds),
-            AnyValue::Null => ruby.qnil().as_value(),
+            AnyValue::Struct(_, _, flds) => struct_dict(ruby, av._iter_struct_av(), flds),
+            AnyValue::Null => Ok(ruby.qnil().as_value()),
             _ => unreachable!(),
         });
 
-        RArray::from_iter(iter).into_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DurationChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let time_unit = Wrap(self.0.time_unit()).into_value();
-        let iter = self.0.into_iter().map(|opt_v| {
-            opt_v.map(|v| {
-                utils
-                    .funcall::<_, _, Value>("_to_ruby_duration", (v, time_unit))
-                    .unwrap()
-            })
+impl TryIntoValue for Wrap<&DurationChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        let utils = pl_utils(ruby);
+        let time_unit = Wrap(self.0.time_unit()).into_value_with(ruby);
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| utils.funcall::<_, _, Value>("_to_ruby_duration", (v, time_unit)))
+                .transpose()
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DatetimeChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let time_unit = Wrap(self.0.time_unit()).into_value();
-        let time_zone = self.0.time_zone().as_deref().map(|v| v.into_value());
-        let iter = self.0.into_iter().map(|opt_v| {
-            opt_v.map(|v| {
-                utils
-                    .funcall::<_, _, Value>("_to_ruby_datetime", (v, time_unit, time_zone))
-                    .unwrap()
-            })
+impl TryIntoValue for Wrap<&DatetimeChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        let time_zone = self.0.time_zone().as_ref();
+        let time_unit = self.0.time_unit();
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| datetime_to_rb_object(ruby, v, time_unit, time_zone))
+                .transpose()
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&TimeChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let iter = self.0.into_iter().map(|opt_v| {
-            opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_time", (v,)).unwrap())
+impl TryIntoValue for Wrap<&TimeChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        let utils = pl_utils(ruby);
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| utils.funcall::<_, _, Value>("_to_ruby_time", (v,)))
+                .transpose()
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DateChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let iter = self.0.into_iter().map(|opt_v| {
-            opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_date", (v,)).unwrap())
+impl TryIntoValue for Wrap<&DateChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        let utils = pl_utils(ruby);
+        let iter = self.0.physical().iter().map(|opt_v| {
+            opt_v
+                .map(|v| utils.funcall::<_, _, Value>("_to_ruby_date", (v,)))
+                .transpose()
         });
-        RArray::from_iter(iter).into_value()
+        ruby.ary_try_from_iter(iter).map(|v| v.as_value())
     }
 }
 
-impl IntoValue for Wrap<&DecimalChunked> {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        let utils = utils();
-        let rb_scale = (-(self.0.scale() as i32)).into_value();
-        let iter = self.0.into_iter().map(|opt_v| {
-            opt_v.map(|v| {
-                utils
-                    .funcall::<_, _, Value>("_to_ruby_decimal", (v.to_string(), rb_scale))
-                    .unwrap()
-            })
-        });
-        RArray::from_iter(iter).into_value()
+impl TryIntoValue for Wrap<&DecimalChunked> {
+    fn try_into_value_with(self, ruby: &Ruby) -> RbResult<Value> {
+        let iter = decimal_to_rbobject_iter(ruby, self.0)?;
+        Ok(iter.as_value())
     }
 }
+
+pub(crate) fn decimal_to_rbobject_iter(ruby: &Ruby, ca: &DecimalChunked) -> RbResult<RArray> {
+    let utils = pl_utils(ruby);
+    let rb_precision = ca.precision().into_value_with(ruby);
+    let mut buf = DecimalFmtBuffer::new();
+    let iter = ca.physical().iter().map(move |opt_v| {
+        opt_v
+            .map(|v| {
+                let s = buf.format_dec128(v, ca.scale(), false, false);
+                utils.funcall::<_, _, Value>("_to_ruby_decimal", (rb_precision, s))
+            })
+            .transpose()
+    });
+    ruby.ary_try_from_iter(iter)
+}

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

@@ -0,0 +1,63 @@
+//! Utilities for converting dates, times, datetimes, and so on.
+
+use std::str::FromStr;
+
+use chrono::{DateTime, Datelike, FixedOffset, NaiveDateTime, TimeDelta, TimeZone as _};
+use chrono_tz::Tz;
+use magnus::{IntoValue, Ruby, Value, prelude::*};
+use polars::prelude::*;
+
+use crate::rb_modules::pl_utils;
+use crate::{RbPolarsErr, RbResult};
+
+pub fn elapsed_offset_to_timedelta(elapsed: i64, time_unit: TimeUnit) -> TimeDelta {
+    let (in_second, nano_multiplier) = match time_unit {
+        TimeUnit::Nanoseconds => (1_000_000_000, 1),
+        TimeUnit::Microseconds => (1_000_000, 1_000),
+        TimeUnit::Milliseconds => (1_000, 1_000_000),
+    };
+    let mut elapsed_sec = elapsed / in_second;
+    let mut elapsed_nanos = nano_multiplier * (elapsed % in_second);
+    if elapsed_nanos < 0 {
+        // TimeDelta expects nanos to always be positive.
+        elapsed_sec -= 1;
+        elapsed_nanos += 1_000_000_000;
+    }
+    TimeDelta::new(elapsed_sec, elapsed_nanos as u32).unwrap()
+}
+
+/// Convert time-units-since-epoch to a more structured object.
+pub fn timestamp_to_naive_datetime(since_epoch: i64, time_unit: TimeUnit) -> NaiveDateTime {
+    DateTime::UNIX_EPOCH.naive_utc() + elapsed_offset_to_timedelta(since_epoch, time_unit)
+}
+
+pub fn datetime_to_rb_object(
+    ruby: &Ruby,
+    v: i64,
+    tu: TimeUnit,
+    tz: Option<&TimeZone>,
+) -> RbResult<Value> {
+    if let Some(time_zone) = tz {
+        if let Ok(tz) = Tz::from_str(time_zone) {
+            let utc_datetime = DateTime::UNIX_EPOCH + elapsed_offset_to_timedelta(v, tu);
+            if utc_datetime.year() >= 2100 {
+                // chrono-tz does not support dates after 2100
+                // https://github.com/chronotope/chrono-tz/issues/135
+                pl_utils(ruby).funcall("_to_ruby_datetime", (v, tu.to_ascii(), time_zone.as_str()))
+            } else {
+                let datetime = utc_datetime.with_timezone(&tz);
+                Ok(datetime.fixed_offset().into_value_with(ruby))
+            }
+        } else if let Ok(tz) = FixedOffset::from_str(time_zone) {
+            let naive_datetime = timestamp_to_naive_datetime(v, tu);
+            let datetime = tz.from_utc_datetime(&naive_datetime);
+            Ok(datetime.into_value_with(ruby))
+        } else {
+            Err(RbPolarsErr::Other(format!("Could not parse timezone: {time_zone}")).into())
+        }
+    } else {
+        Ok(timestamp_to_naive_datetime(v, tu)
+            .and_utc()
+            .into_value_with(ruby))
+    }
+}