Expressions¶

Vortex expressions represent simple filtering conditions on the rows of a Vortex array. For example, the following expression represents the set of rows for which the age column lies between 23 and 55:

>>> import vortex.expr
>>> age = vortex.expr.column("age")
>>> (23 > age) & (age < 55)

Expressions are picklable, so a filter built in one process can be sent to another (for example to a multiprocessing worker or a Ray task). Pickling uses the same protobuf wire format exposed by vortex.expr.Expr.serialize() and vortex.expr.deserialize().

`Expr`	An expression describes how to filter rows when reading an array from a file.
`root`	Create an expression that refers to the identity scope.
`column`	Create an expression that refers to a column by its name.
`literal`	Create an expression that represents a literal value.
`get_item`	Extract a named field from a struct expression.
`not_`	Negate a Boolean expression.
`and_`	True if both arguments are true.
`or_`	True if either argument is true.
`and_collect`	Combine expressions with logical AND using a balanced tree.
`or_collect`	Combine expressions with logical OR using a balanced tree.
`eq`	True where both arguments are equal.
`not_eq`	True where the arguments are not equal.
`gt`	True where left is greater than right.
`gt_eq`	True where left is greater than or equal to right.
`lt`	True where left is less than right.
`lt_eq`	True where left is less than or equal to right.
`add`	The sum of the arguments, erroring on overflow.
`sub`	The difference between the arguments.
`mul`	The product of the arguments.
`div`	left divided by right.
`between`	True where child lies between lower and upper.
`is_null`	Checks which elements of its child are null.
`is_not_null`	Creates an expression that checks for non-null values.
`fill_null`	Replace null values with a fill value.
`like`	A SQL `LIKE` expression.
`ilike`	A case-insensitive SQL `ILIKE` expression.
`not_like`	A negated SQL `NOT LIKE` expression.
`not_ilike`	A negated case-insensitive SQL `NOT ILIKE` expression.
`byte_length`	The byte length of each element, akin to SQL `OCTET_LENGTH()`.
`select`	Project only the named fields of a struct expression.
`select_exclude`	Project every field of a struct expression except the named ones.
`pack`	Pack expressions into a struct with named fields.
`merge`	Merge struct expressions into a single struct.
`list_contains`	True where the list contains the given value.
`list_length`	The number of elements in each list, akin to SQL `CARDINALITY()`.
`list_sum`	The sum of the elements of each list.
`case_when`	A `CASE WHEN` expression.
`zip_`	Select element-wise between two expressions based on a boolean mask.
`mask`	Null out the elements of an expression where the mask is true.
`cast`	Cast an expression to a compatible type.
`ext_storage`	Extract the storage values of an extension-typed expression.
`variant_get`	Extract a path from a Variant expression.
`deserialize`	Rebuild an expression from its protobuf wire format.

Leaves and scope¶

vortex.expr.root()¶

Create an expression that refers to the identity scope.

That is, it returns the full input that the extension is run against.

Return type:: vortex.Expr

Examples

>>> import vortex.expr as ve
>>> ve.root()
<vortex.Expr object at ...>

vortex.expr.column(name)¶

Create an expression that refers to a column by its name.

Parameters:: name (str) – The name of the column.
Return type:: vortex.Expr

Examples

>>> import vortex.expr as ve
>>> ve.column("age")
<vortex.Expr object at ...>

Boolean logic¶

vortex.expr.not_(child)¶

Negate a Boolean expression.

Parameters:: child (Any) – A boolean expression.
Return type:: vortex.Expr

Examples

>>> import vortex.expr as ve
>>> import vortex as vx
>>> ve.not_(ve.literal(vx.int_(), 42) == ve.literal(vx.int_(), 42))
<vortex.Expr object at ...>

vortex.expr.and_(left, right)¶

True if both arguments are true.

Parameters:

left (Expr) – A boolean expression.
right (Expr) – A boolean expression.

Return type:

Expressions¶

Leaves and scope¶

Boolean logic¶

Comparisons and arithmetic¶

Nullability¶

Strings¶

Structs¶

Lists¶

Conditionals and conversions¶

Serialization¶

The expression class¶