Struct Transform 

pub struct Transform;

Transform operations for DataFrames

Implementations

impl Transform

pub fn select(df: &DataFrame, columns: &[String]) -> Result<DataFrame>

Select specific columns from a DataFrame

pub fn select_lazy(lf: LazyFrame, columns: &[String]) -> Result<LazyFrame>

Select specific columns from a LazyFrame

pub fn filter(df: &DataFrame, mask: &Series) -> Result<DataFrame>

Filter DataFrame based on a condition

pub fn filter_lazy(lf: LazyFrame, predicate: Expr) -> Result<LazyFrame>

Filter LazyFrame based on an expression

pub fn sort( df: &DataFrame, by_columns: &[String], descending: Vec<bool>, ) -> Result<DataFrame>

Sort DataFrame by columns

pub fn sort_lazy( lf: LazyFrame, by_columns: &[String], descending: &[bool], ) -> Result<LazyFrame>

Sort LazyFrame by columns

pub fn rename( df: &DataFrame, mapping: &HashMap<String, String>, ) -> Result<DataFrame>

Rename columns in a DataFrame

pub fn rename_lazy( lf: LazyFrame, mapping: &HashMap<String, String>, ) -> Result<LazyFrame>

Rename columns in a LazyFrame

pub fn with_column( df: &DataFrame, name: &str, series: Series, ) -> Result<DataFrame>

Add a new column to a DataFrame

pub fn with_column_lazy(lf: LazyFrame, expr: Expr) -> Result<LazyFrame>

Add a new column expression to a LazyFrame

pub fn drop(df: &DataFrame, columns: &[String]) -> Result<DataFrame>

Drop columns from a DataFrame

pub fn drop_lazy(lf: LazyFrame, columns: &[String]) -> Result<LazyFrame>

Drop columns from a LazyFrame

pub fn unique( df: &DataFrame, subset: Option<&[String]>, keep: UniqueKeepStrategy, ) -> Result<DataFrame>

Get unique values in a DataFrame

pub fn unique_lazy( lf: LazyFrame, subset: Option<&[String]>, keep: UniqueKeepStrategy, ) -> Result<LazyFrame>

Get unique values in a LazyFrame

pub fn limit(df: &DataFrame, n: usize) -> Result<DataFrame>

Limit the number of rows

pub fn limit_lazy(lf: LazyFrame, n: u32) -> Result<LazyFrame>

Limit the number of rows in a LazyFrame

pub fn skip(df: &DataFrame, n: usize) -> Result<DataFrame>

Skip the first n rows

pub fn skip_lazy(lf: LazyFrame, n: u32) -> Result<LazyFrame>

Skip the first n rows in a LazyFrame

pub fn slice(df: &DataFrame, offset: i64, length: usize) -> Result<DataFrame>

Slice a DataFrame

pub fn slice_lazy(lf: LazyFrame, offset: i64, length: u32) -> Result<LazyFrame>

Slice a LazyFrame

pub fn reverse(df: &DataFrame) -> Result<DataFrame>

Reverse the order of rows

pub fn reverse_lazy(lf: LazyFrame) -> Result<LazyFrame>

Reverse the order of rows in a LazyFrame

pub fn sample( df: &DataFrame, n: usize, with_replacement: bool, seed: Option<u64>, ) -> Result<DataFrame>

Sample rows from a DataFrame

pub fn fill_null(df: &DataFrame, value: FillNullStrategy) -> Result<DataFrame>

Fill null values

pub fn fill_null_lazy(lf: LazyFrame, value: Expr) -> Result<LazyFrame>

Fill null values in a LazyFrame

pub fn drop_nulls( df: &DataFrame, subset: Option<&[String]>, ) -> Result<DataFrame>

Drop rows with null values

pub fn drop_nulls_lazy( lf: LazyFrame, _subset: Option<Vec<Expr>>, ) -> Result<LazyFrame>

Drop rows with null values in a LazyFrame

pub fn cast(df: &DataFrame, column: &str, dtype: &DataType) -> Result<DataFrame>

Cast column types

pub fn cast_lazy( lf: LazyFrame, column: &str, dtype: DataType, ) -> Result<LazyFrame>

Cast column types in a LazyFrame

pub fn explode(df: &DataFrame, columns: &[String]) -> Result<DataFrame>

Explode list columns

pub fn explode_lazy(lf: LazyFrame, columns: &[String]) -> Result<LazyFrame>

Explode list columns in a LazyFrame

pub fn melt( df: &DataFrame, id_vars: &[String], value_vars: &[String], _variable_name: Option<&str>, _value_name: Option<&str>, ) -> Result<DataFrame>

Melt DataFrame from wide to long format

pub fn melt_lazy( lf: LazyFrame, id_vars: &[String], value_vars: &[String], _variable_name: Option<&str>, _value_name: Option<&str>, ) -> Result<LazyFrame>

Melt LazyFrame from wide to long format

pub fn pivot( df: &DataFrame, values: &[String], index: &[String], columns: &[String], aggregate_fn: Option<&str>, ) -> Result<DataFrame>

Pivot DataFrame from long to wide format

pub fn map_rows<F, T>(_df: &DataFrame, _f: F) -> Result<DataFrame>

where F: Fn(usize) -> Result<T>, T: Into<Series>,

Apply a function to each row

pub fn map_columns(df: &DataFrame, expr: Expr) -> Result<DataFrame>

Apply a transformation expression to all columns

pub fn transpose( df: &DataFrame, keep_names_as: Option<&str>, ) -> Result<DataFrame>

Transpose a DataFrame