Struct ExpressionView 

pub struct ExpressionView<'a, V: VTable> { /* private fields */ }

A view over an Expression with an associated vtable, allowing typed access to the expression’s instance data.

Implementations

impl ExpressionView<'_, Between>

pub fn child(&self) -> &Expression

pub fn lower(&self) -> &Expression

pub fn upper(&self) -> &Expression

pub fn to_binary_expr(&self) -> Expression

impl ExpressionView<'_, Binary>

pub fn lhs(&self) -> &Expression

pub fn rhs(&self) -> &Expression

pub fn operator(&self) -> Operator

impl ExpressionView<'_, DynamicComparison>

pub fn lhs(&self) -> &Expression

pub fn scalar(&self) -> Option<Scalar>

impl ExpressionView<'_, ListContains>

pub fn list(&self) -> &Expression

pub fn needle(&self) -> &Expression

impl ExpressionView<'_, Pack>

pub fn field(&self, field_name: &FieldName) -> VortexResult<Expression>

impl ExpressionView<'_, Select>

pub fn child(&self) -> &Expression

pub fn as_include(&self, field_names: &FieldNames) -> VortexResult<Expression>

Turn the select expression into an include, relative to a provided array of field names.

For example:

let field_names = FieldNames::from(["a", "b", "c"]);
let include = select(["a"], root());
let exclude = select_exclude(["b", "c"], root());
assert_eq!(
    &include.as_::<Select>().as_include(&field_names).unwrap(),
    &exclude.as_::<Select>().as_include(&field_names).unwrap(),
);

impl<'a, V: VTable> ExpressionView<'a, V>

pub fn new(expression: &'a Expression) -> Self

Wrap up the given expression as an ExpressionView of the specified vtable type.

Panics

Panics if the expression cannot be downcast to the specified vtable type.

pub fn maybe_new(expression: &'a Expression) -> Option<Self>

Attempts to wrap up the given expression as an ExpressionView of the specified vtable type.

impl<'a, V: VTable> ExpressionView<'a, V>

pub fn vtable(&self) -> &'a V

Returns the vtable for this expression.

pub fn data(&self) -> &'a V::Instance

Returns the instance data for this expression.

Methods from Deref<Target = Expression>

pub fn is<V: VTable>(&self) -> bool

Returns if the expression is an instance of the given vtable.

pub fn as_<V: VTable>(&self) -> ExpressionView<'_, V>

Returns a typed view of this expression for the given vtable.

Panics

Panics if the expression’s encoding or metadata cannot be cast to the specified vtable.

pub fn as_opt<V: VTable>(&self) -> Option<ExpressionView<'_, V>>

Returns a typed view of this expression for the given vtable, if the types match.

pub fn id(&self) -> ExprId

Returns the expression ID.

pub fn vtable(&self) -> &ExprVTable

Returns the expression’s vtable.

pub fn data(&self) -> &Arc<dyn Any + Send + Sync>

Returns the opaque data of the expression.

pub fn children(&self) -> &Arc<[Expression]>

Returns the children of this expression.

pub fn child(&self, n: usize) -> &Expression

Returns the n’th child of this expression.

pub fn child_name(&self, n: usize) -> ChildName

Returns the name of the n’th child of this expression.

pub fn serialize_metadata(&self) -> VortexResult<Option<Vec<u8>>>

Returns the serialized metadata for this expression.

pub fn return_dtype(&self, scope: &DType) -> VortexResult<DType>

Computes the return dtype of this expression given the input dtype.

pub fn evaluate(&self, scope: &ArrayRef) -> VortexResult<ArrayRef>

Evaluates the expression in the given scope.

pub fn stat_falsification( &self, catalog: &mut dyn StatsCatalog, ) -> Option<Expression>

An expression over zone-statistics which implies all records in the zone evaluate to false.

Given an expression, e, if e.stat_falsification(..) evaluates to true, it is guaranteed that e evaluates to false on all records in the zone. However, the inverse is not necessarily true: even if the falsification evaluates to false, e need not evaluate to true on all records.

The StatsCatalog can be used to constrain or rename stats used in the final expr.

Examples

• An expression over one variable: x > 0 is false for all records in a zone if the maximum value of the column x in that zone is less than or equal to zero: max(x) <= 0.
• An expression over two variables: x > y becomes max(x) <= min(y).
• A conjunctive expression: x > y AND z < x becomes `max(x) <= min(y) OR min(z) >= max(x).

Some expressions, in theory, have falsifications but this function does not support them such as x < (y < z) or x LIKE "needle%".

pub fn stat_max(&self, catalog: &mut dyn StatsCatalog) -> Option<Expression>

An expression for the upper non-null bound of this expression, if available.

This function returns None if there is no upper bound, or it is difficult to compute.

The returned expression evaluates to null if the maximum value is unknown. In that case, you must not assume the array is empty nor may you assume the array only contains non-null values.

pub fn stat_min(&self, catalog: &mut dyn StatsCatalog) -> Option<Expression>

An expression for the lower non-null bound of this expression, if available.

See Expression::stat_max for important details.

pub fn stat_nan_count( &self, catalog: &mut dyn StatsCatalog, ) -> Option<Expression>

An expression for the NaN count for a column, if available.

This method returns None if the NaNCount stat is unknown.

pub fn stat_field_path(&self) -> Option<FieldPath>

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

Format the expression as a compact string.

Since this is a recursive formatter, it is exposed on the public Expression type. See fmt_data that is only implemented on the vtable trait.

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

Format the instance data of the expression as a string for rendering..

pub fn display_tree(&self) -> impl Display

Display the expression as a formatted tree structure.

This provides a hierarchical view of the expression that shows the relationships between parent and child expressions, making complex nested expressions easier to understand and debug.

Example

// Build a complex nested expression
let complex_expr = select(
    ["result"],
    and(
        not(eq(get_item("status", root()), lit("inactive"))),
        and(
            Like.new_expr(LikeOptions::default(), [get_item("name", root()), lit("%admin%")]),
            gt(
                cast(get_item("score", root()), DType::Primitive(PType::F64, Nullability::NonNullable)),
                lit(75.0)
            )
        )
    )
);

println!("{}", complex_expr.display_tree());

This produces output like:

Select(include): {result}
└── Binary(and)
    ├── lhs: Not
    │   └── Binary(=)
    │       ├── lhs: GetItem(status)
    │       │   └── Root
    │       └── rhs: Literal(value: "inactive", dtype: utf8)
    └── rhs: Binary(and)
        ├── lhs: Like
        │   ├── child: GetItem(name)
        │   │   └── Root
        │   └── pattern: Literal(value: "%admin%", dtype: utf8)
        └── rhs: Binary(>)
            ├── lhs: Cast(target: f64)
            │   └── GetItem(score)
            │       └── Root
            └── rhs: Literal(value: 75f64, dtype: f64)

Trait Implementations

impl<'a, V: VTable> Deref for ExpressionView<'a, V>

type Target = Expression

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.