polars-df 0.23.0 → 0.24.0

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

@@ -23,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);
@@ -88,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)
@@ -145,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>>,
@@ -242,101 +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: NonZeroUsize,
-        datetime_format: Option<String>,
-        date_format: Option<String>,
-        time_format: Option<String>,
-        float_precision: Option<usize>,
-        null_value: Option<String>,
-    ) -> RbResult<()> {
-        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) -> RbResult<()> {
         let file = BufWriter::new(get_file_like(rb_f, true)?);
 
         JsonWriter::new(file)
             .with_json_format(JsonFormat::Json)
-            .finish(&mut self.df.borrow_mut())
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
-    }
-
-    pub fn write_ndjson(&self, rb_f: Value) -> RbResult<()> {
-        let file = BufWriter::new(get_file_like(rb_f, true)?);
-
-        JsonWriter::new(file)
-            .with_json_format(JsonFormat::JsonLines)
-            .finish(&mut self.df.borrow_mut())
-            .map_err(RbPolarsErr::from)?;
-
-        Ok(())
-    }
-
-    pub fn write_ipc(
-        &self,
-        rb_f: Value,
-        compression: Wrap<Option<IpcCompression>>,
-        compat_level: RbCompatLevel,
-        cloud_options: Option<Vec<(String, String)>>,
-        retries: usize,
-    ) -> RbResult<()> {
-        let cloud_options = if let Ok(path) = String::try_convert(rb_f) {
-            let cloud_options = parse_cloud_options(&path, cloud_options.unwrap_or_default())?;
-            Some(cloud_options.with_max_retries(retries))
-        } else {
-            None
-        };
-
-        let f = crate::file::try_get_writeable(rb_f, cloud_options.as_ref())?;
-
-        IpcWriter::new(f)
-            .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(())
     }
@@ -351,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(())
     }
@@ -367,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/mod.rs

@@ -5,27 +5,35 @@ mod io;
 mod serde;
 
 use magnus::{DataTypeFunctions, TypedData, gc};
+use parking_lot::RwLock;
 use polars::prelude::*;
-use std::cell::RefCell;
 
 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),
         }
     }
 }
@@ -36,7 +44,7 @@ impl DataTypeFunctions for RbDataFrame {
         // 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 Ok(df) = self.df.try_borrow() {
+        if let Some(df) = self.df.try_read() {
             for column in df.get_columns() {
                 if let DataType::Object(_) = column.dtype() {
                     match column {

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

@@ -14,7 +14,7 @@ impl RbDataFrame {
 
         Ok(self
             .df
-            .borrow_mut()
+            .write()
             .serialize_into_writer(&mut writer)
             .map_err(RbPolarsErr::from)?)
     }

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, RbIOError, RbRuntimeError, SQLInterfaceError, SQLSyntaxError,
+    SchemaError, SchemaFieldNotFoundError, ShapeError, StringCacheMismatchError,
+    StructFieldNotFoundError,
+};
 
 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 { .. } => {
+                    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::{Error, Ruby};
+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,18 +11,51 @@ 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, Ruby::get().unwrap().exception_type_error());
-create_exception!(RbValueError, Ruby::get().unwrap().exception_arg_error());
-create_exception!(
-    RbOverflowError,
-    Ruby::get().unwrap().exception_range_error()
-);
-create_exception!(RbIndexError, Ruby::get().unwrap().exception_index_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);
+
+macro_rules! create_ruby_exception {
+    ($type:ident, $cls:ident) => {
+        pub struct $type {}
+
+        impl $type {
+            pub fn new_err<T>(message: T) -> Error
+            where
+                T: Into<Cow<'static, str>>,
+            {
+                let cls = Ruby::get().unwrap().$cls();
+                Error::new(cls, message)
+            }
+        }
+    };
+}
+
+create_ruby_exception!(RbKeyboardInterrupt, exception_interrupt);
+create_ruby_exception!(RbIndexError, exception_index_error);
+create_ruby_exception!(RbIOError, exception_io_error);
+create_ruby_exception!(RbOverflowError, exception_range_error);
+create_ruby_exception!(RbRuntimeError, exception_runtime_error);
+create_ruby_exception!(RbTypeError, exception_type_error);
+create_ruby_exception!(RbValueError, exception_arg_error);

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

@@ -159,4 +159,16 @@ impl RbExpr {
     pub fn arr_explode(&self) -> Self {
         self.inner.clone().arr().explode().into()
     }
+
+    pub fn arr_eval(&self, expr: &RbExpr, as_list: bool) -> Self {
+        self.inner
+            .clone()
+            .arr()
+            .eval(expr.inner.clone(), as_list)
+            .into()
+    }
+
+    pub fn arr_agg(&self, expr: &RbExpr) -> Self {
+        self.inner.clone().arr().agg(expr.inner.clone()).into()
+    }
 }

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

@@ -26,8 +26,8 @@ impl RbDataTypeExpr {
         DataTypeExpr::OfExpr(Box::new(expr.inner.clone())).into()
     }
 
-    pub fn collect_dtype(ruby: &Ruby, rb_self: &Self, schema: Wrap<Schema>) -> RbResult<Value> {
-        let dtype = rb_self
+    pub fn collect_dtype(ruby: &Ruby, self_: &Self, schema: Wrap<Schema>) -> RbResult<Value> {
+        let dtype = self_
             .clone()
             .inner
             .into_datatype(&schema.0)

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

@@ -26,10 +26,6 @@ impl RbExpr {
         self.inner.clone().dt().offset_by(by.inner.clone()).into()
     }
 
-    pub fn dt_with_time_unit(&self, tu: Wrap<TimeUnit>) -> Self {
-        self.inner.clone().dt().with_time_unit(tu.0).into()
-    }
-
     pub fn dt_convert_time_zone(&self, time_zone: String) -> RbResult<Self> {
         Ok(self
             .inner
@@ -90,7 +86,6 @@ impl RbExpr {
         self.inner.clone().dt().round(every.inner.clone()).into()
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn dt_replace(
         &self,
         year: &Self,
@@ -162,6 +157,10 @@ impl RbExpr {
         self.clone().inner.dt().month().into()
     }
 
+    pub fn dt_days_in_month(&self) -> Self {
+        self.inner.clone().dt().days_in_month().into()
+    }
+
     pub fn dt_week(&self) -> Self {
         self.clone().inner.dt().week().into()
     }

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

@@ -4,12 +4,14 @@ use magnus::{RArray, Value};
 use polars::lazy::dsl;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
+use polars_core::chunked_array::cast::CastOptions;
 use polars_core::series::IsSorted;
 
+use super::datatype::RbDataTypeExpr;
 use super::selector::RbSelector;
 use crate::conversion::{Wrap, parse_fill_null_strategy};
+use crate::expr::ToExprs;
 use crate::map::lazy::map_single;
-use crate::rb_exprs_to_exprs;
 use crate::{RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
@@ -161,6 +163,10 @@ impl RbExpr {
         self.inner.clone().last().into()
     }
 
+    pub fn item(&self, allow_empty: bool) -> Self {
+        self.inner.clone().item(allow_empty).into()
+    }
+
     pub fn implode(&self) -> Self {
         self.inner.clone().implode().into()
     }
@@ -254,14 +260,20 @@ impl RbExpr {
         self.inner.clone().null_count().into()
     }
 
-    pub fn cast(&self, data_type: Wrap<DataType>, strict: bool) -> RbResult<Self> {
-        let dt = data_type.0;
-        let expr = if strict {
-            self.inner.clone().strict_cast(dt)
+    pub fn cast(&self, dtype: &RbDataTypeExpr, strict: bool, wrap_numerical: bool) -> Self {
+        let options = if wrap_numerical {
+            CastOptions::Overflowing
+        } else if strict {
+            CastOptions::Strict
         } else {
-            self.inner.clone().cast(dt)
+            CastOptions::NonStrict
         };
-        Ok(expr.into())
+
+        let expr = self
+            .inner
+            .clone()
+            .cast_with_options(dtype.inner.clone(), options);
+        expr.into()
     }
 
     pub fn sort_with(&self, descending: bool, nulls_last: bool) -> Self {
@@ -286,7 +298,7 @@ impl RbExpr {
     }
 
     pub fn top_k_by(&self, by: RArray, k: &Self, reverse: Vec<bool>) -> RbResult<Self> {
-        let by = rb_exprs_to_exprs(by)?;
+        let by = by.to_exprs()?;
         Ok(self
             .inner
             .clone()
@@ -299,7 +311,7 @@ impl RbExpr {
     }
 
     pub fn bottom_k_by(&self, by: RArray, k: &Self, reverse: Vec<bool>) -> RbResult<Self> {
-        let by = rb_exprs_to_exprs(by)?;
+        let by = by.to_exprs()?;
         Ok(self
             .inner
             .clone()
@@ -355,7 +367,7 @@ impl RbExpr {
         multithreaded: bool,
         maintain_order: bool,
     ) -> RbResult<Self> {
-        let by = rb_exprs_to_exprs(by)?;
+        let by = by.to_exprs()?;
         Ok(self
             .inner
             .clone()
@@ -585,9 +597,33 @@ impl RbExpr {
         self.inner.clone().is_duplicated().into()
     }
 
-    pub fn over(&self, partition_by: RArray) -> RbResult<Self> {
-        let partition_by = rb_exprs_to_exprs(partition_by)?;
-        Ok(self.inner.clone().over(partition_by).into())
+    pub fn over(
+        &self,
+        partition_by: Option<RArray>,
+        order_by: Option<RArray>,
+        order_by_descending: bool,
+        order_by_nulls_last: bool,
+        mapping_strategy: Wrap<WindowMapping>,
+    ) -> RbResult<Self> {
+        let partition_by = partition_by.map(|v| v.to_exprs()).transpose()?;
+
+        let order_by = order_by.map(|v| v.to_exprs()).transpose()?.map(|order_by| {
+            (
+                order_by,
+                SortOptions {
+                    descending: order_by_descending,
+                    nulls_last: order_by_nulls_last,
+                    ..Default::default()
+                },
+            )
+        });
+
+        Ok(self
+            .inner
+            .clone()
+            .over_with_options(partition_by, order_by, mapping_strategy.0)
+            .map_err(RbPolarsErr::from)?
+            .into())
     }
 
     pub fn rolling(

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

@@ -47,6 +47,10 @@ impl RbExpr {
         self.inner.clone().list().eval(expr.inner.clone()).into()
     }
 
+    pub fn list_agg(&self, expr: &RbExpr) -> Self {
+        self.inner.clone().list().agg(expr.inner.clone()).into()
+    }
+
     pub fn list_filter(&self, predicate: &RbExpr) -> Self {
         self.inner
             .clone()

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

@@ -1,6 +1,7 @@
 use magnus::{RArray, Ruby};
 use polars::prelude::Schema;
 
+use crate::expr::ToRbExprs;
 use crate::{RbExpr, RbPolarsErr, RbResult, Wrap};
 
 impl RbExpr {
@@ -8,15 +9,15 @@ impl RbExpr {
         self.inner == other.inner
     }
 
-    pub fn meta_pop(ruby: &Ruby, rb_self: &Self, schema: Option<Wrap<Schema>>) -> RbResult<RArray> {
+    pub fn meta_pop(ruby: &Ruby, self_: &Self, schema: Option<Wrap<Schema>>) -> RbResult<RArray> {
         let schema = schema.as_ref().map(|s| &s.0);
-        let exprs = rb_self
+        let exprs = self_
             .inner
             .clone()
             .meta()
             .pop(schema)
             .map_err(RbPolarsErr::from)?;
-        Ok(ruby.ary_from_iter(exprs.iter().map(|e| RbExpr::from(e.clone()))))
+        Ok(exprs.to_rbexprs(ruby))
     }
 
     pub fn meta_root_names(&self) -> Vec<String> {
@@ -83,4 +84,8 @@ impl RbExpr {
     pub fn meta_tree_format(&self, schema: Option<Wrap<Schema>>) -> RbResult<String> {
         self.compute_tree_format(false, schema)
     }
+
+    pub fn meta_show_graph(&self, schema: Option<Wrap<Schema>>) -> RbResult<String> {
+        self.compute_tree_format(true, schema)
+    }
 }