polars-df 0.6.0-arm64-darwin → 0.7.0-arm64-darwin

data/lib/polars/list_expr.rb

@@ -27,8 +27,9 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def lengths
-      Utils.wrap_expr(_rbexpr.list_lengths)
+      Utils.wrap_expr(_rbexpr.list_len)
     end
+    alias_method :len, :lengths
 
     # Sum all the lists in the array.
     #
@@ -379,6 +380,7 @@ module Polars
     #   # │ x y   │
     #   # └───────┘
     def join(separator)
+      separator = Utils.parse_as_expression(separator, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.list_join(separator))
     end
 
@@ -457,7 +459,7 @@ module Polars
 
     # Shift values by the given period.
     #
-    # @param periods [Integer]
+    # @param n [Integer]
     #   Number of places to shift (may be negative).
     #
     # @return [Expr]
@@ -472,8 +474,9 @@ module Polars
     #   #         [null, 1, … 3]
     #   #         [null, 10, 2]
     #   # ]
-    def shift(periods = 1)
-      Utils.wrap_expr(_rbexpr.list_shift(periods))
+    def shift(n = 1)
+      n = Utils.parse_as_expression(n)
+      Utils.wrap_expr(_rbexpr.list_shift(n))
     end
 
     # Slice every sublist.
@@ -568,9 +571,10 @@ module Polars
     #   # │ 1              │
     #   # │ 0              │
     #   # └────────────────┘
-    def count_match(element)
-      Utils.wrap_expr(_rbexpr.list_count_match(Utils.expr_to_lit_or_expr(element)._rbexpr))
+    def count_matches(element)
+      Utils.wrap_expr(_rbexpr.list_count_matches(Utils.expr_to_lit_or_expr(element)._rbexpr))
     end
+    alias_method :count_match, :count_matches
 
     # Convert the series of type `List` to a series of type `Struct`.
     #
@@ -609,7 +613,7 @@ module Polars
     #   Run all expression parallel. Don't activate this blindly.
     #   Parallelism is worth it if there is enough work to do per thread.
     #
-    #   This likely should not be use in the groupby context, because we already
+    #   This likely should not be use in the group by context, because we already
     #   parallel execution per group
     #
     # @return [Expr]
@@ -624,7 +628,7 @@ module Polars
     #   # ┌─────┬─────┬────────────┐
     #   # │ a   ┆ b   ┆ rank       │
     #   # │ --- ┆ --- ┆ ---        │
-    #   # │ i64 ┆ i64 ┆ list[f32]  │
+    #   # │ i64 ┆ i64 ┆ list[f64]  │
     #   # ╞═════╪═════╪════════════╡
     #   # │ 1   ┆ 4   ┆ [1.0, 2.0] │
     #   # │ 8   ┆ 5   ┆ [2.0, 1.0] │

data/lib/polars/list_name_space.rb

@@ -315,7 +315,7 @@ module Polars
     #   Run all expression parallel. Don't activate this blindly.
     #   Parallelism is worth it if there is enough work to do per thread.
     #
-    #   This likely should not be use in the groupby context, because we already
+    #   This likely should not be use in the group by context, because we already
     #   parallel execution per group
     #
     # @return [Series]
@@ -330,7 +330,7 @@ module Polars
     #   # ┌─────┬─────┬────────────┐
     #   # │ a   ┆ b   ┆ rank       │
     #   # │ --- ┆ --- ┆ ---        │
-    #   # │ i64 ┆ i64 ┆ list[f32]  │
+    #   # │ i64 ┆ i64 ┆ list[f64]  │
     #   # ╞═════╪═════╪════════════╡
     #   # │ 1   ┆ 4   ┆ [1.0, 2.0] │
     #   # │ 8   ┆ 5   ┆ [2.0, 1.0] │

data/lib/polars/name_expr.rb

@@ -0,0 +1,198 @@
+module Polars
+  # Namespace for expressions that operate on expression names.
+  class NameExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Keep the original root name of the expression.
+    #
+    # @note
+    #   Due to implementation constraints, this method can only be called as the last
+    #   expression in a chain.
+    #
+    # @return [Expr]
+    #
+    # @example Prevent errors due to potential duplicate column names.
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2],
+    #       "b" => [3, 4]
+    #     }
+    #   )
+    #   df.select((Polars.lit(10) / Polars.all).name.keep)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌──────┬──────────┐
+    #   # │ a    ┆ b        │
+    #   # │ ---  ┆ ---      │
+    #   # │ f64  ┆ f64      │
+    #   # ╞══════╪══════════╡
+    #   # │ 10.0 ┆ 3.333333 │
+    #   # │ 5.0  ┆ 2.5      │
+    #   # └──────┴──────────┘
+    #
+    # @example Undo an alias operation.
+    #   df.with_columns((Polars.col("a") * 9).alias("c").name.keep)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 9   ┆ 3   │
+    #   # │ 18  ┆ 4   │
+    #   # └─────┴─────┘
+    def keep
+      Utils.wrap_expr(_rbexpr.name_keep)
+    end
+
+    # Rename the output of an expression by mapping a function over the root name.
+    #
+    # @return [Expr]
+    #
+    # @example Remove a common suffix and convert to lower case.
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "A_reverse" => [3, 2, 1],
+    #       "B_reverse" => ["z", "y", "x"]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.all.reverse.name.map { |c| c.delete_suffix("_reverse").downcase }
+    #   )
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌───────────┬───────────┬─────┬─────┐
+    #   # │ A_reverse ┆ B_reverse ┆ a   ┆ b   │
+    #   # │ ---       ┆ ---       ┆ --- ┆ --- │
+    #   # │ i64       ┆ str       ┆ i64 ┆ str │
+    #   # ╞═══════════╪═══════════╪═════╪═════╡
+    #   # │ 3         ┆ z         ┆ 1   ┆ x   │
+    #   # │ 2         ┆ y         ┆ 2   ┆ y   │
+    #   # │ 1         ┆ x         ┆ 3   ┆ z   │
+    #   # └───────────┴───────────┴─────┴─────┘
+    def map(&f)
+      Utils.wrap_expr(_rbexpr.name_map(f))
+    end
+
+    # Add a prefix to the root column name of the expression.
+    #
+    # @param prefix [Object]
+    #   Prefix to add to the root column name.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.prefix("reverse_"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ reverse_a ┆ reverse_b │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
+    def prefix(prefix)
+      Utils.wrap_expr(_rbexpr.name_prefix(prefix))
+    end
+
+    # Add a suffix to the root column name of the expression.
+    #
+    # @param suffix [Object]
+    #   Suffix to add to the root column name.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.suffix("_reverse"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ a_reverse ┆ b_reverse │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
+    def suffix(suffix)
+      Utils.wrap_expr(_rbexpr.name_suffix(suffix))
+    end
+
+    # Make the root column name lowercase.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "ColX" => [1, 2, 3],
+    #       "ColY" => ["x", "y", "z"],
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.name.to_lowercase)
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌──────┬──────┬──────┬──────┐
+    #   # │ ColX ┆ ColY ┆ colx ┆ coly │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ str  ┆ i64  ┆ str  │
+    #   # ╞══════╪══════╪══════╪══════╡
+    #   # │ 1    ┆ x    ┆ 1    ┆ x    │
+    #   # │ 2    ┆ y    ┆ 2    ┆ y    │
+    #   # │ 3    ┆ z    ┆ 3    ┆ z    │
+    #   # └──────┴──────┴──────┴──────┘
+    def to_lowercase
+      Utils.wrap_expr(_rbexpr.name_to_lowercase)
+    end
+
+    # Make the root column name uppercase.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "ColX" => [1, 2, 3],
+    #       "ColY" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.name.to_uppercase)
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌──────┬──────┬──────┬──────┐
+    #   # │ ColX ┆ ColY ┆ COLX ┆ COLY │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ str  ┆ i64  ┆ str  │
+    #   # ╞══════╪══════╪══════╪══════╡
+    #   # │ 1    ┆ x    ┆ 1    ┆ x    │
+    #   # │ 2    ┆ y    ┆ 2    ┆ y    │
+    #   # │ 3    ┆ z    ┆ 3    ┆ z    │
+    #   # └──────┴──────┴──────┴──────┘
+    def to_uppercase
+      Utils.wrap_expr(_rbexpr.name_to_uppercase)
+    end
+  end
+end

data/lib/polars/rolling_group_by.rb

@@ -2,7 +2,7 @@ module Polars
   # A rolling grouper.
   #
   # This has an `.agg` method which will allow you to run all polars expressions in a
-  # groupby context.
+  # group by context.
   class RollingGroupBy
     def initialize(
       df,
@@ -27,7 +27,7 @@ module Polars
 
     def agg(aggs)
       @df.lazy
-        .groupby_rolling(
+        .group_by_rolling(
           index_column: @time_column, period: @period, offset: @offset, closed: @closed, by: @by, check_sorted: @check_sorted
         )
         .agg(aggs)

data/lib/polars/series.rb

@@ -432,6 +432,18 @@ module Polars
     end
     alias_method :all, :all?
 
+    # Check if all boolean values in the column are `false`.
+    #
+    # @return [Boolean]
+    def none?(&block)
+      if block_given?
+        apply(&block).none?
+      else
+        to_frame.select(Polars.col(name).is_not.all).to_series[0]
+      end
+    end
+    alias_method :none, :none?
+
     # Compute the logarithm to a given base.
     #
     # @param base [Float]
@@ -799,7 +811,7 @@ module Polars
     #   Number of valid values there should be in the window before the expression
     #   is evaluated. valid values = `length - null_count`
     # @param parallel [Boolean]
-    #   Run in parallel. Don't do this in a groupby or another operation that
+    #   Run in parallel. Don't do this in a group by or another operation that
     #   already has much parallelization.
     #
     # @return [Series]
@@ -3097,7 +3109,7 @@ module Polars
     #   s.peak_max
     #   # =>
     #   # shape: (5,)
-    #   # Series: '' [bool]
+    #   # Series: 'a' [bool]
     #   # [
     #   #         false
     #   #         false
@@ -3106,7 +3118,7 @@ module Polars
     #   #         true
     #   # ]
     def peak_max
-      Utils.wrap_s(_s.peak_max)
+      super
     end
 
     # Get a boolean mask of the local minimum peaks.
@@ -3118,7 +3130,7 @@ module Polars
     #   s.peak_min
     #   # =>
     #   # shape: (5,)
-    #   # Series: '' [bool]
+    #   # Series: 'a' [bool]
     #   # [
     #   #         false
     #   #         true
@@ -3127,7 +3139,7 @@ module Polars
     #   #         false
     #   # ]
     def peak_min
-      Utils.wrap_s(_s.peak_min)
+      super
     end
 
     # Count the number of unique values in this Series.
@@ -3211,13 +3223,13 @@ module Polars
     #   s.interpolate
     #   # =>
     #   # shape: (5,)
-    #   # Series: 'a' [i64]
+    #   # Series: 'a' [f64]
     #   # [
-    #   #         1
-    #   #         2
-    #   #         3
-    #   #         4
-    #   #         5
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   #         4.0
+    #   #         5.0
     #   # ]
     def interpolate(method: "linear")
       super
@@ -3260,7 +3272,7 @@ module Polars
     #   s.rank
     #   # =>
     #   # shape: (5,)
-    #   # Series: 'a' [f32]
+    #   # Series: 'a' [f64]
     #   # [
     #   #         3.0
     #   #         4.5
@@ -3998,7 +4010,8 @@ module Polars
       Integer => RbSeries.method(:new_opt_i64),
       TrueClass => RbSeries.method(:new_opt_bool),
       FalseClass => RbSeries.method(:new_opt_bool),
-      BigDecimal => RbSeries.method(:new_decimal)
+      BigDecimal => RbSeries.method(:new_decimal),
+      NilClass => RbSeries.method(:new_null)
     }
 
     def rb_type_to_constructor(dtype)

data/lib/polars/sql_context.rb

@@ -0,0 +1,194 @@
+module Polars
+  # Run SQL queries against DataFrame/LazyFrame data.
+  class SQLContext
+    # @private
+    attr_accessor :_ctxt, :_eager_execution
+
+    # Initialize a new `SQLContext`.
+    def initialize(frames = nil, eager_execution: false, **named_frames)
+      self._ctxt = RbSQLContext.new
+      self._eager_execution = eager_execution
+
+      frames = (frames || {}).to_h
+
+      if frames.any? || named_frames.any?
+        register_many(frames, **named_frames)
+      end
+    end
+
+    # Parse the given SQL query and execute it against the registered frame data.
+    #
+    # @param query [String]
+    #   A valid string SQL query.
+    # @param eager [Boolean]
+    #   Apply the query eagerly, returning `DataFrame` instead of `LazyFrame`.
+    #   If unset, the value of the init-time parameter "eager_execution" will be
+    #   used. (Note that the query itself is always executed in lazy-mode; this
+    #   parameter only impacts the type of the returned frame).
+    #
+    # @return [Object]
+    #
+    # @example Execute a SQL query against the registered frame data:
+    #   df = Polars::DataFrame.new(
+    #     [
+    #       ["The Godfather", 1972, 6_000_000, 134_821_952, 9.2],
+    #       ["The Dark Knight", 2008, 185_000_000, 533_316_061, 9.0],
+    #       ["Schindler's List", 1993, 22_000_000, 96_067_179, 8.9],
+    #       ["Pulp Fiction", 1994, 8_000_000, 107_930_000, 8.9],
+    #       ["The Shawshank Redemption", 1994, 25_000_000, 28_341_469, 9.3],
+    #     ],
+    #     schema: ["title", "release_year", "budget", "gross", "imdb_score"]
+    #   )
+    #   ctx = Polars::SQLContext.new(films: df)
+    #   ctx.execute(
+    #     "
+    #     SELECT title, release_year, imdb_score
+    #     FROM films
+    #     WHERE release_year > 1990
+    #     ORDER BY imdb_score DESC
+    #     ",
+    #     eager: true
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌──────────────────────────┬──────────────┬────────────┐
+    #   # │ title                    ┆ release_year ┆ imdb_score │
+    #   # │ ---                      ┆ ---          ┆ ---        │
+    #   # │ str                      ┆ i64          ┆ f64        │
+    #   # ╞══════════════════════════╪══════════════╪════════════╡
+    #   # │ The Shawshank Redemption ┆ 1994         ┆ 9.3        │
+    #   # │ The Dark Knight          ┆ 2008         ┆ 9.0        │
+    #   # │ Schindler's List         ┆ 1993         ┆ 8.9        │
+    #   # │ Pulp Fiction             ┆ 1994         ┆ 8.9        │
+    #   # └──────────────────────────┴──────────────┴────────────┘
+    #
+    # @example Execute a GROUP BY query:
+    #   ctx.execute(
+    #     "
+    #     SELECT
+    #         MAX(release_year / 10) * 10 AS decade,
+    #         SUM(gross) AS total_gross,
+    #         COUNT(title) AS n_films,
+    #     FROM films
+    #     GROUP BY (release_year / 10) -- decade
+    #     ORDER BY total_gross DESC
+    #     ",
+    #     eager: true
+    #   )
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌────────┬─────────────┬─────────┐
+    #   # │ decade ┆ total_gross ┆ n_films │
+    #   # │ ---    ┆ ---         ┆ ---     │
+    #   # │ i64    ┆ i64         ┆ u32     │
+    #   # ╞════════╪═════════════╪═════════╡
+    #   # │ 2000   ┆ 533316061   ┆ 1       │
+    #   # │ 1990   ┆ 232338648   ┆ 3       │
+    #   # │ 1970   ┆ 134821952   ┆ 1       │
+    #   # └────────┴─────────────┴─────────┘
+    def execute(query, eager: nil)
+      res = Utils.wrap_ldf(_ctxt.execute(query))
+      eager || _eager_execution ? res.collect : res
+    end
+
+    # Register a single frame as a table, using the given name.
+    #
+    # @param name [String]
+    #   Name of the table.
+    # @param frame [Object]
+    #   eager/lazy frame to associate with this table name.
+    #
+    # @return [SQLContext]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"hello" => ["world"]})
+    #   ctx = Polars::SQLContext.new
+    #   ctx.register("frame_data", df).execute("SELECT * FROM frame_data").collect
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌───────┐
+    #   # │ hello │
+    #   # │ ---   │
+    #   # │ str   │
+    #   # ╞═══════╡
+    #   # │ world │
+    #   # └───────┘
+    def register(name, frame)
+      if frame.is_a?(DataFrame)
+        frame = frame.lazy
+      end
+      _ctxt.register(name.to_s, frame._ldf)
+      self
+    end
+
+    # Register multiple eager/lazy frames as tables, using the associated names.
+    #
+    # @param frames [Hash]
+    #   A `{name:frame, ...}` mapping.
+    # @param named_frames [Object]
+    #   Named eager/lazy frames, provided as kwargs.
+    #
+    # @return [SQLContext]
+    def register_many(frames, **named_frames)
+      frames = (frames || {}).to_h
+      frames = frames.merge(named_frames)
+      frames.each do |name, frame|
+        register(name, frame)
+      end
+      self
+    end
+
+    # Unregister one or more eager/lazy frames by name.
+    #
+    # @param names [Object]
+    #   Names of the tables to unregister.
+    #
+    # @return [SQLContext]
+    #
+    # @example Register with a SQLContext object:
+    #   df0 = Polars::DataFrame.new({"ints" => [9, 8, 7, 6, 5]})
+    #   lf1 = Polars::LazyFrame.new({"text" => ["a", "b", "c"]})
+    #   lf2 = Polars::LazyFrame.new({"misc" => ["testing1234"]})
+    #   ctx = Polars::SQLContext.new(test1: df0, test2: lf1, test3: lf2)
+    #   ctx.tables
+    #   # => ["test1", "test2", "test3"]
+    #
+    # @example Unregister one or more of the tables:
+    #   ctx.unregister(["test1", "test3"]).tables
+    #   # => ["test2"]
+    def unregister(names)
+      if names.is_a?(String)
+        names = [names]
+      end
+      names.each do |nm|
+        _ctxt.unregister(nm)
+      end
+      self
+    end
+
+    # Return a list of the registered table names.
+    #
+    # @return [Array]
+    #
+    # @example Executing as SQL:
+    #   frame_data = Polars::DataFrame.new({"hello" => ["world"]})
+    #   ctx = Polars::SQLContext.new(hello_world: frame_data)
+    #   ctx.execute("SHOW TABLES", eager: true)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────────────┐
+    #   # │ name        │
+    #   # │ ---         │
+    #   # │ str         │
+    #   # ╞═════════════╡
+    #   # │ hello_world │
+    #   # └─────────────┘
+    #
+    # @example Calling the method:
+    #   ctx.tables
+    #   # => ["hello_world"]
+    def tables
+      _ctxt.get_tables.sort
+    end
+  end
+end