red-arrow 0.17.0 → 3.0.0

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,8 +160,8 @@ 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]),

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

data/test/test-buffer.rb

@@ -16,6 +16,17 @@
 # under the License.
 
 class BufferTest < Test::Unit::TestCase
+  sub_test_case(".new") do
+    test("GC") do
+      data = "Hello"
+      data_id = data.object_id
+      _buffer = Arrow::Buffer.new(data)
+      data = nil
+      GC.start
+      assert_equal("Hello", ObjectSpace._id2ref(data_id))
+    end
+  end
+
   sub_test_case("instance methods") do
     def setup
       @buffer = Arrow::Buffer.new("Hello")

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

@@ -80,8 +80,13 @@ class Decimal128ArrayBuilderTest < Test::Unit::TestCase
     test("is_valids") do
       @builder.append_values([
                                Arrow::Decimal128.new("10.1"),
-                               nil,
                                Arrow::Decimal128.new("10.1"),
+                               Arrow::Decimal128.new("10.1"),
+                             ],
+                             [
+                               true,
+                               false,
+                               true,
                              ])
       array = @builder.finish
       assert_equal([
@@ -91,5 +96,17 @@ class Decimal128ArrayBuilderTest < Test::Unit::TestCase
                    ],
                    array.to_a)
     end
+
+    test("packed") do
+      @builder.append_values(Arrow::Decimal128.new("10.1").to_bytes.to_s * 3,
+                             [true, false, true])
+      array = @builder.finish
+      assert_equal([
+                     BigDecimal("10.1"),
+                     nil,
+                     BigDecimal("10.1"),
+                   ],
+                   array.to_a)
+    end
   end
 end

data/test/test-decimal128.rb

@@ -60,5 +60,43 @@ class Decimal128Test < Test::Unit::TestCase
                      @decimal128.to_s(1))
       end
     end
+
+    test("#abs") do
+      decimal128 = Arrow::Decimal128.new("-10.1")
+      assert_equal([
+                     Arrow::Decimal128.new("-10.1"),
+                     Arrow::Decimal128.new("10.1"),
+                   ],
+                   [
+                     decimal128,
+                     decimal128.abs,
+                   ])
+    end
+
+    test("#abs!") do
+      decimal128 = Arrow::Decimal128.new("-10.1")
+      decimal128.abs!
+      assert_equal(Arrow::Decimal128.new("10.1"),
+                   decimal128)
+    end
+
+    test("#negate") do
+      decimal128 = Arrow::Decimal128.new("-10.1")
+      assert_equal([
+                     Arrow::Decimal128.new("-10.1"),
+                     Arrow::Decimal128.new("10.1"),
+                   ],
+                   [
+                     decimal128,
+                     decimal128.negate,
+                   ])
+    end
+
+    test("#negate!") do
+      decimal128 = Arrow::Decimal128.new("-10.1")
+      decimal128.negate!
+      assert_equal(Arrow::Decimal128.new("10.1"),
+                   decimal128)
+    end
   end
 end

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

@@ -0,0 +1,112 @@
+# 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 Decimal256ArrayBuilderTest < Test::Unit::TestCase
+  def setup
+    @data_type = Arrow::Decimal256DataType.new(3, 1)
+    @builder = Arrow::Decimal256ArrayBuilder.new(@data_type)
+  end
+
+  sub_test_case("#append_value") do
+    test("nil") do
+      @builder.append_value(nil)
+      array = @builder.finish
+      assert_equal(nil, array[0])
+    end
+
+    test("Arrow::Decimal256") do
+      @builder.append_value(Arrow::Decimal256.new("10.1"))
+      array = @builder.finish
+      assert_equal(BigDecimal("10.1"),
+                   array[0])
+    end
+
+    test("String") do
+      @builder.append_value("10.1")
+      array = @builder.finish
+      assert_equal(BigDecimal("10.1"),
+                   array[0])
+    end
+
+    test("Float") do
+      @builder.append_value(10.1)
+      array = @builder.finish
+      assert_equal(BigDecimal("10.1"),
+                   array[0])
+    end
+
+    test("BigDecimal") do
+      @builder.append_value(BigDecimal("10.1"))
+      array = @builder.finish
+      assert_equal(BigDecimal("10.1"),
+                   array[0])
+    end
+  end
+
+  sub_test_case("#append_values") do
+    test("mixed") do
+      @builder.append_values([
+                               Arrow::Decimal256.new("10.1"),
+                               nil,
+                               "10.1",
+                               10.1,
+                               BigDecimal("10.1"),
+                             ])
+      array = @builder.finish
+      assert_equal([
+                     BigDecimal("10.1"),
+                     nil,
+                     BigDecimal("10.1"),
+                     BigDecimal("10.1"),
+                     BigDecimal("10.1"),
+                   ],
+                   array.to_a)
+    end
+
+    test("is_valids") do
+      @builder.append_values([
+                               Arrow::Decimal256.new("10.1"),
+                               Arrow::Decimal256.new("10.1"),
+                               Arrow::Decimal256.new("10.1"),
+                             ],
+                             [
+                               true,
+                               false,
+                               true,
+                             ])
+      array = @builder.finish
+      assert_equal([
+                     BigDecimal("10.1"),
+                     nil,
+                     BigDecimal("10.1"),
+                   ],
+                   array.to_a)
+    end
+
+    test("packed") do
+      @builder.append_values(Arrow::Decimal256.new("10.1").to_bytes.to_s * 3,
+                             [true, false, true])
+      array = @builder.finish
+      assert_equal([
+                     BigDecimal("10.1"),
+                     nil,
+                     BigDecimal("10.1"),
+                   ],
+                   array.to_a)
+    end
+  end
+end

data/test/test-decimal256-array.rb

@@ -0,0 +1,38 @@
+# 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 Decimal256ArrayTest < Test::Unit::TestCase
+  sub_test_case(".new") do
+    test("build") do
+      data_type = Arrow::Decimal256DataType.new(3, 1)
+      values = [
+        10.1,
+        nil,
+        "10.1",
+        BigDecimal("10.1"),
+      ]
+      array = Arrow::Decimal256Array.new(data_type, values)
+      assert_equal([
+                     BigDecimal("10.1"),
+                     nil,
+                     BigDecimal("10.1"),
+                     BigDecimal("10.1"),
+                   ],
+                   array.to_a)
+    end
+  end
+end

data/test/test-decimal256-data-type.rb

@@ -0,0 +1,31 @@
+# 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 Decimal256DataTypeTest < Test::Unit::TestCase
+  sub_test_case(".new") do
+    test("ordered arguments") do
+      assert_equal("decimal256(8, 2)",
+                   Arrow::Decimal256DataType.new(8, 2).to_s)
+    end
+
+    test("description") do
+      assert_equal("decimal256(8, 2)",
+                   Arrow::Decimal256DataType.new(precision: 8,
+                                                 scale: 2).to_s)
+    end
+  end
+end

data/test/test-decimal256.rb

@@ -0,0 +1,102 @@
+# 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 Decimal256Test < Test::Unit::TestCase
+  sub_test_case("instance methods") do
+    def setup
+      @decimal256 = Arrow::Decimal256.new("10.1")
+    end
+
+    sub_test_case("#==") do
+      test("Arrow::Decimal256") do
+        assert do
+          @decimal256 == @decimal256
+        end
+      end
+
+      test("not Arrow::Decimal256") do
+        assert do
+          not (@decimal256 == 10.1)
+        end
+      end
+    end
+
+    sub_test_case("#!=") do
+      test("Arrow::Decimal256") do
+        assert do
+          not (@decimal256 != @decimal256)
+        end
+      end
+
+      test("not Arrow::Decimal256") do
+        assert do
+          @decimal256 != 10.1
+        end
+      end
+    end
+
+    sub_test_case("#to_s") do
+      test("default") do
+        assert_equal("101",
+                     @decimal256.to_s)
+      end
+
+      test("scale") do
+        assert_equal("10.1",
+                     @decimal256.to_s(1))
+      end
+    end
+
+    test("#abs") do
+      decimal256 = Arrow::Decimal256.new("-10.1")
+      assert_equal([
+                     Arrow::Decimal256.new("-10.1"),
+                     Arrow::Decimal256.new("10.1"),
+                   ],
+                   [
+                     decimal256,
+                     decimal256.abs,
+                   ])
+    end
+
+    test("#abs!") do
+      decimal256 = Arrow::Decimal256.new("-10.1")
+      decimal256.abs!
+      assert_equal(Arrow::Decimal256.new("10.1"),
+                   decimal256)
+    end
+
+    test("#negate") do
+      decimal256 = Arrow::Decimal256.new("-10.1")
+      assert_equal([
+                     Arrow::Decimal256.new("-10.1"),
+                     Arrow::Decimal256.new("10.1"),
+                   ],
+                   [
+                     decimal256,
+                     decimal256.negate,
+                   ])
+    end
+
+    test("#negate!") do
+      decimal256 = Arrow::Decimal256.new("-10.1")
+      decimal256.negate!
+      assert_equal(Arrow::Decimal256.new("10.1"),
+                   decimal256)
+    end
+  end
+end

data/test/test-dense-union-data-type.rb

@@ -28,12 +28,12 @@ class DenseUnionDataTypeTest < Test::Unit::TestCase
     end
 
     test("ordered arguments") do
-      assert_equal("union[dense]<visible: bool=2, count: int32=9>",
+      assert_equal("dense_union<visible: bool=2, count: int32=9>",
                    Arrow::DenseUnionDataType.new(@fields, [2, 9]).to_s)
     end
 
     test("description") do
-      assert_equal("union[dense]<visible: bool=2, count: int32=9>",
+      assert_equal("dense_union<visible: bool=2, count: int32=9>",
                    Arrow::DenseUnionDataType.new(fields: @fields,
                                                   type_codes: [2, 9]).to_s)
     end