polars-df 0.1.5 → 0.2.0

data/Cargo.toml

@@ -3,8 +3,8 @@ members = ["ext/polars"]
 
 [patch.crates-io]
 jsonpath_lib = { git = "https://github.com/ritchie46/jsonpath", rev = "24eaf0b4416edff38a4d1b6b17bc4b9f3f047b4b" }
-magnus-macros = { git = "https://github.com/matsadler/magnus" }
-rb-sys-env = { git = "https://github.com/oxidize-rb/rb-sys" }
+halfbrown = { git = "https://github.com/Licenser/halfbrown", rev = "952023c5dd6461b009bb5ba66b9aa979bd75949f" }
+arrow2 = { git = "https://github.com/ankane/arrow2", rev = "9f36b2b97446e6dd495473e4361a70d863ac8027" }
 
 [profile.release]
 strip = true

data/LICENSE.txt

@@ -1,5 +1,5 @@
 Copyright (c) 2020 Ritchie Vink
-Copyright (c) 2022 Andrew Kane
+Copyright (c) 2022-2023 Andrew Kane
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -12,8 +12,6 @@ Add this line to your application’s Gemfile:
 gem "polars-df"
 ```
 
-Note: Rust is currently required for installation, and it can take 15-20 minutes to compile the extension.
-
 ## Getting Started
 
 This library follows the [Polars Python API](https://pola-rs.github.io/polars/py-polars/html/reference/index.html).

data/ext/polars/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "polars"
-version = "0.1.5"
+version = "0.2.0"
+license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
 publish = false
@@ -11,11 +12,11 @@ crate-type = ["cdylib"]
 [dependencies]
 ahash = "0.8"
 magnus = "0.4"
-polars-core = "0.25.1"
+polars-core = "0.26.1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "0.25.1"
+version = "0.26.1"
 features = [
     "abs",
     "arange",

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

@@ -1,20 +1,32 @@
 use magnus::{class, RArray, TryConvert, Value};
 use polars::prelude::*;
 use polars_core::frame::row::{rows_to_schema_first_non_null, Row};
+use polars_core::series::SeriesIter;
 
 use super::*;
 use crate::{RbDataFrame, RbPolarsErr, RbSeries, Wrap};
 
+fn get_iters(df: &DataFrame) -> Vec<SeriesIter> {
+    df.get_columns().iter().map(|s| s.iter()).collect()
+}
+
+fn get_iters_skip(df: &DataFrame, skip: usize) -> Vec<std::iter::Skip<SeriesIter>> {
+    df.get_columns()
+        .iter()
+        .map(|s| s.iter().skip(skip))
+        .collect()
+}
+
 pub fn apply_lambda_unknown<'a>(
     df: &'a DataFrame,
     lambda: Value,
     inference_size: usize,
 ) -> RbResult<(Value, bool)> {
-    let columns = df.get_columns();
     let mut null_count = 0;
+    let mut iters = get_iters(df);
 
-    for idx in 0..df.height() {
-        let iter = columns.iter().map(|s: &Series| Wrap(s.get(idx)));
+    for _ in 0..df.height() {
+        let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
         let arg = (iter.collect::<Vec<Wrap<AnyValue>>>(),);
         let out: Value = lambda.funcall("call", arg)?;
 
@@ -126,9 +138,9 @@ fn apply_iter<T>(
 where
     T: TryConvert,
 {
-    let columns = df.get_columns();
-    ((init_null_count + skip)..df.height()).map(move |idx| {
-        let iter = columns.iter().map(|s: &Series| Wrap(s.get(idx)));
+    let mut iters = get_iters_skip(df, init_null_count + skip);
+    ((init_null_count + skip)..df.height()).map(move |_| {
+        let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
         let tpl = (iter.collect::<Vec<Wrap<AnyValue>>>(),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => val.try_convert::<T>().ok(),
@@ -197,14 +209,13 @@ pub fn apply_lambda_with_list_out_type<'a>(
     first_value: Option<&Series>,
     dt: &DataType,
 ) -> RbResult<ListChunked> {
-    let columns = df.get_columns();
-
     let skip = usize::from(first_value.is_some());
     if init_null_count == df.height() {
         Ok(ChunkedArray::full_null("apply", df.height()))
     } else {
-        let iter = ((init_null_count + skip)..df.height()).map(|idx| {
-            let iter = columns.iter().map(|s: &Series| Wrap(s.get(idx)));
+        let mut iters = get_iters_skip(df, init_null_count + skip);
+        let iter = ((init_null_count + skip)..df.height()).map(|_| {
+            let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
             let tpl = (iter.collect::<Vec<Wrap<AnyValue>>>(),);
             match lambda.funcall::<_, _, Value>("call", tpl) {
                 Ok(val) => match val.funcall::<_, _, Value>("_s", ()) {
@@ -234,15 +245,15 @@ pub fn apply_lambda_with_rows_output<'a>(
     first_value: Row<'a>,
     inference_size: usize,
 ) -> PolarsResult<DataFrame> {
-    let columns = df.get_columns();
     let width = first_value.0.len();
     let null_row = Row::new(vec![AnyValue::Null; width]);
 
     let mut row_buf = Row::default();
 
     let skip = 1;
-    let mut row_iter = ((init_null_count + skip)..df.height()).map(|idx| {
-        let iter = columns.iter().map(|s: &Series| Wrap(s.get(idx)));
+    let mut iters = get_iters_skip(df, init_null_count + skip);
+    let mut row_iter = ((init_null_count + skip)..df.height()).map(|_| {
+        let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
         let tpl = (iter.collect::<Vec<Wrap<AnyValue>>>(),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => {

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

@@ -31,12 +31,11 @@ fn iterator_to_struct(
     capacity: usize,
 ) -> RbResult<RbSeries> {
     let (vals, flds) = match &first_value {
-        AnyValue::Struct(vals, flds) => (&**vals, *flds),
-        AnyValue::StructOwned(payload) => (&*payload.0, &*payload.1),
+        av @ AnyValue::Struct(_, _, flds) => (av._iter_struct_av().collect::<Vec<_>>(), &**flds),
+        AnyValue::StructOwned(payload) => (payload.0.clone(), &*payload.1),
         _ => {
             return Err(crate::error::ComputeError::new_err(format!(
-                "expected struct got {:?}",
-                first_value
+                "expected struct got {first_value:?}",
             )))
         }
     };

data/ext/polars/src/conversion.rs

@@ -1,9 +1,9 @@
-use magnus::{class, r_hash::ForEach, RArray, RHash, Symbol, TryConvert, Value, QNIL};
+use magnus::{class, r_hash::ForEach, Module, RArray, RHash, Symbol, TryConvert, Value, QNIL};
 use polars::chunked_array::object::PolarsObjectSafe;
 use polars::chunked_array::ops::{FillNullLimit, FillNullStrategy};
 use polars::datatypes::AnyValue;
 use polars::frame::row::Row;
-use polars::frame::DataFrame;
+use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
@@ -18,6 +18,12 @@ pub(crate) fn slice_to_wrapped<T>(slice: &[T]) -> &[Wrap<T>] {
     unsafe { std::mem::transmute(slice) }
 }
 
+pub(crate) fn vec_extract_wrapped<T>(buf: Vec<Wrap<T>>) -> Vec<T> {
+    // Safety:
+    // Wrap is transparent.
+    unsafe { std::mem::transmute(buf) }
+}
+
 #[repr(transparent)]
 pub struct Wrap<T>(pub T);
 
@@ -138,40 +144,127 @@ impl From<Wrap<AnyValue<'_>>> for Value {
 
 impl From<Wrap<DataType>> for Value {
     fn from(w: Wrap<DataType>) -> Self {
-        Symbol::from(w.0.to_string()).into()
+        let pl = crate::module();
+
+        match &w.0 {
+            DataType::Int8 => pl.const_get::<_, Value>("Int8").unwrap(),
+            DataType::Int16 => pl.const_get::<_, Value>("Int16").unwrap(),
+            DataType::Int32 => pl.const_get::<_, Value>("Int32").unwrap(),
+            DataType::Int64 => pl.const_get::<_, Value>("Int64").unwrap(),
+            DataType::UInt8 => pl.const_get::<_, Value>("UInt8").unwrap(),
+            DataType::UInt16 => pl.const_get::<_, Value>("UInt16").unwrap(),
+            DataType::UInt32 => pl.const_get::<_, Value>("UInt32").unwrap(),
+            DataType::UInt64 => pl.const_get::<_, Value>("UInt64").unwrap(),
+            DataType::Float32 => pl.const_get::<_, Value>("Float32").unwrap(),
+            DataType::Float64 => pl.const_get::<_, Value>("Float64").unwrap(),
+            DataType::Boolean => pl.const_get::<_, Value>("Boolean").unwrap(),
+            DataType::Utf8 => pl.const_get::<_, Value>("Utf8").unwrap(),
+            DataType::Binary => pl.const_get::<_, Value>("Binary").unwrap(),
+            DataType::List(inner) => {
+                let inner = Wrap(*inner.clone());
+                let list_class = pl.const_get::<_, Value>("List").unwrap();
+                list_class.funcall::<_, _, Value>("new", (inner,)).unwrap()
+            }
+            DataType::Date => pl.const_get::<_, Value>("Date").unwrap(),
+            DataType::Datetime(tu, tz) => {
+                let datetime_class = pl.const_get::<_, Value>("Datetime").unwrap();
+                datetime_class
+                    .funcall::<_, _, Value>("new", (tu.to_ascii(), tz.clone()))
+                    .unwrap()
+            }
+            DataType::Duration(tu) => {
+                let duration_class = pl.const_get::<_, Value>("Duration").unwrap();
+                duration_class
+                    .funcall::<_, _, Value>("new", (tu.to_ascii(),))
+                    .unwrap()
+            }
+            DataType::Object(_) => pl.const_get::<_, Value>("Object").unwrap(),
+            DataType::Categorical(_) => pl.const_get::<_, Value>("Categorical").unwrap(),
+            DataType::Time => pl.const_get::<_, Value>("Time").unwrap(),
+            DataType::Struct(fields) => {
+                let field_class = pl.const_get::<_, Value>("Field").unwrap();
+                let iter = fields.iter().map(|fld| {
+                    let name = fld.name().clone();
+                    let dtype = Wrap(fld.data_type().clone());
+                    field_class
+                        .funcall::<_, _, Value>("new", (name, dtype))
+                        .unwrap()
+                });
+                let fields = RArray::from_iter(iter);
+                let struct_class = pl.const_get::<_, Value>("Struct").unwrap();
+                struct_class
+                    .funcall::<_, _, Value>("new", (fields,))
+                    .unwrap()
+            }
+            DataType::Null => pl.const_get::<_, Value>("Null").unwrap(),
+            DataType::Unknown => pl.const_get::<_, Value>("Unknown").unwrap(),
+        }
     }
 }
 
 impl TryConvert for Wrap<DataType> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let dtype = match ob.try_convert::<String>()?.as_str() {
-            "u8" => DataType::UInt8,
-            "u16" => DataType::UInt16,
-            "u32" => DataType::UInt32,
-            "u64" => DataType::UInt64,
-            "i8" => DataType::Int8,
-            "i16" => DataType::Int16,
-            "i32" => DataType::Int32,
-            "i64" => DataType::Int64,
-            "str" => DataType::Utf8,
-            "bin" => DataType::Binary,
-            "bool" => DataType::Boolean,
-            "cat" => DataType::Categorical(None),
-            "date" => DataType::Date,
-            "datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
-            "f32" => DataType::Float32,
-            "time" => DataType::Time,
-            "dur" => DataType::Duration(TimeUnit::Microseconds),
-            "f64" => DataType::Float64,
-            // "obj" => DataType::Object(OBJECT_NAME),
-            "list" => DataType::List(Box::new(DataType::Boolean)),
-            "null" => DataType::Null,
-            "unk" => DataType::Unknown,
-            _ => {
-                return Err(RbValueError::new_err(format!(
-                    "{} is not a supported DataType.",
-                    ob
-                )))
+        let dtype = if ob.is_kind_of(class::class()) {
+            let name = ob.funcall::<_, _, String>("name", ())?;
+            match name.as_str() {
+                "Polars::UInt8" => DataType::UInt8,
+                "Polars::UInt16" => DataType::UInt16,
+                "Polars::UInt32" => DataType::UInt32,
+                "Polars::UInt64" => DataType::UInt64,
+                "Polars::Int8" => DataType::Int8,
+                "Polars::Int16" => DataType::Int16,
+                "Polars::Int32" => DataType::Int32,
+                "Polars::Int64" => DataType::Int64,
+                "Polars::Utf8" => DataType::Utf8,
+                "Polars::Binary" => DataType::Binary,
+                "Polars::Boolean" => DataType::Boolean,
+                "Polars::Categorical" => DataType::Categorical(None),
+                "Polars::Date" => DataType::Date,
+                "Polars::Datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
+                "Polars::Time" => DataType::Time,
+                "Polars::Duration" => DataType::Duration(TimeUnit::Microseconds),
+                "Polars::Float32" => DataType::Float32,
+                "Polars::Float64" => DataType::Float64,
+                // "Polars::Object" => DataType::Object(OBJECT_NAME),
+                "Polars::List" => DataType::List(Box::new(DataType::Boolean)),
+                "Polars::Null" => DataType::Null,
+                "Polars::Unknown" => DataType::Unknown,
+                dt => {
+                    return Err(RbValueError::new_err(format!(
+                        "{dt} is not a correct polars DataType.",
+                    )))
+                }
+            }
+        } else {
+            match ob.try_convert::<String>()?.as_str() {
+                "u8" => DataType::UInt8,
+                "u16" => DataType::UInt16,
+                "u32" => DataType::UInt32,
+                "u64" => DataType::UInt64,
+                "i8" => DataType::Int8,
+                "i16" => DataType::Int16,
+                "i32" => DataType::Int32,
+                "i64" => DataType::Int64,
+                "str" => DataType::Utf8,
+                "bin" => DataType::Binary,
+                "bool" => DataType::Boolean,
+                "cat" => DataType::Categorical(None),
+                "date" => DataType::Date,
+                "datetime" => DataType::Datetime(TimeUnit::Microseconds, None),
+                "f32" => DataType::Float32,
+                "time" => DataType::Time,
+                "dur" => DataType::Duration(TimeUnit::Microseconds),
+                "f64" => DataType::Float64,
+                // "obj" => DataType::Object(OBJECT_NAME),
+                "list" => DataType::List(Box::new(DataType::Boolean)),
+                "null" => DataType::Null,
+                "unk" => DataType::Unknown,
+                _ => {
+                    return Err(RbValueError::new_err(format!(
+                        "{} is not a supported DataType.",
+                        ob
+                    )))
+                }
             }
         };
         Ok(Wrap(dtype))
@@ -210,6 +303,21 @@ impl TryConvert for Wrap<AsofStrategy> {
     }
 }
 
+impl TryConvert for Wrap<InterpolationMethod> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match ob.try_convert::<String>()?.as_str() {
+            "linear" => InterpolationMethod::Linear,
+            "nearest" => InterpolationMethod::Nearest,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "method must be one of {{'linear', 'nearest'}}, got {v}",
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<Option<AvroCompression>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match ob.try_convert::<String>()?.as_str() {
@@ -243,6 +351,22 @@ impl TryConvert for Wrap<CategoricalOrdering> {
     }
 }
 
+impl TryConvert for Wrap<StartBy> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match ob.try_convert::<String>()?.as_str() {
+            "window" => StartBy::WindowBound,
+            "datapoint" => StartBy::DataPoint,
+            "monday" => StartBy::Monday,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "closed must be one of {{'window', 'datapoint', 'monday'}}, got {v}",
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<ClosedWindow> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match ob.try_convert::<String>()?.as_str() {

data/ext/polars/src/dataframe.rs

@@ -1,4 +1,5 @@
 use magnus::{r_hash::ForEach, RArray, RHash, RString, Value};
+use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
 use polars::io::mmap::ReaderBytes;
 use polars::io::RowCount;
@@ -397,7 +398,7 @@ impl RbDataFrame {
                         let obj: Option<&ObjectValue> = s.get_object(idx).map(|any| any.into());
                         obj.unwrap().to_object()
                     }
-                    _ => Wrap(s.get(idx)).into(),
+                    _ => Wrap(s.get(idx).unwrap()).into(),
                 })
                 .collect(),
         )
@@ -420,7 +421,7 @@ impl RbDataFrame {
                                         s.get_object(idx).map(|any| any.into());
                                     obj.unwrap().to_object()
                                 }
-                                _ => Wrap(s.get(idx)).into(),
+                                _ => Wrap(s.get(idx).unwrap()).into(),
                             })
                             .collect(),
                     )
@@ -573,9 +574,8 @@ impl RbDataFrame {
             .collect()
     }
 
-    pub fn n_chunks(&self) -> RbResult<usize> {
-        let n = self.df.borrow().n_chunks().map_err(RbPolarsErr::from)?;
-        Ok(n)
+    pub fn n_chunks(&self) -> usize {
+        self.df.borrow().n_chunks()
     }
 
     pub fn shape(&self) -> (usize, usize) {

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

@@ -348,6 +348,7 @@ impl RbLazyFrame {
         include_boundaries: bool,
         closed: Wrap<ClosedWindow>,
         by: RArray,
+        start_by: Wrap<StartBy>,
     ) -> RbResult<RbLazyGroupBy> {
         let closed_window = closed.0;
         let by = rb_exprs_to_exprs(by)?;
@@ -362,6 +363,7 @@ impl RbLazyFrame {
                 truncate,
                 include_boundaries,
                 closed_window,
+                start_by: start_by.0,
             },
         );
 
@@ -514,9 +516,13 @@ impl RbLazyFrame {
         ldf.median().into()
     }
 
-    pub fn quantile(&self, quantile: f64, interpolation: Wrap<QuantileInterpolOptions>) -> Self {
+    pub fn quantile(
+        &self,
+        quantile: &RbExpr,
+        interpolation: Wrap<QuantileInterpolOptions>,
+    ) -> Self {
         let ldf = self.ldf.clone();
-        ldf.quantile(quantile, interpolation.0).into()
+        ldf.quantile(quantile.inner.clone(), interpolation.0).into()
     }
 
     pub fn explode(&self, column: RArray) -> RbResult<Self> {

data/ext/polars/src/lazy/dsl.rs

@@ -164,10 +164,14 @@ impl RbExpr {
         self.clone().inner.list().into()
     }
 
-    pub fn quantile(&self, quantile: f64, interpolation: Wrap<QuantileInterpolOptions>) -> Self {
+    pub fn quantile(
+        &self,
+        quantile: &RbExpr,
+        interpolation: Wrap<QuantileInterpolOptions>,
+    ) -> Self {
         self.clone()
             .inner
-            .quantile(quantile, interpolation.0)
+            .quantile(quantile.inner.clone(), interpolation.0)
             .into()
     }
 
@@ -506,7 +510,13 @@ impl RbExpr {
         self.inner.clone().shrink_dtype().into()
     }
 
-    pub fn str_parse_date(&self, fmt: Option<String>, strict: bool, exact: bool) -> Self {
+    pub fn str_parse_date(
+        &self,
+        fmt: Option<String>,
+        strict: bool,
+        exact: bool,
+        cache: bool,
+    ) -> Self {
         self.inner
             .clone()
             .str()
@@ -515,11 +525,20 @@ impl RbExpr {
                 fmt,
                 strict,
                 exact,
+                cache,
+                tz_aware: false,
             })
             .into()
     }
 
-    pub fn str_parse_datetime(&self, fmt: Option<String>, strict: bool, exact: bool) -> Self {
+    pub fn str_parse_datetime(
+        &self,
+        fmt: Option<String>,
+        strict: bool,
+        exact: bool,
+        cache: bool,
+        tz_aware: bool,
+    ) -> Self {
         let tu = match fmt {
             Some(ref fmt) => {
                 if fmt.contains("%.9f")
@@ -544,11 +563,19 @@ impl RbExpr {
                 fmt,
                 strict,
                 exact,
+                cache,
+                tz_aware,
             })
             .into()
     }
 
-    pub fn str_parse_time(&self, fmt: Option<String>, strict: bool, exact: bool) -> Self {
+    pub fn str_parse_time(
+        &self,
+        fmt: Option<String>,
+        strict: bool,
+        exact: bool,
+        cache: bool,
+    ) -> Self {
         self.inner
             .clone()
             .str()
@@ -557,6 +584,8 @@ impl RbExpr {
                 fmt,
                 strict,
                 exact,
+                cache,
+                tz_aware: false,
             })
             .into()
     }
@@ -723,8 +752,12 @@ impl RbExpr {
         self.inner.clone().str().extract(&pat, group_index).into()
     }
 
-    pub fn str_extract_all(&self, pat: String) -> Self {
-        self.inner.clone().str().extract_all(&pat).into()
+    pub fn str_extract_all(&self, pat: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .extract_all(pat.inner.clone())
+            .into()
     }
 
     pub fn count_match(&self, pat: String) -> Self {
@@ -989,14 +1022,12 @@ impl RbExpr {
             .clone()
             .map_alias(move |name| {
                 let out = lambda.call::<_, String>((name,));
-                // TODO switch to match
-                out.unwrap()
-                // match out {
-                //     Ok(out) => Ok(out.to_string()),
-                //     Err(e) => Err(PolarsError::ComputeError(
-                //         format!("Ruby function in 'map_alias' produced an error: {}.", e).into(),
-                //     )),
-                // }
+                match out {
+                    Ok(out) => Ok(out),
+                    Err(e) => Err(PolarsError::ComputeError(
+                        format!("Ruby function in 'map_alias' produced an error: {}.", e).into(),
+                    )),
+                }
             })
             .into()
     }
@@ -1005,8 +1036,8 @@ impl RbExpr {
         self.inner.clone().exclude(columns).into()
     }
 
-    pub fn interpolate(&self) -> Self {
-        self.inner.clone().interpolate().into()
+    pub fn interpolate(&self, method: Wrap<InterpolationMethod>) -> Self {
+        self.inner.clone().interpolate(method.0).into()
     }
 
     pub fn rolling_sum(
@@ -1297,6 +1328,7 @@ impl RbExpr {
         &self,
         width_strat: Wrap<ListToStructWidthStrategy>,
         _name_gen: Option<Value>,
+        upper_bound: usize,
     ) -> RbResult<Self> {
         // TODO fix
         let name_gen = None;
@@ -1311,7 +1343,7 @@ impl RbExpr {
             .inner
             .clone()
             .arr()
-            .to_struct(width_strat.0, name_gen)
+            .to_struct(width_strat.0, name_gen, upper_bound)
             .into())
     }
 
@@ -1498,6 +1530,10 @@ pub fn cols(names: Vec<String>) -> RbExpr {
     dsl::cols(names).into()
 }
 
+pub fn dtype_cols(dtypes: Vec<DataType>) -> RbExpr {
+    dsl::dtype_cols(dtypes).into()
+}
+
 pub fn fold(acc: &RbExpr, lambda: Value, exprs: RArray) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;