red-arrow 7.0.0 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cee7217ce22a2c2d7a20bbe073ffe41efbab3d9628cfdc0e19e077acb4965557
-  data.tar.gz: da14c7fd57bf63294fbe46f74bb286b0d6e26dafaa80b977d11639c275dbd677
+  metadata.gz: f43d3875f2e48876cd47533124a9fcf9559e263e63e3954c65fedd36b4e59744
+  data.tar.gz: 2548f661536d3288f4ad8bb25d6587a78ee51d810a85a7d533ccdaf595439a12
 SHA512:
-  metadata.gz: 52e22fdcc86f32f0443a6335099ce510840dfae9134bb4ffe6d51bfcbfdc2d66f87bbe29cd46a7af670077add2d12786474eaa3a716a27dc161fcd69b7c40974
-  data.tar.gz: 23b84e6766953cc89e8502043065dfdcf0c6a83ef1f29feae2a85e6ec3f7e01f0800f975eeb38076b255688a818984b9ae5eca2da483b96e42c5dd132089355a
+  metadata.gz: caeffbc164f14db7b056263f1ecd449afe2feec3ccbf7b883c147d415199c9ddc6c20398b00c34884248c103fbb7c55aa225719d8b8e75ac7f49337ee89d557e
+  data.tar.gz: ae5a793e06b63bd80e3499f794193f47f72ff7510a558d2d0e61314068d5bd3a1986e5083bda749b00b73a4615901beb320521eeb360576b93fcb9a1e9d9510a

data/ext/arrow/arrow.cpp

@@ -36,6 +36,13 @@ namespace red_arrow {
   ID id_jd;
   ID id_new;
   ID id_to_datetime;
+
+  namespace symbols {
+    VALUE day;
+    VALUE millisecond;
+    VALUE month;
+    VALUE nanosecond;
+  }
 }
 
 extern "C" void Init_arrow() {
@@ -81,4 +88,9 @@ extern "C" void Init_arrow() {
   red_arrow::id_to_datetime = rb_intern("to_datetime");
 
   red_arrow::memory_view::init(mArrow);
+
+  red_arrow::symbols::day = ID2SYM(rb_intern("day"));
+  red_arrow::symbols::millisecond = ID2SYM(rb_intern("millisecond"));
+  red_arrow::symbols::month = ID2SYM(rb_intern("month"));
+  red_arrow::symbols::nanosecond = ID2SYM(rb_intern("nanosecond"));
 }

data/ext/arrow/converters.hpp

@@ -202,6 +202,40 @@ namespace red_arrow {
     //                      const int64_t i) {
     // };
 
+    inline VALUE convert(const arrow::MonthIntervalArray& array,
+                         const int64_t i) {
+      return INT2NUM(array.Value(i));
+    }
+
+    inline VALUE convert(const arrow::DayTimeIntervalArray& array,
+                         const int64_t i) {
+      auto value = rb_hash_new();
+      auto arrow_value = array.Value(i);
+      rb_hash_aset(value,
+                   red_arrow::symbols::day,
+                   INT2NUM(arrow_value.days));
+      rb_hash_aset(value,
+                   red_arrow::symbols::millisecond,
+                   INT2NUM(arrow_value.milliseconds));
+      return value;
+    }
+
+    inline VALUE convert(const arrow::MonthDayNanoIntervalArray& array,
+                         const int64_t i) {
+      auto value = rb_hash_new();
+      auto arrow_value = array.Value(i);
+      rb_hash_aset(value,
+                   red_arrow::symbols::month,
+                   INT2NUM(arrow_value.months));
+      rb_hash_aset(value,
+                   red_arrow::symbols::day,
+                   INT2NUM(arrow_value.days));
+      rb_hash_aset(value,
+                   red_arrow::symbols::nanosecond,
+                   INT2NUM(arrow_value.nanoseconds));
+      return value;
+    }
+
     VALUE convert(const arrow::ListArray& array,
                   const int64_t i);
 
@@ -298,8 +332,9 @@ namespace red_arrow {
     VISIT(Time32)
     VISIT(Time64)
     VISIT(Timestamp)
-    // TODO
-    // VISIT(Interval)
+    VISIT(MonthInterval)
+    VISIT(DayTimeInterval)
+    VISIT(MonthDayNanoInterval)
     VISIT(List)
     VISIT(Struct)
     VISIT(Map)
@@ -404,8 +439,9 @@ namespace red_arrow {
     VISIT(Time32)
     VISIT(Time64)
     VISIT(Timestamp)
-    // TODO
-    // VISIT(Interval)
+    VISIT(MonthInterval)
+    VISIT(DayTimeInterval)
+    VISIT(MonthDayNanoInterval)
     VISIT(List)
     VISIT(Struct)
     VISIT(Map)
@@ -506,8 +542,9 @@ namespace red_arrow {
     VISIT(Time32)
     VISIT(Time64)
     VISIT(Timestamp)
-    // TODO
-    // VISIT(Interval)
+    VISIT(MonthInterval)
+    VISIT(DayTimeInterval)
+    VISIT(MonthDayNanoInterval)
     VISIT(List)
     VISIT(Struct)
     VISIT(Map)
@@ -609,8 +646,9 @@ namespace red_arrow {
     VISIT(Time32)
     VISIT(Time64)
     VISIT(Timestamp)
-    // TODO
-    // VISIT(Interval)
+    VISIT(MonthInterval)
+    VISIT(DayTimeInterval)
+    VISIT(MonthDayNanoInterval)
     VISIT(List)
     VISIT(Struct)
     VISIT(Map)
@@ -735,8 +773,6 @@ namespace red_arrow {
     VISIT(Time32)
     VISIT(Time64)
     VISIT(Timestamp)
-    // TODO
-    // VISIT(Interval)
     VISIT(List)
     VISIT(Struct)
     VISIT(Map)

data/ext/arrow/raw-records.cpp

@@ -96,8 +96,9 @@ namespace red_arrow {
       VISIT(Time32)
       VISIT(Time64)
       VISIT(Timestamp)
-      // TODO
-      // VISIT(Interval)
+      VISIT(MonthInterval)
+      VISIT(DayTimeInterval)
+      VISIT(MonthDayNanoInterval)
       VISIT(List)
       VISIT(Struct)
       VISIT(Map)

data/ext/arrow/red-arrow.hpp

@@ -47,6 +47,13 @@ namespace red_arrow {
   extern ID id_new;
   extern ID id_to_datetime;
 
+  namespace symbols {
+    extern VALUE day;
+    extern VALUE millisecond;
+    extern VALUE month;
+    extern VALUE nanosecond;
+  }
+
   VALUE array_values(VALUE obj);
   VALUE chunked_array_values(VALUE obj);
 

data/ext/arrow/values.cpp

@@ -77,8 +77,9 @@ namespace red_arrow {
       VISIT(Time32)
       VISIT(Time64)
       VISIT(Timestamp)
-      // TODO
-      // VISIT(Interval)
+      VISIT(MonthInterval)
+      VISIT(DayTimeInterval)
+      VISIT(MonthDayNanoInterval)
       VISIT(List)
       VISIT(Struct)
       VISIT(Map)

data/lib/arrow/day-time-interval-array-builder.rb

@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Arrow
+  class DayTimeIntervalArrayBuilder
+    private
+    def convert_to_arrow_value(value)
+      if value.is_a?(Hash)
+        Arrow::DayMillisecond.new(value[:day], value[:millisecond])
+      else
+        value
+      end
+    end
+  end
+end

data/lib/arrow/loader.rb

@@ -59,6 +59,7 @@ module Arrow
       require "arrow/date64-array"
       require "arrow/date64-array-builder"
       require "arrow/datum"
+      require "arrow/day-time-interval-array-builder"
       require "arrow/decimal128"
       require "arrow/decimal128-array"
       require "arrow/decimal128-array-builder"
@@ -84,6 +85,7 @@ module Arrow
       require "arrow/map-array"
       require "arrow/map-array-builder"
       require "arrow/map-data-type"
+      require "arrow/month-day-nano-interval-array-builder"
       require "arrow/null-array"
       require "arrow/null-array-builder"
       require "arrow/path-extension"

data/lib/arrow/month-day-nano-interval-array-builder.rb

@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Arrow
+  class MonthDayNanoIntervalArrayBuilder
+    private
+    def convert_to_arrow_value(value)
+      if value.is_a?(Hash)
+        Arrow::MonthDayNano.new(value[:month], value[:day], value[:nanosecond])
+      else
+        value
+      end
+    end
+  end
+end

data/lib/arrow/version.rb

@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "7.0.0"
+  VERSION = "8.0.0"
 
   module Version
     numbers, TAG = VERSION.split("-")

data/test/raw-records/test-basic-arrays.rb

@@ -346,6 +346,36 @@ module RawRecordsBasicArraysTests
                    records)
     assert_equal(records, target.raw_records)
   end
+
+  def test_month_interval
+    records = [
+      [1],
+      [nil],
+      [12],
+    ]
+    target = build({column: :month_interval}, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{day: 1, millisecond: 100}],
+      [nil],
+      [{day: 2, millisecond: 300}],
+    ]
+    target = build({column: :day_time_interval}, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{month: 1, day: 1, nanosecond: 100}],
+      [nil],
+      [{month: 2, day: 3, nanosecond: 400}],
+    ]
+    target = build({column: :month_day_nano_interval}, records)
+    assert_equal(records, target.raw_records)
+  end
 end
 
 class RawRecordsRecordBatchBasicArraysTest < Test::Unit::TestCase

data/test/raw-records/test-dense-union-array.rb

@@ -359,6 +359,33 @@ module RawRecordsDenseUnionArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_month_interval
+    records = [
+      [{"0" => 1}],
+      [{"1" => nil}],
+    ]
+    target = build(:month_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{"0" => {day: 1, millisecond: 100}}],
+      [{"1" => nil}],
+    ]
+    target = build(:day_time_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{"0" => {month: 1, day: 1, nanosecond: 100}}],
+      [{"1" => nil}],
+    ]
+    target = build(:month_day_nano_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [{"0" => [true, nil, false]}],

data/test/raw-records/test-list-array.rb

@@ -399,6 +399,45 @@ module RawRecordsListArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_month_interval
+    records = [
+      [[1, nil, 12]],
+      [nil],
+    ]
+    target = build(:month_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [
+        [
+          {day: 1, millisecond: 100},
+          nil,
+          {day: 2, millisecond: 300},
+        ]
+      ],
+      [nil],
+    ]
+    target = build(:day_time_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [
+        [
+          {month: 1, day: 1, nanosecond: 100},
+          nil,
+          {month: 2, day: 3, nanosecond: 400},
+        ]
+      ],
+      [nil],
+    ]
+    target = build(:month_day_nano_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [

data/test/raw-records/test-map-array.rb

@@ -310,6 +310,43 @@ module RawRecordsMapArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_month_interval
+    records = [
+      [{"key1" => 1, "key2" => nil}],
+      [nil],
+    ]
+    target = build(:month_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [
+        {
+          "key1" => {day: 1, millisecond: 100},
+          "key2" => nil,
+        },
+      ],
+      [nil],
+    ]
+    target = build(:day_time_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [
+        {
+          "key1" => {month: 1, day: 1, nanosecond: 100},
+          "key2" => nil,
+        },
+      ],
+      [nil],
+    ]
+    target = build(:month_day_nano_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [{"key1" => [true, nil, false], "key2" => nil}],

data/test/raw-records/test-sparse-union-array.rb

@@ -349,6 +349,33 @@ module RawRecordsSparseUnionArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_month_interval
+    records = [
+      [{"0" => 1}],
+      [{"1" => nil}],
+    ]
+    target = build(:month_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{"0" => {day: 1, millisecond: 100}}],
+      [{"1" => nil}],
+    ]
+    target = build(:day_time_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{"0" => {month: 1, day: 1, nanosecond: 100}}],
+      [{"1" => nil}],
+    ]
+    target = build(:month_day_nano_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [{"0" => [true, nil, false]}],

data/test/raw-records/test-struct-array.rb

@@ -344,6 +344,36 @@ module RawRecordsStructArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_month_interval
+    records = [
+      [{"field" => 1}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    target = build(:month_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{"field" => {day: 1, millisecond: 100}}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    target = build(:day_time_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{"field" => {month: 1, day: 1, nanosecond: 100}}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    target = build(:month_day_nano_interval, records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [{"field" => [true, nil, false]}],

data/test/test-table.rb

@@ -186,7 +186,12 @@ class TableTest < Test::Unit::TestCase
     end
 
     test("{key: Range}: beginless include end") do
-      assert_equal(<<-TABLE, @table.slice(count: ..8).to_s)
+      begin
+        range = eval("..8")
+      rescue SyntaxError
+        omit("beginless range isn't supported")
+      end
+      assert_equal(<<-TABLE, @table.slice(count: range).to_s)
 	count	visible
 0	    1	true   
 1	    2	false  
@@ -196,7 +201,12 @@ class TableTest < Test::Unit::TestCase
     end
 
     test("{key: Range}: beginless exclude end") do
-      assert_equal(<<-TABLE, @table.slice(count: ...8).to_s)
+      begin
+        range = eval("...8")
+      rescue SyntaxError
+        omit("beginless range isn't supported")
+      end
+      assert_equal(<<-TABLE, @table.slice(count: range).to_s)
 	count	visible
 0	    1	true   
 1	    2	false  
@@ -205,7 +215,12 @@ class TableTest < Test::Unit::TestCase
     end
 
     test("{key: Range}: endless") do
-      assert_equal(<<-TABLE, @table.slice(count: 16..).to_s)
+      begin
+        range = eval("16..")
+      rescue SyntaxError
+        omit("endless range isn't supported")
+      end
+      assert_equal(<<-TABLE, @table.slice(count: range).to_s)
 	count	visible
 0	   16	true   
 1	   32	false  

data/test/values/test-basic-arrays.rb

@@ -276,6 +276,36 @@ module ValuesBasicArraysTests
     target = build(Arrow::Decimal256Array.new(data_type, values))
     assert_equal(values, target.values)
   end
+
+  def test_month_interval
+    values = [
+      1,
+      nil,
+      12,
+    ]
+    target = build(Arrow::MonthIntervalArray.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_day_time_interval
+    values = [
+      {day: 1, millisecond: 100},
+      nil,
+      {day: 2, millisecond: 300},
+    ]
+    target = build(Arrow::DayTimeIntervalArray.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_month_day_nano_interval
+    values = [
+      {month: 1, day: 1, nanosecond: 100},
+      nil,
+      {month: 2, day: 3, nanosecond: 400},
+    ]
+    target = build(Arrow::MonthDayNanoIntervalArray.new(values))
+    assert_equal(values, target.values)
+  end
 end
 
 class ValuesArrayBasicArraysTest < Test::Unit::TestCase

data/test/values/test-dense-union-array.rb

@@ -347,6 +347,33 @@ module ValuesDenseUnionArrayTests
     assert_equal(values, target.values)
   end
 
+  def test_month_interval
+    values = [
+      {"0" => 1},
+      {"1" => nil},
+    ]
+    target = build(:month_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_day_time_interval
+    values = [
+      {"0" => {day: 1, millisecond: 100}},
+      {"1" => nil},
+    ]
+    target = build(:day_time_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_month_day_nano_interval
+    values = [
+      {"0" => {month: 1, day: 1, nanosecond: 100}},
+      {"1" => nil},
+    ]
+    target = build(:month_day_nano_interval, values)
+    assert_equal(values, target.values)
+  end
+
   def test_list
     values = [
       {"0" => [true, nil, false]},

data/test/values/test-dictionary-array.rb

@@ -0,0 +1,295 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module ValuesDictionaryArrayTests
+  def test_null
+    target = build(Arrow::NullArray.new(4))
+    assert_equal([nil] * 4, target.values)
+  end
+
+  def test_boolean
+    values = [true, nil, false]
+    target = build(Arrow::BooleanArray.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_int8
+    values = [
+      -(2 ** 7),
+      nil,
+      (2 ** 7) - 1,
+    ]
+    target = build(Arrow::Int8Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_uint8
+    values = [
+      0,
+      nil,
+      (2 ** 8) - 1,
+    ]
+    target = build(Arrow::UInt8Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_int16
+    values = [
+      -(2 ** 15),
+      nil,
+      (2 ** 15) - 1,
+    ]
+    target = build(Arrow::Int16Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_uint16
+    values = [
+      0,
+      nil,
+      (2 ** 16) - 1,
+    ]
+    target = build(Arrow::UInt16Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_int32
+    values = [
+      -(2 ** 31),
+      nil,
+      (2 ** 31) - 1,
+    ]
+    target = build(Arrow::Int32Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_uint32
+    values = [
+      0,
+      nil,
+      (2 ** 32) - 1,
+    ]
+    target = build(Arrow::UInt32Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_int64
+    values = [
+      -(2 ** 63),
+      nil,
+      (2 ** 63) - 1,
+    ]
+    target = build(Arrow::Int64Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_uint64
+    values = [
+      0,
+      nil,
+      (2 ** 64) - 1,
+    ]
+    target = build(Arrow::UInt64Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_float
+    values = [
+      -1.0,
+      nil,
+      1.0,
+    ]
+    target = build(Arrow::FloatArray.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_double
+    values = [
+      -1.0,
+      nil,
+      1.0,
+    ]
+    target = build(Arrow::DoubleArray.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_binary
+    values = [
+      "\x00".b,
+      nil,
+      "\xff".b,
+    ]
+    target = build(Arrow::BinaryArray.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_string
+    values = [
+      "Ruby",
+      nil,
+      "\u3042", # U+3042 HIRAGANA LETTER A
+    ]
+    target = build(Arrow::StringArray.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_date32
+    values = [
+      Date.new(1960, 1, 1),
+      nil,
+      Date.new(2017, 8, 23),
+    ]
+    target = build(Arrow::Date32Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_date64
+    values = [
+      DateTime.new(1960, 1, 1, 2, 9, 30),
+      nil,
+      DateTime.new(2017, 8, 23, 14, 57, 2),
+    ]
+    target = build(Arrow::Date64Array.new(values))
+    assert_equal(values, target.values)
+  end
+
+  def test_timestamp_second
+    values = [
+      Time.parse("1960-01-01T02:09:30Z"),
+      nil,
+      Time.parse("2017-08-23T14:57:02Z"),
+    ]
+    target = build(Arrow::TimestampArray.new(:second, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_timestamp_milli
+    values = [
+      Time.parse("1960-01-01T02:09:30.123Z"),
+      nil,
+      Time.parse("2017-08-23T14:57:02.987Z"),
+    ]
+    target = build(Arrow::TimestampArray.new(:milli, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_timestamp_micro
+    values = [
+      Time.parse("1960-01-01T02:09:30.123456Z"),
+      nil,
+      Time.parse("2017-08-23T14:57:02.987654Z"),
+    ]
+    target = build(Arrow::TimestampArray.new(:micro, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_timestamp_nano
+    values = [
+      Time.parse("1960-01-01T02:09:30.123456789Z"),
+      nil,
+      Time.parse("2017-08-23T14:57:02.987654321Z"),
+    ]
+    target = build(Arrow::TimestampArray.new(:nano, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    values = [
+      Arrow::Time.new(unit, 60 * 10), # 00:10:00
+      nil,
+      Arrow::Time.new(unit, 60 * 60 * 2 + 9), # 02:00:09
+    ]
+    target = build(Arrow::Time32Array.new(unit, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    values = [
+      Arrow::Time.new(unit, (60 * 10) * 1000 + 123), # 00:10:00.123
+      nil,
+      Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987), # 02:00:09.987
+    ]
+    target = build(Arrow::Time32Array.new(unit, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    values = [
+      # 00:10:00.123456
+      Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456),
+      nil,
+      # 02:00:09.987654
+      Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654),
+    ]
+    target = build(Arrow::Time64Array.new(unit, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    values = [
+      # 00:10:00.123456789
+      Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789),
+      nil,
+      # 02:00:09.987654321
+      Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321),
+    ]
+    target = build(Arrow::Time64Array.new(unit, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_decimal128
+    values = [
+      BigDecimal("92.92"),
+      nil,
+      BigDecimal("29.29"),
+    ]
+    data_type = Arrow::Decimal128DataType.new(8, 2)
+    target = build(Arrow::Decimal128Array.new(data_type, values))
+    assert_equal(values, target.values)
+  end
+
+  def test_decimal256
+    values = [
+      BigDecimal("92.92"),
+      nil,
+      BigDecimal("29.29"),
+    ]
+    data_type = Arrow::Decimal256DataType.new(38, 2)
+    target = build(Arrow::Decimal256Array.new(data_type, values))
+    assert_equal(values, target.values)
+  end
+end
+
+class ValuesArrayDictionaryArrayTest < Test::Unit::TestCase
+  include ValuesDictionaryArrayTests
+
+  def build(values)
+    values.dictionary_encode
+  end
+end
+
+class ValuesChunkedArrayDictionaryArrayTest < Test::Unit::TestCase
+  include ValuesDictionaryArrayTests
+
+  def build(values)
+    Arrow::ChunkedArray.new([values.dictionary_encode])
+  end
+end

data/test/values/test-list-array.rb

@@ -372,6 +372,45 @@ module ValuesListArrayTests
     assert_equal(values, target.values)
   end
 
+  def test_month_interval
+    values = [
+      [
+        1,
+        nil,
+        12,
+      ],
+      nil,
+    ]
+    target = build(:month_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_day_time_interval
+    values = [
+      [
+        {day: 1, millisecond: 100},
+        nil,
+        {day: 2, millisecond: 300},
+      ],
+      nil,
+    ]
+    target = build(:day_time_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_month_day_nano_interval
+    values = [
+      [
+        {month: 1, day: 1, nanosecond: 100},
+        nil,
+        {month: 2, day: 3, nanosecond: 400},
+      ],
+      nil,
+    ]
+    target = build(:month_day_nano_interval, values)
+    assert_equal(values, target.values)
+  end
+
   def test_list
     values = [
       [

data/test/values/test-map-array.rb

@@ -302,6 +302,39 @@ module ValuesMapArrayTests
     assert_equal(values, target.values)
   end
 
+  def test_month_interval
+    values = [
+      {"key1" => 1, "key2" => nil},
+      nil,
+    ]
+    target = build(:month_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_day_time_interval
+    values = [
+      {
+        "key1" => {day: 1, millisecond: 100},
+        "key2" => nil,
+      },
+      nil,
+    ]
+    target = build(:day_time_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_month_day_nano_interval
+    values = [
+      {
+        "key1" => {month: 1, day: 1, nanosecond: 100},
+        "key2" => nil,
+      },
+      nil,
+    ]
+    target = build(:month_day_nano_interval, values)
+    assert_equal(values, target.values)
+  end
+
   def test_list
     values = [
       {"key1" => [true, nil, false], "key2" => nil},

data/test/values/test-sparse-union-array.rb

@@ -324,6 +324,33 @@ module ValuesSparseUnionArrayTests
     assert_equal(values, target.values)
   end
 
+  def test_month_interval
+    values = [
+      {"0" => 1},
+      {"1" => nil},
+    ]
+    target = build(:month_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_day_time_interval
+    values = [
+      {"0" => {day: 1, millisecond: 100}},
+      {"1" => nil},
+    ]
+    target = build(:day_time_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_month_day_nano_interval
+    values = [
+      {"0" => {month: 1, day: 1, nanosecond: 100}},
+      {"1" => nil},
+    ]
+    target = build(:month_day_nano_interval, values)
+    assert_equal(values, target.values)
+  end
+
   def test_decimal256
     values = [
       {"0" => BigDecimal("92.92")},

data/test/values/test-struct-array.rb

@@ -341,6 +341,36 @@ module ValuesStructArrayTests
     assert_equal(values, target.values)
   end
 
+  def test_month_interval
+    values = [
+      {"field" => 1},
+      nil,
+      {"field" => nil},
+    ]
+    target = build(:month_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_day_time_interval
+    values = [
+      {"field" => {day: 1, millisecond: 100}},
+      nil,
+      {"field" => nil},
+    ]
+    target = build(:day_time_interval, values)
+    assert_equal(values, target.values)
+  end
+
+  def test_month_day_nano_interval
+    values = [
+      {"field" => {month: 1, day: 1, nanosecond: 100}},
+      nil,
+      {"field" => nil},
+    ]
+    target = build(:month_day_nano_interval, values)
+    assert_equal(values, target.values)
+  end
+
   def test_list
     values = [
       {"field" => [true, nil, false]},

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 8.0.0
 platform: ruby
 authors:
 - Apache Arrow Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-05 00:00:00.000000000 Z
+date: 2022-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -127,6 +127,7 @@ files:
 - lib/arrow/date64-array-builder.rb
 - lib/arrow/date64-array.rb
 - lib/arrow/datum.rb
+- lib/arrow/day-time-interval-array-builder.rb
 - lib/arrow/decimal128-array-builder.rb
 - lib/arrow/decimal128-array.rb
 - lib/arrow/decimal128-data-type.rb
@@ -156,6 +157,7 @@ files:
 - lib/arrow/map-array-builder.rb
 - lib/arrow/map-array.rb
 - lib/arrow/map-data-type.rb
+- lib/arrow/month-day-nano-interval-array-builder.rb
 - lib/arrow/null-array-builder.rb
 - lib/arrow/null-array.rb
 - lib/arrow/path-extension.rb
@@ -292,6 +294,7 @@ files:
 - test/test-timestamp-data-type.rb
 - test/values/test-basic-arrays.rb
 - test/values/test-dense-union-array.rb
+- test/values/test-dictionary-array.rb
 - test/values/test-list-array.rb
 - test/values/test-map-array.rb
 - test/values/test-sparse-union-array.rb
@@ -300,7 +303,7 @@ homepage: https://arrow.apache.org/
 licenses:
 - Apache-2.0
 metadata:
-  msys2_mingw_dependencies: arrow>=7.0.0
+  msys2_mingw_dependencies: arrow>=8.0.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -410,6 +413,7 @@ test_files:
 - test/test-timestamp-data-type.rb
 - test/values/test-basic-arrays.rb
 - test/values/test-dense-union-array.rb
+- test/values/test-dictionary-array.rb
 - test/values/test-list-array.rb
 - test/values/test-map-array.rb
 - test/values/test-sparse-union-array.rb