red-arrow 3.0.0 → 6.0.0

data/lib/arrow/record-batch-reader.rb

@@ -0,0 +1,41 @@
+# 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 RecordBatchReader
+    class << self
+      # @api private
+      def try_convert(value)
+        case value
+        when ::Array
+          return nil if value.empty?
+          if value.all? {|v| v.is_a?(RecordBatch)}
+            new(value)
+          else
+            nil
+          end
+        when RecordBatch
+          new([value])
+        when Table
+          TableBatchReader.new(value)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/arrow/record-batch.rb

@@ -50,8 +50,6 @@ module Arrow
     alias_method :size, :n_rows
     alias_method :length, :n_rows
 
-    alias_method :[], :find_column
-
     # Converts the record batch to {Arrow::Table}.
     #
     # @return [Arrow::Table]

data/lib/arrow/scalar.rb

@@ -0,0 +1,32 @@
+# 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 Scalar
+    # @param other [Arrow::Scalar] The scalar 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_scalar?(other, options=nil)
+      equal_options(other, options)
+    end
+  end
+end

data/lib/arrow/slicer.rb

@@ -16,9 +16,6 @@
 # under the License.
 
 module Arrow
-  # Experimental
-  #
-  # TODO: Almost codes should be implemented in Apache Arrow C++.
   class Slicer
     def initialize(table)
       @table = table
@@ -43,6 +40,21 @@ module Arrow
       super
     end
 
+    module Helper
+      class << self
+        def ensure_boolean(column)
+          case column.data_type
+          when Arrow::BooleanDataType
+            column.data
+          else
+            options = CastOptions.new
+            options.to_data_type = Arrow::BooleanDataType.new
+            Function.find("cast").execute([column.data], options).value
+          end
+        end
+      end
+    end
+
     class Condition
       def evaluate
         message = "Slicer::Condition must define \#evaluate: #{inspect}"
@@ -69,43 +81,28 @@ module Arrow
       end
 
       def evaluate
-        values1 = @condition1.evaluate.each
-        values2 = @condition2.evaluate.each
-        raw_array = []
-        begin
-          loop do
-            value1 = values1.next
-            value2 = values2.next
-            if value1.nil? or value2.nil?
-              raw_array << nil
-            else
-              raw_array << evaluate_value(value1, value2)
-            end
-          end
-        rescue StopIteration
-        end
-        BooleanArray.new(raw_array)
+        function.execute([@condition1.evaluate, @condition2.evaluate]).value
       end
     end
 
     class AndCondition < LogicalCondition
       private
-      def evaluate_value(value1, value2)
-        value1 and value2
+      def function
+        Function.find("and")
       end
     end
 
     class OrCondition < LogicalCondition
       private
-      def evaluate_value(value1, value2)
-        value1 or value2
+      def function
+        Function.find("or")
       end
     end
 
     class XorCondition < LogicalCondition
       private
-      def evaluate_value(value1, value2)
-        value1 ^ value2
+      def function
+        Function.find("xor")
       end
     end
 
@@ -115,21 +112,7 @@ module Arrow
       end
 
       def evaluate
-        data = @column.data
-
-        case @column.data_type
-        when BooleanDataType
-          data
-        else
-          if data.n_chunks == 1
-            data.get_chunk(0).cast(BooleanDataType.new, nil)
-          else
-            arrays = data.each_chunk.collect do |chunk|
-              chunk.cast(BooleanDataType.new, nil)
-            end
-            ChunkedArray.new(arrays)
-          end
-        end
+        Helper.ensure_boolean(@column)
       end
 
       def !@
@@ -187,23 +170,8 @@ module Arrow
       end
 
       def evaluate
-        data = @column.data
-        raw_array = []
-        data.each_chunk do |chunk|
-          if chunk.is_a?(BooleanArray)
-            boolean_array = chunk
-          else
-            boolean_array = chunk.cast(BooleanDataType.new, nil)
-          end
-          boolean_array.each do |value|
-            if value.nil?
-              raw_array << value
-            else
-              raw_array << !value
-            end
-          end
-        end
-        BooleanArray.new(raw_array)
+        data = Helper.ensure_boolean(@column)
+        Function.find("invert").execute([data]).value
       end
 
       def !@
@@ -222,19 +190,10 @@ module Arrow
       end
 
       def evaluate
-        case @value
-        when nil
-          raw_array = @column.collect(&:nil?)
-          BooleanArray.new(raw_array)
+        if @value.nil?
+          Function.find("is_null").execute([@column.data]).value
         else
-          raw_array = @column.collect do |value|
-            if value.nil?
-              nil
-            else
-              @value == value
-            end
-          end
-          BooleanArray.new(raw_array)
+          Function.find("equal").execute([@column.data, @value]).value
         end
       end
     end
@@ -250,25 +209,10 @@ module Arrow
       end
 
       def evaluate
-        case @value
-        when nil
-          if @column.n_nulls.zero?
-            raw_array = [true] * @column.n_rows
-          else
-            raw_array = @column.n_rows.times.collect do |i|
-              @column.valid?(i)
-            end
-          end
-          BooleanArray.new(raw_array)
+        if @value.nil?
+          Function.find("is_valid").execute([@column.data]).value
         else
-          raw_array = @column.collect do |value|
-            if value.nil?
-              nil
-            else
-              @value != value
-            end
-          end
-          BooleanArray.new(raw_array)
+          Function.find("not_equal").execute([@column.data, @value]).value
         end
       end
     end
@@ -284,14 +228,7 @@ module Arrow
       end
 
       def evaluate
-        raw_array = @column.collect do |value|
-          if value.nil?
-            nil
-          else
-            @value > value
-          end
-        end
-        BooleanArray.new(raw_array)
+        Function.find("less").execute([@column.data, @value]).value
       end
     end
 
@@ -306,14 +243,7 @@ module Arrow
       end
 
       def evaluate
-        raw_array = @column.collect do |value|
-          if value.nil?
-            nil
-          else
-            @value >= value
-          end
-        end
-        BooleanArray.new(raw_array)
+        Function.find("less_equal").execute([@column.data, @value]).value
       end
     end
 
@@ -328,14 +258,7 @@ module Arrow
       end
 
       def evaluate
-        raw_array = @column.collect do |value|
-          if value.nil?
-            nil
-          else
-            @value < value
-          end
-        end
-        BooleanArray.new(raw_array)
+        Function.find("greater").execute([@column.data, @value]).value
       end
     end
 
@@ -350,14 +273,7 @@ module Arrow
       end
 
       def evaluate
-        raw_array = @column.collect do |value|
-          if value.nil?
-            nil
-          else
-            @value <= value
-          end
-        end
-        BooleanArray.new(raw_array)
+        Function.find("greater_equal").execute([@column.data, @value]).value
       end
     end
 
@@ -372,18 +288,10 @@ module Arrow
       end
 
       def evaluate
-        values_index = {}
-        @values.each do |value|
-          values_index[value] = true
-        end
-        raw_array = @column.collect do |value|
-          if value.nil?
-            nil
-          else
-            values_index.key?(value)
-          end
-        end
-        BooleanArray.new(raw_array)
+        values = @values
+        values = Array.new(values) unless values.is_a?(Array)
+        options = SetLookupOptions.new(values)
+        Function.find("is_in").execute([@column.data], options).value
       end
     end
 
@@ -398,18 +306,11 @@ module Arrow
       end
 
       def evaluate
-        values_index = {}
-        @values.each do |value|
-          values_index[value] = true
-        end
-        raw_array = @column.collect do |value|
-          if value.nil?
-            nil
-          else
-            not values_index.key?(value)
-          end
-        end
-        BooleanArray.new(raw_array)
+        values = @values
+        values = Array.new(values) unless values.is_a?(Array)
+        options = SetLookupOptions.new(values)
+        booleans = Function.find("is_in").execute([@column.data], options).value
+        Function.find("invert").execute([booleans]).value
       end
     end
 

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