(arrow-rs) branch main updated: fix: Implement support for appending Object and List variants in VariantBuilder (#7735)

[alamb]

This is an automated email from the ASF dual-hosted git repository.

alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git


The following commit(s) were added to refs/heads/main by this push:
     new ce69739142 fix: Implement support for appending Object and List 
variants in VariantBuilder (#7735)
ce69739142 is described below

commit ce6973914282c2fa836c48e8f71275428057076f
Author: Alex Huang <huangweijun1...@gmail.com>
AuthorDate: Mon Jun 23 23:47:35 2025 +0200

    fix: Implement support for appending Object and List variants in 
VariantBuilder (#7735)
    
    # Which issue does this PR close?
    
    Closes #7701 .
    
    # Rationale for this change
    The VariantBuilder::append_value method did not support appending
    `Object` and `List` variants correctly. This PR ensures that these
    complex types are appropriately copied and appended.
    
    
    # What changes are included in this PR?
    
    
    
    # Are there any user-facing changes?
    No
---
 parquet-variant/src/builder.rs | 52 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 50 insertions(+), 2 deletions(-)

diff --git a/parquet-variant/src/builder.rs b/parquet-variant/src/builder.rs
index 6cde4ce911..c595d72e0a 100644
--- a/parquet-variant/src/builder.rs
+++ b/parquet-variant/src/builder.rs
@@ -392,8 +392,19 @@ impl VariantBuilder {
             Variant::Binary(v) => self.append_binary(v),
             Variant::String(s) => self.append_string(s),
             Variant::ShortString(s) => self.append_short_string(s),
-            Variant::Object(_) | Variant::List(_) => {
-                unreachable!("Object and List variants cannot be created 
through Into<Variant>")
+            Variant::Object(obj) => {
+                let mut obj_builder = self.new_object();
+                for (key, value) in obj.iter() {
+                    obj_builder.append_value(key, value);
+                }
+                obj_builder.finish();
+            }
+            Variant::List(list) => {
+                let mut list_builder = self.new_list();
+                for value in list.iter() {
+                    list_builder.append_value(value);
+                }
+                list_builder.finish();
             }
         }
     }
@@ -737,4 +748,41 @@ mod tests {
         // apple(1), banana(2), zebra(0)
         assert_eq!(field_ids, vec![1, 2, 0]);
     }
+
+    #[test]
+    fn test_append_object() {
+        let (object_metadata, object_value) = {
+            let mut builder = VariantBuilder::new();
+            let mut obj = builder.new_object();
+            obj.append_value("name", "John");
+            obj.finish();
+            builder.finish()
+        };
+        let object_variant = Variant::try_new(&object_metadata, 
&object_value).unwrap();
+
+        let mut builder = VariantBuilder::new();
+        builder.append_value(object_variant.clone());
+        let (metadata, value) = builder.finish();
+        let variant = Variant::try_new(&metadata, &value).unwrap();
+        assert_eq!(variant, object_variant);
+    }
+
+    #[test]
+    fn test_append_list() {
+        let (list_metadata, list_value) = {
+            let mut builder = VariantBuilder::new();
+            let mut list = builder.new_list();
+            list.append_value(1i8);
+            list.append_value(2i8);
+            list.finish();
+            builder.finish()
+        };
+        let list_variant = Variant::try_new(&list_metadata, 
&list_value).unwrap();
+
+        let mut builder = VariantBuilder::new();
+        builder.append_value(list_variant.clone());
+        let (metadata, value) = builder.finish();
+        let variant = Variant::try_new(&metadata, &value).unwrap();
+        assert_eq!(variant, list_variant);
+    }
 }