polars-df 0.7.0-x86_64-linux → 0.9.0-x86_64-linux

data/lib/polars/data_frame.rb

@@ -47,8 +47,8 @@ module Polars
     end
 
     # @private
-    def self._from_hashes(data, infer_schema_length: 100, schema: nil)
-      rbdf = RbDataFrame.read_hashes(data, infer_schema_length, schema)
+    def self._from_hashes(data, infer_schema_length: 100, schema: nil, schema_overrides: nil)
+      rbdf = RbDataFrame.read_hashes(data, infer_schema_length, schema, schema_overrides)
       _from_rbdf(rbdf)
     end
 
@@ -119,10 +119,10 @@ module Polars
 
       processed_null_values = Utils._process_null_values(null_values)
 
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
       end
-      if file.is_a?(String) && file.include?("*")
+      if file.is_a?(::String) && file.include?("*")
         dtypes_dict = nil
         if !dtype_list.nil?
           dtypes_dict = dtype_list.to_h
@@ -206,11 +206,11 @@ module Polars
       if Utils.pathlike?(source)
         source = Utils.normalise_filepath(source)
       end
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
       end
 
-      if source.is_a?(String) && source.include?("*") && Utils.local_file?(source)
+      if source.is_a?(::String) && source.include?("*") && Utils.local_file?(source)
         scan =
           Polars.scan_parquet(
             source,
@@ -269,11 +269,11 @@ module Polars
       if Utils.pathlike?(file)
         file = Utils.normalise_filepath(file)
       end
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
       end
 
-      if file.is_a?(String) && file.include?("*")
+      if file.is_a?(::String) && file.include?("*")
         raise Todo
       end
 
@@ -411,7 +411,7 @@ module Polars
     #     }
     #   )
     #   df.dtypes
-    #   # => [Polars::Int64, Polars::Float64, Polars::Utf8]
+    #   # => [Polars::Int64, Polars::Float64, Polars::String]
     def dtypes
       _df.dtypes
     end
@@ -429,7 +429,7 @@ module Polars
     #     }
     #   )
     #   df.schema
-    #   # => {"foo"=>Polars::Int64, "bar"=>Polars::Float64, "ham"=>Polars::Utf8}
+    #   # => {"foo"=>Polars::Int64, "bar"=>Polars::Float64, "ham"=>Polars::String}
     def schema
       columns.zip(dtypes).to_h
     end
@@ -589,13 +589,13 @@ module Polars
             return df.slice(row_selection, 1)
           end
           # df[2, "a"]
-          if col_selection.is_a?(String) || col_selection.is_a?(Symbol)
+          if col_selection.is_a?(::String) || col_selection.is_a?(Symbol)
             return self[col_selection][row_selection]
           end
         end
 
         # column selection can be "a" and ["a", "b"]
-        if col_selection.is_a?(String) || col_selection.is_a?(Symbol)
+        if col_selection.is_a?(::String) || col_selection.is_a?(Symbol)
           col_selection = [col_selection]
         end
 
@@ -621,8 +621,8 @@ module Polars
 
         # select single column
         # df["foo"]
-        if item.is_a?(String) || item.is_a?(Symbol)
-          return Utils.wrap_s(_df.column(item.to_s))
+        if item.is_a?(::String) || item.is_a?(Symbol)
+          return Utils.wrap_s(_df.get_column(item.to_s))
         end
 
         # df[idx]
@@ -647,7 +647,7 @@ module Polars
 
         if item.is_a?(Series)
           dtype = item.dtype
-          if dtype == Utf8
+          if dtype == String
             return _from_rbdf(_df.select(item))
           elsif dtype == UInt32
             return _from_rbdf(_df.take_with_series(item._s))
@@ -698,7 +698,7 @@ module Polars
         s[row_selection] = value
 
         if col_selection.is_a?(Integer)
-          replace_at_idx(col_selection, s)
+          replace_column(col_selection, s)
         elsif Utils.strlike?(col_selection)
           replace(col_selection, s)
         end
@@ -1084,7 +1084,7 @@ module Polars
     #   df.estimated_size
     #   # => 25888898
     #   df.estimated_size("mb")
-    #   # => 24.689577102661133
+    #   # => 26.702880859375
     def estimated_size(unit = "b")
       sz = _df.estimated_size
       Utils.scale_bytes(sz, to: unit)
@@ -1222,7 +1222,7 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 2, 3], "bar" => [4, 5, 6]})
     #   s = Polars::Series.new("baz", [97, 98, 99])
-    #   df.insert_at_idx(1, s)
+    #   df.insert_column(1, s)
     #   # =>
     #   # shape: (3, 3)
     #   # ┌─────┬─────┬─────┐
@@ -1244,7 +1244,7 @@ module Polars
     #     }
     #   )
     #   s = Polars::Series.new("d", [-2.5, 15, 20.5, 0])
-    #   df.insert_at_idx(3, s)
+    #   df.insert_column(3, s)
     #   # =>
     #   # shape: (4, 4)
     #   # ┌─────┬──────┬───────┬──────┐
@@ -1257,13 +1257,14 @@ module Polars
     #   # │ 3   ┆ 10.0 ┆ false ┆ 20.5 │
     #   # │ 4   ┆ 13.0 ┆ true  ┆ 0.0  │
     #   # └─────┴──────┴───────┴──────┘
-    def insert_at_idx(index, series)
+    def insert_column(index, series)
       if index < 0
         index = columns.length + index
       end
-      _df.insert_at_idx(index, series._s)
+      _df.insert_column(index, series._s)
       self
     end
+    alias_method :insert_at_idx, :insert_column
 
     # Filter the rows in the DataFrame based on a predicate expression.
     #
@@ -1367,7 +1368,7 @@ module Polars
           ]
         )._df
       )
-      summary.insert_at_idx(
+      summary.insert_column(
         0,
         Polars::Series.new(
           "describe",
@@ -1388,11 +1389,12 @@ module Polars
     #   df = Polars::DataFrame.new(
     #     {"foo" => [1, 2, 3], "bar" => [6, 7, 8], "ham" => ["a", "b", "c"]}
     #   )
-    #   df.find_idx_by_name("ham")
+    #   df.get_column_index("ham")
     #   # => 2
-    def find_idx_by_name(name)
-      _df.find_idx_by_name(name)
+    def get_column_index(name)
+      _df.get_column_index(name)
     end
+    alias_method :find_idx_by_name, :get_column_index
 
     # Replace a column at an index location.
     #
@@ -1412,7 +1414,7 @@ module Polars
     #     }
     #   )
     #   s = Polars::Series.new("apple", [10, 20, 30])
-    #   df.replace_at_idx(0, s)
+    #   df.replace_column(0, s)
     #   # =>
     #   # shape: (3, 3)
     #   # ┌───────┬─────┬─────┐
@@ -1424,13 +1426,14 @@ module Polars
     #   # │ 20    ┆ 7   ┆ b   │
     #   # │ 30    ┆ 8   ┆ c   │
     #   # └───────┴─────┴─────┘
-    def replace_at_idx(index, series)
+    def replace_column(index, series)
       if index < 0
         index = columns.length + index
       end
-      _df.replace_at_idx(index, series._s)
+      _df.replace_column(index, series._s)
       self
     end
+    alias_method :replace_at_idx, :replace_column
 
     # Sort the DataFrame by column.
     #
@@ -1524,13 +1527,14 @@ module Polars
     #       "ham" => ["c", "b", "a"]
     #     }
     #   )
-    #   df1.frame_equal(df1)
+    #   df1.equals(df1)
     #   # => true
-    #   df1.frame_equal(df2)
+    #   df1.equals(df2)
     #   # => false
-    def frame_equal(other, null_equal: true)
-      _df.frame_equal(other._df, null_equal)
+    def equals(other, null_equal: true)
+      _df.equals(other._df, null_equal)
     end
+    alias_method :frame_equal, :equals
 
     # Replace a column by a new Series.
     #
@@ -1716,7 +1720,7 @@ module Polars
     #   # │ 3   ┆ 8   ┆ c   │
     #   # └─────┴─────┴─────┘
     def drop_nulls(subset: nil)
-      if subset.is_a?(String)
+      if subset.is_a?(::String)
         subset = [subset]
       end
       _from_rbdf(_df.drop_nulls(subset))
@@ -1778,7 +1782,7 @@ module Polars
     #       "b" => [2, 4, 6]
     #     }
     #   )
-    #   df.with_row_count
+    #   df.with_row_index
     #   # =>
     #   # shape: (3, 3)
     #   # ┌────────┬─────┬─────┐
@@ -1790,9 +1794,10 @@ module Polars
     #   # │ 1      ┆ 3   ┆ 4   │
     #   # │ 2      ┆ 5   ┆ 6   │
     #   # └────────┴─────┴─────┘
-    def with_row_count(name: "row_nr", offset: 0)
-      _from_rbdf(_df.with_row_count(name, offset))
+    def with_row_index(name: "row_nr", offset: 0)
+      _from_rbdf(_df.with_row_index(name, offset))
     end
+    alias_method :with_row_count, :with_row_index
 
     # Start a group by operation.
     #
@@ -2267,7 +2272,7 @@ module Polars
       if by.nil?
         by = []
       end
-      if by.is_a?(String)
+      if by.is_a?(::String)
         by = [by]
       end
       if offset.nil?
@@ -2429,6 +2434,8 @@ module Polars
     #   Join strategy.
     # @param suffix [String]
     #   Suffix to append to columns with a duplicate name.
+    # @param join_nulls [Boolean]
+    #   Join on null values. By default null values will never produce matches.
     #
     # @return [DataFrame]
     #
@@ -2461,17 +2468,17 @@ module Polars
     # @example
     #   df.join(other_df, on: "ham", how: "outer")
     #   # =>
-    #   # shape: (4, 4)
-    #   # ┌──────┬──────┬─────┬───────┐
-    #   # │ foo  ┆ bar  ┆ ham ┆ apple │
-    #   # │ ---  ┆ ---  ┆ --- ┆ ---   │
-    #   # │ i64  ┆ f64  ┆ str ┆ str   │
-    #   # ╞══════╪══════╪═════╪═══════╡
-    #   # │ 1    ┆ 6.0  ┆ a   ┆ x     │
-    #   # │ 2    ┆ 7.0  ┆ b   ┆ y     │
-    #   # │ null ┆ null ┆ d   ┆ z     │
-    #   # │ 3    ┆ 8.0  ┆ c   ┆ null  │
-    #   # └──────┴──────┴─────┴───────┘
+    #   # shape: (4, 5)
+    #   # ┌──────┬──────┬──────┬───────┬───────────┐
+    #   # │ foo  ┆ bar  ┆ ham  ┆ apple ┆ ham_right │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---   ┆ ---       │
+    #   # │ i64  ┆ f64  ┆ str  ┆ str   ┆ str       │
+    #   # ╞══════╪══════╪══════╪═══════╪═══════════╡
+    #   # │ 1    ┆ 6.0  ┆ a    ┆ x     ┆ a         │
+    #   # │ 2    ┆ 7.0  ┆ b    ┆ y     ┆ b         │
+    #   # │ null ┆ null ┆ null ┆ z     ┆ d         │
+    #   # │ 3    ┆ 8.0  ┆ c    ┆ null  ┆ null      │
+    #   # └──────┴──────┴──────┴───────┴───────────┘
     #
     # @example
     #   df.join(other_df, on: "ham", how: "left")
@@ -2511,7 +2518,7 @@ module Polars
     #   # ╞═════╪═════╪═════╡
     #   # │ 3   ┆ 8.0 ┆ c   │
     #   # └─────┴─────┴─────┘
-    def join(other, left_on: nil, right_on: nil, on: nil, how: "inner", suffix: "_right")
+    def join(other, left_on: nil, right_on: nil, on: nil, how: "inner", suffix: "_right", join_nulls: false)
       lazy
         .join(
           other.lazy,
@@ -2520,6 +2527,7 @@ module Polars
           on: on,
           how: how,
           suffix: suffix,
+          join_nulls: join_nulls
         )
         .collect(no_optimization: true)
     end
@@ -2863,7 +2871,7 @@ module Polars
     #       "c" => [true, true, false, nil]
     #     }
     #   )
-    #   df.cleared
+    #   df.clear
     #   # =>
     #   # shape: (0, 3)
     #   # ┌─────┬─────┬──────┐
@@ -2872,9 +2880,31 @@ module Polars
     #   # │ i64 ┆ f64 ┆ bool │
     #   # ╞═════╪═════╪══════╡
     #   # └─────┴─────┴──────┘
-    def cleared
-      height > 0 ? head(0) : clone
+    #
+    # @example
+    #   df.clear(2)
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌──────┬──────┬──────┐
+    #   # │ a    ┆ b    ┆ c    │
+    #   # │ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ f64  ┆ bool │
+    #   # ╞══════╪══════╪══════╡
+    #   # │ null ┆ null ┆ null │
+    #   # │ null ┆ null ┆ null │
+    #   # └──────┴──────┴──────┘
+    def clear(n = 0)
+      if n == 0
+        _from_rbdf(_df.clear)
+      elsif n > 0 || len > 0
+        self.class.new(
+          schema.to_h { |nm, tp| [nm, Series.new(nm, [], dtype: tp).extend_constant(nil, n)] }
+        )
+      else
+        clone
+      end
     end
+    alias_method :cleared, :clear
 
     # clone handled by initialize_copy
 
@@ -3111,17 +3141,17 @@ module Polars
       sort_columns: false,
       separator: "_"
     )
-      if values.is_a?(String)
+      if values.is_a?(::String)
         values = [values]
       end
-      if index.is_a?(String)
+      if index.is_a?(::String)
         index = [index]
       end
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
       end
 
-      if aggregate_fn.is_a?(String)
+      if aggregate_fn.is_a?(::String)
         case aggregate_fn
         when "first"
           aggregate_expr = Polars.element.first._rbexpr
@@ -3137,8 +3167,11 @@ module Polars
           aggregate_expr = Polars.element.median._rbexpr
         when "last"
           aggregate_expr = Polars.element.last._rbexpr
+        when "len"
+          aggregate_expr = Polars.len._rbexpr
         when "count"
-          aggregate_expr = Polars.count._rbexpr
+          warn "`aggregate_function: \"count\"` input for `pivot` is deprecated. Use `aggregate_function: \"len\"` instead."
+          aggregate_expr = Polars.len._rbexpr
         else
           raise ArgumentError, "Argument aggregate fn: '#{aggregate_fn}' was not expected."
         end
@@ -3150,9 +3183,9 @@ module Polars
 
       _from_rbdf(
         _df.pivot_expr(
-          values,
           index,
           columns,
+          values,
           maintain_order,
           sort_columns,
           aggregate_expr,
@@ -3206,10 +3239,10 @@ module Polars
     #   # │ z   ┆ c        ┆ 6     │
     #   # └─────┴──────────┴───────┘
     def melt(id_vars: nil, value_vars: nil, variable_name: nil, value_name: nil)
-      if value_vars.is_a?(String)
+      if value_vars.is_a?(::String)
         value_vars = [value_vars]
       end
-      if id_vars.is_a?(String)
+      if id_vars.is_a?(::String)
         id_vars = [id_vars]
       end
       if value_vars.nil?
@@ -3423,7 +3456,7 @@ module Polars
     #   # │ C   ┆ 2   ┆ l   │
     #   # └─────┴─────┴─────┘}
     def partition_by(groups, maintain_order: true, include_key: true, as_dict: false)
-      if groups.is_a?(String)
+      if groups.is_a?(::String)
         groups = [groups]
       elsif !groups.is_a?(::Array)
         groups = Array(groups)
@@ -3587,8 +3620,13 @@ module Polars
 
     # Select columns from this DataFrame.
     #
-    # @param exprs [Object]
-    #   Column or columns to select.
+    # @param exprs [Array]
+    #   Column(s) to select, specified as positional arguments.
+    #   Accepts expression input. Strings are parsed as column names,
+    #   other non-expression inputs are parsed as literals.
+    # @param named_exprs [Hash]
+    #   Additional columns to select, specified as keyword arguments.
+    #   The columns will be renamed to the keyword used.
     #
     # @return [DataFrame]
     #
@@ -3668,23 +3706,25 @@ module Polars
     #   # │ 0       │
     #   # │ 10      │
     #   # └─────────┘
-    def select(exprs)
-      _from_rbdf(
-        lazy
-          .select(exprs)
-          .collect(no_optimization: true, string_cache: false)
-          ._df
-      )
+    def select(*exprs, **named_exprs)
+      lazy.select(*exprs, **named_exprs).collect(_eager: true)
     end
 
-    # Add or overwrite multiple columns in a DataFrame.
+    # Add columns to this DataFrame.
+    #
+    # Added columns will replace existing columns with the same name.
     #
     # @param exprs [Array]
-    #   Array of Expressions that evaluate to columns.
+    #   Column(s) to add, specified as positional arguments.
+    #   Accepts expression input. Strings are parsed as column names, other
+    #   non-expression inputs are parsed as literals.
+    # @param named_exprs [Hash]
+    #   Additional columns to add, specified as keyword arguments.
+    #   The columns will be renamed to the keyword used.
     #
     # @return [DataFrame]
     #
-    # @example
+    # @example Pass an expression to add it as a new column.
     #   df = Polars::DataFrame.new(
     #     {
     #       "a" => [1, 2, 3, 4],
@@ -3692,11 +3732,41 @@ module Polars
     #       "c" => [true, true, false, true]
     #     }
     #   )
+    #   df.with_columns((Polars.col("a") ** 2).alias("a^2"))
+    #   # =>
+    #   # shape: (4, 4)
+    #   # ┌─────┬──────┬───────┬──────┐
+    #   # │ a   ┆ b    ┆ c     ┆ a^2  │
+    #   # │ --- ┆ ---  ┆ ---   ┆ ---  │
+    #   # │ i64 ┆ f64  ┆ bool  ┆ f64  │
+    #   # ╞═════╪══════╪═══════╪══════╡
+    #   # │ 1   ┆ 0.5  ┆ true  ┆ 1.0  │
+    #   # │ 2   ┆ 4.0  ┆ true  ┆ 4.0  │
+    #   # │ 3   ┆ 10.0 ┆ false ┆ 9.0  │
+    #   # │ 4   ┆ 13.0 ┆ true  ┆ 16.0 │
+    #   # └─────┴──────┴───────┴──────┘
+    #
+    # @example Added columns will replace existing columns with the same name.
+    #   df.with_columns(Polars.col("a").cast(Polars::Float64))
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────┬──────┬───────┐
+    #   # │ a   ┆ b    ┆ c     │
+    #   # │ --- ┆ ---  ┆ ---   │
+    #   # │ f64 ┆ f64  ┆ bool  │
+    #   # ╞═════╪══════╪═══════╡
+    #   # │ 1.0 ┆ 0.5  ┆ true  │
+    #   # │ 2.0 ┆ 4.0  ┆ true  │
+    #   # │ 3.0 ┆ 10.0 ┆ false │
+    #   # │ 4.0 ┆ 13.0 ┆ true  │
+    #   # └─────┴──────┴───────┘
+    #
+    # @example Multiple columns can be added by passing a list of expressions.
     #   df.with_columns(
     #     [
     #       (Polars.col("a") ** 2).alias("a^2"),
     #       (Polars.col("b") / 2).alias("b/2"),
-    #       (Polars.col("c").is_not).alias("not c")
+    #       (Polars.col("c").not_).alias("not c"),
     #     ]
     #   )
     #   # =>
@@ -3711,13 +3781,45 @@ module Polars
     #   # │ 3   ┆ 10.0 ┆ false ┆ 9.0  ┆ 5.0  ┆ true  │
     #   # │ 4   ┆ 13.0 ┆ true  ┆ 16.0 ┆ 6.5  ┆ false │
     #   # └─────┴──────┴───────┴──────┴──────┴───────┘
-    def with_columns(exprs)
-      if !exprs.nil? && !exprs.is_a?(::Array)
-        exprs = [exprs]
-      end
-      lazy
-        .with_columns(exprs)
-        .collect(no_optimization: true, string_cache: false)
+    #
+    # @example Multiple columns also can be added using positional arguments instead of a list.
+    #   df.with_columns(
+    #     (Polars.col("a") ** 2).alias("a^2"),
+    #     (Polars.col("b") / 2).alias("b/2"),
+    #     (Polars.col("c").not_).alias("not c"),
+    #   )
+    #   # =>
+    #   # shape: (4, 6)
+    #   # ┌─────┬──────┬───────┬──────┬──────┬───────┐
+    #   # │ a   ┆ b    ┆ c     ┆ a^2  ┆ b/2  ┆ not c │
+    #   # │ --- ┆ ---  ┆ ---   ┆ ---  ┆ ---  ┆ ---   │
+    #   # │ i64 ┆ f64  ┆ bool  ┆ f64  ┆ f64  ┆ bool  │
+    #   # ╞═════╪══════╪═══════╪══════╪══════╪═══════╡
+    #   # │ 1   ┆ 0.5  ┆ true  ┆ 1.0  ┆ 0.25 ┆ false │
+    #   # │ 2   ┆ 4.0  ┆ true  ┆ 4.0  ┆ 2.0  ┆ false │
+    #   # │ 3   ┆ 10.0 ┆ false ┆ 9.0  ┆ 5.0  ┆ true  │
+    #   # │ 4   ┆ 13.0 ┆ true  ┆ 16.0 ┆ 6.5  ┆ false │
+    #   # └─────┴──────┴───────┴──────┴──────┴───────┘
+    #
+    # @example Use keyword arguments to easily name your expression inputs.
+    #   df.with_columns(
+    #     ab: Polars.col("a") * Polars.col("b"),
+    #     not_c: Polars.col("c").not_
+    #   )
+    #   # =>
+    #   # shape: (4, 5)
+    #   # ┌─────┬──────┬───────┬──────┬───────┐
+    #   # │ a   ┆ b    ┆ c     ┆ ab   ┆ not_c │
+    #   # │ --- ┆ ---  ┆ ---   ┆ ---  ┆ ---   │
+    #   # │ i64 ┆ f64  ┆ bool  ┆ f64  ┆ bool  │
+    #   # ╞═════╪══════╪═══════╪══════╪═══════╡
+    #   # │ 1   ┆ 0.5  ┆ true  ┆ 0.5  ┆ false │
+    #   # │ 2   ┆ 4.0  ┆ true  ┆ 8.0  ┆ false │
+    #   # │ 3   ┆ 10.0 ┆ false ┆ 30.0 ┆ true  │
+    #   # │ 4   ┆ 13.0 ┆ true  ┆ 52.0 ┆ false │
+    #   # └─────┴──────┴───────┴──────┴───────┘
+    def with_columns(*exprs, **named_exprs)
+      lazy.with_columns(*exprs, **named_exprs).collect(_eager: true)
     end
 
     # Get number of chunks used by the ChunkedArrays of this DataFrame.
@@ -3774,7 +3876,7 @@ module Polars
     #   # └─────┴─────┴─────┘
     def max(axis: 0)
       if axis == 0
-        _from_rbdf(_df.max)
+        lazy.max.collect(_eager: true)
       elsif axis == 1
         Utils.wrap_s(_df.max_horizontal)
       else
@@ -3806,7 +3908,7 @@ module Polars
     #   # └─────┴─────┴─────┘
     def min(axis: 0)
       if axis == 0
-        _from_rbdf(_df.min)
+        lazy.min.collect(_eager: true)
       elsif axis == 1
         Utils.wrap_s(_df.min_horizontal)
       else
@@ -3855,7 +3957,7 @@ module Polars
     def sum(axis: 0, null_strategy: "ignore")
       case axis
       when 0
-        _from_rbdf(_df.sum)
+        lazy.sum.collect(_eager: true)
       when 1
         Utils.wrap_s(_df.sum_horizontal(null_strategy))
       else
@@ -3893,7 +3995,7 @@ module Polars
     def mean(axis: 0, null_strategy: "ignore")
       case axis
       when 0
-        _from_rbdf(_df.mean)
+        lazy.mean.collect(_eager: true)
       when 1
         Utils.wrap_s(_df.mean_horizontal(null_strategy))
       else
@@ -3939,7 +4041,7 @@ module Polars
     #   # │ 0.816497 ┆ 0.816497 ┆ null │
     #   # └──────────┴──────────┴──────┘
     def std(ddof: 1)
-      _from_rbdf(_df.std(ddof))
+      lazy.std(ddof: ddof).collect(_eager: true)
     end
 
     # Aggregate the columns of this DataFrame to their variance value.
@@ -3980,7 +4082,7 @@ module Polars
     #   # │ 0.666667 ┆ 0.666667 ┆ null │
     #   # └──────────┴──────────┴──────┘
     def var(ddof: 1)
-      _from_rbdf(_df.var(ddof))
+      lazy.var(ddof: ddof).collect(_eager: true)
     end
 
     # Aggregate the columns of this DataFrame to their median value.
@@ -4006,7 +4108,7 @@ module Polars
     #   # │ 2.0 ┆ 7.0 ┆ null │
     #   # └─────┴─────┴──────┘
     def median
-      _from_rbdf(_df.median)
+      lazy.median.collect(_eager: true)
     end
 
     # Aggregate the columns of this DataFrame to their product values.
@@ -4063,7 +4165,7 @@ module Polars
     #   # │ 2.0 ┆ 7.0 ┆ null │
     #   # └─────┴─────┴──────┘
     def quantile(quantile, interpolation: "nearest")
-      _from_rbdf(_df.quantile(quantile, interpolation))
+      lazy.quantile(quantile, interpolation: interpolation).collect(_eager: true)
     end
 
     # Get one hot encoded dummy variables.
@@ -4094,7 +4196,7 @@ module Polars
     #   # │ 0     ┆ 1     ┆ 0     ┆ 1     ┆ 0     ┆ 1     │
     #   # └───────┴───────┴───────┴───────┴───────┴───────┘
     def to_dummies(columns: nil, separator: "_", drop_first: false)
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
       end
       _from_rbdf(_df.to_dummies(columns, separator, drop_first))
@@ -4359,7 +4461,7 @@ module Polars
     #   #         null
     #   # ]
     #
-    # @example A horizontal boolean or, similar to a row-wise .any():
+    # @example A horizontal boolean or, similar to a row-wise .any:
     #   df = Polars::DataFrame.new(
     #     {
     #       "a" => [false, false, true],
@@ -4482,7 +4584,7 @@ module Polars
     #   # => [{"a"=>1, "b"=>2}, {"a"=>3, "b"=>4}, {"a"=>5, "b"=>6}]
     def rows(named: false)
       if named
-        columns = columns()
+        columns = self.columns
         _df.row_tuples.map do |v|
           columns.zip(v).to_h
         end
@@ -4523,7 +4625,7 @@ module Polars
       return to_enum(:iter_rows, named: named, buffer_size: buffer_size) unless block_given?
 
       # load into the local namespace for a modest performance boost in the hot loops
-      columns = columns()
+      columns = self.columns
 
       # note: buffering rows results in a 2-4x speedup over individual calls
       # to ".row(i)", so it should only be disabled in extremely specific cases.
@@ -4603,8 +4705,8 @@ module Polars
     #   # │ 1   ┆ 5   │
     #   # │ 3   ┆ 7   │
     #   # └─────┴─────┘
-    def gather_every(n)
-      select(Utils.col("*").gather_every(n))
+    def gather_every(n, offset = 0)
+      select(Utils.col("*").gather_every(n, offset))
     end
     alias_method :take_every, :gather_every
 
@@ -4754,19 +4856,57 @@ module Polars
     #   # │ bar    ┆ 2   ┆ b   ┆ null ┆ [3]       ┆ womp  │
     #   # └────────┴─────┴─────┴──────┴───────────┴───────┘
     def unnest(names)
-      if names.is_a?(String)
+      if names.is_a?(::String)
         names = [names]
       end
       _from_rbdf(_df.unnest(names))
     end
 
-    # TODO
+    # Requires NumPy
     # def corr
     # end
 
-    # TODO
-    # def merge_sorted
-    # end
+    # Take two sorted DataFrames and merge them by the sorted key.
+    #
+    # The output of this operation will also be sorted.
+    # It is the callers responsibility that the frames are sorted
+    # by that key otherwise the output will not make sense.
+    #
+    # The schemas of both DataFrames must be equal.
+    #
+    # @param other [DataFrame]
+    #   Other DataFrame that must be merged
+    # @param key [String]
+    #   Key that is sorted.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   df0 = Polars::DataFrame.new(
+    #     {"name" => ["steve", "elise", "bob"], "age" => [42, 44, 18]}
+    #   ).sort("age")
+    #   df1 = Polars::DataFrame.new(
+    #     {"name" => ["anna", "megan", "steve", "thomas"], "age" => [21, 33, 42, 20]}
+    #   ).sort("age")
+    #   df0.merge_sorted(df1, "age")
+    #   # =>
+    #   # shape: (7, 2)
+    #   # ┌────────┬─────┐
+    #   # │ name   ┆ age │
+    #   # │ ---    ┆ --- │
+    #   # │ str    ┆ i64 │
+    #   # ╞════════╪═════╡
+    #   # │ bob    ┆ 18  │
+    #   # │ thomas ┆ 20  │
+    #   # │ anna   ┆ 21  │
+    #   # │ megan  ┆ 33  │
+    #   # │ steve  ┆ 42  │
+    #   # │ steve  ┆ 42  │
+    #   # │ elise  ┆ 44  │
+    #   # └────────┴─────┘
+    def merge_sorted(other, key)
+      lazy.merge_sorted(other.lazy, key).collect(_eager: true)
+    end
 
     # Indicate that one or multiple columns are sorted.
     #
@@ -4808,7 +4948,7 @@ module Polars
     end
 
     def _pos_idxs(idxs, dim)
-      idx_type = Polars._get_idx_type
+      idx_type = Plr.get_index_type
 
       if idxs.is_a?(Series)
         if idxs.dtype == idx_type
@@ -4867,10 +5007,10 @@ module Polars
             if val.is_a?(Hash) && dtype != Struct
               updated_data[name] = DataFrame.new(val).to_struct(name)
             elsif !Utils.arrlen(val).nil?
-              updated_data[name] = Series.new(String.new(name), val, dtype: dtype)
-            elsif val.nil? || [Integer, Float, TrueClass, FalseClass, String, ::Date, ::DateTime, ::Time].any? { |cls| val.is_a?(cls) }
+              updated_data[name] = Series.new(::String.new(name), val, dtype: dtype)
+            elsif val.nil? || [Integer, Float, TrueClass, FalseClass, ::String, ::Date, ::DateTime, ::Time].any? { |cls| val.is_a?(cls) }
               dtype = Polars::Float64 if val.nil? && dtype.nil?
-              updated_data[name] = Series.new(String.new(name), [val], dtype: dtype).extend_constant(val, array_len - 1)
+              updated_data[name] = Series.new(::String.new(name), [val], dtype: dtype).extend_constant(val, array_len - 1)
             else
               raise Todo
             end
@@ -4927,7 +5067,7 @@ module Polars
       end
       column_names =
         (schema || []).map.with_index do |col, i|
-          if col.is_a?(String)
+          if col.is_a?(::String)
             col || "column_#{i}"
           else
             col[0]
@@ -4940,7 +5080,7 @@ module Polars
       lookup = column_names.zip(lookup_names || []).to_h
 
       column_dtypes =
-        (schema || []).select { |col| !col.is_a?(String) && col[1] }.to_h do |col|
+        (schema || []).select { |col| !col.is_a?(::String) && col[1] }.to_h do |col|
           [lookup[col[0]] || col[0], col[1]]
         end
 
@@ -5041,14 +5181,14 @@ module Polars
       elsif data[0].is_a?(Hash)
         column_names, dtypes = _unpack_schema(columns)
         schema_overrides = dtypes ? include_unknowns(dtypes, column_names) : nil
-        rbdf = RbDataFrame.read_hashes(data, infer_schema_length, schema_overrides)
+        rbdf = RbDataFrame.read_hashes(data, infer_schema_length, schema, schema_overrides)
         if column_names
           rbdf = _post_apply_columns(rbdf, column_names)
         end
         return rbdf
       elsif data[0].is_a?(::Array)
+        first_element = data[0]
         if orient.nil? && !columns.nil?
-          first_element = data[0]
           row_types = first_element.filter_map { |value| value.class }.uniq
           if row_types.include?(Integer) && row_types.include?(Float)
             row_types.delete(Integer)