red-arrow 8.0.0 → 24.0.0

data/test/test-field.rb

@@ -1,91 +0,0 @@
-# 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.
-
-class FieldTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    test("String, Arrow::DataType") do
-      assert_equal("visible: bool",
-                   Arrow::Field.new("visible", Arrow::BooleanDataType.new).to_s)
-    end
-
-    test("Symbol, Arrow::DataType") do
-      assert_equal("visible: bool",
-                   Arrow::Field.new(:visible, Arrow::BooleanDataType.new).to_s)
-    end
-
-    test("String, Symbol") do
-      assert_equal("visible: bool",
-                   Arrow::Field.new(:visible, :boolean).to_s)
-    end
-
-    test("String, Hash") do
-      assert_equal("visible: bool",
-                   Arrow::Field.new(:visible, type: :boolean).to_s)
-    end
-
-    test("description: String") do
-      assert_equal("visible: bool",
-                   Arrow::Field.new(name: "visible",
-                                    data_type: :boolean).to_s)
-    end
-
-    test("description: Symbol") do
-      assert_equal("visible: bool",
-                   Arrow::Field.new(name: :visible,
-                                    data_type: :boolean).to_s)
-    end
-
-    test("description: shortcut") do
-      assert_equal("visible: bool",
-                   Arrow::Field.new(name: :visible,
-                                    type: :boolean).to_s)
-    end
-
-    test("Hash: shortcut: additional") do
-      description = {
-        name: :tags,
-        type: :list,
-        field: {
-          name: "tag",
-          type: :string,
-        },
-      }
-      assert_equal("tags: list<tag: string>",
-                   Arrow::Field.new(description).to_s)
-    end
-  end
-
-  sub_test_case("instance methods") do
-    def setup
-      @field = Arrow::Field.new("count", :uint32)
-    end
-
-    sub_test_case("#==") do
-      test("Arrow::Field") do
-        assert do
-          @field == @field
-        end
-      end
-
-      test("not Arrow::Field") do
-        assert do
-          not (@field == 29)
-        end
-      end
-    end
-  end
-end

data/test/test-file-output-stream.rb

@@ -1,54 +0,0 @@
-# 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.
-
-class TestFileOutputStream < Test::Unit::TestCase
-  sub_test_case(".open") do
-    def setup
-      @file = Tempfile.open("arrow-file-output-stream")
-      @file.write("Hello")
-      @file.close
-    end
-
-    def test_default
-      Arrow::FileOutputStream.open(@file.path) do |file|
-        file.write(" World")
-      end
-      assert_equal(" World", File.read(@file.path))
-    end
-
-    def test_options_append
-      Arrow::FileOutputStream.open(@file.path, append: true) do |file|
-        file.write(" World")
-      end
-      assert_equal("Hello World", File.read(@file.path))
-    end
-
-    def test_append_true
-      Arrow::FileOutputStream.open(@file.path, true) do |file|
-        file.write(" World")
-      end
-      assert_equal("Hello World", File.read(@file.path))
-    end
-
-    def test_append_false
-      Arrow::FileOutputStream.open(@file.path, false) do |file|
-        file.write(" World")
-      end
-      assert_equal(" World", File.read(@file.path))
-    end
-  end
-end

data/test/test-fixed-size-binary-array-builder.rb

@@ -1,92 +0,0 @@
-# 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.
-
-class FixedSizeBinaryArrayBuilderTest < Test::Unit::TestCase
-  def setup
-    @data_type = Arrow::FixedSizeBinaryDataType.new(4)
-    @builder = Arrow::FixedSizeBinaryArrayBuilder.new(@data_type)
-  end
-
-  sub_test_case("#append_value") do
-    test("nil") do
-      @builder.append_value(nil)
-      array = @builder.finish
-      assert_equal(nil, array[0])
-    end
-
-    test("String") do
-      @builder.append_value("0123")
-      array = @builder.finish
-      assert_equal("0123", array[0])
-    end
-
-    test("GLib::Bytes") do
-      @builder.append_value(GLib::Bytes.new("0123"))
-      array = @builder.finish
-      assert_equal("0123", array[0])
-    end
-  end
-
-  sub_test_case("#append_values") do
-    test("mixed") do
-      @builder.append_values([
-                               "0123",
-                               nil,
-                               GLib::Bytes.new("abcd"),
-                             ])
-      array = @builder.finish
-      assert_equal([
-                     "0123",
-                     nil,
-                     "abcd",
-                   ],
-                   array.to_a)
-    end
-
-    test("is_valids") do
-      @builder.append_values([
-                               "0123",
-                               "0123",
-                               "0123",
-                             ],
-                             [
-                               true,
-                               false,
-                               true,
-                             ])
-      array = @builder.finish
-      assert_equal([
-                     "0123",
-                     nil,
-                     "0123",
-                   ],
-                   array.to_a)
-    end
-
-    test("packed") do
-      @builder.append_values("0123" * 3,
-                             [true, false, true])
-      array = @builder.finish
-      assert_equal([
-                     "0123",
-                     nil,
-                     "0123",
-                   ],
-                   array.to_a)
-    end
-  end
-end

data/test/test-fixed-size-binary-array.rb

@@ -1,36 +0,0 @@
-# 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.
-
-class FixedSizeBinaryArrayTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    test("build") do
-      data_type = Arrow::FixedSizeBinaryDataType.new(4)
-      values = [
-        "0123",
-        nil,
-        GLib::Bytes.new("abcd"),
-      ]
-      array = Arrow::FixedSizeBinaryArray.new(data_type, values)
-      assert_equal([
-                     "0123",
-                     nil,
-                     "abcd",
-                   ],
-                   array.to_a)
-    end
-  end
-end

data/test/test-function.rb

@@ -1,210 +0,0 @@
-# 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.
-
-class FunctionTest < Test::Unit::TestCase
-  sub_test_case("#execute") do
-    test("Arrow::Array") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        Arrow::BooleanArray.new([true, false, false]),
-        Arrow::BooleanArray.new([true, false, true]),
-      ]
-      assert_equal([true, false, true],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("Array") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        [true, false, false],
-        [true, false, true],
-      ]
-      assert_equal([true, false, true],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("Arrow::ChunkedArray") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        Arrow::ChunkedArray.new([
-                                  Arrow::BooleanArray.new([true]),
-                                  Arrow::BooleanArray.new([false, false]),
-                                ]),
-        Arrow::ChunkedArray.new([
-                                  Arrow::BooleanArray.new([true, false]),
-                                  Arrow::BooleanArray.new([true]),
-                                ]),
-      ]
-      assert_equal([true, false, true],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("Arrow::Column") do
-      or_function = Arrow::Function.find("or")
-      table = Arrow::Table.new(a: [true, false, false],
-                               b: [true, false, true])
-      assert_equal([true, false, true],
-                   or_function.execute([table.a, table.b]).value.to_a)
-    end
-
-    test("Arrow::Scalar") do
-      add_function = Arrow::Function.find("add")
-      args = [
-        Arrow::Int8Array.new([1, 2, 3]),
-        Arrow::Int8Scalar.new(5),
-      ]
-      assert_equal([6, 7, 8],
-                   add_function.execute(args).value.to_a)
-    end
-
-    test("Integer") do
-      add_function = Arrow::Function.find("add")
-      args = [
-        [1, 2, 3],
-        5,
-      ]
-      assert_equal([6, 7, 8],
-                   add_function.execute(args).value.to_a)
-    end
-
-    test("Float") do
-      add_function = Arrow::Function.find("add")
-      args = [
-        [1, 2, 3],
-        5.1,
-      ]
-      assert_equal([6.1, 7.1, 8.1],
-                   add_function.execute(args).value.to_a)
-    end
-
-    test("true") do
-      and_function = Arrow::Function.find("and")
-      args = [
-        Arrow::BooleanArray.new([true, false, false]),
-        true,
-      ]
-      assert_equal([true, false, false],
-                   and_function.execute(args).value.to_a)
-    end
-
-    test("false") do
-      or_function = Arrow::Function.find("or")
-      args = [
-        Arrow::BooleanArray.new([true, false, false]),
-        false,
-      ]
-      assert_equal([true, false, false],
-                   or_function.execute(args).value.to_a)
-    end
-
-    test("String") do
-      ascii_upper_function = Arrow::Function.find("ascii_upper")
-      args = [
-        "Hello",
-      ]
-      assert_equal("HELLO",
-                   ascii_upper_function.execute(args).value.to_s)
-    end
-
-    test("Date") do
-      cast_function = Arrow::Function.find("cast")
-      date = Date.new(2021, 6, 12)
-      args = [date]
-      options = {
-        to_data_type: Arrow::TimestampDataType.new(:second),
-      }
-      time = Time.utc(date.year,
-                      date.month,
-                      date.day)
-      assert_equal(Arrow::TimestampScalar.new(options[:to_data_type],
-                                              time.to_i),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("Arrow::Time: second") do
-      cast_function = Arrow::Function.find("cast")
-      arrow_time = Arrow::Time.new(Arrow::TimeUnit::SECOND,
-                                   # 00:10:00
-                                   60 * 10)
-      args = [arrow_time]
-      options = {
-        to_data_type: Arrow::Time64DataType.new(:micro),
-      }
-      assert_equal(Arrow::Time64Scalar.new(options[:to_data_type],
-                                           # 00:10:00.000000
-                                           60 * 10 * 1000 * 1000),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("Arrow::Time: micro") do
-      cast_function = Arrow::Function.find("cast")
-      arrow_time = Arrow::Time.new(Arrow::TimeUnit::MICRO,
-                                   # 00:10:00.000000
-                                   60 * 10 * 1000 * 1000)
-      args = [arrow_time]
-      options = {
-        to_data_type: Arrow::Time32DataType.new(:second),
-        allow_time_truncate: true,
-      }
-      assert_equal(Arrow::Time32Scalar.new(options[:to_data_type],
-                                           # 00:10:00
-                                           60 * 10),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("Time") do
-      cast_function = Arrow::Function.find("cast")
-      time = Time.utc(2021, 6, 12, 1, 2, 3, 1)
-      args = [time]
-      options = {
-        to_data_type: Arrow::TimestampDataType.new(:second),
-        allow_time_truncate: true,
-      }
-      time = Time.utc(time.year,
-                      time.month,
-                      time.day,
-                      time.hour,
-                      time.min,
-                      time.sec)
-      assert_equal(Arrow::TimestampScalar.new(options[:to_data_type],
-                                              time.to_i),
-                   cast_function.execute(args, options).value)
-    end
-
-    test("SetLookupOptions") do
-      is_in_function = Arrow::Function.find("is_in")
-      args = [
-        Arrow::Int16Array.new([1, 0, 1, 2]),
-      ]
-      options = {
-        value_set: Arrow::Int16Array.new([2, 0]),
-      }
-      assert_equal(Arrow::BooleanArray.new([false, true, false, true]),
-                   is_in_function.execute(args, options).value)
-    end
-  end
-
-  def test_call
-      or_function = Arrow::Function.find("or")
-      args = [
-        Arrow::BooleanArray.new([true, false, false]),
-        Arrow::BooleanArray.new([true, false, true]),
-      ]
-      assert_equal([true, false, true],
-                   or_function.call(args).value.to_a)
-  end
-end

data/test/test-group.rb

@@ -1,180 +0,0 @@
-# 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.
-
-class GroupTest < Test::Unit::TestCase
-  include Helper::Fixture
-
-  def setup
-    raw_table = {
-      :group_key1 => Arrow::UInt8Array.new([1, 1, 2, 3, 3, 3]),
-      :group_key2 => Arrow::UInt8Array.new([1, 1, 1, 1, 2, 2]),
-      :int => Arrow::Int32Array.new([-1, -2, nil, -4, -5, -6]),
-      :uint => Arrow::UInt32Array.new([1, nil, 3, 4, 5, 6]),
-      :float => Arrow::FloatArray.new([nil, 2.2, 3.3, 4.4, 5.5, 6.6]),
-      :string => Arrow::StringArray.new(["a", "b", "c", nil, "e", "f"]),
-    }
-    @table = Arrow::Table.new(raw_table)
-  end
-
-  sub_test_case("key") do
-    test("Time") do
-      time_values = [
-        Time.parse("2018-01-29"),
-        Time.parse("2018-01-30"),
-      ]
-      raw_table = {
-        :time => Arrow::ArrayBuilder.build(time_values),
-        :int => Arrow::Int32Array.new([-1, -2]),
-      }
-      table = Arrow::Table.new(raw_table)
-      assert_equal(<<-TABLE, table.group(:time).count.to_s)
-	count(int)	                     time
-0	         1	#{time_values[0].iso8601}
-1	         1	#{time_values[1].iso8601}
-      TABLE
-    end
-  end
-
-  sub_test_case("#count") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).count.to_s)
-	count(group_key2)	count(int)	count(uint)	count(float)	count(string)	group_key1
-0	                2	         2	          1	           1	            2	         1
-1	                1	         0	          1	           1	            1	         2
-2	                3	         3	          3	           3	            2	         3
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).count.to_s)
-	count(int)	count(uint)	count(float)	count(string)	group_key1	group_key2
-0	         2	          1	           1	            2	         1	         1
-1	         0	          1	           1	            1	         2	         1
-2	         1	          1	           1	            0	         3	         1
-3	         2	          2	           2	            2	         3	         2
-      TABLE
-    end
-
-    test("column") do
-      group = @table.group(:group_key1, :group_key2)
-      assert_equal(<<-TABLE, group.count(:int, :uint).to_s)
-	count(int)	count(uint)	group_key1	group_key2
-0	         2	          1	         1	         1
-1	         0	          1	         2	         1
-2	         1	          1	         3	         1
-3	         2	          2	         3	         2
-      TABLE
-    end
-  end
-
-  sub_test_case("#sum") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).sum.to_s)
-	sum(group_key2)	sum(int)	sum(uint)	sum(float)	group_key1
-0	              2	      -3	        1	  2.200000	         1
-1	              1	  (null)	        3	  3.300000	         2
-2	              5	     -15	       15	 16.500000	         3
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).sum.to_s)
-	sum(int)	sum(uint)	sum(float)	group_key1	group_key2
-0	      -3	        1	  2.200000	         1	         1
-1	  (null)	        3	  3.300000	         2	         1
-2	      -4	        4	  4.400000	         3	         1
-3	     -11	       11	 12.100000	         3	         2
-      TABLE
-    end
-  end
-
-  sub_test_case("#mean") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).mean.to_s)
-	mean(group_key2)	 mean(int)	mean(uint)	mean(float)	group_key1
-0	        1.000000	 -1.500000	  1.000000	   2.200000	         1
-1	        1.000000	    (null)	  3.000000	   3.300000	         2
-2	        1.666667	 -5.000000	  5.000000	   5.500000	         3
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).mean.to_s)
-	 mean(int)	mean(uint)	mean(float)	group_key1	group_key2
-0	 -1.500000	  1.000000	   2.200000	         1	         1
-1	    (null)	  3.000000	   3.300000	         2	         1
-2	 -4.000000	  4.000000	   4.400000	         3	         1
-3	 -5.500000	  5.500000	   6.050000	         3	         2
-      TABLE
-    end
-  end
-
-  sub_test_case("#min") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).min.to_s)
-	min(group_key2)	min(int)	min(uint)	min(float)	group_key1
-0	              1	      -2	        1	  2.200000	         1
-1	              1	  (null)	        3	  3.300000	         2
-2	              1	      -6	        4	  4.400000	         3
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).min.to_s)
-	min(int)	min(uint)	min(float)	group_key1	group_key2
-0	      -2	        1	  2.200000	         1	         1
-1	  (null)	        3	  3.300000	         2	         1
-2	      -4	        4	  4.400000	         3	         1
-3	      -6	        5	  5.500000	         3	         2
-      TABLE
-    end
-  end
-
-  sub_test_case("#max") do
-    test("single") do
-      assert_equal(<<-TABLE, @table.group(:group_key1).max.to_s)
-	max(group_key2)	max(int)	max(uint)	max(float)	group_key1
-0	              1	      -1	        1	  2.200000	         1
-1	              1	  (null)	        3	  3.300000	         2
-2	              2	      -4	        6	  6.600000	         3
-      TABLE
-    end
-
-    test("multiple") do
-      assert_equal(<<-TABLE, @table.group(:group_key1, :group_key2).max.to_s)
-	max(int)	max(uint)	max(float)	group_key1	group_key2
-0	      -1	        1	  2.200000	         1	         1
-1	  (null)	        3	  3.300000	         2	         1
-2	      -4	        4	  4.400000	         3	         1
-3	      -5	        6	  6.600000	         3	         2
-      TABLE
-    end
-  end
-
-  sub_test_case("#aggregate") do
-    test("function()") do
-      group = @table.group(:group_key1, :group_key2)
-      assert_equal(<<-TABLE, group.aggregate("count(int)", "sum(uint)").to_s)
-	count(int)	sum(uint)	group_key1	group_key2
-0	         2	        1	         1	         1
-1	         0	        3	         2	         1
-2	         1	        4	         3	         1
-3	         2	       11	         3	         2
-      TABLE
-    end
-  end
-end