[ADD] Path-based field extraction for VariantArray

Author: carpecodeum

parquet-variant-compute/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = ["-A", "unknown-lints", "-A", "clippy::transmute-int-to-float"] 

parquet-variant-compute/Cargo.toml

@@ -29,6 +29,8 @@ keywords = ["arrow", "parquet", "variant"]
 edition = { workspace = true }
 rust-version = { workspace = true }
 
+[lints.rust]
+unknown_lints = "allow"
 
 [dependencies]
 arrow = { workspace = true }

parquet-variant-compute/examples/path_access.rs

@@ -0,0 +1,110 @@
+use parquet_variant_compute::{VariantArrayBuilder, VariantPath};
+use parquet_variant::VariantBuilder;
+
+fn main() {
+    // Create some sample data
+    let mut builder = VariantArrayBuilder::new(2);
+    
+    // Row 1: User Alice
+    {
+        let mut variant_builder = VariantBuilder::new();
+        {
+            let mut obj = variant_builder.new_object();
+            obj.insert("name", "Alice");
+            obj.insert("age", 30i32);
+            
+            {
+                let mut address = obj.new_object("address");
+                address.insert("city", "New York");
+                address.insert("zip", "10001");
+                let _ = address.finish();
+            }
+            
+            {
+                let mut hobbies = obj.new_list("hobbies");
+                hobbies.append_value("reading");
+                hobbies.append_value("hiking");
+                hobbies.append_value("cooking");
+                hobbies.finish();
+            }
+            
+            obj.finish().unwrap();
+        }
+        let (metadata, value) = variant_builder.finish();
+        builder.append_variant_buffers(&metadata, &value);
+    }
+    
+    // Row 2: User Bob
+    {
+        let mut variant_builder = VariantBuilder::new();
+        {
+            let mut obj = variant_builder.new_object();
+            obj.insert("name", "Bob");
+            obj.insert("age", 25i32);
+            
+            {
+                let mut address = obj.new_object("address");
+                address.insert("city", "San Francisco");
+                address.insert("zip", "94102");
+                let _ = address.finish();
+            }
+            
+            {
+                let mut hobbies = obj.new_list("hobbies");
+                hobbies.append_value("swimming");
+                hobbies.append_value("gaming");
+                hobbies.finish();
+            }
+            
+            obj.finish().unwrap();
+        }
+        let (metadata, value) = variant_builder.finish();
+        builder.append_variant_buffers(&metadata, &value);
+    }
+    
+    let variant_array = builder.build();
+    
+    // Demonstrate path access functionality
+    println!("=== Path Access Examples ===");
+    
+    // 1. Single field access
+    let name_path = VariantPath::field("name");
+    let alice_name = variant_array.get_path(0, &name_path).unwrap();
+    println!("Alice's name: {}", alice_name.as_string().unwrap());
+    
+    // 2. Nested field access  
+    let city_path = VariantPath::field("address").push_field("city");
+    let alice_city = variant_array.get_path(0, &city_path).unwrap();
+    let bob_city = variant_array.get_path(1, &city_path).unwrap();
+    println!("Alice's city: {}", alice_city.as_string().unwrap());
+    println!("Bob's city: {}", bob_city.as_string().unwrap());
+    
+    // 3. Array index access
+    let hobby_path = VariantPath::field("hobbies").push_index(0);
+    let alice_first_hobby = variant_array.get_path(0, &hobby_path).unwrap();
+    let bob_first_hobby = variant_array.get_path(1, &hobby_path).unwrap();
+    println!("Alice's first hobby: {}", alice_first_hobby.as_string().unwrap());
+    println!("Bob's first hobby: {}", bob_first_hobby.as_string().unwrap());
+    
+    // 4. Multiple field extraction
+    let paths = vec![
+        VariantPath::field("name"),
+        VariantPath::field("age"),
+        VariantPath::field("address").push_field("city"),
+    ];
+    
+    let alice_data = variant_array.get_paths(0, &paths);
+    println!("Alice's data: name={}, age={}, city={}", 
+             alice_data[0].as_ref().unwrap().as_string().unwrap(),
+             alice_data[1].as_ref().unwrap().as_int32().unwrap(),
+             alice_data[2].as_ref().unwrap().as_string().unwrap());
+    
+    // 5. Column-wise extraction
+    let names = variant_array.extract_field(&VariantPath::field("name"));
+    println!("All names: {:?}", names.iter().map(|v| v.as_ref().unwrap().as_string().unwrap()).collect::<Vec<_>>());
+    
+    println!("=== Performance Benefit ===");
+    println!("✓ Direct field access without reconstructing entire variants");
+    println!("✓ Efficient batch operations for analytical workloads");
+    println!("✓ Foundation for shredding/unshredding operations");
+} 

parquet-variant-compute/src/lib.rs

@@ -15,12 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
+// Suppress warnings from arrow dependencies
+#![allow(unknown_lints)]
+#![allow(clippy::transmute_int_to_float)]
+
 mod from_json;
 mod to_json;
 mod variant_array;
 mod variant_array_builder;
 
-pub use variant_array::VariantArray;
+pub use variant_array::{VariantArray, VariantPath, VariantPathElement};
 pub use variant_array_builder::VariantArrayBuilder;
 
 pub use from_json::batch_json_string_to_variant;