polars-df 0.5.0 → 0.7.0

data/ext/polars/src/lib.rs

@@ -1,4 +1,3 @@
-mod apply;
 mod batched_csv;
 mod conversion;
 mod dataframe;
@@ -8,23 +7,26 @@ mod file;
 mod functions;
 mod lazyframe;
 mod lazygroupby;
+mod map;
 mod object;
 mod prelude;
 pub(crate) mod rb_modules;
 mod series;
+mod sql;
 mod utils;
 
 use batched_csv::RbBatchedCsv;
 use conversion::*;
 use dataframe::RbDataFrame;
-use error::{RbPolarsErr, RbValueError};
+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 +45,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",
@@ -59,15 +65,15 @@ fn init() -> RbResult<()> {
     )?;
     module.define_singleton_method(
         "_concat_lf",
-        function!(crate::functions::lazy::concat_lf, 3),
+        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 +93,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 +135,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))?;
@@ -179,7 +234,6 @@ fn init() -> RbResult<()> {
         "take_with_series",
         method!(RbDataFrame::take_with_series, 1),
     )?;
-    class.define_method("sort", method!(RbDataFrame::sort, 3))?;
     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))?;
@@ -193,7 +247,7 @@ fn init() -> RbResult<()> {
     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))?;
-    class.define_method("partition_by", method!(RbDataFrame::partition_by, 2))?;
+    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))?;
@@ -203,12 +257,12 @@ fn init() -> RbResult<()> {
     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("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("quantile", method!(RbDataFrame::quantile, 2))?;
-    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 2))?;
+    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))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
@@ -218,7 +272,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))?;
@@ -265,15 +319,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",
@@ -287,10 +342,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, 1))?;
     class.define_method("tail", method!(RbExpr::tail, 1))?;
     class.define_method("head", method!(RbExpr::head, 1))?;
     class.define_method("slice", method!(RbExpr::slice, 2))?;
@@ -300,8 +356,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))?;
@@ -324,31 +378,43 @@ 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_parse_date", method!(RbExpr::str_to_date, 4))?;
-    class.define_method("str_parse_datetime", method!(RbExpr::str_to_datetime, 8))?;
-    class.define_method("str_parse_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_to_date", method!(RbExpr::str_to_date, 4))?;
+    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_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))?;
+    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("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))?;
@@ -356,8 +422,8 @@ 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_json_extract", method!(RbExpr::str_json_extract, 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("binary_hex_encode", method!(RbExpr::bin_hex_encode, 0))?;
     class.define_method("binary_hex_decode", method!(RbExpr::bin_hex_decode, 1))?;
     class.define_method(
@@ -374,7 +440,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(
@@ -387,9 +453,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))?;
@@ -437,7 +503,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))?;
@@ -447,18 +512,14 @@ 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, 6))?;
-    class.define_method("rolling_var", method!(RbExpr::rolling_var, 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_skew", method!(RbExpr::rolling_skew, 2))?;
@@ -487,10 +548,10 @@ 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("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, 1))?;
     class.define_method("sample_n", method!(RbExpr::sample_n, 4))?;
@@ -499,8 +560,8 @@ fn init() -> RbResult<()> {
     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),
@@ -517,6 +578,7 @@ fn init() -> RbResult<()> {
     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))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 0))?;
@@ -533,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))?;
@@ -541,9 +611,16 @@ fn init() -> RbResult<()> {
     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, 1))?;
-    class.define_singleton_method("arange", function!(crate::functions::lazy::arange, 3))?;
-    class.define_singleton_method("repeat", function!(crate::functions::lazy::repeat, 2))?;
+    class.define_singleton_method("lit", function!(crate::functions::lazy::lit, 2))?;
+    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",
         function!(crate::functions::lazy::pearson_corr, 3),
@@ -552,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),
@@ -567,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",
@@ -576,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))?;
@@ -587,27 +664,32 @@ 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, 3))?;
-    class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 3))?;
+    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("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, 5))?;
-    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))?;
@@ -632,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))?;
@@ -658,6 +740,7 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("new_null", function!(RbSeries::new_null, 3))?;
     class.define_singleton_method("new_object", function!(RbSeries::new_object, 3))?;
     class.define_singleton_method("new_series_list", function!(RbSeries::new_series_list, 3))?;
+    class.define_singleton_method("new_array", function!(RbSeries::new_array, 5))?;
     class.define_singleton_method("new_decimal", function!(RbSeries::new_decimal, 3))?;
     class.define_singleton_method("repeat", function!(RbSeries::repeat, 4))?;
     class.define_method("struct_unnest", method!(RbSeries::struct_unnest, 0))?;
@@ -725,9 +808,7 @@ fn init() -> RbResult<()> {
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
     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, 1))?;
-    class.define_method("peak_max", method!(RbSeries::peak_max, 0))?;
-    class.define_method("peak_min", method!(RbSeries::peak_min, 0))?;
+    class.define_method("to_dummies", method!(RbSeries::to_dummies, 2))?;
     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))?;
@@ -897,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(())
 }