polars-df 0.15.0 → 0.26.0

data/lib/polars/extension_expr.rb

@@ -0,0 +1,39 @@
+module Polars
+  # Namespace for extension type related expressions.
+  class ExtensionExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Convert to an extension `dtype`.
+    #
+    # The input must be of the storage type of the extension dtype.
+    #
+    # @note
+    #   This functionality is currently considered **unstable**. It may be
+    #   changed at any point without it being considered a breaking change.
+    #
+    # @return [Expr]
+    def to(dtype)
+      rb_dtype = Utils.parse_into_datatype_expr(dtype)._rbdatatype_expr
+      Utils.wrap_expr(_rbexpr.ext_to(rb_dtype))
+    end
+
+    # Get the storage values of an extension data type.
+    #
+    # If the input does not have an extension data type, it is returned as-is.
+    #
+    # @note
+    #   This functionality is currently considered **unstable**. It may be
+    #   changed at any point without it being considered a breaking change.
+    #
+    # @return [Expr]
+    def storage
+      Utils.wrap_expr(_rbexpr.ext_storage)
+    end
+  end
+end

data/lib/polars/extension_name_space.rb

@@ -0,0 +1,39 @@
+module Polars
+  # Series.ext namespace.
+  class ExtensionNameSpace
+    include ExprDispatch
+
+    self._accessor = "ext"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Create a Series with an extension `dtype`.
+    #
+    # The input series must have the storage type of the extension dtype.
+    #
+    # @note
+    #   This functionality is currently considered **unstable**. It may be
+    #   changed at any point without it being considered a breaking change.
+    #
+    # @return [Series]
+    def to(dtype)
+      Utils.wrap_s(_s.ext_to(dtype))
+    end
+
+    # Get the storage values of a Series with an extension data type.
+    #
+    # If the input series does not have an extension data type, it is returned as-is.
+    #
+    # @note
+    #   This functionality is currently considered **unstable**. It may be
+    #   changed at any point without it being considered a breaking change.
+    #
+    # @return [Series]
+    def storage
+      Utils.wrap_s(_s.ext_storage)
+    end
+  end
+end

data/lib/polars/functions/aggregation/horizontal.rb

@@ -143,6 +143,9 @@ module Polars
     # @param exprs [Array]
     #   Column(s) to use in the aggregation. Accepts expression input. Strings are
     #   parsed as column names, other non-expression inputs are parsed as literals.
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default).
+    #   If set to `false`, any null value in the input will lead to a null output.
     #
     # @return [Expr]
     #
@@ -166,9 +169,9 @@ module Polars
     #   # │ 8   ┆ 5    ┆ y   ┆ 13  │
     #   # │ 3   ┆ null ┆ z   ┆ 3   │
     #   # └─────┴──────┴─────┴─────┘
-    def sum_horizontal(*exprs)
+    def sum_horizontal(*exprs, ignore_nulls: true)
       rbexprs = Utils.parse_into_list_of_expressions(*exprs)
-      Utils.wrap_expr(Plr.sum_horizontal(rbexprs))
+      Utils.wrap_expr(Plr.sum_horizontal(rbexprs, ignore_nulls))
     end
 
     # Compute the mean of all values horizontally across columns.
@@ -176,6 +179,9 @@ module Polars
     # @param exprs [Array]
     #   Column(s) to use in the aggregation. Accepts expression input. Strings are
     #   parsed as column names, other non-expression inputs are parsed as literals.
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default).
+    #   If set to `false`, any null value in the input will lead to a null output.
     #
     # @return [Expr]
     #
@@ -199,9 +205,9 @@ module Polars
     #   # │ 8   ┆ 5    ┆ y   ┆ 6.5  │
     #   # │ 3   ┆ null ┆ z   ┆ 3.0  │
     #   # └─────┴──────┴─────┴──────┘
-    def mean_horizontal(*exprs)
+    def mean_horizontal(*exprs, ignore_nulls: true)
       rbexprs = Utils.parse_into_list_of_expressions(*exprs)
-      Utils.wrap_expr(Plr.mean_horizontal(rbexprs))
+      Utils.wrap_expr(Plr.mean_horizontal(rbexprs, ignore_nulls))
     end
 
     # Cumulatively sum all values horizontally across columns.
@@ -237,10 +243,9 @@ module Polars
       exprs_wrapped = rbexprs.map { |e| Utils.wrap_expr(e) }
 
       # (Expr): use u32 as that will not cast to float as eagerly
-      Polars.cum_fold(Polars.lit(0).cast(UInt32), ->(a, b) { a + b }, exprs_wrapped).alias(
+      Polars.cum_fold(Polars.lit(0).cast(UInt32), exprs_wrapped) { |a, b| a + b }.alias(
         "cum_sum"
       )
     end
-    alias_method :cumsum_horizontal, :cum_sum_horizontal
   end
 end

data/lib/polars/functions/aggregation/vertical.rb

@@ -46,7 +46,7 @@ module Polars
         return col("*")
       end
 
-      col(*names).all(drop_nulls: ignore_nulls)
+      col(*names).all(ignore_nulls: ignore_nulls)
     end
 
     # Evaluate a bitwise OR operation.
@@ -78,7 +78,7 @@ module Polars
     #   # │ true │
     #   # └──────┘
     def any(*names, ignore_nulls: true)
-      col(*names).any(drop_nulls: ignore_nulls)
+      col(*names).any(ignore_nulls: ignore_nulls)
     end
 
     # Get the maximum value.
@@ -277,6 +277,5 @@ module Polars
     def cum_sum(*names)
       col(*names).cum_sum
     end
-    alias_method :cumsum, :cum_sum
   end
 end

data/lib/polars/functions/as_datatype.rb

@@ -1,5 +1,233 @@
 module Polars
   module Functions
+    # Create a Polars literal expression of type Datetime.
+    #
+    # @param year [Object]
+    #   Column or literal.
+    # @param month [Object]
+    #   Column or literal, ranging from 1-12.
+    # @param day [Object]
+    #   Column or literal, ranging from 1-31.
+    # @param hour [Object]
+    #   Column or literal, ranging from 0-23.
+    # @param minute [Object]
+    #   Column or literal, ranging from 0-59.
+    # @param second [Object]
+    #   Column or literal, ranging from 0-59.
+    # @param microsecond [Object]
+    #   Column or literal, ranging from 0-999999.
+    # @param time_unit ['us', 'ms', 'ns']
+    #   Time unit of the resulting expression.
+    # @param time_zone [Object]
+    #   Time zone of the resulting expression.
+    # @param ambiguous ['raise', 'earliest', 'latest', 'null']
+    #   Determine how to deal with ambiguous datetimes:
+    #
+    #   - `'raise'` (default): raise
+    #   - `'earliest'`: use the earliest datetime
+    #   - `'latest'`: use the latest datetime
+    #   - `'null'`: set to null
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "month" => [1, 2, 3],
+    #       "day" => [4, 5, 6],
+    #       "hour" => [12, 13, 14],
+    #       "minute" => [15, 30, 45]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.datetime(
+    #       2024,
+    #       Polars.col("month"),
+    #       Polars.col("day"),
+    #       Polars.col("hour"),
+    #       Polars.col("minute"),
+    #       time_zone: "Australia/Sydney"
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (3, 5)
+    #   # ┌───────┬─────┬──────┬────────┬────────────────────────────────┐
+    #   # │ month ┆ day ┆ hour ┆ minute ┆ datetime                       │
+    #   # │ ---   ┆ --- ┆ ---  ┆ ---    ┆ ---                            │
+    #   # │ i64   ┆ i64 ┆ i64  ┆ i64    ┆ datetime[μs, Australia/Sydney] │
+    #   # ╞═══════╪═════╪══════╪════════╪════════════════════════════════╡
+    #   # │ 1     ┆ 4   ┆ 12   ┆ 15     ┆ 2024-01-04 12:15:00 AEDT       │
+    #   # │ 2     ┆ 5   ┆ 13   ┆ 30     ┆ 2024-02-05 13:30:00 AEDT       │
+    #   # │ 3     ┆ 6   ┆ 14   ┆ 45     ┆ 2024-03-06 14:45:00 AEDT       │
+    #   # └───────┴─────┴──────┴────────┴────────────────────────────────┘
+    #
+    # @example We can also use `Polars.datetime` for filtering:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "start" => [
+    #         DateTime.new(2024, 1, 1, 0, 0, 0),
+    #         DateTime.new(2024, 1, 1, 0, 0, 0),
+    #         DateTime.new(2024, 1, 1, 0, 0, 0)
+    #       ],
+    #       "end" => [
+    #         DateTime.new(2024, 5, 1, 20, 15, 10),
+    #         DateTime.new(2024, 7, 1, 21, 25, 20),
+    #         DateTime.new(2024, 9, 1, 22, 35, 30)
+    #       ]
+    #     }
+    #   )
+    #   df.filter(Polars.col("end") > Polars.datetime(2024, 6, 1))
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────────────────────┬─────────────────────┐
+    #   # │ start               ┆ end                 │
+    #   # │ ---                 ┆ ---                 │
+    #   # │ datetime[ns]        ┆ datetime[ns]        │
+    #   # ╞═════════════════════╪═════════════════════╡
+    #   # │ 2024-01-01 00:00:00 ┆ 2024-07-01 21:25:20 │
+    #   # │ 2024-01-01 00:00:00 ┆ 2024-09-01 22:35:30 │
+    #   # └─────────────────────┴─────────────────────┘
+    def datetime(
+      year,
+      month,
+      day,
+      hour = nil,
+      minute = nil,
+      second = nil,
+      microsecond = nil,
+      time_unit: "us",
+      time_zone: nil,
+      ambiguous: "raise"
+    )
+      ambiguous_expr = Utils.parse_into_expression(ambiguous, str_as_lit: true)
+      year_expr = Utils.parse_into_expression(year)
+      month_expr = Utils.parse_into_expression(month)
+      day_expr = Utils.parse_into_expression(day)
+
+      hour_expr = !hour.nil? ? Utils.parse_into_expression(hour) : nil
+      minute_expr = !minute.nil? ? Utils.parse_into_expression(minute) : nil
+      second_expr = !second.nil? ? Utils.parse_into_expression(second) : nil
+      microsecond_expr = (
+        !microsecond.nil? ? Utils.parse_into_expression(microsecond) : nil
+      )
+
+      Utils.wrap_expr(
+        Plr.datetime(
+          year_expr,
+          month_expr,
+          day_expr,
+          hour_expr,
+          minute_expr,
+          second_expr,
+          microsecond_expr,
+          time_unit,
+          time_zone,
+          ambiguous_expr
+        )
+      )
+    end
+
+    # Create a Polars literal expression of type Date.
+    #
+    # @param year [Object]
+    #   column or literal.
+    # @param month [Object]
+    #   column or literal, ranging from 1-12.
+    # @param day [Object]
+    #   column or literal, ranging from 1-31.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "month" => [1, 2, 3],
+    #       "day" => [4, 5, 6]
+    #     }
+    #   )
+    #   df.with_columns(Polars.date(2024, Polars.col("month"), Polars.col("day")))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌───────┬─────┬────────────┐
+    #   # │ month ┆ day ┆ date       │
+    #   # │ ---   ┆ --- ┆ ---        │
+    #   # │ i64   ┆ i64 ┆ date       │
+    #   # ╞═══════╪═════╪════════════╡
+    #   # │ 1     ┆ 4   ┆ 2024-01-04 │
+    #   # │ 2     ┆ 5   ┆ 2024-02-05 │
+    #   # │ 3     ┆ 6   ┆ 2024-03-06 │
+    #   # └───────┴─────┴────────────┘
+    #
+    # @example We can also use `pl.date` for filtering:
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "start" => [Date.new(2024, 1, 1), Date.new(2024, 1, 1), Date.new(2024, 1, 1)],
+    #       "end" => [Date.new(2024, 5, 1), Date.new(2024, 7, 1), Date.new(2024, 9, 1)]
+    #     }
+    #   )
+    #   df.filter(Polars.col("end") > Polars.date(2024, 6, 1))
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌────────────┬────────────┐
+    #   # │ start      ┆ end        │
+    #   # │ ---        ┆ ---        │
+    #   # │ date       ┆ date       │
+    #   # ╞════════════╪════════════╡
+    #   # │ 2024-01-01 ┆ 2024-07-01 │
+    #   # │ 2024-01-01 ┆ 2024-09-01 │
+    #   # └────────────┴────────────┘
+    def date(
+      year,
+      month,
+      day
+    )
+      datetime(year, month, day).cast(Date).alias("date")
+    end
+
+    # Create a Polars literal expression of type Time.
+    #
+    # @param hour [Object]
+    #   column or literal, ranging from 0-23.
+    # @param minute [Object]
+    #   column or literal, ranging from 0-59.
+    # @param second [Object]
+    #   column or literal, ranging from 0-59.
+    # @param microsecond [Object]
+    #   column or literal, ranging from 0-999999.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "hour" => [12, 13, 14],
+    #       "minute" => [15, 30, 45]
+    #     }
+    #   )
+    #   df.with_columns(Polars.time(Polars.col("hour"), Polars.col("minute")))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌──────┬────────┬──────────┐
+    #   # │ hour ┆ minute ┆ time     │
+    #   # │ ---  ┆ ---    ┆ ---      │
+    #   # │ i64  ┆ i64    ┆ time     │
+    #   # ╞══════╪════════╪══════════╡
+    #   # │ 12   ┆ 15     ┆ 12:15:00 │
+    #   # │ 13   ┆ 30     ┆ 13:30:00 │
+    #   # │ 14   ┆ 45     ┆ 14:45:00 │
+    #   # └──────┴────────┴──────────┘
+    def time(
+      hour = nil,
+      minute = nil,
+      second = nil,
+      microsecond = nil
+    )
+      epoch_start = [1970, 1, 1]
+      datetime(*epoch_start, hour, minute, second, microsecond)
+        .cast(Time)
+        .alias("time")
+    end
+
     # Create polars `Duration` from distinct time components.
     #
     # @return [Expr]
@@ -41,8 +269,12 @@ module Polars
       milliseconds: nil,
       microseconds: nil,
       nanoseconds: nil,
-      time_unit: "us"
+      time_unit: nil
     )
+      if !nanoseconds.nil? && time_unit.nil?
+        time_unit = "ns"
+      end
+
       if !weeks.nil?
         weeks = Utils.parse_into_expression(weeks, str_as_lit: false)
       end
@@ -68,6 +300,10 @@ module Polars
         nanoseconds = Utils.parse_into_expression(nanoseconds, str_as_lit: false)
       end
 
+      if time_unit.nil?
+        time_unit = "us"
+      end
+
       Utils.wrap_expr(
         Plr.duration(
           weeks,
@@ -140,6 +376,49 @@ module Polars
       Utils.wrap_expr(Plr.concat_list(exprs))
     end
 
+    # Horizontally concatenate columns into a single array column.
+    #
+    # Non-array columns are reshaped to a unit-width array. All columns must have
+    # a dtype of either `Polars::Array.new(<DataType>, width)` or `Polars::<DataType>`.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param exprs [Object]
+    #   Columns to concatenate into a single array column. Accepts expression input.
+    #   Strings are parsed as column names, other non-expression inputs are parsed as
+    #   literals.
+    # @param more_exprs [Array]
+    #   Additional columns to concatenate into a single array column, specified as
+    #   positional arguments.
+    #
+    # @return [Expr]
+    #
+    # @example Concatenate 2 array columns:
+    #   Polars.select(
+    #     a: Polars::Series.new([[1], [3], nil], dtype: Polars::Array.new(Polars::Int64, 1)),
+    #     b: Polars::Series.new([[3], [nil], [5]], dtype: Polars::Array.new(Polars::Int64, 1))
+    #   ).with_columns(
+    #     Polars.concat_arr("a", "b").alias("concat_arr(a, b)"),
+    #     Polars.concat_arr("a", Polars.first("b")).alias("concat_arr(a, first(b))")
+    #   )
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌───────────────┬───────────────┬──────────────────┬─────────────────────────┐
+    #   # │ a             ┆ b             ┆ concat_arr(a, b) ┆ concat_arr(a, first(b)) │
+    #   # │ ---           ┆ ---           ┆ ---              ┆ ---                     │
+    #   # │ array[i64, 1] ┆ array[i64, 1] ┆ array[i64, 2]    ┆ array[i64, 2]           │
+    #   # ╞═══════════════╪═══════════════╪══════════════════╪═════════════════════════╡
+    #   # │ [1]           ┆ [3]           ┆ [1, 3]           ┆ [1, 3]                  │
+    #   # │ [3]           ┆ [null]        ┆ [3, null]        ┆ [3, 3]                  │
+    #   # │ null          ┆ [5]           ┆ null             ┆ null                    │
+    #   # └───────────────┴───────────────┴──────────────────┴─────────────────────────┘
+    def concat_arr(exprs, *more_exprs)
+      exprs = Utils.parse_into_list_of_expressions(exprs, *more_exprs)
+      Utils.wrap_expr(Plr.concat_arr(exprs))
+    end
+
     # Collect several columns into a Series of dtype Struct.
     #
     # @param exprs [Array]
@@ -194,7 +473,7 @@ module Polars
     #
     # @example Use keyword arguments to easily name each struct field.
     #   df.select(Polars.struct(p: "int", q: "bool").alias("my_struct")).schema
-    #   # => {"my_struct"=>Polars::Struct({"p"=>Polars::Int64, "q"=>Polars::Boolean})}
+    #   # => Polars::Schema({"my_struct"=>Polars::Struct({"p"=>Polars::Int64, "q"=>Polars::Boolean})})
     def struct(*exprs, schema: nil, eager: false, **named_exprs)
       rbexprs = Utils.parse_into_list_of_expressions(*exprs, **named_exprs)
       expr = Utils.wrap_expr(Plr.as_struct(rbexprs))
@@ -221,7 +500,10 @@ module Polars
     #
     # @param exprs [Object]
     #   Columns to concat into a Utf8 Series.
-    # @param sep [String]
+    # @param more_exprs [Array]
+    #   Additional columns to concatenate into a single string column, specified as
+    #   positional arguments.
+    # @param separator [String]
     #   String value that will be used to separate the values.
     # @param ignore_nulls [Boolean]
     #   Ignore null values (default).
@@ -244,7 +526,7 @@ module Polars
     #           Polars.col("b"),
     #           Polars.col("c")
     #         ],
-    #         sep: " "
+    #         separator: " "
     #       ).alias("full_sentence")
     #     ]
     #   )
@@ -259,9 +541,9 @@ module Polars
     #   # │ 2   ┆ cats ┆ swim ┆ 4 cats swim   │
     #   # │ 3   ┆ null ┆ walk ┆ null          │
     #   # └─────┴──────┴──────┴───────────────┘
-    def concat_str(exprs, sep: "", ignore_nulls: false)
-      exprs = Utils.parse_into_list_of_expressions(exprs)
-      Utils.wrap_expr(Plr.concat_str(exprs, sep, ignore_nulls))
+    def concat_str(exprs, *more_exprs, separator: "", ignore_nulls: false)
+      exprs = Utils.parse_into_list_of_expressions(exprs, *more_exprs)
+      Utils.wrap_expr(Plr.concat_str(exprs, separator, ignore_nulls))
     end
 
     # Format expressions as a string.
@@ -314,7 +596,7 @@ module Polars
         end
       end
 
-      concat_str(exprs, sep: "")
+      concat_str(exprs, separator: "")
     end
   end
 end

data/lib/polars/functions/business.rb

@@ -0,0 +1,95 @@
+module Polars
+  module Functions
+    # Count the number of business days between `start` and `end` (not including `end`).
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param start [Object]
+    #   Start dates.
+    # @param stop [Object]
+    #   End dates.
+    # @param week_mask [Array]
+    #   Which days of the week to count. The default is Monday to Friday.
+    #   If you wanted to count only Monday to Thursday, you would pass
+    #   `[true, true, true, true, false, false, false]`.
+    # @param holidays [Array]
+    #   Holidays to exclude from the count.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "start" => [Date.new(2020, 1, 1), Date.new(2020, 1, 2)],
+    #       "end" => [Date.new(2020, 1, 2), Date.new(2020, 1, 10)]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     business_day_count: Polars.business_day_count("start", "end")
+    #   )
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌────────────┬────────────┬────────────────────┐
+    #   # │ start      ┆ end        ┆ business_day_count │
+    #   # │ ---        ┆ ---        ┆ ---                │
+    #   # │ date       ┆ date       ┆ i32                │
+    #   # ╞════════════╪════════════╪════════════════════╡
+    #   # │ 2020-01-01 ┆ 2020-01-02 ┆ 1                  │
+    #   # │ 2020-01-02 ┆ 2020-01-10 ┆ 6                  │
+    #   # └────────────┴────────────┴────────────────────┘
+    #
+    # @example You can pass a custom weekend - for example, if you only take Sunday off:
+    #   week_mask = [true, true, true, true, true, true, false]
+    #   df.with_columns(
+    #     business_day_count: Polars.business_day_count(
+    #       "start", "end", week_mask: week_mask
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌────────────┬────────────┬────────────────────┐
+    #   # │ start      ┆ end        ┆ business_day_count │
+    #   # │ ---        ┆ ---        ┆ ---                │
+    #   # │ date       ┆ date       ┆ i32                │
+    #   # ╞════════════╪════════════╪════════════════════╡
+    #   # │ 2020-01-01 ┆ 2020-01-02 ┆ 1                  │
+    #   # │ 2020-01-02 ┆ 2020-01-10 ┆ 7                  │
+    #   # └────────────┴────────────┴────────────────────┘
+    #
+    # @example You can also pass a list of holidays to exclude from the count:
+    #   holidays = [Date.new(2020, 1, 1), Date.new(2020, 1, 2)]
+    #   df.with_columns(
+    #     business_day_count: Polars.business_day_count("start", "end", holidays: holidays)
+    #   )
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌────────────┬────────────┬────────────────────┐
+    #   # │ start      ┆ end        ┆ business_day_count │
+    #   # │ ---        ┆ ---        ┆ ---                │
+    #   # │ date       ┆ date       ┆ i32                │
+    #   # ╞════════════╪════════════╪════════════════════╡
+    #   # │ 2020-01-01 ┆ 2020-01-02 ┆ 0                  │
+    #   # │ 2020-01-02 ┆ 2020-01-10 ┆ 5                  │
+    #   # └────────────┴────────────┴────────────────────┘
+    def business_day_count(
+      start,
+      stop,
+      week_mask: [true, true, true, true, true, false, false],
+      holidays: []
+    )
+      start_rbexpr = Utils.parse_into_expression(start)
+      end_rbexpr = Utils.parse_into_expression(stop)
+      holidays_rbexpr = Utils._holidays_to_expr(holidays)
+      Utils.wrap_expr(
+        Plr.business_day_count(
+          start_rbexpr,
+          end_rbexpr,
+          week_mask,
+          holidays_rbexpr
+        )
+      )
+    end
+  end
+end

data/lib/polars/functions/col.rb

@@ -8,11 +8,11 @@ module Polars
         if Utils.strlike?(name)
           names_str = [name]
           names_str.concat(more_names)
-          return Utils.wrap_expr(Plr.cols(names_str.map(&:to_s)))
+          return Selector._by_name(names_str.map(&:to_s), strict: true, expand_patterns: true).as_expr
         elsif Utils.is_polars_dtype(name)
           dtypes = [name]
           dtypes.concat(more_names)
-          return Utils.wrap_expr(Plr.dtype_cols(dtypes))
+          return Selector._by_type(dtypes).as_expr
         else
           msg = "invalid input for `col`\n\nExpected `str` or `DataType`, got #{name.class.name}."
           raise TypeError, msg
@@ -22,7 +22,8 @@ module Polars
       if Utils.strlike?(name)
         Utils.wrap_expr(Plr.col(name.to_s))
       elsif Utils.is_polars_dtype(name)
-        Utils.wrap_expr(Plr.dtype_cols([name]))
+        dtypes = [name]
+        Selector._by_dtype(dtypes).as_expr
       elsif name.is_a?(::Array) || name.is_a?(::Set)
         names = Array(name)
         if names.empty?
@@ -31,9 +32,9 @@ module Polars
 
         item = names[0]
         if Utils.strlike?(item)
-          Utils.wrap_expr(Plr.cols(names.map(&:to_s)))
+          Selector._by_name(names.map(&:to_s), strict: true, expand_patterns: true).as_expr
         elsif Utils.is_polars_dtype(item)
-          Utils.wrap_expr(Plr.dtype_cols(names))
+          Selector._by_dtype(names).as_expr
         else
           msg = "invalid input for `col`\n\nExpected iterable of type `str` or `DataType`, got iterable of type #{item.class.name}."
           raise TypeError, msg