Add an AccessPath (Identity + FieldPath) (#3476)

Signed-off-by: Joe Isaacs <[email protected]>

---------

Signed-off-by: Joe Isaacs <[email protected]>
Signed-off-by: Adam Gutglick <[email protected]>
Co-authored-by: Adam Gutglick <[email protected]>

Author: joseph-isaacs

vortex-dtype/src/field.rs

@@ -62,14 +62,14 @@ impl Field {
 /// A path through a (possibly nested) struct, composed of a sequence of field selectors
 // TODO(ngates): we should probably reverse the path. Or better yet, store a Arc<[Field]> along
 //  with a positional index to allow cheap step_into.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FieldPath(Vec<Field>);
 
 impl FieldPath {
     /// The selector for the root (i.e., the top-level struct itself)
     pub fn root() -> Self {
-        Self(vec![])
+        Self::default()
     }
 
     /// Constructs a new `FieldPath` from a single field selector (i.e., a direct child field of the top-level struct)

vortex-expr/src/analysis.rs

@@ -1,12 +1,11 @@
 use vortex_array::stats::Stat;
-use vortex_dtype::FieldPath;
 
-use crate::{ExprRef, Identifier};
+use crate::{AccessPath, ExprRef};
 
 pub trait StatsCatalog {
     /// Given an id, field and stat return an expression that when evaluated will return that stat
     /// this would be a column reference or a literal value, if the value is known at planning time.
-    fn stats_ref(&mut self, _id: &Identifier, _field: &FieldPath, _stat: Stat) -> Option<ExprRef> {
+    fn stats_ref(&mut self, _access_path: &AccessPath, _stat: Stat) -> Option<ExprRef> {
         None
     }
 }
@@ -45,7 +44,7 @@ pub trait AnalysisExpr {
         None
     }
 
-    fn field_path(&self) -> Option<(Identifier, FieldPath)> {
+    fn field_path(&self) -> Option<AccessPath> {
         None
     }
 

vortex-expr/src/get_item.rs

@@ -5,10 +5,10 @@ use std::sync::Arc;
 
 use vortex_array::stats::Stat;
 use vortex_array::{ArrayRef, ToCanonical};
-use vortex_dtype::{DType, FieldName, FieldPath};
+use vortex_dtype::{DType, FieldName};
 use vortex_error::{VortexResult, vortex_err};
 
-use crate::{AnalysisExpr, ExprRef, Identifier, Scope, ScopeDType, StatsCatalog, VortexExpr, root};
+use crate::{AccessPath, AnalysisExpr, ExprRef, Scope, ScopeDType, StatsCatalog, VortexExpr, root};
 
 #[derive(Debug, Clone, Eq, Hash)]
 #[allow(clippy::derived_hash_with_manual_eq)]
@@ -97,19 +97,17 @@ pub(crate) mod proto {
 
 impl AnalysisExpr for GetItem {
     fn max(&self, catalog: &mut dyn StatsCatalog) -> Option<ExprRef> {
-        let (var, path) = self.field_path()?;
-        catalog.stats_ref(&var, &path, Stat::Max)
+        catalog.stats_ref(&self.field_path()?, Stat::Max)
     }
 
     fn min(&self, catalog: &mut dyn StatsCatalog) -> Option<ExprRef> {
-        let (var, path) = self.field_path()?;
-        catalog.stats_ref(&var, &path, Stat::Min)
+        catalog.stats_ref(&self.field_path()?, Stat::Min)
     }
 
-    fn field_path(&self) -> Option<(Identifier, FieldPath)> {
+    fn field_path(&self) -> Option<AccessPath> {
         self.child()
             .field_path()
-            .map(|(var, fp)| (var, fp.push(self.field())))
+            .map(|fp| AccessPath::new(fp.field_path.push(self.field.clone()), fp.identifier))
     }
 }
 

vortex-expr/src/lib.rs

@@ -53,7 +53,7 @@ pub use select::*;
 pub use var::*;
 use vortex_array::aliases::hash_set::HashSet;
 use vortex_array::{Array, ArrayRef};
-use vortex_dtype::{DType, FieldName};
+use vortex_dtype::{DType, FieldName, FieldPath};
 use vortex_error::{VortexResult, VortexUnwrap};
 #[cfg(feature = "proto")]
 use vortex_proto::expr;
@@ -155,6 +155,36 @@ impl VortexExprExt for ExprRef {
     }
 }
 
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct AccessPath {
+    field_path: FieldPath,
+    identifier: Identifier,
+}
+
+impl AccessPath {
+    pub fn root_field(path: FieldName) -> Self {
+        Self {
+            field_path: FieldPath::from_name(path),
+            identifier: Identifier::Identity,
+        }
+    }
+
+    fn new(path: FieldPath, identifier: Identifier) -> Self {
+        Self {
+            field_path: path,
+            identifier,
+        }
+    }
+
+    pub fn identifier(&self) -> &Identifier {
+        &self.identifier
+    }
+
+    pub fn field_path(&self) -> &FieldPath {
+        &self.field_path
+    }
+}
+
 /// Splits top level and operations into separate expressions
 pub fn split_conjunction(expr: &ExprRef) -> Vec<ExprRef> {
     let mut conjunctions = vec![];

vortex-expr/src/pruning/field_or_identity.rs

@@ -1,6 +1,4 @@
-mod field_or_identity;
 mod pruning_predicate;
 mod relation;
 
-pub use field_or_identity::{FieldOrIdentity, stat_field_name};
-pub use pruning_predicate::PruningPredicate;
+pub use pruning_predicate::{PruningPredicate, access_path_stat_field_name};