GH-48306: [Ruby] Add support for reading binary array (#48307)

### Rationale for this change

We can use this as a base feature for UTF-8/large binary/large UTF-8 array.

### What changes are included in this PR?

* Add `ArrowFormat::BinaryType`
* Add `ArrowFormat::BinaryArray`
* Add support `Binary` FlatBuffers type

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* GitHub Issue: #48306

Authored-by: Sutou Kouhei <[email protected]>
Signed-off-by: Sutou Kouhei <[email protected]>

Author: kou

ruby/red-arrow-format/lib/arrow-format/array.rb

@@ -19,11 +19,10 @@ class Array
     attr_reader :type
     attr_reader :size
     alias_method :length, :size
-    def initialize(type, size, validity_buffer, values_buffer)
+    def initialize(type, size, validity_buffer)
       @type = type
       @size = size
       @validity_buffer = validity_buffer
-      @values_buffer = values_buffer
     end
 
     def valid?(i)
@@ -55,15 +54,41 @@ def apply_validity(array)
     end
   end
 
-  class Int8Array < Array
+  class IntArray < Array
+    def initialize(type, size, validity_buffer, values_buffer)
+      super(type, size, validity_buffer)
+      @values_buffer = values_buffer
+    end
+  end
+
+  class Int8Array < IntArray
     def to_a
       apply_validity(@values_buffer.values(:S8, 0, @size))
     end
   end
 
-  class UInt8Array < Array
+  class UInt8Array < IntArray
     def to_a
       apply_validity(@values_buffer.values(:U8, 0, @size))
     end
   end
+
+  class BinaryArray < Array
+    def initialize(type, size, validity_buffer, offsets_buffer, values_buffer)
+      super(type, size, validity_buffer)
+      @offsets_buffer = offsets_buffer
+      @values_buffer = values_buffer
+    end
+
+    def to_a
+      values = @offsets_buffer.
+        each(:s32, 0, @size + 1). # TODO: big endian support
+        each_cons(2).
+        collect do |(_, offset), (_, next_offset)|
+        length = next_offset - offset
+        @values_buffer.get_string(offset, length)
+      end
+      apply_validity(values)
+    end
+  end
 end

ruby/red-arrow-format/lib/arrow-format/file-reader.rb

@@ -137,26 +137,34 @@ def read_schema(fb_schema)
               type = UInt8Type.singleton
             end
           end
+        when Org::Apache::Arrow::Flatbuf::Binary
+          type = BinaryType.singleton
         end
         Field.new(fb_field.name, type)
       end
       Schema.new(fields)
     end
 
     def read_column(field, n_rows, buffers, body)
+      validity_buffer = buffers.shift
+      if validity_buffer.length.zero?
+        validity = nil
+      else
+        validity = body.slice(validity_buffer.offset, validity_buffer.length)
+      end
+
       case field.type
       when Int8Type,
            UInt8Type
-        validity_buffer = buffers.shift
-        if validity_buffer.length.zero?
-          validity = nil
-        else
-          validity = body.slice(validity_buffer.offset, validity_buffer.length)
-        end
-
         values_buffer = buffers.shift
         values = body.slice(values_buffer.offset, values_buffer.length)
         field.type.build_array(n_rows, validity, values)
+      when BinaryType
+        offsets_buffer = buffers.shift
+        values_buffer = buffers.shift
+        offsets = body.slice(offsets_buffer.offset, offsets_buffer.length)
+        values = body.slice(values_buffer.offset, values_buffer.length)
+        field.type.build_array(n_rows, validity, offsets, values)
       end
     end
   end

ruby/red-arrow-format/lib/arrow-format/type.rb

@@ -63,4 +63,21 @@ def build_array(size, validity_buffer, values_buffer)
       UInt8Array.new(self, size, validity_buffer, values_buffer)
     end
   end
+
+  class BinaryType < Type
+    class << self
+      def singleton
+        @singleton ||= new
+      end
+    end
+
+    attr_reader :name
+    def initialize
+      super("Binary")
+    end
+
+    def build_array(size, validity_buffer, offsets_buffer, values_buffer)
+      BinaryArray.new(self, size, validity_buffer, offsets_buffer, values_buffer)
+    end
+  end
 end

ruby/red-arrow-format/test/test-file-reader.rb

@@ -56,9 +56,20 @@ def build_array
       Arrow::UInt8Array.new([0, nil, 255])
     end
 
-    def test_uint8
+    def test_read
       assert_equal([{"value" => [0, nil, 255]}],
                    read)
     end
   end
+
+  sub_test_case("Binary") do
+    def build_array
+      Arrow::BinaryArray.new(["Hello".b, nil, "World".b])
+    end
+
+    def test_read
+      assert_equal([{"value" => ["Hello".b, nil, "World".b]}],
+                   read)
+    end
+  end
 end