[Variant] ParentState handles finish/rollback for builders (apache#8185)

# Which issue does this PR close?

- Closes apache#8182 (directly)
- Closes apache#8170 (as a side
effect)
- Closes apache#8180 (as a side
effect)

# Rationale for this change

Make finish/rollback handling simpler, robust and uniform by pulling it
inside `ParentState` (instead of each builder doing it manually) and
making it fully eager (instead of a mix of eager and lazy).

# What changes are included in this PR?

See above.

# Are these changes tested?

Yes, existing unit tests cover it (including some that needed adjustment
due to behavior changes), along with some new testing.

# Are there any user-facing changes?

`ObjectBuilder` methods `new_list` and `new_object` now panic if a
duplicate field name is provided, and new fallible versions
`try_new_list` and `try_new_object` are provided.

`ObjectBuilder::finish` signature remains fallible, but it always
returns `Result::Ok`
* TODO: apache#8184

Existing `VariantBuilderExt` methods `new_list` and `new_object` now
panic if they encounter a duplicate field name; new fallible versions
`try_new_list` and `try_new_object` are provided.

Author: scovich

parquet-variant-compute/src/variant_array_builder.rs

@@ -19,7 +19,7 @@
 
 use crate::VariantArray;
 use arrow::array::{ArrayRef, BinaryViewArray, BinaryViewBuilder, NullBufferBuilder, StructArray};
-use arrow_schema::{DataType, Field, Fields};
+use arrow_schema::{ArrowError, DataType, Field, Fields};
 use parquet_variant::{ListBuilder, ObjectBuilder, Variant, VariantBuilder, VariantBuilderExt};
 use std::sync::Arc;
 
@@ -222,12 +222,12 @@ impl VariantBuilderExt for VariantArrayVariantBuilder<'_> {
         self.variant_builder.append_value(value);
     }
 
-    fn new_list(&mut self) -> ListBuilder<'_> {
-        self.variant_builder.new_list()
+    fn try_new_list(&mut self) -> Result<ListBuilder<'_>, ArrowError> {
+        Ok(self.variant_builder.new_list())
     }
 
-    fn new_object(&mut self) -> ObjectBuilder<'_> {
-        self.variant_builder.new_object()
+    fn try_new_object(&mut self) -> Result<ObjectBuilder<'_>, ArrowError> {
+        Ok(self.variant_builder.new_object())
     }
 }
 

parquet-variant-json/src/from_json.rs

@@ -111,14 +111,14 @@ fn append_json(json: &Value, builder: &mut impl VariantBuilderExt) -> Result<(),
         }
         Value::String(s) => builder.append_value(s.as_str()),
         Value::Array(arr) => {
-            let mut list_builder = builder.new_list();
+            let mut list_builder = builder.try_new_list()?;
             for val in arr {
                 append_json(val, &mut list_builder)?;
             }
             list_builder.finish();
         }
         Value::Object(obj) => {
-            let mut obj_builder = builder.new_object();
+            let mut obj_builder = builder.try_new_object()?;
             for (key, value) in obj.iter() {
                 let mut field_builder = ObjectFieldBuilder {
                     key,
@@ -142,12 +142,12 @@ impl VariantBuilderExt for ObjectFieldBuilder<'_, '_, '_> {
         self.builder.insert(self.key, value);
     }
 
-    fn new_list(&mut self) -> ListBuilder<'_> {
-        self.builder.new_list(self.key)
+    fn try_new_list(&mut self) -> Result<ListBuilder<'_>, ArrowError> {
+        self.builder.try_new_list(self.key)
     }
 
-    fn new_object(&mut self) -> ObjectBuilder<'_> {
-        self.builder.new_object(self.key)
+    fn try_new_object(&mut self) -> Result<ObjectBuilder<'_>, ArrowError> {
+        self.builder.try_new_object(self.key)
     }
 }
 
@@ -627,10 +627,10 @@ mod test {
         // Verify metadata size = 1 + 2 + 2 * 497 + 3 * 496
         assert_eq!(metadata.len(), 2485);
         // Verify value size.
-        // Size of innermost_list: 1 + 1 + 258 + 256 = 516
-        // Size of inner object: 1 + 4 + 256 + 257 * 3 + 256 * 516 = 133128
-        // Size of json: 1 + 4 + 512 + 1028 + 256 * 133128 = 34082313
-        assert_eq!(value.len(), 34082313);
+        // Size of innermost_list: 1 + 1 + 2*(128 + 1) + 2*128 = 516
+        // Size of inner object: 1 + 4 + 2*256 + 3*(256 + 1) + 256 * 516 = 133384
+        // Size of json: 1 + 4 + 2*256 + 4*(256 + 1) + 256 * 133384 = 34147849
+        assert_eq!(value.len(), 34147849);
 
         let mut variant_builder = VariantBuilder::new();
         let mut object_builder = variant_builder.new_object();