some docs and tests

Signed-off-by: Adam Gutglick <adam@spiraldb.com>

Author: AdamGS

vortex-array/src/arrays/variant/mod.rs

@@ -25,12 +25,15 @@ pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["core_storage", "shredded"];
 
 /// Accessors for canonical variant storage.
 ///
-/// A canonical variant array keeps raw variant semantics in `core_storage` and may carry a
-/// row-aligned, storage-agnostic `shredded` typed tree for selected paths. The shredded child may
-/// have any dtype; its dtype is recorded during serialization and validated by normal child
-/// deserialization.
+/// A canonical variant array keeps the full variant value for every row in `core_storage` and may
+/// carry a row-aligned, storage-agnostic `shredded` typed tree for selected paths.
+///
+/// `core_storage` is a logical `DType::Variant` array, not a specific physical encoding: it may be
+/// chunked, constant, or otherwise encoded. Callers must use normal array operations instead of
+/// assuming a particular slot layout. The shredded child may have any dtype; its dtype is recorded
+/// during serialization and validated by normal child deserialization.
 pub trait VariantArrayExt: TypedArrayRef<Variant> {
-    /// Returns the raw storage that preserves the full variant value for every row.
+    /// Returns the logical variant storage that preserves the full value for every row.
     fn core_storage(&self) -> &ArrayRef {
         self.as_ref().slots()[CORE_STORAGE_SLOT]
             .as_ref()
@@ -45,7 +48,7 @@ pub trait VariantArrayExt: TypedArrayRef<Variant> {
 impl<T: TypedArrayRef<Variant>> VariantArrayExt for T {}
 
 impl Array<Variant> {
-    /// Creates a new `VariantArray` with raw core storage and optional shredded storage.
+    /// Creates a new `VariantArray` with logical variant core storage and optional shredded storage.
     pub fn try_new(core_storage: ArrayRef, shredded: Option<ArrayRef>) -> VortexResult<Self> {
         let dtype = core_storage.dtype().clone();
         vortex_ensure!(

vortex-array/src/scalar_fn/fns/variant_get/mod.rs

@@ -676,6 +676,38 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn variant_get_reads_chunked_variant_input() -> VortexResult<()> {
+        let array = variant_rows([
+            Scalar::variant(variant_object([(
+                "a",
+                Scalar::primitive(10i32, Nullability::NonNullable),
+            )])),
+            Scalar::variant(variant_object([(
+                "b",
+                Scalar::primitive(20i32, Nullability::NonNullable),
+            )])),
+            Scalar::variant(variant_object([(
+                "a",
+                Scalar::primitive(30i32, Nullability::NonNullable),
+            )])),
+            Scalar::null(DType::Variant(Nullability::Nullable)),
+        ])?;
+        assert!(array.is::<Chunked>());
+
+        let result = execute_variant_get(
+            array,
+            "$.a",
+            Some(DType::Primitive(PType::I32, Nullability::NonNullable)),
+        )?;
+
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(10i32), None, Some(30), None])
+        );
+        Ok(())
+    }
+
     #[test]
     fn variant_get_fallback_typed_output_is_contiguous() -> VortexResult<()> {
         let array = variant_rows([
@@ -769,13 +801,8 @@ mod tests {
 
         assert_eq!(variant.len(), 2);
         assert_eq!(canonical_variant.len(), 2);
-        assert!(variant.core_storage().is::<Chunked>());
-
-        let core_variant = variant
-            .core_storage()
-            .clone()
-            .execute::<VariantArray>(&mut LEGACY_SESSION.create_execution_ctx())?;
-        assert_eq!(core_variant.len(), 2);
+        assert_eq!(variant.core_storage().dtype(), variant.dtype());
+        assert_eq!(variant.core_storage().len(), variant.len());
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         for (idx, expected) in [10i32, 20].into_iter().enumerate() {