chore: Add new_expr to all built-in expressions in the name of consistency (#3847)

Signed-off-by: Adam Gutglick <[email protected]>

Author: AdamGS

vortex-dtype/src/field.rs

@@ -93,7 +93,7 @@ impl FieldPath {
     }
 
     /// Returns the sequence of field selectors that make up this path
-    pub fn path(&self) -> &[Field] {
+    pub fn parts(&self) -> &[Field] {
         &self.0
     }
 
@@ -177,7 +177,7 @@ impl FieldPath {
     }
 
     /// Does the field referenced by the field path exist in the given dtype?
-    pub fn exists(&self, dtype: DType) -> bool {
+    pub fn exists_in(&self, dtype: DType) -> bool {
         // Indexing a struct type always allocates anyway.
         self.resolve(dtype).is_some()
     }
@@ -244,7 +244,7 @@ mod tests {
             .into_iter()
             .map(Field::from)
             .collect_vec();
-        assert_eq!(path.path(), &fields);
+        assert_eq!(path.parts(), &fields);
 
         let vec_path = FieldPath::from(fields);
         assert_eq!(vec_path.to_string(), "$A.$B.$C");
@@ -260,7 +260,7 @@ mod tests {
         );
         let path = FieldPath::from_name("a");
         assert_eq!(a_type, path.resolve(dtype.clone()).unwrap());
-        assert!(path.exists(dtype));
+        assert!(path.exists_in(dtype));
     }
 
     #[test]
@@ -282,7 +282,7 @@ mod tests {
         let dtype = path.resolve(outer.clone()).unwrap();
 
         assert_eq!(dtype, DType::Primitive(PType::U8, NonNullable));
-        assert!(path.exists(outer));
+        assert!(path.exists_in(outer));
     }
 
     #[test]
@@ -314,40 +314,40 @@ mod tests {
         let dtype = path.resolve(level1.clone()).unwrap();
 
         assert_eq!(dtype, DType::Primitive(PType::F64, Nullable));
-        assert!(path.exists(level1.clone()));
+        assert!(path.exists_in(level1.clone()));
 
         let path = FieldPath::from_name("a")
             .push("b")
             .push("c")
             .push(Field::ElementType);
         assert!(path.resolve(level1.clone()).is_none());
-        assert!(!path.exists(level1.clone()));
+        assert!(!path.exists_in(level1.clone()));
 
         let path = FieldPath::from_name("a")
             .push(Field::ElementType)
             .push("b")
             .push("c");
         assert!(path.resolve(level1.clone()).is_none());
-        assert!(!path.exists(level1.clone()));
+        assert!(!path.exists_in(level1.clone()));
 
         let path = FieldPath::from_name(Field::ElementType)
             .push("a")
             .push("b")
             .push("c");
         assert!(path.resolve(level1.clone()).is_none());
-        assert!(!path.exists(level1));
+        assert!(!path.exists_in(level1));
     }
 
     #[test]
     fn nested_field_not_found() {
         let dtype = DType::struct_([("a", DType::Bool(NonNullable))], NonNullable);
         let path = FieldPath::from_name("b");
         assert!(path.resolve(dtype.clone()).is_none());
-        assert!(!path.exists(dtype.clone()));
+        assert!(!path.exists_in(dtype.clone()));
 
         let path = FieldPath::from(Field::ElementType);
         assert!(path.resolve(dtype.clone()).is_none());
-        assert!(!path.exists(dtype));
+        assert!(!path.exists_in(dtype));
     }
 
     #[test]
@@ -358,10 +358,10 @@ mod tests {
         );
         let path = FieldPath::from_name("a").push("b");
         assert!(path.resolve(dtype.clone()).is_none());
-        assert!(!path.exists(dtype.clone()));
+        assert!(!path.exists_in(dtype.clone()));
 
         let path = FieldPath::from_name("a").push(Field::ElementType);
         assert!(path.resolve(dtype.clone()).is_none());
-        assert!(!path.exists(dtype));
+        assert!(!path.exists_in(dtype));
     }
 }

vortex-dtype/src/field_mask.rs

@@ -49,7 +49,7 @@ impl FieldMask {
         match self {
             FieldMask::All => vortex_bail!("Cannot get starting field from All mask"),
             // We know that fp is non-empty
-            FieldMask::Prefix(fp) | FieldMask::Exact(fp) => Ok(fp.path().first()),
+            FieldMask::Prefix(fp) | FieldMask::Exact(fp) => Ok(fp.parts().first()),
         }
     }
 

vortex-expr/src/exprs/cast.rs

@@ -94,6 +94,10 @@ impl CastExpr {
     pub fn new(child: ExprRef, target: DType) -> Self {
         Self { target, child }
     }
+
+    pub fn new_expr(child: ExprRef, target: DType) -> ExprRef {
+        Self::new(child, target).into_expr()
+    }
 }
 
 impl Display for CastExpr {

vortex-expr/src/exprs/get_item.rs

@@ -111,6 +111,10 @@ impl GetItemExpr {
         }
     }
 
+    pub fn new_expr(field: impl Into<FieldName>, child: ExprRef) -> ExprRef {
+        Self::new(field, child).into_expr()
+    }
+
     pub fn field(&self) -> &FieldName {
         &self.field
     }

vortex-expr/src/exprs/is_null.rs

@@ -82,6 +82,10 @@ impl IsNullExpr {
     pub fn new(child: ExprRef) -> Self {
         Self { child }
     }
+
+    pub fn new_expr(child: ExprRef) -> ExprRef {
+        Self::new(child).into_expr()
+    }
 }
 
 impl Display for IsNullExpr {

vortex-expr/src/exprs/list_contains.rs

@@ -96,6 +96,10 @@ impl ListContainsExpr {
         Self { list, value }
     }
 
+    pub fn new_expr(list: ExprRef, value: ExprRef) -> ExprRef {
+        Self::new(list, value).into_expr()
+    }
+
     pub fn value(&self) -> &ExprRef {
         &self.value
     }

vortex-expr/src/exprs/merge.rs

@@ -162,6 +162,10 @@ impl MergeExpr {
         }
     }
 
+    pub fn new_expr(values: Vec<ExprRef>, nullability: Nullability) -> ExprRef {
+        Self::new(values, nullability).into_expr()
+    }
+
     pub fn nullability(&self) -> Nullability {
         self.nullability
     }

vortex-expr/src/exprs/pack.rs

@@ -145,6 +145,14 @@ impl PackExpr {
         })
     }
 
+    pub fn try_new_expr(
+        names: FieldNames,
+        values: Vec<ExprRef>,
+        nullability: Nullability,
+    ) -> VortexResult<ExprRef> {
+        Self::try_new(names, values, nullability).map(|v| v.into_expr())
+    }
+
     pub fn names(&self) -> &FieldNames {
         &self.names
     }

vortex-expr/src/exprs/select.rs

@@ -122,6 +122,10 @@ impl SelectExpr {
         Self { fields, child }
     }
 
+    pub fn new_expr(fields: SelectField, child: ExprRef) -> ExprRef {
+        Self::new(fields, child).into_expr()
+    }
+
     pub fn include_expr(columns: FieldNames, child: ExprRef) -> ExprRef {
         Self::new(SelectField::Include(columns), child).into_expr()
     }

vortex-expr/src/pruning/pruning_expr.rs

@@ -49,7 +49,7 @@ impl StatsCatalog for AnyStatsCatalog {
 
 pub fn field_path_stat_field_name(field_path: &FieldPath, stat: Stat) -> FieldName {
     field_path
-        .path()
+        .parts()
         .iter()
         .map(|f| match f {
             Field::Name(n) => n.as_ref(),