Struct datafusion_python::expr::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: ScalarValue) -> 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) -> PyExpr

Create a sort PyExpr from an existing PyExpr.

pub fn is_null(&self) -> PyExpr

pub fn cast(&self, to: PyArrowType<DataType>) -> 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>

impl PyExpr

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

pub fn expr_to_field( expr: &Expr, input_plan: &LogicalPlan ) -> Result<DFField, DataFusionError>

Create a DFField 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

Performs the conversion.

impl PyClass for PyExpr

type Frozen = False

Whether the pyclass is frozen.

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 Layout = PyCell<PyExpr>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<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: &'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: &'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

type AsRefTarget = PyCell<PyExpr>

Utility type to make Py::as_ref work.

const NAME: &'static str = _

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<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

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

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.