red-arrow 0.17.1 → 4.0.0

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

@@ -379,6 +379,26 @@ module RawRecordsListArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_decimal256
+    records = [
+      [
+        [
+          BigDecimal("92.92"),
+          nil,
+          BigDecimal("29.29"),
+        ],
+      ],
+      [nil],
+    ]
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [

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

@@ -51,9 +51,7 @@ module RawRecordsSparseUnionArrayTests
     end
     records.each do |record|
       column = record[0]
-      if column.nil?
-        type_ids << nil
-      elsif column.key?("0")
+      if column.key?("0")
         type_ids << type_codes[0]
       elsif column.key?("1")
         type_ids << type_codes[1]
@@ -71,7 +69,6 @@ module RawRecordsSparseUnionArrayTests
   def test_null
     records = [
       [{"0" => nil}],
-      [nil],
     ]
     target = build(:null, records)
     assert_equal(records, target.raw_records)
@@ -80,7 +77,6 @@ module RawRecordsSparseUnionArrayTests
   def test_boolean
     records = [
       [{"0" => true}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:boolean, records)
@@ -90,7 +86,6 @@ module RawRecordsSparseUnionArrayTests
   def test_int8
     records = [
       [{"0" => -(2 ** 7)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:int8, records)
@@ -100,7 +95,6 @@ module RawRecordsSparseUnionArrayTests
   def test_uint8
     records = [
       [{"0" => (2 ** 8) - 1}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:uint8, records)
@@ -110,7 +104,6 @@ module RawRecordsSparseUnionArrayTests
   def test_int16
     records = [
       [{"0" => -(2 ** 15)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:int16, records)
@@ -120,7 +113,6 @@ module RawRecordsSparseUnionArrayTests
   def test_uint16
     records = [
       [{"0" => (2 ** 16) - 1}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:uint16, records)
@@ -130,7 +122,6 @@ module RawRecordsSparseUnionArrayTests
   def test_int32
     records = [
       [{"0" => -(2 ** 31)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:int32, records)
@@ -140,7 +131,6 @@ module RawRecordsSparseUnionArrayTests
   def test_uint32
     records = [
       [{"0" => (2 ** 32) - 1}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:uint32, records)
@@ -150,7 +140,6 @@ module RawRecordsSparseUnionArrayTests
   def test_int64
     records = [
       [{"0" => -(2 ** 63)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:int64, records)
@@ -160,7 +149,6 @@ module RawRecordsSparseUnionArrayTests
   def test_uint64
     records = [
       [{"0" => (2 ** 64) - 1}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:uint64, records)
@@ -170,7 +158,6 @@ module RawRecordsSparseUnionArrayTests
   def test_float
     records = [
       [{"0" => -1.0}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:float, records)
@@ -180,7 +167,6 @@ module RawRecordsSparseUnionArrayTests
   def test_double
     records = [
       [{"0" => -1.0}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:double, records)
@@ -190,7 +176,6 @@ module RawRecordsSparseUnionArrayTests
   def test_binary
     records = [
       [{"0" => "\xff".b}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:binary, records)
@@ -200,7 +185,6 @@ module RawRecordsSparseUnionArrayTests
   def test_string
     records = [
       [{"0" => "Ruby"}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:string, records)
@@ -210,7 +194,6 @@ module RawRecordsSparseUnionArrayTests
   def test_date32
     records = [
       [{"0" => Date.new(1960, 1, 1)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:date32, records)
@@ -220,7 +203,6 @@ module RawRecordsSparseUnionArrayTests
   def test_date64
     records = [
       [{"0" => DateTime.new(1960, 1, 1, 2, 9, 30)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build(:date64, records)
@@ -230,7 +212,6 @@ module RawRecordsSparseUnionArrayTests
   def test_timestamp_second
     records = [
       [{"0" => Time.parse("1960-01-01T02:09:30Z")}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -244,7 +225,6 @@ module RawRecordsSparseUnionArrayTests
   def test_timestamp_milli
     records = [
       [{"0" => Time.parse("1960-01-01T02:09:30.123Z")}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -258,7 +238,6 @@ module RawRecordsSparseUnionArrayTests
   def test_timestamp_micro
     records = [
       [{"0" => Time.parse("1960-01-01T02:09:30.123456Z")}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -272,7 +251,6 @@ module RawRecordsSparseUnionArrayTests
   def test_timestamp_nano
     records = [
       [{"0" => Time.parse("1960-01-01T02:09:30.123456789Z")}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -288,7 +266,6 @@ module RawRecordsSparseUnionArrayTests
     records = [
       # 00:10:00
       [{"0" => Arrow::Time.new(unit, 60 * 10)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -304,7 +281,6 @@ module RawRecordsSparseUnionArrayTests
     records = [
       # 00:10:00.123
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -320,7 +296,6 @@ module RawRecordsSparseUnionArrayTests
     records = [
       # 00:10:00.123456
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -336,7 +311,6 @@ module RawRecordsSparseUnionArrayTests
     records = [
       # 00:10:00.123456789
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -350,7 +324,6 @@ module RawRecordsSparseUnionArrayTests
   def test_decimal128
     records = [
       [{"0" => BigDecimal("92.92")}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -362,10 +335,23 @@ module RawRecordsSparseUnionArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_decimal256
+    records = [
+      [{"0" => BigDecimal("92.92")}],
+      [{"1" => nil}],
+    ]
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [{"0" => [true, nil, false]}],
-      [nil],
       [{"1" => nil}],
     ]
     target = build({
@@ -382,7 +368,6 @@ module RawRecordsSparseUnionArrayTests
   def test_struct
     records = [
       [{"0" => {"sub_field" => true}}],
-      [nil],
       [{"1" => nil}],
       [{"0" => {"sub_field" => nil}}],
     ]
@@ -403,7 +388,6 @@ module RawRecordsSparseUnionArrayTests
     omit("Need to add support for SparseUnionArrayBuilder")
     records = [
       [{"0" => {"field1" => true}}],
-      [nil],
       [{"1" => nil}],
       [{"0" => {"field2" => nil}}],
     ]
@@ -429,7 +413,6 @@ module RawRecordsSparseUnionArrayTests
     omit("Need to add support for DenseUnionArrayBuilder")
     records = [
       [{"0" => {"field1" => true}}],
-      [nil],
       [{"1" => nil}],
       [{"0" => {"field2" => nil}}],
     ]
@@ -455,7 +438,6 @@ module RawRecordsSparseUnionArrayTests
     omit("Need to add support for DictionaryArrayBuilder")
     records = [
       [{"0" => "Ruby"}],
-      [nil],
       [{"1" => nil}],
       [{"0" => "GLib"}],
     ]

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

@@ -329,6 +329,21 @@ module RawRecordsStructArrayTests
     assert_equal(records, target.raw_records)
   end
 
+  def test_decimal256
+    records = [
+      [{"field" => BigDecimal("92.92")}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    assert_equal(records, target.raw_records)
+  end
+
   def test_list
     records = [
       [{"field" => [true, nil, false]}],

data/test/test-array.rb

@@ -160,12 +160,132 @@ class ArrayTest < Test::Unit::TestCase
 
     test("Arrow::ChunkedArray") do
       chunks = [
-        Arrow::Int16Array.new([1, 0]),
-        Arrow::Int16Array.new([1, 0, 3])
+        Arrow::Int16Array.new([1, 4]),
+        Arrow::Int16Array.new([0, 3])
       ]
       right = Arrow::ChunkedArray.new(chunks)
       assert_equal(Arrow::BooleanArray.new([true, true, true, false]),
                    @array.is_in(right))
     end
   end
+
+  sub_test_case("#concatenate") do
+    test("Arrow::Array: same") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]).
+                     concatenate(Arrow::Int32Array.new([4, 5]),
+                                 Arrow::Int32Array.new([6])))
+    end
+
+    test("Arrow::Array: castable") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]).
+                     concatenate(Arrow::Int8Array.new([4, 5]),
+                                 Arrow::UInt32Array.new([6])))
+    end
+
+    test("Arrow::Array: non-castable") do
+      assert_raise(Arrow::Error::Invalid) do
+        Arrow::Int32Array.new([1, 2, nil]).
+          concatenate(Arrow::StringArray.new(["X"]))
+      end
+    end
+
+    test("Array") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,nil, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]).
+                     concatenate([4, nil],
+                                 [6]))
+    end
+
+    test("invalid") do
+      message = "[array][resolve] can't build int32 array: 4"
+      assert_raise(ArgumentError.new(message)) do
+        Arrow::Int32Array.new([1, 2, nil]).
+          concatenate(4)
+      end
+    end
+  end
+
+  sub_test_case("#+") do
+    test("Arrow::Array: same") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]) +
+                   Arrow::Int32Array.new([4, 5, 6]))
+    end
+
+    test("Arrow::Array: castable") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]) +
+                   Arrow::Int8Array.new([4, 5, 6]))
+    end
+
+    test("Arrow::Array: non-castable") do
+      assert_raise(Arrow::Error::Invalid) do
+        Arrow::Int32Array.new([1, 2, nil]) +
+          Arrow::StringArray.new(["X"])
+      end
+    end
+
+    test("Array") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,nil, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]) +
+                   [4, nil, 6])
+    end
+
+    test("invalid") do
+      message = "[array][resolve] can't build int32 array: 4"
+      assert_raise(ArgumentError.new(message)) do
+        Arrow::Int32Array.new([1, 2, nil]) + 4
+      end
+    end
+  end
+
+  sub_test_case("#resolve") do
+    test("Arrow::Array: same") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil]),
+                   Arrow::Int32Array.new([]).
+                     resolve(Arrow::Int32Array.new([1, 2, nil])))
+    end
+
+    test("Arrow::Array: castable") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil]),
+                   Arrow::Int32Array.new([]).
+                     resolve(Arrow::Int8Array.new([1, 2, nil])))
+    end
+
+    test("Arrow::Array: non-castable") do
+      assert_raise(Arrow::Error::Invalid) do
+        Arrow::Int32Array.new([]) +
+          Arrow::StringArray.new(["X"])
+      end
+    end
+
+    test("Array: non-parametric") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil]),
+                   Arrow::Int32Array.new([]).
+                     resolve([1, 2, nil]))
+    end
+
+    test("Array: parametric") do
+      list_data_type = Arrow::ListDataType.new(name: "visible", type: :boolean)
+      list_array = Arrow::ListArray.new(list_data_type, [])
+      assert_equal(Arrow::ListArray.new(list_data_type,
+                                        [
+                                          [true, false],
+                                          nil,
+                                        ]),
+                   list_array.resolve([
+                                        [true, false],
+                                        nil,
+                                      ]))
+    end
+
+    test("invalid") do
+      message = "[array][resolve] can't build int32 array: 4"
+      assert_raise(ArgumentError.new(message)) do
+        Arrow::Int32Array.new([]).resolve(4)
+      end
+    end
+  end
 end

data/test/test-bigdecimal.rb

@@ -16,8 +16,25 @@
 # under the License.
 
 class BigDecimalTest < Test::Unit::TestCase
-  test("#to_arrow") do
-    assert_equal(Arrow::Decimal128.new("3.14"),
-                 BigDecimal("3.14").to_arrow)
+  sub_test_case("#to_arrow") do
+    def test_128_positive
+      assert_equal(Arrow::Decimal128.new("0.1e38"),
+                   BigDecimal("0.1e38").to_arrow)
+    end
+
+    def test_128_negative
+      assert_equal(Arrow::Decimal128.new("-0.1e38"),
+                   BigDecimal("-0.1e38").to_arrow)
+    end
+
+    def test_256_positive
+      assert_equal(Arrow::Decimal256.new("0.1e39"),
+                   BigDecimal("0.1e39").to_arrow)
+    end
+
+    def test_256_negative
+      assert_equal(Arrow::Decimal256.new("-0.1e39"),
+                   BigDecimal("-0.1e39").to_arrow)
+    end
   end
 end