polars-df 0.6.0 → 0.7.0

data/ext/polars/src/lib.rs

@@ -1,4 +1,3 @@
-mod apply;
 mod batched_csv;
 mod conversion;
 mod dataframe;
@@ -8,10 +7,12 @@ 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;
@@ -20,11 +21,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 +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",
@@ -62,12 +68,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 +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))?;
@@ -202,10 +257,10 @@ 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, 3))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
@@ -217,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))?;
@@ -264,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",
@@ -286,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))?;
@@ -299,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))?;
@@ -323,29 +378,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 +422,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 +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(
@@ -390,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))?;
@@ -440,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))?;
@@ -450,10 +512,6 @@ 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))?;
@@ -490,20 +548,20 @@ 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, 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))?;
@@ -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))?;
@@ -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(())
 }

data/ext/polars/src/{apply → map}/dataframe.rs

@@ -1,4 +1,4 @@
-use magnus::{class, IntoValue, RArray, TryConvert, Value};
+use magnus::{class, prelude::*, typed_data::Obj, IntoValue, RArray, TryConvert, Value};
 use polars::prelude::*;
 use polars_core::frame::row::{rows_to_schema_first_non_null, Row};
 use polars_core::series::SeriesIter;
@@ -34,20 +34,20 @@ pub fn apply_lambda_unknown<'a>(
             null_count += 1;
             continue;
         } else if out.is_kind_of(class::true_class()) || out.is_kind_of(class::false_class()) {
-            let first_value = out.try_convert::<bool>().ok();
+            let first_value = bool::try_convert(out).ok();
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_bool_out_type(df, lambda, null_count, first_value)
                         .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
         } else if out.is_kind_of(class::float()) {
-            let first_value = out.try_convert::<f64>().ok();
+            let first_value = f64::try_convert(out).ok();
 
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Float64Type>(
                         df,
                         lambda,
@@ -55,14 +55,14 @@ pub fn apply_lambda_unknown<'a>(
                         first_value,
                     )
                     .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
         } else if out.is_kind_of(class::integer()) {
-            let first_value = out.try_convert::<i64>().ok();
+            let first_value = i64::try_convert(out).ok();
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Int64Type>(
                         df,
                         lambda,
@@ -70,12 +70,12 @@ pub fn apply_lambda_unknown<'a>(
                         first_value,
                     )
                     .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
         // } else if out.is_kind_of(class::string()) {
-        //     let first_value = out.try_convert::<String>().ok();
+        //     let first_value = String::try_convert(out).ok();
         //     return Ok((
         //         RbSeries::new(
         //             apply_lambda_with_utf8_out_type(df, lambda, null_count, first_value)
@@ -85,25 +85,21 @@ pub fn apply_lambda_unknown<'a>(
         //         false,
         //     ));
         } else if out.respond_to("_s", true)? {
-            let rb_rbseries: Value = out.funcall("_s", ()).unwrap();
-            let series = rb_rbseries
-                .try_convert::<&RbSeries>()
-                .unwrap()
-                .series
-                .borrow();
+            let rb_rbseries: Obj<RbSeries> = out.funcall("_s", ()).unwrap();
+            let series = rb_rbseries.series.borrow();
             let dt = series.dtype();
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_list_out_type(df, lambda, null_count, Some(&series), dt)?
                         .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
-        } else if out.try_convert::<Wrap<Row<'a>>>().is_ok() {
-            let first_value = out.try_convert::<Wrap<Row<'a>>>().unwrap().0;
+        } else if Wrap::<Row<'a>>::try_convert(out).is_ok() {
+            let first_value = Wrap::<Row<'a>>::try_convert(out).unwrap().0;
             return Ok((
-                RbDataFrame::from(
+                Obj::wrap(RbDataFrame::from(
                     apply_lambda_with_rows_output(
                         df,
                         lambda,
@@ -112,8 +108,8 @@ pub fn apply_lambda_unknown<'a>(
                         inference_size,
                     )
                     .map_err(RbPolarsErr::from)?,
-                )
-                .into(),
+                ))
+                .as_value(),
                 true,
             ));
         } else if out.is_kind_of(class::array()) {
@@ -143,7 +139,7 @@ where
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
         let tpl = (RArray::from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
-            Ok(val) => val.try_convert::<T>().ok(),
+            Ok(val) => T::try_convert(val).ok(),
             Err(e) => panic!("ruby function failed {}", e),
         }
     })
@@ -219,8 +215,7 @@ pub fn apply_lambda_with_list_out_type(
             let tpl = (RArray::from_iter(iter),);
             match lambda.funcall::<_, _, Value>("call", tpl) {
                 Ok(val) => match val.funcall::<_, _, Value>("_s", ()) {
-                    Ok(val) => val
-                        .try_convert::<&RbSeries>()
+                    Ok(val) => Obj::<RbSeries>::try_convert(val)
                         .ok()
                         .map(|ps| ps.series.borrow().clone()),
                     Err(_) => {
@@ -257,11 +252,11 @@ pub fn apply_lambda_with_rows_output<'a>(
         let tpl = (RArray::from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => {
-                match val.try_convert::<RArray>().ok() {
+                match RArray::try_convert(val).ok() {
                     Some(tuple) => {
                         row_buf.0.clear();
                         for v in tuple.each() {
-                            let v = v.unwrap().try_convert::<Wrap<AnyValue>>().unwrap().0;
+                            let v = Wrap::<AnyValue>::try_convert(v.unwrap()).unwrap().0;
                             row_buf.0.push(v);
                         }
                         let ptr = &row_buf as *const Row;

data/ext/polars/src/{apply → map}/mod.rs

@@ -2,7 +2,7 @@ pub mod dataframe;
 pub mod lazy;
 pub mod series;
 
-use magnus::{RHash, Value};
+use magnus::{prelude::*, RHash, Value};
 use polars::chunked_array::builder::get_list_builder;
 use polars::prelude::*;
 use polars_core::export::rayon::prelude::*;
@@ -68,7 +68,7 @@ fn iterator_to_struct(
                 }
             }
             Some(dict) => {
-                let dict = dict.try_convert::<RHash>()?;
+                let dict = RHash::try_convert(dict)?;
                 if dict.len() != struct_width {
                     return Err(crate::error::ComputeError::new_err(
                         format!("Cannot create struct type.\n> The struct dtype expects {} fields, but it got a dict with {} fields.", struct_width, dict.len())
@@ -78,7 +78,7 @@ fn iterator_to_struct(
                 // the first item determines the output name
                 todo!()
                 // for ((_, val), field_items) in dict.iter().zip(&mut items) {
-                //     let item = val.try_convert::<Wrap<AnyValue>>()?;
+                //     let item = Wrap::<AnyValue>::try_convert(val)?;
                 //     field_items.push(item.0)
                 // }
             }