red-arrow 0.14.1 → 0.15.0

data/lib/arrow/time.rb

@@ -0,0 +1,159 @@
+# 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 Time
+    attr_reader :unit
+    attr_reader :value
+    def initialize(unit, value)
+      @unit = unit
+      @value = value
+      @unconstructed = false
+    end
+
+    def ==(other)
+      other.is_a?(self.class) and
+        positive? == other.positive? and
+        hour == other.hour and
+        minute == other.minute and
+        second == other.second and
+        nano_second == other.nano_second
+    end
+
+    def cast(target_unit)
+      return self.class.new(@unit, @value) if @unit == target_unit
+
+      target_value = (hour * 60 * 60) + (minute * 60) + second
+      case target_unit
+      when TimeUnit::MILLI
+        target_value *= 1000
+        target_value += nano_second / 1000 / 1000
+      when TimeUnit::MICRO
+        target_value *= 1000 * 1000
+        target_value += nano_second / 1000
+      when TimeUnit::NANO
+        target_value *= 1000 * 1000 * 1000
+        target_value += nano_second
+      end
+      target_value = -target_value if negative?
+      self.class.new(target_unit, target_value)
+    end
+
+    def to_f
+      case @unit
+      when TimeUnit::SECOND
+        @value.to_f
+      when TimeUnit::MILLI
+        @value.to_f / 1000.0
+      when TimeUnit::MICRO
+        @value.to_f / 1000.0 / 1000.0
+      when TimeUnit::NANO
+        @value.to_f / 1000.0 / 1000.0 / 1000.0
+      end
+    end
+
+    def positive?
+      @value.positive?
+    end
+
+    def negative?
+      @value.negative?
+    end
+
+    def hour
+      unconstruct
+      @hour
+    end
+
+    def minute
+      unconstruct
+      @minute
+    end
+    alias_method :min, :minute
+
+    def second
+      unconstruct
+      @second
+    end
+    alias_method :sec, :second
+
+    def nano_second
+      unconstruct
+      @nano_second
+    end
+    alias_method :nsec, :nano_second
+
+    def to_s
+      unconstruct
+      if @nano_second.zero?
+        nano_second_string = ""
+      else
+        nano_second_string = (".%09d" % @nano_second).gsub(/0+\z/, "")
+      end
+      "%s%02d:%02d:%02d%s" % [
+        @value.negative? ? "-" : "",
+        @hour,
+        @minute,
+        @second,
+        nano_second_string,
+      ]
+    end
+
+    private
+    def unconstruct
+      return if @unconstructed
+      abs_value = @value.abs
+      case unit
+      when TimeUnit::SECOND
+        unconstruct_second(abs_value)
+        @nano_second = 0
+      when TimeUnit::MILLI
+        unconstruct_second(abs_value / 1000)
+        @nano_second = (abs_value % 1000) * 1000 * 1000
+      when TimeUnit::MICRO
+        unconstruct_second(abs_value / 1000 / 1000)
+        @nano_second = (abs_value % (1000 * 1000)) * 1000
+      when TimeUnit::NANO
+        unconstruct_second(abs_value / 1000 / 1000 / 1000)
+        @nano_second = abs_value % (1000 * 1000 * 1000)
+      else
+        raise ArgumentError, "invalid unit: #{@unit.inspect}"
+      end
+      @unconstructed = true
+    end
+
+    def unconstruct_second(abs_value_in_second)
+      if abs_value_in_second < 60
+        hour = 0
+        minute = 0
+        second = abs_value_in_second
+      elsif abs_value_in_second < (60 * 60)
+        hour = 0
+        minute = abs_value_in_second / 60
+        second = abs_value_in_second % 60
+      else
+        in_minute = abs_value_in_second / 60
+        hour = in_minute / 60
+        minute = in_minute % 60
+        second = abs_value_in_second % 60
+      end
+      @hour = hour
+      @minute = minute
+      @second = second
+    end
+  end
+end

data/lib/arrow/time32-array-builder.rb

@@ -0,0 +1,49 @@
+# 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 Time32ArrayBuilder
+    class << self
+      def build(unit_or_data_type, values)
+        builder = new(unit_or_data_type)
+        builder.build(values)
+      end
+    end
+
+    alias_method :initialize_raw, :initialize
+    def initialize(unit_or_data_type)
+      case unit_or_data_type
+      when DataType
+        data_type = unit_or_data_type
+      else
+        unit = unit_or_data_type
+        data_type = Time32DataType.new(unit)
+      end
+      initialize_raw(data_type)
+    end
+
+    def unit
+      @unit ||= value_data_type.unit
+    end
+
+    private
+    def convert_to_arrow_value(value)
+      return value unless value.is_a?(Time)
+      value.cast(unit).value
+    end
+  end
+end

data/lib/arrow/time32-array.rb

@@ -0,0 +1,28 @@
+# 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 Time32Array
+    def get_value(i)
+      Time.new(unit, get_raw_value(i))
+    end
+
+    def unit
+      @unit ||= value_data_type.unit
+    end
+  end
+end

data/lib/arrow/time64-array-builder.rb

@@ -0,0 +1,49 @@
+# 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 Time64ArrayBuilder
+    class << self
+      def build(unit_or_data_type, values)
+        builder = new(unit_or_data_type)
+        builder.build(values)
+      end
+    end
+
+    alias_method :initialize_raw, :initialize
+    def initialize(unit_or_data_type)
+      case unit_or_data_type
+      when DataType
+        data_type = unit_or_data_type
+      else
+        unit = unit_or_data_type
+        data_type = Time64DataType.new(unit)
+      end
+      initialize_raw(data_type)
+    end
+
+    def unit
+      @unit ||= value_data_type.unit
+    end
+
+    private
+    def convert_to_arrow_value(value)
+      return value unless value.is_a?(Time)
+      value.cast(unit).value
+    end
+  end
+end

data/lib/arrow/time64-array.rb

@@ -0,0 +1,28 @@
+# 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 Time64Array
+    def get_value(i)
+      Time.new(unit, get_raw_value(i))
+    end
+
+    def unit
+      @unit ||= value_data_type.unit
+    end
+  end
+end

data/lib/arrow/timestamp-array-builder.rb

@@ -17,6 +17,25 @@
 
 module Arrow
   class TimestampArrayBuilder
+    class << self
+      def build(unit_or_data_type, values)
+        builder = new(unit_or_data_type)
+        builder.build(values)
+      end
+    end
+
+    alias_method :initialize_raw, :initialize
+    def initialize(unit_or_data_type)
+      case unit_or_data_type
+      when DataType
+        data_type = unit_or_data_type
+      else
+        unit = unit_or_data_type
+        data_type = TimestampDataType.new(unit)
+      end
+      initialize_raw(data_type)
+    end
+
     private
     def unit_id
       @unit_id ||= value_data_type.unit.nick.to_sym
@@ -27,7 +46,7 @@ module Arrow
         value = value.to_time
       end
 
-      if value.is_a?(Time)
+      if value.is_a?(::Time)
         case unit_id
         when :second
           value.to_i

data/lib/arrow/timestamp-array.rb

@@ -17,16 +17,8 @@
 
 module Arrow
   class TimestampArray
-    class << self
-      def new(unit, values)
-        data_type = TimestampDataType.new(unit)
-        builder = TimestampArrayBuilder.new(data_type)
-        builder.build(values)
-      end
-    end
-
     def get_value(i)
-      to_time(get_raw_value(i))
+      cast_to_time(get_raw_value(i))
     end
 
     def unit
@@ -34,20 +26,16 @@ module Arrow
     end
 
     private
-    def unit_id
-      @unit_id ||= unit.nick.to_sym
-    end
-
-    def to_time(raw_value)
-      case unit_id
-      when :second
-        Time.at(raw_value)
-      when :milli
-        Time.at(*raw_value.divmod(1_000))
-      when :micro
-        Time.at(*raw_value.divmod(1_000_000))
+    def cast_to_time(raw_value)
+      case unit
+      when TimeUnit::SECOND
+        ::Time.at(raw_value)
+      when TimeUnit::MILLI
+        ::Time.at(*raw_value.divmod(1_000))
+      when TimeUnit::MICRO
+        ::Time.at(*raw_value.divmod(1_000_000))
       else
-        Time.at(raw_value / 1_000_000_000.0)
+        ::Time.at(raw_value / 1_000_000_000.0)
       end
     end
   end

data/lib/arrow/version.rb

@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "0.14.1"
+  VERSION = "0.15.0"
 
   module Version
     numbers, TAG = VERSION.split("-")

data/red-arrow.gemspec

@@ -47,7 +47,7 @@ Gem::Specification.new do |spec|
   spec.extensions = ["ext/arrow/extconf.rb"]
 
   spec.add_runtime_dependency("extpp", ">= 0.0.7")
-  spec.add_runtime_dependency("gio2", ">= 3.3.6")
+  spec.add_runtime_dependency("gio2", "= 3.3.7")
   spec.add_runtime_dependency("native-package-installer")
   spec.add_runtime_dependency("pkg-config")
 

data/test/raw-records/test-basic-arrays.rb

@@ -242,10 +242,11 @@ module RawRecordsBasicArraysTests
   end
 
   def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
     records = [
-      [60 * 10], # 00:10:00
+      [Arrow::Time.new(unit, 60 * 10)], # 00:10:00
       [nil],
-      [60 * 60 * 2 + 9], # 02:00:09
+      [Arrow::Time.new(unit, 60 * 60 * 2 + 9)], # 02:00:09
     ]
     target = build({
                      column: {
@@ -258,10 +259,11 @@ module RawRecordsBasicArraysTests
   end
 
   def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
     records = [
-      [(60 * 10) * 1000 + 123], # 00:10:00.123
+      [Arrow::Time.new(unit, (60 * 10) * 1000 + 123)], # 00:10:00.123
       [nil],
-      [(60 * 60 * 2 + 9) * 1000 + 987], # 02:00:09.987
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987)], # 02:00:09.987
     ]
     target = build({
                      column: {
@@ -274,10 +276,13 @@ module RawRecordsBasicArraysTests
   end
 
   def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
     records = [
-      [(60 * 10) * 1_000_000 + 123_456], # 00:10:00.123456
+      # 00:10:00.123456
+      [Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)],
       [nil],
-      [(60 * 60 * 2 + 9) * 1_000_000 + 987_654], # 02:00:09.987654
+      # 02:00:09.987654
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654)],
     ]
     target = build({
                      column: {
@@ -290,10 +295,13 @@ module RawRecordsBasicArraysTests
   end
 
   def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
     records = [
-      [(60 * 10) * 1_000_000_000 + 123_456_789], # 00:10:00.123456789
+      # 00:10:00.123456789
+      [Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)],
       [nil],
-      [(60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321], # 02:00:09.987654321
+      # 02:00:09.987654321
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321)],
     ]
     target = build({
                      column: {