red-arrow 1.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a45e003f0a453f175b1dbfc81c1fcf092cbfe964dd43e44d7b16e2087834ef5d
-  data.tar.gz: 5d1dc1d87a821d1ac4c49603d1d92d723230eb1f8a7cdd540dafe3715a53c12e
+  metadata.gz: df66b2dac421ab800bd00510e4a13e250646d1f1c27541f2ca44cd04be38a3ba
+  data.tar.gz: 3c39ec6a1a3ee48708a28583c125d96f9195e9973f6f2f3707cd923eca915329
 SHA512:
-  metadata.gz: 85329e05ae20268d44a9ffff5fb3278263e5b77deda6f03fda31595b117252b7970fd17328ce2650c8650895a1813a1fb95799d3331a312bce2c276f3e5d55a4
-  data.tar.gz: fe90b0ff0dfb9b9126765818d54f7d4d203e6c72ab53dfb2680a48dc474fef09b8ed3f0553f3c1fe110d500d625ab2300563c3e4169403326c63c6bf27f33a5f
+  metadata.gz: 9ebf50ffecfdea79140b158f5aeea0cc3bb63403e405bcbba2b34e288b8575df3df859b8f46eb12e26199e566237016d0e3907acc1d7c0d16e82d638c7bdce2e
+  data.tar.gz: 1ff1389d28db025efd82c87e9f85cfb7e3bce21abe85a1b943ca8536bbc1015b0015c05ab45e5d9a35914034a673da0bbc59f8211bb0b620ee4a7487f5fec413

data/ext/arrow/converters.hpp

@@ -212,7 +212,17 @@ namespace red_arrow {
 
     inline VALUE convert(const arrow::Decimal128Array& array,
                          const int64_t i) {
-      decimal_buffer_ = array.FormatValue(i);
+      return convert_decimal(std::move(array.FormatValue(i)));
+    }
+
+    inline VALUE convert(const arrow::Decimal256Array& array,
+                         const int64_t i) {
+      return convert_decimal(std::move(array.FormatValue(i)));
+    }
+
+  private:
+    inline VALUE convert_decimal(std::string&& value) {
+      decimal_buffer_ = value;
       return rb_funcall(rb_cObject,
                         id_BigDecimal,
                         1,
@@ -221,7 +231,6 @@ namespace red_arrow {
                                        rb_ascii8bit_encoding()));
     }
 
-  private:
     std::string decimal_buffer_;
     ListArrayValueConverter* list_array_value_converter_;
     StructArrayValueConverter* struct_array_value_converter_;
@@ -289,6 +298,7 @@ namespace red_arrow {
     VISIT(DenseUnion)
     VISIT(Dictionary)
     VISIT(Decimal128)
+    VISIT(Decimal256)
     // TODO
     // VISIT(Extension)
 
@@ -393,6 +403,7 @@ namespace red_arrow {
     VISIT(DenseUnion)
     VISIT(Dictionary)
     VISIT(Decimal128)
+    VISIT(Decimal256)
     // TODO
     // VISIT(Extension)
 
@@ -485,6 +496,7 @@ namespace red_arrow {
     VISIT(DenseUnion)
     VISIT(Dictionary)
     VISIT(Decimal128)
+    VISIT(Decimal256)
     // TODO
     // VISIT(Extension)
 
@@ -609,6 +621,7 @@ namespace red_arrow {
     VISIT(DenseUnion)
     VISIT(Dictionary)
     VISIT(Decimal128)
+    VISIT(Decimal256)
     // TODO
     // VISIT(Extension)
 

data/ext/arrow/extconf.rb

@@ -16,7 +16,8 @@
 # under the License.
 
 require "extpp"
-require "mkmf-gnome2"
+require "mkmf-gnome"
+require_relative "../../lib/arrow/version"
 
 arrow_pkg_config_path = ENV["ARROW_PKG_CONFIG_PATH"]
 if arrow_pkg_config_path
@@ -24,7 +25,12 @@ if arrow_pkg_config_path
   ENV["PKG_CONFIG_PATH"] = pkg_config_paths.join(File::PATH_SEPARATOR)
 end
 
-unless required_pkg_config_package("arrow",
+unless required_pkg_config_package([
+                                     "arrow",
+                                     Arrow::Version::MAJOR,
+                                     Arrow::Version::MINOR,
+                                     Arrow::Version::MICRO,
+                                   ],
                                    debian: "libarrow-dev",
                                    redhat: "arrow-devel",
                                    homebrew: "apache-arrow",
@@ -32,7 +38,12 @@ unless required_pkg_config_package("arrow",
   exit(false)
 end
 
-unless required_pkg_config_package("arrow-glib",
+unless required_pkg_config_package([
+                                     "arrow-glib",
+                                     Arrow::Version::MAJOR,
+                                     Arrow::Version::MINOR,
+                                     Arrow::Version::MICRO,
+                                   ],
                                    debian: "libarrow-glib-dev",
                                    redhat: "arrow-glib-devel",
                                    homebrew: "apache-arrow-glib",

data/ext/arrow/raw-records.cpp

@@ -104,6 +104,7 @@ namespace red_arrow {
       VISIT(DenseUnion)
       VISIT(Dictionary)
       VISIT(Decimal128)
+      VISIT(Decimal256)
       // TODO
       // VISIT(Extension)
 

data/ext/arrow/values.cpp

@@ -85,6 +85,7 @@ namespace red_arrow {
       VISIT(DenseUnion)
       VISIT(Dictionary)
       VISIT(Decimal128)
+      VISIT(Decimal256)
       // TODO
       // VISIT(Extension)
 

data/lib/arrow/array-builder.rb

@@ -115,6 +115,17 @@ module Arrow
             builder: Date32ArrayBuilder.new,
             detected: true,
           }
+        when BigDecimal
+          if value.to_arrow.is_a?(Decimal128)
+            {
+              builder: Decimal128ArrayBuilder.new,
+            }
+          else
+            {
+              builder: Decimal256ArrayBuilder.new,
+              detected: true,
+            }
+          end
         when ::Array
           sub_builder_info = nil
           value.each do |sub_value|
@@ -194,11 +205,5 @@ module Arrow
         end
       end
     end
-
-    def append_nulls(n)
-      n.times do
-        append_null
-      end
-    end
   end
 end

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/bigdecimal-extension.rb

@@ -19,6 +19,10 @@ require "bigdecimal"
 
 class BigDecimal
   def to_arrow
-    Arrow::Decimal128.new(to_s)
+    if precision <= Arrow::Decimal128DataType::MAX_PRECISION
+      Arrow::Decimal128.new(to_s)
+    else
+      Arrow::Decimal256.new(to_s)
+    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/decimal128-array-builder.rb

@@ -26,36 +26,32 @@ module Arrow
 
     alias_method :append_value_raw, :append_value
     def append_value(value)
-      case value
-      when nil
-        return append_null
-      when String
-        value = Decimal128.new(value)
-      when Float
-        value = Decimal128.new(value.to_s)
-      when BigDecimal
-        value = value.to_arrow
-      end
-      append_value_raw(value)
+      append_value_raw(normalize_value(value))
     end
 
+    alias_method :append_values_raw, :append_values
     def append_values(values, is_valids=nil)
-      if is_valids
-        is_valids.each_with_index do |is_valid, i|
-          if is_valid
-            append_value(values[i])
-          else
-            append_null
-          end
+      if values.is_a?(::Array)
+        values = values.collect do |value|
+          normalize_value(value)
         end
+        append_values_raw(values, is_valids)
       else
-        values.each do |value|
-          if value.nil?
-            append_null
-          else
-            append_value(value)
-          end
-        end
+        append_values_packed(values, is_valids)
+      end
+    end
+
+    private
+    def normalize_value(value)
+      case value
+      when String
+        Decimal128.new(value)
+      when Float
+        Decimal128.new(value.to_s)
+      when BigDecimal
+        Decimal128.new(value.to_s)
+      else
+        value
       end
     end
   end

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

@@ -17,6 +17,8 @@
 
 module Arrow
   class Decimal128DataType
+    MAX_PRECISION = max_precision
+
     alias_method :initialize_raw, :initialize
     private :initialize_raw
 

data/lib/arrow/decimal128.rb

@@ -38,5 +38,23 @@ module Arrow
         to_s_raw
       end
     end
+
+    alias_method :abs!, :abs
+
+    # @since 3.0.0
+    def abs
+      copied = dup
+      copied.abs!
+      copied
+    end
+
+    alias_method :negate!, :negate
+
+    # @since 3.0.0
+    def negate
+      copied = dup
+      copied.negate!
+      copied
+    end
   end
 end