pub enum Expr {
Show 26 variants
Alias(Box<Expr>, Arc<str>),
Column(Arc<str>),
Columns(Vec<String>),
DtypeColumn(Vec<DataType>),
Literal(LiteralValue),
BinaryExpr {
left: Box<Expr>,
op: Operator,
right: Box<Expr>,
},
Cast {
expr: Box<Expr>,
data_type: DataType,
strict: bool,
},
Sort {
expr: Box<Expr>,
options: SortOptions,
},
Gather {
expr: Box<Expr>,
idx: Box<Expr>,
returns_scalar: bool,
},
SortBy {
expr: Box<Expr>,
by: Vec<Expr>,
descending: Vec<bool>,
},
Agg(AggExpr),
Ternary {
predicate: Box<Expr>,
truthy: Box<Expr>,
falsy: Box<Expr>,
},
Function {
input: Vec<Expr>,
function: FunctionExpr,
options: FunctionOptions,
},
Explode(Box<Expr>),
Filter {
input: Box<Expr>,
by: Box<Expr>,
},
Window {
function: Box<Expr>,
partition_by: Vec<Expr>,
options: WindowType,
},
Wildcard,
Slice {
input: Box<Expr>,
offset: Box<Expr>,
length: Box<Expr>,
},
Exclude(Box<Expr>, Vec<Excluded>),
KeepName(Box<Expr>),
Count,
Nth(i64),
RenameAlias {
function: SpecialEq<Arc<dyn RenameAliasFn>>,
expr: Box<Expr>,
},
AnonymousFunction {
input: Vec<Expr>,
function: SpecialEq<Arc<dyn SeriesUdf>>,
output_type: SpecialEq<Arc<dyn FunctionOutputField>>,
options: FunctionOptions,
},
SubPlan(SpecialEq<Arc<LogicalPlan>>, Vec<String>),
Selector(Selector),
}
lazy
only.Expand description
Expressions that can be used in various contexts. Queries consist of multiple expressions. When using the polars
lazy API, don’t construct an Expr
directly; instead, create one using the functions in the polars_lazy::dsl
module. See that module’s docs for more info.
Variants§
Alias(Box<Expr>, Arc<str>)
Column(Arc<str>)
Columns(Vec<String>)
DtypeColumn(Vec<DataType>)
Literal(LiteralValue)
BinaryExpr
Cast
Sort
Gather
SortBy
Agg(AggExpr)
Ternary
A ternary operation if true then “foo” else “bar”
Function
Explode(Box<Expr>)
Filter
Window
Fields
options: WindowType
See postgres window functions
Wildcard
Slice
Fields
Exclude(Box<Expr>, Vec<Excluded>)
Can be used in a select statement to exclude a column from selection
KeepName(Box<Expr>)
Set root name as Alias
Count
Special case that does not need columns
Nth(i64)
Take the nth column in the DataFrame
RenameAlias
AnonymousFunction
Fields
output_type: SpecialEq<Arc<dyn FunctionOutputField>>
output dtype of the function
options: FunctionOptions
SubPlan(SpecialEq<Arc<LogicalPlan>>, Vec<String>)
Selector(Selector)
Expressions in this node should only be expanding
e.g.
Expr::Columns
Expr::Dtypes
Expr::Wildcard
Expr::Exclude
Implementations§
§impl Expr
impl Expr
pub fn to_dot(&self) -> Result<String, PolarsError>
pub fn to_dot(&self) -> Result<String, PolarsError>
Get a dot language representation of the Expression.
§impl Expr
impl Expr
pub fn to_field(
&self,
schema: &Schema,
ctxt: Context
) -> Result<Field, PolarsError>
pub fn to_field( &self, schema: &Schema, ctxt: Context ) -> Result<Field, PolarsError>
Get Field result of the expression. The schema is the input data.
§impl Expr
impl Expr
pub fn eq_missing<E>(self, other: E) -> Exprwhere
E: Into<Expr>,
pub fn eq_missing<E>(self, other: E) -> Exprwhere E: Into<Expr>,
Compare Expr
with other Expr
on equality where None == None
.
pub fn neq<E>(self, other: E) -> Exprwhere
E: Into<Expr>,
pub fn neq<E>(self, other: E) -> Exprwhere E: Into<Expr>,
Compare Expr
with other Expr
on non-equality.
pub fn neq_missing<E>(self, other: E) -> Exprwhere
E: Into<Expr>,
pub fn neq_missing<E>(self, other: E) -> Exprwhere E: Into<Expr>,
Compare Expr
with other Expr
on non-equality where None == None
.
pub fn is_not_null(self) -> Expr
pub fn is_not_null(self) -> Expr
Run is_not_null operation on Expr
.
pub fn drop_nulls(self) -> Expr
pub fn drop_nulls(self) -> Expr
Drop null values.
pub fn quantile(self, quantile: Expr, interpol: QuantileInterpolOptions) -> Expr
pub fn quantile(self, quantile: Expr, interpol: QuantileInterpolOptions) -> Expr
Compute the quantile per group.
pub fn agg_groups(self) -> Expr
pub fn agg_groups(self) -> Expr
Get the group indexes of the group by operation.
pub fn slice<E, F>(self, offset: E, length: F) -> Exprwhere
E: Into<Expr>,
F: Into<Expr>,
pub fn slice<E, F>(self, offset: E, length: F) -> Exprwhere E: Into<Expr>, F: Into<Expr>,
Slice the Series.
offset
may be negative.
pub fn append<E>(self, other: E, upcast: bool) -> Exprwhere
E: Into<Expr>,
pub fn append<E>(self, other: E, upcast: bool) -> Exprwhere E: Into<Expr>,
Append expressions. This is done by adding the chunks of other
to this Series
.
pub fn unique_stable(self) -> Expr
pub fn unique_stable(self) -> Expr
Get unique values of this expression, while maintaining order.
This requires more work than Expr::unique
.
pub fn arg_unique(self) -> Expr
pub fn arg_unique(self) -> Expr
Get the first index of unique values of this expression.
pub fn arg_sort(self, sort_options: SortOptions) -> Expr
pub fn arg_sort(self, sort_options: SortOptions) -> Expr
Get the index values that would sort this expression.
pub fn strict_cast(self, data_type: DataType) -> Expr
pub fn strict_cast(self, data_type: DataType) -> Expr
Cast expression to another data type. Throws an error if conversion had overflows.
pub fn sort(self, descending: bool) -> Expr
pub fn sort(self, descending: bool) -> Expr
Sort in increasing order. See the eager implementation.
pub fn sort_with(self, options: SortOptions) -> Expr
pub fn sort_with(self, options: SortOptions) -> Expr
Sort with given options.
pub fn map<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField>>
) -> Exprwhere
F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
pub fn map<F>( self, function: F, output_type: SpecialEq<Arc<dyn FunctionOutputField>> ) -> Exprwhere F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
Apply a function/closure once the logical plan get executed.
This function is very similar to Expr::apply
, but differs in how it handles aggregations.
map
should be used for operations that are independent of groups, e.g.multiply * 2
, orraise to the power
apply
should be used for operations that work on a group of data. e.g.sum
,count
, etc.
It is the responsibility of the caller that the schema is correct by giving the correct output_type. If None given the output type of the input expr is used.
pub fn map_many<F>(
self,
function: F,
arguments: &[Expr],
output_type: SpecialEq<Arc<dyn FunctionOutputField>>
) -> Exprwhere
F: Fn(&mut [Series]) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
pub fn map_many<F>( self, function: F, arguments: &[Expr], output_type: SpecialEq<Arc<dyn FunctionOutputField>> ) -> Exprwhere F: Fn(&mut [Series]) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
pub fn map_list<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField>>
) -> Exprwhere
F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
pub fn map_list<F>( self, function: F, output_type: SpecialEq<Arc<dyn FunctionOutputField>> ) -> Exprwhere F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
Apply a function/closure once the logical plan get executed.
This function is very similar to apply, but differs in how it handles aggregations.
map
should be used for operations that are independent of groups, e.g.multiply * 2
, orraise to the power
apply
should be used for operations that work on a group of data. e.g.sum
,count
, etc.map_list
should be used when the function expects a list aggregated series.
pub fn function_with_options<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField>>,
options: FunctionOptions
) -> Exprwhere
F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
pub fn function_with_options<F>( self, function: F, output_type: SpecialEq<Arc<dyn FunctionOutputField>>, options: FunctionOptions ) -> Exprwhere F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
A function that cannot be expressed with map
or apply
and requires extra settings.
pub fn apply<F>(
self,
function: F,
output_type: SpecialEq<Arc<dyn FunctionOutputField>>
) -> Exprwhere
F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
pub fn apply<F>( self, function: F, output_type: SpecialEq<Arc<dyn FunctionOutputField>> ) -> Exprwhere F: Fn(Series) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
Apply a function/closure over the groups. This should only be used in a group_by aggregation.
It is the responsibility of the caller that the schema is correct by giving the correct output_type. If None given the output type of the input expr is used.
This difference with map is that apply
will create a separate Series
per group.
map
should be used for operations that are independent of groups, e.g.multiply * 2
, orraise to the power
apply
should be used for operations that work on a group of data. e.g.sum
,count
, etc.
pub fn apply_many<F>(
self,
function: F,
arguments: &[Expr],
output_type: SpecialEq<Arc<dyn FunctionOutputField>>
) -> Exprwhere
F: Fn(&mut [Series]) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
pub fn apply_many<F>( self, function: F, arguments: &[Expr], output_type: SpecialEq<Arc<dyn FunctionOutputField>> ) -> Exprwhere F: Fn(&mut [Series]) -> Result<Option<Series>, PolarsError> + 'static + Send + Sync,
Apply a function/closure over the groups with many arguments. This should only be used in a group_by aggregation.
See the Expr::apply
function for the differences between map
and apply
.
pub fn apply_many_private( self, function_expr: FunctionExpr, arguments: &[Expr], auto_explode: bool, cast_to_supertypes: bool ) -> Expr
pub fn map_many_private( self, function_expr: FunctionExpr, arguments: &[Expr], returns_scalar: bool, cast_to_supertypes: bool ) -> Expr
pub fn is_infinite(self) -> Expr
pub fn is_infinite(self) -> Expr
Get mask of infinite values if dtype is Float.
pub fn is_not_nan(self) -> Expr
pub fn is_not_nan(self) -> Expr
Get inverse mask of NaN values if dtype is Float.
pub fn shift(self, n: Expr) -> Expr
pub fn shift(self, n: Expr) -> Expr
Shift the values in the array by some period. See the eager implementation.
pub fn shift_and_fill<E>(self, n: E, fill_value: E) -> Exprwhere
E: Into<Expr>,
pub fn shift_and_fill<E>(self, n: E, fill_value: E) -> Exprwhere E: Into<Expr>,
Shift the values in the array by some period and fill the resulting empty values.
pub fn cum_count(self, reverse: bool) -> Expr
Available on crate feature cum_agg
only.
pub fn cum_count(self, reverse: bool) -> Expr
cum_agg
only.Cumulatively count values from 0 to len.
pub fn cum_sum(self, reverse: bool) -> Expr
Available on crate feature cum_agg
only.
pub fn cum_sum(self, reverse: bool) -> Expr
cum_agg
only.Get an array with the cumulative sum computed at every element.
pub fn cum_prod(self, reverse: bool) -> Expr
Available on crate feature cum_agg
only.
pub fn cum_prod(self, reverse: bool) -> Expr
cum_agg
only.Get an array with the cumulative product computed at every element.
pub fn cum_min(self, reverse: bool) -> Expr
Available on crate feature cum_agg
only.
pub fn cum_min(self, reverse: bool) -> Expr
cum_agg
only.Get an array with the cumulative min computed at every element.
pub fn cum_max(self, reverse: bool) -> Expr
Available on crate feature cum_agg
only.
pub fn cum_max(self, reverse: bool) -> Expr
cum_agg
only.Get an array with the cumulative max computed at every element.
pub fn backward_fill(self, limit: Option<u32>) -> Expr
pub fn backward_fill(self, limit: Option<u32>) -> Expr
Fill missing value with next non-null.
pub fn forward_fill(self, limit: Option<u32>) -> Expr
pub fn forward_fill(self, limit: Option<u32>) -> Expr
Fill missing value with previous non-null.
pub fn round(self, decimals: u32) -> Expr
Available on crate feature round_series
only.
pub fn round(self, decimals: u32) -> Expr
round_series
only.Round underlying floating point array to given decimal numbers.
pub fn round_sig_figs(self, digits: i32) -> Expr
Available on crate feature round_series
only.
pub fn round_sig_figs(self, digits: i32) -> Expr
round_series
only.Round to a number of significant figures.
pub fn floor(self) -> Expr
Available on crate feature round_series
only.
pub fn floor(self) -> Expr
round_series
only.Floor underlying floating point array to the lowest integers smaller or equal to the float value.
pub fn ceil(self) -> Expr
Available on crate feature round_series
only.
pub fn ceil(self) -> Expr
round_series
only.Ceil underlying floating point array to the highest integers smaller or equal to the float value.
pub fn clip(self, min: Expr, max: Expr) -> Expr
Available on crate feature round_series
only.
pub fn clip(self, min: Expr, max: Expr) -> Expr
round_series
only.Clip underlying values to a set boundary.
pub fn clip_max(self, max: Expr) -> Expr
Available on crate feature round_series
only.
pub fn clip_max(self, max: Expr) -> Expr
round_series
only.Clip underlying values to a set boundary.
pub fn clip_min(self, min: Expr) -> Expr
Available on crate feature round_series
only.
pub fn clip_min(self, min: Expr) -> Expr
round_series
only.Clip underlying values to a set boundary.
pub fn abs(self) -> Expr
Available on crate feature abs
only.
pub fn abs(self) -> Expr
abs
only.Convert all values to their absolute/positive value.
pub fn over<E, IE>(self, partition_by: E) -> Exprwhere
E: AsRef<[IE]>,
IE: Into<Expr> + Clone,
pub fn over<E, IE>(self, partition_by: E) -> Exprwhere E: AsRef<[IE]>, IE: Into<Expr> + Clone,
Apply window function over a subgroup. This is similar to a group_by + aggregation + self join. Or similar to window functions in Postgres.
Example
#[macro_use] extern crate polars_core;
use polars_core::prelude::*;
use polars_lazy::prelude::*;
fn example() -> PolarsResult<()> {
let df = df! {
"groups" => &[1, 1, 2, 2, 1, 2, 3, 3, 1],
"values" => &[1, 2, 3, 4, 5, 6, 7, 8, 8]
}?;
let out = df
.lazy()
.select(&[
col("groups"),
sum("values").over([col("groups")]),
])
.collect()?;
println!("{}", &out);
Ok(())
}
Outputs:
╭────────┬────────╮
│ groups ┆ values │
│ --- ┆ --- │
│ i32 ┆ i32 │
╞════════╪════════╡
│ 1 ┆ 16 │
│ 1 ┆ 16 │
│ 2 ┆ 13 │
│ 2 ┆ 13 │
│ … ┆ … │
│ 1 ┆ 16 │
│ 2 ┆ 13 │
│ 3 ┆ 15 │
│ 3 ┆ 15 │
│ 1 ┆ 16 │
╰────────┴────────╯
pub fn over_with_options<E, IE>( self, partition_by: E, options: WindowMapping ) -> Exprwhere E: AsRef<[IE]>, IE: Into<Expr> + Clone,
pub fn rolling(self, options: RollingGroupOptions) -> Expr
dynamic_group_by
only.pub fn fill_null<E>(self, fill_value: E) -> Exprwhere
E: Into<Expr>,
pub fn fill_null<E>(self, fill_value: E) -> Exprwhere E: Into<Expr>,
Replace the null values by a value.
pub fn fill_nan<E>(self, fill_value: E) -> Exprwhere
E: Into<Expr>,
pub fn fill_nan<E>(self, fill_value: E) -> Exprwhere E: Into<Expr>,
Replace the floating point NaN
values by a value.
pub fn filter<E>(self, predicate: E) -> Exprwhere
E: Into<Expr>,
pub fn filter<E>(self, predicate: E) -> Exprwhere E: Into<Expr>,
Filter a single column.
Should be used in aggregation context. If you want to filter on a
DataFrame level, use LazyFrame::filter
.
pub fn is_in<E>(self, other: E) -> Exprwhere
E: Into<Expr>,
Available on crate feature is_in
only.
pub fn is_in<E>(self, other: E) -> Exprwhere E: Into<Expr>,
is_in
only.Check if the values of the left expression are in the lists of the right expr.
pub fn sort_by<E, IE, R>(self, by: E, descending: R) -> Exprwhere
E: AsRef<[IE]>,
IE: Into<Expr> + Clone,
R: AsRef<[bool]>,
pub fn sort_by<E, IE, R>(self, by: E, descending: R) -> Exprwhere E: AsRef<[IE]>, IE: Into<Expr> + Clone, R: AsRef<[bool]>,
Sort this column by the ordering of another column. Can also be used in a group_by context to sort the groups.
pub fn repeat_by<E>(self, by: E) -> Exprwhere
E: Into<Expr>,
Available on crate feature repeat_by
only.
pub fn repeat_by<E>(self, by: E) -> Exprwhere E: Into<Expr>,
repeat_by
only.Repeat the column n
times, where n
is determined by the values in by
.
This yields an Expr
of dtype List
.
pub fn is_first_distinct(self) -> Expr
Available on crate feature is_first_distinct
only.
pub fn is_first_distinct(self) -> Expr
is_first_distinct
only.Get a mask of the first unique value.
pub fn is_last_distinct(self) -> Expr
Available on crate feature is_last_distinct
only.
pub fn is_last_distinct(self) -> Expr
is_last_distinct
only.Get a mask of the last unique value.
pub fn dot<E>(self, other: E) -> Exprwhere
E: Into<Expr>,
pub fn dot<E>(self, other: E) -> Exprwhere E: Into<Expr>,
Compute the dot/inner product between two expressions.
pub fn mode(self) -> Expr
Available on crate feature mode
only.
pub fn mode(self) -> Expr
mode
only.Compute the mode(s) of this column. This is the most occurring value.
pub fn exclude(self, columns: impl IntoVec<String>) -> Expr
pub fn exclude(self, columns: impl IntoVec<String>) -> Expr
Exclude a column from a wildcard/regex selection.
You may also use regexes in the exclude as long as they start with ^
and end with $
/
pub fn exclude_dtype<D>(self, dtypes: D) -> Exprwhere D: AsRef<[DataType]>,
pub fn interpolate(self, method: InterpolationMethod) -> Expr
Available on crate feature interpolate
only.
pub fn interpolate(self, method: InterpolationMethod) -> Expr
interpolate
only.Fill null values using interpolation.
pub fn rolling_min(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_min(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling minimum.
See: [RollingAgg::rolling_min
]
pub fn rolling_max(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_max(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling maximum.
See: [RollingAgg::rolling_max
]
pub fn rolling_mean(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_mean(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling mean.
See: [RollingAgg::rolling_mean
]
pub fn rolling_sum(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_sum(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling sum.
See: [RollingAgg::rolling_sum
]
pub fn rolling_median(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_median(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling median.
See: [RollingAgg::rolling_median
]
pub fn rolling_quantile(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_quantile(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling quantile.
See: [RollingAgg::rolling_quantile
]
pub fn rolling_var(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_var(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling variance.
pub fn rolling_std(self, options: RollingOptions) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_std(self, options: RollingOptions) -> Expr
rolling_window
only.Apply a rolling std-dev.
pub fn rolling_map(
self,
f: Arc<dyn Fn(&Series) -> Series + Send + Sync>,
output_type: SpecialEq<Arc<dyn FunctionOutputField>>,
options: RollingOptionsFixedWindow
) -> Expr
Available on crate feature rolling_window
only.
pub fn rolling_map( self, f: Arc<dyn Fn(&Series) -> Series + Send + Sync>, output_type: SpecialEq<Arc<dyn FunctionOutputField>>, options: RollingOptionsFixedWindow ) -> Expr
rolling_window
only.Apply a custom function over a rolling/ moving window of the array. This has quite some dynamic dispatch, so prefer rolling_min, max, mean, sum over this.
pub fn rolling_map_float<F>(self, window_size: usize, f: F) -> Exprwhere
F: 'static + FnMut(&mut ChunkedArray<Float64Type>) -> Option<f64> + Send + Sync + Copy,
Available on crate feature rolling_window
only.
pub fn rolling_map_float<F>(self, window_size: usize, f: F) -> Exprwhere F: 'static + FnMut(&mut ChunkedArray<Float64Type>) -> Option<f64> + Send + Sync + Copy,
rolling_window
only.Apply a custom function over a rolling/ moving window of the array. Prefer this over rolling_apply in case of floating point numbers as this is faster. This has quite some dynamic dispatch, so prefer rolling_min, max, mean, sum over this.
pub fn rank(self, options: RankOptions, seed: Option<u64>) -> Expr
Available on crate feature rank
only.
pub fn rank(self, options: RankOptions, seed: Option<u64>) -> Expr
rank
only.Assign ranks to data, dealing with ties appropriately.
pub fn diff(self, n: i64, null_behavior: NullBehavior) -> Expr
Available on crate feature diff
only.
pub fn diff(self, n: i64, null_behavior: NullBehavior) -> Expr
diff
only.Calculate the n-th discrete difference between values.
pub fn upper_bound(self) -> Expr
pub fn upper_bound(self) -> Expr
Get maximal value that could be hold by this dtype.
pub fn lower_bound(self) -> Expr
pub fn lower_bound(self) -> Expr
Get minimal value that could be hold by this dtype.
pub fn reshape(self, dims: &[i64]) -> Expr
pub fn any(self, ignore_nulls: bool) -> Expr
pub fn any(self, ignore_nulls: bool) -> Expr
Returns whether any of the values in the column are true
.
If ignore_nulls
is False
, Kleene logic is used to deal with nulls:
if the column contains any null values and no true
values, the output
is null.
pub fn all(self, ignore_nulls: bool) -> Expr
pub fn all(self, ignore_nulls: bool) -> Expr
Returns whether all values in the column are true
.
If ignore_nulls
is False
, Kleene logic is used to deal with nulls:
if the column contains any null values and no true
values, the output
is null.
pub fn shrink_dtype(self) -> Expr
pub fn shrink_dtype(self) -> Expr
Shrink numeric columns to the minimal required datatype
needed to fit the extrema of this Series
.
This can be used to reduce memory pressure.
pub fn value_counts(self, sort: bool, parallel: bool) -> Expr
Available on crate feature dtype-struct
only.
pub fn value_counts(self, sort: bool, parallel: bool) -> Expr
dtype-struct
only.Count all unique values and create a struct mapping value to count. (Note that it is better to turn parallel off in the aggregation context).
pub fn null_count(self) -> Expr
pub fn null_count(self) -> Expr
Get the null count of the column/group.
pub fn set_sorted_flag(self, sorted: IsSorted) -> Expr
pub fn set_sorted_flag(self, sorted: IsSorted) -> Expr
Set this Series
as sorted
so that downstream code can use
fast paths for sorted arrays.
Warning
This can lead to incorrect results if this Series
is not sorted!!
Use with care!
pub fn to_physical(self) -> Expr
pub fn str(self) -> StringNameSpace
Available on crate feature strings
only.
pub fn str(self) -> StringNameSpace
strings
only.Get the string::StringNameSpace
pub fn binary(self) -> BinaryNameSpace
pub fn binary(self) -> BinaryNameSpace
Get the binary::BinaryNameSpace
pub fn dt(self) -> DateLikeNameSpace
Available on crate feature temporal
only.
pub fn dt(self) -> DateLikeNameSpace
temporal
only.Get the dt::DateLikeNameSpace
pub fn list(self) -> ListNameSpace
pub fn list(self) -> ListNameSpace
Get the list::ListNameSpace
pub fn name(self) -> ExprNameNameSpace
pub fn name(self) -> ExprNameNameSpace
Get the [name::ExprNameNameSpace
]
pub fn arr(self) -> ArrayNameSpace
Available on crate feature dtype-array
only.
pub fn arr(self) -> ArrayNameSpace
dtype-array
only.Get the array::ArrayNameSpace
.
pub fn cat(self) -> CategoricalNameSpace
Available on crate feature dtype-categorical
only.
pub fn cat(self) -> CategoricalNameSpace
dtype-categorical
only.Get the CategoricalNameSpace
.
pub fn struct_(self) -> StructNameSpace
Available on crate feature dtype-struct
only.
pub fn struct_(self) -> StructNameSpace
dtype-struct
only.Get the struct_::StructNameSpace
.
Trait Implementations§
source§impl ExprEvalExtension for Expr
impl ExprEvalExtension for Expr
§impl<'a> IntoIterator for &'a Expr
impl<'a> IntoIterator for &'a Expr
§impl TreeWalker for Expr
impl TreeWalker for Expr
fn apply_children<'a>( &'a self, op: &mut dyn FnMut(&Expr) -> Result<VisitRecursion, PolarsError> ) -> Result<VisitRecursion, PolarsError>
fn map_children( self, _op: &mut dyn FnMut(Expr) -> Result<Expr, PolarsError> ) -> Result<Expr, PolarsError>
§fn visit(
&self,
visitor: &mut dyn Visitor<Node = Self>
) -> Result<VisitRecursion, PolarsError>
fn visit( &self, visitor: &mut dyn Visitor<Node = Self> ) -> Result<VisitRecursion, PolarsError>
fn rewrite( self, rewriter: &mut dyn RewritingVisitor<Node = Self> ) -> Result<Self, PolarsError>
impl Eq for Expr
impl StructuralPartialEq for Expr
Auto Trait Implementations§
impl !RefUnwindSafe for Expr
impl Send for Expr
impl Sync for Expr
impl Unpin for Expr
impl !UnwindSafe for Expr
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.