Overtime events

Author: gatesn

vortex-expr/src/exprs/get_item.rs

@@ -65,14 +65,23 @@ impl VTable for GetItem {
     }
 
     fn return_dtype(&self, expr: &ExpressionView<Self>, scope: &DType) -> VortexResult<DType> {
-        let input = expr.children()[0].return_dtype(scope)?;
-        input
+        let struct_dtype = expr.children()[0].return_dtype(scope)?;
+        let field_dtype = struct_dtype
             .as_struct_fields_opt()
             .and_then(|st| st.field(expr.data()))
-            .map(|f| f.union_nullability(input.nullability()))
             .ok_or_else(|| {
                 vortex_err!("Couldn't find the {} field in the input scope", expr.data())
-            })
+            })?;
+
+        // Match here to avoid cloning the dtype if nullability doesn't need to change
+        if matches!(
+            (struct_dtype.nullability(), field_dtype.nullability()),
+            (Nullability::Nullable, Nullability::NonNullable)
+        ) {
+            return Ok(field_dtype.with_nullability(Nullability::Nullable));
+        }
+
+        Ok(field_dtype)
     }
 
     fn evaluate(&self, expr: &ExpressionView<Self>, scope: &ArrayRef) -> VortexResult<ArrayRef> {

vortex-expr/src/view.rs

@@ -21,11 +21,13 @@ impl<'a, V: VTable> ExpressionView<'a, V> {
     /// # Panics
     ///
     /// Panics if the expression cannot be downcast to the specified vtable type.
+    #[inline]
     pub fn new(expression: &'a Expression) -> Self {
         Self::try_new(expression).vortex_expect("Failed to downcast expression")
     }
 
     /// Attempts to wrap up the given expression as an [`ExpressionView`] of the specified vtable type.
+    #[inline]
     pub fn try_new(expression: &'a Expression) -> VortexResult<Self> {
         expression.vtable().as_opt::<V>().ok_or_else(|| {
             vortex_err!(

vortex-expr/src/vtable.rs

@@ -195,10 +195,12 @@ pub trait DynExprVTable: 'static + Send + Sync + private::Sealed {
 pub struct VTableAdapter<V>(V);
 
 impl<V: VTable> DynExprVTable for VTableAdapter<V> {
+    #[inline(always)]
     fn as_any(&self) -> &dyn Any {
         self
     }
 
+    #[inline(always)]
     fn id(&self) -> ExprId {
         V::id(&self.0)
     }