red-arrow 2.0.0 → 5.0.0

data/lib/arrow/array.rb

@@ -55,6 +55,18 @@ module Arrow
       end
     end
 
+    # @param other [Arrow::Array] The array to be compared.
+    # @param options [Arrow::EqualOptions, Hash] (nil)
+    #   The options to custom how to compare.
+    #
+    # @return [Boolean]
+    #   `true` if both of them have the same data, `false` otherwise.
+    #
+    # @since 5.0.0
+    def equal_array?(other, options=nil)
+      equal_options(other, options)
+    end
+
     def each
       return to_enum(__method__) unless block_given?
 
@@ -100,5 +112,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/buffer.rb

@@ -17,12 +17,16 @@
 
 module Arrow
   class Buffer
-    alias_method :initialize_raw, :initialize
-    private :initialize_raw
-
-    def initialize(data)
-      @data = data
-      initialize_raw(data)
+    class << self
+      # @api private
+      def try_convert(value)
+        case value
+        when String
+          new(value)
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/arrow/constructor-arguments-gc-guardable.rb

@@ -0,0 +1,25 @@
+# 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
+  module ConstructorArgumentsGCGuardable
+    def initialize(*args)
+      super
+      @arguments = args
+    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/datum.rb

@@ -0,0 +1,98 @@
+# 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 Datum
+    class << self
+      # @api private
+      def try_convert(value)
+        case value
+        when Array
+          ArrayDatum.new(value)
+        when ChunkedArray
+          ChunkedArrayDatum.new(value)
+        when Scalar
+          ScalarDatum.new(value)
+        when ::Array
+          ArrayDatum.new(ArrayBuilder.build(value))
+        when Integer
+          case value
+          when (0..((2 ** 8) - 1))
+            try_convert(UInt8Scalar.new(value))
+          when ((-(2 ** 7))..((2 ** 7) - 1))
+            try_convert(Int8Scalar.new(value))
+          when (0..((2 ** 16) - 1))
+            try_convert(UInt16Scalar.new(value))
+          when ((-(2 ** 15))..((2 ** 15) - 1))
+            try_convert(Int16Scalar.new(value))
+          when (0..((2 ** 32) - 1))
+            try_convert(UInt32Scalar.new(value))
+          when ((-(2 ** 31))..((2 ** 31) - 1))
+            try_convert(Int32Scalar.new(value))
+          when (0..((2 ** 64) - 1))
+            try_convert(UInt64Scalar.new(value))
+          when ((-(2 ** 63))..((2 ** 63) - 1))
+            try_convert(Int64Scalar.new(value))
+          else
+            nil
+          end
+        when Float
+          try_convert(DoubleScalar.new(value))
+        when true, false
+          try_convert(BooleanScalar.new(value))
+        when String
+          if value.ascii_only? or value.encoding == Encoding::UTF_8
+            if value.bytesize <= ((2 ** 31) - 1)
+              try_convert(StringScalar.new(value))
+            else
+              try_convert(LargeStringScalar.new(value))
+            end
+          else
+            if value.bytesize <= ((2 ** 31) - 1)
+              try_convert(BinaryScalar.new(value))
+            else
+              try_convert(LargeBinaryScalar.new(value))
+            end
+          end
+        when Date
+          date32_value = (value - Date32ArrayBuilder::UNIX_EPOCH).to_i
+          try_convert(Date32Scalar.new(date32_value))
+        when Time
+          case value.unit
+          when TimeUnit::SECOND, TimeUnit::MILLI
+            data_type = Time32DataType.new(value.unit)
+            scalar_class = Time32Scalar
+          else
+            data_type = Time64DataType.new(value.unit)
+            scalar_class = Time64Scalar
+          end
+          try_convert(scalar_class.new(data_type, value.value))
+        when ::Time
+          data_type = TimestampDataType.new(:nano)
+          timestamp_value = value.to_i * 1_000_000_000 + value.nsec
+          try_convert(TimestampScalar.new(data_type, timestamp_value))
+        when Decimal128
+          data_type = TimestampDataType.new(:nano)
+          timestamp_value = value.to_i * 1_000_000_000 + value.nsec
+          try_convert(Decimal128Scalar.new(data_type, timestamp_value))
+        else
+          nil
+        end
+      end
+    end
+  end
+end

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