Struct PyExpr

pub struct PyExpr {
    pub expr: Expr,
}

A PyExpr that can be used on a DataFrame

Fields

expr: Expr

Implementations

impl PyExpr

pub fn literal(value: PyScalarValue) -> PyExpr

pub fn column(value: &str) -> PyExpr

pub fn alias(&self, name: &str) -> PyExpr

assign a name to the PyExpr

pub fn sort(&self, ascending: bool, nulls_first: bool) -> PySortExpr

Create a sort PyExpr from an existing PyExpr.

pub fn is_null(&self) -> PyExpr

pub fn is_not_null(&self) -> PyExpr

pub fn cast(&self, to: PyArrowType<DataType>) -> PyExpr

pub fn between(&self, low: PyExpr, high: PyExpr, negated: bool) -> PyExpr

pub fn rex_type(&self) -> PyResult<RexType>

A Rex (Row Expression) specifies a single row of data. That specification could include user defined functions or types. RexType identifies the row as one of the possible valid RexTypes.

pub fn types(&self) -> PyResult<DataTypeMap>

Given the current Expr return the DataTypeMap which represents the PythonType, Arrow DataType, and SqlType Enum which represents

pub fn python_value(&self, py: Python<'_>) -> PyResult<PyObject>

Extracts the Expr value into a PyObject that can be shared with Python

pub fn rex_call_operands(&self) -> PyResult<Vec<PyExpr>>

Row expressions, Rex(s), operate on the concept of operands. Different variants of Expressions, Expr(s), store those operands in different datastructures. This function examines the Expr variant and returns the operands to the calling logic as a Vec of PyExpr instances.

pub fn rex_call_operator(&self) -> PyResult<String>

Extracts the operator associated with a RexType::Call

pub fn column_name(&self, plan: PyLogicalPlan) -> PyResult<String>

pub fn order_by(&self, order_by: Vec<PySortExpr>) -> PyExprFuncBuilder

pub fn filter(&self, filter: PyExpr) -> PyExprFuncBuilder

pub fn distinct(&self) -> PyExprFuncBuilder

pub fn null_treatment(&self, null_treatment: NullTreatment) -> PyExprFuncBuilder

pub fn partition_by(&self, partition_by: Vec<PyExpr>) -> PyExprFuncBuilder

pub fn window_frame(&self, window_frame: PyWindowFrame) -> PyExprFuncBuilder

pub fn over( &self, partition_by: Option<Vec<PyExpr>>, window_frame: Option<PyWindowFrame>, order_by: Option<Vec<PySortExpr>>, null_treatment: Option<NullTreatment>, ) -> PyDataFusionResult<PyExpr>

impl PyExpr

pub fn _column_name(&self, plan: &LogicalPlan) -> PyDataFusionResult<String>

pub fn expr_to_field( expr: &Expr, input_plan: &LogicalPlan, ) -> PyDataFusionResult<Arc<Field>>

Create a Field representing an Expr, given an input LogicalPlan to resolve against

Trait Implementations

impl Clone for PyExpr

fn clone(&self) -> PyExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PyExpr

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

Formats the value using the given formatter.

impl From<Expr> for PyExpr

fn from(expr: Expr) -> PyExpr

Converts to this type from the input type.

impl From<PyExpr> for Expr

fn from(expr: PyExpr) -> Expr

Converts to this type from the input type.

impl IntoPy<Py<PyAny>> for PyExpr

fn into_py(self, py: Python<'_>) -> PyObject

👎Deprecated since 0.23.0: IntoPy is going to be replaced by IntoPyObject. See the migration guide (https://pyo3.rs/v0.23.0/migration) for more information.

Performs the conversion.

impl<'py> IntoPyObject<'py> for PyExpr

type Target = PyExpr

The Python output type

type Output = Bound<'py, <PyExpr as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for PyExpr

type Frozen = False

Whether the pyclass is frozen.

impl PyClassBaseType for PyExpr

type LayoutAsBase = PyClassObject<PyExpr>

type BaseNativeType = <PyExpr as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<PyExpr>

type PyClassMutability = <PyExpr as PyClassImpl>::PyClassMutability

impl PyClassImpl for PyExpr

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PyExpr>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClass__add__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __add__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__and__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __and__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__mod__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __mod__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__mul__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __mul__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__or__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __or__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__sub__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __sub__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__truediv__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __truediv__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a PyExpr

type Holder = Option<PyRef<'py, PyExpr>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut PyExpr

type Holder = Option<PyRefMut<'py, PyExpr>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<PyExpr> for PyClassImplCollector<PyExpr>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyExpr

const NAME: &'static str = "RawExpr"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

👎Deprecated since 0.23.0: renamed to PyTypeInfo::type_object

Deprecated name for PyTypeInfo::type_object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_type_of

Deprecated name for PyTypeInfo::is_type_of.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_exact_type_of

Deprecated name for PyTypeInfo::is_exact_type_of.

impl DerefToPyAny for PyExpr

impl HasCustomRichCmp for PyExpr