red-arrow 0.4.1 → 0.8.0

data/test/test-table.rb

@@ -1,4 +1,4 @@
-# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+# Copyright 2017-2018 Kouhei Sutou <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,20 +13,328 @@
 # limitations under the License.
 
 class TableTest < Test::Unit::TestCase
-  test("#columns") do
-    fields = [
-      Arrow::Field.new("count", :uint32),
-      Arrow::Field.new("visible", :boolean),
+  def setup
+    @count_field = Arrow::Field.new("count", :uint32)
+    @visible_field = Arrow::Field.new("visible", :boolean)
+    schema = Arrow::Schema.new([@count_field, @visible_field])
+    count_arrays = [
+      Arrow::UInt32Array.new([1, 2]),
+      Arrow::UInt32Array.new([4, 8, 16]),
+      Arrow::UInt32Array.new([32, 64]),
+      Arrow::UInt32Array.new([128]),
     ]
-    schema = Arrow::Schema.new(fields)
-    columns = [
-      Arrow::Column.new(fields[0],
-                        Arrow::UInt32Array.new([1, 2, 4, 8])),
-      Arrow::Column.new(fields[1],
-                        Arrow::BooleanArray.new([true, false, nil, true])),
+    visible_arrays = [
+      Arrow::BooleanArray.new([true, false, nil]),
+      Arrow::BooleanArray.new([true]),
+      Arrow::BooleanArray.new([true, false]),
+      Arrow::BooleanArray.new([nil]),
+      Arrow::BooleanArray.new([nil]),
     ]
-    table = Arrow::Table.new(schema, columns)
+    @count_array = Arrow::ChunkedArray.new(count_arrays)
+    @visible_array = Arrow::ChunkedArray.new(visible_arrays)
+    @count_column = Arrow::Column.new(@count_field, @count_array)
+    @visible_column = Arrow::Column.new(@visible_field, @visible_array)
+    @table = Arrow::Table.new(schema, [@count_column, @visible_column])
+  end
+
+  test("#columns") do
     assert_equal(["count", "visible"],
-                 table.columns.collect(&:name))
+                 @table.columns.collect(&:name))
+  end
+
+  sub_test_case("#slice") do
+    test("Arrow::BooleanArray") do
+      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	    2	false  
+1	    4	       
+2	   16	true   
+3	   64	       
+4	  128	       
+      TABLE
+    end
+
+    test("Integer") do
+      assert_equal(<<-TABLE, @table.slice(2).to_s)
+	count	visible
+0	    4	       
+      TABLE
+    end
+
+    test("Range: include end") do
+      assert_equal(<<-TABLE, @table.slice(2..4).to_s)
+	count	visible
+0	    4	       
+1	    8	true   
+2	   16	true   
+      TABLE
+    end
+
+    test("Range: exclude end") do
+      assert_equal(<<-TABLE, @table.slice(2...4).to_s)
+	count	visible
+0	    4	       
+1	    8	true   
+      TABLE
+    end
+
+    test("[from, to]") do
+      assert_equal(<<-TABLE, @table.slice([0, 2]).to_s)
+	count	visible
+0	    1	true   
+1	    2	false  
+      TABLE
+    end
+
+    test("Integer, Range, ...") do
+      assert_equal(<<-TABLE, @table.slice(0, 4...7).to_s)
+	count	visible
+0	    1	true   
+1	   16	true   
+2	   32	false  
+3	   64	       
+      TABLE
+    end
+  end
+
+  sub_test_case("#[]") do
+    test("[String]") do
+      assert_equal(@count_column, @table["count"])
+    end
+
+    test("[Symbol]") do
+      assert_equal(@visible_column, @table[:visible])
+    end
+
+    test("[String, Symbol]") do
+      assert_equal(Arrow::Table.new(@table.schema,
+                                    [@visible_column, @count_column]).to_s,
+                   @table["visible", :count].to_s)
+    end
+  end
+
+  sub_test_case("#merge") do
+    sub_test_case("Hash") do
+      test("add") do
+        name_array = Arrow::StringArray.new(["a", "b", "c", "d", "e", "f", "g", "h"])
+        assert_equal(<<-TABLE, @table.merge(:name => name_array).to_s)
+	count	visible	name
+0	    1	true   	a   
+1	    2	false  	b   
+2	    4	       	c   
+3	    8	true   	d   
+4	   16	true   	e   
+5	   32	false  	f   
+6	   64	       	g   
+7	  128	       	h   
+        TABLE
+      end
+
+      test("remove") do
+        assert_equal(<<-TABLE, @table.merge(:visible => nil).to_s)
+	count
+0	    1
+1	    2
+2	    4
+3	    8
+4	   16
+5	   32
+6	   64
+7	  128
+        TABLE
+      end
+
+      test("replace") do
+        visible_array = Arrow::Int32Array.new([1] * @visible_array.length)
+        assert_equal(<<-TABLE, @table.merge(:visible => visible_array).to_s)
+	count	visible
+0	    1	      1
+1	    2	      1
+2	    4	      1
+3	    8	      1
+4	   16	      1
+5	   32	      1
+6	   64	      1
+7	  128	      1
+        TABLE
+      end
+    end
+
+    sub_test_case("Arrow::Table") do
+      test("add") do
+        name_array = Arrow::StringArray.new(["a", "b", "c", "d", "e", "f", "g", "h"])
+        table = Arrow::Table.new("name" => name_array)
+        assert_equal(<<-TABLE, @table.merge(table).to_s)
+	count	visible	name
+0	    1	true   	a   
+1	    2	false  	b   
+2	    4	       	c   
+3	    8	true   	d   
+4	   16	true   	e   
+5	   32	false  	f   
+6	   64	       	g   
+7	  128	       	h   
+        TABLE
+      end
+
+      test("replace") do
+        visible_array = Arrow::Int32Array.new([1] * @visible_array.length)
+        table = Arrow::Table.new("visible" => visible_array)
+        assert_equal(<<-TABLE, @table.merge(table).to_s)
+	count	visible
+0	    1	      1
+1	    2	      1
+2	    4	      1
+3	    8	      1
+4	   16	      1
+5	   32	      1
+6	   64	      1
+7	  128	      1
+        TABLE
+      end
+    end
+  end
+
+  test("column name getter") do
+    assert_equal(@visible_column, @table.visible)
+  end
+
+  sub_test_case("#remove_column") do
+    test("String") do
+      assert_equal(<<-TABLE, @table.remove_column("visible").to_s)
+	count
+0	    1
+1	    2
+2	    4
+3	    8
+4	   16
+5	   32
+6	   64
+7	  128
+      TABLE
+    end
+
+    test("Symbol") do
+      assert_equal(<<-TABLE, @table.remove_column(:visible).to_s)
+	count
+0	    1
+1	    2
+2	    4
+3	    8
+4	   16
+5	   32
+6	   64
+7	  128
+      TABLE
+    end
+
+    test("unknown column name") do
+      assert_raise(KeyError) do
+        @table.remove_column(:nonexistent)
+      end
+    end
+
+    test("Integer") do
+      assert_equal(<<-TABLE, @table.remove_column(1).to_s)
+	count
+0	    1
+1	    2
+2	    4
+3	    8
+4	   16
+5	   32
+6	   64
+7	  128
+      TABLE
+    end
+
+    test("negative integer") do
+      assert_equal(<<-TABLE, @table.remove_column(-1).to_s)
+	count
+0	    1
+1	    2
+2	    4
+3	    8
+4	   16
+5	   32
+6	   64
+7	  128
+      TABLE
+    end
+
+    test("too small index") do
+      assert_raise(IndexError) do
+        @table.remove_column(-3)
+      end
+    end
+
+    test("too large index") do
+      assert_raise(IndexError) do
+        @table.remove_column(2)
+      end
+    end
+  end
+
+  sub_test_case("#select_columns") do
+    def setup
+      raw_table = {
+        :a => Arrow::UInt32Array.new([1]),
+        :b => Arrow::UInt32Array.new([1]),
+        :c => Arrow::UInt32Array.new([1]),
+        :d => Arrow::UInt32Array.new([1]),
+        :e => Arrow::UInt32Array.new([1]),
+      }
+      @table = Arrow::Table.new(raw_table)
+    end
+
+    test("names") do
+      assert_equal(<<-TABLE, @table.select_columns(:c, :a).to_s)
+	c	a
+0	1	1
+      TABLE
+    end
+
+    test("range") do
+      assert_equal(<<-TABLE, @table.select_columns(2...4).to_s)
+	c	d
+0	1	1
+      TABLE
+    end
+
+    test("indexes") do
+      assert_equal(<<-TABLE, @table.select_columns(0, -1, 2).to_s)
+	a	e	c
+0	1	1	1
+      TABLE
+    end
+
+    test("mixed") do
+      assert_equal(<<-TABLE, @table.select_columns(:a, -1, 2..3).to_s)
+	a	e	c	d
+0	1	1	1	1
+      TABLE
+    end
+
+    test("block") do
+      selected_table = @table.select_columns.with_index do |column, i|
+        column.name == "a" or i.odd?
+      end
+      assert_equal(<<-TABLE, selected_table.to_s)
+	a	b	d
+0	1	1	1
+      TABLE
+    end
+
+    test("names, indexes and block") do
+      selected_table = @table.select_columns(:a, -1) do |column|
+        column.name == "a"
+      end
+      assert_equal(<<-TABLE, selected_table.to_s)
+	a
+0	1
+      TABLE
+    end
   end
 end

data/test/test-timestamp-array.rb

@@ -0,0 +1,23 @@
+# Copyright 2017 Kouhei Sutou <kou@clear-code.com>
+#
+# Licensed 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 TimestampArrayTest < Test::Unit::TestCase
+  test("#[]") do
+    sec = 1513267750
+    usec = 914509
+    array = Arrow::TimestampArray.new(:micro, [sec * (10 ** 6) + usec])
+    time = Time.at(sec, usec)
+    assert_equal(time, array[0])
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-arrow
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-18 00:00:00.000000000 Z
+date: 2018-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gobject-introspection
@@ -138,6 +138,7 @@ files:
 - dependency-check/Rakefile
 - doc/text/apache-2.0.txt
 - doc/text/news.md
+- image/red-arrow.png
 - lib/arrow.rb
 - lib/arrow/array-builder.rb
 - lib/arrow/array.rb
@@ -146,25 +147,35 @@ files:
 - lib/arrow/chunked-array.rb
 - lib/arrow/column.rb
 - lib/arrow/compatibility.rb
+- lib/arrow/csv-reader.rb
 - lib/arrow/field.rb
 - lib/arrow/loader.rb
 - lib/arrow/record-batch-file-reader.rb
 - lib/arrow/record-batch-stream-reader.rb
 - lib/arrow/record-batch.rb
 - lib/arrow/record.rb
+- lib/arrow/slicer.rb
+- lib/arrow/table-formatter.rb
 - lib/arrow/table.rb
 - lib/arrow/tensor.rb
+- lib/arrow/timestamp-array.rb
 - lib/arrow/version.rb
 - red-arrow.gemspec
+- test/fixture/with-header.csv
+- test/fixture/without-header.csv
 - test/helper.rb
+- test/helper/fixture.rb
 - test/run-test.rb
 - test/test-array-builder.rb
 - test/test-array.rb
 - test/test-chunked-array.rb
 - test/test-column.rb
+- test/test-csv-reader.rb
 - test/test-record-batch-file-reader.rb
 - test/test-record-batch.rb
+- test/test-slicer.rb
 - test/test-table.rb
+- test/test-timestamp-array.rb
 homepage: https://github.com/red-data-tools/red-arrow
 licenses:
 - Apache-2.0
@@ -185,18 +196,24 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.2.2
 signing_key: 
 specification_version: 4
 summary: Red Arrow is a Ruby bindings of Apache Arrow. Red Arrow is based on GObject
   Introspection.
 test_files:
-- test/test-chunked-array.rb
-- test/test-table.rb
 - test/test-record-batch-file-reader.rb
+- test/fixture/with-header.csv
+- test/fixture/without-header.csv
+- test/test-csv-reader.rb
+- test/test-column.rb
 - test/test-array-builder.rb
-- test/run-test.rb
+- test/test-chunked-array.rb
 - test/test-record-batch.rb
 - test/helper.rb
-- test/test-column.rb
+- test/run-test.rb
+- test/test-timestamp-array.rb
+- test/test-table.rb
 - test/test-array.rb
+- test/helper/fixture.rb
+- test/test-slicer.rb