red-arrow 5.0.0 → 6.0.0

data/test/test-table.rb

@@ -53,26 +53,26 @@ class TableTest < Test::Unit::TestCase
       target_rows_raw = [nil, true, true, false, true, false, true, true]
       target_rows = Arrow::BooleanArray.new(target_rows_raw)
       assert_equal(<<-TABLE, @table.slice(target_rows).to_s)
-	count	visible
-0	     	       
-1	    2	false  
-2	    4	       
-3	   16	true   
-4	   64	       
-5	  128	       
+	 count	visible
+0	(null)	 (null)
+1	     2	false  
+2	     4	 (null)
+3	    16	true   
+4	    64	 (null)
+5	   128	 (null)
       TABLE
     end
 
     test("Array: boolean") do
       target_rows_raw = [nil, true, true, false, true, false, true, true]
       assert_equal(<<-TABLE, @table.slice(target_rows_raw).to_s)
-	count	visible
-0	     	       
-1	    2	false  
-2	    4	       
-3	   16	true   
-4	   64	       
-5	  128	       
+	 count	visible
+0	(null)	 (null)
+1	     2	false  
+2	     4	 (null)
+3	    16	true   
+4	    64	 (null)
+5	   128	 (null)
       TABLE
     end
 
@@ -100,7 +100,7 @@ class TableTest < Test::Unit::TestCase
     test("Range: positive: include end") do
       assert_equal(<<-TABLE, @table.slice(2..4).to_s)
 	count	visible
-0	    4	       
+0	    4	 (null)
 1	    8	true   
 2	   16	true   
       TABLE
@@ -109,7 +109,7 @@ class TableTest < Test::Unit::TestCase
     test("Range: positive: exclude end") do
       assert_equal(<<-TABLE, @table.slice(2...4).to_s)
 	count	visible
-0	    4	       
+0	    4	 (null)
 1	    8	true   
       TABLE
     end
@@ -119,7 +119,7 @@ class TableTest < Test::Unit::TestCase
 	count	visible
 0	   16	true   
 1	   32	false  
-2	   64	       
+2	   64	 (null)
       TABLE
     end
 
@@ -147,6 +147,104 @@ class TableTest < Test::Unit::TestCase
       TABLE
     end
 
+    test("{key: Number}") do
+      assert_equal(<<-TABLE, @table.slice(count: 16).to_s)
+	count	visible
+0	   16	true   
+      TABLE
+    end
+
+    test("{key: String}") do
+      table = Arrow::Table.new(name: Arrow::StringArray.new(["a", "b", "c"]))
+      assert_equal(<<-TABLE, table.slice(name: 'b').to_s)
+	name
+0	b   
+      TABLE
+    end
+
+    test("{key: true}") do
+      assert_equal(<<-TABLE, @table.slice(visible: true).to_s)
+	 count	visible
+0	     1	true   
+1	(null)	 (null)
+2	     8	true   
+3	    16	true   
+4	(null)	 (null)
+5	(null)	 (null)
+      TABLE
+    end
+
+    test("{key: false}") do
+      assert_equal(<<-TABLE, @table.slice(visible: false).to_s)
+	 count	visible
+0	     2	false  
+1	(null)	 (null)
+2	    32	false  
+3	(null)	 (null)
+4	(null)	 (null)
+      TABLE
+    end
+
+    test("{key: Range}: beginless include end") do
+      assert_equal(<<-TABLE, @table.slice(count: ..8).to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+2	    4	 (null)
+3	    8	true   
+      TABLE
+    end
+
+    test("{key: Range}: beginless exclude end") do
+      assert_equal(<<-TABLE, @table.slice(count: ...8).to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+2	    4	 (null)
+      TABLE
+    end
+
+    test("{key: Range}: endless") do
+      assert_equal(<<-TABLE, @table.slice(count: 16..).to_s)
+	count	visible
+0	   16	true   
+1	   32	false  
+2	   64	 (null)
+3	  128	 (null)
+      TABLE
+    end
+
+    test("{key: Range}: include end") do
+      assert_equal(<<-TABLE, @table.slice(count: 1..16).to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+2	    4	 (null)
+3	    8	true   
+4	   16	true   
+      TABLE
+    end
+
+    test("{key: Range}: exclude end") do
+      assert_equal(<<-TABLE, @table.slice(count: 1...16).to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+2	    4	 (null)
+3	    8	true   
+      TABLE
+    end
+
+    test("{key1: Range, key2: true}") do
+      assert_equal(<<-TABLE, @table.slice(count: 0..8, visible: false).to_s)
+	 count	visible
+0	     2	false  
+1	(null)	 (null)
+2	(null)	 (null)
+3	(null)	 (null)
+      TABLE
+    end
+
     sub_test_case("wrong argument") do
       test("no arguments") do
         message = "wrong number of arguments (given 0, expected 1..2)"
@@ -190,20 +288,45 @@ class TableTest < Test::Unit::TestCase
   end
 
   sub_test_case("#[]") do
+    def setup
+      @table = Arrow::Table.new(a: [true],
+                                b: [true],
+                                c: [true],
+                                d: [true],
+                                e: [true],
+                                f: [true],
+                                g: [true])
+    end
+
     test("[String]") do
       assert_equal(Arrow::Column.new(@table, 0),
-                   @table["count"])
+                   @table["a"])
     end
 
     test("[Symbol]") do
       assert_equal(Arrow::Column.new(@table, 1),
-                   @table[:visible])
+                   @table[:b])
     end
 
     test("[Integer]") do
-      assert_equal(Arrow::Column.new(@table, 1),
+      assert_equal(Arrow::Column.new(@table, 6),
                    @table[-1])
     end
+
+    test("[Range]") do
+      assert_equal(Arrow::Table.new(d: [true],
+                                    e: [true]),
+                   @table[3..4])
+    end
+
+    test("[[Symbol, String, Integer, Range]]") do
+      assert_equal(Arrow::Table.new(c: [true],
+                                    a: [true],
+                                    g: [true],
+                                    d: [true],
+                                    e: [true]),
+                   @table[[:c, "a", -1, 3..4]])
+    end
   end
 
   sub_test_case("#merge") do
@@ -214,12 +337,12 @@ class TableTest < Test::Unit::TestCase
 	count	visible	name
 0	    1	true   	a   
 1	    2	false  	b   
-2	    4	       	c   
+2	    4	 (null)	c   
 3	    8	true   	d   
 4	   16	true   	e   
 5	   32	false  	f   
-6	   64	       	g   
-7	  128	       	h   
+6	   64	 (null)	g   
+7	  128	 (null)	h   
         TABLE
       end
 
@@ -261,12 +384,12 @@ class TableTest < Test::Unit::TestCase
 	count	visible	name
 0	    1	true   	a   
 1	    2	false  	b   
-2	    4	       	c   
+2	    4	 (null)	c   
 3	    8	true   	d   
 4	   16	true   	e   
 5	   32	false  	f   
-6	   64	       	g   
-7	  128	       	h   
+6	   64	 (null)	g   
+7	  128	 (null)	h   
         TABLE
       end
 
@@ -614,12 +737,12 @@ chris\t-1
 	count	visible
 0	    1	true   
 1	    2	false  
-2	    4	       
+2	    4	 (null)
 3	    8	true   
 4	   16	true   
 5	   32	false  
-6	   64	       
-7	  128	       
+6	   64	 (null)
+7	  128	 (null)
     TABLE
   end
 
@@ -707,13 +830,13 @@ visible: false
     test("Array: boolean") do
       filter = [nil, true, true, false, true, false, true, true]
       assert_equal(<<-TABLE, @table.filter(filter, @options).to_s)
-	count	visible
-0	     	       
-1	    2	false  
-2	    4	       
-3	   16	true   
-4	   64	       
-5	  128	       
+	 count	visible
+0	(null)	 (null)
+1	     2	false  
+2	     4	 (null)
+3	    16	true   
+4	    64	 (null)
+5	   128	 (null)
       TABLE
     end
 
@@ -721,13 +844,13 @@ visible: false
       array = [nil, true, true, false, true, false, true, true]
       filter = Arrow::BooleanArray.new(array)
       assert_equal(<<-TABLE, @table.filter(filter, @options).to_s)
-	count	visible
-0	     	       
-1	    2	false  
-2	    4	       
-3	   16	true   
-4	   64	       
-5	  128	       
+	 count	visible
+0	(null)	 (null)
+1	     2	false  
+2	     4	 (null)
+3	    16	true   
+4	    64	 (null)
+5	   128	 (null)
       TABLE
     end
 
@@ -739,13 +862,13 @@ visible: false
       ]
       filter = Arrow::ChunkedArray.new(filter_chunks)
       assert_equal(<<-TABLE, @table.filter(filter, @options).to_s)
-	count	visible
-0	     	       
-1	    2	false  
-2	    4	       
-3	   16	true   
-4	   64	       
-5	  128	       
+	 count	visible
+0	(null)	 (null)
+1	     2	false  
+2	     4	 (null)
+3	    16	true   
+4	    64	 (null)
+5	   128	 (null)
       TABLE
     end
   end
@@ -757,7 +880,7 @@ visible: false
 	count	visible
 0	    2	false  
 1	    1	true   
-2	    4	       
+2	    4	 (null)
       TABLE
     end
 
@@ -767,7 +890,7 @@ visible: false
 	count	visible
 0	    2	false  
 1	    1	true   
-2	    4	       
+2	    4	 (null)
       TABLE
     end
 
@@ -781,7 +904,21 @@ visible: false
 	count	visible
 0	    2	false  
 1	    1	true   
-2	    4	       
+2	    4	 (null)
+      TABLE
+    end
+  end
+
+  sub_test_case("#concatenate") do
+    test("options: :unify_schemas") do
+      table1 = Arrow::Table.new(a: [true],
+                                b: [false])
+      table2 = Arrow::Table.new(b: [false])
+      concatenated = table1.concatenate([table2], unify_schemas: true)
+      assert_equal(<<-TABLE, concatenated.to_s)
+	a	b
+0	true	false
+1	(null)	false
       TABLE
     end
   end

data/test/values/test-dense-union-array.rb

@@ -382,6 +382,20 @@ module ValuesDenseUnionArrayTests
     assert_equal(values, target.values)
   end
 
+  def test_map
+    values = [
+      {"0" => {"key1" => true, "key2" => nil}},
+      {"1" => nil},
+    ]
+    target = build({
+                     type: :map,
+                     key: :string,
+                     item: :boolean,
+                   },
+                   values)
+    assert_equal(values, target.values)
+  end
+
   def test_sparse_union
     omit("Need to add support for SparseUnionArrayBuilder")
     values = [

data/test/values/test-list-array.rb

@@ -420,6 +420,23 @@ module ValuesListArrayTests
     assert_equal(values, target.values)
   end
 
+  def test_map
+    values = [
+      [
+        {"key1" => true, "key2" => nil},
+        nil,
+      ],
+      nil,
+    ]
+    target = build({
+                     type: :map,
+                     key: :string,
+                     item: :boolean,
+                   },
+                   values)
+    assert_equal(values, target.values)
+  end
+
   def test_sparse
     omit("Need to add support for SparseUnionArrayBuilder")
     values = [