red-arrow 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a70c1505c294a8f74c992ec0f2ab5d651647e45dd178db8523f5b5c01e64a541
-  data.tar.gz: dad979599033104a25d5be3d05c57e552c803f9c8002d66b757866c425937ce9
+  metadata.gz: f048aad4d5cc38373c1acc3976ba7012292c2b21315be7334704b6abbd4076fa
+  data.tar.gz: 426aac582a879286bd8f6ae632f4851bcc00025a08032142f07073fd4c665c62
 SHA512:
-  metadata.gz: b2363ba6468985a3d237cbb9cec8b2ccb5031aae94153b8f263916e811524e8a5326f408867a843b7077f624050fabcde93520b26e6f8ceb1dd094aaa0068ed6
-  data.tar.gz: 797b89062dfd212d92ca957b8e51c6dc8acf16ab51e5a60ecb0cbf31dd979c288f2afb71274b2235a24d31da344cfce93b40830d6dc6edd000ce0aa607ce8cde
+  metadata.gz: 5f7ab5ce2884d205b7d498db7f74d50c9c6228a4c27de8638fb921535c71fed28aa69ffdcb55bc27300e8b5995d5f31b0e78a29b2bd0513fcbf60d1514a58f79
+  data.tar.gz: b6d28706fb0b4845c2b134e22f4988199e8714bf41e24a73d02b38a6161142ad04c7ebf30185791afb3c3a0b7a02701e92193b6ae55ff1e78089d60f3ca91c9a

data/lib/arrow/array.rb

@@ -100,5 +100,123 @@ module Arrow
         is_in_raw(values)
       end
     end
+
+    # @api private
+    alias_method :concatenate_raw, :concatenate
+    # Concatenates the given other arrays to the array.
+    #
+    # @param other_arrays [::Array, Arrow::Array] The arrays to be
+    #   concatenated.
+    #
+    #   Each other array is processed by {#resolve} before they're
+    #   concatenated.
+    #
+    # @example Raw Ruby Array
+    #   array = Arrow::Int32Array.new([1])
+    #   array.concatenate([2, 3], [4]) # => Arrow::Int32Array.new([1, 2, 3, 4])
+    #
+    # @example Arrow::Array
+    #   array = Arrow::Int32Array.new([1])
+    #   array.concatenate(Arrow::Int32Array.new([2, 3]),
+    #                     Arrow::Int8Array.new([4])) # => Arrow::Int32Array.new([1, 2, 3, 4])
+    #
+    # @since 4.0.0
+    def concatenate(*other_arrays)
+      other_arrays = other_arrays.collect do |other_array|
+        resolve(other_array)
+      end
+      concatenate_raw(other_arrays)
+    end
+
+    # Concatenates the given other array to the array.
+    #
+    # If you have multiple arrays to be concatenated, you should use
+    # {#concatenate} to concatenate multiple arrays at once.
+    #
+    # @param other_array [::Array, Arrow::Array] The array to be concatenated.
+    #
+    #   `@other_array` is processed by {#resolve} before it's
+    #   concatenated.
+    #
+    # @example Raw Ruby Array
+    #   Arrow::Int32Array.new([1]) + [2, 3] # => Arrow::Int32Array.new([1, 2, 3])
+    #
+    # @example Arrow::Array
+    #   Arrow::Int32Array.new([1]) +
+    #     Arrow::Int32Array.new([2, 3]) # => Arrow::Int32Array.new([1, 2, 3])
+    #
+    # @since 4.0.0
+    def +(other_array)
+      concatenate(other_array)
+    end
+
+    # Ensures returning the same data type array from the given array.
+    #
+    # @return [Arrow::Array]
+    #
+    # @overload resolve(other_raw_array)
+    #
+    #   @param other_raw_array [::Array] A raw Ruby Array. A new Arrow::Array
+    #     is built by `self.class.new`.
+    #
+    #   @example Raw Ruby Array
+    #     int32_array = Arrow::Int32Array.new([1])
+    #     other_array = int32_array.resolve([2, 3, 4])
+    #     other_array # => Arrow::Int32Array.new([2, 3, 4])
+    #
+    # @overload resolve(other_array)
+    #
+    #   @param other_array [Arrow::Array] Another Arrow::Array.
+    #
+    #     If the given other array is an same data type array of
+    #     `self`, the given other array is returned as-is.
+    #
+    #     If the given other array isn't an same data type array of
+    #     `self`, the given other array is casted.
+    #
+    #   @example Same data type
+    #     int32_array = Arrow::Int32Array.new([1])
+    #     other_int32_array = Arrow::Int32Array.new([2, 3, 4])
+    #     other_array = int32_array.resolve(other_int32_array)
+    #     other_array.object_id == other_int32_array.object_id
+    #
+    #   @example Other data type
+    #     int32_array = Arrow::Int32Array.new([1])
+    #     other_int8_array = Arrow::Int8Array.new([2, 3, 4])
+    #     other_array = int32_array.resolve(other_int32_array)
+    #     other_array #=> Arrow::Int32Array.new([2, 3, 4])
+    #
+    # @since 4.0.0
+    def resolve(other_array)
+      if other_array.is_a?(::Array)
+        builder_class = self.class.builder_class
+        if builder_class.nil?
+          message =
+            "[array][resolve] can't build #{value_data_type} array " +
+            "from raw Ruby Array"
+          raise ArgumentError, message
+        end
+        if builder_class.buildable?([other_array])
+          other_array = builder_class.build(other_array)
+        elsif builder_class.buildable?([value_data_type, other_array])
+          other_array = builder_class.build(value_data_type, other_array)
+        else
+          message =
+            "[array][resolve] need to implement " +
+            "a feature that building #{value_data_type} array " +
+            "from raw Ruby Array"
+          raise NotImpelemented, message
+        end
+        other_array
+      elsif other_array.respond_to?(:value_data_type)
+        return other_array if value_data_type == other_array.value_data_type
+        other_array.cast(value_data_type)
+      else
+        message =
+          "[array][resolve] can't build #{value_data_type} array: " +
+          "#{other_array.inspect}"
+        raise ArgumentError, message
+      end
+    end
   end
 end

data/lib/arrow/data-type.rb

@@ -18,7 +18,7 @@
 module Arrow
   class DataType
     class << self
-      # Creates a new suitable {Arrow::DataType}.
+      # Ensure returning suitable {Arrow::DataType}.
       #
       # @overload resolve(data_type)
       #
@@ -31,17 +31,21 @@ module Arrow
       #
       # @overload resolve(name)
       #
-      #   Creates a suitable data type from type name. For example,
-      #   you can create {Arrow::BooleanDataType} from `:boolean`.
+      #   Creates a suitable data type from the given type name. For
+      #   example, you can create {Arrow::BooleanDataType} from
+      #   `:boolean`.
       #
       #   @param name [String, Symbol] The type name of the data type.
       #
+      #   @return [Arrow::DataType] A new suitable data type.
+      #
       #   @example Create a boolean data type
       #     Arrow::DataType.resolve(:boolean)
       #
       # @overload resolve(name_with_arguments)
       #
-      #   Creates a suitable data type from type name with arguments.
+      #   Creates a new suitable data type from the given type name
+      #   with arguments.
       #
       #   @param name_with_arguments [::Array<String, ...>]
       #     The type name of the data type as the first element.
@@ -51,6 +55,8 @@ module Arrow
       #     For example, {Arrow::TimestampDataType} needs unit as
       #     additional information.
       #
+      #   @return [Arrow::DataType] A new suitable data type.
+      #
       #   @example Create a boolean data type
       #     Arrow::DataType.resolve([:boolean])
       #
@@ -59,7 +65,8 @@ module Arrow
       #
       # @overload resolve(description)
       #
-      #   Creates a suitable data type from data type description.
+      #   Creates a new suitable data type from the given data type
+      #   description.
       #
       #   Data type description is a raw `Hash`. Data type description
       #   must have `:type` value. `:type` is the type of the data type.
@@ -74,6 +81,8 @@ module Arrow
       #   @option description [String, Symbol] :type The type name of
       #     the data type.
       #
+      #   @return [Arrow::DataType] A new suitable data type.
+      #
       #   @example Create a boolean data type
       #     Arrow::DataType.resolve(type: :boolean)
       #

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

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

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

@@ -50,7 +50,7 @@ module Arrow
     #   @param ordered [Boolean] Whether dictionary contents are
     #     ordered or not.
     #
-    #   @example Create a dictionary data type for {0: "Hello", 1: "World"}
+    #   @example Create a dictionary data type for `{0: "Hello", 1: "World"}`
     #     index_data_type = :int8
     #     value_data_type = :string
     #     ordered = true
@@ -91,7 +91,7 @@ module Arrow
     #   @option description [Boolean] :ordered Whether dictionary
     #     contents are ordered or not.
     #
-    #   @example Create a dictionary data type for {0: "Hello", 1: "World"}
+    #   @example Create a dictionary data type for `{0: "Hello", 1: "World"}`
     #     Arrow::DictionaryDataType.new(index_data_type: :int8,
     #                                   value_data_type: :string,
     #                                   ordered: true)

data/lib/arrow/loader.rb

@@ -82,6 +82,8 @@ module Arrow
       require "arrow/rolling-window"
       require "arrow/schema"
       require "arrow/slicer"
+      require "arrow/sort-key"
+      require "arrow/sort-options"
       require "arrow/sparse-union-data-type"
       require "arrow/struct-array"
       require "arrow/struct-array-builder"

data/lib/arrow/sort-key.rb

@@ -0,0 +1,193 @@
+# 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 SortKey
+    class << self
+      # Ensure returning suitable {Arrow::SortKey}.
+      #
+      # @overload resolve(sort_key)
+      #
+      #   Returns the given sort key itself. This is convenient to use
+      #   this method as {Arrow::SortKey} converter.
+      #
+      #   @param sort_key [Arrow::SortKey] The sort key.
+      #
+      #   @return [Arrow::SortKey] The given sort key itself.
+      #
+      # @overload resolve(name)
+      #
+      #   Creates a new suitable sort key from column name with
+      #   leading order mark. See {#initialize} for details about
+      #   order mark.
+      #
+      #   @return [Arrow::SortKey] A new suitable sort key.
+      #
+      # @overload resolve(name, order)
+      #
+      #   Creates a new suitable sort key from column name without
+      #   leading order mark and order. See {#initialize} for details.
+      #
+      #   @return [Arrow::SortKey] A new suitable sort key.
+      #
+      # @since 4.0.0
+      def resolve(name, order=nil)
+        return name if name.is_a?(self)
+        new(name, order)
+      end
+
+      # @api private
+      def try_convert(value)
+        case value
+        when Symbol, String
+          new(value.to_s, :ascending)
+        else
+          nil
+        end
+      end
+    end
+
+    alias_method :initialize_raw, :initialize
+    private :initialize_raw
+    # Creates a new {Arrow::SortKey}.
+    #
+    # @overload initialize(name)
+    #
+    #   @param name [Symbol, String] The name of the sort column.
+    #
+    #     If `name` is a String, the first character may be processed
+    #     as the "leading order mark". If the first character is `"+"`
+    #     or `"-"`, they are processed as a leading order mark. If the
+    #     first character is processed as a leading order mark, the
+    #     first character is removed from sort column name and
+    #     corresponding order is used. `"+"` uses ascending order and
+    #     `"-"` uses ascending order.
+    #
+    #     If `name` is not a String nor `name` doesn't start with the
+    #     leading order mark, sort column name is `name` as-is and
+    #     ascending order is used.
+    #
+    #   @example String without the leading order mark
+    #     key = Arrow::SortKey.new("count")
+    #     key.name  # => "count"
+    #     key.order # => Arrow::SortOrder::ASCENDING
+    #
+    #   @example String with the "+" leading order mark
+    #     key = Arrow::SortKey.new("+count")
+    #     key.name  # => "count"
+    #     key.order # => Arrow::SortOrder::ASCENDING
+    #
+    #   @example String with the "-" leading order mark
+    #     key = Arrow::SortKey.new("-count")
+    #     key.name  # => "count"
+    #     key.order # => Arrow::SortOrder::DESCENDING
+    #
+    #   @example Symbol that starts with "-"
+    #     key = Arrow::SortKey.new(:"-count")
+    #     key.name  # => "-count"
+    #     key.order # => Arrow::SortOrder::ASCENDING
+    #
+    # @overload initialize(name, order)
+    #
+    #   @param name [Symbol, String] The name of the sort column.
+    #
+    #     No leading order mark processing. The given `name` is used
+    #     as-is.
+    #
+    #   @param order [Symbol, String, Arrow::SortOrder] How to order
+    #     by this sort key.
+    #
+    #     If this is a Symbol or String, this must be `:ascending`,
+    #     `"ascending"`, `:asc`, `"asc"`, `:descending`,
+    #     `"descending"`, `:desc` or `"desc"`.
+    #
+    #   @example No leading order mark processing
+    #     key = Arrow::SortKey.new("-count", :ascending)
+    #     key.name  # => "-count"
+    #     key.order # => Arrow::SortOrder::ASCENDING
+    #
+    #   @example Order by abbreviated name with Symbol
+    #     key = Arrow::SortKey.new("count", :desc)
+    #     key.name  # => "count"
+    #     key.order # => Arrow::SortOrder::DESCENDING
+    #
+    #   @example Order by String
+    #     key = Arrow::SortKey.new("count", "descending")
+    #     key.name  # => "count"
+    #     key.order # => Arrow::SortOrder::DESCENDING
+    #
+    #   @example Order by Arrow::SortOrder
+    #     key = Arrow::SortKey.new("count", Arrow::SortOrder::DESCENDING)
+    #     key.name  # => "count"
+    #     key.order # => Arrow::SortOrder::DESCENDING
+    #
+    # @since 4.0.0
+    def initialize(name, order=nil)
+      name, order = normalize_name(name, order)
+      order = normalize_order(order) || :ascending
+      initialize_raw(name, order)
+    end
+
+    # @return [String] The string representation of this sort key. You
+    #   can use recreate {Arrow::SortKey} by
+    #   `Arrow::SortKey.new(key.to_s)`.
+    #
+    # @example Recreate Arrow::SortKey
+    #   key = Arrow::SortKey.new("-count")
+    #   key.to_s # => "-count"
+    #   key == Arrow::SortKey.new(key.to_s) # => true
+    #
+    # @since 4.0.0
+    def to_s
+      if order == SortOrder::ASCENDING
+        "+#{name}"
+      else
+        "-#{name}"
+      end
+    end
+
+    private
+    def normalize_name(name, order)
+      case name
+      when Symbol
+        return name.to_s, order
+      when String
+        return name, order if order
+        if name.start_with?("-")
+          return name[1..-1], order || :descending
+        elsif name.start_with?("+")
+          return name[1..-1], order || :ascending
+        else
+          return name, order
+        end
+      else
+        return name, order
+      end
+    end
+
+    def normalize_order(order)
+      case order
+      when :asc, "asc"
+        :ascending
+      when :desc, "desc"
+        :descending
+      else
+        order
+      end
+    end
+  end
+end

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 = "3.0.0"
+  VERSION = "4.0.0"
 
   module Version
     numbers, TAG = VERSION.split("-")

data/test/test-array.rb

@@ -168,4 +168,124 @@ class ArrayTest < Test::Unit::TestCase
                    @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

data/test/test-decimal128-data-type.rb

@@ -18,12 +18,12 @@
 class Decimal128DataTypeTest < Test::Unit::TestCase
   sub_test_case(".new") do
     test("ordered arguments") do
-      assert_equal("decimal(8, 2)",
+      assert_equal("decimal128(8, 2)",
                    Arrow::Decimal128DataType.new(8, 2).to_s)
     end
 
     test("description") do
-      assert_equal("decimal(8, 2)",
+      assert_equal("decimal128(8, 2)",
                    Arrow::Decimal128DataType.new(precision: 8,
                                                  scale: 2).to_s)
     end

data/test/test-orc.rb

@@ -118,39 +118,35 @@ class ORCTest < Test::Unit::TestCase
                        ]
                      ],
                      [
-                       "map: list<item: " +
-                       "struct<key: string, value: " +
-                       "struct<int1: int32, string1: string>>>",
+                       "map: map<string, struct<int1: int32, string1: string>>",
                        [
                          <<-MAP.chomp
 [
+  keys:
+  []
+  values:
   -- is_valid: all not null
-  -- child 0 type: string
+  -- child 0 type: int32
     []
-  -- child 1 type: struct<int1: int32, string1: string>
-    -- is_valid: all not null
-    -- child 0 type: int32
-      []
-    -- child 1 type: string
-      [],
+  -- child 1 type: string
+    [],
+  keys:
+  [
+    "chani",
+    "mauddib"
+  ]
+  values:
   -- is_valid: all not null
-  -- child 0 type: string
+  -- child 0 type: int32
+    [
+      5,
+      1
+    ]
+  -- child 1 type: string
     [
       "chani",
       "mauddib"
     ]
-  -- child 1 type: struct<int1: int32, string1: string>
-    -- is_valid: all not null
-    -- child 0 type: int32
-      [
-        5,
-        1
-      ]
-    -- child 1 type: string
-      [
-        "chani",
-        "mauddib"
-      ]
 ]
                          MAP
                        ],

data/test/test-sort-indices.rb

@@ -0,0 +1,40 @@
+# 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 SortIndicesTest < Test::Unit::TestCase
+  def setup
+    @table = Arrow::Table.new(number1: [16, -1,   2, 32, -4, -4, -8],
+                              number2: [32,  2, -16,  8,  1,  4,  1])
+  end
+
+  sub_test_case("Table") do
+    test("Symbol") do
+      assert_equal(Arrow::UInt64Array.new([6, 4, 5, 1, 2, 0, 3]),
+                   @table.sort_indices(:number1))
+    end
+
+    test("-String") do
+      assert_equal(Arrow::UInt64Array.new([3, 0, 2, 1, 4, 5, 6]),
+                   @table.sort_indices("-number1"))
+    end
+
+    test("Symbol, -String") do
+      assert_equal(Arrow::UInt64Array.new([6, 5, 4, 1, 2, 0, 3]),
+                   @table.sort_indices([:number1, "-number2"]))
+    end
+  end
+end

data/test/test-sort-key.rb

@@ -0,0 +1,81 @@
+# 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 SortKeyTest < Test::Unit::TestCase
+  sub_test_case(".resolve") do
+    test("SortKey") do
+      assert_equal(Arrow::SortKey.new("-count"),
+                   Arrow::SortKey.resolve(Arrow::SortKey.new("-count")))
+    end
+
+    test("-String") do
+      assert_equal(Arrow::SortKey.new("-count"),
+                   Arrow::SortKey.resolve("-count"))
+    end
+
+    test("Symbol, Symbol") do
+      assert_equal(Arrow::SortKey.new("-count"),
+                   Arrow::SortKey.resolve(:count, :desc))
+    end
+  end
+
+  sub_test_case("#initialize") do
+    test("String") do
+      assert_equal("+count",
+                   Arrow::SortKey.new("count").to_s)
+    end
+
+    test("+String") do
+      assert_equal("+count",
+                   Arrow::SortKey.new("+count").to_s)
+    end
+
+    test("-String") do
+      assert_equal("-count",
+                   Arrow::SortKey.new("-count").to_s)
+    end
+
+    test("Symbol") do
+      assert_equal("+-count",
+                   Arrow::SortKey.new(:"-count").to_s)
+    end
+
+    test("String, Symbol") do
+      assert_equal("--count",
+                   Arrow::SortKey.new("-count", :desc).to_s)
+    end
+
+    test("String, String") do
+      assert_equal("--count",
+                   Arrow::SortKey.new("-count", "desc").to_s)
+    end
+
+    test("String, SortOrder") do
+      assert_equal("--count",
+                   Arrow::SortKey.new("-count",
+                                      Arrow::SortOrder::DESCENDING).to_s)
+    end
+  end
+
+  sub_test_case("#to_s") do
+    test("recreatable") do
+      key = Arrow::SortKey.new("-count", :desc)
+      assert_equal(key,
+                   Arrow::SortKey.new(key.to_s))
+    end
+  end
+end

data/test/test-sort-options.rb

@@ -0,0 +1,58 @@
+# 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 SortOptionsTest < Test::Unit::TestCase
+  sub_test_case("#initialize") do
+    test("none") do
+      options = Arrow::SortOptions.new
+      assert_equal([],
+                   options.sort_keys.collect(&:to_s))
+    end
+
+    test("-String, Symbol") do
+      options = Arrow::SortOptions.new("-count", :age)
+      assert_equal(["-count", "+age"],
+                   options.sort_keys.collect(&:to_s))
+    end
+  end
+
+  sub_test_case("instance methods") do
+    setup do
+      @options = Arrow::SortOptions.new
+    end
+
+    sub_test_case("#add_sort_key") do
+      test("-String") do
+        @options.add_sort_key("-count")
+        assert_equal(["-count"],
+                     @options.sort_keys.collect(&:to_s))
+      end
+
+      test("-String, Symbol") do
+        @options.add_sort_key("-count", :desc)
+        assert_equal(["--count"],
+                     @options.sort_keys.collect(&:to_s))
+      end
+
+      test("SortKey") do
+        @options.add_sort_key(Arrow::SortKey.new("-count"))
+        assert_equal(["-count"],
+                     @options.sort_keys.collect(&:to_s))
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Apache Arrow Developers
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-25 00:00:00.000000000 Z
+date: 2021-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -254,6 +254,8 @@ files:
 - lib/arrow/rolling-window.rb
 - lib/arrow/schema.rb
 - lib/arrow/slicer.rb
+- lib/arrow/sort-key.rb
+- lib/arrow/sort-options.rb
 - lib/arrow/sparse-union-data-type.rb
 - lib/arrow/struct-array-builder.rb
 - lib/arrow/struct-array.rb
@@ -337,6 +339,9 @@ files:
 - test/test-rolling-window.rb
 - test/test-schema.rb
 - test/test-slicer.rb
+- test/test-sort-indices.rb
+- test/test-sort-key.rb
+- test/test-sort-options.rb
 - test/test-sparse-union-data-type.rb
 - test/test-struct-array-builder.rb
 - test/test-struct-array.rb
@@ -359,8 +364,8 @@ homepage: https://arrow.apache.org/
 licenses:
 - Apache-2.0
 metadata:
-  msys2_mingw_dependencies: arrow>=3.0.0
-post_install_message: 
+  msys2_mingw_dependencies: arrow>=4.0.0
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -375,85 +380,88 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Red Arrow is the Ruby bindings of Apache Arrow
 test_files:
-- test/test-decimal256-array-builder.rb
-- test/test-time64-data-type.rb
-- test/test-feather.rb
-- test/test-decimal128.rb
-- test/test-struct-array.rb
-- test/test-data-type.rb
-- test/test-list-data-type.rb
-- test/test-dense-union-data-type.rb
-- test/test-decimal256-array.rb
+- test/fixture/TestOrcFile.test1.orc
+- test/fixture/float-integer.csv
+- test/fixture/integer-float.csv
+- test/fixture/null-with-double-quote.csv
+- test/fixture/null-without-double-quote.csv
+- test/fixture/with-header-float.csv
+- test/fixture/with-header.csv
+- test/fixture/without-header-float.csv
+- test/fixture/without-header.csv
+- test/helper/fixture.rb
+- test/helper/omittable.rb
 - test/helper.rb
-- test/test-record-batch.rb
-- test/test-table.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-timestamp-array.rb
-- test/test-date32-array.rb
 - test/test-array-builder.rb
+- test/test-array.rb
+- test/test-bigdecimal.rb
+- test/test-buffer.rb
+- test/test-chunked-array.rb
+- test/test-column.rb
+- test/test-csv-loader.rb
+- test/test-data-type.rb
+- test/test-date32-array.rb
 - test/test-date64-array.rb
-- test/test-record-batch-file-reader.rb
+- test/test-decimal128-array-builder.rb
+- test/test-decimal128-array.rb
 - test/test-decimal128-data-type.rb
-- test/test-time.rb
-- test/test-timestamp-data-type.rb
+- test/test-decimal128.rb
+- test/test-decimal256-array-builder.rb
+- test/test-decimal256-array.rb
+- test/test-decimal256-data-type.rb
 - test/test-decimal256.rb
+- test/test-dense-union-data-type.rb
 - test/test-dictionary-array.rb
-- test/test-fixed-size-binary-array-builder.rb
-- test/test-column.rb
+- test/test-dictionary-data-type.rb
+- test/test-feather.rb
 - test/test-field.rb
-- test/test-decimal128-array.rb
-- test/test-csv-loader.rb
-- test/test-bigdecimal.rb
+- test/test-file-output-stream.rb
+- test/test-fixed-size-binary-array-builder.rb
 - test/test-fixed-size-binary-array.rb
-- test/test-list-array.rb
-- test/test-decimal256-data-type.rb
-- test/test-time64-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-null-array.rb
-- test/test-time32-data-type.rb
-- test/test-struct-data-type.rb
 - test/test-group.rb
-- test/test-buffer.rb
-- test/values/test-struct-array.rb
-- test/values/test-basic-arrays.rb
-- test/values/test-list-array.rb
-- test/values/test-dense-union-array.rb
-- test/values/test-sparse-union-array.rb
-- test/test-slicer.rb
 - test/test-list-array-builder.rb
-- test/test-sparse-union-data-type.rb
+- test/test-list-array.rb
+- test/test-list-data-type.rb
+- test/test-null-array.rb
+- test/test-orc.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-file-output-stream.rb
+- test/test-record-batch-file-reader.rb
 - test/test-record-batch-iterator.rb
-- test/test-tensor.rb
-- test/test-decimal128-array-builder.rb
-- test/test-chunked-array.rb
+- test/test-record-batch.rb
+- test/test-rolling-window.rb
 - test/test-schema.rb
+- test/test-slicer.rb
+- test/test-sort-indices.rb
+- test/test-sort-key.rb
+- test/test-sort-options.rb
+- test/test-sparse-union-data-type.rb
 - test/test-struct-array-builder.rb
-- test/helper/fixture.rb
-- test/helper/omittable.rb
+- test/test-struct-array.rb
+- test/test-struct-data-type.rb
+- test/test-table.rb
+- test/test-tensor.rb
+- test/test-time.rb
 - test/test-time32-array.rb
+- test/test-time32-data-type.rb
+- test/test-time64-array.rb
+- test/test-time64-data-type.rb
+- test/test-timestamp-array.rb
+- test/test-timestamp-data-type.rb
+- test/values/test-basic-arrays.rb
+- test/values/test-dense-union-array.rb
+- test/values/test-list-array.rb
+- test/values/test-sparse-union-array.rb
+- test/values/test-struct-array.rb