polars-df 0.21.0 → 0.22.0

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

@@ -1,4 +1,4 @@
-use magnus::{Ruby, Value, prelude::*, value::Opaque};
+use magnus::{RArray, prelude::*};
 use polars::lazy::dsl::lit;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
@@ -83,6 +83,18 @@ impl RbExpr {
         self.inner.clone().list().mean().into()
     }
 
+    pub fn list_median(&self) -> Self {
+        self.inner.clone().list().median().into()
+    }
+
+    pub fn list_std(&self, ddof: u8) -> Self {
+        self.inner.clone().list().std(ddof).into()
+    }
+
+    pub fn list_var(&self, ddof: u8) -> Self {
+        self.inner.clone().list().var(ddof).into()
+    }
+
     pub fn list_min(&self) -> Self {
         self.inner.clone().list().min().into()
     }
@@ -171,40 +183,36 @@ impl RbExpr {
             .into()
     }
 
+    pub fn list_gather_every(&self, n: &RbExpr, offset: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .list()
+            .gather_every(n.inner.clone(), offset.inner.clone())
+            .into()
+    }
+
     pub fn list_to_array(&self, width: usize) -> Self {
         self.inner.clone().list().to_array(width).into()
     }
 
-    pub fn list_to_struct(
-        &self,
-        width_strat: Wrap<ListToStructWidthStrategy>,
-        name_gen: Option<Value>,
-        upper_bound: Option<usize>,
-    ) -> RbResult<Self> {
-        let name_gen = name_gen.map(|lambda| {
-            let lambda = Opaque::from(lambda);
-            Arc::new(move |idx: usize| {
-                let lambda = Ruby::get().unwrap().get_inner(lambda);
-                let out: String = lambda.funcall("call", (idx,)).unwrap();
-                PlSmallStr::from_string(out)
-            });
-
-            // non-Ruby thread
-            todo!();
-        });
-
+    pub fn list_to_struct(&self, names: RArray) -> RbResult<Self> {
         Ok(self
             .inner
             .clone()
             .list()
-            .to_struct(ListToStruct::InferWidth {
-                infer_field_strategy: width_strat.0,
-                get_index_name: name_gen,
-                max_fields: upper_bound,
-            })
+            .to_struct(
+                names
+                    .into_iter()
+                    .map(|x| Ok(Wrap::<PlSmallStr>::try_convert(x)?.0))
+                    .collect::<RbResult<Arc<[_]>>>()?,
+            )
             .into())
     }
 
+    pub fn list_n_unique(&self) -> Self {
+        self.inner.clone().list().n_unique().into()
+    }
+
     pub fn list_unique(&self, maintain_order: bool) -> Self {
         let e = self.inner.clone();
 

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

@@ -1,4 +1,4 @@
-use magnus::RArray;
+use magnus::{RArray, Ruby};
 use polars::prelude::Schema;
 
 use crate::{RbExpr, RbPolarsErr, RbResult, Wrap};
@@ -8,17 +8,15 @@ impl RbExpr {
         self.inner == other.inner
     }
 
-    pub fn meta_pop(&self, schema: Option<Wrap<Schema>>) -> RbResult<RArray> {
+    pub fn meta_pop(ruby: &Ruby, rb_self: &Self, schema: Option<Wrap<Schema>>) -> RbResult<RArray> {
         let schema = schema.as_ref().map(|s| &s.0);
-        let exprs = self
+        let exprs = rb_self
             .inner
             .clone()
             .meta()
             .pop(schema)
             .map_err(RbPolarsErr::from)?;
-        Ok(RArray::from_iter(
-            exprs.iter().map(|e| RbExpr::from(e.clone())),
-        ))
+        Ok(ruby.ary_from_iter(exprs.iter().map(|e| RbExpr::from(e.clone()))))
     }
 
     pub fn meta_root_names(&self) -> Vec<String> {
@@ -57,6 +55,17 @@ impl RbExpr {
         self.inner.clone().meta().is_regex_projection()
     }
 
+    pub fn meta_is_column_selection(&self, allow_aliasing: bool) -> bool {
+        self.inner
+            .clone()
+            .meta()
+            .is_column_selection(allow_aliasing)
+    }
+
+    pub fn meta_is_literal(&self, allow_aliasing: bool) -> bool {
+        self.inner.clone().meta().is_literal(allow_aliasing)
+    }
+
     fn compute_tree_format(
         &self,
         display_as_dot: bool,

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

@@ -1,5 +1,6 @@
 mod array;
 mod binary;
+mod bitwise;
 mod categorical;
 pub mod datatype;
 mod datetime;
@@ -9,6 +10,8 @@ mod meta;
 mod name;
 mod rolling;
 pub mod selector;
+#[cfg(feature = "serialize_binary")]
+mod serde;
 mod string;
 mod r#struct;
 

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

@@ -11,20 +11,17 @@ impl RbExpr {
 
     pub fn name_map(&self, lambda: Proc) -> Self {
         let lambda = Opaque::from(lambda);
-        self.inner
-            .clone()
-            .name()
-            .map(move |name| {
-                let lambda = Ruby::get().unwrap().get_inner(lambda);
-                let out = lambda.call::<_, String>((name.as_str(),));
-                match out {
-                    Ok(out) => Ok(format_pl_smallstr!("{}", out)),
-                    Err(e) => Err(PolarsError::ComputeError(
-                        format!("Ruby function in 'name.map' produced an error: {e}.").into(),
-                    )),
-                }
-            })
-            .into()
+        let func = PlanCallback::new(move |name: PlSmallStr| {
+            let lambda = Ruby::get().unwrap().get_inner(lambda);
+            let out = lambda.call::<_, String>((name.as_str(),));
+            match out {
+                Ok(out) => Ok(format_pl_smallstr!("{}", out)),
+                Err(e) => Err(PolarsError::ComputeError(
+                    format!("Ruby function in 'name.map' produced an error: {e}.").into(),
+                )),
+            }
+        });
+        self.inner.clone().name().map(func).into()
     }
 
     pub fn name_prefix(&self, prefix: String) -> Self {
@@ -42,4 +39,12 @@ impl RbExpr {
     pub fn name_to_uppercase(&self) -> Self {
         self.inner.clone().name().to_uppercase().into()
     }
+
+    pub fn name_prefix_fields(&self, prefix: String) -> Self {
+        self.inner.clone().name().prefix_fields(&prefix).into()
+    }
+
+    pub fn name_suffix_fields(&self, suffix: String) -> Self {
+        self.inner.clone().name().suffix_fields(&suffix).into()
+    }
 }

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

@@ -337,4 +337,24 @@ impl RbExpr {
 
         self.inner.clone().rolling_skew(options).into()
     }
+
+    pub fn rolling_kurtosis(
+        &self,
+        window_size: usize,
+        fisher: bool,
+        bias: bool,
+        min_periods: Option<usize>,
+        center: bool,
+    ) -> Self {
+        let min_periods = min_periods.unwrap_or(window_size);
+        let options = RollingOptionsFixedWindow {
+            window_size,
+            weights: None,
+            min_periods,
+            center,
+            fn_params: Some(RollingFnParams::Kurtosis { fisher, bias }),
+        };
+
+        self.inner.clone().rolling_kurtosis(options).into()
+    }
 }

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

@@ -0,0 +1,28 @@
+use std::io::{BufReader, BufWriter};
+
+use magnus::Value;
+use polars::lazy::prelude::Expr;
+use polars_utils::pl_serialize;
+
+use crate::exceptions::ComputeError;
+use crate::file::get_file_like;
+use crate::{RbExpr, RbResult};
+
+impl RbExpr {
+    pub fn serialize_binary(&self, rb_f: Value) -> RbResult<()> {
+        let file = get_file_like(rb_f, true)?;
+        let writer = BufWriter::new(file);
+        pl_serialize::SerializeOptions::default()
+            .serialize_into_writer::<_, _, true>(writer, &self.inner)
+            .map_err(|err| ComputeError::new_err(err.to_string()))
+    }
+
+    pub fn deserialize_binary(rb_f: Value) -> RbResult<RbExpr> {
+        let file = get_file_like(rb_f, false)?;
+        let reader = BufReader::new(file);
+        let expr: Expr = pl_serialize::SerializeOptions::default()
+            .deserialize_from_reader::<_, _, true>(reader)
+            .map_err(|err| ComputeError::new_err(err.to_string()))?;
+        Ok(expr.into())
+    }
+}

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

@@ -1,7 +1,7 @@
 use polars::prelude::*;
 
 use crate::conversion::Wrap;
-use crate::{RbExpr, RbPolarsErr, RbResult};
+use crate::{RbDataTypeExpr, RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
     pub fn str_join(&self, delimiter: String, ignore_nulls: bool) -> Self {
@@ -122,6 +122,14 @@ impl RbExpr {
             .into()
     }
 
+    pub fn str_head(&self, n: &Self) -> Self {
+        self.inner.clone().str().head(n.inner.clone()).into()
+    }
+
+    pub fn str_tail(&self, n: &Self) -> Self {
+        self.inner.clone().str().tail(n.inner.clone()).into()
+    }
+
     pub fn str_to_uppercase(&self) -> Self {
         self.inner.clone().str().to_uppercase().into()
     }
@@ -159,6 +167,10 @@ impl RbExpr {
             .into()
     }
 
+    pub fn str_normalize(&self, form: Wrap<UnicodeForm>) -> Self {
+        self.inner.clone().str().normalize(form.0).into()
+    }
+
     pub fn str_reverse(&self) -> Self {
         self.inner.clone().str().reverse().into()
     }
@@ -200,6 +212,23 @@ impl RbExpr {
         }
     }
 
+    pub fn str_find(&self, pat: &Self, literal: Option<bool>, strict: bool) -> Self {
+        match literal {
+            Some(true) => self
+                .inner
+                .clone()
+                .str()
+                .find_literal(pat.inner.clone())
+                .into(),
+            _ => self
+                .inner
+                .clone()
+                .str()
+                .find(pat.inner.clone(), strict)
+                .into(),
+        }
+    }
+
     pub fn str_ends_with(&self, sub: &RbExpr) -> Self {
         self.inner.clone().str().ends_with(sub.inner.clone()).into()
     }
@@ -236,16 +265,11 @@ impl RbExpr {
             .into()
     }
 
-    pub fn str_json_decode(
-        &self,
-        dtype: Option<Wrap<DataType>>,
-        infer_schema_len: Option<usize>,
-    ) -> Self {
-        let dtype = dtype.map(|wrap| wrap.0);
+    pub fn str_json_decode(&self, dtype: &RbDataTypeExpr) -> Self {
         self.inner
             .clone()
             .str()
-            .json_decode(dtype, infer_schema_len)
+            .json_decode(dtype.inner.clone())
             .into()
     }
 
@@ -323,8 +347,8 @@ impl RbExpr {
         self.inner.clone().str().splitn(by.inner.clone(), n).into()
     }
 
-    pub fn str_to_decimal(&self, infer_len: usize) -> Self {
-        self.inner.clone().str().to_decimal(infer_len).into()
+    pub fn str_to_decimal(&self, scale: usize) -> Self {
+        self.inner.clone().str().to_decimal(scale).into()
     }
 
     pub fn str_contains_any(&self, patterns: &RbExpr, ascii_case_insensitive: bool) -> Self {
@@ -351,4 +375,34 @@ impl RbExpr {
             )
             .into()
     }
+
+    pub fn str_extract_many(
+        &self,
+        patterns: &RbExpr,
+        ascii_case_insensitive: bool,
+        overlapping: bool,
+    ) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .extract_many(patterns.inner.clone(), ascii_case_insensitive, overlapping)
+            .into()
+    }
+
+    pub fn str_find_many(
+        &self,
+        patterns: &RbExpr,
+        ascii_case_insensitive: bool,
+        overlapping: bool,
+    ) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .find_many(patterns.inner.clone(), ascii_case_insensitive, overlapping)
+            .into()
+    }
+
+    pub fn str_escape_regex(&self) -> Self {
+        self.inner.clone().str().escape_regex().into()
+    }
 }

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

@@ -1,4 +1,6 @@
-use crate::RbExpr;
+use magnus::RArray;
+
+use crate::{RbExpr, RbResult, rb_exprs_to_exprs};
 
 impl RbExpr {
     pub fn struct_field_by_index(&self, index: i64) -> Self {
@@ -16,4 +18,10 @@ impl RbExpr {
     pub fn struct_json_encode(&self) -> Self {
         self.inner.clone().struct_().json_encode().into()
     }
+
+    pub fn struct_with_fields(&self, fields: RArray) -> RbResult<Self> {
+        let fields = rb_exprs_to_exprs(fields)?;
+        let e = self.inner.clone().struct_().with_fields(fields);
+        Ok(e.into())
+    }
 }

data/ext/polars/src/file.rs

@@ -3,7 +3,7 @@ use std::io;
 use std::io::{Cursor, Read, Seek, SeekFrom, Write};
 use std::path::PathBuf;
 
-use magnus::{Error, RString, Ruby, Value, exception, prelude::*, value::Opaque};
+use magnus::{Error, RString, Ruby, Value, prelude::*, value::Opaque};
 use polars::io::cloud::CloudOptions;
 use polars::io::mmap::MmapBytesReader;
 use polars::prelude::PlPath;
@@ -67,23 +67,25 @@ impl RbFileLikeObject {
     /// ruby object has a `read`, `write`, and `seek` methods in respect to parameters.
     /// Will return a `TypeError` if object does not have `read`, `seek`, and `write` methods.
     pub fn with_requirements(object: Value, read: bool, write: bool, seek: bool) -> RbResult<Self> {
+        let ruby = Ruby::get_with(object);
+
         if read && !object.respond_to("read", false)? {
             return Err(Error::new(
-                exception::type_error(),
+                ruby.exception_type_error(),
                 "Object does not have a .read() method.",
             ));
         }
 
         if seek && !object.respond_to("seek", false)? {
             return Err(Error::new(
-                exception::type_error(),
+                ruby.exception_type_error(),
                 "Object does not have a .seek() method.",
             ));
         }
 
         if write && !object.respond_to("write", false)? {
             return Err(Error::new(
-                exception::type_error(),
+                ruby.exception_type_error(),
                 "Object does not have a .write() method.",
             ));
         }
@@ -113,10 +115,10 @@ impl Read for RbFileLikeObject {
 
 impl Write for RbFileLikeObject {
     fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
-        let rbbytes = RString::from_slice(buf);
+        let ruby = Ruby::get().unwrap();
+        let rbbytes = ruby.str_from_slice(buf);
 
-        let number_bytes_written = Ruby::get()
-            .unwrap()
+        let number_bytes_written = ruby
             .get_inner(self.inner)
             .funcall::<_, _, usize>("write", (rbbytes,))
             .map_err(rberr_to_io_err)?;
@@ -265,8 +267,12 @@ pub fn get_mmap_bytes_reader_and_path<'a>(
         RbReadBytes::Bytes(v) => Ok((Box::new(Cursor::new(unsafe { v.as_slice() })), None)),
         RbReadBytes::Other(v) => {
             let path = PathBuf::try_convert(*v)?;
-            let f = File::open(&path)
-                .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            let f = File::open(&path).map_err(|e| {
+                Error::new(
+                    Ruby::get().unwrap().exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
             Ok((Box::new(f), Some(path)))
         }
     }

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

@@ -2,7 +2,6 @@ use polars::lazy::dsl;
 
 use crate::RbExpr;
 
-// TODO add to Ruby
 pub fn business_day_count(
     start: &RbExpr,
     end: &RbExpr,

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

@@ -1,6 +1,6 @@
 use std::io::BufReader;
 
-use magnus::{RHash, Value};
+use magnus::{RHash, Ruby, Value};
 use polars::prelude::ArrowSchema;
 
 use crate::conversion::Wrap;
@@ -16,11 +16,32 @@ pub fn read_ipc_schema(rb_f: Value) -> RbResult<RHash> {
         EitherRustRubyFile::Rb(mut r) => read_file_metadata(&mut r).map_err(RbPolarsErr::from)?,
     };
 
-    let dict = RHash::new();
+    let ruby = Ruby::get_with(rb_f);
+    let dict = ruby.hash_new();
     fields_to_rbdict(&metadata.schema, &dict)?;
     Ok(dict)
 }
 
+pub fn read_parquet_metadata(rb_f: Value) -> RbResult<RHash> {
+    use polars_parquet::read::read_metadata;
+    use polars_parquet::read::schema::read_custom_key_value_metadata;
+
+    let metadata = match get_either_file(rb_f, false)? {
+        EitherRustRubyFile::Rust(r) => {
+            read_metadata(&mut BufReader::new(r)).map_err(RbPolarsErr::from)?
+        }
+        EitherRustRubyFile::Rb(mut r) => read_metadata(&mut r).map_err(RbPolarsErr::from)?,
+    };
+
+    let key_value_metadata = read_custom_key_value_metadata(metadata.key_value_metadata());
+    let ruby = Ruby::get_with(rb_f);
+    let dict = ruby.hash_new();
+    for (key, value) in key_value_metadata.into_iter() {
+        dict.aset(key.as_str(), value.as_str())?;
+    }
+    Ok(dict)
+}
+
 pub fn read_parquet_schema(rb_f: Value) -> RbResult<RHash> {
     use polars_parquet::read::{infer_schema, read_metadata};
 
@@ -32,7 +53,8 @@ pub fn read_parquet_schema(rb_f: Value) -> RbResult<RHash> {
     };
     let arrow_schema = infer_schema(&metadata).map_err(RbPolarsErr::from)?;
 
-    let dict = RHash::new();
+    let ruby = Ruby::get_with(rb_f);
+    let dict = ruby.hash_new();
     fields_to_rbdict(&arrow_schema, &dict)?;
     Ok(dict)
 }

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

@@ -1,6 +1,6 @@
-use magnus::encoding::{self, EncodingCapable};
+use magnus::encoding::EncodingCapable;
 use magnus::{
-    Float, Integer, RArray, RString, Ruby, Value, class, prelude::*, typed_data::Obj, value::Opaque,
+    Float, Integer, RArray, RString, Ruby, Value, prelude::*, typed_data::Obj, value::Opaque,
 };
 use polars::lazy::dsl;
 use polars::prelude::*;
@@ -85,6 +85,10 @@ pub fn as_struct(exprs: RArray) -> RbResult<RbExpr> {
     Ok(dsl::as_struct(exprs).into())
 }
 
+pub fn field(names: Vec<String>) -> RbExpr {
+    dsl::Expr::Field(names.into_iter().map(|x| x.into()).collect()).into()
+}
+
 pub fn coalesce(exprs: RArray) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
     Ok(dsl::coalesce(&exprs).into())
@@ -94,10 +98,10 @@ pub fn col(name: String) -> RbExpr {
     dsl::col(&name).into()
 }
 
-pub fn collect_all(lfs: RArray) -> RbResult<RArray> {
+pub fn collect_all(ruby: &Ruby, lfs: RArray) -> RbResult<RArray> {
     let lfs = lfs.typecheck::<Obj<RbLazyFrame>>()?;
 
-    Ok(RArray::from_iter(lfs.iter().map(|lf| {
+    Ok(ruby.ary_from_iter(lfs.iter().map(|lf| {
         let df = lf.ldf.borrow().clone().collect().unwrap();
         RbDataFrame::new(df)
     })))
@@ -279,7 +283,8 @@ pub fn fold(
 }
 
 pub fn lit(value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr> {
-    if value.is_kind_of(class::true_class()) || value.is_kind_of(class::false_class()) {
+    let ruby = Ruby::get_with(value);
+    if value.is_kind_of(ruby.class_true_class()) || value.is_kind_of(ruby.class_false_class()) {
         Ok(dsl::lit(bool::try_convert(value)?).into())
     } else if let Some(v) = Integer::from_value(value) {
         match v.to_i64() {
@@ -298,7 +303,7 @@ pub fn lit(value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr
     } else if let Some(v) = Float::from_value(value) {
         Ok(dsl::lit(v.to_f64()).into())
     } else if let Some(v) = RString::from_value(value) {
-        if v.enc_get() == encoding::Index::utf8() {
+        if v.enc_get() == ruby.utf8_encindex() {
             Ok(dsl::lit(v.to_string()?).into())
         } else {
             Ok(dsl::lit(unsafe { v.as_slice() }).into())

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, Value};
+use magnus::{IntoValue, Ruby, Value};
 use polars_core;
 use polars_core::POOL;
 use polars_core::fmt::FloatFmt;
@@ -7,8 +7,8 @@ use polars_core::prelude::IDX_DTYPE;
 use crate::conversion::Wrap;
 use crate::{RbResult, RbValueError};
 
-pub fn get_index_type() -> Value {
-    Wrap(IDX_DTYPE).into_value()
+pub fn get_index_type(ruby: &Ruby) -> Value {
+    Wrap(IDX_DTYPE).into_value_with(ruby)
 }
 
 pub fn thread_pool_size() -> usize {

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

@@ -1,5 +1,5 @@
 use crate::RbResult;
-use magnus::{RArray, Ruby, Value};
+use magnus::{Ruby, Value};
 
 pub fn enable_string_cache() {
     // The string cache no longer exists.
@@ -18,7 +18,7 @@ pub fn using_string_cache() -> bool {
 pub struct RbStringCacheHolder {}
 
 impl RbStringCacheHolder {
-    pub fn hold() -> RbResult<Value> {
-        Ruby::get().unwrap().yield_splat(RArray::new())
+    pub fn hold(ruby: &Ruby) -> RbResult<Value> {
+        ruby.yield_splat(ruby.ary_new())
     }
 }

data/ext/polars/src/interop/arrow/to_ruby.rs

@@ -1,6 +1,6 @@
 use arrow::datatypes::ArrowDataType;
 use arrow::ffi;
-use magnus::{IntoValue, Value};
+use magnus::{IntoValue, Ruby, Value};
 use polars::datatypes::CompatLevel;
 use polars::frame::DataFrame;
 use polars::prelude::{ArrayRef, ArrowField, PlSmallStr, PolarsResult, SchemaExt};
@@ -20,11 +20,11 @@ impl RbArrowArrayStream {
     }
 }
 
-pub(crate) fn dataframe_to_stream(df: &DataFrame) -> RbResult<Value> {
+pub(crate) fn dataframe_to_stream(df: &DataFrame, ruby: &Ruby) -> RbResult<Value> {
     let iter = Box::new(DataFrameStreamIterator::new(df));
     let field = iter.field();
     let stream = ffi::export_iterator(iter, field);
-    Ok(RbArrowArrayStream { stream }.into_value())
+    Ok(RbArrowArrayStream { stream }.into_value_with(ruby))
 }
 
 pub struct DataFrameStreamIterator {

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, Module, RArray, RClass, RModule, Value, class, prelude::*};
+use magnus::{IntoValue, Module, RClass, RModule, Ruby, Value, prelude::*};
 
 use crate::RbResult;
 
@@ -44,9 +44,10 @@ impl<T: Element> RbArray1<T> {
     where
         I: IntoIterator<Item = T>,
     {
-        class::object()
+        let ruby = Ruby::get().unwrap();
+        ruby.class_object()
             .const_get::<_, RModule>("Numo")?
             .const_get::<_, RClass>(T::class_name())?
-            .funcall("cast", (RArray::from_iter(values),))
+            .funcall("cast", (ruby.ary_from_iter(values),))
     }
 }

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

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use magnus::{TryConvert, Value, value::ReprValue};
+use polars::prelude::default_values::DefaultFieldValues;
 use polars::prelude::deletion::DeletionFilesList;
 use polars::prelude::{
     CastColumnsPolicy, ColumnMapping, ExtraColumnsPolicy, MissingColumnsPolicy, PlSmallStr, Schema,
@@ -48,6 +49,8 @@ impl RbScanOptions {
         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 cloud_options = storage_options;
 
@@ -95,6 +98,9 @@ impl RbScanOptions {
             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()),
         };
 
         Ok(unified_scan_args)