polars-df 0.15.0 → 0.26.0

data/ext/polars/src/lib.rs

@@ -1,5 +1,7 @@
-mod allocator;
-mod batched_csv;
+#![allow(clippy::too_many_arguments)]
+
+mod c_api;
+mod catalog;
 mod conversion;
 mod dataframe;
 mod error;
@@ -8,6 +10,7 @@ mod expr;
 mod file;
 mod functions;
 mod interop;
+mod io;
 mod lazyframe;
 mod lazygroupby;
 mod map;
@@ -15,43 +18,46 @@ mod object;
 mod on_startup;
 mod prelude;
 pub(crate) mod rb_modules;
+mod ruby;
 mod series;
 mod sql;
+mod testing;
+mod timeout;
 mod utils;
 
-use batched_csv::RbBatchedCsv;
+use crate::conversion::Wrap;
+
+pub type RbDataType = Wrap<polars_core::datatypes::DataType>;
+
+use catalog::unity::RbCatalogClient;
 use conversion::*;
 use dataframe::RbDataFrame;
 use error::RbPolarsErr;
-use exceptions::{RbTypeError, RbValueError};
-use expr::rb_exprs_to_exprs;
 use expr::RbExpr;
-use functions::string_cache::RbStringCacheHolder;
+use expr::datatype::RbDataTypeExpr;
+use expr::selector::RbSelector;
 use functions::whenthen::{RbChainedThen, RbChainedWhen, RbThen, RbWhen};
-use interop::arrow::to_ruby::RbArrowArrayStream;
-use lazyframe::RbLazyFrame;
+use interop::arrow::to_rb::{RbArrowArrayStream, RbArrowSchema};
+use lazyframe::{RbCollectBatches, RbInProcessQuery, RbLazyFrame, RbOptFlags};
 use lazygroupby::RbLazyGroupBy;
-use magnus::{define_module, function, method, prelude::*, Ruby};
+use magnus::{Ruby, function, method, prelude::*};
+use ruby::exceptions::{RbTypeError, RbValueError};
 use series::RbSeries;
 use sql::RbSQLContext;
 
-use magnus::error::Result as RbResult;
 use magnus::Error as RbErr;
+use magnus::error::Result as RbResult;
 
 // TODO move
 fn re_escape(pattern: String) -> String {
     regex::escape(&pattern)
 }
 
-#[magnus::init]
+#[magnus::init(name = "polars")]
 fn init(ruby: &Ruby) -> RbResult<()> {
-    crate::on_startup::register_startup_deps();
+    unsafe { crate::on_startup::register_startup_deps(true) };
 
-    let module = define_module("Polars")?;
-
-    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 module = ruby.define_module("Polars")?;
 
     let class = module.define_class("RbDataFrame", ruby.class_object())?;
     class.define_singleton_method("new", function!(RbDataFrame::init, 1))?;
@@ -65,14 +71,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("from_rows", function!(RbDataFrame::from_rows, 3))?;
     class.define_singleton_method("from_hashes", function!(RbDataFrame::from_hashes, 5))?;
     class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 4))?;
-    class.define_singleton_method("read_ndjson", function!(RbDataFrame::read_ndjson, 4))?;
     class.define_method("estimated_size", method!(RbDataFrame::estimated_size, 0))?;
     class.define_method("dtype_strings", method!(RbDataFrame::dtype_strings, 0))?;
     class.define_method("write_avro", method!(RbDataFrame::write_avro, 3))?;
-    class.define_method("write_json", method!(RbDataFrame::write_json, 3))?;
-    class.define_method("write_ndjson", method!(RbDataFrame::write_ndjson, 1))?;
-    class.define_method("write_csv", method!(RbDataFrame::write_csv, 10))?;
-    class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 3))?;
+    class.define_method("write_json", method!(RbDataFrame::write_json, 1))?;
     class.define_method(
         "write_ipc_stream",
         method!(RbDataFrame::write_ipc_stream, 3),
@@ -84,7 +86,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbDataFrame::__arrow_c_stream__, 0),
     )?;
     class.define_method("to_numo", method!(RbDataFrame::to_numo, 0))?;
-    class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 6))?;
     class.define_method("add", method!(RbDataFrame::add, 1))?;
     class.define_method("sub", method!(RbDataFrame::sub, 1))?;
     class.define_method("div", method!(RbDataFrame::div, 1))?;
@@ -116,17 +117,17 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("vstack_mut", method!(RbDataFrame::vstack_mut, 1))?;
     class.define_method("vstack", method!(RbDataFrame::vstack, 1))?;
     class.define_method("drop_in_place", method!(RbDataFrame::drop_in_place, 1))?;
-    class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
+    class.define_method("to_series", method!(RbDataFrame::to_series, 1))?;
     class.define_method(
         "get_column_index",
         method!(RbDataFrame::get_column_index, 1),
     )?;
     class.define_method("get_column", method!(RbDataFrame::get_column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
-    class.define_method("take", method!(RbDataFrame::gather, 1))?;
+    class.define_method("gather", method!(RbDataFrame::gather, 1))?;
     class.define_method(
-        "take_with_series",
-        method!(RbDataFrame::take_with_series, 1),
+        "gather_with_series",
+        method!(RbDataFrame::gather_with_series, 1),
     )?;
     class.define_method("replace", method!(RbDataFrame::replace, 2))?;
     class.define_method("replace_column", method!(RbDataFrame::replace_column, 2))?;
@@ -138,26 +139,31 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("is_duplicated", method!(RbDataFrame::is_duplicated, 0))?;
     class.define_method("equals", method!(RbDataFrame::equals, 2))?;
     class.define_method("with_row_index", method!(RbDataFrame::with_row_index, 2))?;
+    class.define_method(
+        "group_by_map_groups",
+        method!(RbDataFrame::group_by_map_groups, 3),
+    )?;
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
     class.define_method("unpivot", method!(RbDataFrame::unpivot, 4))?;
-    class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
-    class.define_method("mean_horizontal", method!(RbDataFrame::mean_horizontal, 1))?;
-    class.define_method("max_horizontal", method!(RbDataFrame::max_horizontal, 0))?;
-    class.define_method("min_horizontal", method!(RbDataFrame::min_horizontal, 0))?;
-    class.define_method("sum_horizontal", method!(RbDataFrame::sum_horizontal, 1))?;
-    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
+    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 4))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
     class.define_method("map_rows", method!(RbDataFrame::map_rows, 3))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
     class.define_method("hash_rows", method!(RbDataFrame::hash_rows, 4))?;
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
     class.define_method("upsample", method!(RbDataFrame::upsample, 4))?;
-    class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
-    class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
+    class.define_method("to_struct", method!(RbDataFrame::to_struct, 2))?;
     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))?;
@@ -176,7 +182,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("gt_eq", method!(RbExpr::gt_eq, 1))?;
     class.define_method("lt_eq", method!(RbExpr::lt_eq, 1))?;
     class.define_method("lt", method!(RbExpr::lt, 1))?;
-    class.define_method("_alias", method!(RbExpr::alias, 1))?;
+    class.define_method("alias", method!(RbExpr::alias, 1))?;
     class.define_method("not_", method!(RbExpr::not_, 0))?;
     class.define_method("is_null", method!(RbExpr::is_null, 0))?;
     class.define_method("is_not_null", method!(RbExpr::is_not_null, 0))?;
@@ -186,6 +192,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("is_not_nan", method!(RbExpr::is_not_nan, 0))?;
     class.define_method("min", method!(RbExpr::min, 0))?;
     class.define_method("max", method!(RbExpr::max, 0))?;
+    class.define_method("min_by", method!(RbExpr::min_by, 1))?;
+    class.define_method("max_by", method!(RbExpr::max_by, 1))?;
     class.define_method("nan_max", method!(RbExpr::nan_max, 0))?;
     class.define_method("nan_min", method!(RbExpr::nan_min, 0))?;
     class.define_method("mean", method!(RbExpr::mean, 0))?;
@@ -195,9 +203,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arg_unique", method!(RbExpr::arg_unique, 0))?;
     class.define_method("unique", method!(RbExpr::unique, 0))?;
     class.define_method("unique_stable", method!(RbExpr::unique_stable, 0))?;
-    class.define_method("first", method!(RbExpr::first, 0))?;
-    class.define_method("last", method!(RbExpr::last, 0))?;
-    class.define_method("implode", method!(RbExpr::implode, 0))?;
+    class.define_method("first", method!(RbExpr::first, 1))?;
+    class.define_method("last", method!(RbExpr::last, 1))?;
+    class.define_method("item", method!(RbExpr::item, 1))?;
+    class.define_method("implode", method!(RbExpr::implode, 1))?;
     class.define_method("quantile", method!(RbExpr::quantile, 2))?;
     class.define_method("cut", method!(RbExpr::cut, 4))?;
     class.define_method("qcut", method!(RbExpr::qcut, 5))?;
@@ -210,7 +219,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("value_counts", method!(RbExpr::value_counts, 4))?;
     class.define_method("unique_counts", method!(RbExpr::unique_counts, 0))?;
     class.define_method("null_count", method!(RbExpr::null_count, 0))?;
-    class.define_method("cast", method!(RbExpr::cast, 2))?;
+    class.define_method("cast", method!(RbExpr::cast, 3))?;
     class.define_method("sort_with", method!(RbExpr::sort_with, 2))?;
     class.define_method("arg_sort", method!(RbExpr::arg_sort, 2))?;
     class.define_method("top_k", method!(RbExpr::top_k, 1))?;
@@ -221,12 +230,11 @@ 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("search_sorted", method!(RbExpr::search_sorted, 2))?;
-    class.define_method("gather", method!(RbExpr::gather, 1))?;
-    class.define_method("get", method!(RbExpr::get, 1))?;
+    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, 2))?;
+    class.define_method("get", method!(RbExpr::get, 2))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 5))?;
-    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, 2))?;
     class.define_method("fill_null", method!(RbExpr::fill_null, 1))?;
     class.define_method(
@@ -242,17 +250,20 @@ 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))?;
-    class.define_method("explode", method!(RbExpr::explode, 0))?;
+    class.define_method("explode", method!(RbExpr::explode, 2))?;
     class.define_method("gather_every", method!(RbExpr::gather_every, 2))?;
     class.define_method("tail", method!(RbExpr::tail, 1))?;
     class.define_method("head", method!(RbExpr::head, 1))?;
     class.define_method("slice", method!(RbExpr::slice, 2))?;
     class.define_method("append", method!(RbExpr::append, 2))?;
     class.define_method("rechunk", method!(RbExpr::rechunk, 0))?;
-    class.define_method("round", method!(RbExpr::round, 1))?;
+    class.define_method("round", method!(RbExpr::round, 2))?;
+    class.define_method("round_sig_figs", method!(RbExpr::round_sig_figs, 1))?;
+    class.define_method("truncate", method!(RbExpr::truncate, 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))?;
@@ -260,6 +271,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))?;
@@ -269,21 +281,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("is_in", method!(RbExpr::is_in, 1))?;
+    class.define_method("over", method!(RbExpr::over, 5))?;
+    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))?;
@@ -299,6 +315,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))?;
@@ -306,28 +324,38 @@ 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_unique", method!(RbExpr::arr_unique, 1))?;
+    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_to_list", method!(RbExpr::arr_to_list, 0))?;
-    class.define_method("arr_all", method!(RbExpr::arr_all, 0))?;
-    class.define_method("arr_any", method!(RbExpr::arr_any, 0))?;
     class.define_method("arr_sort", method!(RbExpr::arr_sort, 2))?;
-    class.define_method("arr_reverse", method!(RbExpr::arr_reverse, 0))?;
     class.define_method("arr_arg_min", method!(RbExpr::arr_arg_min, 0))?;
     class.define_method("arr_arg_max", method!(RbExpr::arr_arg_max, 0))?;
     class.define_method("arr_get", method!(RbExpr::arr_get, 2))?;
     class.define_method("arr_join", method!(RbExpr::arr_join, 2))?;
-    class.define_method("arr_contains", method!(RbExpr::arr_contains, 1))?;
+    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, 2))?;
+    class.define_method("arr_eval", method!(RbExpr::arr_eval, 2))?;
+    class.define_method("arr_agg", method!(RbExpr::arr_agg, 1))?;
     class.define_method("binary_contains", method!(RbExpr::bin_contains, 1))?;
     class.define_method("binary_ends_with", method!(RbExpr::bin_ends_with, 1))?;
     class.define_method("binary_starts_with", method!(RbExpr::bin_starts_with, 1))?;
@@ -335,8 +363,8 @@ fn init(ruby: &Ruby) -> 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_to_integer", method!(RbExpr::str_to_integer, 2))?;
-    class.define_method("str_json_decode", method!(RbExpr::str_json_decode, 2))?;
+    class.define_method("str_to_integer", method!(RbExpr::str_to_integer, 3))?;
+    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(
@@ -347,6 +375,12 @@ 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("bin_slice", method!(RbExpr::bin_slice, 2))?;
+    class.define_method("bin_head", method!(RbExpr::bin_head, 1))?;
+    class.define_method("bin_tail", method!(RbExpr::bin_tail, 1))?;
+    class.define_method("bin_get", method!(RbExpr::bin_get, 2))?;
     class.define_method(
         "str_json_path_match",
         method!(RbExpr::str_json_path_match, 1),
@@ -355,7 +389,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",
@@ -367,17 +400,34 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::str_split_exact_inclusive, 2),
     )?;
     class.define_method("str_splitn", method!(RbExpr::str_splitn, 2))?;
+    class.define_method("str_split_regex", method!(RbExpr::str_split_regex, 2))?;
+    class.define_method(
+        "str_split_regex_inclusive",
+        method!(RbExpr::str_split_regex_inclusive, 2),
+    )?;
     class.define_method("str_to_decimal", method!(RbExpr::str_to_decimal, 1))?;
     class.define_method("str_contains_any", method!(RbExpr::str_contains_any, 2))?;
-    class.define_method("str_replace_many", method!(RbExpr::str_replace_many, 3))?;
+    class.define_method("str_replace_many", method!(RbExpr::str_replace_many, 4))?;
+    class.define_method("str_extract_many", method!(RbExpr::str_extract_many, 4))?;
+    class.define_method("str_find_many", method!(RbExpr::str_find_many, 4))?;
+    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, 1))?;
+    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))?;
     class.define_method("dt_month", method!(RbExpr::dt_month, 0))?;
+    class.define_method("dt_days_in_month", method!(RbExpr::dt_days_in_month, 0))?;
     class.define_method("dt_week", method!(RbExpr::dt_week, 0))?;
     class.define_method("dt_weekday", method!(RbExpr::dt_weekday, 0))?;
     class.define_method("dt_day", method!(RbExpr::dt_day, 0))?;
@@ -391,27 +441,25 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_millisecond", method!(RbExpr::dt_millisecond, 0))?;
     class.define_method("dt_microsecond", method!(RbExpr::dt_microsecond, 0))?;
     class.define_method("dt_nanosecond", method!(RbExpr::dt_nanosecond, 0))?;
-    class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 0))?;
-    class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 0))?;
-    class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 0))?;
-    class.define_method("dt_total_seconds", method!(RbExpr::dt_total_seconds, 0))?;
+    class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 1))?;
+    class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 1))?;
+    class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 1))?;
+    class.define_method("dt_total_seconds", method!(RbExpr::dt_total_seconds, 1))?;
     class.define_method(
         "dt_total_nanoseconds",
-        method!(RbExpr::dt_total_nanoseconds, 0),
+        method!(RbExpr::dt_total_nanoseconds, 1),
     )?;
     class.define_method(
         "dt_total_microseconds",
-        method!(RbExpr::dt_total_microseconds, 0),
+        method!(RbExpr::dt_total_microseconds, 1),
     )?;
     class.define_method(
         "dt_total_milliseconds",
-        method!(RbExpr::dt_total_milliseconds, 0),
+        method!(RbExpr::dt_total_milliseconds, 1),
     )?;
     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",
         method!(RbExpr::dt_convert_time_zone, 1),
@@ -427,13 +475,13 @@ 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))?;
-    class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
-    class.define_method("mode", method!(RbExpr::mode, 0))?;
-    class.define_method("exclude", method!(RbExpr::exclude, 1))?;
+    class.define_method("reinterpret", method!(RbExpr::reinterpret, 2))?;
+    class.define_method("mode", method!(RbExpr::mode, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
+    class.define_method("interpolate_by", method!(RbExpr::interpolate_by, 1))?;
     class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 4))?;
     class.define_method("rolling_sum_by", method!(RbExpr::rolling_sum_by, 4))?;
     class.define_method("rolling_min", method!(RbExpr::rolling_min, 4))?;
@@ -453,7 +501,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "rolling_quantile_by",
         method!(RbExpr::rolling_quantile_by, 6),
     )?;
-    class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
+    class.define_method("rolling_rank", method!(RbExpr::rolling_rank, 5))?;
+    class.define_method("rolling_rank_by", method!(RbExpr::rolling_rank_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("rolling_map", method!(RbExpr::rolling_map, 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))?;
@@ -466,24 +518,27 @@ 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, 1))?;
-    class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
-    class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
+    class.define_method("list_sort", method!(RbExpr::list_sort, 2))?;
+    class.define_method("list_set_operation", method!(RbExpr::list_set_operation, 2))?;
     class.define_method("list_get", method!(RbExpr::list_get, 2))?;
     class.define_method("list_join", method!(RbExpr::list_join, 2))?;
     class.define_method("list_arg_min", method!(RbExpr::list_arg_min, 0))?;
     class.define_method("list_arg_max", method!(RbExpr::list_arg_max, 0))?;
-    class.define_method("list_all", method!(RbExpr::list_all, 0))?;
-    class.define_method("list_any", method!(RbExpr::list_any, 0))?;
     class.define_method("list_diff", method!(RbExpr::list_diff, 2))?;
     class.define_method("list_shift", method!(RbExpr::list_shift, 1))?;
     class.define_method("list_slice", method!(RbExpr::list_slice, 2))?;
-    class.define_method("list_eval", method!(RbExpr::list_eval, 2))?;
-    class.define_method("cumulative_eval", method!(RbExpr::cumulative_eval, 3))?;
-    class.define_method("list_to_struct", method!(RbExpr::list_to_struct, 3))?;
+    class.define_method("list_eval", method!(RbExpr::list_eval, 1))?;
+    class.define_method("list_agg", method!(RbExpr::list_agg, 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, 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 +546,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,15 +558,21 @@ 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))?;
     class.define_method("any", method!(RbExpr::any, 1))?;
     class.define_method("all", method!(RbExpr::all, 1))?;
+    class.define_method("is_empty", method!(RbExpr::is_empty, 1))?;
     class.define_method(
         "struct_field_by_name",
         method!(RbExpr::struct_field_by_name, 1),
     )?;
+    class.define_method(
+        "struct_multiple_fields",
+        method!(RbExpr::struct_multiple_fields, 1),
+    )?;
     class.define_method(
         "struct_field_by_index",
         method!(RbExpr::struct_field_by_index, 1),
@@ -516,16 +582,54 @@ 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("set_sorted_flag", method!(RbExpr::set_sorted_flag, 2))?;
     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, 0))?;
+    class.define_method("meta_pop", method!(RbExpr::meta_pop, 1))?;
     class.define_method("meta_eq", method!(RbExpr::meta_eq, 1))?;
     class.define_method("meta_roots", method!(RbExpr::meta_root_names, 0))?;
     class.define_method("meta_output_name", method!(RbExpr::meta_output_name, 0))?;
@@ -539,11 +643,13 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "meta_is_regex_projection",
         method!(RbExpr::meta_is_regex_projection, 0),
     )?;
-    class.define_method("_meta_selector_add", method!(RbExpr::_meta_selector_add, 1))?;
-    class.define_method("_meta_selector_sub", method!(RbExpr::_meta_selector_sub, 1))?;
-    class.define_method("_meta_selector_and", method!(RbExpr::_meta_selector_and, 1))?;
-    class.define_method("_meta_as_selector", method!(RbExpr::_meta_as_selector, 0))?;
-    class.define_method("meta_tree_format", method!(RbExpr::meta_tree_format, 0))?;
+    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))?;
+    class.define_method("meta_show_graph", method!(RbExpr::meta_show_graph, 1))?;
 
     // name
     class.define_method("name_keep", method!(RbExpr::name_keep, 0))?;
@@ -552,37 +658,45 @@ 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_replace", method!(RbExpr::name_replace, 3))?;
+    class.define_method("name_map_fields", method!(RbExpr::name_map_fields, 1))?;
+    class.define_method("name_prefix_fields", method!(RbExpr::name_prefix_fields, 1))?;
+    class.define_method("name_suffix_fields", method!(RbExpr::name_suffix_fields, 1))?;
+
+    // extension
+    class.define_method("ext_storage", method!(RbExpr::ext_storage, 0))?;
+    class.define_method("ext_to", method!(RbExpr::ext_to, 1))?;
 
     // maybe add to different class
     let class = module.define_module("Plr")?;
-    class.define_singleton_method("dtype_cols", function!(functions::lazy::dtype_cols, 1))?;
-    class.define_singleton_method("index_cols", function!(functions::lazy::index_cols, 1))?;
     class.define_singleton_method("col", function!(functions::lazy::col, 1))?;
+    class.define_singleton_method("element", function!(functions::lazy::element, 0))?;
     class.define_singleton_method("len", function!(functions::lazy::len, 0))?;
-    class.define_singleton_method("first", function!(functions::lazy::first, 0))?;
-    class.define_singleton_method("last", function!(functions::lazy::last, 0))?;
-    class.define_singleton_method("cols", function!(functions::lazy::cols, 1))?;
-    class.define_singleton_method("fold", function!(functions::lazy::fold, 3))?;
-    class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 4))?;
-    class.define_singleton_method("lit", function!(functions::lazy::lit, 2))?;
+    class.define_singleton_method("fold", function!(functions::lazy::fold, 5))?;
+    class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 6))?;
+    class.define_singleton_method("cum_reduce", function!(functions::lazy::cum_reduce, 4))?;
+    class.define_singleton_method("datetime", function!(functions::lazy::datetime, 10))?;
+    class.define_singleton_method("lit", function!(functions::lazy::lit, 3))?;
     class.define_singleton_method("int_range", function!(functions::range::int_range, 4))?;
     class.define_singleton_method("int_ranges", function!(functions::range::int_ranges, 4))?;
     class.define_singleton_method("repeat", function!(functions::lazy::repeat, 3))?;
-    class.define_singleton_method("pearson_corr", function!(functions::lazy::pearson_corr, 3))?;
+    class.define_singleton_method("map_expr", function!(functions::lazy::map_expr, 5))?;
+    class.define_singleton_method("pearson_corr", function!(functions::lazy::pearson_corr, 2))?;
+    class.define_singleton_method("reduce", function!(functions::lazy::reduce, 4))?;
     class.define_singleton_method(
         "spearman_rank_corr",
-        function!(functions::lazy::spearman_rank_corr, 4),
+        function!(functions::lazy::spearman_rank_corr, 3),
     )?;
     class.define_singleton_method("sql_expr", function!(functions::lazy::sql_expr, 1))?;
     class.define_singleton_method("cov", function!(functions::lazy::cov, 3))?;
     class.define_singleton_method("arctan2", function!(functions::lazy::arctan2, 2))?;
-    class.define_singleton_method("arctan2d", function!(functions::lazy::arctan2d, 2))?;
     class.define_singleton_method("rolling_corr", function!(functions::lazy::rolling_corr, 5))?;
     class.define_singleton_method("rolling_cov", function!(functions::lazy::rolling_cov, 5))?;
     class.define_singleton_method("arg_sort_by", function!(functions::lazy::arg_sort_by, 5))?;
     class.define_singleton_method("when", function!(functions::whenthen::when, 1))?;
     class.define_singleton_method("concat_str", function!(functions::lazy::concat_str, 3))?;
     class.define_singleton_method("concat_list", function!(functions::lazy::concat_list, 1))?;
+    class.define_singleton_method("concat_arr", function!(functions::lazy::concat_arr, 1))?;
     class.define_singleton_method(
         "business_day_count",
         function!(functions::business::business_day_count, 4),
@@ -605,19 +719,24 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method(
         "sum_horizontal",
-        function!(functions::aggregation::sum_horizontal, 1),
+        function!(functions::aggregation::sum_horizontal, 2),
     )?;
     class.define_singleton_method(
         "mean_horizontal",
-        function!(functions::aggregation::mean_horizontal, 1),
+        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(
         "concat_lf_diagonal",
         function!(functions::lazy::concat_lf_diagonal, 4),
     )?;
+    class.define_singleton_method(
+        "concat_lf_horizontal",
+        function!(functions::lazy::concat_lf_horizontal, 3),
+    )?;
     class.define_singleton_method("concat_df", function!(functions::eager::concat_df, 1))?;
     class.define_singleton_method("concat_lf", function!(functions::lazy::concat_lf, 4))?;
     class.define_singleton_method(
@@ -626,7 +745,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method(
         "concat_df_horizontal",
-        function!(functions::eager::concat_df_horizontal, 1),
+        function!(functions::eager::concat_df_horizontal, 2),
     )?;
     class.define_singleton_method(
         "concat_series",
@@ -634,11 +753,20 @@ 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, 3),
+    )?;
     class.define_singleton_method(
         "parquet_schema",
         function!(functions::io::read_parquet_schema, 1),
     )?;
-    class.define_singleton_method("collect_all", function!(functions::lazy::collect_all, 1))?;
+    class.define_singleton_method("collect_all", function!(functions::lazy::collect_all, 3))?;
+    class.define_singleton_method("explain_all", function!(functions::lazy::explain_all, 2))?;
+    class.define_singleton_method(
+        "collect_all_lazy",
+        function!(functions::lazy::collect_all_lazy, 2),
+    )?;
     class.define_singleton_method("date_range", function!(functions::range::date_range, 4))?;
     class.define_singleton_method("date_ranges", function!(functions::range::date_ranges, 4))?;
     class.define_singleton_method(
@@ -651,6 +779,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method("time_range", function!(functions::range::time_range, 4))?;
     class.define_singleton_method("time_ranges", function!(functions::range::time_ranges, 4))?;
+    class.define_singleton_method("linear_space", function!(functions::range::linear_space, 4))?;
+    class.define_singleton_method(
+        "linear_spaces",
+        function!(functions::range::linear_spaces, 5),
+    )?;
     class.define_singleton_method(
         "dtype_str_repr",
         function!(functions::misc::dtype_str_repr, 1),
@@ -660,20 +793,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(functions::meta::get_index_type, 0),
     )?;
     class.define_singleton_method(
-        "threadpool_size",
-        function!(functions::meta::threadpool_size, 0),
-    )?;
-    class.define_singleton_method(
-        "enable_string_cache",
-        function!(functions::string_cache::enable_string_cache, 0),
-    )?;
-    class.define_singleton_method(
-        "disable_string_cache",
-        function!(functions::string_cache::disable_string_cache, 0),
-    )?;
-    class.define_singleton_method(
-        "using_string_cache",
-        function!(functions::string_cache::using_string_cache, 0),
+        "thread_pool_size",
+        function!(functions::meta::thread_pool_size, 0),
     )?;
     class.define_singleton_method(
         "set_float_fmt",
@@ -720,39 +841,98 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(functions::random::set_random_seed, 1),
     )?;
     class.define_singleton_method("re_escape", function!(re_escape, 1))?;
+    class.define_singleton_method(
+        "escape_regex",
+        function!(functions::strings::escape_regex, 1),
+    )?;
+    class.define_singleton_method(
+        "assert_dataframe_equal_rb",
+        function!(testing::assert_dataframe_equal_rb, 9),
+    )?;
+    class.define_singleton_method(
+        "assert_series_equal_rb",
+        function!(testing::assert_series_equal_rb, 9),
+    )?;
+    class.define_singleton_method(
+        "get_engine_affinity",
+        function!(functions::utils::rb_get_engine_affinity, 0),
+    )?;
+    class.define_singleton_method(
+        "polars_schema_to_rbcapsule",
+        function!(interop::arrow::to_rb::polars_schema_to_rbcapsule, 1),
+    )?;
+    class.define_singleton_method(
+        "init_polars_schema_from_arrow_c_schema",
+        function!(interop::arrow::init_polars_schema_from_arrow_c_schema, 2),
+    )?;
 
     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),
+    )?;
+    class.define_method("serialize_json", method!(RbLazyFrame::serialize_json, 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),
+        function!(RbLazyFrame::new_from_ndjson, -1),
     )?;
     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, -1),
+        function!(RbLazyFrame::new_from_parquet, 6),
+    )?;
+    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 3))?;
+    class.define_singleton_method(
+        "new_from_scan_lines",
+        function!(RbLazyFrame::new_from_scan_lines, 3),
     )?;
-    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 10))?;
-    class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
     class.define_method("describe_plan", method!(RbLazyFrame::describe_plan, 0))?;
     class.define_method(
         "describe_optimized_plan",
         method!(RbLazyFrame::describe_optimized_plan, 0),
     )?;
     class.define_method(
-        "optimization_toggle",
-        method!(RbLazyFrame::optimization_toggle, 9),
+        "describe_plan_tree",
+        method!(RbLazyFrame::describe_plan_tree, 0),
+    )?;
+    class.define_method(
+        "describe_optimized_plan_tree",
+        method!(RbLazyFrame::describe_optimized_plan_tree, 0),
+    )?;
+    class.define_method("to_dot", method!(RbLazyFrame::to_dot, 1))?;
+    class.define_method(
+        "to_dot_streaming_phys",
+        method!(RbLazyFrame::to_dot_streaming_phys, 1),
     )?;
     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, 7))?;
-    class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 3))?;
-    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, 15))?;
-    class.define_method("sink_json", method!(RbLazyFrame::sink_json, 2))?;
-    class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
+    class.define_method(
+        "with_optimizations",
+        method!(RbLazyFrame::with_optimizations, 1),
+    )?;
+    class.define_method("profile", method!(RbLazyFrame::profile, 0))?;
+    class.define_method("collect", method!(RbLazyFrame::collect, 1))?;
+    class.define_method("collect_batches", method!(RbLazyFrame::collect_batches, 4))?;
+    class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 9))?;
+    class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 6))?;
+    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, -1))?;
+    class.define_method("sink_ndjson", method!(RbLazyFrame::sink_ndjson, 5))?;
+    class.define_method("sink_batches", method!(RbLazyFrame::sink_batches, 3))?;
     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))?;
@@ -761,15 +941,21 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "group_by_dynamic",
         method!(RbLazyFrame::group_by_dynamic, 9),
     )?;
-    class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
-    class.define_method("join_asof", method!(RbLazyFrame::join_asof, 12))?;
-    class.define_method("join", method!(RbLazyFrame::join, 10))?;
+    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("gather", method!(RbLazyFrame::gather, 2))?;
     class.define_method("with_column", method!(RbLazyFrame::with_column, 1))?;
     class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
     class.define_method(
         "with_columns_seq",
         method!(RbLazyFrame::with_columns_seq, 1),
     )?;
+    class.define_method("match_to_schema", method!(RbLazyFrame::match_to_schema, 7))?;
+    class.define_method(
+        "pipe_with_schema",
+        method!(RbLazyFrame::pipe_with_schema, 1),
+    )?;
     class.define_method("rename", method!(RbLazyFrame::rename, 3))?;
     class.define_method("reverse", method!(RbLazyFrame::reverse, 0))?;
     class.define_method("shift", method!(RbLazyFrame::shift, 2))?;
@@ -782,27 +968,52 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("var", method!(RbLazyFrame::var, 1))?;
     class.define_method("median", method!(RbLazyFrame::median, 0))?;
     class.define_method("quantile", method!(RbLazyFrame::quantile, 2))?;
-    class.define_method("explode", method!(RbLazyFrame::explode, 1))?;
+    class.define_method("explode", method!(RbLazyFrame::explode, 3))?;
     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))?;
+    class.define_method("pivot", method!(RbLazyFrame::pivot, 8))?;
     class.define_method("unpivot", method!(RbLazyFrame::unpivot, 4))?;
     class.define_method("with_row_index", method!(RbLazyFrame::with_row_index, 2))?;
+    class.define_method("map_batches", method!(RbLazyFrame::map_batches, 7))?;
     class.define_method("drop", method!(RbLazyFrame::drop, 1))?;
     class.define_method("cast", method!(RbLazyFrame::cast, 2))?;
     class.define_method("cast_all", method!(RbLazyFrame::cast_all, 2))?;
     class.define_method("_clone", method!(RbLazyFrame::clone, 0))?;
     class.define_method("collect_schema", method!(RbLazyFrame::collect_schema, 0))?;
-    class.define_method("unnest", method!(RbLazyFrame::unnest, 1))?;
+    class.define_method("unnest", method!(RbLazyFrame::unnest, 2))?;
     class.define_method("count", method!(RbLazyFrame::count, 0))?;
-    class.define_method("merge_sorted", method!(RbLazyFrame::merge_sorted, 2))?;
+    class.define_method("merge_sorted", method!(RbLazyFrame::merge_sorted, 3))?;
+    class.define_method("hint_sorted", method!(RbLazyFrame::hint_sorted, 3))?;
+    class.define_method(
+        "collect_concurrently",
+        method!(RbLazyFrame::collect_concurrently, 0),
+    )?;
+
+    let class = module.define_class("RbCollectBatches", ruby.class_object())?;
+    class.define_method("next", method!(RbCollectBatches::next, 0))?;
+    class.define_method(
+        "arrow_c_stream",
+        method!(RbCollectBatches::__arrow_c_stream__, 0),
+    )?;
+
+    let class = module.define_class("RbInProcessQuery", ruby.class_object())?;
+    class.define_method("cancel", method!(RbInProcessQuery::cancel, 0))?;
+    class.define_method("fetch", method!(RbInProcessQuery::fetch, 0))?;
+    class.define_method(
+        "fetch_blocking",
+        method!(RbInProcessQuery::fetch_blocking, 0),
+    )?;
 
     let class = module.define_class("RbLazyGroupBy", ruby.class_object())?;
+    class.define_method("having", method!(RbLazyGroupBy::having, 1))?;
     class.define_method("agg", method!(RbLazyGroupBy::agg, 1))?;
     class.define_method("head", method!(RbLazyGroupBy::head, 1))?;
     class.define_method("tail", method!(RbLazyGroupBy::tail, 1))?;
+    class.define_method("map_groups", method!(RbLazyGroupBy::map_groups, 2))?;
 
     let class = module.define_class("RbSeries", ruby.class_object())?;
     class.define_singleton_method("new_opt_bool", function!(RbSeries::new_opt_bool, 3))?;
@@ -810,12 +1021,15 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_opt_u16", function!(RbSeries::new_opt_u16, 3))?;
     class.define_singleton_method("new_opt_u32", function!(RbSeries::new_opt_u32, 3))?;
     class.define_singleton_method("new_opt_u64", function!(RbSeries::new_opt_u64, 3))?;
+    class.define_singleton_method("new_opt_u128", function!(RbSeries::new_opt_u128, 3))?;
     class.define_singleton_method("new_opt_i8", function!(RbSeries::new_opt_i8, 3))?;
     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("new_opt_f16", function!(RbSeries::new_opt_f16, 3))?;
     class.define_singleton_method(
         "new_from_any_values",
         function!(RbSeries::new_from_any_values, 3),
@@ -829,9 +1043,8 @@ fn init(ruby: &Ruby) -> 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_array", function!(RbSeries::new_array, 4))?;
     class.define_singleton_method("new_decimal", function!(RbSeries::new_decimal, 3))?;
-    class.define_singleton_method("repeat", function!(RbSeries::repeat, 4))?;
     class.define_singleton_method(
         "from_arrow_c_stream",
         function!(RbSeries::from_arrow_c_stream, 1),
@@ -857,9 +1070,11 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("cat_is_local", method!(RbSeries::cat_is_local, 0))?;
     class.define_method("cat_to_local", method!(RbSeries::cat_to_local, 0))?;
     class.define_method("estimated_size", method!(RbSeries::estimated_size, 0))?;
+    class.define_method("reshape", method!(RbSeries::reshape, 1))?;
     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))?;
@@ -867,12 +1082,17 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("name", method!(RbSeries::name, 0))?;
     class.define_method("rename", method!(RbSeries::rename, 1))?;
     class.define_method("dtype", method!(RbSeries::dtype, 0))?;
-    class.define_method("inner_dtype", method!(RbSeries::inner_dtype, 0))?;
     class.define_method("set_sorted", method!(RbSeries::set_sorted_flag, 1))?;
     class.define_method("mean", method!(RbSeries::mean, 0))?;
     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, 1))?;
+    class.define_method("last", method!(RbSeries::last, 1))?;
+    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))?;
@@ -888,13 +1108,15 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("slice", method!(RbSeries::slice, 2))?;
     class.define_method("any", method!(RbSeries::any, 1))?;
     class.define_method("all", method!(RbSeries::all, 1))?;
+    class.define_method("is_empty", method!(RbSeries::is_empty, 1))?;
     class.define_method("arg_min", method!(RbSeries::arg_min, 0))?;
     class.define_method("arg_max", method!(RbSeries::arg_max, 0))?;
-    class.define_method("take_with_series", method!(RbSeries::take_with_series, 1))?;
+    class.define_method(
+        "gather_with_series",
+        method!(RbSeries::gather_with_series, 1),
+    )?;
     class.define_method("null_count", method!(RbSeries::null_count, 0))?;
     class.define_method("has_nulls", method!(RbSeries::has_nulls, 0))?;
-    class.define_method("sample_n", method!(RbSeries::sample_n, 4))?;
-    class.define_method("sample_frac", method!(RbSeries::sample_frac, 4))?;
     class.define_method("equals", method!(RbSeries::equals, 4))?;
     class.define_method("eq", method!(RbSeries::eq, 1))?;
     class.define_method("neq", method!(RbSeries::neq, 1))?;
@@ -902,24 +1124,35 @@ 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("to_s", method!(RbSeries::to_s, 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("list_to_struct", method!(RbSeries::list_to_struct, 2))?;
+    class.define_method("str_json_decode", method!(RbSeries::str_json_decode, 1))?;
+    class.define_method("to_s", method!(RbSeries::as_str, 0))?;
     class.define_method("len", method!(RbSeries::len, 0))?;
     class.define_method("to_a", method!(RbSeries::to_a, 0))?;
     class.define_method("median", method!(RbSeries::median, 0))?;
     class.define_method("quantile", method!(RbSeries::quantile, 2))?;
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
-    class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
+    class.define_method("map_elements", method!(RbSeries::map_elements, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
-    class.define_method("to_dummies", method!(RbSeries::to_dummies, 2))?;
+    class.define_method("to_dummies", method!(RbSeries::to_dummies, 3))?;
     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))?;
     class.define_method("dot", method!(RbSeries::dot, 1))?;
     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("time_unit", method!(RbSeries::time_unit, 0))?;
+    class.define_method("cast", method!(RbSeries::cast, 3))?;
+    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("head", method!(RbSeries::head, 1))?;
+    class.define_method("tail", method!(RbSeries::tail, 1))?;
     class.define_method("scatter", method!(RbSeries::scatter, 2))?;
 
     // set
@@ -1004,6 +1237,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("eq_i16", method!(RbSeries::eq_i16, 1))?;
     class.define_method("eq_i32", method!(RbSeries::eq_i32, 1))?;
     class.define_method("eq_i64", method!(RbSeries::eq_i64, 1))?;
+    class.define_method("eq_i128", method!(RbSeries::eq_i128, 1))?;
     class.define_method("eq_f32", method!(RbSeries::eq_f32, 1))?;
     class.define_method("eq_f64", method!(RbSeries::eq_f64, 1))?;
 
@@ -1016,6 +1250,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("neq_i16", method!(RbSeries::neq_i16, 1))?;
     class.define_method("neq_i32", method!(RbSeries::neq_i32, 1))?;
     class.define_method("neq_i64", method!(RbSeries::neq_i64, 1))?;
+    class.define_method("neq_i128", method!(RbSeries::neq_i128, 1))?;
     class.define_method("neq_f32", method!(RbSeries::neq_f32, 1))?;
     class.define_method("neq_f64", method!(RbSeries::neq_f64, 1))?;
 
@@ -1028,6 +1263,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("gt_i16", method!(RbSeries::gt_i16, 1))?;
     class.define_method("gt_i32", method!(RbSeries::gt_i32, 1))?;
     class.define_method("gt_i64", method!(RbSeries::gt_i64, 1))?;
+    class.define_method("gt_i128", method!(RbSeries::gt_i128, 1))?;
     class.define_method("gt_f32", method!(RbSeries::gt_f32, 1))?;
     class.define_method("gt_f64", method!(RbSeries::gt_f64, 1))?;
 
@@ -1040,6 +1276,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("gt_eq_i16", method!(RbSeries::gt_eq_i16, 1))?;
     class.define_method("gt_eq_i32", method!(RbSeries::gt_eq_i32, 1))?;
     class.define_method("gt_eq_i64", method!(RbSeries::gt_eq_i64, 1))?;
+    class.define_method("gt_eq_i128", method!(RbSeries::gt_eq_i128, 1))?;
     class.define_method("gt_eq_f32", method!(RbSeries::gt_eq_f32, 1))?;
     class.define_method("gt_eq_f64", method!(RbSeries::gt_eq_f64, 1))?;
 
@@ -1052,6 +1289,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("lt_i16", method!(RbSeries::lt_i16, 1))?;
     class.define_method("lt_i32", method!(RbSeries::lt_i32, 1))?;
     class.define_method("lt_i64", method!(RbSeries::lt_i64, 1))?;
+    class.define_method("lt_i128", method!(RbSeries::lt_i128, 1))?;
     class.define_method("lt_f32", method!(RbSeries::lt_f32, 1))?;
     class.define_method("lt_f64", method!(RbSeries::lt_f64, 1))?;
 
@@ -1064,6 +1302,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("lt_eq_i16", method!(RbSeries::lt_eq_i16, 1))?;
     class.define_method("lt_eq_i32", method!(RbSeries::lt_eq_i32, 1))?;
     class.define_method("lt_eq_i64", method!(RbSeries::lt_eq_i64, 1))?;
+    class.define_method("lt_eq_i128", method!(RbSeries::lt_eq_i128, 1))?;
     class.define_method("lt_eq_f32", method!(RbSeries::lt_eq_f32, 1))?;
     class.define_method("lt_eq_f64", method!(RbSeries::lt_eq_f64, 1))?;
 
@@ -1078,9 +1317,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     // npy
     class.define_method("to_numo", method!(RbSeries::to_numo, 0))?;
 
-    // extra
-    class.define_method("extend_constant", method!(RbSeries::extend_constant, 2))?;
-
     // when then
     let class = module.define_class("RbWhen", ruby.class_object())?;
     class.define_method("then", method!(RbWhen::then, 1))?;
@@ -1104,13 +1340,186 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("register", method!(RbSQLContext::register, 2))?;
     class.define_method("unregister", method!(RbSQLContext::unregister, 1))?;
 
-    // string cache
-    let class = module.define_class("RbStringCacheHolder", ruby.class_object())?;
-    class.define_singleton_method("hold", function!(RbStringCacheHolder::hold, 0))?;
-
     // arrow array stream
-    let class = module.define_class("RbArrowArrayStream", ruby.class_object())?;
+    let class = module.define_class("ArrowArrayStream", ruby.class_object())?;
     class.define_method("to_i", method!(RbArrowArrayStream::to_i, 0))?;
 
+    // arrow schema
+    let class = module.define_class("ArrowSchema", ruby.class_object())?;
+    class.define_method("to_i", method!(RbArrowSchema::to_i, 0))?;
+
+    // catalog
+    let class = module.define_class("RbCatalogClient", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbCatalogClient::new, 2))?;
+    class.define_singleton_method(
+        "type_json_to_polars_type",
+        function!(RbCatalogClient::type_json_to_polars_type, 1),
+    )?;
+    class.define_method("list_catalogs", method!(RbCatalogClient::list_catalogs, 0))?;
+    class.define_method(
+        "list_namespaces",
+        method!(RbCatalogClient::list_namespaces, 1),
+    )?;
+    class.define_method("list_tables", method!(RbCatalogClient::list_tables, 2))?;
+    class.define_method(
+        "get_table_info",
+        method!(RbCatalogClient::get_table_info, 3),
+    )?;
+    class.define_method(
+        "create_catalog",
+        method!(RbCatalogClient::create_catalog, 3),
+    )?;
+    class.define_method(
+        "delete_catalog",
+        method!(RbCatalogClient::delete_catalog, 2),
+    )?;
+    class.define_method(
+        "create_namespace",
+        method!(RbCatalogClient::create_namespace, 4),
+    )?;
+    class.define_method(
+        "delete_namespace",
+        method!(RbCatalogClient::delete_namespace, 3),
+    )?;
+    class.define_method("create_table", method!(RbCatalogClient::create_table, 9))?;
+    class.define_method("delete_table", method!(RbCatalogClient::delete_table, 3))?;
+
+    // categories
+    let class = module.define_class("RbCategories", ruby.class_object())?;
+    class.define_singleton_method(
+        "global_categories",
+        function!(RbCategories::global_categories, 0),
+    )?;
+
+    // data type expr
+    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_singleton_method("self_dtype", function!(RbDataTypeExpr::self_dtype, 0))?;
+    class.define_method("collect_dtype", method!(RbDataTypeExpr::collect_dtype, 1))?;
+    class.define_singleton_method(
+        "struct_with_fields",
+        function!(RbDataTypeExpr::struct_with_fields, 1),
+    )?;
+
+    // selector
+    let class = module.define_class("RbSelector", ruby.class_object())?;
+    class.define_method("union", method!(RbSelector::union, 1))?;
+    class.define_method("difference", method!(RbSelector::difference, 1))?;
+    class.define_method("exclusive_or", method!(RbSelector::exclusive_or, 1))?;
+    class.define_method("intersect", method!(RbSelector::intersect, 1))?;
+    class.define_singleton_method("by_dtype", function!(RbSelector::by_dtype, 1))?;
+    class.define_singleton_method("by_name", function!(RbSelector::by_name, 3))?;
+    class.define_singleton_method("by_index", function!(RbSelector::by_index, 2))?;
+    class.define_singleton_method("first", function!(RbSelector::first, 1))?;
+    class.define_singleton_method("last", function!(RbSelector::last, 1))?;
+    class.define_singleton_method("matches", function!(RbSelector::matches, 1))?;
+    class.define_singleton_method("enum_", function!(RbSelector::enum_, 0))?;
+    class.define_singleton_method("categorical", function!(RbSelector::categorical, 0))?;
+    class.define_singleton_method("nested", function!(RbSelector::nested, 0))?;
+    class.define_singleton_method("list", function!(RbSelector::list, 1))?;
+    class.define_singleton_method("array", function!(RbSelector::array, 2))?;
+    class.define_singleton_method("struct_", function!(RbSelector::struct_, 0))?;
+    class.define_singleton_method("integer", function!(RbSelector::integer, 0))?;
+    class.define_singleton_method("signed_integer", function!(RbSelector::signed_integer, 0))?;
+    class.define_singleton_method(
+        "unsigned_integer",
+        function!(RbSelector::unsigned_integer, 0),
+    )?;
+    class.define_singleton_method("float", function!(RbSelector::float, 0))?;
+    class.define_singleton_method("decimal", function!(RbSelector::decimal, 0))?;
+    class.define_singleton_method("numeric", function!(RbSelector::numeric, 0))?;
+    class.define_singleton_method("temporal", function!(RbSelector::temporal, 0))?;
+    class.define_singleton_method("datetime", function!(RbSelector::datetime, 2))?;
+    class.define_singleton_method("duration", function!(RbSelector::duration, 1))?;
+    class.define_singleton_method("object", function!(RbSelector::object, 0))?;
+    class.define_singleton_method("empty", function!(RbSelector::empty, 0))?;
+    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("type_coercion", method!(RbOptFlags::get_type_coercion, 0))?;
+    class.define_method("type_coercion=", method!(RbOptFlags::set_type_coercion, 1))?;
+    class.define_method("type_check", method!(RbOptFlags::get_type_check, 0))?;
+    class.define_method("type_check=", method!(RbOptFlags::set_type_check, 1))?;
+    class.define_method(
+        "projection_pushdown",
+        method!(RbOptFlags::get_projection_pushdown, 0),
+    )?;
+    class.define_method(
+        "projection_pushdown=",
+        method!(RbOptFlags::set_projection_pushdown, 1),
+    )?;
+    class.define_method(
+        "predicate_pushdown",
+        method!(RbOptFlags::get_predicate_pushdown, 0),
+    )?;
+    class.define_method(
+        "predicate_pushdown=",
+        method!(RbOptFlags::set_predicate_pushdown, 1),
+    )?;
+    class.define_method(
+        "cluster_with_columns",
+        method!(RbOptFlags::get_cluster_with_columns, 0),
+    )?;
+    class.define_method(
+        "cluster_with_columns=",
+        method!(RbOptFlags::set_cluster_with_columns, 1),
+    )?;
+    class.define_method(
+        "simplify_expression",
+        method!(RbOptFlags::get_simplify_expression, 0),
+    )?;
+    class.define_method(
+        "simplify_expression=",
+        method!(RbOptFlags::set_simplify_expression, 1),
+    )?;
+    class.define_method("slice_pushdown", method!(RbOptFlags::get_slice_pushdown, 0))?;
+    class.define_method(
+        "slice_pushdown=",
+        method!(RbOptFlags::set_slice_pushdown, 1),
+    )?;
+    class.define_method(
+        "comm_subplan_elim",
+        method!(RbOptFlags::get_comm_subplan_elim, 0),
+    )?;
+    class.define_method(
+        "comm_subplan_elim=",
+        method!(RbOptFlags::set_comm_subplan_elim, 1),
+    )?;
+    class.define_method(
+        "comm_subexpr_elim",
+        method!(RbOptFlags::get_comm_subexpr_elim, 0),
+    )?;
+    class.define_method(
+        "comm_subexpr_elim=",
+        method!(RbOptFlags::set_comm_subexpr_elim, 1),
+    )?;
+    class.define_method(
+        "check_order_observe",
+        method!(RbOptFlags::get_check_order_observe, 0),
+    )?;
+    class.define_method(
+        "check_order_observe=",
+        method!(RbOptFlags::set_check_order_observe, 1),
+    )?;
+    class.define_method(
+        "fast_projection",
+        method!(RbOptFlags::get_fast_projection, 0),
+    )?;
+    class.define_method(
+        "fast_projection=",
+        method!(RbOptFlags::set_fast_projection, 1),
+    )?;
+    class.define_method("eager", method!(RbOptFlags::get_eager, 0))?;
+    class.define_method("eager=", method!(RbOptFlags::set_eager, 1))?;
+    class.define_method("streaming", method!(RbOptFlags::get_streaming, 0))?;
+    class.define_method("streaming=", method!(RbOptFlags::set_streaming, 1))?;
+
     Ok(())
 }