polars-df 0.25.1 → 0.26.0

data/ext/polars/src/series/export.rs

@@ -2,49 +2,49 @@ use magnus::{IntoValue, Ruby, Value, value::ReprValue};
 use polars_core::prelude::*;
 
 use crate::prelude::*;
+use crate::ruby::utils::TryIntoValue;
 use crate::{RbPolarsErr, RbResult, RbSeries};
 
 impl RbSeries {
     /// Convert this Series to a Ruby array.
     /// This operation copies data.
-    pub fn to_a(&self) -> RbResult<Value> {
-        let series = &self.series.read();
+    pub fn to_a(ruby: &Ruby, self_: &Self) -> RbResult<Value> {
+        let series = &self_.series.read();
 
-        fn to_a_recursive(series: &Series) -> RbResult<Value> {
-            let ruby = Ruby::get().unwrap();
+        fn to_a_recursive(ruby: &Ruby, series: &Series) -> RbResult<Value> {
             let rblist = match series.dtype() {
                 DataType::Boolean => ruby
-                    .ary_from_iter(series.bool().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.bool().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt8 => ruby
-                    .ary_from_iter(series.u8().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u8().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt16 => ruby
-                    .ary_from_iter(series.u16().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u16().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt32 => ruby
-                    .ary_from_iter(series.u32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt64 => ruby
-                    .ary_from_iter(series.u64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt128 => ruby
-                    .ary_from_iter(series.u128().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u128().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int8 => ruby
-                    .ary_from_iter(series.i8().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i8().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int16 => ruby
-                    .ary_from_iter(series.i16().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i16().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int32 => ruby
-                    .ary_from_iter(series.i32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int64 => ruby
-                    .ary_from_iter(series.i64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int128 => ruby
-                    .ary_from_iter(series.i128().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i128().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Float16 => ruby
                     .ary_from_iter(
@@ -53,14 +53,15 @@ impl RbSeries {
                             .cast(&DataType::Float32)
                             .map_err(RbPolarsErr::from)?
                             .f32()
-                            .map_err(RbPolarsErr::from)?,
+                            .map_err(RbPolarsErr::from)?
+                            .iter(),
                     )
                     .as_value(),
                 DataType::Float32 => ruby
-                    .ary_from_iter(series.f32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.f32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Float64 => ruby
-                    .ary_from_iter(series.f64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.f64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Categorical(_, _) | DataType::Enum(_, _) => {
                     with_match_categorical_physical_type!(series.dtype().cat_physical().unwrap(), |$C| {
@@ -71,10 +72,7 @@ impl RbSeries {
                     let v = ruby.ary_new_capa(series.len());
                     for i in 0..series.len() {
                         let obj: Option<&ObjectValue> = series.get_object(i).map(|any| any.into());
-                        match obj {
-                            Some(val) => v.push(val.to_value()).unwrap(),
-                            None => v.push(ruby.qnil()).unwrap(),
-                        };
+                        v.push(obj.cloned().into_value_with(ruby))?;
                     }
                     v.as_value()
                 }
@@ -87,7 +85,7 @@ impl RbSeries {
                                 v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
-                                let rblst = to_a_recursive(s.as_ref())?;
+                                let rblst = to_a_recursive(ruby, s.as_ref())?;
                                 v.push(rblst)?;
                             }
                         }
@@ -103,7 +101,7 @@ impl RbSeries {
                                 v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
-                                let rblst = to_a_recursive(s.as_ref())?;
+                                let rblst = to_a_recursive(ruby, s.as_ref())?;
                                 v.push(rblst)?;
                             }
                         }
@@ -112,35 +110,35 @@ impl RbSeries {
                 }
                 DataType::Date => {
                     let ca = series.date().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Time => {
                     let ca = series.time().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Datetime(_, _) => {
                     let ca = series.datetime().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Decimal(_, _) => {
                     let ca = series.decimal().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::String => {
                     let ca = series.str().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Struct(_) => {
                     let ca = series.struct_().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Duration(_) => {
                     let ca = series.duration().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Binary => {
                     let ca = series.binary().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Null => {
                     let null: Option<u8> = None;
@@ -163,10 +161,7 @@ impl RbSeries {
                     }
                     impl ExactSizeIterator for NullIter {}
 
-                    Ruby::get()
-                        .unwrap()
-                        .ary_from_iter(NullIter { iter, n })
-                        .as_value()
+                    ruby.ary_from_iter(NullIter { iter, n }).as_value()
                 }
                 DataType::Unknown(_) => {
                     panic!("to_a not implemented for unknown")
@@ -175,12 +170,12 @@ impl RbSeries {
                     unreachable!()
                 }
                 DataType::Extension(_, _) => {
-                    return to_a_recursive(series.ext().unwrap().storage());
+                    return to_a_recursive(ruby, series.ext().unwrap().storage());
                 }
             };
             Ok(rblist.as_value())
         }
 
-        to_a_recursive(series)
+        to_a_recursive(ruby, series)
     }
 }

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

@@ -10,6 +10,7 @@ use crate::ruby::exceptions::{RbIndexError, RbRuntimeError, RbValueError};
 use crate::ruby::gvl::GvlExt;
 use crate::ruby::plan_callback::PlanCallbackExt;
 use crate::ruby::ruby_function::RubyObject;
+use crate::ruby::utils::TryIntoValue;
 use crate::utils::EnterPolarsExt;
 use crate::{RbDataFrame, RbErr, RbPolarsErr, RbResult, RbSeries};
 
@@ -112,7 +113,7 @@ impl RbSeries {
                 let rbseries = RbSeries::new(s);
                 rb_modules::pl_utils(ruby).funcall("wrap_s", (rbseries,))
             }
-            _ => Ok(Wrap(av).into_value_with(ruby)),
+            _ => Wrap(av).try_into_value_with(ruby),
         }
     }
 
@@ -156,8 +157,8 @@ impl RbSeries {
         self.series.write().rename(name.into());
     }
 
-    pub fn dtype(rb: &Ruby, self_: &Self) -> Value {
-        Wrap(self_.series.read().dtype().clone()).into_value_with(rb)
+    pub fn dtype(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        Wrap(self_.series.read().dtype().clone()).try_into_value_with(rb)
     }
 
     pub fn set_sorted_flag(&self, descending: bool) -> Self {

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

@@ -4,6 +4,7 @@ use super::RbSeries;
 use crate::map::series::ApplyLambdaGeneric;
 use crate::prelude::*;
 use crate::ruby::gvl::GvlExt;
+use crate::ruby::utils::TryIntoValue;
 use crate::series::construction::series_from_objects;
 use crate::{RbPolarsErr, RbResult};
 use crate::{apply_all_polars_dtypes, raise_err};
@@ -78,7 +79,7 @@ fn call_and_collect_objects<T, I>(
     skip_nulls: bool,
 ) -> RbResult<Series>
 where
-    T: IntoValue,
+    T: TryIntoValue,
     I: Iterator<Item = Option<T>>,
 {
     let mut objects = Vec::with_capacity(len);
@@ -91,7 +92,7 @@ where
                 continue;
             }
             None => rb.qnil().into_value_with(rb),
-            Some(val) => val.into_value_with(rb),
+            Some(val) => val.try_into_value_with(rb)?,
         };
         let out: Value = lambda.funcall("call", (arg,))?;
         objects.push(ObjectValue {

data/ext/polars/src/series/scatter.rs

@@ -139,23 +139,23 @@ fn scatter_impl(
             with_match_physical_numeric_polars_type!(dt, |$T| {
                 let ca: &mut ChunkedArray<$T> = mutable_s.as_mut();
                 let values: &ChunkedArray<$T> = values.as_ref().as_ref();
-                ca.scatter(idx, values)
+                ca.scatter(idx, values.iter())
             })
         }
         DataType::Boolean => {
             let ca: &mut ChunkedArray<BooleanType> = mutable_s.as_mut();
             let values = values.bool()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         DataType::Binary => {
             let ca: &mut ChunkedArray<BinaryType> = mutable_s.as_mut();
             let values = values.binary()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         DataType::String => {
             let ca: &mut ChunkedArray<StringType> = mutable_s.as_mut();
             let values = values.str()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         _ => Err(PolarsError::ComputeError(
             format!("not yet implemented for dtype: {logical_dtype}").into(),

data/ext/polars/src/utils.rs

@@ -16,7 +16,6 @@ macro_rules! apply_all_polars_dtypes {
     ($self:expr, $method:ident, $($args:expr),*) => {
         match $self.dtype() {
             DataType::Boolean => $self.bool().unwrap().$method($($args),*),
-            DataType::String => $self.str().unwrap().$method($($args),*),
             DataType::UInt8 => $self.u8().unwrap().$method($($args),*),
             DataType::UInt16 => $self.u16().unwrap().$method($($args),*),
             DataType::UInt32 => $self.u32().unwrap().$method($($args),*),
@@ -27,15 +26,40 @@ macro_rules! apply_all_polars_dtypes {
             DataType::Int32 => $self.i32().unwrap().$method($($args),*),
             DataType::Int64 => $self.i64().unwrap().$method($($args),*),
             DataType::Int128 => $self.i128().unwrap().$method($($args),*),
-            DataType::Float16 => todo!(),
+            DataType::Float16 => $self.cast(&DataType::Float32).unwrap().f32().unwrap().$method($($args),*),
             DataType::Float32 => $self.f32().unwrap().$method($($args),*),
             DataType::Float64 => $self.f64().unwrap().$method($($args),*),
-            DataType::Date => $self.date().unwrap().physical().$method($($args),*),
-            DataType::Datetime(_, _) => $self.datetime().unwrap().physical().$method($($args),*),
-            // TODO implement
-            // DataType::List(_) => $self.list().unwrap().$method($($args),*),
+            DataType::String => $self.str().unwrap().$method($($args),*),
+            DataType::Binary => $self.binary().unwrap().$method($($args),*),
+            DataType::Decimal(_, _) => $self.decimal().unwrap().$method($($args),*),
+
+            DataType::Date => $self.date().unwrap().$method($($args),*),
+            DataType::Datetime(_, _) => $self.datetime().unwrap().$method($($args),*),
+            DataType::Duration(_) => $self.duration().unwrap().$method($($args),*),
+            DataType::Time => $self.time().unwrap().$method($($args),*),
+
+            DataType::List(_) => $self.list().unwrap().$method($($args),*),
             DataType::Struct(_) => $self.struct_().unwrap().$method($($args),*),
-            dt => panic!("dtype {:?} not supported", dt)
+            DataType::Array(_, _) => $self.array().unwrap().$method($($args),*),
+
+            dt @ (DataType::Categorical(_, _) | DataType::Enum(_, _)) => match dt.cat_physical().unwrap() {
+                CategoricalPhysical::U8 => $self.cat8().unwrap().$method($($args),*),
+                CategoricalPhysical::U16 => $self.cat16().unwrap().$method($($args),*),
+                CategoricalPhysical::U32 => $self.cat32().unwrap().$method($($args),*),
+            },
+
+            DataType::Object(_) => {
+                $self
+                .as_any()
+                .downcast_ref::<ObjectChunked<ObjectValue>>()
+                .unwrap()
+                .$method($($args),*)
+            },
+            DataType::Extension(_, _) => $self.ext().unwrap().$method($($args),*),
+
+            DataType::Null => $self.null().unwrap().$method($($args),*),
+
+            dt @ (DataType::BinaryOffset | DataType::Unknown(_)) => panic!("dtype {:?} not supported", dt)
         }
     }
 }

data/lib/polars/array_expr.rb

@@ -377,7 +377,9 @@ module Polars
     #   # │ [1, 2]    │
     #   # └───────────┘
     def unique(maintain_order: false)
-      Utils.wrap_expr(_rbexpr.arr_unique(maintain_order))
+      eval(
+        F.element.unique(maintain_order: maintain_order), as_list: true
+      )
     end
 
     # Count the number of unique values in every sub-arrays.
@@ -403,7 +405,7 @@ module Polars
     #   # │ [2, 3, 4]     ┆ 3        │
     #   # └───────────────┴──────────┘
     def n_unique
-      Utils.wrap_expr(_rbexpr.arr_n_unique)
+      agg(F.element.n_unique)
     end
 
     # Convert an Array column into a List column with the same inner data type.
@@ -432,6 +434,13 @@ module Polars
 
     # Evaluate whether any boolean value is true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `false`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `true` values,
+    #     the output is null.
+    #
     # @return [Expr]
     #
     # @example
@@ -461,12 +470,19 @@ module Polars
     #   # │ [null, null]   ┆ false │
     #   # │ null           ┆ null  │
     #   # └────────────────┴───────┘
-    def any
-      Utils.wrap_expr(_rbexpr.arr_any)
+    def any(ignore_nulls: true)
+      agg(F.element.any(ignore_nulls: ignore_nulls))
     end
 
     # Evaluate whether all boolean values are true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `true`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `false` values,
+    #     the output is null.
+    #
     # @return [Expr]
     #
     # @example
@@ -496,8 +512,8 @@ module Polars
     #   # │ [null, null]   ┆ true  │
     #   # │ null           ┆ null  │
     #   # └────────────────┴───────┘
-    def all
-      Utils.wrap_expr(_rbexpr.arr_all)
+    def all(ignore_nulls: true)
+      agg(F.element.all(ignore_nulls: ignore_nulls))
     end
 
     # Sort the arrays in this column.
@@ -567,7 +583,7 @@ module Polars
     #   # │ [9, 1, 2]     ┆ [2, 1, 9]     │
     #   # └───────────────┴───────────────┘
     def reverse
-      Utils.wrap_expr(_rbexpr.arr_reverse)
+      eval(F.element.reverse)
     end
 
     # Retrieve the index of the minimal value in every sub-array.

data/lib/polars/array_name_space.rb

@@ -212,6 +212,13 @@ module Polars
 
     # Evaluate whether any boolean value is true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `false`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `true` values,
+    #     the output is null.
+    #
     # @return [Series]
     #
     # @example
@@ -230,7 +237,7 @@ module Polars
     #   #         false
     #   #         null
     #   # ]
-    def any
+    def any(ignore_nulls: true)
       super
     end
 
@@ -378,6 +385,13 @@ module Polars
 
     # Evaluate whether all boolean values are true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `true`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `false` values,
+    #     the output is null.
+    #
     # @return [Series]
     #
     # @example
@@ -396,7 +410,7 @@ module Polars
     #   #         true
     #   #         null
     #   # ]
-    def all
+    def all(ignore_nulls: true)
       super
     end
 

data/lib/polars/binary_name_space.rb

@@ -226,6 +226,38 @@ module Polars
       super
     end
 
+    # Get the byte value at the given index.
+    #
+    # For example, index `0` would return the first byte of every binary value
+    # and index `-1` would return the last byte of every binary value.
+    # The behavior if an index is out of bounds is determined by the argument
+    # `null_on_oob`.
+    #
+    # @param index [Object]
+    #   Index to return per binary value
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #
+    #   * true -> set as null
+    #   * false -> raise an error
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", ["\x01\x02\x03".b, "".b, "\x04\x05".b])
+    #   s.bin.get(0, null_on_oob: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [u8]
+    #   # [
+    #   #         1
+    #   #         null
+    #   #         4
+    #   # ]
+    def get(index, null_on_oob: false)
+      super
+    end
+
     # Take the first `n` bytes of the binary values.
     #
     # @param n [Object]

data/lib/polars/data_frame.rb

@@ -3808,6 +3808,57 @@ module Polars
       .collect(optimizations: QueryOptFlags._eager)
     end
 
+    # Selects rows from this DataFrame at the given indices.
+    #
+    # @note
+    #   This functionality is experimental. It may be
+    #   changed at any point without it being considered a breaking change.
+    #
+    # @param indices [Object]
+    #   The indices of the rows to select.
+    # @param null_on_oob [Boolean]
+    #   If true when an index is out-of-bounds a null row will be generated
+    #   instead of raising an error.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"x" => [2, 1, 0], "s" => ["foo", "bar", "baz"]})
+    #   df.gather([2, 0, 0])
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬─────┐
+    #   # │ x   ┆ s   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ str │
+    #   # ╞═════╪═════╡
+    #   # │ 0   ┆ baz │
+    #   # │ 2   ┆ foo │
+    #   # │ 2   ┆ foo │
+    #   # └─────┴─────┘
+    #
+    # @example
+    #   df.gather([0, 10, 1], null_on_oob: true)
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌──────┬──────┐
+    #   # │ x    ┆ s    │
+    #   # │ ---  ┆ ---  │
+    #   # │ i64  ┆ str  │
+    #   # ╞══════╪══════╡
+    #   # │ 2    ┆ foo  │
+    #   # │ null ┆ null │
+    #   # │ 1    ┆ bar  │
+    #   # └──────┴──────┘
+    def gather(
+      indices,
+      null_on_oob: false
+    )
+      lazy
+      .gather(indices, null_on_oob: null_on_oob)
+      .collect(optimizations: QueryOptFlags._eager)
+    end
+
     # Apply a custom/user-defined function (UDF) over the rows of the DataFrame.
     #
     # The UDF will receive each row as a tuple of values: `udf(row)`.
@@ -4527,6 +4578,8 @@ module Polars
     # @param separator [String]
     #   Used as separator/delimiter in generated column names in case of multiple
     #   `values` columns.
+    # @param column_naming ['auto', 'combine']
+    #   How resulting column names will be constructed.
     #
     # @return [DataFrame]
     #
@@ -4557,7 +4610,8 @@ module Polars
       aggregate_function: nil,
       maintain_order: true,
       sort_columns: false,
-      separator: "_"
+      separator: "_",
+      column_naming: "auto"
     )
       if on_columns.nil?
         cols = select(on).unique(maintain_order: true)
@@ -4577,7 +4631,8 @@ module Polars
         values: values,
         aggregate_function: aggregate_function,
         maintain_order: maintain_order,
-        separator: separator
+        separator: separator,
+        column_naming: column_naming
       )
       .collect(optimizations: QueryOptFlags._eager)
     end
@@ -4593,7 +4648,8 @@ module Polars
     #
     # @param on [Object]
     #   Column(s) or selector(s) to use as values variables; if `on`
-    #   is empty all columns that are not in `index` will be used.
+    #   is empty no columns will be used. If set to `nil` (default)
+    #   all columns that are not in `index` will be used.
     # @param index [Object]
     #   Column(s) or selector(s) to use as identifier variables.
     # @param variable_name [Object]
@@ -4627,7 +4683,7 @@ module Polars
     #   # │ z   ┆ c        ┆ 6     │
     #   # └─────┴──────────┴───────┘
     def unpivot(on = nil, index: nil, variable_name: nil, value_name: nil)
-      on = on.nil? ? [] : Utils._expand_selectors(self, on)
+      on = on.nil? ? nil : Utils._expand_selectors(self, on)
       index = index.nil? ? [] : Utils._expand_selectors(self, index)
 
       _from_rbdf(_df.unpivot(on, index, value_name, variable_name))
@@ -6488,7 +6544,7 @@ module Polars
     #   # │ foo    ┆ 1   ┆ a   ┆ true ┆ [1, 2]    ┆ baz   │
     #   # │ bar    ┆ 2   ┆ b   ┆ null ┆ [3]       ┆ womp  │
     #   # └────────┴─────┴─────┴──────┴───────────┴───────┘
-    def unnest(columns, *more_columns, separator: nil)
+    def unnest(columns = nil, *more_columns, separator: nil)
       lazy.unnest(columns, *more_columns, separator: separator).collect(optimizations: QueryOptFlags._eager)
     end
 
@@ -6504,6 +6560,10 @@ module Polars
     #   Other DataFrame that must be merged
     # @param key [String]
     #   Key that is sorted.
+    # @param maintain_order [Boolean]
+    #   If `true`, the output is guaranteed to have left-biased ordering
+    #   for equal keys: rows from the left frame appear before rows from
+    #   the right frame when their keys are equal.
     #
     # @return [DataFrame]
     #
@@ -6530,8 +6590,8 @@ module Polars
     #   # │ steve  ┆ 42  │
     #   # │ elise  ┆ 44  │
     #   # └────────┴─────┘
-    def merge_sorted(other, key)
-      lazy.merge_sorted(other.lazy, key).collect(optimizations: QueryOptFlags._eager)
+    def merge_sorted(other, key, maintain_order: false)
+      lazy.merge_sorted(other.lazy, key, maintain_order: maintain_order).collect(optimizations: QueryOptFlags._eager)
     end
 
     # Flag a column as sorted.
@@ -6545,14 +6605,17 @@ module Polars
     #   Column that is sorted.
     # @param descending [Boolean]
     #   Whether the column is sorted in descending order.
+    # @param nulls_last [Boolean]
+    #   Whether the nulls are at the end.
     #
     # @return [DataFrame]
     def set_sorted(
       column,
-      descending: false
+      descending: false,
+      nulls_last: false
     )
       lazy
-        .set_sorted(column, descending: descending)
+        .set_sorted(column, descending: descending, nulls_last: nulls_last)
         .collect(optimizations: QueryOptFlags._eager)
     end
 
@@ -7111,7 +7174,7 @@ module Polars
     end
 
     def _select_rows_by_slice(df, key)
-      return Slice.new(df).apply(key)
+      Slice.new(df).apply(key)
     end
 
     def _select_rows_by_index(df, key)