debug windows

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

Author: AdamGS

.github/workflows/ci.yml

@@ -329,15 +329,20 @@ jobs:
       - name: Rust Tests (Windows)
         if: matrix.os == 'windows-x64'
         run: |
+          # TEMP: full Windows workspace serial run while debugging PR #8322 hangs.
+          # Targeted packages and both package-split runs pass quickly, so test whether the
+          # original full workspace only hangs under nextest parallelism.
           cargo nextest run --cargo-profile ci --locked --workspace --all-features --no-fail-fast `
-            --exclude vortex-bench `
+            --test-threads 1 `
+            --exclude vortex-bench --exclude vortex-bench-server `
             --exclude vortex-python --exclude vortex-duckdb `
             --exclude vortex-fuzz --exclude vortex-cuda --exclude vortex-cuda-ffi `
             --exclude vortex-nvcomp --exclude vortex-cub --exclude vortex-test-e2e-cuda `
             --exclude duckdb-bench `
             --exclude lance-bench --exclude datafusion-bench --exclude random-access-bench `
             --exclude compress-bench --exclude xtask --exclude vortex-datafusion `
-            --exclude gpu-scan-cli --exclude vortex-sqllogictest
+            --exclude gpu-scan-cli --exclude vortex-sqllogictest `
+            --status-level all --final-status-level all
       - name: Rust Tests (Other)
         if: matrix.os != 'windows-x64'
         run: |

encodings/parquet-variant/src/vtable.rs

@@ -344,6 +344,16 @@ mod tests {
     use crate::ParquetVariant;
     use crate::array::ParquetVariantArrayExt;
 
+    fn debug_step(test: &str, step: &str) {
+        use std::io::Write as _;
+
+        println!(
+            "[parquet_variant::{test}] {step} thread={:?}",
+            std::thread::current().id()
+        );
+        drop(std::io::stdout().flush());
+    }
+
     fn roundtrip(array: ArrayRef) -> VortexResult<ArrayRef> {
         let dtype = array.dtype().clone();
         let len = array.len();
@@ -366,6 +376,7 @@ mod tests {
 
     #[fixture]
     fn typed_value_variant_array() -> VortexResult<ArrayRef> {
+        debug_step("typed_value_variant_array", "building fixture");
         let mut metadata = BinaryViewBuilder::new();
         for _ in 0..3 {
             metadata.append_value(b"\x01\x00");
@@ -382,27 +393,35 @@ mod tests {
             None,
         )?;
 
-        ParquetVariant::from_arrow_variant(&ArrowVariantArray::try_new(&arrow_storage)?)
+        let array =
+            ParquetVariant::from_arrow_variant(&ArrowVariantArray::try_new(&arrow_storage)?);
+        debug_step("typed_value_variant_array", "built fixture");
+        array
     }
 
     #[fixture]
     fn parquet_variant_file_session() -> VortexSession {
+        debug_step("parquet_variant_file_session", "building session");
         let session = VortexSession::empty()
             .with::<ArraySession>()
             .with::<LayoutSession>()
             .with::<RuntimeSession>();
         vortex_file::register_default_encodings(&session);
         session.arrays().register(ParquetVariant);
+        debug_step("parquet_variant_file_session", "built session");
         session
     }
 
     #[fixture]
     fn write_strategy() -> Arc<dyn LayoutStrategy> {
+        debug_step("write_strategy", "building zoned write strategy");
         let mut allowed = vortex_file::ALLOWED_ENCODINGS.clone();
         allowed.insert(ParquetVariant.id());
-        vortex_file::WriteStrategyBuilder::default()
+        let strategy = vortex_file::WriteStrategyBuilder::default()
             .with_allow_encodings(allowed)
-            .build()
+            .build();
+        debug_step("write_strategy", "built zoned write strategy");
+        strategy
     }
 
     #[test]
@@ -451,24 +470,63 @@ mod tests {
         #[from(typed_value_variant_array)] expected: VortexResult<ArrayRef>,
         parquet_variant_file_session: VortexSession,
     ) -> VortexResult<()> {
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "start",
+        );
         let expected = expected?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "resolved expected array",
+        );
 
         let mut bytes = ByteBufferMut::empty();
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "starting flat write",
+        );
         parquet_variant_file_session
             .write_options()
             .with_strategy(Arc::new(FlatLayoutStrategy::default()))
             .write(&mut bytes, expected.to_array_stream())
             .await?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            &format!("finished flat write bytes_len={}", bytes.len()),
+        );
 
-        let actual = parquet_variant_file_session
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "opening buffer",
+        );
+        let opened = parquet_variant_file_session
             .open_options()
-            .open_buffer(bytes)?
-            .scan()?
-            .into_array_stream()?
-            .read_all()
-            .await?;
+            .open_buffer(bytes)?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "opened buffer",
+        );
+        let scan = opened.scan()?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "created scan",
+        );
+        let stream = scan.into_array_stream()?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "created array stream",
+        );
+        let actual = stream.read_all().await?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "read all arrays",
+        );
 
         assert_arrays_eq!(expected, actual);
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_statistics",
+            "done",
+        );
         Ok(())
     }
 
@@ -479,24 +537,63 @@ mod tests {
         parquet_variant_file_session: VortexSession,
         write_strategy: Arc<dyn LayoutStrategy>,
     ) -> VortexResult<()> {
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "start",
+        );
         let expected = expected?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "resolved expected array",
+        );
 
         let mut bytes = ByteBufferMut::empty();
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "starting zoned write",
+        );
         parquet_variant_file_session
             .write_options()
             .with_strategy(write_strategy)
             .write(&mut bytes, expected.to_array_stream())
             .await?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            &format!("finished zoned write bytes_len={}", bytes.len()),
+        );
 
-        let actual = parquet_variant_file_session
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "opening buffer",
+        );
+        let opened = parquet_variant_file_session
             .open_options()
-            .open_buffer(bytes)?
-            .scan()?
-            .into_array_stream()?
-            .read_all()
-            .await?;
+            .open_buffer(bytes)?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "opened buffer",
+        );
+        let scan = opened.scan()?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "created scan",
+        );
+        let stream = scan.into_array_stream()?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "created array stream",
+        );
+        let actual = stream.read_all().await?;
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "read all arrays",
+        );
 
         assert_arrays_eq!(expected, actual);
+        debug_step(
+            "test_file_roundtrip_typed_value_variant_with_zoned_strategy",
+            "done",
+        );
         Ok(())
     }