Expressions

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

vortex-array/src/arrays/scalar_fn/array.rs

@@ -8,7 +8,7 @@ use vortex_error::vortex_ensure;
 use crate::Array;
 use crate::ArrayRef;
 use crate::arrays::ScalarFnVTable;
-use crate::expr::BoundExpression;
+use crate::expr::ScalarFn;
 use crate::stats::ArrayStats;
 use crate::vtable::ArrayVTable;
 use crate::vtable::ArrayVTableExt;
@@ -17,7 +17,7 @@ use crate::vtable::ArrayVTableExt;
 pub struct ScalarFnArray {
     // NOTE(ngates): we should fix vtables so we don't have to hold this
     pub(super) vtable: ArrayVTable,
-    pub(super) bound: BoundExpression,
+    pub(super) bound: ScalarFn,
     pub(super) dtype: DType,
     pub(super) len: usize,
     pub(super) children: Vec<ArrayRef>,
@@ -26,11 +26,7 @@ pub struct ScalarFnArray {
 
 impl ScalarFnArray {
     /// Create a new ScalarFnArray from a scalar function and its children.
-    pub fn try_new(
-        bound: BoundExpression,
-        children: Vec<ArrayRef>,
-        len: usize,
-    ) -> VortexResult<Self> {
+    pub fn try_new(bound: ScalarFn, children: Vec<ArrayRef>, len: usize) -> VortexResult<Self> {
         let arg_dtypes: Vec<_> = children.iter().map(|c| c.dtype().clone()).collect();
         let dtype = bound.return_dtype(&arg_dtypes)?;
 

vortex-array/src/arrays/scalar_fn/metadata.rs

@@ -3,10 +3,10 @@
 
 use vortex_dtype::DType;
 
-use crate::expr::BoundExpression;
+use crate::expr::ScalarFn;
 
 #[derive(Clone, Debug)]
 pub struct ScalarFnMetadata {
-    pub(super) bound: BoundExpression,
+    pub(super) bound: ScalarFn,
     pub(super) child_dtypes: Vec<DType>,
 }

vortex-array/src/arrays/scalar_fn/vtable/mod.rs

@@ -29,9 +29,9 @@ use crate::arrays::scalar_fn::array::ScalarFnArray;
 use crate::arrays::scalar_fn::metadata::ScalarFnMetadata;
 use crate::execution::ExecutionCtx;
 use crate::expr;
-use crate::expr::BoundExpression;
 use crate::expr::ExecutionArgs;
 use crate::expr::ExprVTable;
+use crate::expr::ScalarFn;
 use crate::optimizer::rules::MatchKey;
 use crate::optimizer::rules::Matcher;
 use crate::serde::ArrayChildren;
@@ -162,7 +162,7 @@ pub trait ScalarFnArrayExt: expr::VTable {
         options: Self::Options,
         children: impl Into<Vec<ArrayRef>>,
     ) -> VortexResult<ArrayRef> {
-        let bound = BoundExpression::new_static(self, options);
+        let bound = ScalarFn::new_static(self, options);
 
         let children = children.into();
         vortex_ensure!(

vortex-array/src/expr/display.rs

@@ -5,8 +5,8 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 use std::ops::Deref;
 
-use crate::expr::BoundExpression;
 use crate::expr::Expression;
+use crate::expr::ScalarFn;
 
 pub enum DisplayFormat {
     Compact,
@@ -19,7 +19,7 @@ impl Display for DisplayTreeExpr<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         pub use termtree::Tree;
         fn make_tree(expr: &Expression) -> Result<Tree<String>, std::fmt::Error> {
-            let bound: &BoundExpression = expr.deref();
+            let bound: &ScalarFn = expr.deref();
             let node_name = format!("{}", bound);
 
             // Get child names for display purposes

vortex-array/src/expr/expression.rs

@@ -17,9 +17,9 @@ use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
 use crate::expr::Root;
+use crate::expr::ScalarFn;
 use crate::expr::StatsCatalog;
 use crate::expr::VTable;
-use crate::expr::bound::BoundExpression;
 use crate::expr::display::DisplayTreeExpr;
 use crate::expr::stats::Stat;
 
@@ -29,36 +29,39 @@ use crate::expr::stats::Stat;
 /// expression consists of an encoding (vtable), heap-allocated metadata, and child expressions.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Expression {
-    /// The bound expression for this node.
-    bound: BoundExpression,
+    /// The scalar fn for this node.
+    scalar_fn: ScalarFn,
     /// Any children of this expression.
     children: Arc<[Expression]>,
 }
 
 impl Deref for Expression {
-    type Target = BoundExpression;
+    type Target = ScalarFn;
 
     fn deref(&self) -> &Self::Target {
-        &self.bound
+        &self.scalar_fn
     }
 }
 
 impl Expression {
-    /// Create a new expression node from a bound expression and its children.
+    /// Create a new expression node from a scalar_fn expression and its children.
     pub fn try_new(
-        bound: BoundExpression,
+        scalar_fn: ScalarFn,
         children: impl Into<Arc<[Expression]>>,
     ) -> VortexResult<Self> {
         let children: Arc<[Expression]> = children.into();
 
         vortex_ensure!(
-            bound.signature().arity().matches(children.len()),
+            scalar_fn.signature().arity().matches(children.len()),
             "Expression arity mismatch: expected {} children but got {}",
-            bound.signature().arity(),
+            scalar_fn.signature().arity(),
             children.len()
         );
 
-        Ok(Self { bound, children })
+        Ok(Self {
+            scalar_fn,
+            children,
+        })
     }
 
     /// Returns true if this expression is of the given vtable type.
@@ -77,6 +80,11 @@ impl Expression {
             .vortex_expect("Expression options type mismatch")
     }
 
+    /// Returns the scalar fn vtable for this expression.
+    pub fn scalar_fn(&self) -> &ScalarFn {
+        &self.scalar_fn
+    }
+
     /// Returns the children of this expression.
     pub fn children(&self) -> &Arc<[Expression]> {
         &self.children
@@ -111,15 +119,15 @@ impl Expression {
             .iter()
             .map(|c| c.return_dtype(scope))
             .try_collect()?;
-        self.bound.return_dtype(&dtypes)
+        self.scalar_fn.return_dtype(&dtypes)
     }
 
     /// Evaluates the expression in the given scope, returning an array.
     pub fn evaluate(&self, scope: &ArrayRef) -> VortexResult<ArrayRef> {
         if self.is::<Root>() {
             return Ok(scope.clone());
         }
-        self.bound.evaluate(self, scope)
+        self.scalar_fn.evaluate(self, scope)
     }
 
     /// An expression over zone-statistics which implies all records in the zone evaluate to false.

vortex-array/src/expr/mod.rs

@@ -12,7 +12,7 @@
 
 use std::hash::Hash;
 use std::hash::Hasher;
-use std::ptr;
+use std::sync::Arc;
 
 use arcref::ArcRef;
 use vortex_dtype::FieldName;
@@ -26,7 +26,6 @@ pub mod aliases;
 pub mod analysis;
 #[cfg(feature = "arbitrary")]
 pub mod arbitrary;
-mod bound;
 pub mod display;
 mod expression;
 mod exprs;
@@ -35,6 +34,7 @@ pub mod forms;
 mod options;
 pub mod proto;
 pub mod pruning;
+mod scalar_fn;
 pub mod session;
 mod signature;
 mod simplify;
@@ -44,10 +44,10 @@ pub mod traversal;
 mod vtable;
 
 pub use analysis::*;
-pub use bound::*;
 pub use expression::*;
 pub use exprs::*;
 pub use pruning::StatsCatalog;
+pub use scalar_fn::*;
 pub use vtable::*;
 
 pub type ExprId = ArcRef<str>;
@@ -85,14 +85,13 @@ fn split_inner(expr: &Expression, exprs: &mut Vec<Expression>) {
     }
 }
 
-/// An expression wrapper that performs pointer equality.
+/// An expression wrapper that performs pointer equality on child expressions.
 #[derive(Clone)]
 pub struct ExactExpr(pub Expression);
-
 impl PartialEq for ExactExpr {
     fn eq(&self, other: &Self) -> bool {
-        self.0.id() == other.0.id()
-            && ptr::addr_eq(self.0.options().as_any(), other.0.options().as_any())
+        self.0.scalar_fn() == other.0.scalar_fn()
+            && Arc::ptr_eq(self.0.children(), other.0.children())
     }
 }
 impl Eq for ExactExpr {}

vortex-array/src/expr/bound.rs vortex-array/src/expr/scalar_fn.rsvortex-array/src/expr/bound.rs renamed to vortex-array/src/expr/scalar_fn.rs

@@ -24,12 +24,12 @@ use crate::expr::options::ExpressionOptions;
 use crate::expr::signature::ExpressionSignature;
 
 /// An instance of an expression bound to some invocation options.
-pub struct BoundExpression {
+pub struct ScalarFn {
     vtable: ExprVTable,
     options: Box<dyn Any + Send + Sync>,
 }
 
-impl BoundExpression {
+impl ScalarFn {
     /// Create a new bound expression from raw vtable and options.
     ///
     /// # Safety
@@ -103,16 +103,16 @@ impl BoundExpression {
     }
 }
 
-impl Clone for BoundExpression {
+impl Clone for ScalarFn {
     fn clone(&self) -> Self {
-        BoundExpression {
+        ScalarFn {
             vtable: self.vtable.clone(),
             options: self.vtable.as_dyn().options_clone(self.options.deref()),
         }
     }
 }
 
-impl Debug for BoundExpression {
+impl Debug for ScalarFn {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("BoundExpression")
             .field("vtable", &self.vtable)
@@ -128,7 +128,7 @@ impl Debug for BoundExpression {
     }
 }
 
-impl Display for BoundExpression {
+impl Display for ScalarFn {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}(", self.vtable.id())?;
         self.vtable
@@ -138,7 +138,7 @@ impl Display for BoundExpression {
     }
 }
 
-impl PartialEq for BoundExpression {
+impl PartialEq for ScalarFn {
     fn eq(&self, other: &Self) -> bool {
         self.vtable == other.vtable
             && self
@@ -147,9 +147,9 @@ impl PartialEq for BoundExpression {
                 .options_eq(self.options.deref(), other.options.deref())
     }
 }
-impl Eq for BoundExpression {}
+impl Eq for ScalarFn {}
 
-impl Hash for BoundExpression {
+impl Hash for ScalarFn {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.vtable.hash(state);
         self.vtable

vortex-array/src/expr/vtable.rs

@@ -22,8 +22,8 @@ use vortex_vector::VectorOps;
 use crate::ArrayRef;
 use crate::expr::ExprId;
 use crate::expr::StatsCatalog;
-use crate::expr::bound::BoundExpression;
 use crate::expr::expression::Expression;
+use crate::expr::scalar_fn::ScalarFn;
 use crate::expr::stats::Stat;
 
 /// This trait defines the interface for expression vtables, including methods for
@@ -247,9 +247,9 @@ impl Display for EmptyOptions {
 
 /// Factory functions for static vtables.
 pub trait VTableExt: VTable {
-    /// Bind this vtable with the given options into a [`BoundExpression`].
-    fn bind(&'static self, options: Self::Options) -> BoundExpression {
-        BoundExpression::new_static(self, options)
+    /// Bind this vtable with the given options into a [`ScalarFn`].
+    fn bind(&'static self, options: Self::Options) -> ScalarFn {
+        ScalarFn::new_static(self, options)
     }
 
     /// Create a new expression with this vtable and the given options and children.
@@ -535,12 +535,9 @@ impl ExprVTable {
     }
 
     /// Deserialize an options of this expression vtable from metadata.
-    pub fn deserialize(&self, metadata: &[u8]) -> VortexResult<BoundExpression> {
+    pub fn deserialize(&self, metadata: &[u8]) -> VortexResult<ScalarFn> {
         Ok(unsafe {
-            BoundExpression::new_unchecked(
-                self.clone(),
-                self.as_dyn().options_deserialize(metadata)?,
-            )
+            ScalarFn::new_unchecked(self.clone(), self.as_dyn().options_deserialize(metadata)?)
         })
     }
 }