polars-df 0.21.0 → 0.22.0

data/ext/polars/src/lib.rs

@@ -28,14 +28,15 @@ use dataframe::RbDataFrame;
 use error::RbPolarsErr;
 use exceptions::{RbTypeError, RbValueError};
 use expr::RbExpr;
+use expr::datatype::RbDataTypeExpr;
 use expr::rb_exprs_to_exprs;
 use expr::selector::RbSelector;
 use functions::string_cache::RbStringCacheHolder;
 use functions::whenthen::{RbChainedThen, RbChainedWhen, RbThen, RbWhen};
 use interop::arrow::to_ruby::RbArrowArrayStream;
-use lazyframe::RbLazyFrame;
+use lazyframe::{RbLazyFrame, RbOptFlags};
 use lazygroupby::RbLazyGroupBy;
-use magnus::{Ruby, define_module, function, method, prelude::*};
+use magnus::{Ruby, function, method, prelude::*};
 use series::RbSeries;
 use sql::RbSQLContext;
 
@@ -51,7 +52,7 @@ fn re_escape(pattern: String) -> String {
 fn init(ruby: &Ruby) -> RbResult<()> {
     crate::on_startup::register_startup_deps();
 
-    let module = define_module("Polars")?;
+    let module = ruby.define_module("Polars")?;
 
     let class = module.define_class("RbBatchedCsv", ruby.class_object())?;
     class.define_singleton_method("new", function!(RbBatchedCsv::new, -1))?;
@@ -157,7 +158,14 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
     class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
     class.define_method("clear", method!(RbDataFrame::clear, 0))?;
-    class.define_method("serialize_json", method!(RbDataFrame::serialize_json, 1))?;
+    class.define_method(
+        "serialize_binary",
+        method!(RbDataFrame::serialize_binary, 1),
+    )?;
+    class.define_singleton_method(
+        "deserialize_binary",
+        function!(RbDataFrame::deserialize_binary, 1),
+    )?;
 
     let class = module.define_class("RbExpr", ruby.class_object())?;
     class.define_method("+", method!(RbExpr::add, 1))?;
@@ -221,6 +229,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("peak_max", method!(RbExpr::peak_max, 0))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
+    class.define_method("index_of", method!(RbExpr::index_of, 1))?;
     class.define_method("search_sorted", method!(RbExpr::search_sorted, 3))?;
     class.define_method("gather", method!(RbExpr::gather, 1))?;
     class.define_method("get", method!(RbExpr::get, 1))?;
@@ -240,6 +249,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("var", method!(RbExpr::var, 1))?;
     class.define_method("is_unique", method!(RbExpr::is_unique, 0))?;
     class.define_method("is_between", method!(RbExpr::is_between, 3))?;
+    class.define_method("is_close", method!(RbExpr::is_close, 4))?;
     class.define_method("approx_n_unique", method!(RbExpr::approx_n_unique, 0))?;
     class.define_method("is_first_distinct", method!(RbExpr::is_first_distinct, 0))?;
     class.define_method("is_last_distinct", method!(RbExpr::is_last_distinct, 0))?;
@@ -251,6 +261,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("append", method!(RbExpr::append, 2))?;
     class.define_method("rechunk", method!(RbExpr::rechunk, 0))?;
     class.define_method("round", method!(RbExpr::round, 2))?;
+    class.define_method("round_sig_figs", method!(RbExpr::round_sig_figs, 1))?;
     class.define_method("floor", method!(RbExpr::floor, 0))?;
     class.define_method("ceil", method!(RbExpr::ceil, 0))?;
     class.define_method("clip", method!(RbExpr::clip, 2))?;
@@ -258,6 +269,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sin", method!(RbExpr::sin, 0))?;
     class.define_method("cos", method!(RbExpr::cos, 0))?;
     class.define_method("tan", method!(RbExpr::tan, 0))?;
+    class.define_method("cot", method!(RbExpr::cot, 0))?;
     class.define_method("arcsin", method!(RbExpr::arcsin, 0))?;
     class.define_method("arccos", method!(RbExpr::arccos, 0))?;
     class.define_method("arctan", method!(RbExpr::arctan, 0))?;
@@ -267,21 +279,25 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arcsinh", method!(RbExpr::arcsinh, 0))?;
     class.define_method("arccosh", method!(RbExpr::arccosh, 0))?;
     class.define_method("arctanh", method!(RbExpr::arctanh, 0))?;
+    class.define_method("degrees", method!(RbExpr::degrees, 0))?;
+    class.define_method("radians", method!(RbExpr::radians, 0))?;
     class.define_method("sign", method!(RbExpr::sign, 0))?;
     class.define_method("is_duplicated", method!(RbExpr::is_duplicated, 0))?;
     class.define_method("over", method!(RbExpr::over, 1))?;
-    class.define_method("_and", method!(RbExpr::_and, 1))?;
-    class.define_method("_xor", method!(RbExpr::_xor, 1))?;
-    class.define_method("_or", method!(RbExpr::_or, 1))?;
+    class.define_method("rolling", method!(RbExpr::rolling, 4))?;
+    class.define_method("and_", method!(RbExpr::and_, 1))?;
+    class.define_method("or_", method!(RbExpr::or_, 1))?;
+    class.define_method("xor_", method!(RbExpr::xor_, 1))?;
     class.define_method("is_in", method!(RbExpr::is_in, 2))?;
     class.define_method("repeat_by", method!(RbExpr::repeat_by, 1))?;
     class.define_method("pow", method!(RbExpr::pow, 1))?;
+    class.define_method("sqrt", method!(RbExpr::sqrt, 0))?;
+    class.define_method("cbrt", method!(RbExpr::cbrt, 0))?;
     class.define_method("cum_sum", method!(RbExpr::cum_sum, 1))?;
     class.define_method("cum_max", method!(RbExpr::cum_max, 1))?;
     class.define_method("cum_min", method!(RbExpr::cum_min, 1))?;
     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, 7))?;
     class.define_method("str_to_time", method!(RbExpr::str_to_time, 3))?;
@@ -297,6 +313,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_strip_prefix", method!(RbExpr::str_strip_prefix, 1))?;
     class.define_method("str_strip_suffix", method!(RbExpr::str_strip_suffix, 1))?;
     class.define_method("str_slice", method!(RbExpr::str_slice, 2))?;
+    class.define_method("str_head", method!(RbExpr::str_head, 1))?;
+    class.define_method("str_tail", method!(RbExpr::str_tail, 1))?;
     class.define_method("str_to_uppercase", method!(RbExpr::str_to_uppercase, 0))?;
     class.define_method("str_to_lowercase", method!(RbExpr::str_to_lowercase, 0))?;
     // class.define_method("str_to_titlecase", method!(RbExpr::str_to_titlecase, 0))?;
@@ -304,17 +322,25 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_len_chars", method!(RbExpr::str_len_chars, 0))?;
     class.define_method("str_replace_n", method!(RbExpr::str_replace_n, 4))?;
     class.define_method("str_replace_all", method!(RbExpr::str_replace_all, 3))?;
+    class.define_method("str_normalize", method!(RbExpr::str_normalize, 1))?;
     class.define_method("str_reverse", method!(RbExpr::str_reverse, 0))?;
     class.define_method("str_zfill", method!(RbExpr::str_zfill, 1))?;
     class.define_method("str_pad_start", method!(RbExpr::str_pad_start, 2))?;
     class.define_method("str_pad_end", method!(RbExpr::str_pad_end, 2))?;
     class.define_method("str_contains", method!(RbExpr::str_contains, 3))?;
+    class.define_method("str_find", method!(RbExpr::str_find, 3))?;
     class.define_method("str_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
-    class.define_method("array_max", method!(RbExpr::array_max, 0))?;
-    class.define_method("array_min", method!(RbExpr::array_min, 0))?;
-    class.define_method("array_sum", method!(RbExpr::array_sum, 0))?;
+    class.define_method("arr_len", method!(RbExpr::arr_len, 0))?;
+    class.define_method("arr_max", method!(RbExpr::arr_max, 0))?;
+    class.define_method("arr_min", method!(RbExpr::arr_min, 0))?;
+    class.define_method("arr_sum", method!(RbExpr::arr_sum, 0))?;
+    class.define_method("arr_std", method!(RbExpr::arr_std, 1))?;
+    class.define_method("arr_var", method!(RbExpr::arr_var, 1))?;
+    class.define_method("arr_mean", method!(RbExpr::arr_mean, 0))?;
+    class.define_method("arr_median", method!(RbExpr::arr_median, 0))?;
     class.define_method("arr_unique", method!(RbExpr::arr_unique, 1))?;
+    class.define_method("arr_n_unique", method!(RbExpr::arr_n_unique, 0))?;
     class.define_method("arr_to_list", method!(RbExpr::arr_to_list, 0))?;
     class.define_method("arr_all", method!(RbExpr::arr_all, 0))?;
     class.define_method("arr_any", method!(RbExpr::arr_any, 0))?;
@@ -326,6 +352,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arr_join", method!(RbExpr::arr_join, 2))?;
     class.define_method("arr_contains", method!(RbExpr::arr_contains, 2))?;
     class.define_method("arr_count_matches", method!(RbExpr::arr_count_matches, 1))?;
+    class.define_method("arr_to_struct", method!(RbExpr::arr_to_struct, 1))?;
+    class.define_method("arr_slice", method!(RbExpr::arr_slice, 3))?;
+    class.define_method("arr_tail", method!(RbExpr::arr_tail, 2))?;
+    class.define_method("arr_shift", method!(RbExpr::arr_shift, 1))?;
+    class.define_method("arr_explode", method!(RbExpr::arr_explode, 0))?;
     class.define_method("binary_contains", method!(RbExpr::bin_contains, 1))?;
     class.define_method("binary_ends_with", method!(RbExpr::bin_ends_with, 1))?;
     class.define_method("binary_starts_with", method!(RbExpr::bin_starts_with, 1))?;
@@ -334,7 +365,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_base64_encode", method!(RbExpr::str_base64_encode, 0))?;
     class.define_method("str_base64_decode", method!(RbExpr::str_base64_decode, 1))?;
     class.define_method("str_to_integer", method!(RbExpr::str_to_integer, 3))?;
-    class.define_method("str_json_decode", method!(RbExpr::str_json_decode, 2))?;
+    class.define_method("str_json_decode", method!(RbExpr::str_json_decode, 1))?;
     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(
@@ -345,6 +376,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "binary_base64_decode",
         method!(RbExpr::bin_base64_decode, 1),
     )?;
+    class.define_method("bin_reinterpret", method!(RbExpr::bin_reinterpret, 2))?;
+    class.define_method("bin_size_bytes", method!(RbExpr::bin_size_bytes, 0))?;
     class.define_method(
         "str_json_path_match",
         method!(RbExpr::str_json_path_match, 1),
@@ -353,7 +386,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_extract_all", method!(RbExpr::str_extract_all, 1))?;
     class.define_method("str_extract_groups", method!(RbExpr::str_extract_groups, 1))?;
     class.define_method("str_count_matches", method!(RbExpr::str_count_matches, 2))?;
-    class.define_method("strftime", method!(RbExpr::dt_to_string, 1))?;
     class.define_method("str_split", method!(RbExpr::str_split, 1))?;
     class.define_method(
         "str_split_inclusive",
@@ -368,10 +400,21 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_to_decimal", method!(RbExpr::str_to_decimal, 1))?;
     class.define_method("str_contains_any", method!(RbExpr::str_contains_any, 2))?;
     class.define_method("str_replace_many", method!(RbExpr::str_replace_many, 3))?;
+    class.define_method("str_extract_many", method!(RbExpr::str_extract_many, 3))?;
+    class.define_method("str_find_many", method!(RbExpr::str_find_many, 3))?;
+    class.define_method("str_escape_regex", method!(RbExpr::str_escape_regex, 0))?;
     class.define_method("list_len", method!(RbExpr::list_len, 0))?;
     class.define_method("list_contains", method!(RbExpr::list_contains, 2))?;
     class.define_method("list_count_matches", method!(RbExpr::list_count_matches, 1))?;
+    class.define_method(
+        "dt_add_business_days",
+        method!(RbExpr::dt_add_business_days, 4),
+    )?;
+    class.define_method("strftime", method!(RbExpr::dt_to_string, 1))?;
+    class.define_method("dt_millennium", method!(RbExpr::dt_millennium, 0))?;
+    class.define_method("dt_century", method!(RbExpr::dt_century, 0))?;
     class.define_method("dt_year", method!(RbExpr::dt_year, 0))?;
+    class.define_method("dt_is_business_day", method!(RbExpr::dt_is_business_day, 2))?;
     class.define_method("dt_is_leap_year", method!(RbExpr::dt_is_leap_year, 0))?;
     class.define_method("dt_iso_year", method!(RbExpr::dt_iso_year, 0))?;
     class.define_method("dt_quarter", method!(RbExpr::dt_quarter, 0))?;
@@ -408,7 +451,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_timestamp", method!(RbExpr::dt_timestamp, 1))?;
     class.define_method("dt_to_string", method!(RbExpr::dt_to_string, 1))?;
     class.define_method("dt_offset_by", method!(RbExpr::dt_offset_by, 1))?;
-    class.define_method("dt_epoch_seconds", method!(RbExpr::dt_epoch_seconds, 0))?;
     class.define_method("dt_with_time_unit", method!(RbExpr::dt_with_time_unit, 1))?;
     class.define_method(
         "dt_convert_time_zone",
@@ -425,6 +467,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_base_utc_offset", method!(RbExpr::dt_base_utc_offset, 0))?;
     class.define_method("dt_dst_offset", method!(RbExpr::dt_dst_offset, 0))?;
     class.define_method("dt_round", method!(RbExpr::dt_round, 1))?;
+    class.define_method("dt_replace", method!(RbExpr::dt_replace, 8))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
     class.define_method("map_batches", method!(RbExpr::map_batches, 5))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
@@ -452,6 +495,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::rolling_quantile_by, 6),
     )?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 4))?;
+    class.define_method("rolling_kurtosis", method!(RbExpr::rolling_kurtosis, 5))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
     class.define_method("list_max", method!(RbExpr::list_max, 0))?;
@@ -464,11 +508,16 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::list_sample_fraction, 4),
     )?;
     class.define_method("list_gather", method!(RbExpr::list_gather, 2))?;
+    class.define_method("list_gather_every", method!(RbExpr::list_gather_every, 2))?;
     class.define_method("list_to_array", method!(RbExpr::list_to_array, 1))?;
     class.define_method("list_mean", method!(RbExpr::list_mean, 0))?;
+    class.define_method("list_median", method!(RbExpr::list_median, 0))?;
+    class.define_method("list_std", method!(RbExpr::list_std, 1))?;
+    class.define_method("list_var", method!(RbExpr::list_var, 1))?;
     class.define_method("list_tail", method!(RbExpr::list_tail, 1))?;
     class.define_method("list_sort", method!(RbExpr::list_sort, 2))?;
     class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
+    class.define_method("list_n_unique", method!(RbExpr::list_n_unique, 0))?;
     class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
     class.define_method("list_set_operation", method!(RbExpr::list_set_operation, 2))?;
     class.define_method("list_get", method!(RbExpr::list_get, 2))?;
@@ -483,7 +532,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_eval", method!(RbExpr::list_eval, 1))?;
     class.define_method("list_filter", method!(RbExpr::list_filter, 1))?;
     class.define_method("cumulative_eval", method!(RbExpr::cumulative_eval, 2))?;
-    class.define_method("list_to_struct", method!(RbExpr::list_to_struct, 3))?;
+    class.define_method("list_to_struct", method!(RbExpr::list_to_struct, 1))?;
     class.define_method("rank", method!(RbExpr::rank, 3))?;
     class.define_method("diff", method!(RbExpr::diff, 2))?;
     class.define_method("pct_change", method!(RbExpr::pct_change, 1))?;
@@ -491,6 +540,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("kurtosis", method!(RbExpr::kurtosis, 2))?;
     class.define_method("str_join", method!(RbExpr::str_join, 2))?;
     class.define_method("cat_get_categories", method!(RbExpr::cat_get_categories, 0))?;
+    class.define_method("cat_len_bytes", method!(RbExpr::cat_len_bytes, 0))?;
+    class.define_method("cat_len_chars", method!(RbExpr::cat_len_chars, 0))?;
+    class.define_method("cat_starts_with", method!(RbExpr::cat_starts_with, 1))?;
+    class.define_method("cat_ends_with", method!(RbExpr::cat_ends_with, 1))?;
+    class.define_method("cat_slice", method!(RbExpr::cat_slice, 2))?;
     class.define_method("reshape", method!(RbExpr::reshape, 1))?;
     class.define_method("cum_count", method!(RbExpr::cum_count, 1))?;
     class.define_method("to_physical", method!(RbExpr::to_physical, 0))?;
@@ -498,6 +552,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sample_n", method!(RbExpr::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbExpr::sample_frac, 4))?;
     class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 4))?;
+    class.define_method("ewm_mean_by", method!(RbExpr::ewm_mean_by, 2))?;
     class.define_method("ewm_std", method!(RbExpr::ewm_std, 5))?;
     class.define_method("ewm_var", method!(RbExpr::ewm_var, 5))?;
     class.define_method("extend_constant", method!(RbExpr::extend_constant, 2))?;
@@ -516,15 +571,51 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::struct_rename_fields, 1),
     )?;
     class.define_method("struct_json_encode", method!(RbExpr::struct_json_encode, 0))?;
+    class.define_method("struct_with_fields", method!(RbExpr::struct_with_fields, 1))?;
     class.define_method("log", method!(RbExpr::log, 1))?;
+    class.define_method("log1p", method!(RbExpr::log1p, 0))?;
     class.define_method("exp", method!(RbExpr::exp, 0))?;
     class.define_method("entropy", method!(RbExpr::entropy, 2))?;
     class.define_method("_hash", method!(RbExpr::hash, 4))?;
     class.define_method("set_sorted_flag", method!(RbExpr::set_sorted_flag, 1))?;
     class.define_method("replace", method!(RbExpr::replace, 2))?;
     class.define_method("replace_strict", method!(RbExpr::replace_strict, 4))?;
+    class.define_method("hist", method!(RbExpr::hist, 4))?;
     class.define_method("into_selector", method!(RbExpr::into_selector, 0))?;
     class.define_singleton_method("new_selector", function!(RbExpr::new_selector, 1))?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_method("serialize_binary", method!(RbExpr::serialize_binary, 1))?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_singleton_method(
+        "deserialize_binary",
+        function!(RbExpr::deserialize_binary, 1),
+    )?;
+
+    // bitwise
+    class.define_method("bitwise_count_ones", method!(RbExpr::bitwise_count_ones, 0))?;
+    class.define_method(
+        "bitwise_count_zeros",
+        method!(RbExpr::bitwise_count_zeros, 0),
+    )?;
+    class.define_method(
+        "bitwise_leading_ones",
+        method!(RbExpr::bitwise_leading_ones, 0),
+    )?;
+    class.define_method(
+        "bitwise_leading_zeros",
+        method!(RbExpr::bitwise_leading_zeros, 0),
+    )?;
+    class.define_method(
+        "bitwise_trailing_ones",
+        method!(RbExpr::bitwise_trailing_ones, 0),
+    )?;
+    class.define_method(
+        "bitwise_trailing_zeros",
+        method!(RbExpr::bitwise_trailing_zeros, 0),
+    )?;
+    class.define_method("bitwise_and", method!(RbExpr::bitwise_and, 0))?;
+    class.define_method("bitwise_or", method!(RbExpr::bitwise_or, 0))?;
+    class.define_method("bitwise_xor", method!(RbExpr::bitwise_xor, 0))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 1))?;
@@ -541,6 +632,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "meta_is_regex_projection",
         method!(RbExpr::meta_is_regex_projection, 0),
     )?;
+    class.define_method(
+        "meta_is_column_selection",
+        method!(RbExpr::meta_is_column_selection, 1),
+    )?;
+    class.define_method("meta_is_literal", method!(RbExpr::meta_is_literal, 1))?;
     class.define_method("meta_tree_format", method!(RbExpr::meta_tree_format, 1))?;
 
     // name
@@ -550,6 +646,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("name_suffix", method!(RbExpr::name_suffix, 1))?;
     class.define_method("name_to_lowercase", method!(RbExpr::name_to_lowercase, 0))?;
     class.define_method("name_to_uppercase", method!(RbExpr::name_to_uppercase, 0))?;
+    class.define_method("name_prefix_fields", method!(RbExpr::name_prefix_fields, 1))?;
+    class.define_method("name_suffix_fields", method!(RbExpr::name_suffix_fields, 1))?;
 
     // maybe add to different class
     let class = module.define_module("Plr")?;
@@ -605,6 +703,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(functions::aggregation::mean_horizontal, 2),
     )?;
     class.define_singleton_method("as_struct", function!(functions::lazy::as_struct, 1))?;
+    class.define_singleton_method("field", function!(functions::lazy::field, 1))?;
     class.define_singleton_method("coalesce", function!(functions::lazy::coalesce, 1))?;
     class.define_singleton_method("arg_where", function!(functions::lazy::arg_where, 1))?;
     class.define_singleton_method(
@@ -631,6 +730,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method("duration", function!(functions::lazy::duration, 9))?;
     class.define_singleton_method("ipc_schema", function!(functions::io::read_ipc_schema, 1))?;
+    class.define_singleton_method(
+        "read_parquet_metadata",
+        function!(functions::io::read_parquet_metadata, 1),
+    )?;
     class.define_singleton_method(
         "parquet_schema",
         function!(functions::io::read_parquet_schema, 1),
@@ -719,7 +822,20 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("re_escape", function!(re_escape, 1))?;
 
     let class = module.define_class("RbLazyFrame", ruby.class_object())?;
-    class.define_singleton_method("read_json", function!(RbLazyFrame::read_json, 1))?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_method(
+        "serialize_binary",
+        method!(RbLazyFrame::serialize_binary, 1),
+    )?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_singleton_method(
+        "deserialize_binary",
+        function!(RbLazyFrame::deserialize_binary, 1),
+    )?;
+    class.define_singleton_method(
+        "deserialize_json",
+        function!(RbLazyFrame::deserialize_json, 1),
+    )?;
     class.define_singleton_method(
         "new_from_ndjson",
         function!(RbLazyFrame::new_from_ndjson, 8),
@@ -742,6 +858,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("sort", method!(RbLazyFrame::sort, 5))?;
     class.define_method("sort_by_exprs", method!(RbLazyFrame::sort_by_exprs, 5))?;
+    class.define_method("top_k", method!(RbLazyFrame::top_k, 3))?;
+    class.define_method("bottom_k", method!(RbLazyFrame::bottom_k, 3))?;
     class.define_method("cache", method!(RbLazyFrame::cache, 0))?;
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
     class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 9))?;
@@ -749,6 +867,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, -1))?;
     class.define_method("sink_json", method!(RbLazyFrame::sink_json, 4))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
+    class.define_method("remove", method!(RbLazyFrame::remove, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
     class.define_method("select_seq", method!(RbLazyFrame::select_seq, 1))?;
     class.define_method("group_by", method!(RbLazyFrame::group_by, 2))?;
@@ -760,6 +879,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 14))?;
     class.define_method("join", method!(RbLazyFrame::join, 11))?;
+    class.define_method("join_where", method!(RbLazyFrame::join_where, 3))?;
     class.define_method("with_column", method!(RbLazyFrame::with_column, 1))?;
     class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
     class.define_method(
@@ -781,6 +901,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("explode", method!(RbLazyFrame::explode, 1))?;
     class.define_method("null_count", method!(RbLazyFrame::null_count, 0))?;
     class.define_method("unique", method!(RbLazyFrame::unique, 3))?;
+    class.define_method("drop_nans", method!(RbLazyFrame::drop_nans, 1))?;
     class.define_method("drop_nulls", method!(RbLazyFrame::drop_nulls, 1))?;
     class.define_method("slice", method!(RbLazyFrame::slice, 2))?;
     class.define_method("tail", method!(RbLazyFrame::tail, 1))?;
@@ -810,6 +931,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_opt_i16", function!(RbSeries::new_opt_i16, 3))?;
     class.define_singleton_method("new_opt_i32", function!(RbSeries::new_opt_i32, 3))?;
     class.define_singleton_method("new_opt_i64", function!(RbSeries::new_opt_i64, 3))?;
+    class.define_singleton_method("new_opt_i128", function!(RbSeries::new_opt_i128, 3))?;
     class.define_singleton_method("new_opt_f32", function!(RbSeries::new_opt_f32, 3))?;
     class.define_singleton_method("new_opt_f64", function!(RbSeries::new_opt_f64, 3))?;
     class.define_singleton_method(
@@ -855,7 +977,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("estimated_size", method!(RbSeries::estimated_size, 0))?;
     class.define_method("get_fmt", method!(RbSeries::get_fmt, 2))?;
     class.define_method("rechunk", method!(RbSeries::rechunk, 1))?;
-    class.define_method("get_idx", method!(RbSeries::get_idx, 1))?;
+    class.define_method("get_index", method!(RbSeries::get_index, 1))?;
+    class.define_method("get_index_signed", method!(RbSeries::get_index_signed, 1))?;
     class.define_method("bitand", method!(RbSeries::bitand, 1))?;
     class.define_method("bitor", method!(RbSeries::bitor, 1))?;
     class.define_method("bitxor", method!(RbSeries::bitxor, 1))?;
@@ -869,6 +992,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("max", method!(RbSeries::max, 0))?;
     class.define_method("min", method!(RbSeries::min, 0))?;
     class.define_method("sum", method!(RbSeries::sum, 0))?;
+    class.define_method("first", method!(RbSeries::first, 0))?;
+    class.define_method("last", method!(RbSeries::last, 0))?;
+    class.define_method("approx_n_unique", method!(RbSeries::approx_n_unique, 0))?;
+    class.define_method("bitwise_and", method!(RbSeries::bitwise_and, 0))?;
+    class.define_method("bitwise_or", method!(RbSeries::bitwise_or, 0))?;
+    class.define_method("bitwise_xor", method!(RbSeries::bitwise_xor, 0))?;
     class.define_method("n_chunks", method!(RbSeries::n_chunks, 0))?;
     class.define_method("append", method!(RbSeries::append, 1))?;
     class.define_method("extend", method!(RbSeries::extend, 1))?;
@@ -898,7 +1027,13 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("gt_eq", method!(RbSeries::gt_eq, 1))?;
     class.define_method("lt", method!(RbSeries::lt, 1))?;
     class.define_method("lt_eq", method!(RbSeries::lt_eq, 1))?;
-    class.define_method("not", method!(RbSeries::not, 0))?;
+    class.define_method("not_", method!(RbSeries::not_, 0))?;
+    class.define_method("shrink_dtype", method!(RbSeries::shrink_dtype, 0))?;
+    class.define_method(
+        "str_to_decimal_infer",
+        method!(RbSeries::str_to_decimal_infer, 1),
+    )?;
+    class.define_method("str_json_decode", method!(RbSeries::str_json_decode, 1))?;
     class.define_method("to_s", method!(RbSeries::to_s, 0))?;
     class.define_method("len", method!(RbSeries::len, 0))?;
     class.define_method("to_a", method!(RbSeries::to_a, 0))?;
@@ -915,6 +1050,9 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("skew", method!(RbSeries::skew, 1))?;
     class.define_method("kurtosis", method!(RbSeries::kurtosis, 2))?;
     class.define_method("cast", method!(RbSeries::cast, 2))?;
+    class.define_method("get_chunks", method!(RbSeries::get_chunks, 0))?;
+    class.define_method("is_sorted", method!(RbSeries::is_sorted, 2))?;
+    class.define_method("clear", method!(RbSeries::clear, 0))?;
     class.define_method("time_unit", method!(RbSeries::time_unit, 0))?;
     class.define_method("scatter", method!(RbSeries::scatter, 2))?;
 
@@ -1152,7 +1290,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
 
     // data type expr
-    let _class = module.define_class("RbDataTypeExpr", ruby.class_object())?;
+    let class = module.define_class("RbDataTypeExpr", ruby.class_object())?;
+    class.define_singleton_method("from_dtype", function!(RbDataTypeExpr::from_dtype, 1))?;
+    class.define_singleton_method("of_expr", function!(RbDataTypeExpr::of_expr, 1))?;
+    class.define_method("collect_dtype", method!(RbDataTypeExpr::collect_dtype, 1))?;
 
     // selector
     let class = module.define_class("RbSelector", ruby.class_object())?;
@@ -1189,5 +1330,106 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("all", function!(RbSelector::all, 0))?;
     class.define_method("_hash", method!(RbSelector::hash, 0))?;
 
+    // opt flags
+    let class = module.define_class("RbOptFlags", ruby.class_object())?;
+    class.define_singleton_method("empty", function!(RbOptFlags::empty, 0))?;
+    class.define_singleton_method("default", function!(RbOptFlags::default, 0))?;
+    class.define_method("no_optimizations", method!(RbOptFlags::no_optimizations, 0))?;
+    class.define_method("copy", method!(RbOptFlags::copy, 0))?;
+    class.define_method(
+        "get_type_coercion",
+        method!(RbOptFlags::get_type_coercion, 0),
+    )?;
+    class.define_method(
+        "set_type_coercion",
+        method!(RbOptFlags::set_type_coercion, 1),
+    )?;
+    class.define_method("get_type_check", method!(RbOptFlags::get_type_check, 0))?;
+    class.define_method("set_type_check", method!(RbOptFlags::set_type_check, 1))?;
+    class.define_method(
+        "get_projection_pushdown",
+        method!(RbOptFlags::get_projection_pushdown, 0),
+    )?;
+    class.define_method(
+        "set_projection_pushdown",
+        method!(RbOptFlags::set_projection_pushdown, 1),
+    )?;
+    class.define_method(
+        "get_predicate_pushdown",
+        method!(RbOptFlags::get_predicate_pushdown, 0),
+    )?;
+    class.define_method(
+        "set_predicate_pushdown",
+        method!(RbOptFlags::set_predicate_pushdown, 1),
+    )?;
+    class.define_method(
+        "get_cluster_with_columns",
+        method!(RbOptFlags::get_cluster_with_columns, 0),
+    )?;
+    class.define_method(
+        "set_cluster_with_columns",
+        method!(RbOptFlags::set_cluster_with_columns, 1),
+    )?;
+    class.define_method(
+        "get_simplify_expression",
+        method!(RbOptFlags::get_simplify_expression, 0),
+    )?;
+    class.define_method(
+        "set_simplify_expression",
+        method!(RbOptFlags::set_simplify_expression, 1),
+    )?;
+    class.define_method(
+        "get_slice_pushdown",
+        method!(RbOptFlags::get_slice_pushdown, 0),
+    )?;
+    class.define_method(
+        "set_slice_pushdown",
+        method!(RbOptFlags::set_slice_pushdown, 1),
+    )?;
+    class.define_method(
+        "get_comm_subplan_elim",
+        method!(RbOptFlags::get_comm_subplan_elim, 0),
+    )?;
+    class.define_method(
+        "set_comm_subplan_elim",
+        method!(RbOptFlags::set_comm_subplan_elim, 1),
+    )?;
+    class.define_method(
+        "get_comm_subexpr_elim",
+        method!(RbOptFlags::get_comm_subexpr_elim, 0),
+    )?;
+    class.define_method(
+        "set_comm_subexpr_elim",
+        method!(RbOptFlags::set_comm_subexpr_elim, 1),
+    )?;
+    class.define_method(
+        "get_collapse_joins",
+        method!(RbOptFlags::get_collapse_joins, 0),
+    )?;
+    class.define_method(
+        "set_collapse_joins",
+        method!(RbOptFlags::set_collapse_joins, 1),
+    )?;
+    class.define_method(
+        "get_check_order_observe",
+        method!(RbOptFlags::get_check_order_observe, 0),
+    )?;
+    class.define_method(
+        "set_check_order_observe",
+        method!(RbOptFlags::set_check_order_observe, 1),
+    )?;
+    class.define_method(
+        "get_fast_projection",
+        method!(RbOptFlags::get_fast_projection, 0),
+    )?;
+    class.define_method(
+        "set_fast_projection",
+        method!(RbOptFlags::set_fast_projection, 1),
+    )?;
+    class.define_method("get_eager", method!(RbOptFlags::get_eager, 0))?;
+    class.define_method("set_eager", method!(RbOptFlags::set_eager, 1))?;
+    class.define_method("get_streaming", method!(RbOptFlags::get_streaming, 0))?;
+    class.define_method("set_streaming", method!(RbOptFlags::set_streaming, 1))?;
+
     Ok(())
 }