polars-df 0.20.0 → 0.21.1

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

@@ -1,15 +1,16 @@
 pub(crate) mod any_value;
+mod categorical;
 mod chunked_array;
 
 use std::fmt::{Debug, Display, Formatter};
 use std::fs::File;
 use std::hash::{Hash, Hasher};
 use std::num::NonZeroUsize;
-use std::path::PathBuf;
 
+pub use categorical::RbCategories;
 use magnus::{
-    class, exception, prelude::*, r_hash::ForEach, try_convert::TryConvertOwned, value::Opaque,
-    IntoValue, Module, RArray, RHash, Ruby, Symbol, TryConvert, Value,
+    IntoValue, Module, RArray, RHash, Ruby, Symbol, TryConvert, Value, class, exception,
+    prelude::*, r_hash::ForEach, try_convert::TryConvertOwned, value::Opaque,
 };
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
@@ -17,17 +18,20 @@ use polars::datatypes::AnyValue;
 use polars::frame::row::Row;
 use polars::io::avro::AvroCompression;
 use polars::io::cloud::CloudOptions;
+use polars::prelude::deletion::DeletionFilesList;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
+use polars_core::schema::iceberg::IcebergSchema;
 use polars_core::utils::arrow::array::Array;
 use polars_core::utils::materialize_dyn_int;
 use polars_plan::dsl::ScanSources;
 use polars_utils::mmap::MemSlice;
 use polars_utils::total_ord::{TotalEq, TotalHash};
 
-use crate::file::{get_ruby_scan_source_input, RubyScanSourceInput};
+use crate::file::{RubyScanSourceInput, get_ruby_scan_source_input};
 use crate::object::OBJECT_NAME;
 use crate::rb_modules::series;
+use crate::utils::to_rb_err;
 use crate::{RbDataFrame, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
 
 pub(crate) fn slice_extract_wrapped<T>(slice: &[Wrap<T>]) -> &[T] {
@@ -226,18 +230,25 @@ impl IntoValue for Wrap<DataType> {
                 let class = pl.const_get::<_, Value>("Object").unwrap();
                 class.funcall("new", ()).unwrap()
             }
-            DataType::Categorical(_, ordering) => {
-                let class = pl.const_get::<_, Value>("Categorical").unwrap();
-                class.funcall("new", (Wrap(ordering),)).unwrap()
-            }
-            DataType::Enum(rev_map, _) => {
-                // we should always have an initialized rev_map coming from rust
-                let categories = rev_map.as_ref().unwrap().get_categories();
+            DataType::Categorical(cats, _) => {
+                let categories_class = pl.const_get::<_, Value>("Categories").unwrap();
+                let categorical_class = pl.const_get::<_, Value>("Categorical").unwrap();
+                let categories: Value = categories_class
+                    .funcall("_from_rb_categories", (RbCategories::from(cats.clone()),))
+                    .unwrap();
+                let kwargs = RHash::new();
+                kwargs.aset(Symbol::new("categories"), categories).unwrap();
+                categorical_class.funcall("new", (kwargs,)).unwrap()
+            }
+            DataType::Enum(_, mapping) => {
+                let categories = unsafe {
+                    StringChunked::from_chunks(
+                        PlSmallStr::from_static("category"),
+                        vec![mapping.to_arrow(true)],
+                    )
+                };
                 let class = pl.const_get::<_, Value>("Enum").unwrap();
-                let s =
-                    Series::from_arrow(PlSmallStr::from_static("category"), categories.to_boxed())
-                        .unwrap();
-                let series = to_series(s.into());
+                let series = to_series(categories.into_series().into());
                 class.funcall::<_, _, Value>("new", (series,)).unwrap()
             }
             DataType::Time => {
@@ -277,13 +288,13 @@ impl IntoValue for Wrap<DataType> {
     }
 }
 
+enum CategoricalOrdering {
+    Lexical,
+}
+
 impl IntoValue for Wrap<CategoricalOrdering> {
     fn into_value_with(self, _: &Ruby) -> Value {
-        let ordering = match self.0 {
-            CategoricalOrdering::Physical => "physical",
-            CategoricalOrdering::Lexical => "lexical",
-        };
-        ordering.into_value()
+        "lexical".into_value()
     }
 }
 
@@ -324,8 +335,10 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::Boolean" => DataType::Boolean,
                 "Polars::String" => DataType::String,
                 "Polars::Binary" => DataType::Binary,
-                "Polars::Categorical" => DataType::Categorical(None, Default::default()),
-                "Polars::Enum" => DataType::Enum(None, Default::default()),
+                "Polars::Categorical" => DataType::from_categories(Categories::global()),
+                "Polars::Enum" => {
+                    DataType::from_frozen_categories(FrozenCategories::new([]).unwrap())
+                }
                 "Polars::Date" => DataType::Date,
                 "Polars::Time" => DataType::Time,
                 "Polars::Datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
@@ -340,11 +353,12 @@ impl TryConvert for Wrap<DataType> {
                 dt => {
                     return Err(RbValueError::new_err(format!(
                         "{dt} is not a correct polars DataType.",
-                    )))
+                    )));
                 }
             }
         } else if String::try_convert(ob).is_err() {
-            let name = unsafe { ob.class().name() }.into_owned();
+            let cls = ob.class();
+            let name = unsafe { cls.name() }.into_owned();
             match name.as_str() {
                 "Polars::Int8" => DataType::Int8,
                 "Polars::Int16" => DataType::Int16,
@@ -360,17 +374,20 @@ impl TryConvert for Wrap<DataType> {
                 "Polars::String" => DataType::String,
                 "Polars::Binary" => DataType::Binary,
                 "Polars::Categorical" => {
-                    let ordering = ob
-                        .funcall::<_, _, Wrap<CategoricalOrdering>>("ordering", ())?
-                        .0;
-                    DataType::Categorical(None, ordering)
+                    let categories: Value = ob.funcall("categories", ()).unwrap();
+                    let rb_categories: &RbCategories =
+                        categories.funcall("_categories", ()).unwrap();
+                    DataType::from_categories(rb_categories.categories().clone())
                 }
                 "Polars::Enum" => {
-                    let categories = ob.funcall("categories", ()).unwrap();
+                    let categories: Value = ob.funcall("categories", ()).unwrap();
                     let s = get_series(categories)?;
                     let ca = s.str().map_err(RbPolarsErr::from)?;
                     let categories = ca.downcast_iter().next().unwrap().clone();
-                    create_enum_dtype(categories)
+                    assert!(!categories.has_nulls());
+                    DataType::from_frozen_categories(
+                        FrozenCategories::new(categories.values_iter()).unwrap(),
+                    )
                 }
                 "Polars::Date" => DataType::Date,
                 "Polars::Time" => DataType::Time,
@@ -420,7 +437,7 @@ impl TryConvert for Wrap<DataType> {
                     return Err(RbTypeError::new_err(format!(
                         "A {dt} object is not a correct polars DataType. \
                         Hint: use the class without instantiating it.",
-                    )))
+                    )));
                 }
             }
         } else {
@@ -436,7 +453,7 @@ impl TryConvert for Wrap<DataType> {
                 "str" => DataType::String,
                 "bin" => DataType::Binary,
                 "bool" => DataType::Boolean,
-                "cat" => DataType::Categorical(None, Default::default()),
+                "cat" => DataType::from_categories(Categories::global()),
                 "date" => DataType::Date,
                 "datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
                 "f32" => DataType::Float32,
@@ -449,9 +466,8 @@ impl TryConvert for Wrap<DataType> {
                 "unk" => DataType::Unknown(Default::default()),
                 _ => {
                     return Err(RbValueError::new_err(format!(
-                        "{} is not a supported DataType.",
-                        ob
-                    )))
+                        "{ob} is not a supported DataType."
+                    )));
                 }
             }
         };
@@ -475,7 +491,7 @@ impl TryConvert for Wrap<StatisticsOptions> {
                 _ => {
                     return Err(RbTypeError::new_err(format!(
                         "'{key}' is not a valid statistic option",
-                    )))
+                    )));
                 }
             }
             Ok(ForEach::Continue)
@@ -510,6 +526,12 @@ impl TryConvert for Wrap<Schema> {
     }
 }
 
+impl TryConvert for Wrap<ArrowSchema> {
+    fn try_convert(_ob: Value) -> RbResult<Self> {
+        todo!();
+    }
+}
+
 impl TryConvert for Wrap<ScanSources> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let list = RArray::try_convert(ob)?;
@@ -519,7 +541,7 @@ impl TryConvert for Wrap<ScanSources> {
         }
 
         enum MutableSources {
-            Paths(Vec<PathBuf>),
+            Paths(Vec<PlPath>),
             Files(Vec<File>),
             Buffers(Vec<MemSlice>),
         }
@@ -560,7 +582,7 @@ impl TryConvert for Wrap<ScanSources> {
                     return Err(RbTypeError::new_err(
                         "Cannot combine in-memory bytes, paths and files for scan sources"
                             .to_string(),
-                    ))
+                    ));
                 }
             }
         }
@@ -678,7 +700,7 @@ impl TryConvert for Wrap<AsofStrategy> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "asof `strategy` must be one of {{'backward', 'forward', 'nearest'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -693,7 +715,7 @@ impl TryConvert for Wrap<InterpolationMethod> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "method must be one of {{'linear', 'nearest'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -708,9 +730,8 @@ impl TryConvert for Wrap<Option<AvroCompression>> {
             "deflate" => Some(AvroCompression::Deflate),
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "compression must be one of {{'uncompressed', 'snappy', 'deflate'}}, got {}",
-                    v
-                )))
+                    "compression must be one of {{'uncompressed', 'snappy', 'deflate'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -720,13 +741,18 @@ impl TryConvert for Wrap<Option<AvroCompression>> {
 impl TryConvert for Wrap<CategoricalOrdering> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
-            "physical" => CategoricalOrdering::Physical,
             "lexical" => CategoricalOrdering::Lexical,
+            "physical" => {
+                polars_warn!(
+                    Deprecation,
+                    "physical ordering is deprecated, will use lexical ordering instead"
+                );
+                CategoricalOrdering::Lexical
+            }
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "ordering must be one of {{'physical', 'lexical'}}, got {}",
-                    v
-                )))
+                    "ordering must be one of {{'physical', 'lexical'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -742,7 +768,7 @@ impl TryConvert for Wrap<StartBy> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "closed must be one of {{'window', 'datapoint', 'monday'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -758,9 +784,8 @@ impl TryConvert for Wrap<ClosedWindow> {
             "none" => ClosedWindow::None,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "closed must be one of {{'left', 'right', 'both', 'none'}}, got {}",
-                    v
-                )))
+                    "closed must be one of {{'left', 'right', 'both', 'none'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -789,9 +814,8 @@ impl TryConvert for Wrap<CsvEncoding> {
             "utf8-lossy" => CsvEncoding::LossyUtf8,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "encoding must be one of {{'utf8', 'utf8-lossy'}}, got {}",
-                    v
-                )))
+                    "encoding must be one of {{'utf8', 'utf8-lossy'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -806,9 +830,8 @@ impl TryConvert for Wrap<Option<IpcCompression>> {
             "zstd" => Some(IpcCompression::ZSTD),
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "compression must be one of {{'uncompressed', 'lz4', 'zstd'}}, got {}",
-                    v
-                )))
+                    "compression must be one of {{'uncompressed', 'lz4', 'zstd'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -826,9 +849,8 @@ impl TryConvert for Wrap<JoinType> {
             "cross" => JoinType::Cross,
             v => {
                 return Err(RbValueError::new_err(format!(
-                "how must be one of {{'inner', 'left', 'full', 'semi', 'anti', 'cross'}}, got {}",
-                v
-            )))
+                    "how must be one of {{'inner', 'left', 'full', 'semi', 'anti', 'cross'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -844,7 +866,7 @@ impl TryConvert for Wrap<Label> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`label` must be one of {{'left', 'right', 'datapoint'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -858,9 +880,8 @@ impl TryConvert for Wrap<ListToStructWidthStrategy> {
             "max_width" => ListToStructWidthStrategy::MaxWidth,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "n_field_strategy must be one of {{'first_non_null', 'max_width'}}, got {}",
-                    v
-                )))
+                    "n_field_strategy must be one of {{'first_non_null', 'max_width'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -875,7 +896,7 @@ impl TryConvert for Wrap<NonExistent> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`non_existent` must be one of {{'null', 'raise'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -889,9 +910,8 @@ impl TryConvert for Wrap<NullBehavior> {
             "ignore" => NullBehavior::Ignore,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "null behavior must be one of {{'drop', 'ignore'}}, got {}",
-                    v
-                )))
+                    "null behavior must be one of {{'drop', 'ignore'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -905,9 +925,8 @@ impl TryConvert for Wrap<NullStrategy> {
             "propagate" => NullStrategy::Propagate,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "null strategy must be one of {{'ignore', 'propagate'}}, got {}",
-                    v
-                )))
+                    "null strategy must be one of {{'ignore', 'propagate'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -923,9 +942,8 @@ impl TryConvert for Wrap<ParallelStrategy> {
             "none" => ParallelStrategy::None,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "parallel must be one of {{'auto', 'columns', 'row_groups', 'none'}}, got {}",
-                    v
-                )))
+                    "parallel must be one of {{'auto', 'columns', 'row_groups', 'none'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -942,9 +960,8 @@ impl TryConvert for Wrap<QuantileMethod> {
             "midpoint" => QuantileMethod::Midpoint,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "interpolation must be one of {{'lower', 'higher', 'nearest', 'linear', 'midpoint'}}, got {}",
-                    v
-                )))
+                    "interpolation must be one of {{'lower', 'higher', 'nearest', 'linear', 'midpoint'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -962,9 +979,24 @@ impl TryConvert for Wrap<RankMethod> {
             "random" => RankMethod::Random,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "method must be one of {{'min', 'max', 'average', 'dense', 'ordinal', 'random'}}, got {}",
-                    v
-                )))
+                    "method must be one of {{'min', 'max', 'average', 'dense', 'ordinal', 'random'}}, got {v}"
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<Roll> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "raise" => Roll::Raise,
+            "forward" => Roll::Forward,
+            "backward" => Roll::Backward,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`roll` must be one of {{'raise', 'forward', 'backward'}}, got {v}",
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -979,15 +1011,16 @@ impl TryConvert for Wrap<TimeUnit> {
             "ms" => TimeUnit::Milliseconds,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "time unit must be one of {{'ns', 'us', 'ms'}}, got {}",
-                    v
-                )))
+                    "time unit must be one of {{'ns', 'us', 'ms'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
     }
 }
 
+unsafe impl TryConvertOwned for Wrap<TimeUnit> {}
+
 impl TryConvert for Wrap<UniqueKeepStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
@@ -995,9 +1028,8 @@ impl TryConvert for Wrap<UniqueKeepStrategy> {
             "last" => UniqueKeepStrategy::Last,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "keep must be one of {{'first', 'last'}}, got {}",
-                    v
-                )))
+                    "keep must be one of {{'first', 'last'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1011,9 +1043,8 @@ impl TryConvert for Wrap<IpcCompression> {
             "zstd" => IpcCompression::ZSTD,
             v => {
                 return Err(RbValueError::new_err(format!(
-                    "compression must be one of {{'lz4', 'zstd'}}, got {}",
-                    v
-                )))
+                    "compression must be one of {{'lz4', 'zstd'}}, got {v}"
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1029,7 +1060,7 @@ impl TryConvert for Wrap<SearchSortedSide> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "side must be one of {{'any', 'left', 'right'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1046,7 +1077,7 @@ impl TryConvert for Wrap<ClosedInterval> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`closed` must be one of {{'both', 'left', 'right', 'none'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1061,8 +1092,8 @@ impl TryConvert for Wrap<WindowMapping> {
             "explode" => WindowMapping::Explode,
             v => {
                 return Err(RbValueError::new_err(format!(
-                "`mapping_strategy` must be one of {{'group_to_rows', 'join', 'explode'}}, got {v}",
-            )))
+                    "`mapping_strategy` must be one of {{'group_to_rows', 'join', 'explode'}}, got {v}",
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1079,7 +1110,7 @@ impl TryConvert for Wrap<JoinValidation> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`validate` must be one of {{'m:m', 'm:1', '1:m', '1:1'}}, got {v}",
-                )))
+                )));
             }
         };
         Ok(Wrap(parsed))
@@ -1097,8 +1128,8 @@ impl TryConvert for Wrap<MaintainOrderJoin> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`maintain_order` must be one of {{'none', 'left', 'right', 'left_right', 'right_left'}}, got {v}",
-                )))
-            },
+                )));
+            }
         };
         Ok(Wrap(parsed))
     }
@@ -1114,8 +1145,8 @@ impl TryConvert for Wrap<QuoteStyle> {
             v => {
                 return Err(RbValueError::new_err(format!(
                     "`quote_style` must be one of {{'always', 'necessary', 'non_numeric', 'never'}}, got {v}",
-                )))
-            },
+                )));
+            }
         };
         Ok(Wrap(parsed))
     }
@@ -1126,6 +1157,33 @@ pub(crate) fn parse_cloud_options(uri: &str, kv: Vec<(String, String)>) -> RbRes
     Ok(out)
 }
 
+impl TryConvert for Wrap<SetOperation> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "union" => SetOperation::Union,
+            "difference" => SetOperation::Difference,
+            "intersection" => SetOperation::Intersection,
+            "symmetric_difference" => SetOperation::SymmetricDifference,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "set operation must be one of {{'union', 'difference', 'intersection', 'symmetric_difference'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<CastColumnsPolicy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        if ob.is_nil() {
+            let out = Wrap(CastColumnsPolicy::ERROR_ON_MISMATCH);
+            return Ok(out);
+        }
+        todo!();
+    }
+}
+
 pub fn parse_fill_null_strategy(
     strategy: &str,
     limit: FillNullLimit,
@@ -1139,10 +1197,12 @@ pub fn parse_fill_null_strategy(
         "zero" => FillNullStrategy::Zero,
         "one" => FillNullStrategy::One,
         e => {
-            return Err(magnus::Error::new(exception::runtime_error(), format!(
-                "strategy must be one of {{'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'}}, got {}",
-                e,
-            )))
+            return Err(magnus::Error::new(
+                exception::runtime_error(),
+                format!(
+                    "strategy must be one of {{'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'}}, got {e}",
+                ),
+            ));
         }
     };
     Ok(parsed)
@@ -1159,7 +1219,7 @@ pub fn parse_parquet_compression(
             compression_level
                 .map(|lvl| {
                     GzipLevel::try_new(lvl as u8)
-                        .map_err(|e| RbValueError::new_err(format!("{:?}", e)))
+                        .map_err(|e| RbValueError::new_err(format!("{e:?}")))
                 })
                 .transpose()?,
         ),
@@ -1168,7 +1228,7 @@ pub fn parse_parquet_compression(
             compression_level
                 .map(|lvl| {
                     BrotliLevel::try_new(lvl as u32)
-                        .map_err(|e| RbValueError::new_err(format!("{:?}", e)))
+                        .map_err(|e| RbValueError::new_err(format!("{e:?}")))
                 })
                 .transpose()?,
         ),
@@ -1176,16 +1236,14 @@ pub fn parse_parquet_compression(
         "zstd" => ParquetCompression::Zstd(
             compression_level
                 .map(|lvl| {
-                    ZstdLevel::try_new(lvl)
-                        .map_err(|e| RbValueError::new_err(format!("{:?}", e)))
+                    ZstdLevel::try_new(lvl).map_err(|e| RbValueError::new_err(format!("{e:?}")))
                 })
                 .transpose()?,
         ),
         e => {
             return Err(RbValueError::new_err(format!(
-                "compression must be one of {{'uncompressed', 'snappy', 'gzip', 'lzo', 'brotli', 'lz4', 'zstd'}}, got {}",
-                e
-            )))
+                "compression must be one of {{'uncompressed', 'snappy', 'gzip', 'lzo', 'brotli', 'lz4', 'zstd'}}, got {e}"
+            )));
         }
     };
     Ok(parsed)
@@ -1236,6 +1294,23 @@ impl TryConvert for RbCompatLevel {
     }
 }
 
+impl TryConvert for Wrap<UnicodeForm> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "NFC" => UnicodeForm::NFC,
+            "NFKC" => UnicodeForm::NFKC,
+            "NFD" => UnicodeForm::NFD,
+            "NFKD" => UnicodeForm::NFKD,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`form` must be one of {{'NFC', 'NFKC', 'NFD', 'NFKD'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<Option<TimeZone>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let tz = Option::<Wrap<PlSmallStr>>::try_convert(ob)?;
@@ -1245,3 +1320,94 @@ impl TryConvert for Wrap<Option<TimeZone>> {
         Ok(Wrap(TimeZone::opt_try_new(tz).map_err(RbPolarsErr::from)?))
     }
 }
+
+unsafe impl TryConvertOwned for Wrap<Option<TimeZone>> {}
+
+impl TryConvert for Wrap<ExtraColumnsPolicy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "ignore" => ExtraColumnsPolicy::Ignore,
+            "raise" => ExtraColumnsPolicy::Raise,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "extra column/field parameter must be one of {{'ignore', 'raise'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<MissingColumnsPolicy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "insert" => MissingColumnsPolicy::Insert,
+            "raise" => MissingColumnsPolicy::Raise,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "missing column/field parameter must be one of {{'insert', 'raise'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<ColumnMapping> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let (column_mapping_type, ob) = <(String, Value)>::try_convert(ob)?;
+
+        Ok(Wrap(match column_mapping_type.as_str() {
+            "iceberg-column-mapping" => {
+                let arrow_schema = Wrap::<ArrowSchema>::try_convert(ob)?;
+                ColumnMapping::Iceberg(Arc::new(
+                    IcebergSchema::from_arrow_schema(&arrow_schema.0).map_err(to_rb_err)?,
+                ))
+            }
+
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "unknown column mapping type: {v}"
+                )));
+            }
+        }))
+    }
+}
+
+impl TryConvert for Wrap<DeletionFilesList> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let (deletion_file_type, ob) = <(String, Value)>::try_convert(ob)?;
+
+        Ok(Wrap(match deletion_file_type.as_str() {
+            "iceberg-position-delete" => {
+                let dict = RHash::try_convert(ob)?;
+
+                let mut out = PlIndexMap::new();
+
+                dict.foreach(|k: usize, v: RArray| {
+                    let files = v
+                        .into_iter()
+                        .map(|x| {
+                            let x = String::try_convert(x)?;
+                            Ok(x)
+                        })
+                        .collect::<RbResult<Arc<[String]>>>()?;
+
+                    if !files.is_empty() {
+                        out.insert(k, files);
+                    }
+
+                    Ok(ForEach::Continue)
+                })?;
+
+                DeletionFilesList::IcebergPositionDelete(Arc::new(out))
+            }
+
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "unknown deletion file type: {v}"
+                )));
+            }
+        }))
+    }
+}