polars-df 0.25.0 → 0.26.0

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

@@ -1,10 +1,11 @@
 use magnus::prelude::*;
-use magnus::{RHash, Value};
+use magnus::{RHash, Ruby, Value};
 use polars::prelude::{ArrowDataType, DataType};
 use polars_error::polars_err;
 
 use crate::interop::arrow::to_rust::normalize_arrow_fields;
 use crate::prelude::Wrap;
+use crate::ruby::utils::TryIntoValue;
 use crate::series::import_schema_rbcapsule;
 use crate::utils::to_rb_err;
 use crate::{RbResult, RbValueError};
@@ -16,6 +17,7 @@ pub fn init_polars_schema_from_arrow_c_schema(
     polars_schema: RHash,
     schema_object: Value,
 ) -> RbResult<()> {
+    let ruby = &Ruby::get_with(polars_schema);
     let schema_capsule = schema_object.funcall("arrow_c_schema", ())?;
 
     let field = import_schema_rbcapsule(schema_capsule)?;
@@ -33,7 +35,7 @@ pub fn init_polars_schema_from_arrow_c_schema(
         let dtype = DataType::from_arrow_field(&field);
 
         let name = field.name.as_str();
-        let dtype = Wrap(dtype);
+        let dtype = Wrap(dtype).try_into_value_with(ruby)?;
 
         if polars_schema.get(name).is_some() {
             return Err(to_rb_err(polars_err!(

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

@@ -11,7 +11,7 @@ use crate::RbResult;
 
 #[magnus::wrap(class = "Polars::ArrowArrayStream")]
 pub struct RbArrowArrayStream {
-    stream: ffi::ArrowArrayStream,
+    pub(crate) stream: ffi::ArrowArrayStream,
 }
 
 impl RbArrowArrayStream {

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

@@ -1,4 +1,4 @@
-use magnus::Value;
+use magnus::{Ruby, Value};
 use num_traits::{Float, NumCast};
 use polars_core::prelude::*;
 
@@ -10,34 +10,35 @@ use crate::series::RbSeries;
 
 impl RbSeries {
     /// Convert this Series to a Numo array.
-    pub fn to_numo(&self) -> RbResult<Value> {
-        series_to_numo(&self.series.read())
+    pub fn to_numo(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        series_to_numo(rb, &self_.series.read())
     }
 }
 
 /// Convert a Series to a Numo array.
-fn series_to_numo(s: &Series) -> RbResult<Value> {
-    series_to_numo_with_copy(s)
+fn series_to_numo(rb: &Ruby, s: &Series) -> RbResult<Value> {
+    series_to_numo_with_copy(rb, s)
 }
 
 /// Convert a Series to a Numo array, copying data in the process.
-fn series_to_numo_with_copy(s: &Series) -> RbResult<Value> {
+fn series_to_numo_with_copy(rb: &Ruby, s: &Series) -> RbResult<Value> {
     use DataType::*;
     match s.dtype() {
-        Int8 => numeric_series_to_numpy::<Int8Type, f32>(s),
-        Int16 => numeric_series_to_numpy::<Int16Type, f32>(s),
-        Int32 => numeric_series_to_numpy::<Int32Type, f64>(s),
-        Int64 => numeric_series_to_numpy::<Int64Type, f64>(s),
-        UInt8 => numeric_series_to_numpy::<UInt8Type, f32>(s),
-        UInt16 => numeric_series_to_numpy::<UInt16Type, f32>(s),
-        UInt32 => numeric_series_to_numpy::<UInt32Type, f64>(s),
-        UInt64 => numeric_series_to_numpy::<UInt64Type, f64>(s),
-        Float32 => numeric_series_to_numpy::<Float32Type, f32>(s),
-        Float64 => numeric_series_to_numpy::<Float64Type, f64>(s),
-        Boolean => boolean_series_to_numo(s),
+        Int8 => numeric_series_to_numo::<Int8Type, f32>(rb, s),
+        Int16 => numeric_series_to_numo::<Int16Type, f32>(rb, s),
+        Int32 => numeric_series_to_numo::<Int32Type, f64>(rb, s),
+        Int64 => numeric_series_to_numo::<Int64Type, f64>(rb, s),
+        UInt8 => numeric_series_to_numo::<UInt8Type, f32>(rb, s),
+        UInt16 => numeric_series_to_numo::<UInt16Type, f32>(rb, s),
+        UInt32 => numeric_series_to_numo::<UInt32Type, f64>(rb, s),
+        UInt64 => numeric_series_to_numo::<UInt64Type, f64>(rb, s),
+        Float32 => numeric_series_to_numo::<Float32Type, f32>(rb, s),
+        Float64 => numeric_series_to_numo::<Float64Type, f64>(rb, s),
+        Boolean => boolean_series_to_numo(rb, s),
         String => {
             let ca = s.str().unwrap();
-            RbArray1::from_iter(ca)
+            let values = ca.iter();
+            RbArray1::from_iter(rb, values)
         }
         dt => {
             raise_err!(
@@ -49,7 +50,7 @@ fn series_to_numo_with_copy(s: &Series) -> RbResult<Value> {
 }
 
 /// Convert numeric types to f32 or f64 with NaN representing a null value.
-fn numeric_series_to_numpy<T, U>(s: &Series) -> RbResult<Value>
+fn numeric_series_to_numo<T, U>(rb: &Ruby, s: &Series) -> RbResult<Value>
 where
     T: PolarsNumericType,
     T::Native: Element,
@@ -58,25 +59,25 @@ where
     let ca: &ChunkedArray<T> = s.as_ref().as_ref();
     if s.null_count() == 0 {
         let values = ca.into_no_null_iter();
-        RbArray1::<T::Native>::from_iter(values)
+        RbArray1::<T::Native>::from_iter(rb, values)
     } else {
         let mapper = |opt_v: Option<T::Native>| match opt_v {
             Some(v) => NumCast::from(v).unwrap(),
             None => U::nan(),
         };
         let values = ca.iter().map(mapper);
-        RbArray1::from_iter(values)
+        RbArray1::from_iter(rb, values)
     }
 }
 
 /// Convert booleans to bit if no nulls are present, otherwise convert to objects.
-fn boolean_series_to_numo(s: &Series) -> RbResult<Value> {
+fn boolean_series_to_numo(rb: &Ruby, s: &Series) -> RbResult<Value> {
     let ca = s.bool().unwrap();
     if s.null_count() == 0 {
-        let values = ca.into_no_null_iter();
-        RbArray1::<bool>::from_iter(values)
+        let values = ca.no_null_iter();
+        RbArray1::<bool>::from_iter(rb, values)
     } else {
         let values = ca.iter();
-        RbArray1::from_iter(values)
+        RbArray1::from_iter(rb, values)
     }
 }

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

@@ -11,9 +11,9 @@ use polars_io::{HiveOptions, RowIndex};
 use polars_utils::IdxSize;
 use polars_utils::slice_enum::Slice;
 
-use crate::RbResult;
 use crate::io::cloud_options::OptRbCloudOptions;
 use crate::prelude::Wrap;
+use crate::{RbDataFrame, RbResult};
 
 /// Interface to `class ScanOptions` on the Ruby side
 pub struct RbScanOptions(Value);
@@ -25,8 +25,11 @@ impl TryConvert for RbScanOptions {
 }
 
 impl TryConvert for Wrap<TableStatistics> {
-    fn try_convert(_ob: Value) -> RbResult<Self> {
-        todo!();
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let attr: Value = ob.funcall("_df", ())?;
+        Ok(Wrap(TableStatistics(Arc::new(
+            <&RbDataFrame>::try_convert(attr)?.clone().df.into_inner(),
+        ))))
     }
 }
 

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

@@ -26,6 +26,7 @@ impl RbSinkOptions {
         let sync_on_close: Option<Wrap<SyncOnCloseType>> = self.0.funcall("sync_on_close", ())?;
         let storage_options: OptRbCloudOptions = self.0.funcall("storage_options", ())?;
         let credential_provider: Option<Value> = self.0.funcall("credential_provider", ())?;
+        let sinked_paths_callback: Option<Value> = self.0.funcall("sinked_paths_callback", ())?;
 
         let cloud_options =
             storage_options.extract_opt_cloud_options(cloud_scheme, credential_provider)?;
@@ -37,6 +38,7 @@ impl RbSinkOptions {
             maintain_order,
             sync_on_close,
             cloud_options: cloud_options.map(Arc::new),
+            sinked_paths_callback: sinked_paths_callback.map(|_| todo!()),
         };
 
         Ok(unified_sink_args)

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

@@ -1,10 +1,13 @@
+use arrow::ffi::export_iterator;
 use magnus::{
     IntoValue, RArray, RHash, Ruby, TryConvert, Value, r_hash::ForEach, value::ReprValue,
 };
 use parking_lot::Mutex;
+use polars::frame::PivotColumnNaming;
 use polars::io::RowIndex;
 use polars::lazy::frame::LazyFrame;
 use polars::prelude::*;
+use polars_core::query_result::QueryResult;
 use polars_plan::dsl::ScanSources;
 use polars_plan::plans::{HintIR, Sorted};
 use std::num::NonZeroUsize;
@@ -19,8 +22,14 @@ use crate::io::sink_options::RbSinkOptions;
 use crate::io::sink_output::RbFileSinkDestination;
 use crate::ruby::gvl::GvlExt;
 use crate::ruby::lazy::RubyUdfLazyFrameExt;
-use crate::utils::EnterPolarsExt;
-use crate::{RbDataFrame, RbExpr, RbLazyGroupBy, RbPolarsErr, RbResult, RbValueError};
+use crate::ruby::plan_callback::PlanCallbackExt;
+use crate::ruby::ruby_function::RubyObject;
+use crate::ruby::utils::TryIntoValue;
+use crate::utils::{EnterPolarsExt, to_rb_err};
+use crate::{
+    RbArrowArrayStream, RbDataFrame, RbExpr, RbLazyGroupBy, RbPolarsErr, RbResult, RbTypeError,
+    RbValueError,
+};
 
 fn rbobject_to_first_path_and_scan_sources(
     obj: Value,
@@ -128,6 +137,7 @@ impl RbLazyFrame {
         let cloud_options = OptRbCloudOptions::try_convert(arguments[28])?;
         let credential_provider = Option::<Value>::try_convert(arguments[29])?;
         let include_file_paths = Option::<String>::try_convert(arguments[30])?;
+        let missing_columns = Option::<Wrap<MissingColumnsPolicy>>::try_convert(arguments[31])?;
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
@@ -189,7 +199,8 @@ impl RbLazyFrame {
             .with_decimal_comma(decimal_comma)
             .with_glob(glob)
             .with_raise_if_empty(raise_if_empty)
-            .with_include_file_paths(include_file_paths.map(|x| x.into()));
+            .with_include_file_paths(include_file_paths.map(|x| x.into()))
+            .with_missing_columns_policy(missing_columns.map(|x| x.0));
 
         if let Some(lambda) = with_schema_modify {
             let f = |schema: Schema| {
@@ -272,6 +283,25 @@ impl RbLazyFrame {
         Ok(lf.into())
     }
 
+    pub fn new_from_scan_lines(
+        sources: Wrap<ScanSources>,
+        scan_options: RbScanOptions,
+        name: String,
+    ) -> RbResult<Self> {
+        let sources = sources.0;
+        let first_path = sources.first_path();
+
+        let unified_scan_args =
+            scan_options.extract_unified_scan_args(first_path.and_then(|x| x.scheme()))?;
+
+        let dsl: DslPlan = DslBuilder::scan_lines(sources, unified_scan_args, (&*name).into())
+            .map_err(to_rb_err)?
+            .build();
+        let lf: LazyFrame = dsl.into();
+
+        Ok(lf.into())
+    }
+
     pub fn describe_plan(rb: &Ruby, self_: &Self) -> RbResult<String> {
         rb.enter_polars(|| self_.ldf.read().describe_plan())
     }
@@ -388,7 +418,11 @@ impl RbLazyFrame {
     pub fn collect(rb: &Ruby, self_: &Self, engine: Wrap<Engine>) -> RbResult<RbDataFrame> {
         rb.enter_polars_df(|| {
             let ldf = self_.ldf.read().clone();
-            ldf.collect_with_engine(engine.0)
+            ldf.collect_with_engine(engine.0).map(|r| match r {
+                QueryResult::Single(df) => df,
+                // TODO: Should return query results
+                QueryResult::Multiple(_) => DataFrame::empty(),
+            })
         })
     }
 
@@ -409,7 +443,7 @@ impl RbLazyFrame {
 
             PolarsResult::Ok(RbCollectBatches {
                 inner: Arc::new(Mutex::new(collect_batches)),
-                _ldf: ldf,
+                ldf,
             })
         })
     }
@@ -573,6 +607,20 @@ impl RbLazyFrame {
         .map(Into::into)
     }
 
+    pub fn sink_batches(
+        rb: &Ruby,
+        self_: &Self,
+        function: Value,
+        maintain_order: bool,
+        chunk_size: Option<NonZeroUsize>,
+    ) -> RbResult<RbLazyFrame> {
+        let ldf = self_.ldf.read().clone();
+        // ensure new_ruby is called with GVL
+        let callback = PlanCallback::new_ruby(RubyObject::from(function));
+        rb.enter_polars(|| ldf.sink_batches(callback, maintain_order, chunk_size))
+            .map(Into::into)
+    }
+
     pub fn filter(&self, predicate: &RbExpr) -> Self {
         let ldf = self.ldf.read().clone();
         ldf.filter(predicate.inner.clone()).into()
@@ -771,6 +819,12 @@ impl RbLazyFrame {
             .into())
     }
 
+    pub fn gather(&self, idxs: &Self, null_on_oob: bool) -> Self {
+        let ldf = self.ldf.read().clone();
+        let idxs = idxs.clone().ldf.into_inner();
+        ldf.gather(idxs, null_on_oob).into()
+    }
+
     pub fn with_column(&self, expr: &RbExpr) -> Self {
         let ldf = self.ldf.read().clone();
         ldf.with_column(expr.inner.clone()).into()
@@ -786,6 +840,127 @@ impl RbLazyFrame {
         Ok(ldf.with_columns_seq(exprs.to_exprs()?).into())
     }
 
+    pub fn match_to_schema(
+        &self,
+        schema: Wrap<Schema>,
+        missing_columns: Value,
+        missing_struct_fields: Value,
+        extra_columns: Wrap<ExtraColumnsPolicy>,
+        extra_struct_fields: Value,
+        integer_cast: Value,
+        float_cast: Value,
+    ) -> RbResult<Self> {
+        fn parse_missing_columns(
+            schema: &Schema,
+            missing_columns: Value,
+        ) -> RbResult<Vec<MissingColumnsPolicyOrExpr>> {
+            let mut out = Vec::with_capacity(schema.len());
+            if let Ok(policy) = Wrap::<MissingColumnsPolicyOrExpr>::try_convert(missing_columns) {
+                out.extend(std::iter::repeat_n(policy.0, schema.len()));
+            } else if let Ok(dict) = RHash::try_convert(missing_columns) {
+                out.extend(std::iter::repeat_n(
+                    MissingColumnsPolicyOrExpr::Raise,
+                    schema.len(),
+                ));
+                dict.foreach(|key: String, value: Wrap<MissingColumnsPolicyOrExpr>| {
+                    out[schema.try_index_of(&key).map_err(to_rb_err)?] = value.0;
+                    Ok(ForEach::Continue)
+                })?;
+            } else {
+                return Err(RbTypeError::new_err("Invalid value for `missing_columns`"));
+            }
+            Ok(out)
+        }
+        fn parse_missing_struct_fields(
+            schema: &Schema,
+            missing_struct_fields: Value,
+        ) -> RbResult<Vec<MissingColumnsPolicy>> {
+            let mut out = Vec::with_capacity(schema.len());
+            if let Ok(policy) = Wrap::<MissingColumnsPolicy>::try_convert(missing_struct_fields) {
+                out.extend(std::iter::repeat_n(policy.0, schema.len()));
+            } else if let Ok(dict) = RHash::try_convert(missing_struct_fields) {
+                out.extend(std::iter::repeat_n(
+                    MissingColumnsPolicy::Raise,
+                    schema.len(),
+                ));
+                dict.foreach(|key: String, value: Wrap<MissingColumnsPolicy>| {
+                    out[schema.try_index_of(&key).map_err(to_rb_err)?] = value.0;
+                    Ok(ForEach::Continue)
+                })?;
+            } else {
+                return Err(RbTypeError::new_err(
+                    "Invalid value for `missing_struct_fields`",
+                ));
+            }
+            Ok(out)
+        }
+        fn parse_extra_struct_fields(
+            schema: &Schema,
+            extra_struct_fields: Value,
+        ) -> RbResult<Vec<ExtraColumnsPolicy>> {
+            let mut out = Vec::with_capacity(schema.len());
+            if let Ok(policy) = Wrap::<ExtraColumnsPolicy>::try_convert(extra_struct_fields) {
+                out.extend(std::iter::repeat_n(policy.0, schema.len()));
+            } else if let Ok(dict) = RHash::try_convert(extra_struct_fields) {
+                out.extend(std::iter::repeat_n(ExtraColumnsPolicy::Raise, schema.len()));
+                dict.foreach(|key: String, value: Wrap<ExtraColumnsPolicy>| {
+                    out[schema.try_index_of(&key).map_err(to_rb_err)?] = value.0;
+                    Ok(ForEach::Continue)
+                })?;
+            } else {
+                return Err(RbTypeError::new_err(
+                    "Invalid value for `extra_struct_fields`",
+                ));
+            }
+            Ok(out)
+        }
+        fn parse_cast(schema: &Schema, cast: Value) -> RbResult<Vec<UpcastOrForbid>> {
+            let mut out = Vec::with_capacity(schema.len());
+            if let Ok(policy) = Wrap::<UpcastOrForbid>::try_convert(cast) {
+                out.extend(std::iter::repeat_n(policy.0, schema.len()));
+            } else if let Ok(dict) = RHash::try_convert(cast) {
+                out.extend(std::iter::repeat_n(UpcastOrForbid::Forbid, schema.len()));
+                dict.foreach(|key: String, value: Wrap<UpcastOrForbid>| {
+                    out[schema.try_index_of(&key).map_err(to_rb_err)?] = value.0;
+                    Ok(ForEach::Continue)
+                })?;
+            } else {
+                return Err(RbTypeError::new_err(
+                    "Invalid value for `integer_cast` / `float_cast`",
+                ));
+            }
+            Ok(out)
+        }
+
+        let missing_columns = parse_missing_columns(&schema.0, missing_columns)?;
+        let missing_struct_fields = parse_missing_struct_fields(&schema.0, missing_struct_fields)?;
+        let extra_struct_fields = parse_extra_struct_fields(&schema.0, extra_struct_fields)?;
+        let integer_cast = parse_cast(&schema.0, integer_cast)?;
+        let float_cast = parse_cast(&schema.0, float_cast)?;
+
+        let per_column = (0..schema.0.len())
+            .map(|i| MatchToSchemaPerColumn {
+                missing_columns: missing_columns[i].clone(),
+                missing_struct_fields: missing_struct_fields[i],
+                extra_struct_fields: extra_struct_fields[i],
+                integer_cast: integer_cast[i],
+                float_cast: float_cast[i],
+            })
+            .collect();
+
+        let ldf = self.ldf.read().clone();
+        Ok(ldf
+            .match_to_schema(Arc::new(schema.0), per_column, extra_columns.0)
+            .into())
+    }
+
+    pub fn pipe_with_schema(&self, callback: Value) -> Self {
+        let ldf = self.ldf.read().clone();
+        let function = RubyObject::from(callback);
+        ldf.pipe_with_schema(PlanCallback::new_ruby(function))
+            .into()
+    }
+
     pub fn rename(&self, existing: Vec<String>, new: Vec<String>, strict: bool) -> Self {
         let ldf = self.ldf.read().clone();
         ldf.rename(existing, new, strict).into()
@@ -930,6 +1105,7 @@ impl RbLazyFrame {
         agg: &RbExpr,
         maintain_order: bool,
         separator: String,
+        column_naming: Wrap<PivotColumnNaming>,
     ) -> Self {
         let ldf = self.ldf.read().clone();
         ldf.pivot(
@@ -940,6 +1116,7 @@ impl RbLazyFrame {
             agg.inner.clone(),
             maintain_order,
             separator.into(),
+            column_naming.0,
         )
         .into()
     }
@@ -981,7 +1158,7 @@ impl RbLazyFrame {
         opt.set(OptFlags::PREDICATE_PUSHDOWN, predicate_pushdown);
         opt.set(OptFlags::PROJECTION_PUSHDOWN, projection_pushdown);
         opt.set(OptFlags::SLICE_PUSHDOWN, slice_pushdown);
-        opt.set(OptFlags::NEW_STREAMING, streamable);
+        opt.set(OptFlags::STREAMING, streamable);
 
         self.ldf
             .read()
@@ -1022,14 +1199,12 @@ impl RbLazyFrame {
         let schema = rb.enter_polars(|| self_.ldf.write().collect_schema())?;
 
         let schema_dict = rb.hash_new();
-        schema.iter_fields().for_each(|fld| {
-            schema_dict
-                .aset::<String, Value>(
-                    fld.name().to_string(),
-                    Wrap(fld.dtype().clone()).into_value_with(rb),
-                )
-                .unwrap();
-        });
+        for fld in schema.iter_fields() {
+            schema_dict.aset(
+                fld.name().to_string(),
+                Wrap(fld.dtype().clone()).try_into_value_with(rb)?,
+            )?;
+        }
         Ok(schema_dict)
     }
 
@@ -1049,12 +1224,12 @@ impl RbLazyFrame {
         ldf.count().into()
     }
 
-    pub fn merge_sorted(&self, other: &Self, key: String) -> RbResult<Self> {
+    pub fn merge_sorted(&self, other: &Self, key: String, maintain_order: bool) -> RbResult<Self> {
         let out = self
             .ldf
             .read()
             .clone()
-            .merge_sorted(other.ldf.read().clone(), &key)
+            .merge_sorted(other.ldf.read().clone(), &key, maintain_order)
             .map_err(RbPolarsErr::from)?;
         Ok(out.into())
     }
@@ -1118,7 +1293,7 @@ impl RbLazyFrame {
 #[magnus::wrap(class = "Polars::RbCollectBatches")]
 pub struct RbCollectBatches {
     inner: Arc<Mutex<CollectBatches>>,
-    _ldf: LazyFrame,
+    ldf: LazyFrame,
 }
 
 impl RbCollectBatches {
@@ -1126,4 +1301,55 @@ impl RbCollectBatches {
         let inner = Arc::clone(&slf.inner);
         rb.enter_polars(|| PolarsResult::Ok(inner.lock().next().transpose()?.map(RbDataFrame::new)))
     }
+
+    pub fn __arrow_c_stream__(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        let mut ldf = self_.ldf.clone();
+        let schema = ldf
+            .collect_schema()
+            .map_err(RbPolarsErr::from)?
+            .to_arrow(CompatLevel::newest());
+
+        let dtype = ArrowDataType::Struct(schema.into_iter_values().collect());
+
+        let iter = Box::new(ArrowStreamIterator::new(self_.inner.clone(), dtype.clone()));
+        let field = ArrowField::new(PlSmallStr::EMPTY, dtype, false);
+        let stream = export_iterator(iter, field);
+        Ok(RbArrowArrayStream { stream }.into_value_with(rb))
+    }
+}
+
+pub struct ArrowStreamIterator {
+    inner: Arc<Mutex<CollectBatches>>,
+    dtype: ArrowDataType,
+}
+
+impl ArrowStreamIterator {
+    fn new(inner: Arc<Mutex<CollectBatches>>, schema: ArrowDataType) -> Self {
+        Self {
+            inner,
+            dtype: schema,
+        }
+    }
+}
+
+impl Iterator for ArrowStreamIterator {
+    type Item = PolarsResult<ArrayRef>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let next = self.inner.lock().next();
+        match next {
+            None => None,
+            Some(Err(err)) => Some(Err(err)),
+            Some(Ok(df)) => {
+                let height = df.height();
+                let arrays = df.rechunk_into_arrow(CompatLevel::newest());
+                Some(Ok(Box::new(arrow::array::StructArray::new(
+                    self.dtype.clone(),
+                    height,
+                    arrays,
+                    None,
+                ))))
+            }
+        }
+    }
 }

data/ext/polars/src/lazyframe/optflags.rs

@@ -52,7 +52,8 @@ flag_getter_setters! {
     (COMM_SUBEXPR_ELIM, get_comm_subexpr_elim, set_comm_subexpr_elim, clear=true)
     (CHECK_ORDER_OBSERVE, get_check_order_observe, set_check_order_observe, clear=true)
     (FAST_PROJECTION, get_fast_projection, set_fast_projection, clear=true)
+    (SORT_COLLAPSE, get_sort_collapse, set_sort_collapse, clear=true)
 
     (EAGER, get_eager, set_eager, clear=true)
-    (NEW_STREAMING, get_streaming, set_streaming, clear=true)
+    (STREAMING, get_streaming, set_streaming, clear=true)
 }