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 literal_with_metadata( value: PyScalarValue, metadata: HashMap<String, String>, ) -> PyExpr

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

pub fn alias( &self, name: &str, metadata: Option<HashMap<String, String>>, ) -> 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 try_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<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>>

Extracts the Expr value into a Py 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>

pub fn to_bytes<'py>( &'py self, py: Python<'py>, ctx: Option<PySessionContext>, ) -> PyDataFusionResult<Bound<'py, PyBytes>>

Serialize this Expr to protobuf bytes.

When ctx is supplied, encoding routes through the session’s installed LogicalExtensionCodec so user FFI codecs see the encode path. Without ctx a default-inner Python codec is used; Python scalar UDFs still inline when in-band encoding lands, non-Python UDFs fall through to the default codec.

pub fn from_bytes( ctx: PySessionContext, proto_msg: Bound<'_, PyBytes>, ) -> PyDataFusionResult<Self>

Decode an Expr from protobuf bytes against the session’s function registry and logical codec.

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 duplicate 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 DerefToPyAny for PyExpr

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<'a, 'py> FromPyObject<'a, 'py> for PyExpr

where Self: Clone,

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

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

const NAME: &str = "RawExpr"

Name of the class.

type Frozen = True

Whether the pyclass is frozen.

impl PyClassBaseType for PyExpr

type LayoutAsBase = <PyExpr as PyClassImpl>::Layout

type BaseNativeType = <PyExpr as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<PyExpr>

type PyClassMutability = <PyExpr as PyClassImpl>::PyClassMutability

type Layout<T: PyClassImpl> = <<PyExpr as PyClassBaseType>::BaseNativeType as PyClassBaseType>::Layout<T>

The type of object layout to use for ancestors or descendants of this type.

impl PyClassImpl for PyExpr

const MODULE: Option<&str>

Module which the class will be associated with.

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)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// A PyExpr that can be used on a DataFrame

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<PyExpr as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<PyExpr>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = NoopThreadChecker

This handles following two situations:

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

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 lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyClass__add__SlotFragment<PyExpr> for PyClassImplCollector<PyExpr>

unsafe fn __add__( self, py: Python<'_>, _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<'_>, _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<'_>, _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<'_>, _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<'_>, _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<'_>, _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<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

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

impl PyMethods<PyExpr> for PyClassImplCollector<PyExpr>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyExpr

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

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 is_type_of(object: &Bound<'_, PyAny>) -> bool

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

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

Checks if object is an instance of this type.