red-arrow 6.0.1 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 853f00543077ecc6ecbc5dcca0f535eda624ece16e2f74bb5ec966f435d60137
-  data.tar.gz: 8e6ea3a343fb7977729a004f61789c5f579b0d2a3c0823faedc4c10425eaec56
+  metadata.gz: cee7217ce22a2c2d7a20bbe073ffe41efbab3d9628cfdc0e19e077acb4965557
+  data.tar.gz: da14c7fd57bf63294fbe46f74bb286b0d6e26dafaa80b977d11639c275dbd677
 SHA512:
-  metadata.gz: cb6de71e011620648821b4b13081386f5ad5a7e77ca7be26554c956a2f1d97ac488ad7f14bf289656fa15504600243fd4e3ba16068d355d6e1559a02a8e1c56f
-  data.tar.gz: 5e1ec7c8e1d306d5c72c282447a23c0b58674ee64f74c6d230834ba495265560a22953e489009bcecff9baa8c49816e5c8e431a1c1c5557cd2bac39a3696df02
+  metadata.gz: 52e22fdcc86f32f0443a6335099ce510840dfae9134bb4ffe6d51bfcbfdc2d66f87bbe29cd46a7af670077add2d12786474eaa3a716a27dc161fcd69b7c40974
+  data.tar.gz: 23b84e6766953cc89e8502043065dfdcf0c6a83ef1f29feae2a85e6ec3f7e01f0800f975eeb38076b255688a818984b9ae5eca2da483b96e42c5dd132089355a

data/Gemfile

@@ -20,3 +20,13 @@
 source "https://rubygems.org/"
 
 gemspec
+
+gem "benchmark-driver"
+gem "bundler"
+gem "faker"
+gem "fiddle", ">= 1.0.9"
+gem "rake"
+gem "redcarpet"
+gem "test-unit"
+gem "webrick"
+gem "yard"

data/ext/arrow/extconf.rb

@@ -28,7 +28,7 @@ end
 checking_for(checking_message("Homebrew")) do
   platform = NativePackageInstaller::Platform.detect
   if platform.is_a?(NativePackageInstaller::Platform::Homebrew)
-    openssl_prefix = `brew --prefix openssl@1.1`.chomp
+    openssl_prefix = `brew --prefix openssl`.chomp
     unless openssl_prefix.empty?
       PKGConfig.add_path("#{openssl_prefix}/lib/pkgconfig")
     end

data/lib/arrow/datum.rb

@@ -27,6 +27,8 @@ module Arrow
           ArrayDatum.new(value)
         when ChunkedArray
           ChunkedArrayDatum.new(value)
+        when Column
+          ChunkedArrayDatum.new(value.data)
         when Scalar
           ScalarDatum.new(value)
         when ::Array

data/lib/arrow/function.rb

@@ -0,0 +1,52 @@
+# 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 Function
+    alias_method :execute_raw, :execute
+    def execute(args, options=nil, context=nil)
+      options = resolve_options(options)
+      execute_raw(args, options, context)
+    end
+    alias_method :call, :execute
+
+    private
+    def resolve_options(options)
+      return nil if options.nil?
+      return options if options.is_a?(FunctionOptions)
+
+      arrow_options_class = options_type&.to_class
+      if arrow_options_class
+        if arrow_options_class.respond_to?(:try_convert)
+          arrow_options = arrow_options_class.try_convert(options)
+          return arrow_options if arrow_options
+        end
+        arrow_options = (default_options || arrow_options_class.new)
+      else
+        arrow_options = default_options
+      end
+      return arrow_options if arrow_options.nil?
+
+      options.each do |key, value|
+        setter = :"#{key}="
+        next unless arrow_options.respond_to?(setter)
+        arrow_options.__send__(setter, value)
+      end
+      arrow_options
+    end
+  end
+end

data/lib/arrow/loader.rb

@@ -30,6 +30,7 @@ module Arrow
       require_libraries
       require_extension_library
       gc_guard
+      self.class.start_callback_dispatch_thread
     end
 
     def require_libraries
@@ -76,6 +77,7 @@ module Arrow
       require "arrow/file-system"
       require "arrow/fixed-size-binary-array"
       require "arrow/fixed-size-binary-array-builder"
+      require "arrow/function"
       require "arrow/group"
       require "arrow/list-array-builder"
       require "arrow/list-data-type"
@@ -93,6 +95,7 @@ module Arrow
       require "arrow/record-batch-reader"
       require "arrow/record-batch-stream-reader"
       require "arrow/rolling-window"
+      require "arrow/s3-global-options"
       require "arrow/scalar"
       require "arrow/schema"
       require "arrow/slicer"
@@ -212,5 +215,16 @@ module Arrow
         super
       end
     end
+
+    def prepare_function_info_lock_gvl(function_info, klass)
+      super
+      case klass.name
+      when "Arrow::RecordBatchFileReader"
+        case function_info.name
+        when "new"
+          function_info.lock_gvl_default = false
+        end
+      end
+    end
   end
 end

data/lib/arrow/s3-global-options.rb

@@ -0,0 +1,38 @@
+# 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 S3GlobalOptions
+    class << self
+      # @api private
+      def try_convert(value)
+        case value
+        when Hash
+          options = new
+          value.each do |k, v|
+            setter = :"#{k}="
+            return unless options.respond_to?(setter)
+            options.__send__(setter, v)
+          end
+          options
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/arrow/sort-key.rb

@@ -29,25 +29,26 @@ module Arrow
       #
       #   @return [Arrow::SortKey] The given sort key itself.
       #
-      # @overload resolve(name)
+      # @overload resolve(target)
       #
-      #   Creates a new suitable sort key from column name with
-      #   leading order mark. See {#initialize} for details about
+      #   Creates a new suitable sort key from column name or dot path
+      #   with leading order mark. See {#initialize} for details about
       #   order mark.
       #
       #   @return [Arrow::SortKey] A new suitable sort key.
       #
-      # @overload resolve(name, order)
+      # @overload resolve(target, order)
       #
-      #   Creates a new suitable sort key from column name without
-      #   leading order mark and order. See {#initialize} for details.
+      #   Creates a new suitable sort key from column name or dot path
+      #   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)
+      def resolve(target, order=nil)
+        return target if target.is_a?(self)
+        new(target, order)
       end
 
       # @api private
@@ -65,47 +66,49 @@ module Arrow
     private :initialize_raw
     # Creates a new {Arrow::SortKey}.
     #
-    # @overload initialize(name)
+    # @overload initialize(target)
     #
-    #   @param name [Symbol, String] The name of the sort column.
+    #   @param target [Symbol, String] The name or dot path 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 `target` 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
+    #     target 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
+    #     If `target` is not a String nor `target` doesn't start with the
+    #     leading order mark, sort column target is `target` 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
+    #     key.target # => "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
+    #     key.target # => "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
+    #     key.target # => "count"
+    #     key.order  # => Arrow::SortOrder::DESCENDING
     #
     #   @example Symbol that starts with "-"
     #     key = Arrow::SortKey.new(:"-count")
-    #     key.name  # => "-count"
-    #     key.order # => Arrow::SortOrder::ASCENDING
+    #     key.target # => "-count"
+    #     key.order  # => Arrow::SortOrder::ASCENDING
     #
-    # @overload initialize(name, order)
+    # @overload initialize(target, order)
     #
-    #   @param name [Symbol, String] The name of the sort column.
+    #   @param target [Symbol, String] The name or dot path of the
+    #     sort column.
     #
-    #     No leading order mark processing. The given `name` is used
+    #     No leading order mark processing. The given `target` is used
     #     as-is.
     #
     #   @param order [Symbol, String, Arrow::SortOrder] How to order
@@ -117,29 +120,29 @@ module Arrow
     #
     #   @example No leading order mark processing
     #     key = Arrow::SortKey.new("-count", :ascending)
-    #     key.name  # => "-count"
-    #     key.order # => Arrow::SortOrder::ASCENDING
+    #     key.target # => "-count"
+    #     key.order  # => Arrow::SortOrder::ASCENDING
     #
-    #   @example Order by abbreviated name with Symbol
+    #   @example Order by abbreviated target with Symbol
     #     key = Arrow::SortKey.new("count", :desc)
-    #     key.name  # => "count"
-    #     key.order # => Arrow::SortOrder::DESCENDING
+    #     key.target # => "count"
+    #     key.order  # => Arrow::SortOrder::DESCENDING
     #
     #   @example Order by String
     #     key = Arrow::SortKey.new("count", "descending")
-    #     key.name  # => "count"
-    #     key.order # => Arrow::SortOrder::DESCENDING
+    #     key.target # => "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
+    #     key.target # => "count"
+    #     key.order  # => Arrow::SortOrder::DESCENDING
     #
     # @since 4.0.0
-    def initialize(name, order=nil)
-      name, order = normalize_name(name, order)
+    def initialize(target, order=nil)
+      target, order = normalize_target(target, order)
       order = normalize_order(order) || :ascending
-      initialize_raw(name, order)
+      initialize_raw(target, order)
     end
 
     # @return [String] The string representation of this sort key. You
@@ -154,28 +157,31 @@ module Arrow
     # @since 4.0.0
     def to_s
       if order == SortOrder::ASCENDING
-        "+#{name}"
+        "+#{target}"
       else
-        "-#{name}"
+        "-#{target}"
       end
     end
 
+    # For backward compatibility
+    alias_method :name, :target
+
     private
-    def normalize_name(name, order)
-      case name
+    def normalize_target(target, order)
+      case target
       when Symbol
-        return name.to_s, order
+        return target.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
+        return target, order if order
+        if target.start_with?("-")
+          return target[1..-1], order || :descending
+        elsif target.start_with?("+")
+          return target[1..-1], order || :ascending
         else
-          return name, order
+          return target, order
         end
       else
-        return name, order
+        return target, order
       end
     end
 

data/lib/arrow/sort-options.rb

@@ -78,20 +78,20 @@ module Arrow
     #     options.add_sort_key(Arrow::SortKey.new(:price, :descending))
     #     options.sort_keys.collect(&:to_s) # => ["-price"]
     #
-    # @overload add_sort_key(name)
+    # @overload add_sort_key(target)
     #
-    #   @param name [Symbol, String] The sort key name to be
-    #     added. See also {Arrow::SortKey#initialize} for the leading
-    #     order mark for String name.
+    #   @param target [Symbol, String] The sort key name or dot path
+    #     to be added. See also {Arrow::SortKey#initialize} for the
+    #     leading order mark for `String` target.
     #
     #   @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)
+    # @overload add_sort_key(target, order)
     #
-    #   @param name [Symbol, String] The sort key name.
+    #   @param target [Symbol, String] The sort key name or dot path.
     #
     #   @param order [Symbol, String, Arrow::SortOrder] The sort
     #     order. See {Arrow::SortKey#initialize} for details.
@@ -102,8 +102,8 @@ module Arrow
     #     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))
+    def add_sort_key(target, order=nil)
+      add_sort_key_raw(SortKey.resolve(target, order))
     end
   end
 end

data/lib/arrow/table-loader.rb

@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require "uri"
+require "open-uri"
 
 module Arrow
   class TableLoader
@@ -34,30 +34,47 @@ module Arrow
 
     def load
       if @input.is_a?(URI)
-        custom_load_method = "load_from_uri"
+        custom_load_method_candidates = []
+        if @input.scheme
+          custom_load_method_candidates << "load_from_uri_#{@input.scheme}"
+        end
+        custom_load_method_candidates << "load_from_uri"
       elsif @input.is_a?(String) and ::File.directory?(@input)
-        custom_load_method = "load_from_directory"
+        custom_load_method_candidates = ["load_from_directory"]
       else
-        custom_load_method = "load_from_file"
+        custom_load_method_candidates = ["load_from_file"]
       end
-      unless respond_to?(custom_load_method, true)
-        available_schemes = []
-        (methods(true) | private_methods(true)).each do |name|
-          match_data = /\Aload_from_/.match(name.to_s)
-          if match_data
-            available_schemes << match_data.post_match
-          end
+      custom_load_method_candidates.each do |custom_load_method|
+        next unless respond_to?(custom_load_method, true)
+        return __send__(custom_load_method)
+      end
+      available_schemes = []
+      (methods(true) | private_methods(true)).each do |name|
+        match_data = /\Aload_from_/.match(name.to_s)
+        if match_data
+          available_schemes << match_data.post_match
         end
-        message = "Arrow::Table load source must be one of ["
-        message << available_schemes.join(", ")
-        message << "]: #{@input.inspect}"
-        raise ArgumentError, message
       end
-      __send__(custom_load_method)
+      message = "Arrow::Table load source must be one of ["
+      message << available_schemes.join(", ")
+      message << "]: #{@input.inspect}"
+      raise ArgumentError, message
     end
 
     private
+    def load_from_uri_http
+      load_by_reader
+    end
+
+    def load_from_uri_https
+      load_by_reader
+    end
+
     def load_from_file
+      load_by_reader
+    end
+
+    def load_by_reader
       format = @options[:format]
       custom_load_method = "load_as_#{format}"
       unless respond_to?(custom_load_method, true)
@@ -111,10 +128,29 @@ module Arrow
     end
 
     def open_input_stream
-      if @input.is_a?(Buffer)
-        BufferInputStream.new(@input)
+      case @input
+      when Buffer
+        yield(BufferInputStream.new(@input))
+      when URI
+        @input.open do |ruby_input|
+          case @options[:format]
+          when :stream, :arrow_streaming
+            Gio::RubyInputStream.open(ruby_input) do |gio_input|
+              GIOInputStream.open(gio_input) do |input|
+                yield(input)
+              end
+            end
+          else
+            # TODO: We need to consider Ruby's GVL carefully to use
+            # Ruby object directly for input with other formats. We
+            # read data and use it as Buffer for now.
+            data = GLib::Bytes.new(ruby_input.read.freeze)
+            buffer = Buffer.new(data)
+            yield(BufferInputStream.new(buffer))
+          end
+        end
       else
-        MemoryMappedInputStream.new(@input)
+        yield(MemoryMappedInputStream.new(@input))
       end
     end
 
@@ -130,32 +166,19 @@ module Arrow
     end
 
     def load_as_arrow
-      input = nil
-      reader = nil
-      error = nil
-      reader_class_candidates = [
-        RecordBatchFileReader,
-        RecordBatchStreamReader,
-      ]
-      reader_class_candidates.each do |reader_class_candidate|
-        input = open_input_stream
-        begin
-          reader = reader_class_candidate.new(input)
-        rescue Arrow::Error
-          error = $!
-        else
-          break
-        end
+      begin
+        load_as_arrow_file
+      rescue
+        load_as_arrows
       end
-      raise error if reader.nil?
-      load_raw(input, reader)
     end
 
     # @since 1.0.0
     def load_as_arrow_file
-      input = open_input_stream
-      reader = RecordBatchFileReader.new(input)
-      load_raw(input, reader)
+      open_input_stream do |input|
+        reader = RecordBatchFileReader.new(input)
+        load_raw(input, reader)
+      end
     end
 
     # @deprecated Use `format: :arrow_file` instead.
@@ -163,34 +186,46 @@ module Arrow
       load_as_arrow_file
     end
 
+    # @since 7.0.0
+    def load_as_arrows
+      open_input_stream do |input|
+        reader = RecordBatchStreamReader.new(input)
+        load_raw(input, reader)
+      end
+    end
+
     # @since 1.0.0
     def load_as_arrow_streaming
-      input = open_input_stream
-      reader = RecordBatchStreamReader.new(input)
-      load_raw(input, reader)
+      load_as_arrows
     end
 
     # @deprecated Use `format: :arrow_streaming` instead.
     def load_as_stream
-      load_as_arrow_streaming
+      load_as_arrows
     end
 
     if Arrow.const_defined?(:ORCFileReader)
       def load_as_orc
-        input = open_input_stream
-        reader = ORCFileReader.new(input)
-        field_indexes = @options[:field_indexes]
-        reader.set_field_indexes(field_indexes) if field_indexes
-        table = reader.read_stripes
-        table.instance_variable_set(:@input, input)
-        table
+        open_input_stream do |input|
+          reader = ORCFileReader.new(input)
+          field_indexes = @options[:field_indexes]
+          reader.set_field_indexes(field_indexes) if field_indexes
+          table = reader.read_stripes
+          table.instance_variable_set(:@input, input)
+          table
+        end
       end
     end
 
     def csv_load(options)
       options.delete(:format)
-      if @input.is_a?(Buffer)
+      case @input
+      when Buffer
         CSVLoader.load(@input.data.to_s, **options)
+      when URI
+        @input.open do |input|
+          CSVLoader.load(input.read, **options)
+        end
       else
         CSVLoader.load(Pathname.new(@input), **options)
       end
@@ -207,19 +242,21 @@ module Arrow
     end
 
     def load_as_feather
-      input = open_input_stream
-      reader = FeatherFileReader.new(input)
-      table = reader.read
-      table.instance_variable_set(:@input, input)
-      table
+      open_input_stream do |input|
+        reader = FeatherFileReader.new(input)
+        table = reader.read
+        table.instance_variable_set(:@input, input)
+        table
+      end
     end
 
     def load_as_json
-      input = open_input_stream
-      reader = JSONReader.new(input)
-      table = reader.read
-      table.instance_variable_set(:@input, input)
-      table
+      open_input_stream do |input|
+        reader = JSONReader.new(input)
+        table = reader.read
+        table.instance_variable_set(:@input, input)
+        table
+      end
     end
   end
 end

data/lib/arrow/table-saver.rb

@@ -151,14 +151,19 @@ module Arrow
       save_as_arrow_file
     end
 
+    # @since 7.0.0
+    def save_as_arrows
+      save_raw(RecordBatchStreamWriter)
+    end
+
     # @since 1.0.0
     def save_as_arrow_streaming
-      save_raw(RecordBatchStreamWriter)
+      save_as_arrows
     end
 
     # @deprecated Use `format: :arrow_streaming` instead.
     def save_as_stream
-      save_as_arrow_streaming
+      save_as_arrows
     end
 
     def csv_save(**options)