red-arrow 0.13.0 → 0.14.0

data/test/test-dictionary-data-type.rb

@@ -19,21 +19,21 @@ class DictionaryDataTypeTest < Test::Unit::TestCase
   sub_test_case(".new") do
     def setup
       @index_data_type = :int8
-      @dictionary = Arrow::StringArray.new(["Hello", "World"])
+      @value_data_type = :string
       @ordered = true
     end
 
     test("ordered arguments") do
       assert_equal("dictionary<values=string, indices=int8, ordered=1>",
                    Arrow::DictionaryDataType.new(@index_data_type,
-                                                 @dictionary,
+                                                 @value_data_type,
                                                  @ordered).to_s)
     end
 
     test("description") do
       assert_equal("dictionary<values=string, indices=int8, ordered=1>",
                    Arrow::DictionaryDataType.new(index_data_type: @index_data_type,
-                                                 dictionary: @dictionary,
+                                                 value_data_type: @value_data_type,
                                                  ordered: @ordered).to_s)
     end
   end

data/test/test-table.rb

@@ -74,17 +74,24 @@ class TableTest < Test::Unit::TestCase
     end
 
     test("Integer: positive") do
-      assert_equal(<<-TABLE, @table.slice(2).to_s)
-	count	visible
-0	    4	       
-      TABLE
+      assert_equal({"count" => 128, "visible" => nil},
+                   @table.slice(@table.n_rows - 1).to_h)
     end
 
     test("Integer: negative") do
-      assert_equal(<<-TABLE, @table.slice(-1).to_s)
-	count	visible
-0	  128	       
-      TABLE
+      assert_equal({"count" => 1, "visible" => true},
+                   @table.slice(-@table.n_rows).to_h)
+    end
+
+    test("Integer: out of index") do
+      assert_equal([
+                     nil,
+                     nil,
+                   ],
+                   [
+                     @table.slice(@table.n_rows),
+                     @table.slice(-(@table.n_rows + 1)),
+                   ])
     end
 
     test("Range: positive: include end") do
@@ -145,17 +152,35 @@ class TableTest < Test::Unit::TestCase
         end
       end
 
-      test("too many arguments: with block") do
+      test("too many arguments") do
         message = "wrong number of arguments (given 3, expected 1..2)"
         assert_raise(ArgumentError.new(message)) do
           @table.slice(1, 2, 3)
         end
       end
 
-      test("too many arguments: without block") do
-        message = "wrong number of arguments (given 3, expected 0..2)"
+      test("arguments: with block") do
+        message = "must not specify both arguments and block"
+        assert_raise(ArgumentError.new(message)) do
+          @table.slice(1, 2) {}
+        end
+      end
+
+      test("offset: too small") do
+        n_rows = @table.n_rows
+        offset = -(n_rows + 1)
+        message = "offset is out of range (-#{n_rows + 1},#{n_rows}): #{offset}"
+        assert_raise(ArgumentError.new(message)) do
+          @table.slice(offset, 1)
+        end
+      end
+
+      test("offset: too large") do
+        n_rows = @table.n_rows
+        offset = n_rows
+        message = "offset is out of range (-#{n_rows + 1},#{n_rows}): #{offset}"
         assert_raise(ArgumentError.new(message)) do
-          @table.slice(1, 2, 3) {}
+          @table.slice(offset, 1)
         end
       end
     end
@@ -492,7 +517,8 @@ class TableTest < Test::Unit::TestCase
 
           test("csv.gz") do
             file = Tempfile.new(["red-arrow", ".csv.gz"])
-            Zlib::GzipWriter.wrap(file) do |gz|
+            file.close
+            Zlib::GzipWriter.open(file.path) do |gz|
               gz.write(<<-CSV)
 name,score
 alice,10
@@ -505,7 +531,7 @@ chris,-1
 0	alice	   10
 1	bob 	   29
 2	chris	   -1
-          TABLE
+            TABLE
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Apache Arrow Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-31 00:00:00.000000000 Z
+date: 2019-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: extpp
@@ -181,7 +181,7 @@ files:
 - doc/text/development.md
 - ext/arrow/arrow.cpp
 - ext/arrow/extconf.rb
-- ext/arrow/record-batch.cpp
+- ext/arrow/raw-records.cpp
 - ext/arrow/red-arrow.hpp
 - image/red-arrow.png
 - lib/arrow.rb
@@ -254,12 +254,13 @@ files:
 - test/fixture/without-header.csv
 - test/helper.rb
 - test/helper/fixture.rb
-- test/raw-records/record-batch/test-basic-arrays.rb
-- test/raw-records/record-batch/test-dense-union-array.rb
-- test/raw-records/record-batch/test-list-array.rb
-- test/raw-records/record-batch/test-multiple-columns.rb
-- test/raw-records/record-batch/test-sparse-union-array.rb
-- test/raw-records/record-batch/test-struct-array.rb
+- test/raw-records/test-basic-arrays.rb
+- test/raw-records/test-dense-union-array.rb
+- test/raw-records/test-list-array.rb
+- test/raw-records/test-multiple-columns.rb
+- test/raw-records/test-sparse-union-array.rb
+- test/raw-records/test-struct-array.rb
+- test/raw-records/test-table.rb
 - test/run-test.rb
 - test/test-array-builder.rb
 - test/test-array.rb
@@ -328,62 +329,63 @@ signing_key:
 specification_version: 4
 summary: Red Arrow is the Ruby bindings of Apache Arrow
 test_files:
-- test/test-record-batch-file-reader.rb
-- test/test-tensor.rb
-- test/test-dense-union-data-type.rb
 - test/test-time64-data-type.rb
-- test/fixture/with-header.csv
-- test/fixture/float-integer.csv
-- test/fixture/null-without-double-quote.csv
-- test/fixture/without-header-float.csv
-- test/fixture/with-header-float.csv
-- test/fixture/without-header.csv
-- test/fixture/integer-float.csv
-- test/fixture/TestOrcFile.test1.orc
-- test/fixture/null-with-double-quote.csv
-- test/test-file-output-stream.rb
-- test/test-bigdecimal.rb
-- test/test-record-batch-builder.rb
-- test/test-struct.rb
-- test/test-column.rb
-- test/test-time32-data-type.rb
+- test/test-feather.rb
+- test/test-decimal128.rb
 - test/test-struct-array.rb
-- test/test-array-builder.rb
-- test/test-chunked-array.rb
-- test/test-list-array.rb
-- test/test-date32-array.rb
-- test/test-field.rb
-- test/test-struct-array-builder.rb
-- test/test-decimal128-array-builder.rb
-- test/test-record-batch.rb
+- test/test-data-type.rb
+- test/test-list-data-type.rb
+- test/test-dense-union-data-type.rb
 - test/helper.rb
-- test/test-orc.rb
-- test/test-struct-data-type.rb
-- test/test-rolling-window.rb
+- test/test-record-batch.rb
+- test/test-table.rb
 - test/run-test.rb
-- test/test-timestamp-data-type.rb
-- test/test-feather.rb
-- test/test-decimal128-data-type.rb
-- test/test-list-data-type.rb
 - test/test-timestamp-array.rb
+- test/test-date32-array.rb
+- test/test-array-builder.rb
+- test/test-date64-array.rb
+- test/test-record-batch-file-reader.rb
+- test/test-decimal128-data-type.rb
+- test/test-timestamp-data-type.rb
+- test/test-column.rb
+- test/test-field.rb
 - test/test-decimal128-array.rb
-- test/test-table.rb
 - test/test-csv-loader.rb
+- test/test-bigdecimal.rb
+- test/test-list-array.rb
+- test/test-rolling-window.rb
+- test/test-dictionary-data-type.rb
+- test/fixture/integer-float.csv
+- test/fixture/without-header-float.csv
+- test/fixture/null-with-double-quote.csv
+- test/fixture/with-header-float.csv
+- test/fixture/TestOrcFile.test1.orc
+- test/fixture/null-without-double-quote.csv
+- test/fixture/without-header.csv
+- test/fixture/with-header.csv
+- test/fixture/float-integer.csv
+- test/test-orc.rb
+- test/test-time32-data-type.rb
+- test/test-struct-data-type.rb
+- test/test-struct.rb
+- test/test-group.rb
+- test/test-buffer.rb
+- test/test-slicer.rb
 - test/test-list-array-builder.rb
+- test/test-sparse-union-data-type.rb
+- test/test-record-batch-builder.rb
+- test/raw-records/test-struct-array.rb
+- test/raw-records/test-table.rb
+- test/raw-records/test-basic-arrays.rb
+- test/raw-records/test-list-array.rb
+- test/raw-records/test-dense-union-array.rb
+- test/raw-records/test-sparse-union-array.rb
+- test/raw-records/test-multiple-columns.rb
 - test/test-array.rb
-- test/test-group.rb
+- test/test-file-output-stream.rb
+- test/test-tensor.rb
+- test/test-decimal128-array-builder.rb
+- test/test-chunked-array.rb
 - test/test-schema.rb
-- test/test-dictionary-data-type.rb
-- test/test-data-type.rb
-- test/raw-records/record-batch/test-sparse-union-array.rb
-- test/raw-records/record-batch/test-basic-arrays.rb
-- test/raw-records/record-batch/test-multiple-columns.rb
-- test/raw-records/record-batch/test-struct-array.rb
-- test/raw-records/record-batch/test-list-array.rb
-- test/raw-records/record-batch/test-dense-union-array.rb
-- test/test-decimal128.rb
+- test/test-struct-array-builder.rb
 - test/helper/fixture.rb
-- test/test-date64-array.rb
-- test/test-buffer.rb
-- test/test-sparse-union-data-type.rb
-- test/test-slicer.rb

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

@@ -1,349 +0,0 @@
-# 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.
-
-class RawRecordsRecordBatchBasicArraysTest < Test::Unit::TestCase
-  test("NullArray") do
-    records = [
-      [nil],
-      [nil],
-      [nil],
-      [nil],
-    ]
-    array = Arrow::NullArray.new(records.size)
-    schema = Arrow::Schema.new(column: :null)
-    record_batch = Arrow::RecordBatch.new(schema,
-                                          records.size,
-                                          [array])
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("BooleanArray") do
-    records = [
-      [true],
-      [nil],
-      [false],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :boolean},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("Int8Array") do
-    records = [
-      [-(2 ** 7)],
-      [nil],
-      [(2 ** 7) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :int8},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("UInt8Array") do
-    records = [
-      [0],
-      [nil],
-      [(2 ** 8) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :uint8},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("Int16Array") do
-    records = [
-      [-(2 ** 15)],
-      [nil],
-      [(2 ** 15) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :int16},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("UInt16Array") do
-    records = [
-      [0],
-      [nil],
-      [(2 ** 16) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :uint16},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("Int32Array") do
-    records = [
-      [-(2 ** 31)],
-      [nil],
-      [(2 ** 31) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :int32},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("UInt32Array") do
-    records = [
-      [0],
-      [nil],
-      [(2 ** 32) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :uint32},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("Int64Array") do
-    records = [
-      [-(2 ** 63)],
-      [nil],
-      [(2 ** 63) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :int64},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("UInt64Array") do
-    records = [
-      [0],
-      [nil],
-      [(2 ** 64) - 1],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :uint64},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("FloatArray") do
-    records = [
-      [-1.0],
-      [nil],
-      [1.0],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :float},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("DoubleArray") do
-    records = [
-      [-1.0],
-      [nil],
-      [1.0],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :double},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("BinaryArray") do
-    records = [
-      ["\x00".b],
-      [nil],
-      ["\xff".b],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :binary},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("StringArray") do
-    records = [
-      ["Ruby"],
-      [nil],
-      ["\u3042"], # U+3042 HIRAGANA LETTER A
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :string},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("Date32Array") do
-    records = [
-      [Date.new(1960, 1, 1)],
-      [nil],
-      [Date.new(2017, 8, 23)],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :date32},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  test("Date64Array") do
-    records = [
-      [DateTime.new(1960, 1, 1, 2, 9, 30)],
-      [nil],
-      [DateTime.new(2017, 8, 23, 14, 57, 2)],
-    ]
-    record_batch = Arrow::RecordBatch.new({column: :date64},
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-
-  sub_test_case("TimestampArray") do
-    test("second") do
-      records = [
-        [Time.parse("1960-01-01T02:09:30Z")],
-        [nil],
-        [Time.parse("2017-08-23T14:57:02Z")],
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :timestamp,
-                                                unit: :second,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-
-    test("milli") do
-      records = [
-        [Time.parse("1960-01-01T02:09:30.123Z")],
-        [nil],
-        [Time.parse("2017-08-23T14:57:02.987Z")],
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :timestamp,
-                                                unit: :milli,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-
-    test("micro") do
-      records = [
-        [Time.parse("1960-01-01T02:09:30.123456Z")],
-        [nil],
-        [Time.parse("2017-08-23T14:57:02.987654Z")],
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :timestamp,
-                                                unit: :micro,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-
-    test("nano") do
-      records = [
-        [Time.parse("1960-01-01T02:09:30.123456789Z")],
-        [nil],
-        [Time.parse("2017-08-23T14:57:02.987654321Z")],
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :timestamp,
-                                                unit: :nano,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-  end
-
-  sub_test_case("Time32Array") do
-    test("second") do
-      records = [
-        [60 * 10], # 00:10:00
-        [nil],
-        [60 * 60 * 2 + 9], # 02:00:09
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :time32,
-                                                unit: :second,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-
-    test("milli") do
-      records = [
-        [(60 * 10) * 1000 + 123], # 00:10:00.123
-        [nil],
-        [(60 * 60 * 2 + 9) * 1000 + 987], # 02:00:09.987
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :time32,
-                                                unit: :milli,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-  end
-
-  sub_test_case("Time64Array") do
-    test("micro") do
-      records = [
-        [(60 * 10) * 1_000_000 + 123_456], # 00:10:00.123456
-        [nil],
-        [(60 * 60 * 2 + 9) * 1_000_000 + 987_654], # 02:00:09.987654
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :time64,
-                                                unit: :micro,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-
-    test("nano") do
-      records = [
-        [(60 * 10) * 1_000_000_000 + 123_456_789], # 00:10:00.123456789
-        [nil],
-        [(60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321], # 02:00:09.987654321
-      ]
-      record_batch = Arrow::RecordBatch.new({
-                                              column: {
-                                                type: :time64,
-                                                unit: :nano,
-                                              }
-                                            },
-                                            records)
-      assert_equal(records, record_batch.raw_records)
-    end
-  end
-
-  test("Decimal128Array") do
-    records = [
-      [BigDecimal("92.92")],
-      [nil],
-      [BigDecimal("29.29")],
-    ]
-    record_batch = Arrow::RecordBatch.new({
-                                            column: {
-                                              type: :decimal128,
-                                              precision: 8,
-                                              scale: 2,
-                                            }
-                                          },
-                                          records)
-    assert_equal(records, record_batch.raw_records)
-  end
-end