Revert "Revert "chore[ci]: add windows test to CI (#5439)"" (#5486)

Reverts #5449

---------

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

.github/actions/setup-rust/action.yml

@@ -25,6 +25,7 @@ runs:
       run: echo "version=$(cat rust-toolchain.toml | grep channel | awk -F'\"' '{print $2}')" >> $GITHUB_OUTPUT
 
     - name: Install Mold
+      if: runner.os == 'Linux'
       uses: rui314/setup-mold@v1
 
     - name: Rust Toolchain
@@ -50,6 +51,7 @@ runs:
       run: echo "PATH=$PATH" >> $GITHUB_ENV
 
     - name: Install Protoc (for lance-encoding build step)
+      if: runner.os != 'Windows'
       uses: arduino/setup-protoc@v3
       with:
         version: "29.3"

.github/workflows/ci.yml

@@ -400,6 +400,59 @@ jobs:
             --target x86_64-unknown-linux-gnu \
             --verbose
 
+  rust-test-other:
+    name: "Rust tests (${{ matrix.os }})"
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-x64
+            runner:
+              - runs-on=${{ github.run_id }}
+              - family=m7i
+              - cpu=8
+              - image=windows22-full-x64
+              - tag=rust-test-windows
+          - os: linux-arm64
+            runner:
+              - runs-on=${{ github.run_id }}
+              - family=m7g
+              - cpu=8
+              - image=ubuntu24-full-arm64
+              - extras=s3-cache
+              - tag=rust-test-linux-arm64
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - uses: runs-on/action@v2
+        if: matrix.os == 'linux-arm64'
+        with:
+          sccache: s3
+      - uses: actions/checkout@v5
+      - name: Install Visual Studio Build Tools (Windows)
+        if: matrix.os == 'windows-x64'
+        shell: bash
+        run: |
+          choco install visualstudio2022buildtools --package-parameters "--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --passive" -y
+      - name: Setup Python (Windows)
+        if: matrix.os == 'windows-x64'
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - uses: ./.github/actions/setup-rust
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install nextest
+        uses: taiki-e/install-action@v2
+        with:
+          tool: nextest
+      - name: Rust Tests (Windows)
+        if: matrix.os == 'windows-x64'
+        run: cargo nextest run --locked --workspace --all-features --no-fail-fast --exclude bench-vortex --exclude vortex-python --exclude vortex-duckdb --exclude vortex-fuzz
+      - name: Rust Tests (Other)
+        if: matrix.os != 'windows-x64'
+        run: cargo nextest run --locked --workspace --all-features --no-fail-fast --exclude bench-vortex --exclude vortex-duckdb
+
   build-java:
     name: "Java"
     runs-on: ubuntu-latest

vortex-ffi/src/file.rs

@@ -122,18 +122,29 @@ impl vx_file_scan_options {
             self.filter_expression_len,
         )?;
 
+        // On Windows, c_ulong is u32, so we need to convert to u64
+        // On Unix, c_ulong is already u64, so we can use it directly
+        #[cfg(windows)]
+        let row_range = (self.row_range_end > self.row_range_start)
+            .then_some(self.row_range_start as u64..self.row_range_end as u64);
+        #[cfg(not(windows))]
         let row_range = (self.row_range_end > self.row_range_start)
             .then_some(self.row_range_start..self.row_range_end);
 
         let split_by = (self.split_by_row_count > 0)
             .then_some(SplitBy::RowCount(self.split_by_row_count as usize));
 
+        #[cfg(windows)]
+        let row_offset = self.row_offset as u64;
+        #[cfg(not(windows))]
+        let row_offset = self.row_offset;
+
         Ok(ScanOptions {
             projection_expr,
             filter_expr,
             split_by,
             row_range,
-            row_offset: self.row_offset,
+            row_offset,
         })
     }
 }

vortex-io/src/file/mod.rs

@@ -7,7 +7,7 @@ mod driver;
 pub mod object_store;
 mod read;
 #[cfg(not(target_arch = "wasm32"))]
-mod std_file;
+pub(crate) mod std_file;
 
 pub(crate) use driver::*;
 pub use read::*;

vortex-io/src/file/object_store.rs

@@ -2,8 +2,6 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::io;
-#[cfg(unix)]
-use std::os::unix::fs::FileExt;
 use std::sync::Arc;
 
 use async_compat::Compat;
@@ -16,6 +14,8 @@ use vortex_error::{VortexError, VortexResult, vortex_ensure};
 
 use crate::file::IoRequest;
 use crate::file::read::{CoalesceWindow, IntoReadSource, ReadSource, ReadSourceRef};
+#[cfg(not(target_arch = "wasm32"))]
+use crate::file::std_file::read_exact_at;
 use crate::runtime::Handle;
 
 const COALESCING_WINDOW: CoalesceWindow = CoalesceWindow {
@@ -134,15 +134,8 @@ impl ReadSource for ObjectStoreIoSource {
 
                             handle
                                 .spawn_blocking(move || {
-                                    #[cfg(unix)] {
-                                        file.read_exact_at(&mut buffer, range.start)?;
-                                        Ok::<_, io::Error>(buffer)
-                                    }
-                                    #[cfg(not(unix))] {
-                                        file.seek(range.start)?;
-                                        file.read_exact(&mut buffer)?;
-                                        Ok::<_, io::Error>(buffer)
-                                    }
+                                    read_exact_at(&file, &mut buffer, range.start)?;
+                                    Ok::<_, io::Error>(buffer)
                                 })
                                 .await
                                 .map_err(io::Error::other)?

vortex-io/src/file/std_file.rs

@@ -2,7 +2,12 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fs::File;
+#[cfg(not(unix))]
+use std::io::{Read, Seek};
+#[cfg(unix)]
 use std::os::unix::fs::FileExt;
+#[cfg(windows)]
+use std::os::windows::fs::FileExt;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
@@ -15,6 +20,23 @@ use vortex_error::{VortexError, VortexResult};
 use crate::file::{CoalesceWindow, IntoReadSource, IoRequest, ReadSource, ReadSourceRef};
 use crate::runtime::Handle;
 
+/// Read exactly `buffer.len()` bytes from `file` starting at `offset`.
+/// This is a platform-specific helper that uses the most efficient method available.
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn read_exact_at(file: &File, buffer: &mut [u8], offset: u64) -> std::io::Result<()> {
+    #[cfg(unix)]
+    {
+        file.read_exact_at(buffer, offset)
+    }
+    #[cfg(not(unix))]
+    {
+        use std::io::SeekFrom;
+        let mut file_ref = file;
+        file_ref.seek(SeekFrom::Start(offset))?;
+        file_ref.read_exact(buffer)
+    }
+}
+
 const COALESCING_WINDOW: CoalesceWindow = CoalesceWindow {
     // TODO(ngates): these numbers don't make sense if we're using spawn_blocking..
     distance: 8 * 1024, // KB
@@ -83,12 +105,7 @@ impl ReadSource for FileIoSource {
                         let mut buffer = ByteBufferMut::with_capacity_aligned(len, req.alignment());
                         unsafe { buffer.set_len(len) };
 
-                        #[cfg(unix)]
-                        let buffer_res = file.read_exact_at(&mut buffer, offset);
-                        #[cfg(not(unix))]
-                        let buffer_res = file
-                            .seek(io::SeekFrom::Start(offset))
-                            .and_then(|_| file.read_exact(&mut buffer));
+                        let buffer_res = read_exact_at(&file, &mut buffer, offset);
 
                         req.resolve(
                             buffer_res

vortex-io/src/runtime/tests.rs

@@ -326,18 +326,20 @@ async fn test_task_detach() {
     let handle = TokioRuntime::current();
     let counter = Arc::new(AtomicUsize::new(0));
     let c = counter.clone();
+    let (tx, rx) = oneshot::channel::<()>();
 
     let task = handle.spawn(async move {
         tokio::time::sleep(std::time::Duration::from_millis(10)).await;
         c.fetch_add(1, Ordering::SeqCst);
-        42
+        tx.send(())
     });
 
     // Detach the task so it continues running
     task.detach();
 
     // Wait for task to complete
     tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+    let _ = rx.await;
 
     // Task should have completed even though we detached it
     assert_eq!(counter.load(Ordering::SeqCst), 1);