fix

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

Author: joseph-isaacs

vortex-ffi/src/file.rs

@@ -122,20 +122,29 @@ impl vx_file_scan_options {
             self.filter_expression_len,
         )?;
 
-        #[allow(clippy::useless_conversion)] // c_ulong is u32 on Windows, u64 on Unix
+        // 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(u64::from(self.row_range_start)..u64::from(self.row_range_end));
+            .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));
 
-        #[allow(clippy::useless_conversion)]
+        #[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: u64::from(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,10 +2,6 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::io;
-#[cfg(not(unix))]
-use std::io::{Read, Seek};
-#[cfg(unix)]
-use std::os::unix::fs::FileExt;
 use std::sync::Arc;
 
 use async_compat::Compat;
@@ -18,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 {
@@ -137,15 +135,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(io::SeekFrom::Start(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,9 +2,11 @@
 // 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)]
+#[cfg(all(not(unix), windows))]
 use std::os::windows::fs::FileExt;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
@@ -18,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
@@ -86,18 +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(windows)]
-                        let buffer_res = file.seek_read(&mut buffer, offset);
-                        #[cfg(not(any(unix, windows)))]
-                        let buffer_res = {
-                            use std::io::{Read, Seek, SeekFrom};
-                            let mut file_ref = file.as_ref();
-                            file_ref
-                                .seek(SeekFrom::Start(offset))
-                                .and_then(|_| file_ref.read_exact(&mut buffer))
-                        };
+                        let buffer_res = read_exact_at(&file, &mut buffer, offset);
 
                         req.resolve(
                             buffer_res