polars-df 0.5.0 → 0.7.0

data/ext/polars/src/series.rs

@@ -5,15 +5,14 @@ mod construction;
 mod export;
 mod set_at_idx;
 
-use magnus::{exception, Error, IntoValue, RArray, Value, QNIL};
+use magnus::{exception, prelude::*, value::qnil, Error, IntoValue, RArray, Value};
 use polars::prelude::*;
 use polars::series::IsSorted;
 use std::cell::RefCell;
 
-use crate::apply::series::{call_lambda_and_extract, ApplyLambda};
 use crate::apply_method_all_arrow_series2;
 use crate::conversion::*;
-use crate::series::set_at_idx::set_at_idx;
+use crate::map::series::{call_lambda_and_extract, ApplyLambda};
 use crate::{RbDataFrame, RbPolarsErr, RbResult};
 
 #[magnus::wrap(class = "Polars::RbSeries")]
@@ -38,7 +37,7 @@ impl RbSeries {
 pub fn to_series_collection(rs: RArray) -> RbResult<Vec<Series>> {
     let mut series = Vec::new();
     for item in rs.each() {
-        series.push(item?.try_convert::<&RbSeries>()?.series.borrow().clone());
+        series.push(<&RbSeries>::try_convert(item?)?.series.borrow().clone());
     }
     Ok(series)
 }
@@ -303,7 +302,7 @@ impl RbSeries {
     pub fn to_a(&self) -> Value {
         let series = &self.series.borrow();
 
-        fn to_list_recursive(series: &Series) -> Value {
+        fn to_a_recursive(series: &Series) -> Value {
             let rblist = match series.dtype() {
                 DataType::Boolean => RArray::from_iter(series.bool().unwrap()).into_value(),
                 DataType::UInt8 => RArray::from_iter(series.u8().unwrap()).into_value(),
@@ -325,7 +324,7 @@ impl RbSeries {
                         let obj: Option<&ObjectValue> = series.get_object(i).map(|any| any.into());
                         match obj {
                             Some(val) => v.push(val.to_object()).unwrap(),
-                            None => v.push(QNIL).unwrap(),
+                            None => v.push(qnil()).unwrap(),
                         };
                     }
                     v.into_value()
@@ -333,13 +332,29 @@ impl RbSeries {
                 DataType::List(_) => {
                     let v = RArray::new();
                     let ca = series.list().unwrap();
+                    for opt_s in unsafe { ca.amortized_iter() } {
+                        match opt_s {
+                            None => {
+                                v.push(qnil()).unwrap();
+                            }
+                            Some(s) => {
+                                let rblst = to_a_recursive(s.as_ref());
+                                v.push(rblst).unwrap();
+                            }
+                        }
+                    }
+                    v.into_value()
+                }
+                DataType::Array(_, _) => {
+                    let v = RArray::new();
+                    let ca = series.array().unwrap();
                     for opt_s in ca.amortized_iter() {
                         match opt_s {
                             None => {
-                                v.push(QNIL).unwrap();
+                                v.push(qnil()).unwrap();
                             }
                             Some(s) => {
-                                let rblst = to_list_recursive(s.as_ref());
+                                let rblst = to_a_recursive(s.as_ref());
                                 v.push(rblst).unwrap();
                             }
                         }
@@ -347,18 +362,20 @@ impl RbSeries {
                     v.into_value()
                 }
                 DataType::Date => {
-                    let a = RArray::with_capacity(series.len());
-                    for v in series.iter() {
-                        a.push::<Value>(Wrap(v).into_value()).unwrap();
-                    }
-                    return a.into_value();
+                    let ca = series.date().unwrap();
+                    return Wrap(ca).into_value();
+                }
+                DataType::Time => {
+                    let ca = series.time().unwrap();
+                    return Wrap(ca).into_value();
                 }
                 DataType::Datetime(_, _) => {
-                    let a = RArray::with_capacity(series.len());
-                    for v in series.iter() {
-                        a.push::<Value>(Wrap(v).into_value()).unwrap();
-                    }
-                    return a.into_value();
+                    let ca = series.datetime().unwrap();
+                    return Wrap(ca).into_value();
+                }
+                DataType::Decimal(_, _) => {
+                    let ca = series.decimal().unwrap();
+                    return Wrap(ca).into_value();
                 }
                 DataType::Utf8 => {
                     let ca = series.utf8().unwrap();
@@ -376,15 +393,37 @@ impl RbSeries {
                     let ca = series.binary().unwrap();
                     return Wrap(ca).into_value();
                 }
-                DataType::Null | DataType::Unknown => {
+                DataType::Null => {
+                    let null: Option<u8> = None;
+                    let n = series.len();
+                    let iter = std::iter::repeat(null).take(n);
+                    use std::iter::{Repeat, Take};
+                    struct NullIter {
+                        iter: Take<Repeat<Option<u8>>>,
+                        n: usize,
+                    }
+                    impl Iterator for NullIter {
+                        type Item = Option<u8>;
+
+                        fn next(&mut self) -> Option<Self::Item> {
+                            self.iter.next()
+                        }
+                        fn size_hint(&self) -> (usize, Option<usize>) {
+                            (self.n, Some(self.n))
+                        }
+                    }
+                    impl ExactSizeIterator for NullIter {}
+
+                    RArray::from_iter(NullIter { iter, n }).into_value()
+                }
+                DataType::Unknown => {
                     panic!("to_a not implemented for null/unknown")
                 }
-                _ => todo!(),
             };
             rblist
         }
 
-        to_list_recursive(series)
+        to_a_recursive(series)
     }
 
     pub fn clone(&self) -> Self {
@@ -594,23 +633,15 @@ impl RbSeries {
         Ok(RbSeries::new(s))
     }
 
-    pub fn to_dummies(&self, sep: Option<String>) -> RbResult<RbDataFrame> {
+    pub fn to_dummies(&self, sep: Option<String>, drop_first: bool) -> RbResult<RbDataFrame> {
         let df = self
             .series
             .borrow()
-            .to_dummies(sep.as_deref())
+            .to_dummies(sep.as_deref(), drop_first)
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
 
-    pub fn peak_max(&self) -> Self {
-        self.series.borrow().peak_max().into_series().into()
-    }
-
-    pub fn peak_min(&self) -> Self {
-        self.series.borrow().peak_min().into_series().into()
-    }
-
     pub fn n_unique(&self) -> RbResult<usize> {
         let n = self.series.borrow().n_unique().map_err(RbPolarsErr::from)?;
         Ok(n)
@@ -668,17 +699,6 @@ impl RbSeries {
             None
         }
     }
-
-    pub fn set_at_idx(&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()) {
-            Ok(out) => {
-                *s = out;
-                Ok(())
-            }
-            Err(e) => Err(RbPolarsErr::from(e)),
-        }
-    }
 }
 
 macro_rules! impl_set_with_mask {

data/ext/polars/src/sql.rs

@@ -0,0 +1,46 @@
+use polars::sql::SQLContext;
+use std::cell::RefCell;
+
+use crate::{RbLazyFrame, RbPolarsErr, RbResult};
+
+#[magnus::wrap(class = "Polars::RbSQLContext")]
+#[repr(transparent)]
+#[derive(Clone)]
+pub struct RbSQLContext {
+    pub context: RefCell<SQLContext>,
+}
+
+#[allow(
+    clippy::wrong_self_convention,
+    clippy::should_implement_trait,
+    clippy::len_without_is_empty
+)]
+impl RbSQLContext {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> RbSQLContext {
+        RbSQLContext {
+            context: SQLContext::new().into(),
+        }
+    }
+
+    pub fn execute(&self, query: String) -> RbResult<RbLazyFrame> {
+        Ok(self
+            .context
+            .borrow_mut()
+            .execute(&query)
+            .map_err(RbPolarsErr::from)?
+            .into())
+    }
+
+    pub fn get_tables(&self) -> RbResult<Vec<String>> {
+        Ok(self.context.borrow().get_tables())
+    }
+
+    pub fn register(&self, name: String, lf: &RbLazyFrame) {
+        self.context.borrow_mut().register(&name, lf.ldf.clone())
+    }
+
+    pub fn unregister(&self, name: String) {
+        self.context.borrow_mut().unregister(&name)
+    }
+}

data/lib/polars/array_expr.rb

@@ -0,0 +1,84 @@
+module Polars
+  # Namespace for array related expressions.
+  class ArrayExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Compute the min values of the sub-arrays.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"a" => [[1, 2], [4, 3]]},
+    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #   )
+    #   df.select(Polars.col("a").arr.min)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 1   │
+    #   # │ 3   │
+    #   # └─────┘
+    def min
+      Utils.wrap_expr(_rbexpr.array_min)
+    end
+
+    # Compute the max values of the sub-arrays.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"a" => [[1, 2], [4, 3]]},
+    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #   )
+    #   df.select(Polars.col("a").arr.max)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 2   │
+    #   # │ 4   │
+    #   # └─────┘
+    def max
+      Utils.wrap_expr(_rbexpr.array_max)
+    end
+
+    # Compute the sum values of the sub-arrays.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"a" => [[1, 2], [4, 3]]},
+    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #   )
+    #   df.select(Polars.col("a").arr.sum)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 3   │
+    #   # │ 7   │
+    #   # └─────┘
+    def sum
+      Utils.wrap_expr(_rbexpr.array_sum)
+    end
+  end
+end

data/lib/polars/array_name_space.rb

@@ -0,0 +1,77 @@
+module Polars
+  # Series.arr namespace.
+  class ArrayNameSpace
+    include ExprDispatch
+
+    self._accessor = "arr"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Compute the min values of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(2, Polars::Int64)
+    #   )
+    #   s.arr.min
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         3
+    #   # ]
+    def min
+      super
+    end
+
+    # Compute the max values of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(
+    #     "a", [[1, 2], [4, 3]], dtype: Polars::Array.new(2, Polars::Int64)
+    #   )
+    #   s.arr.max
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   #         4
+    #   # ]
+    def max
+      super
+    end
+
+    # Compute the sum values of the sub-arrays.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"a" => [[1, 2], [4, 3]]},
+    #     schema: {"a" => Polars::Array.new(2, Polars::Int64)}
+    #   )
+    #   df.select(Polars.col("a").arr.sum)
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 3   │
+    #   # │ 7   │
+    #   # └─────┘
+    def sum
+      super
+    end
+  end
+end

data/lib/polars/batched_csv_reader.rb

@@ -41,7 +41,7 @@ module Polars
           dtypes.each do|k, v|
             dtype_list << [k, Utils.rb_type_to_dtype(v)]
           end
-        elsif dtypes.is_a?(Array)
+        elsif dtypes.is_a?(::Array)
           dtype_slice = dtypes
         else
           raise ArgumentError, "dtype arg should be list or dict"