red-arrow 1.0.0 → 4.0.1

data/lib/arrow/sort-options.rb

@@ -0,0 +1,109 @@
+# 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 SortOptions
+    class << self
+      # @api private
+      def try_convert(value)
+        case value
+        when Symbol, String
+          new(value)
+        when ::Array
+          new(*value)
+        else
+          nil
+        end
+      end
+    end
+
+    alias_method :initialize_raw, :initialize
+    private :initialize_raw
+    # @param sort_keys [::Array<String, Symbol, Arrow::SortKey>] The
+    #   sort keys to be used. See {Arrow::SortKey.resolve} how to
+    #   resolve each sort key in `sort_keys`.
+    #
+    #   You can add more sort keys by {#add_sort_key} later.
+    #
+    # @example No initial sort keys
+    #   options = Arrow::SortOptions.new
+    #   options.sort_keys # => []
+    #
+    # @example String sort keys
+    #   options = Arrow::SortOptions.new("count", "-age")
+    #   options.sort_keys.collect(&:to_s) # => ["+count", "-age"]
+    #
+    # @example Symbol sort keys
+    #   options = Arrow::SortOptions.new(:count, :age)
+    #   options.sort_keys.collect(&:to_s) # => ["+count", "+age"]
+    #
+    # @example Mixed sort keys
+    #   options = Arrow::SortOptions.new(:count, "-age")
+    #   options.sort_keys.collect(&:to_s) # => ["+count", "-age"]
+    #
+    # @since 4.0.0
+    def initialize(*sort_keys)
+      initialize_raw
+      sort_keys.each do |sort_key|
+        add_sort_key(sort_key)
+      end
+    end
+
+    # @api private
+    alias_method :add_sort_key_raw, :add_sort_key
+    # Add a sort key.
+    #
+    # @return [void]
+    #
+    # @overload add_sort_key(key)
+    #
+    #   @param key [Arrow::SortKey] The sort key to be added.
+    #
+    #   @example Add a key to sort by "price" column in descending order
+    #     options = Arrow::SortOptions.new
+    #     options.add_sort_key(Arrow::SortKey.new(:price, :descending))
+    #     options.sort_keys.collect(&:to_s) # => ["-price"]
+    #
+    # @overload add_sort_key(name)
+    #
+    #   @param name [Symbol, String] The sort key name to be
+    #     added. See also {Arrow::SortKey#initialize} for the leading
+    #     order mark for String name.
+    #
+    #   @example Add a key to sort by "price" column in descending order
+    #     options = Arrow::SortOptions.new
+    #     options.add_sort_key("-price")
+    #     options.sort_keys.collect(&:to_s) # => ["-price"]
+    #
+    # @overload add_sort_key(name, order)
+    #
+    #   @param name [Symbol, String] The sort key name.
+    #
+    #   @param order [Symbol, String, Arrow::SortOrder] The sort
+    #     order. See {Arrow::SortKey#initialize} for details.
+    #
+    #   @example Add a key to sort by "price" column in descending order
+    #     options = Arrow::SortOptions.new
+    #     options.add_sort_key("price", :desc)
+    #     options.sort_keys.collect(&:to_s) # => ["-price"]
+    #
+    # @since 4.0.0
+    def add_sort_key(name, order=nil)
+      add_sort_key_raw(SortKey.resolve(name, order))
+    end
+  end
+end

data/lib/arrow/sparse-union-data-type.rb

@@ -33,7 +33,7 @@ module Arrow
     #   @param type_codes [::Array<Integer>] The IDs that indicates
     #     corresponding fields.
     #
-    #   @example Create a sparse union data type for {2: visible, 9: count}
+    #   @example Create a sparse union data type for `{2: visible, 9: count}`
     #     fields = [
     #       Arrow::Field.new("visible", :boolean),
     #       {
@@ -57,7 +57,7 @@ module Arrow
     #   @option description [::Array<Integer>] :type_codes The IDs
     #     that indicates corresponding fields.
     #
-    #   @example Create a sparse union data type for {2: visible, 9: count}
+    #   @example Create a sparse union data type for `{2: visible, 9: count}`
     #     fields = [
     #       Arrow::Field.new("visible", :boolean),
     #       {

data/lib/arrow/time32-data-type.rb

@@ -29,7 +29,7 @@ module Arrow
     #
     #     The unit must be second or millisecond.
     #
-    #   @example Create a time32 data type with {Arrow::TimeUnit}
+    #   @example Create a time32 data type with Arrow::TimeUnit
     #     Arrow::Time32DataType.new(Arrow::TimeUnit::MILLI)
     #
     #   @example Create a time32 data type with Symbol
@@ -45,7 +45,7 @@ module Arrow
     #
     #     The unit must be second or millisecond.
     #
-    #   @example Create a time32 data type with {Arrow::TimeUnit}
+    #   @example Create a time32 data type with Arrow::TimeUnit
     #     Arrow::Time32DataType.new(unit: Arrow::TimeUnit::MILLI)
     #
     #   @example Create a time32 data type with Symbol

data/lib/arrow/time64-data-type.rb

@@ -29,7 +29,7 @@ module Arrow
     #
     #     The unit must be microsecond or nanosecond.
     #
-    #   @example Create a time64 data type with {Arrow::TimeUnit}
+    #   @example Create a time64 data type with Arrow::TimeUnit
     #     Arrow::Time64DataType.new(Arrow::TimeUnit::NANO)
     #
     #   @example Create a time64 data type with Symbol
@@ -45,7 +45,7 @@ module Arrow
     #
     #     The unit must be microsecond or nanosecond.
     #
-    #   @example Create a time64 data type with {Arrow::TimeUnit}
+    #   @example Create a time64 data type with Arrow::TimeUnit
     #     Arrow::Time64DataType.new(unit: Arrow::TimeUnit::NANO)
     #
     #   @example Create a time64 data type with Symbol

data/lib/arrow/timestamp-data-type.rb

@@ -27,7 +27,7 @@ module Arrow
     #   @param unit [Arrow::TimeUnit, Symbol] The unit of the
     #     timestamp data type.
     #
-    #   @example Create a timestamp data type with {Arrow::TimeUnit}
+    #   @example Create a timestamp data type with Arrow::TimeUnit
     #     Arrow::TimestampDataType.new(Arrow::TimeUnit::MILLI)
     #
     #   @example Create a timestamp data type with Symbol
@@ -41,7 +41,7 @@ module Arrow
     #   @option description [Arrow::TimeUnit, Symbol] :unit The unit of
     #     the timestamp data type.
     #
-    #   @example Create a timestamp data type with {Arrow::TimeUnit}
+    #   @example Create a timestamp data type with Arrow::TimeUnit
     #     Arrow::TimestampDataType.new(unit: Arrow::TimeUnit::MILLI)
     #
     #   @example Create a timestamp data type with Symbol

data/lib/arrow/version.rb

@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "1.0.0"
+  VERSION = "4.0.1"
 
   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,12 +160,132 @@ 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]),
                    @array.is_in(right))
     end
   end
+
+  sub_test_case("#concatenate") do
+    test("Arrow::Array: same") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]).
+                     concatenate(Arrow::Int32Array.new([4, 5]),
+                                 Arrow::Int32Array.new([6])))
+    end
+
+    test("Arrow::Array: castable") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]).
+                     concatenate(Arrow::Int8Array.new([4, 5]),
+                                 Arrow::UInt32Array.new([6])))
+    end
+
+    test("Arrow::Array: non-castable") do
+      assert_raise(Arrow::Error::Invalid) do
+        Arrow::Int32Array.new([1, 2, nil]).
+          concatenate(Arrow::StringArray.new(["X"]))
+      end
+    end
+
+    test("Array") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,nil, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]).
+                     concatenate([4, nil],
+                                 [6]))
+    end
+
+    test("invalid") do
+      message = "[array][resolve] can't build int32 array: 4"
+      assert_raise(ArgumentError.new(message)) do
+        Arrow::Int32Array.new([1, 2, nil]).
+          concatenate(4)
+      end
+    end
+  end
+
+  sub_test_case("#+") do
+    test("Arrow::Array: same") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]) +
+                   Arrow::Int32Array.new([4, 5, 6]))
+    end
+
+    test("Arrow::Array: castable") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,5, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]) +
+                   Arrow::Int8Array.new([4, 5, 6]))
+    end
+
+    test("Arrow::Array: non-castable") do
+      assert_raise(Arrow::Error::Invalid) do
+        Arrow::Int32Array.new([1, 2, nil]) +
+          Arrow::StringArray.new(["X"])
+      end
+    end
+
+    test("Array") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil, 4 ,nil, 6]),
+                   Arrow::Int32Array.new([1, 2, nil]) +
+                   [4, nil, 6])
+    end
+
+    test("invalid") do
+      message = "[array][resolve] can't build int32 array: 4"
+      assert_raise(ArgumentError.new(message)) do
+        Arrow::Int32Array.new([1, 2, nil]) + 4
+      end
+    end
+  end
+
+  sub_test_case("#resolve") do
+    test("Arrow::Array: same") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil]),
+                   Arrow::Int32Array.new([]).
+                     resolve(Arrow::Int32Array.new([1, 2, nil])))
+    end
+
+    test("Arrow::Array: castable") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil]),
+                   Arrow::Int32Array.new([]).
+                     resolve(Arrow::Int8Array.new([1, 2, nil])))
+    end
+
+    test("Arrow::Array: non-castable") do
+      assert_raise(Arrow::Error::Invalid) do
+        Arrow::Int32Array.new([]) +
+          Arrow::StringArray.new(["X"])
+      end
+    end
+
+    test("Array: non-parametric") do
+      assert_equal(Arrow::Int32Array.new([1, 2, nil]),
+                   Arrow::Int32Array.new([]).
+                     resolve([1, 2, nil]))
+    end
+
+    test("Array: parametric") do
+      list_data_type = Arrow::ListDataType.new(name: "visible", type: :boolean)
+      list_array = Arrow::ListArray.new(list_data_type, [])
+      assert_equal(Arrow::ListArray.new(list_data_type,
+                                        [
+                                          [true, false],
+                                          nil,
+                                        ]),
+                   list_array.resolve([
+                                        [true, false],
+                                        nil,
+                                      ]))
+    end
+
+    test("invalid") do
+      message = "[array][resolve] can't build int32 array: 4"
+      assert_raise(ArgumentError.new(message)) do
+        Arrow::Int32Array.new([]).resolve(4)
+      end
+    end
+  end
 end