red-arrow 18.1.0 → 19.0.1

data/test/test-buffer.rb

@@ -1,49 +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 BufferTest < Test::Unit::TestCase
-  sub_test_case(".new") do
-    test("GC") do
-      data = "Hello"
-      data_id = data.object_id
-      _buffer = Arrow::Buffer.new(data)
-      data = nil
-      GC.start
-      assert_equal("Hello", ObjectSpace._id2ref(data_id))
-    end
-  end
-
-  sub_test_case("instance methods") do
-    def setup
-      @buffer = Arrow::Buffer.new("Hello")
-    end
-
-    sub_test_case("#==") do
-      test("Arrow::Buffer") do
-        assert do
-          @buffer == @buffer
-        end
-      end
-
-      test("not Arrow::Buffer") do
-        assert do
-          not (@buffer == 29)
-        end
-      end
-    end
-  end
-end

data/test/test-chunked-array.rb

@@ -1,198 +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 ChunkedArrayTest < Test::Unit::TestCase
-  test("#each") do
-    arrays = [
-      Arrow::BooleanArray.new([true, false]),
-      Arrow::BooleanArray.new([nil, true]),
-    ]
-    chunked_array = Arrow::ChunkedArray.new(arrays)
-    assert_equal([true, false, nil, true],
-                 chunked_array.to_a)
-  end
-
-  sub_test_case("#pack") do
-    test("basic array") do
-      arrays = [
-        Arrow::BooleanArray.new([true, false]),
-        Arrow::BooleanArray.new([nil, true]),
-      ]
-      chunked_array = Arrow::ChunkedArray.new(arrays)
-      packed_chunked_array = chunked_array.pack
-      assert_equal([
-                     Arrow::BooleanArray,
-                     [true, false, nil, true],
-                   ],
-                   [
-                     packed_chunked_array.class,
-                     packed_chunked_array.to_a,
-                   ])
-    end
-
-    test("TimestampArray") do
-      type = Arrow::TimestampDataType.new(:nano)
-      arrays = [
-        Arrow::TimestampArrayBuilder.new(type).build([Time.at(0)]),
-        Arrow::TimestampArrayBuilder.new(type).build([Time.at(1)]),
-      ]
-      chunked_array = Arrow::ChunkedArray.new(arrays)
-      packed_chunked_array = chunked_array.pack
-      assert_equal([
-                     Arrow::TimestampArray,
-                     [Time.at(0), Time.at(1)],
-                   ],
-                   [
-                     packed_chunked_array.class,
-                     packed_chunked_array.to_a,
-                   ])
-    end
-  end
-
-  sub_test_case("#==") do
-    def setup
-      arrays = [
-        Arrow::BooleanArray.new([true]),
-        Arrow::BooleanArray.new([false, true]),
-      ]
-      @chunked_array = Arrow::ChunkedArray.new(arrays)
-    end
-
-    test("Arrow::ChunkedArray") do
-      assert do
-        @chunked_array == @chunked_array
-      end
-    end
-
-    test("not Arrow::ChunkedArray") do
-      assert do
-        not (@chunked_array == 29)
-      end
-    end
-  end
-
-  sub_test_case("#filter") do
-    def setup
-      arrays = [
-        Arrow::BooleanArray.new([false, true]),
-        Arrow::BooleanArray.new([false, true, false]),
-      ]
-      @chunked_array = Arrow::ChunkedArray.new(arrays)
-      @options = Arrow::FilterOptions.new
-      @options.null_selection_behavior = :emit_null
-    end
-
-    test("Array: boolean") do
-      filter = [nil, true, true, false, true]
-      chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([false, false]),
-      ]
-      filtered_chunked_array = Arrow::ChunkedArray.new(chunks)
-      assert_equal(filtered_chunked_array,
-                   @chunked_array.filter(filter, @options))
-    end
-
-    test("Arrow::BooleanArray") do
-      filter = Arrow::BooleanArray.new([nil, true, true, false, true])
-      chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([false, false]),
-      ]
-      filtered_chunked_array = Arrow::ChunkedArray.new(chunks)
-      assert_equal(filtered_chunked_array,
-                   @chunked_array.filter(filter, @options))
-    end
-
-    test("Arrow::ChunkedArray") do
-      chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([true, false, true]),
-      ]
-      filter = Arrow::ChunkedArray.new(chunks)
-      filtered_chunks = [
-        Arrow::BooleanArray.new([nil, true]),
-        Arrow::BooleanArray.new([false, false]),
-      ]
-      filtered_chunked_array = Arrow::ChunkedArray.new(filtered_chunks)
-      assert_equal(filtered_chunked_array,
-                   @chunked_array.filter(filter, @options))
-    end
-  end
-
-  sub_test_case("#take") do
-    def setup
-      chunks = [
-        Arrow::Int16Array.new([1, 0]),
-        Arrow::Int16Array.new([2]),
-      ]
-      @chunked_array = Arrow::ChunkedArray.new(chunks)
-    end
-
-    test("Arrow: boolean") do
-      chunks = [
-        Arrow::Int16Array.new([0, 1]),
-        Arrow::Int16Array.new([2])
-      ]
-      taken_chunked_array = Arrow::ChunkedArray.new(chunks)
-      indices = [1, 0, 2]
-      assert_equal(taken_chunked_array,
-                   @chunked_array.take(indices))
-    end
-
-    test("Arrow::Array") do
-      chunks = [
-        Arrow::Int16Array.new([0, 1]),
-        Arrow::Int16Array.new([2])
-      ]
-      taken_chunked_array = Arrow::ChunkedArray.new(chunks)
-      indices = Arrow::Int16Array.new([1, 0, 2])
-      assert_equal(taken_chunked_array,
-                   @chunked_array.take(indices))
-    end
-
-    test("Arrow::ChunkedArray") do
-      taken_chunks = [
-        Arrow::Int16Array.new([0, 1]),
-        Arrow::Int16Array.new([2])
-      ]
-      taken_chunked_array = Arrow::ChunkedArray.new(taken_chunks)
-      indices_chunks = [
-        Arrow::Int16Array.new([1, 0]),
-        Arrow::Int16Array.new([2])
-      ]
-      indices = Arrow::ChunkedArray.new(indices_chunks)
-      assert_equal(taken_chunked_array,
-                   @chunked_array.take(indices))
-    end
-  end
-
-  test("#cast") do
-    chunked_array = Arrow::ChunkedArray.new([[1, nil, 3]])
-    assert_equal(Arrow::ChunkedArray.new([["1", nil, "3"]]),
-                 chunked_array.cast(:string))
-  end
-
-  test("#index") do
-    arrays = [
-      Arrow::Int32Array.new([1, 2]),
-      Arrow::Int32Array.new([3, 4, 5]),
-    ]
-    chunked_array = Arrow::ChunkedArray.new(arrays)
-    assert_equal(2, chunked_array.index(3))
-  end
-end

data/test/test-column.rb

@@ -1,123 +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 ColumnTest < Test::Unit::TestCase
-  def setup
-    table = Arrow::Table.new("visible" => [true, nil, false])
-    @column = table.visible
-  end
-
-  test("#name") do
-    assert_equal("visible", @column.name)
-  end
-
-  test("#data_type") do
-    assert_equal(Arrow::BooleanDataType.new, @column.data_type)
-  end
-
-  test("#null?") do
-    assert do
-      @column.null?(1)
-    end
-  end
-
-  test("#valid?") do
-    assert do
-      @column.valid?(0)
-    end
-  end
-
-  test("#each") do
-    assert_equal([true, nil, false], @column.each.to_a)
-  end
-
-  test("#reverse_each") do
-    assert_equal([false, nil, true], @column.reverse_each.to_a)
-  end
-
-  test("#n_rows") do
-    assert_equal(3, @column.n_rows)
-  end
-
-  test("#n_nulls") do
-    assert_equal(1, @column.n_nulls)
-  end
-
-  sub_test_case("#==") do
-    test("same value") do
-      table1 = Arrow::Table.new("visible" => [true, false])
-      table2 = Arrow::Table.new("visible" => [true, false])
-      assert do
-        table1.visible == table2.visible
-      end
-    end
-
-    test("different name") do
-      table1 = Arrow::Table.new("visible" => [true, false])
-      table2 = Arrow::Table.new("invisible" => [true, false])
-      assert do
-        not table1.visible == table2.invisible
-      end
-    end
-
-    test("different value") do
-      table1 = Arrow::Table.new("visible" => [true, false])
-      table2 = Arrow::Table.new("visible" => [true, true])
-      assert do
-        not table1.visible == table2.visible
-      end
-    end
-
-    test("not Arrow::Column") do
-      table = Arrow::Table.new("visible" => [true, false])
-      assert do
-        not table.visible == 29
-      end
-    end
-  end
-
-  test("#count") do
-    table = Arrow::Table.new("revenue" => [1, nil, 3])
-    assert_equal(2, table["revenue"].count)
-  end
-
-  test("#min") do
-    table = Arrow::Table.new("revenue" => [1, 2, 3])
-    assert_equal(1, table["revenue"].min)
-  end
-
-  test("#max") do
-    table = Arrow::Table.new("revenue" => [1, 2, 3])
-    assert_equal(3, table["revenue"].max)
-  end
-
-  test("#sum") do
-    table = Arrow::Table.new("revenue" => [1, 2, 3])
-    assert_equal(6, table["revenue"].sum)
-  end
-
-  test("#uniq") do
-    table = Arrow::Table.new("revenue" => [1, 2, 2])
-    assert_equal([1, 2], table["revenue"].uniq)
-  end
-
-  test("#cast") do
-    table = Arrow::Table.new("revenue" => [1, nil, 3])
-    assert_equal(Arrow::ChunkedArray.new([["1", nil, "3"]]),
-                 table["revenue"].cast(:string))
-  end
-end

data/test/test-csv-loader.rb

@@ -1,297 +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 CSVLoaderTest < Test::Unit::TestCase
-  include Helper::Fixture
-  include Helper::Omittable
-
-  def load_csv(input)
-    Arrow::CSVLoader.load(input, skip_lines: /^#/)
-  end
-
-  sub_test_case(".load") do
-    test("String: data: with header") do
-      data = fixture_path("with-header-float.csv").read
-      assert_equal(<<-TABLE, load_csv(data).to_s)
-	  name	     score
-	(utf8)	  (double)
-0	alice 	 10.100000
-1	bob   	 29.200000
-2	chris 	 -1.300000
-      TABLE
-    end
-
-    test("String: data: without header") do
-      data = fixture_path("without-header-float.csv").read
-      assert_equal(<<-TABLE, load_csv(data).to_s)
-	     0	         1
-	(utf8)	  (double)
-0	alice 	 10.100000
-1	bob   	 29.200000
-2	chris 	 -1.300000
-      TABLE
-    end
-
-    test("String: path: with header") do
-      path = fixture_path("with-header-float.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	  name	     score
-	(utf8)	  (double)
-0	alice 	 10.100000
-1	bob   	 29.200000
-2	chris 	 -1.300000
-      TABLE
-    end
-
-    test("String: path: without header") do
-      path = fixture_path("without-header-float.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	     0	         1
-	(utf8)	  (double)
-0	alice 	 10.100000
-1	bob   	 29.200000
-2	chris 	 -1.300000
-      TABLE
-    end
-
-    test("Pathname: with header") do
-      path = fixture_path("with-header-float.csv")
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	  name	     score
-	(utf8)	  (double)
-0	alice 	 10.100000
-1	bob   	 29.200000
-2	chris 	 -1.300000
-      TABLE
-    end
-
-    test("Pathname: without header") do
-      path = fixture_path("without-header-float.csv")
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	     0	         1
-	(utf8)	  (double)
-0	alice 	 10.100000
-1	bob   	 29.200000
-2	chris 	 -1.300000
-      TABLE
-    end
-
-    test("null: with double quote") do
-      path = fixture_path("null-with-double-quote.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	  name	 score
-	(utf8)	(int8)
-0	alice 	    10
-1	bob   	(null)
-2	chris 	    -1
-      TABLE
-    end
-
-    test("null: without double quote") do
-      path = fixture_path("null-without-double-quote.csv").to_s
-      assert_equal(<<-TABLE, load_csv(path).to_s)
-	  name	 score
-	(utf8)	(int8)
-0	alice 	    10
-1	bob   	(null)
-2	chris 	    -1
-      TABLE
-    end
-
-    test("number: float, integer") do
-      path = fixture_path("float-integer.csv").to_s
-      assert_equal([2.9, 10, -1.1],
-                   load_csv(path)[:score].to_a)
-    end
-
-    test("number: integer, float") do
-      path = fixture_path("integer-float.csv").to_s
-      assert_equal([10.0, 2.9, -1.1],
-                   load_csv(path)[:score].to_a)
-    end
-  end
-
-  sub_test_case("CSVReader") do
-    def load_csv(data, **options)
-      Arrow::CSVLoader.load(data, **options)
-    end
-
-    sub_test_case(":headers") do
-      test("true") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(value: values),
-                     load_csv(<<-CSV, headers: true))
-value
-a
-b
-c
-                     CSV
-      end
-
-      test(":first_line") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(value: values),
-                     load_csv(<<-CSV, headers: :first_line))
-value
-a
-b
-c
-                     CSV
-      end
-
-      test("truthy") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(value: values),
-                     load_csv(<<-CSV, headers: 0))
-value
-a
-b
-c
-                     CSV
-      end
-
-      test("Array of column names") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(column: values),
-                     load_csv(<<-CSV, headers: ["column"]))
-a
-b
-c
-                     CSV
-      end
-
-      test("false") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(f0: values),
-                     load_csv(<<-CSV, headers: false))
-a
-b
-c
-                     CSV
-      end
-
-      test("nil") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(f0: values),
-                     load_csv(<<-CSV, headers: nil))
-a
-b
-c
-                     CSV
-      end
-
-      test("string") do
-        values = Arrow::StringArray.new(["a", "b", "c"])
-        assert_equal(Arrow::Table.new(column: values),
-                     load_csv(<<-CSV, headers: "column"))
-a
-b
-c
-                     CSV
-      end
-    end
-
-    test(":column_types") do
-      assert_equal(Arrow::Table.new(:count => Arrow::UInt16Array.new([1, 2, 4])),
-                   load_csv(<<-CSV, column_types: {count: :uint16}))
-count
-1
-2
-4
-                   CSV
-    end
-
-    test(":schema") do
-      table = Arrow::Table.new(:count => Arrow::UInt16Array.new([1, 2, 4]))
-      assert_equal(table,
-                   load_csv(<<-CSV, schema: table.schema))
-count
-1
-2
-4
-                   CSV
-    end
-
-    test(":encoding") do
-      messages = [
-        "\u3042", # U+3042 HIRAGANA LETTER A
-        "\u3044", # U+3044 HIRAGANA LETTER I
-        "\u3046", # U+3046 HIRAGANA LETTER U
-      ]
-      table = Arrow::Table.new(:message => Arrow::StringArray.new(messages))
-      encoding = "cp932"
-      assert_equal(table,
-                   load_csv((["message"] + messages).join("\n").encode(encoding),
-                            schema: table.schema,
-                            encoding: encoding))
-    end
-
-    test(":encoding and :compression") do
-      messages = [
-        "\u3042", # U+3042 HIRAGANA LETTER A
-        "\u3044", # U+3044 HIRAGANA LETTER I
-        "\u3046", # U+3046 HIRAGANA LETTER U
-      ]
-      table = Arrow::Table.new(:message => Arrow::StringArray.new(messages))
-      encoding = "cp932"
-      csv = (["message"] + messages).join("\n").encode(encoding)
-      assert_equal(table,
-                   load_csv(Zlib::Deflate.deflate(csv),
-                            schema: table.schema,
-                            encoding: encoding,
-                            compression: :gzip))
-    end
-
-    sub_test_case(":timestamp_parsers") do
-      test(":iso8601") do
-        require_glib(2, 58, 0)
-        data_type = Arrow::TimestampDataType.new(:second,
-                                                 GLib::TimeZone.new("UTC"))
-        timestamps = [
-          Time.iso8601("2024-03-16T23:54:12Z"),
-          Time.iso8601("2024-03-16T23:54:13Z"),
-          Time.iso8601("2024-03-16T23:54:14Z"),
-        ]
-        values = Arrow::TimestampArray.new(data_type, timestamps)
-        assert_equal(Arrow::Table.new(value: values),
-                     load_csv(<<-CSV, headers: true, timestamp_parsers: [:iso8601]))
-value
-#{timestamps[0].iso8601}
-#{timestamps[1].iso8601}
-#{timestamps[2].iso8601}
-                     CSV
-      end
-
-      test("String") do
-        timestamps = [
-          Time.iso8601("2024-03-16T23:54:12Z"),
-          Time.iso8601("2024-03-16T23:54:13Z"),
-          Time.iso8601("2024-03-16T23:54:14Z"),
-        ]
-        values = Arrow::TimestampArray.new(:second, timestamps)
-        format = "%Y-%m-%dT%H:%M:%S"
-        assert_equal(Arrow::Table.new(value: values).schema,
-                     load_csv(<<-CSV, headers: true, timestamp_parsers: [format]).schema)
-value
-#{timestamps[0].iso8601.chomp("Z")}
-#{timestamps[1].iso8601.chomp("Z")}
-#{timestamps[2].iso8601.chomp("Z")}
-                     CSV
-      end
-    end
-  end
-end