GH-48992: [Ruby] Add support for writing large UTF-8 array (#48993)

### Rationale for this change

It's a large variant of UTF-8 array.

### What changes are included in this PR?

* Add `ArrowFormat::LargeUTF8Type#to_flatbuffers`
* Add support for large UTF-8 array of `#values` and `#raw_records`

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* GitHub Issue: #48992

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

Author: kou

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

@@ -574,6 +574,10 @@ def build_array(size, validity_buffer, offsets_buffer, values_buffer)
                          offsets_buffer,
                          values_buffer)
     end
+
+    def to_flatbuffers
+      FB::LargeUtf8::Data.new
+    end
   end
 
   class FixedSizeBinaryType < Type

ruby/red-arrow-format/test/test-writer.rb

@@ -52,6 +52,8 @@ def convert_type(red_arrow_type)
       ArrowFormat::LargeBinaryType.singleton
     when Arrow::StringDataType
       ArrowFormat::UTF8Type.singleton
+    when Arrow::LargeStringDataType
+      ArrowFormat::LargeUTF8Type.singleton
     else
       raise "Unsupported type: #{red_arrow_type.inspect}"
     end
@@ -298,6 +300,17 @@ def test_write
                          @values)
           end
         end
+
+        sub_test_case("LargeString") do
+          def build_array
+            Arrow::LargeStringArray.new(["Hello", nil, "World"])
+          end
+
+          def test_write
+            assert_equal(["Hello", nil, "World"],
+                         @values)
+          end
+        end
       end
     end
   end

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

@@ -175,6 +175,14 @@ namespace red_arrow {
                              length);
     }
 
+    inline VALUE convert(const arrow::LargeStringArray& array,
+                         const int64_t i) {
+      int64_t length;
+      const auto value = array.GetValue(i, &length);
+      return rb_utf8_str_new(reinterpret_cast<const char*>(value),
+                             length);
+    }
+
     inline VALUE convert(const arrow::FixedSizeBinaryArray& array,
                          const int64_t i) {
       return rb_enc_str_new(reinterpret_cast<const char*>(array.Value(i)),

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

@@ -90,6 +90,7 @@ namespace red_arrow {
       VISIT(Binary)
       VISIT(LargeBinary)
       VISIT(String)
+      VISIT(LargeString)
       VISIT(FixedSizeBinary)
       VISIT(Date32)
       VISIT(Date64)
@@ -227,6 +228,7 @@ namespace red_arrow {
       VISIT(Binary)
       VISIT(LargeBinary)
       VISIT(String)
+      VISIT(LargeString)
       VISIT(FixedSizeBinary)
       VISIT(Date32)
       VISIT(Date64)

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

@@ -71,6 +71,7 @@ namespace red_arrow {
       VISIT(Binary)
       VISIT(LargeBinary)
       VISIT(String)
+      VISIT(LargeString)
       VISIT(FixedSizeBinary)
       VISIT(Date32)
       VISIT(Date64)

ruby/red-arrow/test/raw-records/test-basic-arrays.rb

@@ -177,6 +177,16 @@ def test_string
     assert_equal(records, actual_records(target))
   end
 
+  def test_large_string
+    records = [
+      ["Ruby"],
+      [nil],
+      ["\u3042"], # U+3042 HIRAGANA LETTER A
+    ]
+    target = build({column: :large_string}, records)
+    assert_equal(records, actual_records(target))
+  end
+
   def test_date32
     records = [
       [Date.new(1960, 1, 1)],

ruby/red-arrow/test/values/test-basic-arrays.rb

@@ -167,6 +167,16 @@ def test_string
     assert_equal(values, target.values)
   end
 
+  def test_large_string
+    values = [
+      "Ruby",
+      nil,
+      "\u3042", # U+3042 HIRAGANA LETTER A
+    ]
+    target = build(Arrow::LargeStringArray.new(values))
+    assert_equal(values, target.values)
+  end
+
   def test_date32
     values = [
       Date.new(1960, 1, 1),