parquet 0.2.13 → 0.3.0

data/ext/parquet/src/reader/parquet_column_reader.rs

@@ -1,20 +1,18 @@
 use crate::header_cache::StringCache;
+use crate::ruby_reader::{RubyReader, ThreadSafeRubyReader};
 use crate::types::{ArrayWrapper, TryIntoValue};
 use crate::{
-    create_column_enumerator, utils::*, ColumnEnumeratorArgs, ColumnRecord, ForgottenFileHandle,
-    ParquetValueVec, ParserResultType, SeekableRubyValue,
+    create_column_enumerator, utils::*, ColumnEnumeratorArgs, ColumnRecord, ParquetValueVec,
+    ParserResultType,
 };
 use ahash::RandomState;
-use magnus::rb_sys::AsRawValue;
-use magnus::value::{Opaque, ReprValue};
+use magnus::value::ReprValue;
 use magnus::IntoValue;
 use magnus::{Error as MagnusError, Ruby, Value};
 use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
 use parquet::arrow::ProjectionMask;
 use std::collections::HashMap;
 use std::fs::File;
-use std::mem::ManuallyDrop;
-use std::os::fd::FromRawFd;
 use std::sync::OnceLock;
 
 use super::ReaderError;
@@ -71,50 +69,12 @@ pub fn parse_parquet_columns<'a>(rb_self: Value, args: &[Value]) -> Result<Value
 
         let reader = builder.build().map_err(|e| ReaderError::Parquet(e))?;
 
-        (reader, schema, num_rows)
-    } else if to_read.is_kind_of(ruby.class_io()) {
-        let raw_value = to_read.as_raw();
-        let fd = std::panic::catch_unwind(|| unsafe { rb_sys::rb_io_descriptor(raw_value) })
-            .map_err(|_| {
-                ReaderError::FileDescriptor("Failed to get file descriptor".to_string())
-            })?;
-
-        if fd < 0 {
-            return Err(ReaderError::InvalidFileDescriptor.into());
-        }
-
-        let file = unsafe { File::from_raw_fd(fd) };
-        let file = ForgottenFileHandle(ManuallyDrop::new(file));
-
-        let mut builder =
-            ParquetRecordBatchReaderBuilder::try_new(file).map_err(|e| ReaderError::Parquet(e))?;
-        let schema = builder.schema().clone();
-        let num_rows = builder.metadata().file_metadata().num_rows();
-
-        // If columns are specified, project only those columns
-        if let Some(cols) = &columns {
-            // Get the parquet schema
-            let parquet_schema = builder.parquet_schema();
-
-            // Create a projection mask from column names
-            let projection =
-                ProjectionMask::columns(parquet_schema, cols.iter().map(|s| s.as_str()));
-
-            builder = builder.with_projection(projection);
-        }
-
-        if let Some(batch_size) = batch_size {
-            builder = builder.with_batch_size(batch_size);
-        }
-
-        let reader = builder.build().map_err(|e| ReaderError::Parquet(e))?;
-
         (reader, schema, num_rows)
     } else {
-        let readable = SeekableRubyValue(Opaque::from(to_read));
+        let readable = ThreadSafeRubyReader::new(RubyReader::try_from(to_read)?);
 
-        let mut builder = ParquetRecordBatchReaderBuilder::try_new(readable)
-            .map_err(|e| ReaderError::Parquet(e))?;
+        let mut builder =
+            ParquetRecordBatchReaderBuilder::try_new(readable).map_err(ReaderError::from)?;
         let schema = builder.schema().clone();
         let num_rows = builder.metadata().file_metadata().num_rows();
 

data/ext/parquet/src/reader/parquet_row_reader.rs

@@ -1,12 +1,12 @@
 use crate::header_cache::StringCache;
+use crate::ruby_reader::{RubyReader, ThreadSafeRubyReader};
 use crate::types::TryIntoValue;
 use crate::{
-    create_row_enumerator, utils::*, ForgottenFileHandle, ParquetField, ParserResultType,
-    ReaderError, RowEnumeratorArgs, RowRecord, SeekableRubyValue,
+    create_row_enumerator, utils::*, ParquetField, ParserResultType, ReaderError,
+    RowEnumeratorArgs, RowRecord,
 };
 use ahash::RandomState;
-use magnus::rb_sys::AsRawValue;
-use magnus::value::{Opaque, ReprValue};
+use magnus::value::ReprValue;
 use magnus::IntoValue;
 use magnus::{Error as MagnusError, Ruby, Value};
 use parquet::file::reader::{FileReader, SerializedFileReader};
@@ -14,8 +14,6 @@ use parquet::record::reader::RowIter as ParquetRowIter;
 use parquet::schema::types::{Type as SchemaType, TypePtr};
 use std::collections::HashMap;
 use std::fs::File;
-use std::mem::ManuallyDrop;
-use std::os::fd::FromRawFd;
 use std::sync::OnceLock;
 
 #[inline]
@@ -40,39 +38,17 @@ pub fn parse_parquet_rows<'a>(rb_self: Value, args: &[Value]) -> Result<Value, M
         .map(|yield_enum| yield_enum.into_value_with(&ruby));
     }
 
-    let (schema, mut iter) = if to_read.is_kind_of(ruby.class_string()) {
+    let reader: Box<dyn FileReader> = if to_read.is_kind_of(ruby.class_string()) {
         let path_string = to_read.to_r_string()?;
         let file_path = unsafe { path_string.as_str()? };
-        let file = File::open(file_path).unwrap();
-        let reader = SerializedFileReader::new(file).unwrap();
-        let schema = reader.metadata().file_metadata().schema().clone();
-
-        (schema, ParquetRowIter::from_file_into(Box::new(reader)))
-    } else if to_read.is_kind_of(ruby.class_io()) {
-        let raw_value = to_read.as_raw();
-        let fd = std::panic::catch_unwind(|| unsafe { rb_sys::rb_io_descriptor(raw_value) })
-            .map_err(|_| {
-                ReaderError::FileDescriptor("Failed to get file descriptor".to_string())
-            })?;
-
-        if fd < 0 {
-            return Err(ReaderError::InvalidFileDescriptor.into());
-        }
-
-        let file = unsafe { File::from_raw_fd(fd) };
-        let file = ForgottenFileHandle(ManuallyDrop::new(file));
-        let reader = SerializedFileReader::new(file).unwrap();
-        let schema = reader.metadata().file_metadata().schema().clone();
-
-        (schema, ParquetRowIter::from_file_into(Box::new(reader)))
+        let file = File::open(file_path).map_err(ReaderError::from)?;
+        Box::new(SerializedFileReader::new(file).map_err(ReaderError::from)?)
     } else {
-        let readable = SeekableRubyValue(Opaque::from(to_read));
-        let reader = SerializedFileReader::new(readable).unwrap();
-        let schema = reader.metadata().file_metadata().schema().clone();
-
-        (schema, ParquetRowIter::from_file_into(Box::new(reader)))
+        let readable = ThreadSafeRubyReader::new(RubyReader::try_from(to_read)?);
+        Box::new(SerializedFileReader::new(readable).map_err(ReaderError::from)?)
     };
-
+    let schema = reader.metadata().file_metadata().schema().clone();
+    let mut iter = ParquetRowIter::from_file_into(reader);
     if let Some(cols) = columns {
         let projection = create_projection_schema(&schema, &cols);
         iter = iter.project(Some(projection.to_owned())).map_err(|e| {
@@ -97,7 +73,8 @@ pub fn parse_parquet_rows<'a>(rb_self: Value, args: &[Value]) -> Result<Value, M
                             header_string.push(k.to_owned());
                         }
 
-                        let headers = StringCache::intern_many(&header_string).unwrap();
+                        let headers = StringCache::intern_many(&header_string)
+                            .expect("Failed to intern headers");
 
                         headers
                     });
@@ -110,7 +87,7 @@ pub fn parse_parquet_rows<'a>(rb_self: Value, args: &[Value]) -> Result<Value, M
                     Ok(map)
                 })
                 .and_then(|row| Ok(RowRecord::Map::<RandomState>(row)))
-                .map_err(|e| ReaderError::Parquet(e))
+                .map_err(|e| ReaderError::from(e))
             });
 
             for result in iter {
@@ -128,7 +105,7 @@ pub fn parse_parquet_rows<'a>(rb_self: Value, args: &[Value]) -> Result<Value, M
                     Ok(vec)
                 })
                 .and_then(|row| Ok(RowRecord::Vec::<RandomState>(row)))
-                .map_err(|e| ReaderError::Parquet(e))
+                .map_err(|e| ReaderError::from(e))
             });
 
             for result in iter {

data/ext/parquet/src/ruby_reader.rs

@@ -1,171 +1,294 @@
+use bytes::Bytes;
 use magnus::{
     value::{Opaque, ReprValue},
     RClass, RString, Ruby, Value,
 };
-use std::io::{self, Read, Seek, SeekFrom, Write};
-use std::sync::OnceLock;
+use parquet::{
+    errors::ParquetError,
+    file::reader::{ChunkReader, Length},
+};
+use std::{
+    fs::File,
+    sync::{Mutex, OnceLock},
+};
+use std::{
+    io::{self, BufReader, Read, Seek, SeekFrom, Write},
+    sync::Arc,
+};
 
 static STRING_IO_CLASS: OnceLock<Opaque<RClass>> = OnceLock::new();
 
 /// A reader that can handle various Ruby input types (String, StringIO, IO-like objects)
 /// and provide a standard Read implementation for them.
-pub struct RubyReader<T> {
-    inner: T,
-    offset: usize,
+pub enum RubyReader {
+    String {
+        inner: Opaque<RString>,
+        offset: usize,
+    },
+    RubyIoLike {
+        inner: Opaque<Value>,
+    },
+    NativeProxyIoLike {
+        proxy_file: File,
+    },
 }
 
-pub trait SeekableRead: Read + Seek {}
-impl<T: Read + Seek> SeekableRead for T {}
-
-pub fn build_ruby_reader(
-    ruby: &Ruby,
-    input: Value,
-) -> Result<Box<dyn SeekableRead>, magnus::Error> {
-    if RubyReader::is_string_io(ruby, &input) {
-        RubyReader::from_string_io(ruby, input)
-    } else if RubyReader::is_io_like(&input) {
-        RubyReader::from_io(input)
-    } else {
-        RubyReader::from_string_like(input)
+impl RubyReader {
+    fn is_string_io(ruby: &Ruby, value: &Value) -> bool {
+        let string_io_class = STRING_IO_CLASS.get_or_init(|| {
+            let class = RClass::from_value(ruby.eval("StringIO").expect("Failed to find StringIO"))
+                .expect("Failed to get StringIO class");
+            Opaque::from(class)
+        });
+        value.is_kind_of(ruby.get_inner(*string_io_class))
     }
-}
 
-impl Seek for RubyReader<Value> {
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        let (whence, offset) = match pos {
-            SeekFrom::Start(i) => (0, i as i64),
-            SeekFrom::Current(i) => (1, i),
-            SeekFrom::End(i) => (2, i),
-        };
-
-        let new_position = self
-            .inner
-            .funcall("seek", (offset, whence))
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+    fn is_io_like(value: &Value) -> bool {
+        value.respond_to("read", false).unwrap_or(false)
+    }
 
-        Ok(new_position)
+    // For now, don't use this. Having to use seek in length is scary.
+    fn is_seekable_io_like(_value: &Value) -> bool {
+        // Self::is_io_like(value) && value.respond_to("seek", false).unwrap_or(false)
+        false
     }
 }
 
-impl Write for RubyReader<Value> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
-        let ruby_bytes = RString::from_slice(buf);
+impl TryFrom<Value> for RubyReader {
+    type Error = magnus::Error;
 
-        let bytes_written = self
-            .inner
-            .funcall::<_, _, usize>("write", (ruby_bytes,))
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
-
-        Ok(bytes_written)
-    }
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        if RubyReader::is_string_io(&ruby, &value) {
+            let string_content = value.funcall::<_, _, RString>("string", ())?;
+            Ok(RubyReader::String {
+                inner: Opaque::from(string_content),
+                offset: 0,
+            })
+        } else if RubyReader::is_seekable_io_like(&value) {
+            Ok(RubyReader::RubyIoLike {
+                inner: Opaque::from(value),
+            })
+        } else if RubyReader::is_io_like(&value) {
+            let mut temp_file = tempfile::tempfile()
+                .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e.to_string()))?;
 
-    fn flush(&mut self) -> Result<(), io::Error> {
-        self.inner
-            .funcall::<_, _, Value>("flush", ())
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+            // This is safe, because we won't call seek
+            let inner_readable = RubyReader::RubyIoLike {
+                inner: Opaque::from(value),
+            };
+            let mut reader = BufReader::new(inner_readable);
+            io::copy(&mut reader, &mut temp_file)
+                .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+            temp_file
+                .seek(SeekFrom::Start(0))
+                .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e.to_string()))?;
 
-        Ok(())
+            Ok(RubyReader::NativeProxyIoLike {
+                proxy_file: temp_file,
+            })
+        } else {
+            // Try calling `to_str`, and if that fails, try `to_s`
+            let string_content = value
+                .funcall::<_, _, RString>("to_str", ())
+                .or_else(|_| value.funcall::<_, _, RString>("to_s", ()))?;
+            Ok(RubyReader::String {
+                inner: Opaque::from(string_content),
+                offset: 0,
+            })
+        }
     }
 }
 
-impl Seek for RubyReader<RString> {
+impl Seek for RubyReader {
     fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        match pos {
-            io::SeekFrom::Start(offset) => self.offset = offset as usize,
-            io::SeekFrom::Current(offset) => self.offset = (self.offset as i64 + offset) as usize,
-            io::SeekFrom::End(offset) => self.offset = self.inner.len() - offset as usize,
+        let ruby = unsafe { Ruby::get_unchecked() };
+        match self {
+            RubyReader::NativeProxyIoLike { proxy_file } => proxy_file.seek(pos),
+            RubyReader::String {
+                inner,
+                offset: original_offset,
+            } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
+
+                let new_offset = match pos {
+                    io::SeekFrom::Start(offset) => offset as usize,
+                    io::SeekFrom::Current(offset) => (*original_offset as i64 + offset) as usize,
+                    io::SeekFrom::End(offset) => {
+                        unwrapped_inner.len().saturating_sub(offset as usize)
+                    }
+                };
+
+                *original_offset = new_offset.min(unwrapped_inner.len());
+                Ok(*original_offset as u64)
+            }
+            RubyReader::RubyIoLike { inner } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
+
+                let (whence, ruby_offset) = match pos {
+                    SeekFrom::Start(i) => (0, i as i64),
+                    SeekFrom::Current(i) => (1, i),
+                    SeekFrom::End(i) => (2, i),
+                };
+
+                let new_position = unwrapped_inner
+                    .funcall("seek", (ruby_offset, whence))
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+
+                Ok(new_position)
+            }
         }
-        Ok(self.offset as u64)
     }
 }
 
-impl RubyReader<Value> {
-    fn from_io(input: Value) -> Result<Box<dyn SeekableRead>, magnus::Error> {
-        if Self::is_io_like(&input) {
-            Ok(Box::new(Self::from_io_like(input)))
-        } else {
-            Err(magnus::Error::new(
-                magnus::exception::type_error(),
-                "Input is not an IO-like object",
-            ))
+impl Read for RubyReader {
+    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        match self {
+            RubyReader::NativeProxyIoLike { proxy_file } => proxy_file.read(buf),
+            RubyReader::String { inner, offset } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
+
+                let string_buffer = unsafe { unwrapped_inner.as_slice() };
+                if *offset >= string_buffer.len() {
+                    return Ok(0); // EOF
+                }
+
+                let remaining = string_buffer.len() - *offset;
+                let copy_size = remaining.min(buf.len());
+                buf[..copy_size].copy_from_slice(&string_buffer[*offset..*offset + copy_size]);
+
+                *offset += copy_size;
+
+                Ok(copy_size)
+            }
+            RubyReader::RubyIoLike { inner } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
+
+                let bytes = unwrapped_inner
+                    .funcall::<_, _, Option<RString>>("read", (buf.len(),))
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+
+                match bytes {
+                    Some(bytes) => {
+                        let string_buffer = unsafe { bytes.as_slice() };
+                        buf.write_all(string_buffer)?;
+                        Ok(string_buffer.len())
+                    }
+                    None => {
+                        return Ok(0);
+                    }
+                }
+            }
         }
     }
+}
 
-    fn is_io_like(input: &Value) -> bool {
-        input.respond_to("read", false).unwrap_or(false)
-    }
+impl Length for RubyReader {
+    fn len(&self) -> u64 {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        match self {
+            RubyReader::NativeProxyIoLike { proxy_file } => proxy_file.len(),
+            RubyReader::String { inner, offset: _ } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
+                unwrapped_inner.len() as u64
+            }
+            RubyReader::RubyIoLike { inner } => {
+                let unwrapped_inner = ruby.get_inner(*inner);
+                let current_pos = unwrapped_inner.funcall::<_, _, u64>("seek", (0, 1));
+
+                if let Err(e) = current_pos {
+                    eprintln!("Error seeking: {}", e);
+                    return 0;
+                }
+
+                if let Err(e) = unwrapped_inner.funcall::<_, _, u64>("seek", (0, 2)) {
+                    eprintln!("Error seeking: {}", e);
+                    return 0;
+                }
 
-    fn from_io_like(input: Value) -> Self {
-        Self {
-            inner: input,
-            offset: 0,
+                let size = unwrapped_inner.funcall::<_, _, u64>("pos", ());
+
+                match size {
+                    Ok(size) => {
+                        // Restore original position
+                        if let Err(e) = unwrapped_inner.funcall::<_, _, u64>(
+                            "seek",
+                            (current_pos.expect("Current position is not set!"), 0),
+                        ) {
+                            eprintln!("Error seeking: {}", e);
+                            return 0;
+                        }
+                        size
+                    }
+                    Err(e) => {
+                        eprintln!("Error seeking: {}", e);
+                        return 0;
+                    }
+                }
+            }
         }
     }
 }
 
-impl RubyReader<RString> {
-    pub fn from_string_io(
-        ruby: &Ruby,
-        input: Value,
-    ) -> Result<Box<dyn SeekableRead>, magnus::Error> {
-        if !Self::is_string_io(ruby, &input) {
-            return Err(magnus::Error::new(
-                magnus::exception::type_error(),
-                "Input is not a StringIO",
-            ));
-        }
+const READ_BUFFER_SIZE: usize = 16 * 1024;
+
+#[derive(Clone)]
+pub struct ThreadSafeRubyReader(Arc<Mutex<RubyReader>>);
 
-        let string_content = input.funcall::<_, _, RString>("string", ()).unwrap();
-        Ok(Box::new(Self {
-            inner: string_content,
-            offset: 0,
-        }))
+impl ThreadSafeRubyReader {
+    pub fn new(reader: RubyReader) -> Self {
+        Self(Arc::new(Mutex::new(reader)))
     }
+}
 
-    fn is_string_io(ruby: &Ruby, input: &Value) -> bool {
-        let string_io_class = STRING_IO_CLASS.get_or_init(|| {
-            let class = RClass::from_value(ruby.eval("StringIO").unwrap()).unwrap();
-            Opaque::from(class)
-        });
-        input.is_kind_of(ruby.get_inner(*string_io_class))
+impl Length for ThreadSafeRubyReader {
+    fn len(&self) -> u64 {
+        self.0.lock().expect("Failed to lock mutex").len()
     }
+}
 
-    fn from_string_like(input: Value) -> Result<Box<dyn SeekableRead>, magnus::Error> {
-        // Try calling `to_str`, and if that fails, try `to_s`
-        let string_content = input
-            .funcall::<_, _, RString>("to_str", ())
-            .or_else(|_| input.funcall::<_, _, RString>("to_s", ()))?;
-        Ok(Box::new(Self {
-            inner: string_content,
-            offset: 0,
-        }))
+impl Seek for ThreadSafeRubyReader {
+    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
+        let mut reader = self
+            .0
+            .lock()
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+        reader.seek(pos)
     }
 }
 
-impl Read for RubyReader<Value> {
-    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
-        let bytes = self
-            .inner
-            .funcall::<_, _, RString>("read", (buf.len(),))
+impl Read for ThreadSafeRubyReader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let mut reader = self
+            .0
+            .lock()
             .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+        reader.read(buf)
+    }
+}
 
-        buf.write_all(unsafe { bytes.as_slice() })?;
+impl ChunkReader for ThreadSafeRubyReader {
+    type T = BufReader<ThreadSafeRubyReader>;
 
-        Ok(bytes.len())
+    fn get_read(&self, start: u64) -> parquet::errors::Result<Self::T> {
+        let mut reader = self.clone();
+        reader.seek(SeekFrom::Start(start))?;
+        Ok(BufReader::with_capacity(READ_BUFFER_SIZE, reader))
     }
-}
 
-impl Read for RubyReader<RString> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let string_buffer = unsafe { self.inner.as_slice() };
-        if self.offset >= string_buffer.len() {
-            return Ok(0); // EOF
-        }
+    fn get_bytes(&self, start: u64, length: usize) -> parquet::errors::Result<Bytes> {
+        let mut buffer = Vec::with_capacity(length);
+        let mut reader = self.clone();
+        reader.seek(SeekFrom::Start(start))?;
+        let read = reader.take(length as _).read_to_end(&mut buffer)?;
 
-        let remaining = string_buffer.len() - self.offset;
-        let copy_size = remaining.min(buf.len());
-        buf[..copy_size].copy_from_slice(&string_buffer[self.offset..self.offset + copy_size]);
-        self.offset += copy_size;
-        Ok(copy_size)
+        if read != length {
+            return Err(ParquetError::EOF(format!(
+                "Expected to read {} bytes, read only {}",
+                length, read
+            )));
+        }
+        Ok(buffer.into())
     }
 }

data/ext/parquet/src/types/timestamp.rs

@@ -45,7 +45,7 @@ pub fn parse_zoned_timestamp(value: &ParquetValue) -> jiff::Timestamp {
             ts.to_zoned(tz).timestamp()
         } else {
             // Try IANA timezone
-            match ts.intz(&tz) {
+            match ts.in_tz(&tz) {
                 Ok(zoned) => zoned.timestamp(),
                 Err(_) => ts, // Fall back to UTC if timezone is invalid
             }

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.2.13"
+  VERSION = "0.3.0"
 end

data/lib/parquet.rb

@@ -1,5 +1,10 @@
 require_relative "parquet/version"
-require_relative "parquet/parquet"
+
+begin
+  require "parquet/#{RUBY_VERSION.to_f}/parquet"
+rescue LoadError
+  require "parquet/parquet"
+end
 
 module Parquet
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.3.0
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-03 00:00:00.000000000 Z
+date: 2025-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -63,7 +63,6 @@ files:
 - ext/parquet/src/reader/mod.rs
 - ext/parquet/src/reader/parquet_column_reader.rs
 - ext/parquet/src/reader/parquet_row_reader.rs
-- ext/parquet/src/ruby_integration.rs
 - ext/parquet/src/ruby_reader.rs
 - ext/parquet/src/types/core_types.rs
 - ext/parquet/src/types/mod.rs
@@ -76,7 +75,6 @@ files:
 - ext/parquet/src/writer/mod.rs
 - lib/parquet.rb
 - lib/parquet.rbi
-- lib/parquet/parquet.so
 - lib/parquet/version.rb
 homepage: https://github.com/njaremko/parquet-ruby
 licenses: