Enum FunctionExpr

pub enum FunctionExpr {
    ArrayExpr(ArrayFunction),
    BinaryExpr(BinaryFunction),
    Categorical(CategoricalFunction),
    ListExpr(ListFunction),
    StringExpr(StringFunction),
    StructExpr(StructFunction),
    TemporalExpr(TemporalFunction),
    Bitwise(BitwiseFunction),
    Boolean(BooleanFunction),
    Business(BusinessFunction),
    Abs,
    Negate,
    Hist {
        bin_count: Option<usize>,
        include_category: bool,
        include_breakpoint: bool,
    },
    NullCount,
    Pow(PowFunction),
    Hash(u64, u64, u64, u64),
    ArgWhere,
    IndexOf,
    SearchSorted(SearchSortedSide),
    Range(RangeFunction),
    Trigonometry(TrigonometricFunction),
    Atan2,
    Sign,
    FillNull,
    FillNullWithStrategy(FillNullStrategy),
    RollingExpr(RollingFunction),
    RollingExprBy(RollingFunctionBy),
    ShiftAndFill,
    Shift,
    DropNans,
    DropNulls,
    Mode,
    Skew(bool),
    Kurtosis(bool, bool),
    Reshape(Vec<ReshapeDimension>),
    RepeatBy,
    ArgUnique,
    Rank {
        options: RankOptions,
        seed: Option<u64>,
    },
    Repeat,
    Clip {
        has_min: bool,
        has_max: bool,
    },
    AsStruct,
    TopK {
        descending: bool,
    },
    TopKBy {
        descending: Vec<bool>,
    },
    CumCount {
        reverse: bool,
    },
    CumSum {
        reverse: bool,
    },
    CumProd {
        reverse: bool,
    },
    CumMin {
        reverse: bool,
    },
    CumMax {
        reverse: bool,
    },
    Reverse,
    ValueCounts {
        sort: bool,
        parallel: bool,
        name: PlSmallStr,
        normalize: bool,
    },
    UniqueCounts,
    ApproxNUnique,
    Coalesce,
    ShrinkType,
    Diff(i64, NullBehavior),
    PctChange,
    Interpolate(InterpolationMethod),
    InterpolateBy,
    Entropy {
        base: f64,
        normalize: bool,
    },
    Log {
        base: f64,
    },
    Log1p,
    Exp,
    Unique(bool),
    Round {
        decimals: u32,
    },
    RoundSF {
        digits: i32,
    },
    Floor,
    Ceil,
    UpperBound,
    LowerBound,
    Fused(FusedOperator),
    ConcatExpr(bool),
    Correlation {
        method: CorrelationMethod,
    },
    PeakMin,
    PeakMax,
    Cut {
        breaks: Vec<f64>,
        labels: Option<Vec<PlSmallStr>>,
        left_closed: bool,
        include_breaks: bool,
    },
    QCut {
        probs: Vec<f64>,
        labels: Option<Vec<PlSmallStr>>,
        left_closed: bool,
        allow_duplicates: bool,
        include_breaks: bool,
    },
    RLE,
    RLEID,
    ToPhysical,
    Random {
        method: RandomMethod,
        seed: Option<u64>,
    },
    SetSortedFlag(IsSorted),
    FfiPlugin {
        lib: PlSmallStr,
        symbol: PlSmallStr,
        kwargs: Arc<[u8]>,
    },
    BackwardFill {
        limit: Option<u32>,
    },
    ForwardFill {
        limit: Option<u32>,
    },
    MaxHorizontal,
    MinHorizontal,
    SumHorizontal {
        ignore_nulls: bool,
    },
    MeanHorizontal {
        ignore_nulls: bool,
    },
    EwmMean {
        options: EWMOptions,
    },
    EwmMeanBy {
        half_life: Duration,
    },
    EwmStd {
        options: EWMOptions,
    },
    EwmVar {
        options: EWMOptions,
    },
    Replace,
    ReplaceStrict {
        return_dtype: Option<DataType>,
    },
    GatherEvery {
        n: usize,
        offset: usize,
    },
    Reinterpret(bool),
    ExtendConstant,
}

Variants

ArrayExpr(ArrayFunction)

BinaryExpr(BinaryFunction)

Categorical(CategoricalFunction)

ListExpr(ListFunction)

StringExpr(StringFunction)

StructExpr(StructFunction)

TemporalExpr(TemporalFunction)

Bitwise(BitwiseFunction)

Boolean(BooleanFunction)

Business(BusinessFunction)

Abs

Negate

Hist

Fields

bin_count: Option<usize>

include_category: bool

include_breakpoint: bool

NullCount

Pow(PowFunction)

Hash(u64, u64, u64, u64)

ArgWhere

IndexOf

SearchSorted(SearchSortedSide)

Range(RangeFunction)

Trigonometry(TrigonometricFunction)

Atan2

Sign

FillNull

FillNullWithStrategy(FillNullStrategy)

RollingExpr(RollingFunction)

RollingExprBy(RollingFunctionBy)

ShiftAndFill

Shift

DropNans

DropNulls

Mode

Skew(bool)

Kurtosis(bool, bool)

Reshape(Vec<ReshapeDimension>)

RepeatBy

ArgUnique

Rank

Fields

options: RankOptions

seed: Option<u64>

Repeat

Clip

Fields

has_min: bool

has_max: bool

AsStruct

TopK

Fields

descending: bool

TopKBy

Fields

descending: Vec<bool>

CumCount

Fields

reverse: bool

CumSum

Fields

reverse: bool

CumProd

Fields

reverse: bool

CumMin

Fields

reverse: bool

CumMax

Fields

reverse: bool

Reverse

ValueCounts

Fields

sort: bool

parallel: bool

name: PlSmallStr

normalize: bool

UniqueCounts

ApproxNUnique

Coalesce

ShrinkType

Diff(i64, NullBehavior)

PctChange

Interpolate(InterpolationMethod)

InterpolateBy

Entropy

Fields

base: f64

normalize: bool

Log

Fields

base: f64

Log1p

Exp

Unique(bool)

Round

Fields

decimals: u32

RoundSF

Fields

digits: i32

Floor

Ceil

UpperBound

LowerBound

Fused(FusedOperator)

ConcatExpr(bool)

Correlation

Fields

method: CorrelationMethod

PeakMin

PeakMax

Cut

Fields

breaks: Vec<f64>

labels: Option<Vec<PlSmallStr>>

left_closed: bool

include_breaks: bool

QCut

Fields

probs: Vec<f64>

labels: Option<Vec<PlSmallStr>>

left_closed: bool

allow_duplicates: bool

include_breaks: bool

RLE

RLEID

ToPhysical

Random

Fields

method: RandomMethod

seed: Option<u64>

SetSortedFlag(IsSorted)

FfiPlugin

Creating this node is unsafe This will lead to calls over FFI.

Fields

lib: PlSmallStr

Shared library.

symbol: PlSmallStr

Identifier in the shared lib.

kwargs: Arc<[u8]>

Pickle serialized keyword arguments.

BackwardFill

Fields

limit: Option<u32>

ForwardFill

Fields

limit: Option<u32>

MaxHorizontal

MinHorizontal

SumHorizontal

Fields

ignore_nulls: bool

MeanHorizontal

Fields

ignore_nulls: bool

EwmMean

Fields

options: EWMOptions

EwmMeanBy

Fields

half_life: Duration

EwmStd

Fields

options: EWMOptions

EwmVar

Fields

options: EWMOptions

Replace

ReplaceStrict

Fields

return_dtype: Option<DataType>

GatherEvery

Fields

n: usize

offset: usize

Reinterpret(bool)

ExtendConstant

Trait Implementations

impl Clone for FunctionExpr

fn clone(&self) -> FunctionExpr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FunctionExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FunctionExpr

fn deserialize<__D>( __deserializer: __D, ) -> Result<FunctionExpr, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FunctionExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<BinaryFunction> for FunctionExpr

fn from(b: BinaryFunction) -> FunctionExpr

Converts to this type from the input type.

impl From<BooleanFunction> for FunctionExpr

fn from(func: BooleanFunction) -> FunctionExpr

Converts to this type from the input type.

impl From<CategoricalFunction> for FunctionExpr

fn from(func: CategoricalFunction) -> FunctionExpr

Converts to this type from the input type.

impl From<FunctionExpr> for SpecialEq<Arc<dyn ColumnsUdf>>

fn from(func: FunctionExpr) -> SpecialEq<Arc<dyn ColumnsUdf>>

Converts to this type from the input type.

impl From<StringFunction> for FunctionExpr

fn from(str: StringFunction) -> FunctionExpr

Converts to this type from the input type.

impl Hash for FunctionExpr

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FunctionExpr

fn eq(&self, other: &FunctionExpr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for FunctionExpr

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FunctionExpr