polars-df 0.7.0 → 0.8.0

data/ext/polars/src/lazyframe.rs

@@ -87,7 +87,7 @@ impl RbLazyFrame {
         let cache = bool::try_convert(arguments[6])?;
         let overwrite_dtype = Option::<Vec<(String, Wrap<DataType>)>>::try_convert(arguments[7])?;
         let low_memory = bool::try_convert(arguments[8])?;
-        let comment_char = Option::<String>::try_convert(arguments[9])?;
+        let comment_prefix = Option::<String>::try_convert(arguments[9])?;
         let quote_char = Option::<String>::try_convert(arguments[10])?;
         let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[11])?;
         let infer_schema_length = Option::<usize>::try_convert(arguments[12])?;
@@ -101,7 +101,6 @@ impl RbLazyFrame {
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
-        let comment_char = comment_char.map(|s| s.as_bytes()[0]);
         let quote_char = quote_char.map(|s| s.as_bytes()[0]);
         let separator = separator.as_bytes()[0];
         let eol_char = eol_char.as_bytes()[0];
@@ -124,7 +123,7 @@ impl RbLazyFrame {
             .with_cache(cache)
             .with_dtype_overwrite(overwrite_dtype.as_ref())
             .low_memory(low_memory)
-            .with_comment_char(comment_char)
+            .with_comment_prefix(comment_prefix.as_deref())
             .with_quote_char(quote_char)
             .with_end_of_line_char(eol_char)
             .with_rechunk(rechunk)
@@ -510,48 +509,58 @@ impl RbLazyFrame {
         ldf.fill_nan(fill_value.inner.clone()).into()
     }
 
-    pub fn min(&self) -> Self {
+    pub fn min(&self) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.min().into()
+        let out = ldf.min().map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
-    pub fn max(&self) -> Self {
+    pub fn max(&self) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.max().into()
+        let out = ldf.max().map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
-    pub fn sum(&self) -> Self {
+    pub fn sum(&self) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.sum().into()
+        let out = ldf.sum().map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
-    pub fn mean(&self) -> Self {
+    pub fn mean(&self) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.mean().into()
+        let out = ldf.mean().map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
-    pub fn std(&self, ddof: u8) -> Self {
+    pub fn std(&self, ddof: u8) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.std(ddof).into()
+        let out = ldf.std(ddof).map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
-    pub fn var(&self, ddof: u8) -> Self {
+    pub fn var(&self, ddof: u8) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.var(ddof).into()
+        let out = ldf.var(ddof).map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
-    pub fn median(&self) -> Self {
+    pub fn median(&self) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.median().into()
+        let out = ldf.median().map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
     pub fn quantile(
         &self,
         quantile: &RbExpr,
         interpolation: Wrap<QuantileInterpolOptions>,
-    ) -> Self {
+    ) -> RbResult<Self> {
         let ldf = self.ldf.clone();
-        ldf.quantile(quantile.inner.clone(), interpolation.0).into()
+        let out = ldf
+            .quantile(quantile.inner.clone(), interpolation.0)
+            .map_err(RbPolarsErr::from)?;
+        Ok(out.into())
     }
 
     pub fn explode(&self, column: RArray) -> RbResult<Self> {

data/ext/polars/src/lib.rs

@@ -8,6 +8,7 @@ mod functions;
 mod lazyframe;
 mod lazygroupby;
 mod map;
+mod on_startup;
 mod object;
 mod prelude;
 pub(crate) mod rb_modules;
@@ -224,8 +225,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("drop", method!(RbDataFrame::drop, 1))?;
     class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
     class.define_method(
-        "find_idx_by_name",
-        method!(RbDataFrame::find_idx_by_name, 1),
+        "get_column_index",
+        method!(RbDataFrame::get_column_index, 1),
     )?;
     class.define_method("column", method!(RbDataFrame::column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
@@ -235,14 +236,14 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbDataFrame::take_with_series, 1),
     )?;
     class.define_method("replace", method!(RbDataFrame::replace, 2))?;
-    class.define_method("replace_at_idx", method!(RbDataFrame::replace_at_idx, 2))?;
-    class.define_method("insert_at_idx", method!(RbDataFrame::insert_at_idx, 2))?;
+    class.define_method("replace_column", method!(RbDataFrame::replace_column, 2))?;
+    class.define_method("insert_column", method!(RbDataFrame::insert_column, 2))?;
     class.define_method("slice", method!(RbDataFrame::slice, 2))?;
     class.define_method("head", method!(RbDataFrame::head, 1))?;
     class.define_method("tail", method!(RbDataFrame::tail, 1))?;
     class.define_method("is_unique", method!(RbDataFrame::is_unique, 0))?;
     class.define_method("is_duplicated", method!(RbDataFrame::is_duplicated, 0))?;
-    class.define_method("frame_equal", method!(RbDataFrame::frame_equal, 2))?;
+    class.define_method("equals", method!(RbDataFrame::equals, 2))?;
     class.define_method("with_row_count", method!(RbDataFrame::with_row_count, 2))?;
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
@@ -250,18 +251,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
     class.define_method("shift", method!(RbDataFrame::shift, 1))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
-    class.define_method("max", method!(RbDataFrame::max, 0))?;
-    class.define_method("min", method!(RbDataFrame::min, 0))?;
-    class.define_method("sum", method!(RbDataFrame::sum, 0))?;
-    class.define_method("mean", method!(RbDataFrame::mean, 0))?;
-    class.define_method("std", method!(RbDataFrame::std, 1))?;
-    class.define_method("var", method!(RbDataFrame::var, 1))?;
-    class.define_method("median", method!(RbDataFrame::median, 0))?;
     class.define_method("mean_horizontal", method!(RbDataFrame::mean_horizontal, 1))?;
     class.define_method("max_horizontal", method!(RbDataFrame::max_horizontal, 0))?;
     class.define_method("min_horizontal", method!(RbDataFrame::min_horizontal, 0))?;
     class.define_method("sum_horizontal", method!(RbDataFrame::sum_horizontal, 1))?;
-    class.define_method("quantile", method!(RbDataFrame::quantile, 2))?;
     class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
     class.define_method("apply", method!(RbDataFrame::apply, 3))?;
@@ -309,8 +302,14 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("last", method!(RbExpr::last, 0))?;
     class.define_method("implode", method!(RbExpr::implode, 0))?;
     class.define_method("quantile", method!(RbExpr::quantile, 2))?;
+    class.define_method("cut", method!(RbExpr::cut, 4))?;
+    class.define_method("qcut", method!(RbExpr::qcut, 5))?;
+    class.define_method("qcut_uniform", method!(RbExpr::qcut_uniform, 5))?;
+    class.define_method("rle", method!(RbExpr::rle, 0))?;
+    class.define_method("rle_id", method!(RbExpr::rle_id, 0))?;
     class.define_method("agg_groups", method!(RbExpr::agg_groups, 0))?;
     class.define_method("count", method!(RbExpr::count, 0))?;
+    class.define_method("len", method!(RbExpr::len, 0))?;
     class.define_method("value_counts", method!(RbExpr::value_counts, 2))?;
     class.define_method("unique_counts", method!(RbExpr::unique_counts, 0))?;
     class.define_method("null_count", method!(RbExpr::null_count, 0))?;
@@ -346,7 +345,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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("gather_every", method!(RbExpr::gather_every, 1))?;
+    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))?;
@@ -518,10 +517,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("rolling_min", method!(RbExpr::rolling_min, 6))?;
     class.define_method("rolling_max", method!(RbExpr::rolling_max, 6))?;
     class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 6))?;
-    class.define_method("rolling_std", method!(RbExpr::rolling_std, 7))?;
-    class.define_method("rolling_var", method!(RbExpr::rolling_var, 7))?;
-    class.define_method("rolling_median", method!(RbExpr::rolling_median, 6))?;
-    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 8))?;
+    class.define_method("rolling_std", method!(RbExpr::rolling_std, 8))?;
+    class.define_method("rolling_var", method!(RbExpr::rolling_var, 8))?;
+    class.define_method("rolling_median", method!(RbExpr::rolling_median, 7))?;
+    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 9))?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
@@ -550,6 +549,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("kurtosis", method!(RbExpr::kurtosis, 2))?;
     class.define_method("str_concat", method!(RbExpr::str_concat, 2))?;
     class.define_method("cat_set_ordering", method!(RbExpr::cat_set_ordering, 1))?;
+    class.define_method("cat_get_categories", method!(RbExpr::cat_get_categories, 0))?;
     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))?;
@@ -792,7 +792,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("has_validity", method!(RbSeries::has_validity, 0))?;
     class.define_method("sample_n", method!(RbSeries::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbSeries::sample_frac, 4))?;
-    class.define_method("series_equal", method!(RbSeries::series_equal, 3))?;
+    class.define_method("equals", method!(RbSeries::equals, 3))?;
     class.define_method("eq", method!(RbSeries::eq, 1))?;
     class.define_method("neq", method!(RbSeries::neq, 1))?;
     class.define_method("gt", method!(RbSeries::gt, 1))?;
@@ -817,7 +817,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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("set_at_idx", method!(RbSeries::set_at_idx, 2))?;
+    class.define_method("scatter", method!(RbSeries::scatter, 2))?;
 
     // set
     // class.define_method("set_with_mask_str", method!(RbSeries::set_with_mask_str, 2))?;

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

@@ -187,7 +187,7 @@ pub fn apply_lambda_with_utf8_out_type(
     lambda: Value,
     init_null_count: usize,
     first_value: Option<&str>,
-) -> Utf8Chunked {
+) -> StringChunked {
     let skip = usize::from(first_value.is_some());
     if init_null_count == df.height() {
         ChunkedArray::full_null("apply", df.height())

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

@@ -198,11 +198,11 @@ fn iterator_to_utf8(
     first_value: Option<&str>,
     name: &str,
     capacity: usize,
-) -> Utf8Chunked {
+) -> StringChunked {
     let first_value = first_value.map(|v| v.to_string());
 
     // safety: we know the iterators len
-    let mut ca: Utf8Chunked = unsafe {
+    let mut ca: StringChunked = unsafe {
         if init_null_count > 0 {
             (0..init_null_count)
                 .map(|_| None)

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

@@ -101,7 +101,7 @@ pub trait ApplyLambda<'a> {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked>;
+    ) -> RbResult<StringChunked>;
 
     /// Apply a lambda with list output type
     fn apply_lambda_with_list_out_type(
@@ -285,7 +285,7 @@ impl<'a> ApplyLambda<'a> for BooleanChunked {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let skip = usize::from(first_value.is_some());
         if init_null_count == self.len() {
             Ok(ChunkedArray::full_null(self.name(), self.len()))
@@ -562,7 +562,7 @@ where
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let skip = usize::from(first_value.is_some());
         if init_null_count == self.len() {
             Ok(ChunkedArray::full_null(self.name(), self.len()))
@@ -705,7 +705,7 @@ where
     }
 }
 
-impl<'a> ApplyLambda<'a> for Utf8Chunked {
+impl<'a> ApplyLambda<'a> for StringChunked {
     fn apply_lambda_unknown(&'a self, lambda: Value) -> RbResult<RbSeries> {
         let mut null_count = 0;
         for opt_v in self.into_iter() {
@@ -834,7 +834,7 @@ impl<'a> ApplyLambda<'a> for Utf8Chunked {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let skip = usize::from(first_value.is_some());
         if init_null_count == self.len() {
             Ok(ChunkedArray::full_null(self.name(), self.len()))
@@ -1079,7 +1079,7 @@ impl<'a> ApplyLambda<'a> for StructChunked {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let names = self.fields().iter().map(|s| s.name()).collect::<Vec<_>>();
 
         let skip = usize::from(first_value.is_some());

data/ext/polars/src/object.rs

@@ -1,31 +1 @@
-use std::any::Any;
-use std::sync::Arc;
-
-use magnus::IntoValue;
-use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
-use polars_core::chunked_array::object::registry;
-use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
-use polars_core::prelude::AnyValue;
-
-use crate::prelude::ObjectValue;
-use crate::Wrap;
-
 pub(crate) const OBJECT_NAME: &str = "object";
-
-pub(crate) fn register_object_builder() {
-    if !registry::is_object_builder_registered() {
-        let object_builder = Box::new(|name: &str, capacity: usize| {
-            Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
-                as Box<dyn AnonymousObjectBuilder>
-        });
-
-        let object_converter = Arc::new(|av: AnyValue| {
-            let object = ObjectValue {
-                inner: Wrap(av).into_value().into(),
-            };
-            Box::new(object) as Box<dyn Any>
-        });
-
-        registry::register_object_builder(object_builder, object_converter)
-    }
-}

data/ext/polars/src/on_startup.rs

@@ -0,0 +1,32 @@
+use std::any::Any;
+use std::sync::Arc;
+
+use magnus::IntoValue;
+use polars::prelude::*;
+use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
+use polars_core::chunked_array::object::registry;
+use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
+use polars_core::prelude::AnyValue;
+
+use crate::prelude::ObjectValue;
+use crate::Wrap;
+
+pub(crate) fn register_object_builder() {
+    if !registry::is_object_builder_registered() {
+        let object_builder = Box::new(|name: &str, capacity: usize| {
+            Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
+                as Box<dyn AnonymousObjectBuilder>
+        });
+
+        let object_converter = Arc::new(|av: AnyValue| {
+            let object = ObjectValue {
+                inner: Wrap(av).into_value().into(),
+            };
+            Box::new(object) as Box<dyn Any>
+        });
+
+        let object_size = std::mem::size_of::<ObjectValue>();
+        let physical_dtype = ArrowDataType::FixedSizeBinary(object_size);
+        registry::register_object_builder(object_builder, object_converter, physical_dtype)
+    }
+}

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

@@ -17,6 +17,7 @@ impl RbSeries {
             self.series
                 .borrow()
                 .max_as_series()
+                .map_err(RbPolarsErr::from)?
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )
@@ -48,6 +49,7 @@ impl RbSeries {
             self.series
                 .borrow()
                 .min_as_series()
+                .map_err(RbPolarsErr::from)?
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )
@@ -75,6 +77,7 @@ impl RbSeries {
             self.series
                 .borrow()
                 .sum_as_series()
+                .map_err(RbPolarsErr::from)?
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )

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

@@ -106,7 +106,7 @@ impl RbSeries {
         Ok(s.into())
     }
 
-    pub fn new_str(name: String, val: Wrap<Utf8Chunked>, _strict: bool) -> Self {
+    pub fn new_str(name: String, val: Wrap<StringChunked>, _strict: bool) -> Self {
         let mut s = val.0.into_series();
         s.rename(&name);
         RbSeries::new(s)

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

@@ -9,8 +9,8 @@ impl RbSeries {
     pub fn to_numo(&self) -> RbResult<Value> {
         let s = &self.series.borrow();
         match s.dtype() {
-            DataType::Utf8 => {
-                let ca = s.utf8().unwrap();
+            DataType::String => {
+                let ca = s.str().unwrap();
 
                 // TODO make more efficient
                 let np_arr = RArray::from_iter(ca);

data/ext/polars/src/{series.rs → series/mod.rs}

@@ -3,7 +3,7 @@ mod arithmetic;
 mod comparison;
 mod construction;
 mod export;
-mod set_at_idx;
+mod scatter;
 
 use magnus::{exception, prelude::*, value::qnil, Error, IntoValue, RArray, Value};
 use polars::prelude::*;
@@ -80,7 +80,7 @@ impl RbSeries {
 
     pub fn get_fmt(&self, index: usize, str_lengths: usize) -> String {
         let val = format!("{}", self.series.borrow().get(index).unwrap());
-        if let DataType::Utf8 | DataType::Categorical(_) = self.series.borrow().dtype() {
+        if let DataType::String | DataType::Categorical(_, _) = self.series.borrow().dtype() {
             let v_trunc = &val[..val
                 .char_indices()
                 .take(str_lengths)
@@ -90,7 +90,7 @@ impl RbSeries {
             if val == v_trunc {
                 val
             } else {
-                format!("{}...", v_trunc)
+                format!("{}…", v_trunc)
             }
         } else {
             val
@@ -273,15 +273,13 @@ impl RbSeries {
         Ok(s.into())
     }
 
-    pub fn series_equal(&self, other: &RbSeries, null_equal: bool, strict: bool) -> bool {
+    pub fn equals(&self, other: &RbSeries, null_equal: bool, strict: bool) -> bool {
         if strict {
             self.series.borrow().eq(&other.series.borrow())
         } else if null_equal {
-            self.series
-                .borrow()
-                .series_equal_missing(&other.series.borrow())
+            self.series.borrow().equals_missing(&other.series.borrow())
         } else {
-            self.series.borrow().series_equal(&other.series.borrow())
+            self.series.borrow().equals(&other.series.borrow())
         }
     }
 
@@ -315,10 +313,10 @@ impl RbSeries {
                 DataType::Int64 => RArray::from_iter(series.i64().unwrap()).into_value(),
                 DataType::Float32 => RArray::from_iter(series.f32().unwrap()).into_value(),
                 DataType::Float64 => RArray::from_iter(series.f64().unwrap()).into_value(),
-                DataType::Categorical(_) => {
+                DataType::Categorical(_, _) => {
                     RArray::from_iter(series.categorical().unwrap().iter_str()).into_value()
                 }
-                DataType::Object(_) => {
+                DataType::Object(_, _) => {
                     let v = RArray::with_capacity(series.len());
                     for i in 0..series.len() {
                         let obj: Option<&ObjectValue> = series.get_object(i).map(|any| any.into());
@@ -377,8 +375,8 @@ impl RbSeries {
                     let ca = series.decimal().unwrap();
                     return Wrap(ca).into_value();
                 }
-                DataType::Utf8 => {
-                    let ca = series.utf8().unwrap();
+                DataType::String => {
+                    let ca = series.str().unwrap();
                     return Wrap(ca).into_value();
                 }
                 DataType::Struct(_) => {
@@ -442,7 +440,7 @@ impl RbSeries {
 
         macro_rules! dispatch_apply {
             ($self:expr, $method:ident, $($args:expr),*) => {
-                if matches!($self.dtype(), DataType::Object(_)) {
+                if matches!($self.dtype(), DataType::Object(_, _)) {
                     // let ca = $self.0.unpack::<ObjectType<ObjectValue>>().unwrap();
                     // ca.$method($($args),*)
                     todo!()
@@ -463,7 +461,7 @@ impl RbSeries {
             DataType::Datetime(_, _)
                 | DataType::Date
                 | DataType::Duration(_)
-                | DataType::Categorical(_)
+                | DataType::Categorical(_, _)
                 | DataType::Time
         ) || !skip_nulls
         {
@@ -604,12 +602,12 @@ impl RbSeries {
                 )?;
                 ca.into_datetime(tu, tz).into_series()
             }
-            Some(DataType::Utf8) => {
+            Some(DataType::String) => {
                 let ca = dispatch_apply!(series, apply_lambda_with_utf8_out_type, lambda, 0, None)?;
 
                 ca.into_series()
             }
-            Some(DataType::Object(_)) => {
+            Some(DataType::Object(_, _)) => {
                 let ca =
                     dispatch_apply!(series, apply_lambda_with_object_out_type, lambda, 0, None)?;
                 ca.into_series()
@@ -656,8 +654,13 @@ impl RbSeries {
         self.series.borrow_mut().shrink_to_fit();
     }
 
-    pub fn dot(&self, other: &RbSeries) -> Option<f64> {
-        self.series.borrow().dot(&other.series.borrow())
+    pub fn dot(&self, other: &RbSeries) -> RbResult<f64> {
+        let out = self
+            .series
+            .borrow()
+            .dot(&other.series.borrow())
+            .map_err(RbPolarsErr::from)?;
+        Ok(out)
     }
 
     pub fn skew(&self, bias: bool) -> RbResult<Option<f64>> {

data/ext/polars/src/series/{set_at_idx.rs → scatter.rs}

@@ -5,9 +5,9 @@ use crate::error::RbPolarsErr;
 use crate::{RbResult, RbSeries};
 
 impl RbSeries {
-    pub fn set_at_idx(&self, idx: &RbSeries, values: &RbSeries) -> RbResult<()> {
+    pub fn scatter(&self, idx: &RbSeries, values: &RbSeries) -> RbResult<()> {
         let mut s = self.series.borrow_mut();
-        match set_at_idx(s.clone(), &idx.series.borrow(), &values.series.borrow()) {
+        match scatter(s.clone(), &idx.series.borrow(), &values.series.borrow()) {
             Ok(out) => {
                 *s = out;
                 Ok(())
@@ -17,7 +17,7 @@ impl RbSeries {
     }
 }
 
-fn set_at_idx(mut s: Series, idx: &Series, values: &Series) -> PolarsResult<Series> {
+fn scatter(mut s: Series, idx: &Series, values: &Series) -> PolarsResult<Series> {
     let logical_dtype = s.dtype().clone();
     let idx = idx.cast(&IDX_DTYPE)?;
     let idx = idx.rechunk();
@@ -43,62 +43,62 @@ fn set_at_idx(mut s: Series, idx: &Series, values: &Series) -> PolarsResult<Seri
         DataType::Int8 => {
             let ca: &mut ChunkedArray<Int8Type> = mutable_s.as_mut();
             let values = values.i8()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::Int16 => {
             let ca: &mut ChunkedArray<Int16Type> = mutable_s.as_mut();
             let values = values.i16()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::Int32 => {
             let ca: &mut ChunkedArray<Int32Type> = mutable_s.as_mut();
             let values = values.i32()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::Int64 => {
             let ca: &mut ChunkedArray<Int64Type> = mutable_s.as_mut();
             let values = values.i64()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::UInt8 => {
             let ca: &mut ChunkedArray<UInt8Type> = mutable_s.as_mut();
             let values = values.u8()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::UInt16 => {
             let ca: &mut ChunkedArray<UInt16Type> = mutable_s.as_mut();
             let values = values.u16()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::UInt32 => {
             let ca: &mut ChunkedArray<UInt32Type> = mutable_s.as_mut();
             let values = values.u32()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::UInt64 => {
             let ca: &mut ChunkedArray<UInt64Type> = mutable_s.as_mut();
             let values = values.u64()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::Float32 => {
             let ca: &mut ChunkedArray<Float32Type> = mutable_s.as_mut();
             let values = values.f32()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::Float64 => {
             let ca: &mut ChunkedArray<Float64Type> = mutable_s.as_mut();
             let values = values.f64()?;
-            std::mem::take(ca).set_at_idx2(idx, values)
+            std::mem::take(ca).scatter(idx, values)
         }
         DataType::Boolean => {
             let ca = s.bool()?;
             let values = values.bool()?;
-            ca.set_at_idx2(idx, values)
+            ca.scatter(idx, values)
         }
-        DataType::Utf8 => {
-            let ca = s.utf8()?;
-            let values = values.utf8()?;
-            ca.set_at_idx2(idx, values)
+        DataType::String => {
+            let ca = s.str()?;
+            let values = values.str()?;
+            ca.scatter(idx, values)
         }
         _ => panic!("not yet implemented for dtype: {}", logical_dtype),
     };

data/ext/polars/src/utils.rs

@@ -23,7 +23,7 @@ macro_rules! apply_method_all_arrow_series2 {
     ($self:expr, $method:ident, $($args:expr),*) => {
         match $self.dtype() {
             DataType::Boolean => $self.bool().unwrap().$method($($args),*),
-            DataType::Utf8 => $self.utf8().unwrap().$method($($args),*),
+            DataType::String => $self.str().unwrap().$method($($args),*),
             DataType::UInt8 => $self.u8().unwrap().$method($($args),*),
             DataType::UInt16 => $self.u16().unwrap().$method($($args),*),
             DataType::UInt32 => $self.u32().unwrap().$method($($args),*),