Class: Arrow::Array

Inherits:
Object
  • Object
show all
Includes:
ArrayComputable, GenericFilterable, GenericTakeable, InputReferable, Enumerable
Defined in:
lib/arrow/array.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods included from InputReferable

#refer_input, #share_input

Methods included from GenericTakeable

included, #take_generic

Methods included from GenericFilterable

#filter_generic, included

Methods included from ArrayComputable

#index, #max, #min, #uniq

Class Method Details

.builder_class ⇒ Object 



35
36
37
38
39
 
# File 'lib/arrow/array.rb', line 35

def builder_class
  builder_class_name = "#{name}Builder"
  return nil unless const_defined?(builder_class_name)
  const_get(builder_class_name)
end

.new(*args) ⇒ Object 



28
29
30
31
32
33
 
# File 'lib/arrow/array.rb', line 28

def new(*args)
  _builder_class = builder_class
  return super if _builder_class.nil?
  return super unless _builder_class.buildable?(args)
  _builder_class.build(*args)
end

.try_convert(value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/arrow/array.rb', line 42

def try_convert(value)
  case value
  when ::Array
    begin
      new(value)
    rescue ArgumentError
      nil
    end
  else
    if value.respond_to?(:to_arrow_array)
      begin
        value.to_arrow_array
      rescue RangeError
        nil
      end
    else
      nil
    end
  end
end

Instance Method Details

#+(other_array) ⇒ Object

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.

Examples:

Raw Ruby Array

Arrow::Int32Array.new([1]) + [2, 3] # => Arrow::Int32Array.new([1, 2, 3])

Arrow::Array

Arrow::Int32Array.new([1]) +
  Arrow::Int32Array.new([2, 3]) # => Arrow::Int32Array.new([1, 2, 3])

Parameters:

  • other_array (::Array, Arrow::Array) —

    The array to be concatenated.

    ‘@other_array` is processed by #resolve before it’s concatenated.

Since:

  • 4.0.0



194
195
196
 
# File 'lib/arrow/array.rb', line 194

def +(other_array)
  concatenate(other_array)
end

#[](i) ⇒ Object?

Returns The ‘i`-th value.

‘nil` for NULL value or out of range `i`.

Parameters:

  • i (Integer) —

    The index of the value to be gotten.

    You can specify negative index like for ‘::Array#[]`.

Returns:

  • (Object, nil) —

    The ‘i`-th value.

    ‘nil` for NULL value or out of range `i`.



73
74
75
76
77
78
79
80
81
 
# File 'lib/arrow/array.rb', line 73

def [](i)
  i += length if i < 0
  return nil if i < 0 or i >= length
  if null?(i)
    nil
  else
    get_value(i)
  end
end

#concatenate(*other_arrays) ⇒ Object

Concatenates the given other arrays to the array.

Examples:

Raw Ruby Array

array = Arrow::Int32Array.new([1])
array.concatenate([2, 3], [4]) # => Arrow::Int32Array.new([1, 2, 3, 4])

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])

Parameters:

  • other_arrays (::Array, Arrow::Array) —

    The arrays to be concatenated.

    Each other array is processed by #resolve before they’re concatenated.

Since:

  • 4.0.0



169
170
171
172
173
174
 
# File 'lib/arrow/array.rb', line 169

def concatenate(*other_arrays)
  other_arrays = other_arrays.collect do |other_array|
    resolve(other_array)
  end
  concatenate_raw(other_arrays)
end

#concatenate_raw ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



150
 
# File 'lib/arrow/array.rb', line 150

alias_method :concatenate_raw, :concatenate

#each ⇒ Object 



95
96
97
98
99
100
101
 
# File 'lib/arrow/array.rb', line 95

def each
  return to_enum(__method__) unless block_given?

  length.times do |i|
    yield(self[i])
  end
end

#equal_array?(other, options = nil) ⇒ Boolean

Returns ‘true` if both of them have the same data, `false` otherwise.

Parameters:

  • other (Arrow::Array) —

    The array to be compared.

  • options (Arrow::EqualOptions, Hash) (defaults to: nil) —

    (nil) The options to custom how to compare.

Returns:

  • (Boolean) —

    ‘true` if both of them have the same data, `false` otherwise.

Since:

  • 5.0.0



91
92
93
 
# File 'lib/arrow/array.rb', line 91

def equal_array?(other, options=nil)
  equal_options(other, options)
end

#is_in(values) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/arrow/array.rb', line 133

def is_in(values)
  case values
  when ::Array
    if self.class.builder_class.buildable?([values])
      values = self.class.new(values)
    else
      values = self.class.new(value_data_type, values)
    end
    is_in_raw(values)
  when ChunkedArray
    is_in_chunked_array(values)
  else
    is_in_raw(values)
  end
end

#is_in_raw ⇒ Object 



132
 
# File 'lib/arrow/array.rb', line 132

alias_method :is_in_raw, :is_in

#resolve(other_raw_array) ⇒ Arrow::Array #resolve(other_array) ⇒ Arrow::Array

Ensures returning the same data type array from the given array.

Overloads:

  • #resolve(other_raw_array) ⇒ Arrow::Array

    Examples:

    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])

    Parameters:

    • other_raw_array (::Array) —

      A raw Ruby Array. A new Arrow::Array is built by ‘self.class.new`.

  • #resolve(other_array) ⇒ Arrow::Array

    Examples:

    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

    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])

    Parameters:

    • 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.

Returns:

Since:

  • 4.0.0



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/arrow/array.rb', line 235

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

#reverse_each ⇒ Object 



103
104
105
106
107
108
109
 
# File 'lib/arrow/array.rb', line 103

def reverse_each
  return to_enum(__method__) unless block_given?

  (length - 1).downto(0) do |i|
    yield(self[i])
  end
end

#to_a ⇒ Object 



128
129
130
 
# File 'lib/arrow/array.rb', line 128

def to_a
  values
end

#to_arrow ⇒ Object 



111
112
113
 
# File 'lib/arrow/array.rb', line 111

def to_arrow
  self
end

#to_arrow_array ⇒ Object 



115
116
117
 
# File 'lib/arrow/array.rb', line 115

def to_arrow_array
  self
end

#to_arrow_chunked_array ⇒ Object 



119
120
121
 
# File 'lib/arrow/array.rb', line 119

def to_arrow_chunked_array
  ChunkedArray.new([self])
end

#value_data_type ⇒ Object 



124
125
126
 
# File 'lib/arrow/array.rb', line 124

def value_data_type
  @value_data_type ||= value_data_type_raw
end

#value_data_type_raw ⇒ Object 



123
 
# File 'lib/arrow/array.rb', line 123

alias_method :value_data_type_raw, :value_data_type