polars-df 0.6.0 → 0.8.0

data/ext/polars/src/lib.rs

@@ -1,4 +1,3 @@
-mod apply;
 mod batched_csv;
 mod conversion;
 mod dataframe;
@@ -8,10 +7,13 @@ mod file;
 mod functions;
 mod lazyframe;
 mod lazygroupby;
+mod map;
+mod on_startup;
 mod object;
 mod prelude;
 pub(crate) mod rb_modules;
 mod series;
+mod sql;
 mod utils;
 
 use batched_csv::RbBatchedCsv;
@@ -20,11 +22,12 @@ use dataframe::RbDataFrame;
 use error::{RbPolarsErr, RbTypeError, RbValueError};
 use expr::rb_exprs_to_exprs;
 use expr::RbExpr;
-use functions::whenthen::{RbWhen, RbWhenThen};
+use functions::whenthen::{RbThen, RbWhen};
 use lazyframe::RbLazyFrame;
 use lazygroupby::RbLazyGroupBy;
-use magnus::{define_module, function, method, prelude::*, Error};
+use magnus::{define_module, function, method, prelude::*, Error, Ruby};
 use series::RbSeries;
+use sql::RbSQLContext;
 
 #[cfg(target_os = "linux")]
 use jemallocator::Jemalloc;
@@ -43,15 +46,19 @@ static GLOBAL: MiMalloc = MiMalloc;
 type RbResult<T> = Result<T, Error>;
 
 #[magnus::init]
-fn init() -> RbResult<()> {
+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, 8),
+        function!(crate::functions::lazy::duration, 9),
     )?;
     module.define_singleton_method(
         "_concat_df",
@@ -62,12 +69,12 @@ fn init() -> RbResult<()> {
         function!(crate::functions::lazy::concat_lf, 4),
     )?;
     module.define_singleton_method(
-        "_diag_concat_df",
-        function!(crate::functions::eager::diag_concat_df, 1),
+        "_concat_df_diagonal",
+        function!(crate::functions::eager::concat_df_diagonal, 1),
     )?;
     module.define_singleton_method(
-        "_hor_concat_df",
-        function!(crate::functions::eager::hor_concat_df, 1),
+        "_concat_df_horizontal",
+        function!(crate::functions::eager::concat_df_horizontal, 1),
     )?;
     module.define_singleton_method(
         "_concat_series",
@@ -87,15 +94,35 @@ fn init() -> RbResult<()> {
     )?;
     module.define_singleton_method(
         "_rb_date_range",
-        function!(crate::functions::eager::date_range, 7),
+        function!(crate::functions::range::date_range, 6),
     )?;
     module.define_singleton_method(
         "_coalesce_exprs",
         function!(crate::functions::lazy::coalesce, 1),
     )?;
     module.define_singleton_method(
-        "_sum_exprs",
-        function!(crate::functions::lazy::sum_exprs, 1),
+        "_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",
@@ -109,17 +136,46 @@ fn init() -> RbResult<()> {
         "_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", Default::default())?;
+    let class = module.define_class("RbBatchedCsv", ruby.class_object())?;
     class.define_singleton_method("new", function!(RbBatchedCsv::new, -1))?;
     class.define_method("next_batches", method!(RbBatchedCsv::next_batches, 1))?;
 
-    let class = module.define_class("RbDataFrame", Default::default())?;
+    let class = module.define_class("RbDataFrame", ruby.class_object())?;
     class.define_singleton_method("new", function!(RbDataFrame::init, 1))?;
     class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
     class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 9))?;
     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_hash", function!(RbDataFrame::read_hash, 1))?;
     class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 1))?;
@@ -169,8 +225,8 @@ fn init() -> RbResult<()> {
     class.define_method("drop", method!(RbDataFrame::drop, 1))?;
     class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
     class.define_method(
-        "find_idx_by_name",
-        method!(RbDataFrame::find_idx_by_name, 1),
+        "get_column_index",
+        method!(RbDataFrame::get_column_index, 1),
     )?;
     class.define_method("column", method!(RbDataFrame::column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
@@ -180,14 +236,14 @@ fn init() -> RbResult<()> {
         method!(RbDataFrame::take_with_series, 1),
     )?;
     class.define_method("replace", method!(RbDataFrame::replace, 2))?;
-    class.define_method("replace_at_idx", method!(RbDataFrame::replace_at_idx, 2))?;
-    class.define_method("insert_at_idx", method!(RbDataFrame::insert_at_idx, 2))?;
+    class.define_method("replace_column", method!(RbDataFrame::replace_column, 2))?;
+    class.define_method("insert_column", method!(RbDataFrame::insert_column, 2))?;
     class.define_method("slice", method!(RbDataFrame::slice, 2))?;
     class.define_method("head", method!(RbDataFrame::head, 1))?;
     class.define_method("tail", method!(RbDataFrame::tail, 1))?;
     class.define_method("is_unique", method!(RbDataFrame::is_unique, 0))?;
     class.define_method("is_duplicated", method!(RbDataFrame::is_duplicated, 0))?;
-    class.define_method("frame_equal", method!(RbDataFrame::frame_equal, 2))?;
+    class.define_method("equals", method!(RbDataFrame::equals, 2))?;
     class.define_method("with_row_count", method!(RbDataFrame::with_row_count, 2))?;
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
@@ -195,18 +251,10 @@ fn init() -> RbResult<()> {
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
     class.define_method("shift", method!(RbDataFrame::shift, 1))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
-    class.define_method("max", method!(RbDataFrame::max, 0))?;
-    class.define_method("min", method!(RbDataFrame::min, 0))?;
-    class.define_method("sum", method!(RbDataFrame::sum, 0))?;
-    class.define_method("mean", method!(RbDataFrame::mean, 0))?;
-    class.define_method("std", method!(RbDataFrame::std, 1))?;
-    class.define_method("var", method!(RbDataFrame::var, 1))?;
-    class.define_method("median", method!(RbDataFrame::median, 0))?;
-    class.define_method("hmean", method!(RbDataFrame::hmean, 1))?;
-    class.define_method("hmax", method!(RbDataFrame::hmax, 0))?;
-    class.define_method("hmin", method!(RbDataFrame::hmin, 0))?;
-    class.define_method("hsum", method!(RbDataFrame::hsum, 1))?;
-    class.define_method("quantile", method!(RbDataFrame::quantile, 2))?;
+    class.define_method("mean_horizontal", method!(RbDataFrame::mean_horizontal, 1))?;
+    class.define_method("max_horizontal", method!(RbDataFrame::max_horizontal, 0))?;
+    class.define_method("min_horizontal", method!(RbDataFrame::min_horizontal, 0))?;
+    class.define_method("sum_horizontal", method!(RbDataFrame::sum_horizontal, 1))?;
     class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
     class.define_method("apply", method!(RbDataFrame::apply, 3))?;
@@ -217,7 +265,7 @@ fn init() -> RbResult<()> {
     class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
     class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
 
-    let class = module.define_class("RbExpr", Default::default())?;
+    let class = module.define_class("RbExpr", ruby.class_object())?;
     class.define_method("+", method!(RbExpr::add, 1))?;
     class.define_method("-", method!(RbExpr::sub, 1))?;
     class.define_method("*", method!(RbExpr::mul, 1))?;
@@ -254,8 +302,14 @@ fn init() -> RbResult<()> {
     class.define_method("last", method!(RbExpr::last, 0))?;
     class.define_method("implode", method!(RbExpr::implode, 0))?;
     class.define_method("quantile", method!(RbExpr::quantile, 2))?;
+    class.define_method("cut", method!(RbExpr::cut, 4))?;
+    class.define_method("qcut", method!(RbExpr::qcut, 5))?;
+    class.define_method("qcut_uniform", method!(RbExpr::qcut_uniform, 5))?;
+    class.define_method("rle", method!(RbExpr::rle, 0))?;
+    class.define_method("rle_id", method!(RbExpr::rle_id, 0))?;
     class.define_method("agg_groups", method!(RbExpr::agg_groups, 0))?;
     class.define_method("count", method!(RbExpr::count, 0))?;
+    class.define_method("len", method!(RbExpr::len, 0))?;
     class.define_method("value_counts", method!(RbExpr::value_counts, 2))?;
     class.define_method("unique_counts", method!(RbExpr::unique_counts, 0))?;
     class.define_method("null_count", method!(RbExpr::null_count, 0))?;
@@ -264,15 +318,16 @@ fn init() -> RbResult<()> {
     class.define_method("arg_sort", method!(RbExpr::arg_sort, 2))?;
     class.define_method("top_k", method!(RbExpr::top_k, 1))?;
     class.define_method("bottom_k", method!(RbExpr::bottom_k, 1))?;
+    class.define_method("peak_min", method!(RbExpr::peak_min, 0))?;
+    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("search_sorted", method!(RbExpr::search_sorted, 2))?;
-    class.define_method("take", method!(RbExpr::take, 1))?;
+    class.define_method("gather", method!(RbExpr::gather, 1))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 2))?;
     class.define_method("backward_fill", method!(RbExpr::backward_fill, 1))?;
     class.define_method("forward_fill", method!(RbExpr::forward_fill, 1))?;
-    class.define_method("shift", method!(RbExpr::shift, 1))?;
-    class.define_method("shift_and_fill", method!(RbExpr::shift_and_fill, 2))?;
+    class.define_method("shift", method!(RbExpr::shift, 2))?;
     class.define_method("fill_null", method!(RbExpr::fill_null, 1))?;
     class.define_method(
         "fill_null_with_strategy",
@@ -286,10 +341,11 @@ fn init() -> RbResult<()> {
     class.define_method("std", method!(RbExpr::std, 1))?;
     class.define_method("var", method!(RbExpr::var, 1))?;
     class.define_method("is_unique", method!(RbExpr::is_unique, 0))?;
-    class.define_method("approx_unique", method!(RbExpr::approx_unique, 0))?;
-    class.define_method("is_first", method!(RbExpr::is_first, 0))?;
+    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))?;
     class.define_method("explode", method!(RbExpr::explode, 0))?;
-    class.define_method("take_every", method!(RbExpr::take_every, 1))?;
+    class.define_method("gather_every", method!(RbExpr::gather_every, 2))?;
     class.define_method("tail", method!(RbExpr::tail, 1))?;
     class.define_method("head", method!(RbExpr::head, 1))?;
     class.define_method("slice", method!(RbExpr::slice, 2))?;
@@ -299,8 +355,6 @@ fn init() -> RbResult<()> {
     class.define_method("floor", method!(RbExpr::floor, 0))?;
     class.define_method("ceil", method!(RbExpr::ceil, 0))?;
     class.define_method("clip", method!(RbExpr::clip, 2))?;
-    class.define_method("clip_min", method!(RbExpr::clip_min, 1))?;
-    class.define_method("clip_max", method!(RbExpr::clip_max, 1))?;
     class.define_method("abs", method!(RbExpr::abs, 0))?;
     class.define_method("sin", method!(RbExpr::sin, 0))?;
     class.define_method("cos", method!(RbExpr::cos, 0))?;
@@ -323,29 +377,37 @@ fn init() -> RbResult<()> {
     class.define_method("is_in", method!(RbExpr::is_in, 1))?;
     class.define_method("repeat_by", method!(RbExpr::repeat_by, 1))?;
     class.define_method("pow", method!(RbExpr::pow, 1))?;
-    class.define_method("cumsum", method!(RbExpr::cumsum, 1))?;
-    class.define_method("cummax", method!(RbExpr::cummax, 1))?;
-    class.define_method("cummin", method!(RbExpr::cummin, 1))?;
-    class.define_method("cumprod", method!(RbExpr::cumprod, 1))?;
+    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))?;
+    class.define_method("cum_prod", method!(RbExpr::cum_prod, 1))?;
     class.define_method("product", method!(RbExpr::product, 0))?;
     class.define_method("shrink_dtype", method!(RbExpr::shrink_dtype, 0))?;
     class.define_method("str_to_date", method!(RbExpr::str_to_date, 4))?;
-    class.define_method("str_to_datetime", method!(RbExpr::str_to_datetime, 6))?;
+    class.define_method("str_to_datetime", method!(RbExpr::str_to_datetime, 7))?;
     class.define_method("str_to_time", method!(RbExpr::str_to_time, 3))?;
-    class.define_method("str_strip", method!(RbExpr::str_strip, 1))?;
-    class.define_method("str_rstrip", method!(RbExpr::str_rstrip, 1))?;
-    class.define_method("str_lstrip", method!(RbExpr::str_lstrip, 1))?;
+    class.define_method("str_strip_chars", method!(RbExpr::str_strip_chars, 1))?;
+    class.define_method(
+        "str_strip_chars_start",
+        method!(RbExpr::str_strip_chars_start, 1),
+    )?;
+    class.define_method(
+        "str_strip_chars_end",
+        method!(RbExpr::str_strip_chars_end, 1),
+    )?;
+    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_explode", method!(RbExpr::str_explode, 0))?;
     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_lengths", method!(RbExpr::str_lengths, 0))?;
-    class.define_method("str_n_chars", method!(RbExpr::str_n_chars, 0))?;
+    class.define_method("str_len_bytes", method!(RbExpr::str_len_bytes, 0))?;
+    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_zfill", method!(RbExpr::str_zfill, 1))?;
-    class.define_method("str_ljust", method!(RbExpr::str_ljust, 2))?;
-    class.define_method("str_rjust", method!(RbExpr::str_rjust, 2))?;
+    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_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
@@ -359,7 +421,7 @@ fn init() -> 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_parse_int", method!(RbExpr::str_parse_int, 2))?;
+    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("binary_hex_encode", method!(RbExpr::bin_hex_encode, 0))?;
     class.define_method("binary_hex_decode", method!(RbExpr::bin_hex_decode, 1))?;
@@ -377,7 +439,7 @@ fn init() -> 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("count_match", method!(RbExpr::str_count_match, 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(
@@ -390,9 +452,9 @@ fn init() -> RbResult<()> {
         method!(RbExpr::str_split_exact_inclusive, 2),
     )?;
     class.define_method("str_splitn", method!(RbExpr::str_splitn, 2))?;
-    class.define_method("list_lengths", method!(RbExpr::list_lengths, 0))?;
+    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_match", method!(RbExpr::list_count_match, 1))?;
+    class.define_method("list_count_matches", method!(RbExpr::list_count_matches, 1))?;
     class.define_method("year", method!(RbExpr::dt_year, 0))?;
     class.define_method("dt_is_leap_year", method!(RbExpr::dt_is_leap_year, 0))?;
     class.define_method("iso_year", method!(RbExpr::dt_iso_year, 0))?;
@@ -440,7 +502,6 @@ fn init() -> RbResult<()> {
         "dt_replace_time_zone",
         method!(RbExpr::dt_replace_time_zone, 2),
     )?;
-    class.define_method("dt_tz_localize", method!(RbExpr::dt_tz_localize, 1))?;
     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))?;
@@ -450,20 +511,16 @@ fn init() -> RbResult<()> {
     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("keep_name", method!(RbExpr::keep_name, 0))?;
-    class.define_method("prefix", method!(RbExpr::prefix, 1))?;
-    class.define_method("suffix", method!(RbExpr::suffix, 1))?;
-    class.define_method("map_alias", method!(RbExpr::map_alias, 1))?;
     class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
     class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 6))?;
     class.define_method("rolling_min", method!(RbExpr::rolling_min, 6))?;
     class.define_method("rolling_max", method!(RbExpr::rolling_max, 6))?;
     class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 6))?;
-    class.define_method("rolling_std", method!(RbExpr::rolling_std, 7))?;
-    class.define_method("rolling_var", method!(RbExpr::rolling_var, 7))?;
-    class.define_method("rolling_median", method!(RbExpr::rolling_median, 6))?;
-    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 8))?;
+    class.define_method("rolling_std", method!(RbExpr::rolling_std, 8))?;
+    class.define_method("rolling_var", method!(RbExpr::rolling_var, 8))?;
+    class.define_method("rolling_median", method!(RbExpr::rolling_median, 7))?;
+    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 9))?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
@@ -490,20 +547,21 @@ fn init() -> RbResult<()> {
     class.define_method("pct_change", method!(RbExpr::pct_change, 1))?;
     class.define_method("skew", method!(RbExpr::skew, 1))?;
     class.define_method("kurtosis", method!(RbExpr::kurtosis, 2))?;
-    class.define_method("str_concat", method!(RbExpr::str_concat, 1))?;
+    class.define_method("str_concat", method!(RbExpr::str_concat, 2))?;
     class.define_method("cat_set_ordering", method!(RbExpr::cat_set_ordering, 1))?;
+    class.define_method("cat_get_categories", method!(RbExpr::cat_get_categories, 0))?;
     class.define_method("reshape", method!(RbExpr::reshape, 1))?;
-    class.define_method("cumcount", method!(RbExpr::cumcount, 1))?;
+    class.define_method("cum_count", method!(RbExpr::cum_count, 1))?;
     class.define_method("to_physical", method!(RbExpr::to_physical, 0))?;
-    class.define_method("shuffle", method!(RbExpr::shuffle, 2))?;
-    class.define_method("sample_n", method!(RbExpr::sample_n, 5))?;
-    class.define_method("sample_frac", method!(RbExpr::sample_frac, 5))?;
+    class.define_method("shuffle", method!(RbExpr::shuffle, 1))?;
+    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_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))?;
-    class.define_method("any", method!(RbExpr::any, 0))?;
-    class.define_method("all", method!(RbExpr::all, 0))?;
+    class.define_method("any", method!(RbExpr::any, 1))?;
+    class.define_method("all", method!(RbExpr::all, 1))?;
     class.define_method(
         "struct_field_by_name",
         method!(RbExpr::struct_field_by_name, 1),
@@ -537,6 +595,14 @@ fn init() -> RbResult<()> {
         method!(RbExpr::meta_is_regex_projection, 0),
     )?;
 
+    // name
+    class.define_method("name_keep", method!(RbExpr::name_keep, 0))?;
+    class.define_method("name_map", method!(RbExpr::name_map, 1))?;
+    class.define_method("name_prefix", method!(RbExpr::name_prefix, 1))?;
+    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))?;
+
     // 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))?;
@@ -546,7 +612,14 @@ fn init() -> RbResult<()> {
     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))?;
-    class.define_singleton_method("arange", function!(crate::functions::lazy::arange, 3))?;
+    class.define_singleton_method(
+        "int_range",
+        function!(crate::functions::range::int_range, 4),
+    )?;
+    class.define_singleton_method(
+        "int_ranges",
+        function!(crate::functions::range::int_ranges, 4),
+    )?;
     class.define_singleton_method("repeat", function!(crate::functions::lazy::repeat, 3))?;
     class.define_singleton_method(
         "pearson_corr",
@@ -556,7 +629,7 @@ fn init() -> RbResult<()> {
         "spearman_rank_corr",
         function!(crate::functions::lazy::spearman_rank_corr, 4),
     )?;
-    class.define_singleton_method("cov", function!(crate::functions::lazy::cov, 2))?;
+    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),
@@ -571,7 +644,7 @@ fn init() -> RbResult<()> {
         function!(crate::functions::lazy::concat_lst, 1),
     )?;
 
-    let class = module.define_class("RbLazyFrame", Default::default())?;
+    let class = module.define_class("RbLazyFrame", ruby.class_object())?;
     class.define_singleton_method("read_json", function!(RbLazyFrame::read_json, 1))?;
     class.define_singleton_method(
         "new_from_ndjson",
@@ -580,7 +653,7 @@ fn init() -> 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, 8),
+        function!(RbLazyFrame::new_from_parquet, 9),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -591,7 +664,7 @@ fn init() -> RbResult<()> {
     )?;
     class.define_method(
         "optimization_toggle",
-        method!(RbLazyFrame::optimization_toggle, 7),
+        method!(RbLazyFrame::optimization_toggle, 8),
     )?;
     class.define_method("sort", method!(RbLazyFrame::sort, 4))?;
     class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 4))?;
@@ -601,17 +674,22 @@ fn init() -> RbResult<()> {
     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("groupby", method!(RbLazyFrame::groupby, 2))?;
-    class.define_method("groupby_rolling", method!(RbLazyFrame::groupby_rolling, 6))?;
-    class.define_method("groupby_dynamic", method!(RbLazyFrame::groupby_dynamic, 9))?;
+    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(
+        "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("with_columns", method!(RbLazyFrame::with_columns, 1))?;
     class.define_method("rename", method!(RbLazyFrame::rename, 2))?;
     class.define_method("reverse", method!(RbLazyFrame::reverse, 0))?;
-    class.define_method("shift", method!(RbLazyFrame::shift, 1))?;
-    class.define_method("shift_and_fill", method!(RbLazyFrame::shift_and_fill, 2))?;
+    class.define_method("shift", method!(RbLazyFrame::shift, 2))?;
     class.define_method("fill_nan", method!(RbLazyFrame::fill_nan, 1))?;
     class.define_method("min", method!(RbLazyFrame::min, 0))?;
     class.define_method("max", method!(RbLazyFrame::max, 0))?;
@@ -636,12 +714,12 @@ fn init() -> RbResult<()> {
     class.define_method("unnest", method!(RbLazyFrame::unnest, 1))?;
     class.define_method("width", method!(RbLazyFrame::width, 0))?;
 
-    let class = module.define_class("RbLazyGroupBy", Default::default())?;
+    let class = module.define_class("RbLazyGroupBy", ruby.class_object())?;
     class.define_method("agg", method!(RbLazyGroupBy::agg, 1))?;
     class.define_method("head", method!(RbLazyGroupBy::head, 1))?;
     class.define_method("tail", method!(RbLazyGroupBy::tail, 1))?;
 
-    let class = module.define_class("RbSeries", Default::default())?;
+    let class = module.define_class("RbSeries", ruby.class_object())?;
     class.define_singleton_method("new_opt_bool", function!(RbSeries::new_opt_bool, 3))?;
     class.define_singleton_method("new_opt_u8", function!(RbSeries::new_opt_u8, 3))?;
     class.define_singleton_method("new_opt_u16", function!(RbSeries::new_opt_u16, 3))?;
@@ -714,7 +792,7 @@ fn init() -> RbResult<()> {
     class.define_method("has_validity", method!(RbSeries::has_validity, 0))?;
     class.define_method("sample_n", method!(RbSeries::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbSeries::sample_frac, 4))?;
-    class.define_method("series_equal", method!(RbSeries::series_equal, 3))?;
+    class.define_method("equals", method!(RbSeries::equals, 3))?;
     class.define_method("eq", method!(RbSeries::eq, 1))?;
     class.define_method("neq", method!(RbSeries::neq, 1))?;
     class.define_method("gt", method!(RbSeries::gt, 1))?;
@@ -731,8 +809,6 @@ fn init() -> RbResult<()> {
     class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
     class.define_method("to_dummies", method!(RbSeries::to_dummies, 2))?;
-    class.define_method("peak_max", method!(RbSeries::peak_max, 0))?;
-    class.define_method("peak_min", method!(RbSeries::peak_min, 0))?;
     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))?;
@@ -741,7 +817,7 @@ fn init() -> RbResult<()> {
     class.define_method("kurtosis", method!(RbSeries::kurtosis, 2))?;
     class.define_method("cast", method!(RbSeries::cast, 2))?;
     class.define_method("time_unit", method!(RbSeries::time_unit, 0))?;
-    class.define_method("set_at_idx", method!(RbSeries::set_at_idx, 2))?;
+    class.define_method("scatter", method!(RbSeries::scatter, 2))?;
 
     // set
     // class.define_method("set_with_mask_str", method!(RbSeries::set_with_mask_str, 2))?;
@@ -902,11 +978,19 @@ fn init() -> RbResult<()> {
     // extra
     class.define_method("extend_constant", method!(RbSeries::extend_constant, 2))?;
 
-    let class = module.define_class("RbWhen", Default::default())?;
+    let class = module.define_class("RbWhen", ruby.class_object())?;
     class.define_method("_then", method!(RbWhen::then, 1))?;
 
-    let class = module.define_class("RbWhenThen", Default::default())?;
-    class.define_method("otherwise", method!(RbWhenThen::overwise, 1))?;
+    let class = module.define_class("RbWhenThen", ruby.class_object())?;
+    class.define_method("otherwise", method!(RbThen::overwise, 1))?;
+
+    // sql
+    let class = module.define_class("RbSQLContext", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbSQLContext::new, 0))?;
+    class.define_method("execute", method!(RbSQLContext::execute, 1))?;
+    class.define_method("get_tables", method!(RbSQLContext::get_tables, 0))?;
+    class.define_method("register", method!(RbSQLContext::register, 2))?;
+    class.define_method("unregister", method!(RbSQLContext::unregister, 1))?;
 
     Ok(())
 }