parquet 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea1f639c9ac61eb47b4449999aacb95770a5b863dcf00358b616bdd57dcdf348
-  data.tar.gz: dc9480d6c4959e8f6ad4cc6775583f3ebf59ef5393eaeef801f84e25ca32fa3d
+  metadata.gz: dd9295880f123b0ed979fb970d789bf63461007e8c087641b47391baa02bef29
+  data.tar.gz: e5ccd26a48e7b800412049e9d44e7f8c6fb5c12dbe25c74980467c822fb114c6
 SHA512:
-  metadata.gz: b1c17ae80a816a643ef47afc44172b6738baa9c28d671938f9c5781a466285199332d29ee96b4362c446f41c1ad7737255bab78c63a62626d6d982202da0b867
-  data.tar.gz: a91604cc16cc3f8eeb127da29d70e4ed9fca72a1c52613f4d7587db15809342710e9dc9d0c513c29ba6f112ace47d466b99a159629d5bb84969c587392f2468e
+  metadata.gz: f275d82733cd6b1658ed7b6212618830e2a12e6831bcfcc26beeae79691ddc972b22b0b0660f10db9b0bb7a03e2af29da15de28d037d5896891fbd678b3ecca9
+  data.tar.gz: 8fbfd33a92350c84409c0e879745fbc5a07d60f0a2862a2993a4780eb5c110be7b3918bfdfe6721e60e44635792108a1a3eeed460a189076bd03056a27764e50

data/ext/parquet/src/adapter_ffi.rs

@@ -1,6 +1,6 @@
 use magnus::scan_args::{get_kwargs, scan_args};
-use magnus::value::ReprValue;
 use magnus::{Error as MagnusError, Ruby, Value};
+use parquet_ruby_adapter::utils::parse_string_or_symbol;
 use parquet_ruby_adapter::{
     logger::RubyLogger, types::ParserResultType, utils::parse_parquet_write_args,
 };
@@ -34,11 +34,14 @@ pub fn each_row(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError> {
     )?;
 
     let result_type: ParserResultType = if let Some(rt_value) = kwargs.optional.0.flatten() {
-        rt_value
-            .to_r_string()?
-            .to_string()?
+        parse_string_or_symbol(&ruby, rt_value)?
+            .ok_or_else(|| {
+                MagnusError::new(magnus::exception::arg_error(), "result_type cannot be nil")
+            })?
             .parse()
-            .map_err(|e| MagnusError::new(ruby.exception_arg_error(), e))?
+            .map_err(|_| {
+                MagnusError::new(magnus::exception::arg_error(), "Invalid result_type value")
+            })?
     } else {
         ParserResultType::Hash
     };
@@ -89,11 +92,14 @@ pub fn each_column(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError>
     )?;
 
     let result_type: ParserResultType = if let Some(rt_value) = kwargs.optional.0.flatten() {
-        rt_value
-            .to_r_string()?
-            .to_string()?
+        parse_string_or_symbol(&ruby, rt_value)?
+            .ok_or_else(|| {
+                MagnusError::new(magnus::exception::arg_error(), "result_type cannot be nil")
+            })?
             .parse()
-            .map_err(|e| MagnusError::new(ruby.exception_arg_error(), e))?
+            .map_err(|_| {
+                MagnusError::new(magnus::exception::arg_error(), "Invalid result_type value")
+            })?
     } else {
         ParserResultType::Hash
     };
@@ -101,7 +107,7 @@ pub fn each_column(rb_self: Value, args: &[Value]) -> Result<Value, MagnusError>
     let batch_size = if let Some(bs) = kwargs.optional.2.flatten() {
         if bs == 0 {
             return Err(MagnusError::new(
-                ruby.exception_arg_error(),
+                magnus::exception::arg_error(),
                 "batch_size must be greater than 0",
             ));
         }

data/ext/parquet-ruby-adapter/src/schema.rs

@@ -2,6 +2,8 @@ use magnus::value::ReprValue;
 use magnus::{Error as MagnusError, RArray, RHash, Ruby, Symbol, TryConvert, Value};
 use parquet_core::{ParquetError, PrimitiveType, Result, Schema, SchemaNode};
 
+use crate::utils::parse_string_or_symbol;
+
 /// Ruby schema builder that converts Ruby hash/array representations to Parquet schemas
 pub struct RubySchemaBuilder;
 
@@ -595,7 +597,7 @@ fn schema_node_to_ruby(node: &SchemaNode, _ruby: &Ruby) -> Result<Value> {
 /// Convert old schema format to new format
 /// Old: [{ "column_name" => "type" }, ...]
 /// New: [{ name: "column_name", type: :type }, ...]
-pub fn convert_legacy_schema(_ruby: &Ruby, schema: RArray) -> Result<RArray> {
+pub fn convert_legacy_schema(ruby: &Ruby, schema: RArray) -> Result<RArray> {
     let new_schema = RArray::new();
 
     for item in schema.into_iter() {
@@ -609,7 +611,12 @@ pub fn convert_legacy_schema(_ruby: &Ruby, schema: RArray) -> Result<RArray> {
             |key: Value,
              value: Value|
              -> std::result::Result<magnus::r_hash::ForEach, MagnusError> {
-                let key_str: String = TryConvert::try_convert(key)?;
+                let key_str: String = parse_string_or_symbol(ruby, key)?.ok_or_else(|| {
+                    MagnusError::new(
+                        magnus::exception::arg_error(),
+                        "Nil keys not allowed in schema",
+                    )
+                })?;
                 let type_str: String = TryConvert::try_convert(value)?;
 
                 new_field.aset(Symbol::new("name"), key_str)?;

data/ext/parquet-ruby-adapter/src/utils.rs

@@ -122,6 +122,21 @@ pub fn parse_parquet_write_args(
     })
 }
 
+/// Convert a Ruby Value to a String, handling both String and Symbol types
+pub fn parse_string_or_symbol(ruby: &Ruby, value: Value) -> Result<Option<String>, MagnusError> {
+    if value.is_nil() {
+        Ok(None)
+    } else if value.is_kind_of(ruby.class_string()) || value.is_kind_of(ruby.class_symbol()) {
+        let stringed = value.to_r_string()?.to_string()?;
+        Ok(Some(stringed))
+    } else {
+        Err(MagnusError::new(
+            magnus::exception::type_error(),
+            "Value must be a String or Symbol",
+        ))
+    }
+}
+
 /// Handle block or enumerator creation
 pub fn handle_block_or_enum<F, T>(
     block_given: bool,

data/lib/parquet/version.rb

@@ -1,3 +1,3 @@
 module Parquet
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Nathan Jaremko