GH-33749: [Ruby] Add Arrow::RecordBatch#each_raw_record

ruby/red-arrow/ext/arrow/arrow.cpp

@@ -87,6 +87,9 @@ extern "C" void Init_arrow() {
   rb_define_method(cArrowTable, "raw_records",
                    reinterpret_cast<rb::RawMethod>(red_arrow::table_raw_records),
                    0);
+  rb_define_method(cArrowTable, "each_raw_record",
+                   reinterpret_cast<rb::RawMethod>(red_arrow::table_each_raw_record),
+                   0);
 
   red_arrow::cDate = rb_const_get(rb_cObject, rb_intern("Date"));
 

ruby/red-arrow/ext/arrow/raw-records.cpp

@@ -26,7 +26,9 @@ namespace red_arrow {
       explicit RawRecordsBuilder(VALUE records, int n_columns)
         : Converter(),
           records_(records),
-          n_columns_(n_columns) {
+          record_(Qnil),
+          n_columns_(n_columns),
+          is_produce_mode_(false) {
       }
 
       void build(const arrow::RecordBatch& record_batch) {
@@ -68,6 +70,29 @@ namespace red_arrow {
         });
       }
 
+      void produce(const arrow::Table& table) {
+        rb::protect([&] {
+          is_produce_mode_ = true;
+          const auto n_rows = table.num_rows();
+          for (int64_t i = 0; i < n_rows; ++i) {
+            row_offset_ = i;
+            record_ = rb_ary_new_capa(n_columns_);
+
+            for (int i = 0; i < n_columns_; ++i) {
+              const auto& chunked_array = table.column(i).get();
+              column_index_ = i;
+
+              for (const auto array : chunked_array->chunks()) {
+                check_status(array->Accept(this),
+                            "[table][each-raw-record]");
+              }
+            }
+            rb_yield(record_);
+          }
+          return Qnil;
+        });
+      }
+
 #define VISIT(TYPE)                                                     \
       arrow::Status Visit(const arrow::TYPE ## Array& array) override { \
         convert(array);                                                 \
@@ -125,16 +150,23 @@ namespace red_arrow {
             rb_ary_store(record, column_index_, value);
           }
         } else {
-          for (int64_t i = 0, ii = row_offset_; i < n; ++i, ++ii) {
-            auto record = rb_ary_entry(records_, ii);
-            rb_ary_store(record, column_index_, convert_value(array, i));
+          if (is_produce_mode_) {
+            rb_ary_store(record_, column_index_, convert_value(array, row_offset_));
+          } else {
+            for (int64_t i = 0, ii = row_offset_; i < n; ++i, ++ii) {
+              auto record = rb_ary_entry(records_, ii);
+              rb_ary_store(record, column_index_, convert_value(array, i));
+            }
           }
         }
       }
 
       // Destination for converted records.
       VALUE records_;
 
+      // Destination for converted record.
+      VALUE record_;
+
       // The current column index.
       int column_index_;
 
@@ -143,6 +175,8 @@ namespace red_arrow {
 
       // The number of columns.
       const int n_columns_;
+
+      bool is_produce_mode_;
     };
   }
 
@@ -181,4 +215,22 @@ namespace red_arrow {
 
     return records;
   }
+
+  VALUE
+  table_each_raw_record(VALUE rb_table) {
+    auto garrow_table = GARROW_TABLE(RVAL2GOBJ(rb_table));
+    auto table = garrow_table_get_raw(garrow_table).get();
+    const auto n_rows = table->num_rows();
+    const auto n_columns = table->num_columns();
+    auto records = rb_ary_new_capa(n_rows);
+
+    try {
+      RawRecordsBuilder builder(records, n_columns);
+      builder.produce(*table);
+    } catch (rb::State& state) {
+      state.jump();
+    }
+
+    return Qnil;
+  }
 }

ruby/red-arrow/ext/arrow/red-arrow.hpp

@@ -59,6 +59,7 @@ namespace red_arrow {
 
   VALUE record_batch_raw_records(VALUE obj);
   VALUE table_raw_records(VALUE obj);
+  VALUE table_each_raw_record(VALUE obj);
 
   inline VALUE time_unit_to_scale(const arrow::TimeUnit::type unit) {
     switch (unit) {