parquet 0.5.13 → 0.6.0

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

@@ -0,0 +1,435 @@
+use magnus::value::ReprValue;
+use magnus::{Error as MagnusError, Ruby, TryConvert, Value};
+use parquet::file::properties::WriterProperties;
+use parquet_core::Schema;
+use std::io::{BufReader, BufWriter, Write};
+use tempfile::NamedTempFile;
+
+use crate::io::RubyIOWriter;
+use crate::types::WriterOutput;
+use crate::utils::parse_compression;
+
+/// Create a writer based on the output type (file path or IO object)
+pub fn create_writer(
+    ruby: &Ruby,
+    write_to: Value,
+    schema: Schema,
+    compression: Option<String>,
+) -> Result<WriterOutput, MagnusError> {
+    let compression_setting = parse_compression(compression)?;
+    let props = WriterProperties::builder()
+        .set_compression(compression_setting)
+        .build();
+
+    if write_to.is_kind_of(ruby.class_string()) {
+        // Direct file path
+        let path_str: String = TryConvert::try_convert(write_to)?;
+        let file = std::fs::File::create(&path_str)
+            .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+        let writer = parquet_core::writer::Writer::new_with_properties(file, schema, props)
+            .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+        Ok(WriterOutput::File(writer))
+    } else {
+        // IO-like object - create temporary file
+        let temp_file = NamedTempFile::new().map_err(|e| {
+            MagnusError::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to create temporary file: {}", e),
+            )
+        })?;
+
+        // Clone the file handle for the writer
+        let file = temp_file.reopen().map_err(|e| {
+            MagnusError::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to reopen temporary file: {}", e),
+            )
+        })?;
+
+        let writer = parquet_core::writer::Writer::new_with_properties(file, schema, props)
+            .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+        Ok(WriterOutput::TempFile(writer, temp_file, write_to))
+    }
+}
+
+/// Finalize the writer and copy temp file to IO if needed
+pub fn finalize_writer(writer_output: WriterOutput) -> Result<(), MagnusError> {
+    match writer_output {
+        WriterOutput::File(writer) => writer
+            .close()
+            .map_err(|e| MagnusError::new(magnus::exception::runtime_error(), e.to_string())),
+        WriterOutput::TempFile(writer, temp_file, io_object) => {
+            // Close the writer first
+            writer
+                .close()
+                .map_err(|e| MagnusError::new(magnus::exception::runtime_error(), e.to_string()))?;
+
+            // Copy temp file to IO object
+            copy_temp_file_to_io(temp_file, io_object)
+        }
+    }
+}
+
+/// Copy temporary file contents to Ruby IO object
+fn copy_temp_file_to_io(temp_file: NamedTempFile, io_object: Value) -> Result<(), MagnusError> {
+    let file = temp_file.reopen().map_err(|e| {
+        MagnusError::new(
+            magnus::exception::runtime_error(),
+            format!("Failed to reopen temporary file: {}", e),
+        )
+    })?;
+
+    let mut buf_reader = BufReader::new(file);
+    let ruby_io_writer = RubyIOWriter::new(io_object);
+    let mut buf_writer = BufWriter::new(ruby_io_writer);
+
+    std::io::copy(&mut buf_reader, &mut buf_writer).map_err(|e| {
+        MagnusError::new(
+            magnus::exception::runtime_error(),
+            format!("Failed to copy temp file to IO object: {}", e),
+        )
+    })?;
+
+    buf_writer.flush().map_err(|e| {
+        MagnusError::new(
+            magnus::exception::runtime_error(),
+            format!("Failed to flush IO object: {}", e),
+        )
+    })?;
+
+    // The temporary file will be automatically deleted when temp_file is dropped
+    Ok(())
+}
+
+/// Write data in row format to a parquet file
+pub fn write_rows(
+    ruby: &Ruby,
+    write_args: crate::types::ParquetWriteArgs,
+) -> Result<Value, MagnusError> {
+    use crate::batch_manager::BatchSizeManager;
+    use crate::converter::RubyValueConverter;
+    use crate::logger::RubyLogger;
+    use crate::schema::{extract_field_schemas, process_schema_value, ruby_schema_to_parquet};
+    use crate::string_cache::StringCache;
+    use crate::utils::estimate_row_size;
+    use magnus::{RArray, TryConvert};
+
+    // Convert data to array if it isn't already
+    let data_array = if write_args.read_from.is_kind_of(ruby.class_array()) {
+        TryConvert::try_convert(write_args.read_from)?
+    } else if write_args.read_from.respond_to("to_a", false)? {
+        let array_value: Value = write_args.read_from.funcall("to_a", ())?;
+        TryConvert::try_convert(array_value)?
+    } else {
+        return Err(MagnusError::new(
+            ruby.exception_type_error(),
+            "data must be an array or respond to 'to_a'",
+        ));
+    };
+
+    let data_array: RArray = data_array;
+
+    // Process schema value
+    let schema_hash = process_schema_value(ruby, write_args.schema_value, Some(&data_array))
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Create schema
+    let schema = ruby_schema_to_parquet(schema_hash)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Extract field schemas for conversion hints
+    let field_schemas = extract_field_schemas(&schema);
+
+    // Create writer
+    let mut writer_output = create_writer(
+        ruby,
+        write_args.write_to,
+        schema.clone(),
+        write_args.compression,
+    )?;
+
+    // Create logger
+    let logger = RubyLogger::new(write_args.logger)?;
+    let _ = logger.info(|| "Starting to write parquet file".to_string());
+
+    // Create batch size manager
+    let mut batch_manager = BatchSizeManager::new(
+        write_args.batch_size,
+        write_args.flush_threshold,
+        write_args.sample_size,
+    );
+
+    let _ = logger.debug(|| {
+        format!(
+            "Batch sizing: fixed_size={:?}, memory_threshold={}, sample_size={}",
+            batch_manager.fixed_batch_size,
+            batch_manager.memory_threshold,
+            batch_manager.sample_size
+        )
+    });
+
+    // Create converter with string cache if enabled
+    let mut converter = if write_args.string_cache.unwrap_or(false) {
+        let _ = logger.debug(|| "String cache enabled".to_string());
+        RubyValueConverter::with_string_cache(StringCache::new(true))
+    } else {
+        RubyValueConverter::new()
+    };
+
+    // Collect rows in batches
+    let mut batch = Vec::new();
+    let mut batch_memory_size = 0usize;
+    let mut total_rows = 0u64;
+
+    for row_value in data_array.into_iter() {
+        // Convert Ruby row to ParquetValue vector
+        let row = if row_value.is_kind_of(ruby.class_array()) {
+            let array: RArray = TryConvert::try_convert(row_value)?;
+            let mut values = Vec::with_capacity(array.len());
+
+            for (idx, item) in array.into_iter().enumerate() {
+                let schema_hint = field_schemas.get(idx);
+                let pq_value = converter
+                    .to_parquet_with_schema_hint(item, schema_hint)
+                    .map_err(|e| {
+                        let error_msg = e.to_string();
+                        // Check if this is an encoding error
+                        if error_msg.contains("EncodingError")
+                            || error_msg.contains("invalid utf-8")
+                        {
+                            // Extract the actual encoding error message
+                            if let Some(pos) = error_msg.find("EncodingError: ") {
+                                let encoding_msg = error_msg[pos + 15..].to_string();
+                                MagnusError::new(ruby.exception_encoding_error(), encoding_msg)
+                            } else {
+                                MagnusError::new(ruby.exception_encoding_error(), error_msg)
+                            }
+                        } else {
+                            MagnusError::new(ruby.exception_runtime_error(), error_msg)
+                        }
+                    })?;
+                values.push(pq_value);
+            }
+            values
+        } else {
+            return Err(MagnusError::new(
+                ruby.exception_type_error(),
+                "each row must be an array",
+            ));
+        };
+
+        // Record row size for dynamic batch sizing
+        let row_size = estimate_row_size(&row);
+        batch_manager.record_row_size(row_size);
+        batch_memory_size += row_size;
+
+        batch.push(row);
+        total_rows += 1;
+
+        // Log sampling progress
+        if batch_manager.row_size_samples.len() <= batch_manager.sample_size
+            && batch_manager.row_size_samples.len() % 10 == 0
+        {
+            let _ = logger.debug(|| {
+                format!(
+                    "Sampled {} rows, avg size: {} bytes, current batch size: {}",
+                    batch_manager.row_size_samples.len(),
+                    batch_manager.average_row_size(),
+                    batch_manager.current_batch_size
+                )
+            });
+        }
+
+        // Write batch if it reaches threshold
+        if batch_manager.should_flush(batch.len(), batch_memory_size) {
+            let _ = logger.info(|| format!("Writing batch of {} rows", batch.len()));
+            let _ = logger.debug(|| format!(
+                "Batch details: recent avg row size: {} bytes, current batch size: {}, actual memory: {} bytes",
+                batch_manager.recent_average_size(),
+                batch_manager.current_batch_size,
+                batch_memory_size
+            ));
+            match &mut writer_output {
+                WriterOutput::File(writer) | WriterOutput::TempFile(writer, _, _) => {
+                    writer.write_rows(std::mem::take(&mut batch)).map_err(|e| {
+                        MagnusError::new(ruby.exception_runtime_error(), e.to_string())
+                    })?;
+                }
+            }
+            batch_memory_size = 0;
+        }
+    }
+
+    // Write remaining rows
+    if !batch.is_empty() {
+        let _ = logger.info(|| format!("Writing batch of {} rows", batch.len()));
+        let _ = logger.debug(|| format!("Final batch: {} rows", batch.len()));
+        match &mut writer_output {
+            WriterOutput::File(writer) | WriterOutput::TempFile(writer, _, _) => {
+                writer
+                    .write_rows(batch)
+                    .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+            }
+        }
+    }
+
+    let _ = logger.info(|| format!("Finished writing {} rows to parquet file", total_rows));
+
+    // Log string cache statistics if enabled
+    if let Some(stats) = converter.string_cache_stats() {
+        let _ = logger.info(|| {
+            format!(
+                "String cache stats: {} unique strings, {} hits ({:.1}% hit rate)",
+                stats.size,
+                stats.hits,
+                stats.hit_rate * 100.0
+            )
+        });
+    }
+
+    // Finalize the writer
+    finalize_writer(writer_output)?;
+
+    Ok(ruby.qnil().as_value())
+}
+
+/// Write data in column format to a parquet file
+pub fn write_columns(
+    ruby: &Ruby,
+    write_args: crate::types::ParquetWriteArgs,
+) -> Result<Value, MagnusError> {
+    use crate::converter::RubyValueConverter;
+    use crate::schema::{extract_field_schemas, process_schema_value, ruby_schema_to_parquet};
+    use magnus::{RArray, TryConvert};
+
+    // Convert data to array for processing
+    let data_array = if write_args.read_from.is_kind_of(ruby.class_array()) {
+        TryConvert::try_convert(write_args.read_from)?
+    } else if write_args.read_from.respond_to("to_a", false)? {
+        let array_value: Value = write_args.read_from.funcall("to_a", ())?;
+        TryConvert::try_convert(array_value)?
+    } else {
+        return Err(MagnusError::new(
+            ruby.exception_type_error(),
+            "data must be an array or respond to 'to_a'",
+        ));
+    };
+
+    let data_array: RArray = data_array;
+
+    // Process schema value
+    let schema_hash = process_schema_value(ruby, write_args.schema_value, Some(&data_array))
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Create schema
+    let schema = ruby_schema_to_parquet(schema_hash)
+        .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+    // Extract field schemas for conversion hints
+    let field_schemas = extract_field_schemas(&schema);
+
+    // Create writer
+    let mut writer_output = create_writer(
+        ruby,
+        write_args.write_to,
+        schema.clone(),
+        write_args.compression,
+    )?;
+
+    // Get column names from schema
+    let column_names: Vec<String> =
+        if let parquet_core::SchemaNode::Struct { fields, .. } = &schema.root {
+            fields.iter().map(|f| f.name().to_string()).collect()
+        } else {
+            return Err(MagnusError::new(
+                ruby.exception_runtime_error(),
+                "Schema root must be a struct",
+            ));
+        };
+
+    // Convert data to columns format
+    let mut all_columns: Vec<(String, Vec<parquet_core::ParquetValue>)> = Vec::new();
+
+    // Process batches
+    for (batch_idx, batch) in data_array.into_iter().enumerate() {
+        if !batch.is_kind_of(ruby.class_array()) {
+            return Err(MagnusError::new(
+                ruby.exception_type_error(),
+                "each batch must be an array of column values",
+            ));
+        }
+
+        let batch_array: RArray = TryConvert::try_convert(batch)?;
+
+        // Verify batch has the right number of columns
+        if batch_array.len() != column_names.len() {
+            return Err(MagnusError::new(
+                ruby.exception_runtime_error(),
+                format!(
+                    "Batch has {} columns but schema has {}",
+                    batch_array.len(),
+                    column_names.len()
+                ),
+            ));
+        }
+
+        // Process each column in the batch
+        for (col_idx, column_values) in batch_array.into_iter().enumerate() {
+            if !column_values.is_kind_of(ruby.class_array()) {
+                return Err(MagnusError::new(
+                    ruby.exception_type_error(),
+                    format!("Column {} values must be an array", col_idx),
+                ));
+            }
+
+            let values_array: RArray = TryConvert::try_convert(column_values)?;
+
+            // Initialize column vector on first batch
+            if batch_idx == 0 {
+                all_columns.push((column_names[col_idx].clone(), Vec::new()));
+            }
+
+            // Convert and append values
+            let mut converter = RubyValueConverter::new();
+            let schema_hint = field_schemas.get(col_idx);
+
+            for value in values_array.into_iter() {
+                let pq_value = converter
+                    .to_parquet_with_schema_hint(value, schema_hint)
+                    .map_err(|e| {
+                        let error_msg = e.to_string();
+                        // Check if this is an encoding error
+                        if error_msg.contains("EncodingError")
+                            || error_msg.contains("invalid utf-8")
+                        {
+                            // Extract the actual encoding error message
+                            if let Some(pos) = error_msg.find("EncodingError: ") {
+                                let encoding_msg = error_msg[pos + 15..].to_string();
+                                MagnusError::new(ruby.exception_encoding_error(), encoding_msg)
+                            } else {
+                                MagnusError::new(ruby.exception_encoding_error(), error_msg)
+                            }
+                        } else {
+                            MagnusError::new(ruby.exception_runtime_error(), error_msg)
+                        }
+                    })?;
+                all_columns[col_idx].1.push(pq_value);
+            }
+        }
+    }
+
+    // Write the columns
+    match &mut writer_output {
+        WriterOutput::File(writer) | WriterOutput::TempFile(writer, _, _) => {
+            writer
+                .write_columns(all_columns)
+                .map_err(|e| MagnusError::new(ruby.exception_runtime_error(), e.to_string()))?;
+        }
+    }
+
+    // Finalize the writer
+    finalize_writer(writer_output)?;
+
+    Ok(ruby.qnil().as_value())
+}

data/lib/parquet/schema.rb

@@ -59,12 +59,31 @@ module Parquet
       #   - `key_nullable:, value_nullable:` controls nullability of map keys/values (default: true)
       #   - `format:` if you want to store some format string
       #   - `precision:, scale:` if type == :decimal (precision defaults to 38, scale to 0)
+      #   - `has_timezone:` if type is timestamp - true means UTC storage (default), false means local/unzoned
+      #   - `timezone:` (DEPRECATED) if type is timestamp - any value means UTC storage
       #   - `nullable:` default to true if not specified
       def field(name, type, nullable: true, **kwargs, &block)
         field_hash = { name: name.to_s, type: type, nullable: !!nullable }
 
         # Possibly store a format if provided
         field_hash[:format] = kwargs[:format] if kwargs.key?(:format)
+        
+        # Handle timezone for timestamp types
+        if [:timestamp_second, :timestamp_millis, :timestamp_micros, :timestamp_nanos].include?(type)
+          # Support new has_timezone parameter (preferred)
+          if kwargs.key?(:has_timezone)
+            # If has_timezone is true, store "UTC" to indicate timezone presence
+            # If explicitly false, don't store timezone (indicates local/unzoned)
+            field_hash[:timezone] = "UTC" if kwargs[:has_timezone]
+          elsif kwargs.key?(:timezone)
+            # Legacy support: any timezone value means UTC storage
+            # Store "UTC" regardless of the actual value to make it clear
+            field_hash[:timezone] = "UTC"
+          else
+            # Default behavior when neither parameter is specified: UTC storage
+            field_hash[:timezone] = "UTC"
+          end
+        end
 
         case type
         when :struct

data/lib/parquet/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parquet
 version: !ruby/object:Gem::Version
-  version: 0.5.13
+  version: 0.6.0
 platform: ruby
 authors:
 - Nathan Jaremko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-24 00:00:00.000000000 Z
+date: 2025-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -54,33 +54,59 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- ext/parquet-core/Cargo.toml
+- ext/parquet-core/src/arrow_conversion.rs
+- ext/parquet-core/src/error.rs
+- ext/parquet-core/src/lib.rs
+- ext/parquet-core/src/reader.rs
+- ext/parquet-core/src/schema.rs
+- ext/parquet-core/src/test_utils.rs
+- ext/parquet-core/src/traits/mod.rs
+- ext/parquet-core/src/traits/schema.rs
+- ext/parquet-core/src/value.rs
+- ext/parquet-core/src/writer.rs
+- ext/parquet-core/tests/arrow_conversion_tests.rs
+- ext/parquet-core/tests/binary_data.rs
+- ext/parquet-core/tests/column_projection.rs
+- ext/parquet-core/tests/complex_types.rs
+- ext/parquet-core/tests/compression_tests.rs
+- ext/parquet-core/tests/concurrent_access.rs
+- ext/parquet-core/tests/decimal_tests.rs
+- ext/parquet-core/tests/edge_cases_corner_cases.rs
+- ext/parquet-core/tests/error_handling_comprehensive_tests.rs
+- ext/parquet-core/tests/null_handling_tests.rs
+- ext/parquet-core/tests/performance_memory.rs
+- ext/parquet-core/tests/primitive_types.rs
+- ext/parquet-core/tests/real_world_patterns.rs
+- ext/parquet-core/tests/roundtrip_correctness.rs
+- ext/parquet-core/tests/schema_comprehensive_tests.rs
+- ext/parquet-core/tests/temporal_tests.rs
+- ext/parquet-core/tests/test_helpers.rs
+- ext/parquet-core/tests/writer_tests.rs
+- ext/parquet-ruby-adapter/Cargo.toml
+- ext/parquet-ruby-adapter/build.rs
+- ext/parquet-ruby-adapter/examples/try_into_value_demo.rs
+- ext/parquet-ruby-adapter/src/batch_manager.rs
+- ext/parquet-ruby-adapter/src/chunk_reader.rs
+- ext/parquet-ruby-adapter/src/converter.rs
+- ext/parquet-ruby-adapter/src/error.rs
+- ext/parquet-ruby-adapter/src/io.rs
+- ext/parquet-ruby-adapter/src/lib.rs
+- ext/parquet-ruby-adapter/src/logger.rs
+- ext/parquet-ruby-adapter/src/metadata.rs
+- ext/parquet-ruby-adapter/src/reader.rs
+- ext/parquet-ruby-adapter/src/schema.rs
+- ext/parquet-ruby-adapter/src/string_cache.rs
+- ext/parquet-ruby-adapter/src/try_into_value.rs
+- ext/parquet-ruby-adapter/src/types.rs
+- ext/parquet-ruby-adapter/src/utils.rs
+- ext/parquet-ruby-adapter/src/writer.rs
 - ext/parquet/Cargo.toml
 - ext/parquet/build.rs
 - ext/parquet/extconf.rb
+- ext/parquet/src/adapter_ffi.rs
 - ext/parquet/src/allocator.rs
-- ext/parquet/src/enumerator.rs
-- ext/parquet/src/header_cache.rs
 - ext/parquet/src/lib.rs
-- ext/parquet/src/logger.rs
-- ext/parquet/src/reader/common.rs
-- 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/reader/unified/mod.rs
-- ext/parquet/src/ruby_reader.rs
-- ext/parquet/src/types/core_types.rs
-- ext/parquet/src/types/mod.rs
-- ext/parquet/src/types/parquet_value.rs
-- ext/parquet/src/types/record_types.rs
-- ext/parquet/src/types/schema_converter.rs
-- ext/parquet/src/types/schema_node.rs
-- ext/parquet/src/types/timestamp.rs
-- ext/parquet/src/types/type_conversion.rs
-- ext/parquet/src/types/writer_types.rs
-- ext/parquet/src/utils.rs
-- ext/parquet/src/writer/mod.rs
-- ext/parquet/src/writer/write_columns.rs
-- ext/parquet/src/writer/write_rows.rs
 - lib/parquet.rb
 - lib/parquet.rbi
 - lib/parquet/schema.rb

data/ext/parquet/src/enumerator.rs

@@ -1,68 +0,0 @@
-use crate::ParserResultType;
-use magnus::{value::ReprValue, Error as MagnusError, KwArgs, RArray, RHash, Symbol, Value};
-
-pub struct RowEnumeratorArgs {
-    pub rb_self: Value,
-    pub to_read: Value,
-    pub result_type: ParserResultType,
-    pub columns: Option<Vec<String>>,
-    pub strict: bool,
-    pub logger: Option<Value>,
-}
-
-/// Creates an enumerator for lazy Parquet row parsing
-pub fn create_row_enumerator(args: RowEnumeratorArgs) -> Result<magnus::Enumerator, MagnusError> {
-    let kwargs = RHash::new();
-    kwargs.aset(
-        Symbol::new("result_type"),
-        Symbol::new(args.result_type.to_string()),
-    )?;
-    if let Some(columns) = args.columns {
-        kwargs.aset(Symbol::new("columns"), RArray::from_vec(columns))?;
-    }
-    if args.strict {
-        kwargs.aset(Symbol::new("strict"), true)?;
-    }
-    if let Some(logger) = args.logger {
-        kwargs.aset(Symbol::new("logger"), logger)?;
-    }
-    Ok(args
-        .rb_self
-        .enumeratorize("each_row", (args.to_read, KwArgs(kwargs))))
-}
-
-pub struct ColumnEnumeratorArgs {
-    pub rb_self: Value,
-    pub to_read: Value,
-    pub result_type: ParserResultType,
-    pub columns: Option<Vec<String>>,
-    pub batch_size: Option<usize>,
-    pub strict: bool,
-    pub logger: Option<Value>,
-}
-
-#[inline]
-pub fn create_column_enumerator(
-    args: ColumnEnumeratorArgs,
-) -> Result<magnus::Enumerator, MagnusError> {
-    let kwargs = RHash::new();
-    kwargs.aset(
-        Symbol::new("result_type"),
-        Symbol::new(args.result_type.to_string()),
-    )?;
-    if let Some(columns) = args.columns {
-        kwargs.aset(Symbol::new("columns"), RArray::from_vec(columns))?;
-    }
-    if let Some(batch_size) = args.batch_size {
-        kwargs.aset(Symbol::new("batch_size"), batch_size)?;
-    }
-    if args.strict {
-        kwargs.aset(Symbol::new("strict"), true)?;
-    }
-    if let Some(logger) = args.logger {
-        kwargs.aset(Symbol::new("logger"), logger)?;
-    }
-    Ok(args
-        .rb_self
-        .enumeratorize("each_column", (args.to_read, KwArgs(kwargs))))
-}