liurenjie1024 commented on code in PR #731:
URL: https://github.com/apache/iceberg-rust/pull/731#discussion_r1952367599
##########
crates/iceberg/src/spec/schema.rs:
##########
@@ -1132,6 +1132,213 @@ impl ReassignFieldIds {
}
}
+/// A post order schema visitor with partner.
+///
+/// For order of methods called, please refer to [`visit_schema_with_partner`].
+pub trait SchemaWithPartnerVisitor<P> {
+ /// Return type of this visitor.
+ type T;
+
+ /// Called before struct field.
+ fn before_struct_field(&mut self, _field: &NestedFieldRef, _partner: &P)
-> Result<()> {
+ Ok(())
+ }
+ /// Called after struct field.
+ fn after_struct_field(&mut self, _field: &NestedFieldRef, _partner: &P) ->
Result<()> {
+ Ok(())
+ }
+ /// Called before list field.
+ fn before_list_element(&mut self, _field: &NestedFieldRef, _partner: &P)
-> Result<()> {
+ Ok(())
+ }
+ /// Called after list field.
+ fn after_list_element(&mut self, _field: &NestedFieldRef, _partner: &P) ->
Result<()> {
+ Ok(())
+ }
+ /// Called before map key field.
+ fn before_map_key(&mut self, _field: &NestedFieldRef, _partner: &P) ->
Result<()> {
+ Ok(())
+ }
+ /// Called after map key field.
+ fn after_map_key(&mut self, _field: &NestedFieldRef, _partner: &P) ->
Result<()> {
+ Ok(())
+ }
+ /// Called before map value field.
+ fn before_map_value(&mut self, _field: &NestedFieldRef, _partner: &P) ->
Result<()> {
+ Ok(())
+ }
+ /// Called after map value field.
+ fn after_map_value(&mut self, _field: &NestedFieldRef, _partner: &P) ->
Result<()> {
+ Ok(())
+ }
+
+ /// Called before every type, if this function return `Some`, the
following visiting will be skipped.
+ /// This function used to implement early return.
+ fn visit_type_before(&mut self, _ty: &Type, _partner: &P) ->
Result<Option<Self::T>> {
+ return Ok(None);
+ }
+
+ /// Called after schema's type visited.
+ fn schema(&mut self, schema: &Schema, partner: &P, value: Self::T) ->
Result<Self::T>;
+ /// Called after struct's field type visited.
+ fn field(&mut self, field: &NestedFieldRef, partner: &P, value: Self::T)
-> Result<Self::T>;
+ /// Called after struct's fields visited.
+ fn r#struct(
+ &mut self,
+ r#struct: &StructType,
+ partner: &P,
+ results: Vec<Self::T>,
+ ) -> Result<Self::T>;
+ /// Called after list fields visited.
+ fn list(&mut self, list: &ListType, partner: &P, value: Vec<Self::T>) ->
Result<Self::T>;
+ /// Called after map's key and value fields visited.
+ fn map(
+ &mut self,
+ map: &MapType,
+ partner: &P,
+ key_value: Vec<Self::T>,
+ value: Vec<Self::T>,
+ ) -> Result<Self::T>;
+ /// Called when see a primitive type.
+ fn primitive(&mut self, p: &PrimitiveType, partner: &P) -> Result<Self::T>;
+}
+
+/// Accessor used to get child partner from parent partner.
+pub trait PartnerAccessor<P> {
+ /// List partner iterator.
+ type L: ListPartnerIterator<P>;
+ /// Map partner iterator.
+ type M: MapPartnerIterator<P>;
+
+ /// Get the struct partner from schema partner.
+ fn struct_parner<'a>(&self, schema_partner: &'a P) -> Result<&'a P>;
+ /// Get the field partner from struct partner.
+ fn field_partner<'a>(&self, struct_partner: &'a P, field_id: i32, field:
&str)
+ -> Result<&'a P>;
+ /// Get the list element partner from list partner.
+ fn list_element_partner<'a>(&self, list_partner: &'a P) -> Result<Self::L>;
+ /// Get the map key partner from map partner.
+ fn map_element_partner<'a>(&self, map_partner: &'a P) -> Result<Self::M>;
+}
+
+/// Iterator for list partner.
+pub trait ListPartnerIterator<P> {
+ /// Get the next partner.
+ fn next(&mut self) -> Option<P>;
+}
+
+/// Iterator for map partner.
+pub trait MapPartnerIterator<P> {
+ /// Get the next partner.
+ fn next(&mut self) -> Option<(P, P)>;
+}
+
+/// Visiting a type in post order.
+pub fn visit_type_with_partner<P, V: SchemaWithPartnerVisitor<P>, A:
PartnerAccessor<P>>(
+ r#type: &Type,
+ partner: &P,
+ visitor: &mut V,
+ accessor: &A,
+) -> Result<V::T> {
+ if let Some(res) = visitor.visit_type_before(r#type, partner)? {
+ return Ok(res);
+ }
+ match r#type {
+ Type::Primitive(p) => visitor.primitive(p, partner),
+ Type::List(list) => {
+ let mut results = Vec::new();
+ let mut list_element_partner_iter =
accessor.list_element_partner(partner)?;
+ if let Some(list_element_partner) =
list_element_partner_iter.next() {
Review Comment:
Sorry for late reply, I'll take a look at this pr recently.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For additional commands, e-mail: issues-h...@iceberg.apache.org
