Enum Expression 

pub enum Expression {
    Literal(Scalar),
    Column(ColumnName),
    Predicate(Box<Predicate>),
    Struct(Vec<ExpressionRef>, Option<ExpressionRef>),
    StructPatch(ExpressionStructPatch),
    Unary(UnaryExpression),
    Binary(BinaryExpression),
    Variadic(VariadicExpression),
    Opaque(OpaqueExpression),
    Unknown(String),
    ParseJson(ParseJsonExpression),
    MapToStruct(MapToStructExpression),
    Cast(CastExpression),
}

A SQL expression.

These expressions do not track or validate data types, other than the type of literals. It is up to the expression evaluator to validate the expression against a schema and add appropriate casts as required.

Variants

Literal(Scalar)

A literal value.

Column(ColumnName)

A column reference by name. A ColumnName is a path, so a multi-segment name like add.stats.numRecords descends one nested struct field per segment, matching by name.

Predicate(Box<Predicate>)

A predicate treated as a boolean expression

Struct(Vec<ExpressionRef>, Option<ExpressionRef>)

A struct computed from one expression per output field, in field order.

Field names and nullability come from the surrounding output schema (the evaluator’s result_type, such as a Project’s target field), and each field expression’s type is validated against the schema, so building a struct takes both. The expression count must equal the output field count.

The optional nullability predicate says when to keep the struct: a row survives only where it is true, and nulls entirely where it is false or null.

CASE WHEN keep_pred THEN struct(expr1, expr2, ...) END

StructPatch(ExpressionStructPatch)

A sparse patch of a struct. More efficient than Struct for wide schemas where only a few fields change, achieving O(changes) instead of O(schema_width) complexity.

Unary(UnaryExpression)

An expression that takes one expression as input.

Binary(BinaryExpression)

An expression that takes two expressions as input.

Variadic(VariadicExpression)

An expression that takes a variable number of expressions as input.

Opaque(OpaqueExpression)

An expression that the engine defines and implements. Kernel interacts with the expression only through methods provided by the OpaqueExpressionOp trait.

Unknown(String)

An unknown expression (i.e. one that neither kernel nor engine attempts to evaluate). For data skipping purposes, kernel treats unknown expressions as if they were literal NULL values (which may disable skipping if it “poisons” the predicate), but engines MUST NOT attempt to interpret them as NULL when evaluating query filters because it could produce incorrect results. For example, converting WHERE <fancy-udf-invocation> IS NULL to WHERE <unknown> IS NULL to WHERE NULL IS NULL is equivalent to WHERE TRUE and would include all rows – almost certainly NOT what the query author intended. Use Expression::Opaque for expressions kernel doesn’t understand but which engine can still evaluate.

ParseJson(ParseJsonExpression)

Parse a JSON string expression into a struct with the given schema. Unparseable input, which includes an empty string, must yield NULL rather than error; see ParseJsonExpression.

MapToStruct(MapToStructExpression)

Extract keys from a Map<String, String> and parse values into a typed struct. See MapToStructExpression for how values are parsed.

Cast(CastExpression)

Cast a child expression to a target type. See CastExpression.

Implementations

impl Expression

pub fn references(&self) -> HashSet<&ColumnName>

Returns a set of columns referenced by this expression.

pub fn column(field_names: impl CollectInto<ColumnName>) -> Expression

Create a new column name expression from input satisfying FromIterator for ColumnName.

pub fn literal(value: impl Into<Scalar>) -> Self

Create a new expression for a literal value

pub const fn null_literal(data_type: DataType) -> Self

Creates a NULL literal expression

pub fn from_pred(value: Predicate) -> Self

Wraps a predicate as a boolean-valued expression

pub fn struct_from( exprs: impl IntoIterator<Item = impl Into<Arc<Self>>>, ) -> Self

Create a new struct expression.

The field names and types are supplied by the caller at evaluation time via the result_type parameter of the expression evaluator. Use this when the schema is always available from external context (e.g. the expression is the top-level output of crate::ExpressionEvaluator).

pub fn struct_with_nullability_from( exprs: impl IntoIterator<Item = impl Into<Arc<Self>>>, nullability_predicate: impl Into<Arc<Self>>, ) -> Self

Create a new struct expression with a nullability predicate.

When the predicate evaluates to false or null for a row, the entire struct is null for that row.

pub fn struct_patch<P>(patch: P) -> DeltaResult<Self>

where P: TryInto<ExpressionStructPatch>, Error: From<P::Error>,

Creates a new struct patch expression from a raw patch or patch builder.

Returns an expression that applies the supplied sparse patch to an input struct. Passing a raw ExpressionStructPatch is infallible; passing an ExpressionStructPatchBuilder validates and lowers the recorded operations before constructing the expression.

Errors

Returns an error if the supplied patch builder contains conflicting operations.

pub fn is_null(self) -> Predicate

Create a new predicate self IS NULL

pub fn is_not_null(self) -> Predicate

Create a new predicate self IS NOT NULL

pub fn eq(self, other: impl Into<Self>) -> Predicate

Create a new predicate self == other

pub fn ne(self, other: impl Into<Self>) -> Predicate

Create a new predicate self != other

pub fn le(self, other: impl Into<Self>) -> Predicate

Create a new predicate self <= other

pub fn lt(self, other: impl Into<Self>) -> Predicate

Create a new predicate self < other

pub fn ge(self, other: impl Into<Self>) -> Predicate

Create a new predicate self >= other

pub fn gt(self, other: impl Into<Self>) -> Predicate

Create a new predicate self > other

pub fn distinct(self, other: impl Into<Self>) -> Predicate

Create a new predicate DISTINCT(self, other)

pub fn unary(op: UnaryExpressionOp, expr: impl Into<Expression>) -> Self

Creates a new unary expression

pub fn binary( op: BinaryExpressionOp, lhs: impl Into<Expression>, rhs: impl Into<Expression>, ) -> Self

Creates a new binary expression lhs OP rhs

pub fn variadic( op: VariadicExpressionOp, exprs: impl IntoIterator<Item = impl Into<Expression>>, ) -> Self

Creates a new variadic expression

pub fn coalesce(exprs: impl IntoIterator<Item = impl Into<Expression>>) -> Self

Creates a new COALESCE expression that returns the first non-null value.

COALESCE evaluates expressions in order and returns the first non-null result. If all expressions evaluate to null, the result is null.

pub fn array(exprs: impl IntoIterator<Item = impl Into<Expression>>) -> Self

Creates a new Array constructor expression. See VariadicExpressionOp::Array.

pub fn opaque( op: impl OpaqueExpressionOp, exprs: impl IntoIterator<Item = Expression>, ) -> Self

Creates a new opaque expression

pub fn unknown(name: impl Into<String>) -> Self

Creates a new unknown expression

pub fn parse_json( json_expr: impl Into<Expression>, output_schema: SchemaRef, ) -> Self

Creates a new ParseJson expression that parses a JSON string column into a struct. This is the inverse of UnaryExpressionOp::ToJson - it converts a JSON-encoded string into a struct. Sub-millisecond timestamp precision does not survive the round trip, since ToJson truncates it.

pub fn map_to_struct(map_expr: impl Into<Expression>) -> Self

Extracts keys from a Map<String, String> and parses values into a typed struct. The output struct schema is determined by the evaluator’s result_type. An empty-string value is the exception (aligning with Spark): it casts to itself for string, to empty bytes for binary, and to null for every other type. See MapToStructExpression for the full contract.

pub fn cast(expr: impl Into<Expression>, target: DataType) -> Self

Creates a new cast of expr to target, following SQL CAST semantics (unrepresentable values become NULL). See CastExpression.

Trait Implementations

impl<R: Into<Expression>> Add<R> for Expression

type Output = Expression

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Self::Output

Performs the + operation.

impl ArrowOpaqueExpression for Expression

Available on crate feature arrow-expression and crate feature default-engine-base and (crate features arrow-conversion or declarative-plans or default-engine-base) only.

fn arrow_opaque( op: impl ArrowOpaqueExpressionOp, exprs: impl IntoIterator<Item = Expression>, ) -> Expression

Creates a new opaque expression. See also Expression::opaque.

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expression

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

Formats the value using the given formatter.

impl<R: Into<Expression>> Div<R> for Expression

type Output = Expression

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Self

Performs the / operation.

impl From<&Expression> for Expression

Available on crate feature declarative-plans only.

fn from(expr: &Expression) -> Self

Converts to this type from the input type.

impl From<ColumnName> for Expression

fn from(value: ColumnName) -> Self

Converts to this type from the input type.

impl From<Predicate> for Expression

fn from(value: Predicate) -> Self

Converts to this type from the input type.

impl From<Scalar> for Expression

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl<R: Into<Expression>> Mul<R> for Expression

type Output = Expression

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self

Performs the * operation.

impl PartialEq for Expression

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Expression

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expression

impl<R: Into<Expression>> Sub<R> for Expression

type Output = Expression

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Self

Performs the - operation.