red-arrow 0.14.1 → 0.15.0

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

@@ -52,7 +52,7 @@ module RawRecordsDenseUnionArrayTests
       end
       sub_record_batch = Arrow::RecordBatch.new(sub_schema,
                                                 sub_records)
-      sub_record_batch.columns[0]
+      sub_record_batch.columns[0].data
     end
     records.each do |record|
       column = record[0]
@@ -295,8 +295,10 @@ module RawRecordsDenseUnionArrayTests
   end
 
   def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
     records = [
-      [{"0" => 60 * 10}], # 00:10:00
+      # 00:10:00
+      [{"0" => Arrow::Time.new(unit, 60 * 10)}],
       [nil],
       [{"1" => nil}],
     ]
@@ -309,8 +311,10 @@ module RawRecordsDenseUnionArrayTests
   end
 
   def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
     records = [
-      [{"0" => (60 * 10) * 1000 + 123}], # 00:10:00.123
+      # 00:10:00.123
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
       [nil],
       [{"1" => nil}],
     ]
@@ -323,8 +327,10 @@ module RawRecordsDenseUnionArrayTests
   end
 
   def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
     records = [
-      [{"0" => (60 * 10) * 1_000_000 + 123_456}], # 00:10:00.123456
+      # 00:10:00.123456
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
       [nil],
       [{"1" => nil}],
     ]
@@ -337,9 +343,10 @@ module RawRecordsDenseUnionArrayTests
   end
 
   def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
     records = [
       # 00:10:00.123456789
-      [{"0" => (60 * 10) * 1_000_000_000 + 123_456_789}],
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
       [nil],
       [{"1" => nil}],
     ]

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

@@ -271,13 +271,16 @@ module RawRecordsListArrayTests
     assert_equal(records, target.raw_records)
   end
 
-  def test_time32_test
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
     records = [
       [
         [
-          60 * 10, # 00:10:00
+          # 00:10:00
+          Arrow::Time.new(unit, 60 * 10),
           nil,
-          60 * 60 * 2 + 9, # 02:00:09
+          # 02:00:09
+          Arrow::Time.new(unit, 60 * 60 * 2 + 9),
         ],
       ],
       [nil],
@@ -291,12 +294,15 @@ module RawRecordsListArrayTests
   end
 
   def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
     records = [
       [
         [
-          (60 * 10) * 1000 + 123, # 00:10:00.123
+          # 00:10:00.123
+          Arrow::Time.new(unit, (60 * 10) * 1000 + 123),
           nil,
-          (60 * 60 * 2 + 9) * 1000 + 987, # 02:00:09.987
+          # 02:00:09.987
+          Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987),
         ],
       ],
       [nil],
@@ -310,12 +316,15 @@ module RawRecordsListArrayTests
   end
 
   def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
     records = [
       [
         [
-          (60 * 10) * 1_000_000 + 123_456, # 00:10:00.123456
+          # 00:10:00.123456
+          Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456),
           nil,
-          (60 * 60 * 2 + 9) * 1_000_000 + 987_654, # 02:00:09.987654
+          # 02:00:09.987654
+          Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654),
         ],
       ],
       [nil],
@@ -329,12 +338,15 @@ module RawRecordsListArrayTests
   end
 
   def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
     records = [
       [
         [
-          (60 * 10) * 1_000_000_000 + 123_456_789, # 00:10:00.123456789
+          # 00:10:00.123456789
+          Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789),
           nil,
-          (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321, # 02:00:09.987654321
+          # 02:00:09.987654321
+          Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321),
         ],
       ],
       [nil],

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

@@ -47,7 +47,7 @@ module RawRecordsSparseUnionArrayTests
       end
       sub_record_batch = Arrow::RecordBatch.new(sub_schema,
                                                 sub_records)
-      sub_record_batch.columns[0]
+      sub_record_batch.columns[0].data
     end
     records.each do |record|
       column = record[0]
@@ -284,8 +284,10 @@ module RawRecordsSparseUnionArrayTests
   end
 
   def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
     records = [
-      [{"0" => 60 * 10}], # 00:10:00
+      # 00:10:00
+      [{"0" => Arrow::Time.new(unit, 60 * 10)}],
       [nil],
       [{"1" => nil}],
     ]
@@ -298,8 +300,10 @@ module RawRecordsSparseUnionArrayTests
   end
 
   def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
     records = [
-      [{"0" => (60 * 10) * 1000 + 123}], # 00:10:00.123
+      # 00:10:00.123
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
       [nil],
       [{"1" => nil}],
     ]
@@ -312,8 +316,10 @@ module RawRecordsSparseUnionArrayTests
   end
 
   def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
     records = [
-      [{"0" => (60 * 10) * 1_000_000 + 123_456}], # 00:10:00.123456
+      # 00:10:00.123456
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
       [nil],
       [{"1" => nil}],
     ]
@@ -326,8 +332,10 @@ module RawRecordsSparseUnionArrayTests
   end
 
   def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
     records = [
-      [{"0" => (60 * 10) * 1_000_000_000 + 123_456_789}], # 00:10:00.123456789
+      # 00:10:00.123456789
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
       [nil],
       [{"1" => nil}],
     ]

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

@@ -251,8 +251,10 @@ module RawRecordsStructArrayTests
   end
 
   def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
     records = [
-      [{"field" => 60 * 10}], # 00:10:00
+      # 00:10:00
+      [{"field" => Arrow::Time.new(unit, 60 * 10)}],
       [nil],
       [{"field" => nil}],
     ]
@@ -265,8 +267,10 @@ module RawRecordsStructArrayTests
   end
 
   def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
     records = [
-      [{"field" => (60 * 10) * 1000 + 123}], # 00:10:00.123
+      # 00:10:00.123
+      [{"field" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
       [nil],
       [{"field" => nil}],
     ]
@@ -279,8 +283,10 @@ module RawRecordsStructArrayTests
   end
 
   def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
     records = [
-      [{"field" => (60 * 10) * 1_000_000 + 123_456}], # 00:10:00.123456
+      # 00:10:00.123456
+      [{"field" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
       [nil],
       [{"field" => nil}],
     ]
@@ -293,9 +299,10 @@ module RawRecordsStructArrayTests
   end
 
   def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
     records = [
       # 00:10:00.123456789
-      [{"field" => (60 * 10) * 1_000_000_000 + 123_456_789}],
+      [{"field" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
       [nil],
       [{"field" => nil}],
     ]

data/test/test-column.rb

@@ -16,51 +16,76 @@
 # under the License.
 
 class ColumnTest < Test::Unit::TestCase
+  def setup
+    table = Arrow::Table.new("visible" => [true, nil, false])
+    @column = table.visible
+  end
+
+  test("#name") do
+    assert_equal("visible", @column.name)
+  end
+
+  test("#data_type") do
+    assert_equal(Arrow::BooleanDataType.new, @column.data_type)
+  end
+
+  test("#null?") do
+    assert do
+      @column.null?(1)
+    end
+  end
+
+  test("#valid?") do
+    assert do
+      @column.valid?(0)
+    end
+  end
+
   test("#each") do
-    arrays = [
-      Arrow::BooleanArray.new([true, false]),
-      Arrow::BooleanArray.new([nil, true]),
-    ]
-    chunked_array = Arrow::ChunkedArray.new(arrays)
-    column = Arrow::Column.new(Arrow::Field.new("visible", :boolean),
-                               chunked_array)
-    assert_equal([true, false, nil, true],
-                 column.to_a)
+    assert_equal([true, nil, false], @column.each.to_a)
+  end
+
+  test("#reverse_each") do
+    assert_equal([false, nil, true], @column.reverse_each.to_a)
   end
 
-  test("#pack") do
-    arrays = [
-      Arrow::BooleanArray.new([true, false]),
-      Arrow::BooleanArray.new([nil, true]),
-    ]
-    chunked_array = Arrow::ChunkedArray.new(arrays)
-    column = Arrow::Column.new(Arrow::Field.new("visible", :boolean),
-                               chunked_array)
-    packed_column = column.pack
-    assert_equal([1, [true, false, nil, true]],
-                 [packed_column.data.n_chunks, packed_column.to_a])
+  test("#n_rows") do
+    assert_equal(3, @column.n_rows)
+  end
+
+  test("#n_nulls") do
+    assert_equal(1, @column.n_nulls)
   end
 
   sub_test_case("#==") do
-    def setup
-      arrays = [
-        Arrow::BooleanArray.new([true]),
-        Arrow::BooleanArray.new([false, true]),
-      ]
-      chunked_array = Arrow::ChunkedArray.new(arrays)
-      @column = Arrow::Column.new(Arrow::Field.new("visible", :boolean),
-                                  chunked_array)
+    test("same value") do
+      table1 = Arrow::Table.new("visible" => [true, false])
+      table2 = Arrow::Table.new("visible" => [true, false])
+      assert do
+        table1.visible == table2.visible
+      end
+    end
+
+    test("different name") do
+      table1 = Arrow::Table.new("visible" => [true, false])
+      table2 = Arrow::Table.new("invisible" => [true, false])
+      assert do
+        not table1.visible == table2.invisible
+      end
     end
 
-    test("Arrow::Column") do
+    test("different value") do
+      table1 = Arrow::Table.new("visible" => [true, false])
+      table2 = Arrow::Table.new("visible" => [true, true])
       assert do
-        @column == @column
+        not table1.visible == table2.visible
       end
     end
 
     test("not Arrow::Column") do
+      table = Arrow::Table.new("visible" => [true, false])
       assert do
-        not (@column == 29)
+        not table.visible == 29
       end
     end
   end

data/test/test-decimal128-array-builder.rb

@@ -17,7 +17,7 @@
 
 class Decimal128ArrayBuilderTest < Test::Unit::TestCase
   def setup
-    @data_type = Arrow::Decimal128DataType.new(8, 2)
+    @data_type = Arrow::Decimal128DataType.new(3, 1)
     @builder = Arrow::Decimal128ArrayBuilder.new(@data_type)
   end
 
@@ -31,28 +31,28 @@ class Decimal128ArrayBuilderTest < Test::Unit::TestCase
     test("Arrow::Decimal128") do
       @builder.append_value(Arrow::Decimal128.new("10.1"))
       array = @builder.finish
-      assert_equal(Arrow::Decimal128.new("10.1"),
+      assert_equal(BigDecimal("10.1"),
                    array[0])
     end
 
     test("String") do
       @builder.append_value("10.1")
       array = @builder.finish
-      assert_equal(Arrow::Decimal128.new("10.1"),
+      assert_equal(BigDecimal("10.1"),
                    array[0])
     end
 
     test("Float") do
       @builder.append_value(10.1)
       array = @builder.finish
-      assert_equal(Arrow::Decimal128.new("10.1"),
+      assert_equal(BigDecimal("10.1"),
                    array[0])
     end
 
     test("BigDecimal") do
       @builder.append_value(BigDecimal("10.1"))
       array = @builder.finish
-      assert_equal(Arrow::Decimal128.new("10.1"),
+      assert_equal(BigDecimal("10.1"),
                    array[0])
     end
   end
@@ -68,11 +68,11 @@ class Decimal128ArrayBuilderTest < Test::Unit::TestCase
                              ])
       array = @builder.finish
       assert_equal([
-                     Arrow::Decimal128.new("10.1"),
+                     BigDecimal("10.1"),
                      nil,
-                     Arrow::Decimal128.new("10.1"),
-                     Arrow::Decimal128.new("10.1"),
-                     Arrow::Decimal128.new("10.1"),
+                     BigDecimal("10.1"),
+                     BigDecimal("10.1"),
+                     BigDecimal("10.1"),
                    ],
                    array.to_a)
     end
@@ -85,9 +85,9 @@ class Decimal128ArrayBuilderTest < Test::Unit::TestCase
                              ])
       array = @builder.finish
       assert_equal([
-                     Arrow::Decimal128.new("10.1"),
+                     BigDecimal("10.1"),
                      nil,
-                     Arrow::Decimal128.new("10.1"),
+                     BigDecimal("10.1"),
                    ],
                    array.to_a)
     end

data/test/test-decimal128-array.rb

@@ -18,7 +18,7 @@
 class Decimal128ArrayTest < Test::Unit::TestCase
   sub_test_case(".new") do
     test("build") do
-      data_type = Arrow::Decimal128DataType.new(8, 2)
+      data_type = Arrow::Decimal128DataType.new(3, 1)
       values = [
         10.1,
         nil,
@@ -27,10 +27,10 @@ class Decimal128ArrayTest < Test::Unit::TestCase
       ]
       array = Arrow::Decimal128Array.new(data_type, values)
       assert_equal([
-                     Arrow::Decimal128.new("10.1"),
+                     BigDecimal("10.1"),
                      nil,
-                     Arrow::Decimal128.new("10.1"),
-                     Arrow::Decimal128.new("10.1"),
+                     BigDecimal("10.1"),
+                     BigDecimal("10.1"),
                    ],
                    array.to_a)
     end

data/test/test-slicer.rb

@@ -36,9 +36,7 @@ class SlicerTest < Test::Unit::TestCase
     ]
     @count_array = Arrow::ChunkedArray.new(count_arrays)
     @visible_array = Arrow::ChunkedArray.new(visible_arrays)
-    @count_column = Arrow::Column.new(@count_field, @count_array)
-    @visible_column = Arrow::Column.new(@visible_field, @visible_array)
-    @table = Arrow::Table.new(schema, [@count_column, @visible_column])
+    @table = Arrow::Table.new(schema, [@count_array, @visible_array])
   end
 
   sub_test_case("column") do

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

@@ -168,12 +168,12 @@ class StructArrayBuilderTest < Test::Unit::TestCase
       @builder.get_field_builder(1).append(2)
       array = @builder.finish
       assert_equal([
-                     [true, 1],
-                     [false, 2],
+                     {"visible" => true,  "count" => 1},
+                     {"visible" => false, "count" => 2},
                    ],
                    [
-                     array.get_value(0).values,
-                     array.get_value(1).values,
+                     array.get_value(0),
+                     array.get_value(1),
                    ])
     end
   end