red-arrow 8.0.0 → 10.0.0

data/test/test-table.rb

@@ -40,6 +40,22 @@ class TableTest < Test::Unit::TestCase
     @table = Arrow::Table.new(schema, [@count_array, @visible_array])
   end
 
+  sub_test_case(".new") do
+    test("{Symbol: Arrow::Tensor}") do
+      assert_equal(Arrow::Table.new(numbers: Arrow::UInt8Array.new([1, 2, 3])),
+                   Arrow::Table.new(numbers: Arrow::Tensor.new([1, 2, 3])))
+    end
+
+    test("{Symbol: #to_ary}") do
+      array_like = Object.new
+      def array_like.to_ary
+        [1, 2, 3]
+      end
+      assert_equal(Arrow::Table.new(numbers: Arrow::UInt8Array.new([1, 2, 3])),
+                   Arrow::Table.new(numbers: array_like))
+    end
+  end
+
   test("#columns") do
     assert_equal([
                    Arrow::Column.new(@table, 0),

data/test/test-tensor.rb

@@ -16,6 +16,233 @@
 # under the License.
 
 class TensorTest < Test::Unit::TestCase
+  sub_test_case("class methods") do
+    sub_test_case(".new") do
+      def setup
+        @raw_tensor = [
+          [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+          ],
+          [
+            [9, 10, 11, 12],
+            [13, 14, 15, 16],
+          ],
+          [
+            [17, 18, 19, 20],
+            [21, 22, 23, 24],
+          ],
+        ]
+        @shape = [3, 2, 4]
+        @strides = [8, 4, 1]
+      end
+
+      test("Array") do
+        tensor = Arrow::Tensor.new(@raw_tensor)
+        assert_equal({
+                       value_data_type: Arrow::UInt8DataType.new,
+                       buffer: @raw_tensor.flatten.pack("C*"),
+                       shape: @shape,
+                       strides: @strides,
+                       dimension_names: ["", "", ""],
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                     })
+      end
+
+      test("Array, data_type: Symbol") do
+        tensor = Arrow::Tensor.new(@raw_tensor, data_type: :int32)
+        assert_equal({
+                       value_data_type: Arrow::Int32DataType.new,
+                       buffer: @raw_tensor.flatten.pack("l*"),
+                       shape: @shape,
+                       strides: @strides.collect {|x| x * 4},
+                       dimension_names: ["", "", ""],
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                     })
+      end
+
+      test("Array, dimension_names: Array<String>") do
+        tensor = Arrow::Tensor.new(@raw_tensor,
+                                   dimension_names: ["a", "b", "c"])
+        assert_equal({
+                       value_data_type: Arrow::UInt8DataType.new,
+                       buffer: @raw_tensor.flatten.pack("C*"),
+                       shape: @shape,
+                       strides: @strides,
+                       dimension_names: ["a", "b", "c"],
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                     })
+      end
+
+      test("Array, dimension_names: Array<Symbol>") do
+        tensor = Arrow::Tensor.new(@raw_tensor,
+                                   dimension_names: [:a, :b, :c])
+        assert_equal({
+                       value_data_type: Arrow::UInt8DataType.new,
+                       buffer: @raw_tensor.flatten.pack("C*"),
+                       shape: @shape,
+                       strides: @strides,
+                       dimension_names: ["a", "b", "c"],
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                     })
+      end
+
+      test("Array, strides:") do
+        message = "strides: is only accepted with " +
+                  "an Arrow::Buffer or String raw tensor: #{@strides.inspect}"
+        assert_raise(ArgumentError.new(message)) do
+          Arrow::Tensor.new(@raw_tensor, strides: @strides)
+        end
+      end
+
+      test("Arrow::Buffer, data_type:, shape:") do
+        data_type = :uint8
+        data = Arrow::Buffer.new(@raw_tensor.flatten.pack("C*").freeze)
+        tensor = Arrow::Tensor.new(data,
+                                   data_type: data_type,
+                                   shape: @shape)
+        assert_equal({
+                       value_data_type: Arrow::UInt8DataType.new,
+                       buffer: @raw_tensor.flatten.pack("C*"),
+                       shape: @shape,
+                       strides: @strides,
+                       dimension_names: ["", "", ""],
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                     })
+      end
+
+      test("String, data_type:, shape:") do
+        data_type = :uint8
+        data = @raw_tensor.flatten.pack("C*").freeze
+        tensor = Arrow::Tensor.new(data,
+                                   data_type: data_type,
+                                   shape: @shape)
+        assert_equal({
+                       value_data_type: Arrow::UInt8DataType.new,
+                       buffer: @raw_tensor.flatten.pack("C*"),
+                       shape: @shape,
+                       strides: @strides,
+                       dimension_names: ["", "", ""],
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                     })
+      end
+
+      test("String, data_type:") do
+        data_type = :uint8
+        data = @raw_tensor.flatten.pack("C*").freeze
+        message = "shape: is missing: #{data.inspect}"
+        assert_raise(ArgumentError.new(message)) do
+          Arrow::Tensor.new(data, data_type: data_type)
+        end
+      end
+
+      test("String, shape:") do
+        data = @raw_tensor.flatten.pack("C*").freeze
+        message = "data_type: is missing: #{data.inspect}"
+        assert_raise(ArgumentError.new(message)) do
+          Arrow::Tensor.new(data, shape: @shape)
+        end
+      end
+
+      test("String - not ASCII-8BIT") do
+        data = "XXX"
+        message = "raw tensor String must be " +
+                  "an ASCII-8BIT encoded string: #{data.encoding.inspect}"
+        assert_raise(ArgumentError.new(message)) do
+          Arrow::Tensor.new("XXX")
+        end
+      end
+
+      test("Symbol, Arrow::Buffer, shape:") do
+        data_type = :uint8
+        data = Arrow::Buffer.new(@raw_tensor.flatten.pack("C*").freeze)
+        tensor = Arrow::Tensor.new(data_type,
+                                   data,
+                                   shape: @shape)
+        assert_equal({
+                       value_data_type: Arrow::UInt8DataType.new,
+                       buffer: @raw_tensor.flatten.pack("C*"),
+                       shape: @shape,
+                       strides: @strides,
+                       dimension_names: ["", "", ""],
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                     })
+      end
+
+      test("Symbol, String, shape:, strides: - !contiguous and column major") do
+        data_type = :uint8
+        @shape[-1] -= 1 # Ignore the last element in @raw_tensor
+        @strides.reverse
+        tensor = Arrow::Tensor.new(data_type,
+                                   @raw_tensor.flatten.pack("C*"),
+                                   shape: @shape,
+                                   strides: @strides)
+        assert_equal({
+                       value_data_type: Arrow::UInt8DataType.new,
+                       buffer: @raw_tensor.flatten.pack("C*"),
+                       shape: @shape,
+                       strides: @strides,
+                       dimension_names: ["", "", ""],
+                       contiguous: false,
+                       row_major: false,
+                       column_major: false,
+                     },
+                     {
+                       value_data_type: tensor.value_data_type,
+                       buffer: tensor.buffer.data.to_s,
+                       shape: tensor.shape,
+                       strides: tensor.strides,
+                       dimension_names: tensor.dimension_names,
+                       contiguous: tensor.contiguous?,
+                       row_major: tensor.row_major?,
+                       column_major: tensor.column_major?,
+                     })
+      end
+    end
+  end
+
   sub_test_case("instance methods") do
     def setup
       raw_data = [
@@ -28,11 +255,11 @@ class TensorTest < Test::Unit::TestCase
         9, 10,
         11, 12,
       ]
-      data = Arrow::Buffer.new(raw_data.pack("c*"))
+      data = Arrow::Buffer.new(raw_data.pack("c*").freeze)
       shape = [3, 2, 2]
       strides = []
       names = ["a", "b", "c"]
-      @tensor = Arrow::Tensor.new(Arrow::Int8DataType.new,
+      @tensor = Arrow::Tensor.new(:int8,
                                   data,
                                   shape,
                                   strides,
@@ -52,5 +279,19 @@ class TensorTest < Test::Unit::TestCase
         end
       end
     end
+
+    sub_test_case("#to_arrow_array") do
+      test("1 dimension") do
+        assert_equal(Arrow::UInt8Array.new([1, 2, 3]),
+                     Arrow::Tensor.new([1, 2, 3]).to_arrow_array)
+      end
+
+      test("2 dimensions") do
+        message = "must be 1 dimensional tensor: [3, 1]"
+        assert_raise(RangeError.new(message)) do
+          Arrow::Tensor.new([[1], [2], [3]]).to_arrow_array
+        end
+      end
+    end
   end
 end

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

@@ -276,6 +276,36 @@ module ValuesDictionaryArrayTests
     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 ValuesArrayDictionaryArrayTest < Test::Unit::TestCase

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow
 version: !ruby/object:Gem::Version
-  version: 8.0.0
+  version: 10.0.0
 platform: ruby
 authors:
 - Apache Arrow Developers
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-07 00:00:00.000000000 Z
+date: 2022-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.3
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.3
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: extpp
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +109,7 @@ files:
 - lib/arrow/aggregate-node-options.rb
 - lib/arrow/aggregation.rb
 - lib/arrow/array-builder.rb
+- lib/arrow/array-computable.rb
 - lib/arrow/array.rb
 - lib/arrow/bigdecimal-extension.rb
 - lib/arrow/binary-dictionary-array-builder.rb
@@ -162,6 +163,7 @@ files:
 - lib/arrow/null-array.rb
 - lib/arrow/path-extension.rb
 - lib/arrow/raw-table-converter.rb
+- lib/arrow/raw-tensor-converter.rb
 - lib/arrow/record-batch-builder.rb
 - lib/arrow/record-batch-file-reader.rb
 - lib/arrow/record-batch-iterator.rb
@@ -179,6 +181,7 @@ files:
 - lib/arrow/sort-options.rb
 - lib/arrow/source-node-options.rb
 - lib/arrow/sparse-union-data-type.rb
+- lib/arrow/string-array-builder.rb
 - lib/arrow/string-dictionary-array-builder.rb
 - lib/arrow/struct-array-builder.rb
 - lib/arrow/struct-array.rb
@@ -192,6 +195,7 @@ files:
 - lib/arrow/table-table-formatter.rb
 - lib/arrow/table.rb
 - lib/arrow/tensor.rb
+- lib/arrow/time-unit.rb
 - lib/arrow/time.rb
 - lib/arrow/time32-array-builder.rb
 - lib/arrow/time32-array.rb
@@ -219,6 +223,7 @@ files:
 - test/helper/omittable.rb
 - test/raw-records/test-basic-arrays.rb
 - test/raw-records/test-dense-union-array.rb
+- test/raw-records/test-dictionary-array.rb
 - test/raw-records/test-list-array.rb
 - test/raw-records/test-map-array.rb
 - test/raw-records/test-multiple-columns.rb
@@ -303,8 +308,8 @@ homepage: https://arrow.apache.org/
 licenses:
 - Apache-2.0
 metadata:
-  msys2_mingw_dependencies: arrow>=8.0.0
-post_install_message: 
+  msys2_mingw_dependencies: arrow>=10.0.0
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -319,8 +324,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
-signing_key: 
+rubygems_version: 3.3.15
+signing_key:
 specification_version: 4
 summary: Red Arrow is the Ruby bindings of Apache Arrow
 test_files:
@@ -338,6 +343,7 @@ test_files:
 - test/helper.rb
 - test/raw-records/test-basic-arrays.rb
 - test/raw-records/test-dense-union-array.rb
+- test/raw-records/test-dictionary-array.rb
 - test/raw-records/test-list-array.rb
 - test/raw-records/test-map-array.rb
 - test/raw-records/test-multiple-columns.rb