polars-df 0.20.0 → 0.21.1

data/ext/polars/src/lib.rs

@@ -1,5 +1,6 @@
 mod allocator;
 mod batched_csv;
+mod catalog;
 mod conversion;
 mod dataframe;
 mod error;
@@ -8,6 +9,7 @@ mod expr;
 mod file;
 mod functions;
 mod interop;
+mod io;
 mod lazyframe;
 mod lazygroupby;
 mod map;
@@ -20,23 +22,26 @@ mod sql;
 mod utils;
 
 use batched_csv::RbBatchedCsv;
+use catalog::unity::RbCatalogClient;
 use conversion::*;
 use dataframe::RbDataFrame;
 use error::RbPolarsErr;
 use exceptions::{RbTypeError, RbValueError};
-use expr::rb_exprs_to_exprs;
 use expr::RbExpr;
+use expr::datatype::RbDataTypeExpr;
+use expr::rb_exprs_to_exprs;
+use expr::selector::RbSelector;
 use functions::string_cache::RbStringCacheHolder;
 use functions::whenthen::{RbChainedThen, RbChainedWhen, RbThen, RbWhen};
 use interop::arrow::to_ruby::RbArrowArrayStream;
 use lazyframe::RbLazyFrame;
 use lazygroupby::RbLazyGroupBy;
-use magnus::{define_module, function, method, prelude::*, Ruby};
+use magnus::{Ruby, define_module, function, method, prelude::*};
 use series::RbSeries;
 use sql::RbSQLContext;
 
-use magnus::error::Result as RbResult;
 use magnus::Error as RbErr;
+use magnus::error::Result as RbResult;
 
 // TODO move
 fn re_escape(pattern: String) -> String {
@@ -143,7 +148,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
-    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
+    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 4))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
     class.define_method("map_rows", method!(RbDataFrame::map_rows, 3))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
@@ -217,6 +222,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("peak_max", method!(RbExpr::peak_max, 0))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
+    class.define_method("index_of", method!(RbExpr::index_of, 1))?;
     class.define_method("search_sorted", method!(RbExpr::search_sorted, 3))?;
     class.define_method("gather", method!(RbExpr::gather, 1))?;
     class.define_method("get", method!(RbExpr::get, 1))?;
@@ -236,6 +242,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("var", method!(RbExpr::var, 1))?;
     class.define_method("is_unique", method!(RbExpr::is_unique, 0))?;
     class.define_method("is_between", method!(RbExpr::is_between, 3))?;
+    class.define_method("is_close", method!(RbExpr::is_close, 4))?;
     class.define_method("approx_n_unique", method!(RbExpr::approx_n_unique, 0))?;
     class.define_method("is_first_distinct", method!(RbExpr::is_first_distinct, 0))?;
     class.define_method("is_last_distinct", method!(RbExpr::is_last_distinct, 0))?;
@@ -247,6 +254,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("append", method!(RbExpr::append, 2))?;
     class.define_method("rechunk", method!(RbExpr::rechunk, 0))?;
     class.define_method("round", method!(RbExpr::round, 2))?;
+    class.define_method("round_sig_figs", method!(RbExpr::round_sig_figs, 1))?;
     class.define_method("floor", method!(RbExpr::floor, 0))?;
     class.define_method("ceil", method!(RbExpr::ceil, 0))?;
     class.define_method("clip", method!(RbExpr::clip, 2))?;
@@ -254,6 +262,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sin", method!(RbExpr::sin, 0))?;
     class.define_method("cos", method!(RbExpr::cos, 0))?;
     class.define_method("tan", method!(RbExpr::tan, 0))?;
+    class.define_method("cot", method!(RbExpr::cot, 0))?;
     class.define_method("arcsin", method!(RbExpr::arcsin, 0))?;
     class.define_method("arccos", method!(RbExpr::arccos, 0))?;
     class.define_method("arctan", method!(RbExpr::arctan, 0))?;
@@ -263,15 +272,20 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arcsinh", method!(RbExpr::arcsinh, 0))?;
     class.define_method("arccosh", method!(RbExpr::arccosh, 0))?;
     class.define_method("arctanh", method!(RbExpr::arctanh, 0))?;
+    class.define_method("degrees", method!(RbExpr::degrees, 0))?;
+    class.define_method("radians", method!(RbExpr::radians, 0))?;
     class.define_method("sign", method!(RbExpr::sign, 0))?;
     class.define_method("is_duplicated", method!(RbExpr::is_duplicated, 0))?;
     class.define_method("over", method!(RbExpr::over, 1))?;
-    class.define_method("_and", method!(RbExpr::_and, 1))?;
-    class.define_method("_xor", method!(RbExpr::_xor, 1))?;
-    class.define_method("_or", method!(RbExpr::_or, 1))?;
+    class.define_method("rolling", method!(RbExpr::rolling, 4))?;
+    class.define_method("and_", method!(RbExpr::and_, 1))?;
+    class.define_method("or_", method!(RbExpr::or_, 1))?;
+    class.define_method("xor_", method!(RbExpr::xor_, 1))?;
     class.define_method("is_in", method!(RbExpr::is_in, 2))?;
     class.define_method("repeat_by", method!(RbExpr::repeat_by, 1))?;
     class.define_method("pow", method!(RbExpr::pow, 1))?;
+    class.define_method("sqrt", method!(RbExpr::sqrt, 0))?;
+    class.define_method("cbrt", method!(RbExpr::cbrt, 0))?;
     class.define_method("cum_sum", method!(RbExpr::cum_sum, 1))?;
     class.define_method("cum_max", method!(RbExpr::cum_max, 1))?;
     class.define_method("cum_min", method!(RbExpr::cum_min, 1))?;
@@ -293,6 +307,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_strip_prefix", method!(RbExpr::str_strip_prefix, 1))?;
     class.define_method("str_strip_suffix", method!(RbExpr::str_strip_suffix, 1))?;
     class.define_method("str_slice", method!(RbExpr::str_slice, 2))?;
+    class.define_method("str_head", method!(RbExpr::str_head, 1))?;
+    class.define_method("str_tail", method!(RbExpr::str_tail, 1))?;
     class.define_method("str_to_uppercase", method!(RbExpr::str_to_uppercase, 0))?;
     class.define_method("str_to_lowercase", method!(RbExpr::str_to_lowercase, 0))?;
     // class.define_method("str_to_titlecase", method!(RbExpr::str_to_titlecase, 0))?;
@@ -300,17 +316,25 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_len_chars", method!(RbExpr::str_len_chars, 0))?;
     class.define_method("str_replace_n", method!(RbExpr::str_replace_n, 4))?;
     class.define_method("str_replace_all", method!(RbExpr::str_replace_all, 3))?;
+    class.define_method("str_normalize", method!(RbExpr::str_normalize, 1))?;
     class.define_method("str_reverse", method!(RbExpr::str_reverse, 0))?;
     class.define_method("str_zfill", method!(RbExpr::str_zfill, 1))?;
     class.define_method("str_pad_start", method!(RbExpr::str_pad_start, 2))?;
     class.define_method("str_pad_end", method!(RbExpr::str_pad_end, 2))?;
     class.define_method("str_contains", method!(RbExpr::str_contains, 3))?;
+    class.define_method("str_find", method!(RbExpr::str_find, 3))?;
     class.define_method("str_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
-    class.define_method("array_max", method!(RbExpr::array_max, 0))?;
-    class.define_method("array_min", method!(RbExpr::array_min, 0))?;
-    class.define_method("array_sum", method!(RbExpr::array_sum, 0))?;
+    class.define_method("arr_len", method!(RbExpr::arr_len, 0))?;
+    class.define_method("arr_max", method!(RbExpr::arr_max, 0))?;
+    class.define_method("arr_min", method!(RbExpr::arr_min, 0))?;
+    class.define_method("arr_sum", method!(RbExpr::arr_sum, 0))?;
+    class.define_method("arr_std", method!(RbExpr::arr_std, 1))?;
+    class.define_method("arr_var", method!(RbExpr::arr_var, 1))?;
+    class.define_method("arr_mean", method!(RbExpr::arr_mean, 0))?;
+    class.define_method("arr_median", method!(RbExpr::arr_median, 0))?;
     class.define_method("arr_unique", method!(RbExpr::arr_unique, 1))?;
+    class.define_method("arr_n_unique", method!(RbExpr::arr_n_unique, 0))?;
     class.define_method("arr_to_list", method!(RbExpr::arr_to_list, 0))?;
     class.define_method("arr_all", method!(RbExpr::arr_all, 0))?;
     class.define_method("arr_any", method!(RbExpr::arr_any, 0))?;
@@ -322,6 +346,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arr_join", method!(RbExpr::arr_join, 2))?;
     class.define_method("arr_contains", method!(RbExpr::arr_contains, 2))?;
     class.define_method("arr_count_matches", method!(RbExpr::arr_count_matches, 1))?;
+    class.define_method("arr_to_struct", method!(RbExpr::arr_to_struct, 1))?;
+    class.define_method("arr_slice", method!(RbExpr::arr_slice, 3))?;
+    class.define_method("arr_tail", method!(RbExpr::arr_tail, 2))?;
+    class.define_method("arr_shift", method!(RbExpr::arr_shift, 1))?;
+    class.define_method("arr_explode", method!(RbExpr::arr_explode, 0))?;
     class.define_method("binary_contains", method!(RbExpr::bin_contains, 1))?;
     class.define_method("binary_ends_with", method!(RbExpr::bin_ends_with, 1))?;
     class.define_method("binary_starts_with", method!(RbExpr::bin_starts_with, 1))?;
@@ -329,7 +358,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_hex_decode", method!(RbExpr::str_hex_decode, 1))?;
     class.define_method("str_base64_encode", method!(RbExpr::str_base64_encode, 0))?;
     class.define_method("str_base64_decode", method!(RbExpr::str_base64_decode, 1))?;
-    class.define_method("str_to_integer", method!(RbExpr::str_to_integer, 2))?;
+    class.define_method("str_to_integer", method!(RbExpr::str_to_integer, 3))?;
     class.define_method("str_json_decode", method!(RbExpr::str_json_decode, 2))?;
     class.define_method("binary_hex_encode", method!(RbExpr::bin_hex_encode, 0))?;
     class.define_method("binary_hex_decode", method!(RbExpr::bin_hex_decode, 1))?;
@@ -341,6 +370,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "binary_base64_decode",
         method!(RbExpr::bin_base64_decode, 1),
     )?;
+    class.define_method("bin_reinterpret", method!(RbExpr::bin_reinterpret, 2))?;
+    class.define_method("bin_size_bytes", method!(RbExpr::bin_size_bytes, 0))?;
     class.define_method(
         "str_json_path_match",
         method!(RbExpr::str_json_path_match, 1),
@@ -349,7 +380,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_extract_all", method!(RbExpr::str_extract_all, 1))?;
     class.define_method("str_extract_groups", method!(RbExpr::str_extract_groups, 1))?;
     class.define_method("str_count_matches", method!(RbExpr::str_count_matches, 2))?;
-    class.define_method("strftime", method!(RbExpr::dt_to_string, 1))?;
     class.define_method("str_split", method!(RbExpr::str_split, 1))?;
     class.define_method(
         "str_split_inclusive",
@@ -364,10 +394,21 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_to_decimal", method!(RbExpr::str_to_decimal, 1))?;
     class.define_method("str_contains_any", method!(RbExpr::str_contains_any, 2))?;
     class.define_method("str_replace_many", method!(RbExpr::str_replace_many, 3))?;
+    class.define_method("str_extract_many", method!(RbExpr::str_extract_many, 3))?;
+    class.define_method("str_find_many", method!(RbExpr::str_find_many, 3))?;
+    class.define_method("str_escape_regex", method!(RbExpr::str_escape_regex, 0))?;
     class.define_method("list_len", method!(RbExpr::list_len, 0))?;
     class.define_method("list_contains", method!(RbExpr::list_contains, 2))?;
     class.define_method("list_count_matches", method!(RbExpr::list_count_matches, 1))?;
+    class.define_method(
+        "dt_add_business_days",
+        method!(RbExpr::dt_add_business_days, 4),
+    )?;
+    class.define_method("strftime", method!(RbExpr::dt_to_string, 1))?;
+    class.define_method("dt_millennium", method!(RbExpr::dt_millennium, 0))?;
+    class.define_method("dt_century", method!(RbExpr::dt_century, 0))?;
     class.define_method("dt_year", method!(RbExpr::dt_year, 0))?;
+    class.define_method("dt_is_business_day", method!(RbExpr::dt_is_business_day, 2))?;
     class.define_method("dt_is_leap_year", method!(RbExpr::dt_is_leap_year, 0))?;
     class.define_method("dt_iso_year", method!(RbExpr::dt_iso_year, 0))?;
     class.define_method("dt_quarter", method!(RbExpr::dt_quarter, 0))?;
@@ -421,12 +462,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_base_utc_offset", method!(RbExpr::dt_base_utc_offset, 0))?;
     class.define_method("dt_dst_offset", method!(RbExpr::dt_dst_offset, 0))?;
     class.define_method("dt_round", method!(RbExpr::dt_round, 1))?;
+    class.define_method("dt_replace", method!(RbExpr::dt_replace, 8))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
     class.define_method("map_batches", method!(RbExpr::map_batches, 5))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
     class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
-    class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
     class.define_method("interpolate_by", method!(RbExpr::interpolate_by, 1))?;
     class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 4))?;
@@ -449,6 +490,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::rolling_quantile_by, 6),
     )?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 4))?;
+    class.define_method("rolling_kurtosis", method!(RbExpr::rolling_kurtosis, 5))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
     class.define_method("list_max", method!(RbExpr::list_max, 0))?;
@@ -461,12 +503,18 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::list_sample_fraction, 4),
     )?;
     class.define_method("list_gather", method!(RbExpr::list_gather, 2))?;
+    class.define_method("list_gather_every", method!(RbExpr::list_gather_every, 2))?;
     class.define_method("list_to_array", method!(RbExpr::list_to_array, 1))?;
     class.define_method("list_mean", method!(RbExpr::list_mean, 0))?;
+    class.define_method("list_median", method!(RbExpr::list_median, 0))?;
+    class.define_method("list_std", method!(RbExpr::list_std, 1))?;
+    class.define_method("list_var", method!(RbExpr::list_var, 1))?;
     class.define_method("list_tail", method!(RbExpr::list_tail, 1))?;
     class.define_method("list_sort", method!(RbExpr::list_sort, 2))?;
     class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
+    class.define_method("list_n_unique", method!(RbExpr::list_n_unique, 0))?;
     class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
+    class.define_method("list_set_operation", method!(RbExpr::list_set_operation, 2))?;
     class.define_method("list_get", method!(RbExpr::list_get, 2))?;
     class.define_method("list_join", method!(RbExpr::list_join, 2))?;
     class.define_method("list_arg_min", method!(RbExpr::list_arg_min, 0))?;
@@ -477,6 +525,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_shift", method!(RbExpr::list_shift, 1))?;
     class.define_method("list_slice", method!(RbExpr::list_slice, 2))?;
     class.define_method("list_eval", method!(RbExpr::list_eval, 1))?;
+    class.define_method("list_filter", method!(RbExpr::list_filter, 1))?;
     class.define_method("cumulative_eval", method!(RbExpr::cumulative_eval, 2))?;
     class.define_method("list_to_struct", method!(RbExpr::list_to_struct, 3))?;
     class.define_method("rank", method!(RbExpr::rank, 3))?;
@@ -486,6 +535,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("kurtosis", method!(RbExpr::kurtosis, 2))?;
     class.define_method("str_join", method!(RbExpr::str_join, 2))?;
     class.define_method("cat_get_categories", method!(RbExpr::cat_get_categories, 0))?;
+    class.define_method("cat_len_bytes", method!(RbExpr::cat_len_bytes, 0))?;
+    class.define_method("cat_len_chars", method!(RbExpr::cat_len_chars, 0))?;
+    class.define_method("cat_starts_with", method!(RbExpr::cat_starts_with, 1))?;
+    class.define_method("cat_ends_with", method!(RbExpr::cat_ends_with, 1))?;
+    class.define_method("cat_slice", method!(RbExpr::cat_slice, 2))?;
     class.define_method("reshape", method!(RbExpr::reshape, 1))?;
     class.define_method("cum_count", method!(RbExpr::cum_count, 1))?;
     class.define_method("to_physical", method!(RbExpr::to_physical, 0))?;
@@ -493,6 +547,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sample_n", method!(RbExpr::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbExpr::sample_frac, 4))?;
     class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 4))?;
+    class.define_method("ewm_mean_by", method!(RbExpr::ewm_mean_by, 2))?;
     class.define_method("ewm_std", method!(RbExpr::ewm_std, 5))?;
     class.define_method("ewm_var", method!(RbExpr::ewm_var, 5))?;
     class.define_method("extend_constant", method!(RbExpr::extend_constant, 2))?;
@@ -511,13 +566,44 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::struct_rename_fields, 1),
     )?;
     class.define_method("struct_json_encode", method!(RbExpr::struct_json_encode, 0))?;
+    class.define_method("struct_with_fields", method!(RbExpr::struct_with_fields, 1))?;
     class.define_method("log", method!(RbExpr::log, 1))?;
+    class.define_method("log1p", method!(RbExpr::log1p, 0))?;
     class.define_method("exp", method!(RbExpr::exp, 0))?;
     class.define_method("entropy", method!(RbExpr::entropy, 2))?;
     class.define_method("_hash", method!(RbExpr::hash, 4))?;
     class.define_method("set_sorted_flag", method!(RbExpr::set_sorted_flag, 1))?;
     class.define_method("replace", method!(RbExpr::replace, 2))?;
     class.define_method("replace_strict", method!(RbExpr::replace_strict, 4))?;
+    class.define_method("hist", method!(RbExpr::hist, 4))?;
+    class.define_method("into_selector", method!(RbExpr::into_selector, 0))?;
+    class.define_singleton_method("new_selector", function!(RbExpr::new_selector, 1))?;
+
+    // bitwise
+    class.define_method("bitwise_count_ones", method!(RbExpr::bitwise_count_ones, 0))?;
+    class.define_method(
+        "bitwise_count_zeros",
+        method!(RbExpr::bitwise_count_zeros, 0),
+    )?;
+    class.define_method(
+        "bitwise_leading_ones",
+        method!(RbExpr::bitwise_leading_ones, 0),
+    )?;
+    class.define_method(
+        "bitwise_leading_zeros",
+        method!(RbExpr::bitwise_leading_zeros, 0),
+    )?;
+    class.define_method(
+        "bitwise_trailing_ones",
+        method!(RbExpr::bitwise_trailing_ones, 0),
+    )?;
+    class.define_method(
+        "bitwise_trailing_zeros",
+        method!(RbExpr::bitwise_trailing_zeros, 0),
+    )?;
+    class.define_method("bitwise_and", method!(RbExpr::bitwise_and, 0))?;
+    class.define_method("bitwise_or", method!(RbExpr::bitwise_or, 0))?;
+    class.define_method("bitwise_xor", method!(RbExpr::bitwise_xor, 0))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 1))?;
@@ -534,10 +620,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "meta_is_regex_projection",
         method!(RbExpr::meta_is_regex_projection, 0),
     )?;
-    class.define_method("_meta_selector_add", method!(RbExpr::_meta_selector_add, 1))?;
-    class.define_method("_meta_selector_sub", method!(RbExpr::_meta_selector_sub, 1))?;
-    class.define_method("_meta_selector_and", method!(RbExpr::_meta_selector_and, 1))?;
-    class.define_method("_meta_as_selector", method!(RbExpr::_meta_as_selector, 0))?;
+    class.define_method(
+        "meta_is_column_selection",
+        method!(RbExpr::meta_is_column_selection, 1),
+    )?;
+    class.define_method("meta_is_literal", method!(RbExpr::meta_is_literal, 1))?;
     class.define_method("meta_tree_format", method!(RbExpr::meta_tree_format, 1))?;
 
     // name
@@ -547,18 +634,15 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("name_suffix", method!(RbExpr::name_suffix, 1))?;
     class.define_method("name_to_lowercase", method!(RbExpr::name_to_lowercase, 0))?;
     class.define_method("name_to_uppercase", method!(RbExpr::name_to_uppercase, 0))?;
+    class.define_method("name_prefix_fields", method!(RbExpr::name_prefix_fields, 1))?;
+    class.define_method("name_suffix_fields", method!(RbExpr::name_suffix_fields, 1))?;
 
     // maybe add to different class
     let class = module.define_module("Plr")?;
-    class.define_singleton_method("dtype_cols", function!(functions::lazy::dtype_cols, 1))?;
-    class.define_singleton_method("index_cols", function!(functions::lazy::index_cols, 1))?;
     class.define_singleton_method("col", function!(functions::lazy::col, 1))?;
     class.define_singleton_method("len", function!(functions::lazy::len, 0))?;
-    class.define_singleton_method("first", function!(functions::lazy::first, 0))?;
-    class.define_singleton_method("last", function!(functions::lazy::last, 0))?;
-    class.define_singleton_method("cols", function!(functions::lazy::cols, 1))?;
     class.define_singleton_method("fold", function!(functions::lazy::fold, 5))?;
-    class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 4))?;
+    class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 6))?;
     class.define_singleton_method("lit", function!(functions::lazy::lit, 3))?;
     class.define_singleton_method("int_range", function!(functions::range::int_range, 4))?;
     class.define_singleton_method("int_ranges", function!(functions::range::int_ranges, 4))?;
@@ -607,6 +691,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(functions::aggregation::mean_horizontal, 2),
     )?;
     class.define_singleton_method("as_struct", function!(functions::lazy::as_struct, 1))?;
+    class.define_singleton_method("field", function!(functions::lazy::field, 1))?;
     class.define_singleton_method("coalesce", function!(functions::lazy::coalesce, 1))?;
     class.define_singleton_method("arg_where", function!(functions::lazy::arg_where, 1))?;
     class.define_singleton_method(
@@ -633,6 +718,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method("duration", function!(functions::lazy::duration, 9))?;
     class.define_singleton_method("ipc_schema", function!(functions::io::read_ipc_schema, 1))?;
+    class.define_singleton_method(
+        "read_parquet_metadata",
+        function!(functions::io::read_parquet_metadata, 1),
+    )?;
     class.define_singleton_method(
         "parquet_schema",
         function!(functions::io::read_parquet_schema, 1),
@@ -729,7 +818,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, -1),
+        function!(RbLazyFrame::new_from_parquet, 6),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 10))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -744,14 +833,16 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("sort", method!(RbLazyFrame::sort, 5))?;
     class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 5))?;
+    class.define_method("top_k", method!(RbLazyFrame::top_k, 3))?;
+    class.define_method("bottom_k", method!(RbLazyFrame::bottom_k, 3))?;
     class.define_method("cache", method!(RbLazyFrame::cache, 0))?;
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
     class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 9))?;
     class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 5))?;
     class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, -1))?;
     class.define_method("sink_json", method!(RbLazyFrame::sink_json, 4))?;
-    class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
+    class.define_method("remove", method!(RbLazyFrame::remove, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
     class.define_method("select_seq", method!(RbLazyFrame::select_seq, 1))?;
     class.define_method("group_by", method!(RbLazyFrame::group_by, 2))?;
@@ -763,6 +854,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 14))?;
     class.define_method("join", method!(RbLazyFrame::join, 11))?;
+    class.define_method("join_where", method!(RbLazyFrame::join_where, 3))?;
     class.define_method("with_column", method!(RbLazyFrame::with_column, 1))?;
     class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
     class.define_method(
@@ -784,6 +876,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("explode", method!(RbLazyFrame::explode, 1))?;
     class.define_method("null_count", method!(RbLazyFrame::null_count, 0))?;
     class.define_method("unique", method!(RbLazyFrame::unique, 3))?;
+    class.define_method("drop_nans", method!(RbLazyFrame::drop_nans, 1))?;
     class.define_method("drop_nulls", method!(RbLazyFrame::drop_nulls, 1))?;
     class.define_method("slice", method!(RbLazyFrame::slice, 2))?;
     class.define_method("tail", method!(RbLazyFrame::tail, 1))?;
@@ -858,7 +951,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("estimated_size", method!(RbSeries::estimated_size, 0))?;
     class.define_method("get_fmt", method!(RbSeries::get_fmt, 2))?;
     class.define_method("rechunk", method!(RbSeries::rechunk, 1))?;
-    class.define_method("get_idx", method!(RbSeries::get_idx, 1))?;
+    class.define_method("get_index", method!(RbSeries::get_index, 1))?;
+    class.define_method("get_index_signed", method!(RbSeries::get_index_signed, 1))?;
     class.define_method("bitand", method!(RbSeries::bitand, 1))?;
     class.define_method("bitor", method!(RbSeries::bitor, 1))?;
     class.define_method("bitxor", method!(RbSeries::bitxor, 1))?;
@@ -872,6 +966,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("max", method!(RbSeries::max, 0))?;
     class.define_method("min", method!(RbSeries::min, 0))?;
     class.define_method("sum", method!(RbSeries::sum, 0))?;
+    class.define_method("first", method!(RbSeries::first, 0))?;
+    class.define_method("last", method!(RbSeries::last, 0))?;
+    class.define_method("approx_n_unique", method!(RbSeries::approx_n_unique, 0))?;
+    class.define_method("bitwise_and", method!(RbSeries::bitwise_and, 0))?;
+    class.define_method("bitwise_or", method!(RbSeries::bitwise_or, 0))?;
+    class.define_method("bitwise_xor", method!(RbSeries::bitwise_xor, 0))?;
     class.define_method("n_chunks", method!(RbSeries::n_chunks, 0))?;
     class.define_method("append", method!(RbSeries::append, 1))?;
     class.define_method("extend", method!(RbSeries::extend, 1))?;
@@ -901,16 +1001,16 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("gt_eq", method!(RbSeries::gt_eq, 1))?;
     class.define_method("lt", method!(RbSeries::lt, 1))?;
     class.define_method("lt_eq", method!(RbSeries::lt_eq, 1))?;
-    class.define_method("not", method!(RbSeries::not, 0))?;
+    class.define_method("not_", method!(RbSeries::not_, 0))?;
     class.define_method("to_s", method!(RbSeries::to_s, 0))?;
     class.define_method("len", method!(RbSeries::len, 0))?;
     class.define_method("to_a", method!(RbSeries::to_a, 0))?;
     class.define_method("median", method!(RbSeries::median, 0))?;
     class.define_method("quantile", method!(RbSeries::quantile, 2))?;
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
-    class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
+    class.define_method("map_elements", method!(RbSeries::map_elements, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
-    class.define_method("to_dummies", method!(RbSeries::to_dummies, 2))?;
+    class.define_method("to_dummies", method!(RbSeries::to_dummies, 3))?;
     class.define_method("n_unique", method!(RbSeries::n_unique, 0))?;
     class.define_method("floor", method!(RbSeries::floor, 0))?;
     class.define_method("shrink_to_fit", method!(RbSeries::shrink_to_fit, 0))?;
@@ -918,6 +1018,9 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("skew", method!(RbSeries::skew, 1))?;
     class.define_method("kurtosis", method!(RbSeries::kurtosis, 2))?;
     class.define_method("cast", method!(RbSeries::cast, 2))?;
+    class.define_method("get_chunks", method!(RbSeries::get_chunks, 0))?;
+    class.define_method("is_sorted", method!(RbSeries::is_sorted, 2))?;
+    class.define_method("clear", method!(RbSeries::clear, 0))?;
     class.define_method("time_unit", method!(RbSeries::time_unit, 0))?;
     class.define_method("scatter", method!(RbSeries::scatter, 2))?;
 
@@ -1111,5 +1214,89 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     let class = module.define_class("ArrowArrayStream", ruby.class_object())?;
     class.define_method("to_i", method!(RbArrowArrayStream::to_i, 0))?;
 
+    // catalog
+    let class = module.define_class("RbCatalogClient", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbCatalogClient::new, 2))?;
+    class.define_singleton_method(
+        "type_json_to_polars_type",
+        function!(RbCatalogClient::type_json_to_polars_type, 1),
+    )?;
+    class.define_method("list_catalogs", method!(RbCatalogClient::list_catalogs, 0))?;
+    class.define_method(
+        "list_namespaces",
+        method!(RbCatalogClient::list_namespaces, 1),
+    )?;
+    class.define_method("list_tables", method!(RbCatalogClient::list_tables, 2))?;
+    class.define_method(
+        "get_table_info",
+        method!(RbCatalogClient::get_table_info, 3),
+    )?;
+    class.define_method(
+        "create_catalog",
+        method!(RbCatalogClient::create_catalog, 3),
+    )?;
+    class.define_method(
+        "delete_catalog",
+        method!(RbCatalogClient::delete_catalog, 2),
+    )?;
+    class.define_method(
+        "create_namespace",
+        method!(RbCatalogClient::create_namespace, 4),
+    )?;
+    class.define_method(
+        "delete_namespace",
+        method!(RbCatalogClient::delete_namespace, 3),
+    )?;
+    class.define_method("create_table", method!(RbCatalogClient::create_table, 9))?;
+    class.define_method("delete_table", method!(RbCatalogClient::delete_table, 3))?;
+
+    // categories
+    let class = module.define_class("RbCategories", ruby.class_object())?;
+    class.define_singleton_method(
+        "global_categories",
+        function!(RbCategories::global_categories, 0),
+    )?;
+
+    // data type expr
+    let class = module.define_class("RbDataTypeExpr", ruby.class_object())?;
+    class.define_singleton_method("from_dtype", function!(RbDataTypeExpr::from_dtype, 1))?;
+    class.define_singleton_method("of_expr", function!(RbDataTypeExpr::of_expr, 1))?;
+    class.define_method("collect_dtype", method!(RbDataTypeExpr::collect_dtype, 1))?;
+
+    // selector
+    let class = module.define_class("RbSelector", ruby.class_object())?;
+    class.define_method("union", method!(RbSelector::union, 1))?;
+    class.define_method("difference", method!(RbSelector::difference, 1))?;
+    class.define_method("exclusive_or", method!(RbSelector::exclusive_or, 1))?;
+    class.define_method("intersect", method!(RbSelector::intersect, 1))?;
+    class.define_singleton_method("by_dtype", function!(RbSelector::by_dtype, 1))?;
+    class.define_singleton_method("by_name", function!(RbSelector::by_name, 2))?;
+    class.define_singleton_method("by_index", function!(RbSelector::by_index, 2))?;
+    class.define_singleton_method("first", function!(RbSelector::first, 1))?;
+    class.define_singleton_method("last", function!(RbSelector::last, 1))?;
+    class.define_singleton_method("matches", function!(RbSelector::matches, 1))?;
+    class.define_singleton_method("enum_", function!(RbSelector::enum_, 0))?;
+    class.define_singleton_method("categorical", function!(RbSelector::categorical, 0))?;
+    class.define_singleton_method("nested", function!(RbSelector::nested, 0))?;
+    class.define_singleton_method("list", function!(RbSelector::list, 1))?;
+    class.define_singleton_method("array", function!(RbSelector::array, 2))?;
+    class.define_singleton_method("struct_", function!(RbSelector::struct_, 0))?;
+    class.define_singleton_method("integer", function!(RbSelector::integer, 0))?;
+    class.define_singleton_method("signed_integer", function!(RbSelector::signed_integer, 0))?;
+    class.define_singleton_method(
+        "unsigned_integer",
+        function!(RbSelector::unsigned_integer, 0),
+    )?;
+    class.define_singleton_method("float", function!(RbSelector::float, 0))?;
+    class.define_singleton_method("decimal", function!(RbSelector::decimal, 0))?;
+    class.define_singleton_method("numeric", function!(RbSelector::numeric, 0))?;
+    class.define_singleton_method("temporal", function!(RbSelector::temporal, 0))?;
+    class.define_singleton_method("datetime", function!(RbSelector::datetime, 2))?;
+    class.define_singleton_method("duration", function!(RbSelector::duration, 1))?;
+    class.define_singleton_method("object", function!(RbSelector::object, 0))?;
+    class.define_singleton_method("empty", function!(RbSelector::empty, 0))?;
+    class.define_singleton_method("all", function!(RbSelector::all, 0))?;
+    class.define_method("_hash", method!(RbSelector::hash, 0))?;
+
     Ok(())
 }

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

@@ -1,19 +1,19 @@
-use magnus::{class, prelude::*, typed_data::Obj, IntoValue, RArray, TryConvert, Value};
+use magnus::{IntoValue, RArray, TryConvert, Value, class, prelude::*, typed_data::Obj};
 use polars::prelude::*;
-use polars_core::frame::row::{rows_to_schema_first_non_null, Row};
+use polars_core::frame::row::{Row, rows_to_schema_first_non_null};
 use polars_core::series::SeriesIter;
 
 use super::*;
 use crate::{RbDataFrame, RbPolarsErr, RbSeries, Wrap};
 
-fn get_iters(df: &DataFrame) -> Vec<SeriesIter> {
+fn get_iters(df: &DataFrame) -> Vec<SeriesIter<'_>> {
     df.get_columns()
         .iter()
         .map(|s| s.as_materialized_series().iter())
         .collect()
 }
 
-fn get_iters_skip(df: &DataFrame, skip: usize) -> Vec<std::iter::Skip<SeriesIter>> {
+fn get_iters_skip(df: &DataFrame, skip: usize) -> Vec<std::iter::Skip<SeriesIter<'_>>> {
     df.get_columns()
         .iter()
         .map(|s| s.as_materialized_series().iter().skip(skip))
@@ -144,7 +144,7 @@ where
         let tpl = (RArray::from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => T::try_convert(val).ok(),
-            Err(e) => panic!("ruby function failed {}", e),
+            Err(e) => panic!("ruby function failed {e}"),
         }
     })
 }
@@ -157,7 +157,7 @@ pub fn apply_lambda_with_primitive_out_type<D>(
     first_value: Option<D::Native>,
 ) -> ChunkedArray<D>
 where
-    D: RbArrowPrimitiveType,
+    D: RbPolarsNumericType,
     D::Native: IntoValue + TryConvert,
 {
     let skip = usize::from(first_value.is_some());
@@ -247,11 +247,11 @@ pub fn apply_lambda_with_list_out_type(
                         if val.is_nil() {
                             None
                         } else {
-                            panic!("should return a Series, got a {:?}", val)
+                            panic!("should return a Series, got a {val:?}")
                         }
                     }
                 },
-                Err(e) => panic!("ruby function failed {}", e),
+                Err(e) => panic!("ruby function failed {e}"),
             }
         });
         iterator_to_list(
@@ -302,7 +302,7 @@ pub fn apply_lambda_with_rows_output<'a>(
                     None => Ok(&null_row),
                 }
             }
-            Err(e) => panic!("ruby function failed {}", e),
+            Err(e) => panic!("ruby function failed {e}"),
         }
     });
 

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

@@ -1,4 +1,4 @@
-use magnus::{prelude::*, RArray, Value};
+use magnus::{RArray, Value, prelude::*};
 use polars::prelude::*;
 
 use crate::rb_modules::*;