polars-df 0.21.0 → 0.21.1

data/ext/polars/src/lib.rs

@@ -28,6 +28,7 @@ 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;
@@ -221,6 +222,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 +242,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 +254,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 +262,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,15 +272,20 @@ 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))?;
@@ -297,6 +307,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 +316,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 +346,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))?;
@@ -345,6 +370,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 +380,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 +394,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))?;
@@ -425,6 +462,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 +490,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 +503,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))?;
@@ -491,6 +535,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 +547,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,16 +566,45 @@ 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))?;
 
+    // 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))?;
     class.define_method("meta_eq", method!(RbExpr::meta_eq, 1))?;
@@ -541,6 +620,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 +634,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 +691,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 +718,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),
@@ -742,6 +833,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 +842,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 +854,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 +876,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))?;
@@ -855,7 +951,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 +966,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 +1001,7 @@ 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("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 +1018,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 +1258,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())?;

data/ext/polars/src/map/dataframe.rs

@@ -6,14 +6,14 @@ use polars_core::series::SeriesIter;
 use super::*;
 use crate::{RbDataFrame, RbPolarsErr, RbSeries, Wrap};
 
-fn get_iters(df: &DataFrame) -> Vec<SeriesIter> {
+fn get_iters(df: &DataFrame) -> Vec<SeriesIter<'_>> {
     df.get_columns()
         .iter()
         .map(|s| s.as_materialized_series().iter())
         .collect()
 }
 
-fn get_iters_skip(df: &DataFrame, skip: usize) -> Vec<std::iter::Skip<SeriesIter>> {
+fn get_iters_skip(df: &DataFrame, skip: usize) -> Vec<std::iter::Skip<SeriesIter<'_>>> {
     df.get_columns()
         .iter()
         .map(|s| s.as_materialized_series().iter().skip(skip))

data/ext/polars/src/map/series.rs

@@ -999,7 +999,7 @@ impl<'a> ApplyLambda<'a> for StringChunked {
     }
 }
 
-fn iter_struct(ca: &StructChunked) -> impl Iterator<Item = AnyValue> {
+fn iter_struct(ca: &StructChunked) -> impl Iterator<Item = AnyValue<'_>> {
     (0..ca.len()).map(|i| unsafe { ca.get_any_value_unchecked(i) })
 }
 

data/ext/polars/src/series/aggregation.rs

@@ -3,6 +3,10 @@ use crate::prelude::*;
 use crate::{RbResult, RbSeries};
 use magnus::{IntoValue, Value};
 
+fn scalar_to_rb(scalar: RbResult<Scalar>) -> RbResult<Value> {
+    Ok(Wrap(scalar?.as_any_value()).into_value())
+}
+
 impl RbSeries {
     pub fn any(&self, ignore_nulls: bool) -> RbResult<Option<bool>> {
         let binding = self.series.borrow();
@@ -118,4 +122,44 @@ impl RbSeries {
         )
         .into_value())
     }
+
+    pub fn first(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self.series.borrow().first()))
+    }
+
+    pub fn last(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self.series.borrow().last()))
+    }
+
+    pub fn approx_n_unique(&self) -> RbResult<IdxSize> {
+        Ok(self
+            .series
+            .borrow()
+            .approx_n_unique()
+            .map_err(RbPolarsErr::from)?)
+    }
+
+    pub fn bitwise_and(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self
+            .series
+            .borrow()
+            .and_reduce()
+            .map_err(RbPolarsErr::from)?))
+    }
+
+    pub fn bitwise_or(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self
+            .series
+            .borrow()
+            .or_reduce()
+            .map_err(RbPolarsErr::from)?))
+    }
+
+    pub fn bitwise_xor(&self) -> RbResult<Value> {
+        scalar_to_rb(Ok(self
+            .series
+            .borrow()
+            .xor_reduce()
+            .map_err(RbPolarsErr::from)?))
+    }
 }

data/ext/polars/src/series/general.rs

@@ -1,8 +1,11 @@
-use magnus::{Error, IntoValue, Value, exception};
+use magnus::{Error, IntoValue, RArray, Value, exception, value::ReprValue};
 use polars::prelude::*;
 use polars::series::IsSorted;
+use polars_core::utils::flatten::flatten_series;
 
 use crate::conversion::*;
+use crate::exceptions::RbIndexError;
+use crate::rb_modules;
 use crate::{RbDataFrame, RbPolarsErr, RbResult, RbSeries};
 
 impl RbSeries {
@@ -84,8 +87,39 @@ impl RbSeries {
         }
     }
 
-    pub fn get_idx(&self, idx: usize) -> RbResult<Value> {
-        Ok(Wrap(self.series.borrow().get(idx).map_err(RbPolarsErr::from)?).into_value())
+    pub fn get_index(&self, index: usize) -> RbResult<Value> {
+        let binding = self.series.borrow();
+        let av = match binding.get(index) {
+            Ok(v) => v,
+            Err(PolarsError::OutOfBounds(err)) => {
+                return Err(RbIndexError::new_err(err.to_string()));
+            }
+            Err(e) => return Err(RbPolarsErr::from(e).into()),
+        };
+
+        match av {
+            AnyValue::List(s) | AnyValue::Array(s, _) => {
+                let rbseries = RbSeries::new(s);
+                rb_modules::utils().funcall("wrap_s", (rbseries,))
+            }
+            _ => Ok(Wrap(av).into_value()),
+        }
+    }
+
+    pub fn get_index_signed(&self, index: isize) -> RbResult<Value> {
+        let index = if index < 0 {
+            match self.len().checked_sub(index.unsigned_abs()) {
+                Some(v) => v,
+                None => {
+                    return Err(RbIndexError::new_err(
+                        polars_err!(oob = index, self.len()).to_string(),
+                    ));
+                }
+            }
+        } else {
+            usize::try_from(index).unwrap()
+        };
+        self.get_index(index)
     }
 
     pub fn bitand(&self, other: &RbSeries) -> RbResult<Self> {
@@ -279,7 +313,7 @@ impl RbSeries {
         }
     }
 
-    pub fn not(&self) -> RbResult<Self> {
+    pub fn not_(&self) -> RbResult<Self> {
         let binding = self.series.borrow();
         let bool = binding.bool().map_err(RbPolarsErr::from)?;
         Ok((!bool).into_series().into())
@@ -370,6 +404,32 @@ impl RbSeries {
         Ok(out.into())
     }
 
+    pub fn get_chunks(&self) -> RbResult<RArray> {
+        flatten_series(&self.series.borrow())
+            .into_iter()
+            .map(|s| rb_modules::utils().funcall::<_, _, Value>("wrap_s", (Self::new(s),)))
+            .collect()
+    }
+
+    pub fn is_sorted(&self, descending: bool, nulls_last: bool) -> RbResult<bool> {
+        let options = SortOptions {
+            descending,
+            nulls_last,
+            multithreaded: true,
+            maintain_order: false,
+            limit: None,
+        };
+        Ok(self
+            .series
+            .borrow()
+            .is_sorted(options)
+            .map_err(RbPolarsErr::from)?)
+    }
+
+    pub fn clear(&self) -> Self {
+        self.series.borrow().clear().into()
+    }
+
     pub fn time_unit(&self) -> Option<String> {
         if let DataType::Datetime(tu, _) | DataType::Duration(tu) = self.series.borrow().dtype() {
             Some(