polars-df 0.8.0 → 0.9.0

data/ext/polars/src/lib.rs

@@ -8,8 +8,8 @@ mod functions;
 mod lazyframe;
 mod lazygroupby;
 mod map;
-mod on_startup;
 mod object;
+mod on_startup;
 mod prelude;
 pub(crate) mod rb_modules;
 mod series;
@@ -22,6 +22,7 @@ use dataframe::RbDataFrame;
 use error::{RbPolarsErr, RbTypeError, RbValueError};
 use expr::rb_exprs_to_exprs;
 use expr::RbExpr;
+use functions::string_cache::RbStringCacheHolder;
 use functions::whenthen::{RbThen, RbWhen};
 use lazyframe::RbLazyFrame;
 use lazygroupby::RbLazyGroupBy;
@@ -48,122 +49,6 @@ type RbResult<T> = Result<T, Error>;
 #[magnus::init]
 fn init(ruby: &Ruby) -> RbResult<()> {
     let module = define_module("Polars")?;
-    module.define_singleton_method(
-        "_dtype_cols",
-        function!(crate::functions::lazy::dtype_cols2, 1),
-    )?;
-    module.define_singleton_method(
-        "_concat_lf_diagonal",
-        function!(crate::functions::lazy::concat_lf_diagonal, 4),
-    )?;
-    module.define_singleton_method(
-        "_rb_duration",
-        function!(crate::functions::lazy::duration, 9),
-    )?;
-    module.define_singleton_method(
-        "_concat_df",
-        function!(crate::functions::eager::concat_df, 1),
-    )?;
-    module.define_singleton_method(
-        "_concat_lf",
-        function!(crate::functions::lazy::concat_lf, 4),
-    )?;
-    module.define_singleton_method(
-        "_concat_df_diagonal",
-        function!(crate::functions::eager::concat_df_diagonal, 1),
-    )?;
-    module.define_singleton_method(
-        "_concat_df_horizontal",
-        function!(crate::functions::eager::concat_df_horizontal, 1),
-    )?;
-    module.define_singleton_method(
-        "_concat_series",
-        function!(crate::functions::eager::concat_series, 1),
-    )?;
-    module.define_singleton_method(
-        "_ipc_schema",
-        function!(crate::functions::io::read_ipc_schema, 1),
-    )?;
-    module.define_singleton_method(
-        "_parquet_schema",
-        function!(crate::functions::io::read_parquet_schema, 1),
-    )?;
-    module.define_singleton_method(
-        "_collect_all",
-        function!(crate::functions::lazy::collect_all, 1),
-    )?;
-    module.define_singleton_method(
-        "_rb_date_range",
-        function!(crate::functions::range::date_range, 6),
-    )?;
-    module.define_singleton_method(
-        "_coalesce_exprs",
-        function!(crate::functions::lazy::coalesce, 1),
-    )?;
-    module.define_singleton_method(
-        "_all_horizontal",
-        function!(crate::functions::aggregation::all_horizontal, 1),
-    )?;
-    module.define_singleton_method(
-        "_any_horizontal",
-        function!(crate::functions::aggregation::any_horizontal, 1),
-    )?;
-    module.define_singleton_method(
-        "_max_horizontal",
-        function!(crate::functions::aggregation::max_horizontal, 1),
-    )?;
-    module.define_singleton_method(
-        "_min_horizontal",
-        function!(crate::functions::aggregation::min_horizontal, 1),
-    )?;
-    module.define_singleton_method(
-        "_sum_horizontal",
-        function!(crate::functions::aggregation::sum_horizontal, 1),
-    )?;
-    module.define_singleton_method(
-        "_dtype_str_repr",
-        function!(crate::functions::misc::dtype_str_repr, 1),
-    )?;
-    module.define_singleton_method(
-        "_as_struct",
-        function!(crate::functions::lazy::as_struct, 1),
-    )?;
-    module.define_singleton_method(
-        "_arg_where",
-        function!(crate::functions::lazy::arg_where, 1),
-    )?;
-    module.define_singleton_method(
-        "_get_idx_type",
-        function!(crate::functions::meta::get_idx_type, 0),
-    )?;
-    module.define_singleton_method(
-        "_threadpool_size",
-        function!(crate::functions::meta::threadpool_size, 0),
-    )?;
-    module.define_singleton_method(
-        "_enable_string_cache",
-        function!(crate::functions::string_cache::enable_string_cache, 0),
-    )?;
-    module.define_singleton_method(
-        "_disable_string_cache",
-        function!(crate::functions::string_cache::disable_string_cache, 0),
-    )?;
-    module.define_singleton_method(
-        "_using_string_cache",
-        function!(crate::functions::string_cache::using_string_cache, 0),
-    )?;
-    module.define_singleton_method(
-        "_set_float_fmt",
-        function!(crate::functions::meta::set_float_fmt, 1),
-    )?;
-    module.define_singleton_method(
-        "_get_float_fmt",
-        function!(crate::functions::meta::get_float_fmt, 0),
-    )?;
-    module.define_singleton_method(
-        "_set_random_seed",
-        function!(crate::functions::random::set_random_seed, 1),
-    )?;
 
     let class = module.define_class("RbBatchedCsv", ruby.class_object())?;
     class.define_singleton_method("new", function!(RbBatchedCsv::new, -1))?;
@@ -176,7 +61,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
     class.define_singleton_method("read_avro", function!(RbDataFrame::read_avro, 4))?;
     class.define_singleton_method("read_rows", function!(RbDataFrame::read_rows, 3))?;
-    class.define_singleton_method("read_hashes", function!(RbDataFrame::read_hashes, 3))?;
+    class.define_singleton_method("read_hashes", function!(RbDataFrame::read_hashes, 4))?;
     class.define_singleton_method("read_hash", function!(RbDataFrame::read_hash, 1))?;
     class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 1))?;
     class.define_singleton_method("read_ndjson", function!(RbDataFrame::read_ndjson, 1))?;
@@ -228,7 +113,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "get_column_index",
         method!(RbDataFrame::get_column_index, 1),
     )?;
-    class.define_method("column", method!(RbDataFrame::column, 1))?;
+    class.define_method("get_column", method!(RbDataFrame::get_column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
     class.define_method("take", method!(RbDataFrame::take, 1))?;
     class.define_method(
@@ -244,7 +129,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("is_unique", method!(RbDataFrame::is_unique, 0))?;
     class.define_method("is_duplicated", method!(RbDataFrame::is_duplicated, 0))?;
     class.define_method("equals", method!(RbDataFrame::equals, 2))?;
-    class.define_method("with_row_count", method!(RbDataFrame::with_row_count, 2))?;
+    class.define_method("with_row_index", method!(RbDataFrame::with_row_index, 2))?;
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
@@ -264,6 +149,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("upsample", method!(RbDataFrame::upsample, 5))?;
     class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
     class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
+    class.define_method("clear", method!(RbDataFrame::clear, 0))?;
 
     let class = module.define_class("RbExpr", ruby.class_object())?;
     class.define_method("+", method!(RbExpr::add, 1))?;
@@ -272,15 +158,18 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("/", method!(RbExpr::truediv, 1))?;
     class.define_method("%", method!(RbExpr::_mod, 1))?;
     class.define_method("floordiv", method!(RbExpr::floordiv, 1))?;
+    class.define_method("neg", method!(RbExpr::neg, 0))?;
     class.define_method("to_str", method!(RbExpr::to_str, 0))?;
     class.define_method("eq", method!(RbExpr::eq, 1))?;
+    class.define_method("eq_missing", method!(RbExpr::eq_missing, 1))?;
     class.define_method("neq", method!(RbExpr::neq, 1))?;
+    class.define_method("neq_missing", method!(RbExpr::neq_missing, 1))?;
     class.define_method("gt", method!(RbExpr::gt, 1))?;
     class.define_method("gt_eq", method!(RbExpr::gt_eq, 1))?;
     class.define_method("lt_eq", method!(RbExpr::lt_eq, 1))?;
     class.define_method("lt", method!(RbExpr::lt, 1))?;
     class.define_method("_alias", method!(RbExpr::alias, 1))?;
-    class.define_method("is_not", method!(RbExpr::is_not, 0))?;
+    class.define_method("not_", method!(RbExpr::not_, 0))?;
     class.define_method("is_null", method!(RbExpr::is_null, 0))?;
     class.define_method("is_not_null", method!(RbExpr::is_not_null, 0))?;
     class.define_method("is_infinite", method!(RbExpr::is_infinite, 0))?;
@@ -405,6 +294,7 @@ 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_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))?;
@@ -414,6 +304,18 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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_unique", method!(RbExpr::arr_unique, 1))?;
+    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))?;
+    class.define_method("arr_sort", method!(RbExpr::arr_sort, 2))?;
+    class.define_method("arr_reverse", method!(RbExpr::arr_reverse, 0))?;
+    class.define_method("arr_arg_min", method!(RbExpr::arr_arg_min, 0))?;
+    class.define_method("arr_arg_max", method!(RbExpr::arr_arg_max, 0))?;
+    class.define_method("arr_get", method!(RbExpr::arr_get, 1))?;
+    class.define_method("arr_join", method!(RbExpr::arr_join, 2))?;
+    class.define_method("arr_contains", method!(RbExpr::arr_contains, 1))?;
+    class.define_method("arr_count_matches", method!(RbExpr::arr_count_matches, 1))?;
     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))?;
@@ -422,7 +324,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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_json_extract", method!(RbExpr::str_json_extract, 2))?;
+    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))?;
     class.define_method(
@@ -439,6 +341,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("str_extract", method!(RbExpr::str_extract, 2))?;
     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))?;
@@ -452,6 +355,9 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::str_split_exact_inclusive, 2),
     )?;
     class.define_method("str_splitn", method!(RbExpr::str_splitn, 2))?;
+    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("list_len", method!(RbExpr::list_len, 0))?;
     class.define_method("list_contains", method!(RbExpr::list_contains, 1))?;
     class.define_method("list_count_matches", method!(RbExpr::list_count_matches, 1))?;
@@ -473,21 +379,21 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("millisecond", method!(RbExpr::dt_millisecond, 0))?;
     class.define_method("microsecond", method!(RbExpr::dt_microsecond, 0))?;
     class.define_method("nanosecond", method!(RbExpr::dt_nanosecond, 0))?;
-    class.define_method("duration_days", method!(RbExpr::duration_days, 0))?;
-    class.define_method("duration_hours", method!(RbExpr::duration_hours, 0))?;
-    class.define_method("duration_minutes", method!(RbExpr::duration_minutes, 0))?;
-    class.define_method("duration_seconds", method!(RbExpr::duration_seconds, 0))?;
+    class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 0))?;
+    class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 0))?;
+    class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 0))?;
+    class.define_method("dt_total_seconds", method!(RbExpr::dt_total_seconds, 0))?;
     class.define_method(
-        "duration_nanoseconds",
-        method!(RbExpr::duration_nanoseconds, 0),
+        "dt_total_nanoseconds",
+        method!(RbExpr::dt_total_nanoseconds, 0),
     )?;
     class.define_method(
-        "duration_microseconds",
-        method!(RbExpr::duration_microseconds, 0),
+        "dt_total_microseconds",
+        method!(RbExpr::dt_total_microseconds, 0),
     )?;
     class.define_method(
-        "duration_milliseconds",
-        method!(RbExpr::duration_milliseconds, 0),
+        "dt_total_milliseconds",
+        method!(RbExpr::dt_total_milliseconds, 0),
     )?;
     class.define_method("timestamp", method!(RbExpr::dt_timestamp, 1))?;
     class.define_method("dt_offset_by", method!(RbExpr::dt_offset_by, 1))?;
@@ -505,6 +411,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 2))?;
     class.define_method("dt_month_start", method!(RbExpr::dt_month_start, 0))?;
     class.define_method("dt_month_end", method!(RbExpr::dt_month_end, 0))?;
+    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, 2))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
     class.define_method("map", method!(RbExpr::map, 3))?;
@@ -527,15 +435,25 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_max", method!(RbExpr::list_max, 0))?;
     class.define_method("list_min", method!(RbExpr::list_min, 0))?;
     class.define_method("list_sum", method!(RbExpr::list_sum, 0))?;
-    class.define_method("list_take", method!(RbExpr::list_take, 2))?;
+    class.define_method("list_drop_nulls", method!(RbExpr::list_drop_nulls, 0))?;
+    class.define_method("list_sample_n", method!(RbExpr::list_sample_n, 4))?;
+    class.define_method(
+        "list_sample_fraction",
+        method!(RbExpr::list_sample_fraction, 4),
+    )?;
+    class.define_method("list_gather", method!(RbExpr::list_gather, 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_tail", method!(RbExpr::list_tail, 1))?;
     class.define_method("list_sort", method!(RbExpr::list_sort, 1))?;
     class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
     class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
     class.define_method("list_get", method!(RbExpr::list_get, 1))?;
-    class.define_method("list_join", method!(RbExpr::list_join, 1))?;
+    class.define_method("list_join", method!(RbExpr::list_join, 2))?;
     class.define_method("list_arg_min", method!(RbExpr::list_arg_min, 0))?;
     class.define_method("list_arg_max", method!(RbExpr::list_arg_max, 0))?;
+    class.define_method("list_all", method!(RbExpr::list_all, 0))?;
+    class.define_method("list_any", method!(RbExpr::list_any, 0))?;
     class.define_method("list_diff", method!(RbExpr::list_diff, 2))?;
     class.define_method("list_shift", method!(RbExpr::list_shift, 1))?;
     class.define_method("list_slice", method!(RbExpr::list_slice, 2))?;
@@ -574,11 +492,13 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "struct_rename_fields",
         method!(RbExpr::struct_rename_fields, 1),
     )?;
+    class.define_method("struct_json_encode", method!(RbExpr::struct_json_encode, 0))?;
     class.define_method("log", method!(RbExpr::log, 1))?;
     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, 4))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 0))?;
@@ -590,10 +510,16 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "meta_has_multiple_outputs",
         method!(RbExpr::meta_has_multiple_outputs, 0),
     )?;
+    class.define_method("meta_is_column", method!(RbExpr::meta_is_column, 0))?;
     class.define_method(
         "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_tree_format", method!(RbExpr::meta_tree_format, 0))?;
 
     // name
     class.define_method("name_keep", method!(RbExpr::name_keep, 0))?;
@@ -604,44 +530,154 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("name_to_uppercase", method!(RbExpr::name_to_uppercase, 0))?;
 
     // maybe add to different class
-    class.define_singleton_method("col", function!(crate::functions::lazy::col, 1))?;
-    class.define_singleton_method("count", function!(crate::functions::lazy::count, 0))?;
-    class.define_singleton_method("first", function!(crate::functions::lazy::first, 0))?;
-    class.define_singleton_method("last", function!(crate::functions::lazy::last, 0))?;
-    class.define_singleton_method("cols", function!(crate::functions::lazy::cols, 1))?;
-    class.define_singleton_method("fold", function!(crate::functions::lazy::fold, 3))?;
-    class.define_singleton_method("cumfold", function!(crate::functions::lazy::cumfold, 4))?;
-    class.define_singleton_method("lit", function!(crate::functions::lazy::lit, 2))?;
+    let class = module.define_module("Plr")?;
+    class.define_singleton_method("dtype_cols", function!(functions::lazy::dtype_cols2, 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, 3))?;
+    class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 4))?;
+    class.define_singleton_method("lit", function!(functions::lazy::lit, 2))?;
+    class.define_singleton_method("int_range", function!(functions::range::int_range, 4))?;
+    class.define_singleton_method("int_ranges", function!(functions::range::int_ranges, 4))?;
+    class.define_singleton_method("repeat", function!(functions::lazy::repeat, 3))?;
+    class.define_singleton_method("pearson_corr", function!(functions::lazy::pearson_corr, 3))?;
     class.define_singleton_method(
-        "int_range",
-        function!(crate::functions::range::int_range, 4),
+        "spearman_rank_corr",
+        function!(functions::lazy::spearman_rank_corr, 4),
+    )?;
+    class.define_singleton_method("sql_expr", function!(functions::lazy::sql_expr, 1))?;
+    class.define_singleton_method("cov", function!(functions::lazy::cov, 3))?;
+    class.define_singleton_method("arctan2", function!(functions::lazy::arctan2, 2))?;
+    class.define_singleton_method("arctan2d", function!(functions::lazy::arctan2d, 2))?;
+    class.define_singleton_method("rolling_corr", function!(functions::lazy::rolling_corr, 5))?;
+    class.define_singleton_method("rolling_cov", function!(functions::lazy::rolling_cov, 5))?;
+    class.define_singleton_method("arg_sort_by", function!(functions::lazy::arg_sort_by, 2))?;
+    class.define_singleton_method("when", function!(functions::whenthen::when, 1))?;
+    class.define_singleton_method("concat_str", function!(functions::lazy::concat_str, 3))?;
+    class.define_singleton_method("concat_list", function!(functions::lazy::concat_list, 1))?;
+    class.define_singleton_method(
+        "all_horizontal",
+        function!(functions::aggregation::all_horizontal, 1),
     )?;
     class.define_singleton_method(
-        "int_ranges",
-        function!(crate::functions::range::int_ranges, 4),
+        "any_horizontal",
+        function!(functions::aggregation::any_horizontal, 1),
     )?;
-    class.define_singleton_method("repeat", function!(crate::functions::lazy::repeat, 3))?;
     class.define_singleton_method(
-        "pearson_corr",
-        function!(crate::functions::lazy::pearson_corr, 3),
+        "max_horizontal",
+        function!(functions::aggregation::max_horizontal, 1),
     )?;
     class.define_singleton_method(
-        "spearman_rank_corr",
-        function!(crate::functions::lazy::spearman_rank_corr, 4),
+        "min_horizontal",
+        function!(functions::aggregation::min_horizontal, 1),
+    )?;
+    class.define_singleton_method(
+        "sum_horizontal",
+        function!(functions::aggregation::sum_horizontal, 1),
     )?;
-    class.define_singleton_method("cov", function!(crate::functions::lazy::cov, 3))?;
     class.define_singleton_method(
-        "arg_sort_by",
-        function!(crate::functions::lazy::arg_sort_by, 2),
+        "mean_horizontal",
+        function!(functions::aggregation::mean_horizontal, 1),
     )?;
-    class.define_singleton_method("when", function!(crate::functions::whenthen::when, 1))?;
+    class.define_singleton_method("as_struct", function!(functions::lazy::as_struct, 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(
-        "concat_str",
-        function!(crate::functions::lazy::concat_str, 2),
+        "concat_lf_diagonal",
+        function!(functions::lazy::concat_lf_diagonal, 4),
     )?;
+    class.define_singleton_method("concat_df", function!(functions::eager::concat_df, 1))?;
+    class.define_singleton_method("concat_lf", function!(functions::lazy::concat_lf, 4))?;
     class.define_singleton_method(
-        "concat_lst",
-        function!(crate::functions::lazy::concat_lst, 1),
+        "concat_df_diagonal",
+        function!(functions::eager::concat_df_diagonal, 1),
+    )?;
+    class.define_singleton_method(
+        "concat_df_horizontal",
+        function!(functions::eager::concat_df_horizontal, 1),
+    )?;
+    class.define_singleton_method(
+        "concat_series",
+        function!(functions::eager::concat_series, 1),
+    )?;
+    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(
+        "parquet_schema",
+        function!(functions::io::read_parquet_schema, 1),
+    )?;
+    class.define_singleton_method("collect_all", function!(functions::lazy::collect_all, 1))?;
+    class.define_singleton_method("date_range", function!(functions::range::date_range, 6))?;
+    class.define_singleton_method(
+        "dtype_str_repr",
+        function!(functions::misc::dtype_str_repr, 1),
+    )?;
+    class.define_singleton_method(
+        "get_index_type",
+        function!(functions::meta::get_index_type, 0),
+    )?;
+    class.define_singleton_method(
+        "threadpool_size",
+        function!(functions::meta::threadpool_size, 0),
+    )?;
+    class.define_singleton_method(
+        "enable_string_cache",
+        function!(functions::string_cache::enable_string_cache, 0),
+    )?;
+    class.define_singleton_method(
+        "disable_string_cache",
+        function!(functions::string_cache::disable_string_cache, 0),
+    )?;
+    class.define_singleton_method(
+        "using_string_cache",
+        function!(functions::string_cache::using_string_cache, 0),
+    )?;
+    class.define_singleton_method(
+        "set_float_fmt",
+        function!(functions::meta::set_float_fmt, 1),
+    )?;
+    class.define_singleton_method(
+        "get_float_fmt",
+        function!(functions::meta::get_float_fmt, 0),
+    )?;
+    class.define_singleton_method(
+        "set_float_precision",
+        function!(functions::meta::set_float_precision, 1),
+    )?;
+    class.define_singleton_method(
+        "get_float_precision",
+        function!(functions::meta::get_float_precision, 0),
+    )?;
+    class.define_singleton_method(
+        "set_thousands_separator",
+        function!(functions::meta::set_thousands_separator, 1),
+    )?;
+    class.define_singleton_method(
+        "get_thousands_separator",
+        function!(functions::meta::get_thousands_separator, 0),
+    )?;
+    class.define_singleton_method(
+        "set_decimal_separator",
+        function!(functions::meta::set_decimal_separator, 1),
+    )?;
+    class.define_singleton_method(
+        "get_decimal_separator",
+        function!(functions::meta::get_decimal_separator, 0),
+    )?;
+    class.define_singleton_method(
+        "set_trim_decimal_zeros",
+        function!(functions::meta::set_trim_decimal_zeros, 1),
+    )?;
+    class.define_singleton_method(
+        "get_trim_decimal_zeros",
+        function!(functions::meta::get_trim_decimal_zeros, 0),
+    )?;
+    class.define_singleton_method(
+        "set_random_seed",
+        function!(functions::random::set_random_seed, 1),
     )?;
 
     let class = module.define_class("RbLazyFrame", ruby.class_object())?;
@@ -664,29 +700,35 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method(
         "optimization_toggle",
-        method!(RbLazyFrame::optimization_toggle, 8),
+        method!(RbLazyFrame::optimization_toggle, 9),
     )?;
     class.define_method("sort", method!(RbLazyFrame::sort, 4))?;
     class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 4))?;
     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, 7))?;
+    class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 3))?;
+    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, 14))?;
+    class.define_method("sink_json", method!(RbLazyFrame::sink_json, 2))?;
     class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 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))?;
-    class.define_method(
-        "group_by_rolling",
-        method!(RbLazyFrame::group_by_rolling, 6),
-    )?;
+    class.define_method("rolling", method!(RbLazyFrame::rolling, 6))?;
     class.define_method(
         "group_by_dynamic",
         method!(RbLazyFrame::group_by_dynamic, 10),
     )?;
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 11))?;
-    class.define_method("join", method!(RbLazyFrame::join, 7))?;
+    class.define_method("join", method!(RbLazyFrame::join, 8))?;
+    class.define_method("with_column", method!(RbLazyFrame::with_column, 1))?;
     class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
+    class.define_method(
+        "with_columns_seq",
+        method!(RbLazyFrame::with_columns_seq, 1),
+    )?;
     class.define_method("rename", method!(RbLazyFrame::rename, 2))?;
     class.define_method("reverse", method!(RbLazyFrame::reverse, 0))?;
     class.define_method("shift", method!(RbLazyFrame::shift, 2))?;
@@ -700,19 +742,23 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("median", method!(RbLazyFrame::median, 0))?;
     class.define_method("quantile", method!(RbLazyFrame::quantile, 2))?;
     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_nulls", method!(RbLazyFrame::drop_nulls, 1))?;
     class.define_method("slice", method!(RbLazyFrame::slice, 2))?;
     class.define_method("tail", method!(RbLazyFrame::tail, 1))?;
     class.define_method("melt", method!(RbLazyFrame::melt, 5))?;
-    class.define_method("with_row_count", method!(RbLazyFrame::with_row_count, 2))?;
-    class.define_method("drop_columns", method!(RbLazyFrame::drop_columns, 1))?;
+    class.define_method("with_row_index", method!(RbLazyFrame::with_row_index, 2))?;
+    class.define_method("drop", method!(RbLazyFrame::drop, 1))?;
+    class.define_method("cast_all", method!(RbLazyFrame::cast_all, 2))?;
     class.define_method("_clone", method!(RbLazyFrame::clone, 0))?;
     class.define_method("columns", method!(RbLazyFrame::columns, 0))?;
     class.define_method("dtypes", method!(RbLazyFrame::dtypes, 0))?;
     class.define_method("schema", method!(RbLazyFrame::schema, 0))?;
     class.define_method("unnest", method!(RbLazyFrame::unnest, 1))?;
     class.define_method("width", method!(RbLazyFrame::width, 0))?;
+    class.define_method("count", method!(RbLazyFrame::count, 0))?;
+    class.define_method("merge_sorted", method!(RbLazyFrame::merge_sorted, 2))?;
 
     let class = module.define_class("RbLazyGroupBy", ruby.class_object())?;
     class.define_method("agg", method!(RbLazyGroupBy::agg, 1))?;
@@ -756,6 +802,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "can_fast_explode_flag",
         method!(RbSeries::can_fast_explode_flag, 0),
     )?;
+    class.define_method(
+        "cat_uses_lexical_ordering",
+        method!(RbSeries::cat_uses_lexical_ordering, 0),
+    )?;
+    class.define_method("cat_is_local", method!(RbSeries::cat_is_local, 0))?;
+    class.define_method("cat_to_local", method!(RbSeries::cat_to_local, 0))?;
     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))?;
@@ -783,8 +835,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("mul", method!(RbSeries::mul, 1))?;
     class.define_method("div", method!(RbSeries::div, 1))?;
     class.define_method("rem", method!(RbSeries::rem, 1))?;
-    class.define_method("sort", method!(RbSeries::sort, 1))?;
+    class.define_method("sort", method!(RbSeries::sort, 2))?;
     class.define_method("value_counts", method!(RbSeries::value_counts, 1))?;
+    class.define_method("any", method!(RbSeries::any, 1))?;
+    class.define_method("all", method!(RbSeries::all, 1))?;
     class.define_method("arg_min", method!(RbSeries::arg_min, 0))?;
     class.define_method("arg_max", method!(RbSeries::arg_max, 0))?;
     class.define_method("take_with_series", method!(RbSeries::take_with_series, 1))?;
@@ -992,5 +1046,9 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("register", method!(RbSQLContext::register, 2))?;
     class.define_method("unregister", method!(RbSQLContext::unregister, 1))?;
 
+    // string cache
+    let class = module.define_class("RbStringCacheHolder", ruby.class_object())?;
+    class.define_singleton_method("hold", function!(RbStringCacheHolder::hold, 0))?;
+
     Ok(())
 }

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

@@ -4,6 +4,26 @@ use crate::{RbResult, RbSeries, RbValueError};
 use magnus::{IntoValue, Value};
 
 impl RbSeries {
+    pub fn any(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
+        let binding = self.series.borrow();
+        let s = binding.bool().map_err(RbPolarsErr::from)?;
+        Ok(if ignore_nulls {
+            Some(s.any())
+        } else {
+            s.any_kleene()
+        })
+    }
+
+    pub fn all(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
+        let binding = self.series.borrow();
+        let s = binding.bool().map_err(RbPolarsErr::from)?;
+        Ok(if ignore_nulls {
+            Some(s.all())
+        } else {
+            s.all_kleene()
+        })
+    }
+
     pub fn arg_max(&self) -> Option<usize> {
         self.series.borrow().arg_max()
     }