red-arrow 0.11.0 → 0.12.0

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

@@ -0,0 +1,69 @@
+# 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 Decimal128DataType
+    alias_method :initialize_raw, :initialize
+    private :initialize_raw
+
+    # Creates a new {Arrow::Decimal128DataType}.
+    #
+    # @overload initialize(precision, scale)
+    #
+    #   @param precision [Integer] The precision of the decimal data
+    #     type. It's the number of digits including the number of
+    #     digits after the decimal point.
+    #
+    #   @param scale [Integer] The scale of the decimal data
+    #     type. It's the number of digits after the decimal point.
+    #
+    #   @example Create a decimal data type for "XXXXXX.YY" decimal
+    #     Arrow::Decimal128DataType.new(8, 2)
+    #
+    # @overload initialize(description)
+    #
+    #   @param description [Hash] The description of the decimal data
+    #     type. It must have `:precision` and `:scale` values.
+    #
+    #   @option description [Integer] :precision The precision of the
+    #     decimal data type. It's the number of digits including the
+    #     number of digits after the decimal point.
+    #
+    #   @option description [Integer] :scale The scale of the decimal
+    #     data type. It's the number of digits after the decimal
+    #     point.
+    #
+    #   @example Create a decimal data type for "XXXXXX.YY" decimal
+    #     Arrow::Decimal128DataType.new(precision: 8,
+    #                                   scale: 2)
+    def initialize(*args)
+      n_args = args.size
+      case n_args
+      when 1
+        description = args[0]
+        precision = description[:precision]
+        scale = description[:scale]
+      when 2
+        precision, scale = args
+      else
+        message = "wrong number of arguments (given, #{n_args}, expected 1..2)"
+        raise ArgumentError, message
+      end
+      initialize_raw(precision, scale)
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# 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 DenseUnionDataType
+    alias_method :initialize_raw, :initialize
+    private :initialize_raw
+
+    # Creates a new {Arrow::DenseUnionDataType}.
+    #
+    # @overload initialize(fields, type_codes)
+    #
+    #   @param fields [::Array<Arrow::Field, Hash>] The fields of the
+    #     dense union data type. You can mix {Arrow::Field} and field
+    #     description in the fields.
+    #
+    #     See {Arrow::Field.new} how to specify field description.
+    #
+    #   @param type_codes [::Array<Integer>] The IDs that indicates
+    #     corresponding fields.
+    #
+    #   @example Create a dense union data type for {2: visible, 9: count}
+    #     fields = [
+    #       Arrow::Field.new("visible", :boolean),
+    #       {
+    #         name: "count",
+    #         type: :int32,
+    #       },
+    #     ]
+    #     Arrow::DenseUnionDataType.new(fields, [2, 9])
+    #
+    # @overload initialize(description)
+    #
+    #   @param description [Hash] The description of the dense union
+    #     data type. It must have `:fields` and `:type_codes` values.
+    #
+    #   @option description [::Array<Arrow::Field, Hash>] :fields The
+    #     fields of the dense union data type. You can mix
+    #     {Arrow::Field} and field description in the fields.
+    #
+    #     See {Arrow::Field.new} how to specify field description.
+    #
+    #   @option description [::Array<Integer>] :type_codes The IDs
+    #     that indicates corresponding fields.
+    #
+    #   @example Create a dense union data type for {2: visible, 9: count}
+    #     fields = [
+    #       Arrow::Field.new("visible", :boolean),
+    #       {
+    #         name: "count",
+    #         type: :int32,
+    #       },
+    #     ]
+    #     Arrow::DenseUnionDataType.new(fields: fields,
+    #                                   type_codes: [2, 9])
+    def initialize(*args)
+      n_args = args.size
+      case n_args
+      when 1
+        description = args[0]
+        fields = description[:fields]
+        type_codes = description[:type_codes]
+      when 2
+        fields, type_codes = args
+      else
+        message = "wrong number of arguments (given, #{n_args}, expected 1..2)"
+        raise ArgumentError, message
+      end
+      fields = fields.collect do |field|
+        field = Field.new(field) unless field.is_a?(Field)
+        field
+      end
+      initialize_raw(fields, type_codes)
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# 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 DictionaryDataType
+    alias_method :initialize_raw, :initialize
+    private :initialize_raw
+
+    # Creates a new {Arrow::DictionaryDataType}.
+    #
+    # @overload initialize(index_data_type, dictionary, ordered)
+    #
+    #   @param index_data_type [Arrow::DataType, Hash, String, Symbol]
+    #     The index data type of the dictionary data type. It must be
+    #     signed integer data types. Here are available signed integer
+    #     data types:
+    #
+    #       * Arrow::Int8DataType
+    #       * Arrow::Int16DataType
+    #       * Arrow::Int32DataType
+    #       * Arrow::Int64DataType
+    #
+    #     You can specify data type as a description by `Hash`.
+    #
+    #     See {Arrow::DataType.resolve} how to specify data type
+    #     description.
+    #
+    #   @param dictionary [Arrow::Array] The real values of the
+    #     dictionary data type.
+    #
+    #   @param ordered [Boolean] Whether dictionary contents are
+    #     ordered or not.
+    #
+    #   @example Create a dictionary data type for {0: "Hello", 1: "World"}
+    #     index_data_type = :int8
+    #     dictionary = Arrow::StringArray.new(["Hello", "World"])
+    #     ordered = true
+    #     Arrow::DictionaryDataType.new(index_data_type,
+    #                                   dictionary,
+    #                                   ordered)
+    #
+    # @overload initialize(description)
+    #
+    #   @param description [Hash] The description of the dictionary
+    #     data type. It must have `:index_data_type`, `:dictionary`
+    #     and `:ordered` values.
+    #
+    #   @option description [Arrow::DataType, Hash, String, Symbol]
+    #     :index_data_type The index data type of the dictionary data
+    #     type. It must be signed integer data types. Here are
+    #     available signed integer data types:
+    #
+    #       * Arrow::Int8DataType
+    #       * Arrow::Int16DataType
+    #       * Arrow::Int32DataType
+    #       * Arrow::Int64DataType
+    #
+    #     You can specify data type as a description by `Hash`.
+    #
+    #     See {Arrow::DataType.resolve} how to specify data type
+    #     description.
+    #
+    #   @option description [Arrow::Array] :dictionary The real values
+    #     of the dictionary data type.
+    #
+    #   @option description [Boolean] :ordered Whether dictionary
+    #     contents are ordered or not.
+    #
+    #   @example Create a dictionary data type for {0: "Hello", 1: "World"}
+    #     dictionary = Arrow::StringArray.new(["Hello", "World"])
+    #     Arrow::DictionaryDataType.new(index_data_type: :int8,
+    #                                   dictionary: dictionary,
+    #                                   ordered: true)
+    def initialize(*args)
+      n_args = args.size
+      case n_args
+      when 1
+        description = args[0]
+        index_data_type = description[:index_data_type]
+        dictionary = description[:dictionary]
+        ordered = description[:ordered]
+      when 3
+        index_data_type, dictionary, ordered = args
+      else
+        message = "wrong number of arguments (given, #{n_args}, expected 1 or 3)"
+        raise ArgumentError, message
+      end
+      index_data_type = DataType.resolve(index_data_type)
+      initialize_raw(index_data_type, dictionary, ordered)
+    end
+  end
+end

data/lib/arrow/field-containable.rb

@@ -0,0 +1,35 @@
+# 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 FieldContainable
+    def find_field(name_or_index)
+      case name_or_index
+      when String, Symbol
+        name = name_or_index
+        get_field_by_name(name)
+      when Integer
+        index = name_or_index
+        get_field(index)
+      else
+        message = "field name or index must be String, Symbol or Integer"
+        message << ": <#{name_or_index.inspect}>"
+        raise ArgumentError, message
+      end
+    end
+  end
+end

data/lib/arrow/field.rb

@@ -18,16 +18,100 @@
 module Arrow
   class Field
     alias_method :initialize_raw, :initialize
-    def initialize(name, data_type)
-      case data_type
-      when String, Symbol
-        data_type_name = data_type.to_s.capitalize.gsub(/\AUint/, "UInt")
-        data_type_class_name = "#{data_type_name}DataType"
-        if Arrow.const_defined?(data_type_class_name)
-          data_type_class = Arrow.const_get(data_type_class_name)
-          data_type = data_type_class.new
+    private :initialize_raw
+
+    # Creates a new {Arrow::Field}.
+    #
+    # @overload initialize(name, data_type)
+    #
+    #   @param name [String, Symbol] The name of the field.
+    #
+    #   @param data_type [Arrow::DataType, Hash, String, Symbol] The
+    #     data type of the field.
+    #
+    #     You can specify data type as a description by `Hash`.
+    #
+    #     See {Arrow::DataType.resolve} how to specify data type
+    #     description.
+    #
+    #   @example Create a field with {Arrow::DataType}s
+    #     Arrow::Field.new("visible", Arrow::BooleanDataType.new)
+    #
+    #   @example Create a field with data type description
+    #     Arrow::Field.new("visible", :boolean)
+    #
+    #   @example Create a field with name as `Symbol`
+    #     Arrow::Field.new(:visible, :boolean)
+    #
+    # @overload initialize(description)
+    #
+    #   @param description [Hash] The description of the field.
+    #
+    #     Field description is a raw `Hash`. Field description must
+    #     have `:name` and `:data_type` values. `:name` is the name of
+    #     the field. `:data_type` is the data type of the field. You
+    #     can use {Arrow::DataType} or data type description as
+    #     `:data_type` value.
+    #
+    #     See {Arrow::DataType.resolve} how to specify data type
+    #     description.
+    #
+    #     There is a shortcut for convenience. If field description
+    #     doesn't have `:data_type`, all keys except `:name` are
+    #     processes as data type description. For example, the
+    #     following field descrptions are the same:
+    #
+    #     ```ruby
+    #     {name: "visible", data_type: {type: :boolean}}
+    #     {name: "visible", type: :boolean} # Shortcut version
+    #     ```
+    #
+    #   @option description [String, Symbol] :name The name of the field.
+    #
+    #   @option description [Arrow::DataType, Hash] :data_type The
+    #     data type of the field. You can specify data type description
+    #     by `Hash`.
+    #
+    #     See {Arrow::DataType.resolve} how to specify data type
+    #     description.
+    #
+    #   @example Create a field with {Arrow::DataType}s
+    #     Arrow::Field.new(name: "visible",
+    #                      data_type: Arrow::BooleanDataType.new)
+    #
+    #   @example Create a field with data type description
+    #     Arrow::Field.new(name: "visible", data_type: {type: :boolean}
+    #
+    #   @example Create a field with shortcut form
+    #     Arrow::Field.new(name: "visible", type: :boolean)
+    def initialize(*args)
+      n_args = args.size
+      case n_args
+      when 1
+        description = args[0]
+        name = nil
+        data_type = nil
+        data_type_description = {}
+        description.each do |key, value|
+          key = key.to_sym
+          case key
+          when :name
+            name = value
+          when :data_type
+            data_type = DataType.resolve(value)
+          else
+            data_type_description[key] = value
+          end
         end
+        data_type ||= DataType.resolve(data_type_description)
+      when 2
+        name = args[0]
+        data_type = DataType.resolve(args[1])
+      else
+        message = "wrong number of arguments (given #{n_args}, expected 1..2)"
+        raise ArgumentError, message
       end
+
       initialize_raw(name, data_type)
     end
   end

data/lib/arrow/file-output-stream.rb

@@ -0,0 +1,34 @@
+# 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 FileOutputStream
+    alias_method :initialize_raw, :initialize
+    private :initialize_raw
+    def initialize(path, options={})
+      append = nil
+      case options
+      when true, false
+        append = options
+      when Hash
+        append = options[:append]
+      end
+      append = false if append.nil?
+      initialize_raw(path, append)
+    end
+  end
+end