red-arrow 0.15.1 → 0.16.0

data/test/test-array.rb

@@ -63,5 +63,107 @@ class ArrayTest < Test::Unit::TestCase
         end
       end
     end
+
+    sub_test_case("#cast") do
+      test("Symbol") do
+        assert_equal(Arrow::Int32Array.new([1, 2, 3]),
+                     Arrow::StringArray.new(["1", "2", "3"]).cast(:int32))
+      end
+    end
+  end
+
+  sub_test_case("#filter") do
+    def setup
+      values = [true, false, false, true]
+      @array = Arrow::BooleanArray.new(values)
+    end
+
+    test("Array: boolean") do
+      filter = [nil, true, true, false]
+      filtered_array = Arrow::BooleanArray.new([nil, false, false])
+      assert_equal(filtered_array,
+                   @array.filter(filter))
+    end
+
+    test("Arrow::BooleanArray") do
+      filter = Arrow::BooleanArray.new([nil, true, true, false])
+      filtered_array = Arrow::BooleanArray.new([nil, false, false])
+      assert_equal(filtered_array,
+                   @array.filter(filter))
+    end
+
+    test("Arrow::ChunkedArray") do
+      chunks = [
+        Arrow::BooleanArray.new([nil, true]),
+        Arrow::BooleanArray.new([true, false]),
+      ]
+      filter = Arrow::ChunkedArray.new(chunks)
+      filtered_array = Arrow::BooleanArray.new([nil, false, false])
+      assert_equal(filtered_array,
+                   @array.filter(filter))
+    end
+  end
+
+  sub_test_case("#take") do
+    def setup
+      values = [1, 0 ,2]
+      @array = Arrow::Int16Array.new(values)
+    end
+
+    test("Arrow: boolean") do
+      indices = [1, 0, 2]
+      assert_equal(Arrow::Int16Array.new([0, 1, 2]),
+                   @array.take(indices))
+    end
+
+    test("Arrow::Array") do
+      indices = Arrow::Int16Array.new([1, 0, 2])
+      assert_equal(Arrow::Int16Array.new([0, 1, 2]),
+                   @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,
+                   @array.take(indices))
+    end
+  end
+
+  sub_test_case("#is_in") do
+    def setup
+      values = [1, 0, 1, 2]
+      @array = Arrow::Int16Array.new(values)
+    end
+
+    test("Arrow: Array") do
+      right = [2, 0]
+      assert_equal(Arrow::BooleanArray.new([false, true, false, true]),
+                   @array.is_in(right))
+    end
+
+    test("Arrow::Array") do
+      right = Arrow::Int16Array.new([2, 0])
+      assert_equal(Arrow::BooleanArray.new([false, true, false, true]),
+                   @array.is_in(right))
+    end
+
+    test("Arrow::ChunkedArray") do
+      chunks = [
+        Arrow::Int16Array.new([1, 0]),
+        Arrow::Int16Array.new([1, 0, 3])
+      ]
+      right = Arrow::ChunkedArray.new(chunks)
+      assert_equal(Arrow::BooleanArray.new([true, true, true, false]),
+                   @array.is_in(right))
+    end
   end
 end

data/test/test-chunked-array.rb

@@ -84,4 +84,98 @@ class ChunkedArrayTest < Test::Unit::TestCase
       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)
+    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))
+    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))
+    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))
+    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
 end

data/test/test-csv-loader.rb

@@ -117,8 +117,8 @@ class CSVLoaderTest < Test::Unit::TestCase
   end
 
   sub_test_case("CSVReader") do
-    def load_csv(data, options)
-      Arrow::CSVLoader.load(data, options)
+    def load_csv(data, **options)
+      Arrow::CSVLoader.load(data, **options)
     end
 
     sub_test_case(":headers") do

data/test/test-data-type.rb

@@ -48,6 +48,17 @@ class DataTypeTest < Test::Unit::TestCase
       assert_equal(Arrow::FixedSizeBinaryDataType.new(10),
                    Arrow::DataType.resolve([:fixed_size_binary, 10]))
     end
+
+    test("abstract") do
+      message =
+        "abstract type: <:floating_point>: " +
+        "use one of not abstract type: [" +
+        "Arrow::DoubleDataType, " +
+        "Arrow::FloatDataType]"
+      assert_raise(ArgumentError.new(message)) do
+        Arrow::DataType.resolve(:floating_point)
+      end
+    end
   end
 
   sub_test_case("instance methods") do

data/test/test-list-data-type.rb

@@ -23,7 +23,7 @@ class ListDataTypeTest < Test::Unit::TestCase
                    Arrow::ListDataType.new(field).to_s)
     end
 
-    test("Hash") do
+    test("name: String") do
       assert_equal("list<tag: string>",
                    Arrow::ListDataType.new(name: "tag", type: :string).to_s)
     end
@@ -39,5 +39,31 @@ class ListDataTypeTest < Test::Unit::TestCase
       assert_equal("list<tag: string>",
                    Arrow::ListDataType.new(field: field_description).to_s)
     end
+
+    test("Arrow::DataType") do
+      data_type = Arrow::BooleanDataType.new
+      assert_equal("list<item: bool>",
+                   Arrow::ListDataType.new(data_type).to_s)
+    end
+
+    test("String") do
+      assert_equal("list<item: bool>",
+                   Arrow::ListDataType.new("boolean").to_s)
+    end
+
+    test("Symbol") do
+      assert_equal("list<item: bool>",
+                   Arrow::ListDataType.new(:boolean).to_s)
+    end
+
+    test("[data type name, additional information]") do
+      assert_equal("list<item: time32[ms]>",
+                   Arrow::ListDataType.new([:time32, :milli]).to_s)
+    end
+
+    test("type: Symbol") do
+      assert_equal("list<item: bool>",
+                   Arrow::ListDataType.new(type: :boolean).to_s)
+    end
   end
 end

data/test/test-null-array.rb

@@ -0,0 +1,23 @@
+# 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 NullArrayTest < Test::Unit::TestCase
+  test("#[]") do
+    array = Arrow::NullArray.new(1)
+    assert_nil(array[0])
+  end
+end

data/test/test-slicer.rb

@@ -46,10 +46,14 @@ class SlicerTest < Test::Unit::TestCase
       end
       assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	    1	true   
-1	    8	true   
-2	   16	true   
-3	  256	true   
+0	     	       
+1	    1	true   
+2	     	       
+3	    8	true   
+4	   16	true   
+5	     	       
+6	     	       
+7	  256	true   
       TABLE
     end
 
@@ -66,7 +70,8 @@ class SlicerTest < Test::Unit::TestCase
 4	   16	true   
 5	   32	false  
 6	   64	       
-7	  256	true   
+7	     	       
+8	  256	true   
       TABLE
     end
   end
@@ -78,8 +83,12 @@ class SlicerTest < Test::Unit::TestCase
       end
       assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	    2	false  
-1	   32	false  
+0	     	       
+1	    2	false  
+2	     	       
+3	   32	false  
+4	     	       
+5	     	       
       TABLE
     end
 
@@ -90,6 +99,7 @@ class SlicerTest < Test::Unit::TestCase
       assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
 0	    0	       
+1	     	       
       TABLE
     end
   end
@@ -142,10 +152,14 @@ class SlicerTest < Test::Unit::TestCase
       end
       assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	    1	true   
-1	    8	true   
-2	   16	true   
-3	  256	true   
+0	     	       
+1	    1	true   
+2	     	       
+3	    8	true   
+4	   16	true   
+5	     	       
+6	     	       
+7	  256	true   
       TABLE
     end
   end
@@ -172,8 +186,12 @@ class SlicerTest < Test::Unit::TestCase
       end
       assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	    2	false  
-1	   32	false  
+0	     	       
+1	    2	false  
+2	     	       
+3	   32	false  
+4	     	       
+5	     	       
       TABLE
     end
   end
@@ -200,8 +218,12 @@ class SlicerTest < Test::Unit::TestCase
       end
       assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	    2	false  
-1	   32	false  
+0	     	       
+1	    2	false  
+2	     	       
+3	   32	false  
+4	     	       
+5	     	       
       TABLE
     end
   end
@@ -217,6 +239,7 @@ class SlicerTest < Test::Unit::TestCase
 2	    2	false  
 3	    4	       
 4	    8	true   
+5	     	       
     TABLE
   end
 
@@ -229,7 +252,8 @@ class SlicerTest < Test::Unit::TestCase
 0	   16	true   
 1	   32	false  
 2	   64	       
-3	  256	true   
+3	     	       
+4	  256	true   
     TABLE
   end
 
@@ -245,6 +269,7 @@ class SlicerTest < Test::Unit::TestCase
 3	    4	       
 4	    8	true   
 5	   16	true   
+6	     	       
     TABLE
   end
 
@@ -256,7 +281,8 @@ class SlicerTest < Test::Unit::TestCase
 	count	visible
 0	   32	false  
 1	   64	       
-2	  256	true   
+2	     	       
+3	  256	true   
     TABLE
   end
 
@@ -268,7 +294,8 @@ class SlicerTest < Test::Unit::TestCase
 	count	visible
 0	   32	false  
 1	   64	       
-2	  256	true   
+2	     	       
+3	  256	true   
     TABLE
   end
 
@@ -284,6 +311,7 @@ class SlicerTest < Test::Unit::TestCase
 3	    4	       
 4	    8	true   
 5	   16	true   
+6	     	       
     TABLE
   end
 
@@ -296,7 +324,8 @@ class SlicerTest < Test::Unit::TestCase
 0	   16	true   
 1	   32	false  
 2	   64	       
-3	  256	true   
+3	     	       
+4	  256	true   
     TABLE
   end
 
@@ -311,6 +340,7 @@ class SlicerTest < Test::Unit::TestCase
 2	    2	false  
 3	    4	       
 4	    8	true   
+5	     	       
     TABLE
   end
 
@@ -324,6 +354,7 @@ class SlicerTest < Test::Unit::TestCase
 1	    4	       
 2	   16	true   
 3	   64	       
+4	     	       
     TABLE
   end
 
@@ -337,7 +368,8 @@ class SlicerTest < Test::Unit::TestCase
 1	    2	false  
 2	    8	true   
 3	   32	false  
-4	  256	true   
+4	     	       
+5	  256	true   
     TABLE
   end
 
@@ -347,8 +379,12 @@ class SlicerTest < Test::Unit::TestCase
     end
     assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	   16	true   
-1	  256	true   
+0	     	       
+1	     	       
+2	   16	true   
+3	     	       
+4	     	       
+5	  256	true   
     TABLE
   end
 
@@ -358,11 +394,15 @@ class SlicerTest < Test::Unit::TestCase
     end
     assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	    1	true   
-1	    8	true   
-2	   16	true   
-3	   32	false  
-4	  256	true   
+0	     	       
+1	    1	true   
+2	     	       
+3	    8	true   
+4	   16	true   
+5	   32	false  
+6	     	       
+7	     	       
+8	  256	true   
     TABLE
   end
 
@@ -372,9 +412,13 @@ class SlicerTest < Test::Unit::TestCase
     end
     assert_equal(<<-TABLE, sliced_table.to_s)
 	count	visible
-0	    1	true   
-1	    8	true   
-2	   32	false  
+0	     	       
+1	    1	true   
+2	     	       
+3	    8	true   
+4	   32	false  
+5	     	       
+6	     	       
     TABLE
   end