polars-df 0.15.0 → 0.26.0

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

@@ -1,16 +1,14 @@
-use magnus::{prelude::*, Value};
-use polars::io::avro::AvroCompression;
+use magnus::{Value, prelude::*};
 use polars::io::RowIndex;
+use polars::io::avro::AvroCompression;
 use polars::prelude::*;
-use polars_utils::mmap::ensure_not_mapped;
 use std::io::BufWriter;
 use std::num::NonZeroUsize;
 
 use super::*;
 use crate::conversion::*;
 use crate::file::{
-    get_either_file, get_file_like, get_mmap_bytes_reader, get_mmap_bytes_reader_and_path,
-    read_if_bytesio, EitherRustRubyFile,
+    get_file_like, get_mmap_bytes_reader, get_mmap_bytes_reader_and_path, read_if_bytesio,
 };
 use crate::{RbPolarsErr, RbResult};
 
@@ -25,28 +23,29 @@ impl RbDataFrame {
         let ignore_errors = bool::try_convert(arguments[4])?;
         let n_rows = Option::<usize>::try_convert(arguments[5])?;
         let skip_rows = usize::try_convert(arguments[6])?;
-        let projection = Option::<Vec<usize>>::try_convert(arguments[7])?;
-        let separator = String::try_convert(arguments[8])?;
-        let rechunk = bool::try_convert(arguments[9])?;
-        let columns = Option::<Vec<String>>::try_convert(arguments[10])?;
-        let encoding = Wrap::<CsvEncoding>::try_convert(arguments[11])?;
-        let n_threads = Option::<usize>::try_convert(arguments[12])?;
-        let path = Option::<String>::try_convert(arguments[13])?;
-        let overwrite_dtype = Option::<Vec<(String, Wrap<DataType>)>>::try_convert(arguments[14])?;
-        let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::try_convert(arguments[15])?;
-        let low_memory = bool::try_convert(arguments[16])?;
-        let comment_prefix = Option::<String>::try_convert(arguments[17])?;
-        let quote_char = Option::<String>::try_convert(arguments[18])?;
-        let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[19])?;
-        let missing_utf8_is_empty_string = bool::try_convert(arguments[20])?;
-        let try_parse_dates = bool::try_convert(arguments[21])?;
-        let skip_rows_after_header = usize::try_convert(arguments[22])?;
-        let row_index = Option::<(String, IdxSize)>::try_convert(arguments[23])?;
-        let eol_char = String::try_convert(arguments[24])?;
-        let raise_if_empty = bool::try_convert(arguments[25])?;
-        let truncate_ragged_lines = bool::try_convert(arguments[26])?;
-        let decimal_comma = bool::try_convert(arguments[27])?;
-        let schema = Option::<Wrap<Schema>>::try_convert(arguments[28])?;
+        let skip_lines = usize::try_convert(arguments[7])?;
+        let projection = Option::<Vec<usize>>::try_convert(arguments[8])?;
+        let separator = String::try_convert(arguments[9])?;
+        let rechunk = bool::try_convert(arguments[10])?;
+        let columns = Option::<Vec<String>>::try_convert(arguments[11])?;
+        let encoding = Wrap::<CsvEncoding>::try_convert(arguments[12])?;
+        let n_threads = Option::<usize>::try_convert(arguments[13])?;
+        let path = Option::<String>::try_convert(arguments[14])?;
+        let overwrite_dtype = Option::<Vec<(String, Wrap<DataType>)>>::try_convert(arguments[15])?;
+        let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::try_convert(arguments[16])?;
+        let low_memory = bool::try_convert(arguments[17])?;
+        let comment_prefix = Option::<String>::try_convert(arguments[18])?;
+        let quote_char = Option::<String>::try_convert(arguments[19])?;
+        let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[20])?;
+        let missing_utf8_is_empty_string = bool::try_convert(arguments[21])?;
+        let try_parse_dates = bool::try_convert(arguments[22])?;
+        let skip_rows_after_header = usize::try_convert(arguments[23])?;
+        let row_index = Option::<(String, IdxSize)>::try_convert(arguments[24])?;
+        let eol_char = String::try_convert(arguments[25])?;
+        let raise_if_empty = bool::try_convert(arguments[26])?;
+        let truncate_ragged_lines = bool::try_convert(arguments[27])?;
+        let decimal_comma = bool::try_convert(arguments[28])?;
+        let schema = Option::<Wrap<Schema>>::try_convert(arguments[29])?;
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
@@ -90,6 +89,7 @@ impl RbDataFrame {
             .with_has_header(has_header)
             .with_n_rows(n_rows)
             .with_skip_rows(skip_rows)
+            .with_skip_lines(skip_lines)
             .with_ignore_errors(ignore_errors)
             .with_projection(projection.map(Arc::new))
             .with_rechunk(rechunk)
@@ -147,33 +147,6 @@ impl RbDataFrame {
         Ok(out.into())
     }
 
-    pub fn read_ndjson(
-        rb_f: Value,
-        ignore_errors: bool,
-        schema: Option<Wrap<Schema>>,
-        schema_overrides: Option<Wrap<Schema>>,
-    ) -> RbResult<Self> {
-        let rb_f = read_if_bytesio(rb_f);
-        let mmap_bytes_r = get_mmap_bytes_reader(&rb_f)?;
-
-        let mut builder = JsonReader::new(mmap_bytes_r)
-            .with_json_format(JsonFormat::JsonLines)
-            .with_ignore_errors(ignore_errors);
-
-        if let Some(schema) = schema {
-            builder = builder.with_schema(Arc::new(schema.0));
-        }
-
-        if let Some(schema) = schema_overrides.as_ref() {
-            builder = builder.with_schema_overwrite(&schema.0);
-        }
-
-        let out = builder
-            .finish()
-            .map_err(|e| RbPolarsErr::Other(format!("{e}")))?;
-        Ok(out.into())
-    }
-
     pub fn read_ipc(
         rb_f: Value,
         columns: Option<Vec<String>>,
@@ -244,102 +217,12 @@ impl RbDataFrame {
         Ok(RbDataFrame::new(df))
     }
 
-    #[allow(clippy::too_many_arguments)]
-    pub fn write_csv(
-        &self,
-        rb_f: Value,
-        include_header: bool,
-        separator: u8,
-        quote_char: u8,
-        batch_size: Wrap<NonZeroUsize>,
-        datetime_format: Option<String>,
-        date_format: Option<String>,
-        time_format: Option<String>,
-        float_precision: Option<usize>,
-        null_value: Option<String>,
-    ) -> RbResult<()> {
-        let batch_size = batch_size.0;
-        let null = null_value.unwrap_or_default();
-        let mut buf = get_file_like(rb_f, true)?;
-        CsvWriter::new(&mut buf)
-            .include_header(include_header)
-            .with_separator(separator)
-            .with_quote_char(quote_char)
-            .with_batch_size(batch_size)
-            .with_datetime_format(datetime_format)
-            .with_date_format(date_format)
-            .with_time_format(time_format)
-            .with_float_precision(float_precision)
-            .with_null_value(null)
-            .finish(&mut self.df.borrow_mut())
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
-    }
-
-    pub fn write_parquet(
-        &self,
-        rb_f: Value,
-        compression: String,
-        compression_level: Option<i32>,
-        statistics: Wrap<StatisticsOptions>,
-        row_group_size: Option<usize>,
-        data_page_size: Option<usize>,
-    ) -> RbResult<()> {
-        let compression = parse_parquet_compression(&compression, compression_level)?;
-
-        let buf = get_file_like(rb_f, true)?;
-        ParquetWriter::new(buf)
-            .with_compression(compression)
-            .with_statistics(statistics.0)
-            .with_row_group_size(row_group_size)
-            .with_data_page_size(data_page_size)
-            .finish(&mut self.df.borrow_mut())
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
-    }
-
-    pub fn write_json(&self, rb_f: Value, pretty: bool, row_oriented: bool) -> RbResult<()> {
+    pub fn write_json(&self, rb_f: Value) -> RbResult<()> {
         let file = BufWriter::new(get_file_like(rb_f, true)?);
 
-        let r = match (pretty, row_oriented) {
-            (_, true) => JsonWriter::new(file)
-                .with_json_format(JsonFormat::Json)
-                .finish(&mut self.df.borrow_mut()),
-            (true, _) => serde_json::to_writer_pretty(file, &*self.df.borrow())
-                .map_err(|e| PolarsError::ComputeError(format!("{:?}", e).into())),
-            (false, _) => serde_json::to_writer(file, &*self.df.borrow())
-                .map_err(|e| PolarsError::ComputeError(format!("{:?}", e).into())),
-        };
-        r.map_err(|e| RbPolarsErr::Other(format!("{:?}", e)))?;
-        Ok(())
-    }
-
-    pub fn write_ndjson(&self, rb_f: Value) -> RbResult<()> {
-        let file = BufWriter::new(get_file_like(rb_f, true)?);
-
-        let r = JsonWriter::new(file)
-            .with_json_format(JsonFormat::JsonLines)
-            .finish(&mut self.df.borrow_mut());
-
-        r.map_err(|e| RbPolarsErr::Other(format!("{:?}", e)))?;
-        Ok(())
-    }
-
-    pub fn write_ipc(
-        &self,
-        rb_f: Value,
-        compression: Wrap<Option<IpcCompression>>,
-        compat_level: RbCompatLevel,
-    ) -> RbResult<()> {
-        let either = get_either_file(rb_f, true)?;
-        if let EitherRustRubyFile::Rust(ref f) = either {
-            ensure_not_mapped(f).map_err(RbPolarsErr::from)?;
-        }
-        let mut buf = either.into_dyn();
-        IpcWriter::new(&mut buf)
-            .with_compression(compression.0)
-            .with_compat_level(compat_level.0)
-            .finish(&mut self.df.borrow_mut())
+        JsonWriter::new(file)
+            .with_json_format(JsonFormat::Json)
+            .finish(&mut self.df.write())
             .map_err(RbPolarsErr::from)?;
         Ok(())
     }
@@ -354,7 +237,7 @@ impl RbDataFrame {
         IpcStreamWriter::new(&mut buf)
             .with_compression(compression.0)
             .with_compat_level(compat_level.0)
-            .finish(&mut self.df.borrow_mut())
+            .finish(&mut self.df.write())
             .map_err(RbPolarsErr::from)?;
         Ok(())
     }
@@ -370,7 +253,7 @@ impl RbDataFrame {
         AvroWriter::new(&mut buf)
             .with_compression(compression.0)
             .with_name(name)
-            .finish(&mut self.df.borrow_mut())
+            .finish(&mut self.df.write())
             .map_err(RbPolarsErr::from)?;
         Ok(())
     }

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

@@ -0,0 +1,175 @@
+use magnus::{IntoValue, RArray, Ruby, TryConvert, Value, value::Opaque, value::ReprValue};
+use polars::frame::row::{Row, rows_to_schema_first_non_null};
+use polars_core::utils::CustomIterTools;
+
+use super::*;
+use crate::error::RbPolarsErr;
+use crate::prelude::*;
+use crate::ruby::utils::{TryIntoValue, to_pl_err};
+use crate::series::construction::series_from_objects;
+use crate::{RbResult, RbSeries, raise_err};
+
+impl RbDataFrame {
+    pub fn map_rows(
+        rb: &Ruby,
+        self_: &Self,
+        lambda: Value,
+        output_type: Option<Wrap<DataType>>,
+        inference_size: usize,
+    ) -> RbResult<(Value, bool)> {
+        let df = self_.df.read();
+        let height = df.height();
+        let col_series: Vec<_> = df
+            .columns()
+            .iter()
+            .map(|s| s.as_materialized_series().clone())
+            .collect();
+        let mut iters: Vec<_> = col_series.iter().map(|c| c.iter()).collect();
+        drop(df); // Release lock before calling lambda.
+
+        let lambda_result_iter = (0..height).map(move |_| {
+            let iter = iters
+                .iter_mut()
+                .map(|it| Wrap(it.next().unwrap()).try_into_value_with(rb));
+            rb.ary_try_from_iter(iter)
+                .and_then(|tpl| lambda.funcall::<_, _, Value>("call", (tpl,)))
+        });
+
+        // Simple case: return type set.
+        if let Some(output_type) = &output_type {
+            // If the output type is Object we should not go through AnyValue.
+            if let DataType::Object(_) = output_type.0 {
+                let objects = lambda_result_iter
+                    .map(|res| {
+                        Ok(ObjectValue {
+                            inner: Opaque::from(res?),
+                        })
+                    })
+                    .collect::<RbResult<Vec<_>>>()?;
+                let s = series_from_objects(rb, PlSmallStr::from_static("map"), objects);
+                return Ok((RbSeries::from(s).into_value_with(rb), false));
+            }
+
+            let avs = lambda_result_iter
+                .map(|res| Wrap::<AnyValue>::try_convert(res?).map(|w| w.0))
+                .collect::<RbResult<Vec<AnyValue>>>()?;
+            let s = Series::from_any_values_and_dtype(
+                PlSmallStr::from_static("map"),
+                &avs,
+                &output_type.0,
+                true,
+            )
+            .map_err(RbPolarsErr::from)?;
+            return Ok((RbSeries::from(s).into_value_with(rb), false));
+        }
+
+        // Disambiguate returning a DataFrame vs Series by checking the
+        // first non-null output value.
+        let mut peek_iter = lambda_result_iter.peekable();
+        let mut null_count = 0;
+        while let Some(ret) = peek_iter.peek() {
+            if let Ok(v) = ret
+                && v.is_nil()
+            {
+                null_count += 1;
+                peek_iter.next();
+            } else {
+                break;
+            }
+        }
+
+        let first_val = match peek_iter.peek() {
+            Some(Ok(v)) => v,
+            Some(Err(e)) => return Err(e.clone()),
+            None => {
+                let msg = "The output type of the 'map_rows' function cannot be determined.\n\
+                All returned values are None, consider setting the 'return_dtype'.";
+                raise_err!(msg, ComputeError)
+            }
+        };
+
+        if let Ok(first_row) = RArray::try_convert(*first_val) {
+            let width = first_row.len();
+            let out_df = collect_lambda_ret_with_rows_output(
+                height,
+                width,
+                null_count,
+                inference_size,
+                peek_iter,
+            )
+            .map_err(RbPolarsErr::from)?;
+            Ok((RbDataFrame::from(out_df).into_value_with(rb), true))
+        } else {
+            let avs = peek_iter
+                .map(|res| Wrap::<AnyValue>::try_convert(res?).map(|w| w.0))
+                .collect::<RbResult<Vec<AnyValue>>>()?;
+            let s = Series::from_any_values(PlSmallStr::from_static("map"), &avs, true)
+                .map_err(RbPolarsErr::from)?;
+
+            let out = if null_count > 0 {
+                let mut tmp = Series::full_null(s.name().clone(), null_count, s.dtype());
+                tmp.append_owned(s).map_err(RbPolarsErr::from)?;
+                tmp
+            } else {
+                s
+            };
+            Ok((RbSeries::from(out).into_value_with(rb), false))
+        }
+    }
+}
+
+fn collect_lambda_ret_with_rows_output(
+    height: usize,
+    width: usize,
+    init_null_count: usize,
+    inference_size: usize,
+    ret_iter: impl Iterator<Item = RbResult<Value>>,
+) -> PolarsResult<DataFrame> {
+    let null_row = Row::new(vec![AnyValue::Null; width]);
+
+    let mut row_buf = Row::default();
+    let mut row_iter = ret_iter.map(|retval| {
+        let retval = retval.map_err(to_pl_err)?;
+        if retval.is_nil() {
+            Ok(&null_row)
+        } else {
+            let tuple = RArray::try_convert(retval).map_err(|_| polars_err!(ComputeError: format!("expected tuple, got {}", unsafe { retval.classname() })))?;
+            row_buf.0.clear();
+            for v in tuple {
+                let v = Wrap::<AnyValue>::try_convert(v).unwrap().0;
+                row_buf.0.push(v);
+            }
+            let ptr = &row_buf as *const Row;
+            // SAFETY:
+            // we know that row constructor of polars dataframe does not keep a reference
+            // to the row. Before we mutate the row buf again, the reference is dropped.
+            // we only cannot prove it to the compiler.
+            // we still to this because it save a Vec allocation in a hot loop.
+            Ok(unsafe { &*ptr })
+        }
+    });
+
+    // First rows for schema inference.
+    let mut buf = Vec::with_capacity(inference_size);
+    for v in (&mut row_iter).take(inference_size) {
+        buf.push(v?.clone());
+    }
+
+    let schema = rows_to_schema_first_non_null(&buf, Some(50))?;
+
+    if init_null_count > 0 {
+        // SAFETY: we know the iterators size.
+        let iter = unsafe {
+            (0..init_null_count)
+                .map(|_| Ok(&null_row))
+                .chain(buf.iter().map(Ok))
+                .chain(row_iter)
+                .trust_my_length(height)
+        };
+        DataFrame::try_from_rows_iter_and_schema(iter, &schema)
+    } else {
+        // SAFETY: we know the iterators size.
+        let iter = unsafe { buf.iter().map(Ok).chain(row_iter).trust_my_length(height) };
+        DataFrame::try_from_rows_iter_and_schema(iter, &schema)
+    }
+}

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

@@ -2,26 +2,58 @@ mod construction;
 mod export;
 mod general;
 mod io;
+mod map;
 mod serde;
 
+use magnus::{DataTypeFunctions, TypedData, gc};
+use parking_lot::RwLock;
 use polars::prelude::*;
-use std::cell::RefCell;
 
-#[magnus::wrap(class = "Polars::RbDataFrame")]
+use crate::series::mark_series;
+
+#[derive(TypedData)]
+#[magnus(class = "Polars::RbDataFrame", mark)]
 pub struct RbDataFrame {
-    pub df: RefCell<DataFrame>,
+    pub df: RwLock<DataFrame>,
+}
+
+impl Clone for RbDataFrame {
+    fn clone(&self) -> Self {
+        RbDataFrame {
+            df: RwLock::new(self.df.read().clone()),
+        }
+    }
 }
 
 impl From<DataFrame> for RbDataFrame {
     fn from(df: DataFrame) -> Self {
-        RbDataFrame::new(df)
+        Self::new(df)
     }
 }
 
 impl RbDataFrame {
     pub fn new(df: DataFrame) -> Self {
         RbDataFrame {
-            df: RefCell::new(df),
+            df: RwLock::new(df),
+        }
+    }
+}
+
+impl DataTypeFunctions for RbDataFrame {
+    fn mark(&self, marker: &gc::Marker) {
+        // this is really, really not ideal, as objects will not be marked if unable to borrow
+        // currently, this should only happen for write_* methods,
+        // which should refuse to write Object datatype, and therefore be safe,
+        // since GC will not have a chance to run
+        if let Some(df) = self.df.try_read() {
+            for column in df.columns() {
+                if let DataType::Object(_) = column.dtype() {
+                    match column {
+                        Column::Series(s) => mark_series(marker, s),
+                        Column::Scalar(s) => mark_series(marker, &s.as_single_value_series()),
+                    }
+                }
+            }
         }
     }
 }

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

@@ -1,15 +1,30 @@
-use crate::exceptions::ComputeError;
+use std::io::{BufReader, BufWriter};
+
+use polars::prelude::*;
+
 use crate::file::get_file_like;
-use crate::{RbDataFrame, RbResult};
+use crate::utils::to_rb_err;
+use crate::{RbDataFrame, RbPolarsErr, RbResult};
 use magnus::Value;
-use std::io::BufWriter;
 
 impl RbDataFrame {
-    // TODO add to Ruby
-    pub fn serialize_json(&self, rb_f: Value) -> RbResult<()> {
+    pub fn serialize_binary(&self, rb_f: Value) -> RbResult<()> {
         let file = get_file_like(rb_f, true)?;
-        let writer = BufWriter::new(file);
-        serde_json::to_writer(writer, &self.df)
-            .map_err(|err| ComputeError::new_err(err.to_string()))
+        let mut writer = BufWriter::new(file);
+
+        Ok(self
+            .df
+            .write()
+            .serialize_into_writer(&mut writer)
+            .map_err(RbPolarsErr::from)?)
+    }
+
+    pub fn deserialize_binary(rb_f: Value) -> RbResult<Self> {
+        let file = get_file_like(rb_f, false)?;
+        let mut file = BufReader::new(file);
+
+        DataFrame::deserialize_from_reader(&mut file)
+            .map(|v| v.into())
+            .map_err(to_rb_err)
     }
 }

data/ext/polars/src/error.rs

@@ -3,11 +3,17 @@ use std::fmt::{Debug, Formatter};
 use magnus::Error;
 use polars::prelude::PolarsError;
 
-use crate::exceptions::{ComputeError, InvalidOperationError};
-use crate::rb_modules;
+use crate::RbErr;
+use crate::exceptions::{
+    AssertionError, ColumnNotFoundError, ComputeError, DuplicateError, InvalidOperationError,
+    NoDataError, OutOfBoundsError, SQLInterfaceError, SQLSyntaxError, SchemaError,
+    SchemaFieldNotFoundError, ShapeError, StringCacheMismatchError, StructFieldNotFoundError,
+};
+use crate::ruby::exceptions::{RbIOError, RbRuntimeError};
 
 pub enum RbPolarsErr {
     Polars(PolarsError),
+    Ruby(RbErr),
     Other(String),
 }
 
@@ -17,9 +23,9 @@ impl From<PolarsError> for RbPolarsErr {
     }
 }
 
-impl From<std::io::Error> for RbPolarsErr {
-    fn from(value: std::io::Error) -> Self {
-        RbPolarsErr::Other(format!("{value:?}"))
+impl From<RbErr> for RbPolarsErr {
+    fn from(err: RbErr) -> Self {
+        RbPolarsErr::Ruby(err)
     }
 }
 
@@ -27,13 +33,43 @@ impl From<RbPolarsErr> for Error {
     fn from(err: RbPolarsErr) -> Self {
         match err {
             RbPolarsErr::Polars(err) => match err {
+                PolarsError::AssertionError(err) => AssertionError::new_err(err.to_string()),
+                PolarsError::ColumnNotFound(name) => ColumnNotFoundError::new_err(name.to_string()),
                 PolarsError::ComputeError(err) => ComputeError::new_err(err.to_string()),
+                PolarsError::Duplicate(err) => DuplicateError::new_err(err.to_string()),
                 PolarsError::InvalidOperation(err) => {
                     InvalidOperationError::new_err(err.to_string())
                 }
-                _ => Error::new(rb_modules::error(), err.to_string()),
+                PolarsError::IO { error, msg } => {
+                    let msg = if let Some(msg) = msg {
+                        msg.to_string()
+                    } else {
+                        error.to_string()
+                    };
+                    RbIOError::new_err(msg)
+                }
+                PolarsError::NoData(err) => NoDataError::new_err(err.to_string()),
+                PolarsError::OutOfBounds(err) => OutOfBoundsError::new_err(err.to_string()),
+                PolarsError::SQLInterface(name) => SQLInterfaceError::new_err(name.to_string()),
+                PolarsError::SQLSyntax(name) => SQLSyntaxError::new_err(name.to_string()),
+                PolarsError::SchemaFieldNotFound(name) => {
+                    SchemaFieldNotFoundError::new_err(name.to_string())
+                }
+                PolarsError::SchemaMismatch(err) => SchemaError::new_err(err.to_string()),
+                PolarsError::ShapeMismatch(err) => ShapeError::new_err(err.to_string()),
+                PolarsError::StringCacheMismatch(err) => {
+                    StringCacheMismatchError::new_err(err.to_string())
+                }
+                PolarsError::StructFieldNotFound(name) => {
+                    StructFieldNotFoundError::new_err(name.to_string())
+                }
+                PolarsError::Context { .. } | PolarsError::ExprContext { .. } => {
+                    let tmp = RbPolarsErr::Polars(err.context_trace());
+                    RbErr::from(tmp)
+                }
             },
-            RbPolarsErr::Other(err) => Error::new(rb_modules::error(), err.to_string()),
+            RbPolarsErr::Ruby(err) => err,
+            err => RbRuntimeError::new_err(format!("{:?}", &err)),
         }
     }
 }
@@ -43,6 +79,7 @@ impl Debug for RbPolarsErr {
         use RbPolarsErr::*;
         match self {
             Polars(err) => write!(f, "{err:?}"),
+            Ruby(err) => write!(f, "{err:?}"),
             Other(err) => write!(f, "BindingsError: {err:?}"),
         }
     }

data/ext/polars/src/exceptions.rs

@@ -1,9 +1,9 @@
 use crate::rb_modules;
-use magnus::{exception, Error};
+use magnus::{Error, Module, Ruby};
 use std::borrow::Cow;
 
 macro_rules! create_exception {
-    ($type:ident, $cls:expr) => {
+    ($type:ident) => {
         pub struct $type {}
 
         impl $type {
@@ -11,14 +11,27 @@ macro_rules! create_exception {
             where
                 T: Into<Cow<'static, str>>,
             {
-                Error::new($cls, message)
+                let ruby = Ruby::get().unwrap();
+                let cls = rb_modules::polars(&ruby)
+                    .const_get(stringify!($type))
+                    .unwrap();
+                Error::new(cls, message)
             }
         }
     };
 }
 
-create_exception!(RbTypeError, exception::type_error());
-create_exception!(RbValueError, exception::arg_error());
-create_exception!(RbOverflowError, exception::range_error());
-create_exception!(ComputeError, rb_modules::compute_error());
-create_exception!(InvalidOperationError, rb_modules::invalid_operation_error());
+create_exception!(AssertionError);
+create_exception!(ColumnNotFoundError);
+create_exception!(ComputeError);
+create_exception!(DuplicateError);
+create_exception!(InvalidOperationError);
+create_exception!(NoDataError);
+create_exception!(OutOfBoundsError);
+create_exception!(SQLInterfaceError);
+create_exception!(SQLSyntaxError);
+create_exception!(SchemaError);
+create_exception!(SchemaFieldNotFoundError);
+create_exception!(ShapeError);
+create_exception!(StringCacheMismatchError);
+create_exception!(StructFieldNotFoundError);