Overtime events

Author: gatesn

vortex-datafusion/src/convert/exprs.rs

@@ -378,18 +378,18 @@ mod tests {
         let col_expr = df_expr::Column::new("test_column", 0);
         let result = Expression::try_from_df(&col_expr).unwrap();
 
-        assert_snapshot!(result.display_tree().to_string(), @r"
-        GetItem(test_column)
-        └── Root
-        ");
+        assert_snapshot!(result.display_tree().to_string(), @r#"
+        vortex.get_item "test_column"
+        └── input: vortex.root
+        "#);
     }
 
     #[test]
     fn test_expr_from_df_literal() {
         let literal_expr = df_expr::Literal::new(ScalarValue::Int32(Some(42)));
         let result = Expression::try_from_df(&literal_expr).unwrap();
 
-        assert_snapshot!(result.display_tree().to_string(), @"Literal(value: 42i32, dtype: i32)");
+        assert_snapshot!(result.display_tree().to_string(), @"vortex.literal 42i32");
     }
 
     #[test]
@@ -401,12 +401,12 @@ mod tests {
 
         let result = Expression::try_from_df(&binary_expr).unwrap();
 
-        assert_snapshot!(result.display_tree().to_string(), @r"
-        Binary(=)
-        ├── lhs: GetItem(left)
-        │   └── Root
-        └── rhs: Literal(value: 42i32, dtype: i32)
-        ");
+        assert_snapshot!(result.display_tree().to_string(), @r#"
+        vortex.binary =
+        ├── lhs: vortex.get_item "left"
+        │   └── input: vortex.root 
+        └── rhs: vortex.literal 42i32
+        "#);
     }
 
     #[rstest]
@@ -425,10 +425,10 @@ mod tests {
 
         insta::allow_duplicates! {
             assert_snapshot!(result.display_tree().to_string(), @r#"
-            Like
-            ├── child: GetItem(text_col)
-            │   └── Root
-            └── pattern: Literal(value: "test%", dtype: utf8)
+            vortex.like LikeOptions { negated: false, case_insensitive: false }
+            ├── child: vortex.get_item "text_col"
+            │   └── input: vortex.root 
+            └── pattern: vortex.literal "test%"
             "#);
         }
     }
@@ -600,11 +600,11 @@ mod tests {
             Arc::new(ConfigOptions::new()),
         );
         let result = Expression::try_from_df(&get_field_expr).unwrap();
-        assert_snapshot!(result.display_tree().to_string(), @r"
-        GetItem(field1)
-        └── GetItem(my_struct)
-            └── Root
-        ");
+        assert_snapshot!(result.display_tree().to_string(), @r#"
+        vortex.get_item "field1"
+        └── input: vortex.get_item "my_struct"
+            └── input: vortex.root
+        "#);
     }
 
     #[test]

vortex-expr/src/display.rs

@@ -97,7 +97,7 @@ mod tests {
         use insta::assert_snapshot;
 
         let root_expr = root();
-        assert_snapshot!(root_expr.display_tree().to_string(), @"Root");
+        assert_snapshot!(root_expr.display_tree().to_string(), @"vortex.root");
 
         let lit_expr = lit(42);
         assert_snapshot!(lit_expr.display_tree().to_string(), @"Literal(value: 42i32, dtype: i32)");

vortex-expr/src/exprs/binary.rs

@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use prost::Message;
-use std::fmt::{Formatter, Pointer};
+use std::fmt::Formatter;
 use vortex_array::compute::{add, and_kleene, compare, div, mul, or_kleene, sub};
 use vortex_array::{compute, ArrayRef};
 use vortex_dtype::DType;
@@ -59,7 +59,7 @@ impl VTable for Binary {
     }
 
     fn fmt_data(&self, instance: &Self::Instance, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", instance)
+        write!(f, "{}", *instance)
     }
 
     fn return_dtype(&self, expr: &ExprInstance<Self>, scope: &DType) -> VortexResult<DType> {

vortex-expr/src/exprs/cast.rs

@@ -175,6 +175,6 @@ mod tests {
         assert_eq!(expr.to_string(), "cast($.value as i64)");
 
         let expr2 = cast(root(), DType::Bool(Nullability::Nullable));
-        assert_eq!(expr2.to_string(), "cast($, bool?)");
+        assert_eq!(expr2.to_string(), "cast($ as bool?)");
     }
 }

vortex-expr/src/exprs/literal.rs

@@ -59,6 +59,10 @@ impl VTable for Literal {
         write!(f, "{}", expr.data())
     }
 
+    fn fmt_data(&self, instance: &Self::Instance, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", instance)
+    }
+
     fn return_dtype(&self, expr: &ExprInstance<Self>, _scope: &DType) -> VortexResult<DType> {
         Ok(expr.data().dtype().clone())
     }

vortex-expr/src/exprs/select.rs

@@ -81,12 +81,13 @@ impl VTable for Select {
     }
 
     fn fmt_sql(&self, expr: &ExprInstance<Self>, f: &mut Formatter<'_>) -> std::fmt::Result {
+        expr.child().fmt_sql(f)?;
         match expr.data() {
             FieldSelection::Include(fields) => {
-                write!(f, "select({{{}}})", DisplayFieldNames(fields))
+                write!(f, "{{{}}}", DisplayFieldNames(fields))
             }
             FieldSelection::Exclude(fields) => {
-                write!(f, "select(~ {{{}}})", DisplayFieldNames(fields))
+                write!(f, "{{~ {}}}", DisplayFieldNames(fields))
             }
         }
     }

vortex-expr/src/lib.rs

@@ -217,7 +217,7 @@ mod tests {
                 root()
             )
             .to_string(),
-            "$~{col1, col2}"
+            "${~ col1, col2}"
         );
 
         assert_eq!(lit(Scalar::from(0u8)).to_string(), "0u8");

vortex-expr/src/vtable.rs

@@ -251,7 +251,7 @@ impl<V: VTable> DynExprVTable for VTableAdapter<V> {
         let instance = instance
             .downcast_ref::<V::Instance>()
             .vortex_expect("Failed to downcast expression instance to expected type");
-        write!(f, "{:?}", instance)
+        V::fmt_data(&self.0, instance, f)
     }
 
     fn return_dtype(&self, expression: &Expression, scope: &DType) -> VortexResult<DType> {