red-arrow 2.0.0 → 3.0.0

data/lib/arrow/fixed-size-binary-array.rb

@@ -0,0 +1,26 @@
+# 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.
+
+module Arrow
+  class FixedSizeBinaryArray
+    alias_method :get_value_raw, :get_value
+    # @since 3.0.0
+    def get_value(i)
+      get_value_raw(i).to_s
+    end
+  end
+end

data/lib/arrow/loader.rb

@@ -56,11 +56,17 @@ module Arrow
       require "arrow/decimal128-array"
       require "arrow/decimal128-array-builder"
       require "arrow/decimal128-data-type"
+      require "arrow/decimal256"
+      require "arrow/decimal256-array"
+      require "arrow/decimal256-array-builder"
+      require "arrow/decimal256-data-type"
       require "arrow/dense-union-data-type"
       require "arrow/dictionary-array"
       require "arrow/dictionary-data-type"
       require "arrow/field"
       require "arrow/file-output-stream"
+      require "arrow/fixed-size-binary-array"
+      require "arrow/fixed-size-binary-array-builder"
       require "arrow/group"
       require "arrow/list-array-builder"
       require "arrow/list-data-type"
@@ -141,6 +147,7 @@ module Arrow
       when "Arrow::Date32Array",
            "Arrow::Date64Array",
            "Arrow::Decimal128Array",
+           "Arrow::Decimal256Array",
            "Arrow::Time32Array",
            "Arrow::Time64Array",
            "Arrow::TimestampArray"
@@ -149,6 +156,12 @@ module Arrow
           method_name = "get_raw_value"
         end
         super(info, klass, method_name)
+      when "Arrow::Decimal128", "Arrow::Decimal256"
+        case method_name
+        when "copy"
+          method_name = "dup"
+        end
+        super(info, klass, method_name)
       else
         super
       end

data/lib/arrow/version.rb

@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 
   module Version
     numbers, TAG = VERSION.split("-")

data/red-arrow.gemspec

@@ -46,6 +46,7 @@ Gem::Specification.new do |spec|
   spec.test_files += Dir.glob("test/**/*")
   spec.extensions = ["ext/arrow/extconf.rb"]
 
+  spec.add_runtime_dependency("bigdecimal", ">= 2.0.3")
   spec.add_runtime_dependency("extpp", ">= 0.0.7")
   spec.add_runtime_dependency("gio2", ">= 3.3.6")
   spec.add_runtime_dependency("native-package-installer")

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

@@ -329,6 +329,23 @@ module RawRecordsBasicArraysTests
                    records)
     assert_equal(records, target.raw_records)
   end
+
+  def test_decimal256
+    records = [
+      [BigDecimal("92.92")],
+      [nil],
+      [BigDecimal("29.29")],
+    ]
+    target = build({
+                     column: {
+                       type: :decimal256,
+                       precision: 38,
+                       scale: 2,
+                     }
+                   },
+                   records)
+    assert_equal(records, target.raw_records)
+  end
 end
 
 class RawRecordsRecordBatchBasicArraysTest < Test::Unit::TestCase

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

@@ -345,6 +345,20 @@ module RawRecordsDenseUnionArrayTests
     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]}],

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

@@ -335,6 +335,20 @@ 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]}],

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-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