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 execute(&self, vector: &Vector, dtype: &DType) -> VortexResult<Vector>

Executes the expression over the given vector input scope.

pub fn stat_falsification( &self, catalog: &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_expression( &self, stat: Stat, catalog: &dyn StatsCatalog, ) -> Option<Expression>

Returns an expression representing the zoned statistic for the given stat, if available.

The StatsCatalog returns expressions that can be evaluated using the zone map as a scope. Expressions can implement this function to propagate such statistics through the expression tree. For example, the a + 10 expression could propagate min: min(a) + 10.

NOTE(gatesn): we currently cannot represent statistics over nested fields. Please file an issue to discuss a solution to this.

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

Returns an expression representing the zoned maximum statistic, if available.

See Self::stat_expression for details.

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

Returns an expression representing the zoned maximum statistic, if available.

See Self::stat_expression for details.

pub fn is_null_sensitive(&self) -> bool

Returns whether this expression itself is null-sensitive. See VTable::is_null_sensitive.

pub fn is_fallible(&self) -> bool

Returns whether this expression itself is fallible. See VTable::is_fallible.

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.