hbase-jruby 0.2.6-java → 0.3.0-java

data/test/test_schema.rb

@@ -0,0 +1,275 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+require 'set'
+
+class TestSchema < TestHBaseJRubyBase
+  def teardown
+    @hbase.schema[@table.name] = {}
+
+    # Same
+    @hbase.schema.delete @table.name
+  end
+
+  def test_schema
+    @hbase.schema = {
+      @table.name => {
+        :cf1 => {
+          :a    => :fixnum,
+          :b    => :symbol,
+          :c    => :int,
+          /^d/i => :float,
+          'd2'  => :short,
+        },
+        # Every column from cf2 is :string
+        :cf2 => { :e => :string },
+
+        # cf3:f is a 8-byte integer
+        :cf3 => { :f => :fixnum },
+      }
+    }
+
+    data = {
+      :a  => 100,
+      :b  => :symb,
+      :c  => 200,
+      :d  => 3.14,
+      :d2 => 300,
+      :e  => 'Hello',
+      :f  => 400,
+      [:cf1, HBase::ByteArray['x']] => 500
+    }
+
+    # PUT
+    @table.put 1, 'cf1:a' => data[:a], 'cf1:b'  => data[:b],    'cf1:c' => data[:c],
+                  'cf1:d' => data[:d], 'cf1:d2' => data[:d2],   'cf2:e'  => data[:e],
+                  'cf3:f' => data[:f], 'cf1:x'  => data[[:cf1, HBase::ByteArray['x']]]
+    @table.put 2, data
+
+    # GET
+    row = @table.get(2)
+    assert_equal Set[ *@table.get(1).to_h.values.map { |b| HBase::ByteArray.new b }],
+                 Set[ *          row.to_h.values.map { |b| HBase::ByteArray.new b }]
+    assert_equal Set[ *@table.get(1).to_h.keys ], Set[ *row.to_h.keys ]
+    assert_equal Set[ *data.keys ],               Set[ *row.to_h.keys ]
+
+    assert_equal data[:a],  row[:a]
+    assert_equal data[:a],  row['a']
+
+    assert_equal data[:b],  row[:b]
+    assert_equal data[:b],  row['b']
+
+    assert_equal data[:c],  row[:c]
+    assert_equal data[:c],  row['c']
+
+    assert_equal data[:d],  row[:d]
+    assert_equal data[:d],  row['d']
+
+    assert_equal data[:d2], row[:d2]
+    assert_equal data[:d2], row['d2']
+
+    assert_equal data[:e],  row['cf2:e']
+    assert_equal data[:f],  row['cf3:f']
+
+    assert_equal data[[:cf1, HBase::ByteArray['x']]], HBase::Util.from_bytes(:long, row['cf1:x'])
+
+    data1 = @table.get(1).to_h
+    data1[:a] *= 2
+    data1[:b] = :new_symbol
+    @table.put 3, data1
+    @table.increment 3, :a => 5
+
+    # PUT again
+    assert_equal data[:a] * 2 + 5, @table.get(3)[:a]
+    assert_equal :new_symbol,      @table.get(3)[:b]
+    assert_equal :new_symbol,      @table.get(3)['b']
+    assert_equal :new_symbol,      @table.get(3)['cf1:b']
+
+    # PROJECT
+    assert_equal [:a, :c, :e, :f],
+      @table.project(:a, 'cf1:c', :cf2, :cf3).first.to_h.keys
+
+    # FILTER
+    assert_equal 1, @table.filter(:b => :new_symbol).count
+    assert_equal 2, @table.filter(:b => data[:b]).count
+
+    assert_equal 2, @table.filter(  'cf1:a' => 50..110).count
+    assert_equal 2, @table.filter(      'a' => 50..110).count
+    assert_equal 2, @table.filter(       :a => 50..110).count
+    assert_equal 1, @table.filter(:a => { :gt => 150 }).count
+  end
+
+  def test_schema_readme
+    @hbase.schema[@table.name] = {
+      :cf1 => {
+        :name   => :string,
+        :age    => :fixnum,
+        :sex    => :symbol,
+        :height => :float,
+        :weight => :float,
+        :alive  => :boolean
+      },
+      :cf2 => {
+        :description => :string,
+        /^score.*/   => :float
+      }
+    }
+
+    data = {
+      :name        => 'John Doe',
+      :age         => 20,
+      :sex         => :male,
+      :height      => 6.0,
+      :weight      => 175,
+      :description => 'N/A',
+      :score1      => 8.0,
+      :score2      => 9.0,
+      :score3      => 10.0,
+      :alive       => true
+    }
+
+    @table.put(100 => data)
+
+    john = @table.get(100)
+
+    data.each do |k, v|
+      assert_equal v, john[k]
+      assert_equal v, john[k.to_s]
+    end
+
+    assert_equal 20,   john[:age]
+    assert_equal 10.0, john[:score3]
+
+    assert_equal data, john.to_h
+    assert_equal data, Hash[ john.to_H.map { |k, v| [k, v.first.last] } ]
+  end
+
+  def test_schema_book
+    table = @table
+
+    @hbase.schema[table.name] = {
+      # Columns in cf1 family
+      :cf1 => {
+        :title    => :string,
+        :author   => :string,
+        :category => :string,
+        :year     => :short,
+        :pages    => :fixnum,
+        :price    => :bigdecimal,
+        :weight   => :float,
+        :in_print => :boolean
+      },
+      # Columns in cf2 family
+      :cf2 => {
+        :summary      => :string,
+        :reviews      => :fixnum,
+        :stars        => :fixnum,
+        /^comment\d+/ => :string
+      }
+    }
+
+    # Put data (rowkey: 1)
+    data = {
+      :title    => 'The Golden Bough: A Study of Magic and Religion',
+      :author   => 'Sir James G. Frazer',
+      :category => 'Occult',
+      :year     => 1890,
+      :pages    => 1006,
+      :price    => BigDecimal('21.50'),
+      :weight   => 3.0,
+      :in_print => true,
+      :summary  => 'A wide-ranging, comparative study of mythology and religion',
+      :reviews  => 52,
+      :stars    => 226,
+      :comment1 => 'A must-have',
+      :comment2 => 'Rewarding purchase'
+    }
+    table.put 1, data
+
+    # Get data (rowkey: 1)
+    book = table.get 1
+
+    assert_equal data, book.to_h
+    assert_equal data[:title], book['title']
+    assert_equal data[:comment2], book['comment2']
+
+    assert_equal true, book.to_H.values.map(&:keys).flatten.all? { |e| e.is_a? Fixnum }
+
+    # Scan table
+    table.range(0..100).
+          filter(:year     => 1880...1900,
+                 :in_print => true,
+                 :category => ['Comics', 'Fiction', /cult/i],
+                 :price    => { :lt => BigDecimal('30.00') },
+                 :summary  => /myth/i).
+          project(:cf1, :reviews).
+          each do |book|
+
+      assert_equal data[:title], book[:title]
+      assert_equal data[:reviews], book[:reviews]
+      assert_equal nil, book[:summary]
+
+      # Update price
+      table.put book.rowkey => { :price => book[:price] + BigDecimal('1') }
+
+      # Atomic increment
+      table.increment book.rowkey, :reviews => 1, :stars => 5
+    end
+
+    assert_equal data[:price]   + 1.0, table.get(1)[:price]
+    assert_equal data[:reviews] + 1,   table.get(1)[:reviews]
+    assert_equal data[:stars]   + 5,   table.get(1)[:stars]
+
+    # Coprocessor
+    table.enable_aggregation!
+    table.put 2, :reviews => 100, :stars => 500
+    assert_equal data[:reviews] + 1 + data[:stars] + 5 + 100 + 500,
+      table.project(:reviews, :stars).aggregate(:sum)
+    #table.disable_aggregation!
+
+    # Undefined columns
+    table.put 1, 'cf1:x'      => 1000
+    table.put 1, [:cf1, :y]   => 2000
+    table.put 1, [:cf1, 2013] => 3000
+    assert_equal 1000, table.get(1).fixnum('cf1:x')
+
+    [
+      [:cf1, HBase::ByteArray['x']],
+      ['cf1', HBase::ByteArray['x']],
+      [:cf1, :x],
+      [:cf1, 'x'],
+      ['cf1', :x],
+      %w[cf1 x],
+      'cf1:x'
+    ].each do |param|
+      assert_equal 1000, HBase::Util.from_bytes(:fixnum, table.get(1)[param])
+      assert_equal 1000, HBase::Util.from_bytes(:fixnum, table.get(1)[*param])
+      assert_equal 1000, HBase::Util.from_bytes(:fixnum, table.get(1).to_h[param])
+    end
+
+    assert_equal 2000, HBase::Util.from_bytes(:fixnum, table.get(1)[:cf1, :y])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(1)[:cf1, 2013])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(1)[[:cf1, 2013]])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(1).to_h[[:cf1, HBase::ByteArray[2013]]])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(1).to_h[[:cf1, 2013]])
+
+    # Delete :title column of book 1
+    table.delete 1, :title
+    assert_equal nil, table.get(1)[:title]
+    assert_equal data[:author], table.get(1)[:author]
+
+    # Delete column family
+    table.delete 1, :cf1
+    assert_equal nil, table.get(1)[:author]
+    assert_equal data[:summary], table.get(1)[:summary]
+
+    # Delete book 1
+    table.delete 1
+    assert_equal nil, table.get(1)
+
+    # Drop table for subsequent tests
+    table.drop!
+  end
+end
+

data/test/test_scoped.rb

@@ -57,12 +57,12 @@ class TestScoped < TestHBaseJRubyBase
       @table.put(i, 'cf1:a' => i, 'cf2:b' => i, 'cf3:c' => i * 3)
     end
 
-    assert_instance_of HBase::Scoped, @table.each
-    scoped = @table.each
-    assert_equal scoped, scoped.each
+    assert_instance_of HBase::Scoped, @table.scoped
+    assert_instance_of Enumerator, @table.each
 
     assert_equal 50, @table.count
     assert_equal 50, @table.each.count
+    assert_equal 50, @table.each.take_while { true }.count
     assert_equal 50, @table.to_a.length # each
 
     # Start key
@@ -147,21 +147,25 @@ class TestScoped < TestHBaseJRubyBase
     end
     insert.call
 
-    assert_instance_of HBase::Scoped, @table.each
+    assert_instance_of HBase::Scoped, @table.scoped
+
+    get_cols = lambda do |hsh|
+      hsh.keys.map { |e| [e[0], e[1].decode(:string)].join ':' }
+    end
 
     # Test both for HBase::Table and HBase::Scoped
-    [@table, @table.each].each do |table|
+    [@table, @table.scoped].each do |table|
       # project
       project_cols = ['cf1:a', 'cf3:c']
       assert table.project(*project_cols).all? { |result|
-        result.to_hash.keys == project_cols
+        get_cols.call(result.to_h) == project_cols
       }
 
       # project: additive
-      assert_equal project_cols + ['cf3:d'], table.project(*project_cols).project('cf3:d').first.to_hash.keys.map(&:to_s)
+      assert_equal project_cols + ['cf3:d'], get_cols.call( table.project(*project_cols).project('cf3:d').first.to_h )
 
       # project: family
-      assert_equal %w[cf1:a cf3:c cf3:d cf3:e], table.project('cf1:a', 'cf3').first.to_hash.keys.map(&:to_s)
+      assert_equal %w[cf1:a cf3:c cf3:d cf3:e], get_cols.call( table.project('cf1:a', 'cf3').first.to_h )
 
       # filter: Hash
       #   to_a.length instead of count :)
@@ -189,16 +193,18 @@ class TestScoped < TestHBaseJRubyBase
       # filter: Java filter
       # Bug: https://issues.apache.org/jira/browse/HBASE-6954
       import org.apache.hadoop.hbase.filter.ColumnPaginationFilter
-      assert_equal 3, table.filter(ColumnPaginationFilter.new(3, 1)).first.to_hash.keys.length
+      assert_equal 3, table.filter(ColumnPaginationFilter.new(3, 1)).first.to_h.keys.length
 
       # filter: Java filter list
       import org.apache.hadoop.hbase.filter.FilterList
       import org.apache.hadoop.hbase.filter.ColumnRangeFilter
       assert_equal %w[cf2:b cf3:c],
-          table.filter(FilterList.new [
-             ColumnRangeFilter.new('a'.to_java_bytes, true, 'd'.to_java_bytes, true),
-             ColumnPaginationFilter.new(2, 1),
-          ]).first.to_hash.keys.map(&:to_s)
+          get_cols.call(
+            table.filter(FilterList.new [
+               ColumnRangeFilter.new('a'.to_java_bytes, true, 'd'.to_java_bytes, true),
+               ColumnPaginationFilter.new(2, 1),
+            ]).first.to_h
+          )
 
 
       # limit with filter
@@ -212,10 +218,10 @@ class TestScoped < TestHBaseJRubyBase
     end
 
     insert.call
-    [@table, @table.each].each do |table|
+    [@table, @table.scoped].each do |table|
       # versions
-      assert table.all? { |result| result.to_hash_with_versions['cf1:a'].length == 2 }
-      assert table.versions(1).all? { |result| result.to_hash_with_versions['cf1:a'].length == 1 }
+      assert table.all? { |result| result.to_H[%w[cf1 a]].length == 2 }
+      assert table.versions(1).all? { |result| result.to_H[%w[cf1 a]].length == 1 }
     end
   end
 
@@ -233,7 +239,7 @@ class TestScoped < TestHBaseJRubyBase
       @table.put rk.to_s, 'cf1:a' => rk
     end
     assert_equal 20, @table.range('1'..'9').count
-    assert_equal %w[1 10 11 12 13 14 15 16 17 18 19 2 20 3 4 5 6 7 8 9], @table.range('1'..'9').map(&:rowkey)
+    assert_equal %w[1 10 11 12 13 14 15 16 17 18 19 2 20 3 4 5 6 7 8 9], @table.range('1'..'9').map { |e| e.rowkey :string }
 
     assert_equal 19, @table.range('1'...'9').count
 
@@ -249,21 +255,18 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_non_string_column_name
-    @table.put 'rowkey', Hash[ (1..20).map { |cq| [HBase::ColumnKey('cf1', cq), cq] } ]
+    @table.put 'rowkey', Hash[ (1..20).map { |cq| [['cf1', cq], cq] } ]
 
-    assert((1..20).all? { |cq| @table.get('rowkey').fixnum(HBase::ColumnKey('cf1', cq)) == cq })
+    assert((1..20).all? { |cq| @table.get('rowkey').fixnum(['cf1', cq]) == cq })
 
     assert @table.project(['cf1', 10], ['cf1', 20]).map { |r|
-      [r.fixnum(HBase::ColumnKey('cf1', 10)), r.fixnum(HBase::ColumnKey.new('cf1', 20))]
+      [r.fixnum(['cf1', 10]), r.fixnum(['cf1', 20])]
     }.all? { |e| e == [10, 20] }
 
-    hash = @table.get('rowkey').to_hash(
-      HBase::ColumnKey('cf1', 1) => :fixnum,
-      HBase::ColumnKey('cf1', 2) => :fixnum
-    )
-    assert_equal 1, hash[HBase::ColumnKey(:cf1, 1)]
-    assert_equal 2, hash[HBase::ColumnKey(:cf1, 2)]
-    assert_equal 3, HBase::Util.from_bytes(:fixnum, hash[HBase::ColumnKey(:cf1, 3)])
+    hash = @table.get('rowkey').to_h
+    assert_equal 1, HBase::Util.from_bytes(:fixnum, hash[[:cf1, 1]])
+    assert_equal 2, HBase::Util.from_bytes(:fixnum, hash[[:cf1, 2]])
+    assert_equal 3, HBase::Util.from_bytes(:fixnum, hash[[:cf1, 3]])
   end
 
   def test_table_descriptor
@@ -289,14 +292,14 @@ class TestScoped < TestHBaseJRubyBase
     (1..100).each do |rk|
       data = {}
       (1..200).each do |cq|
-        data[HBase::ColumnKey(:cf1, cq)] = rk + cq
+        data[[:cf1, cq]] = rk + cq
       end
       all_data[rk] = data
     end
     @table.put all_data
 
     # One simple filter (Rowkey 10 ~ 19)
-    scoped1 = @table.filter(HBase::ColumnKey('cf1', 100) => 110...120)
+    scoped1 = @table.filter(['cf1', 100] => 110...120)
     ret = scoped1.get((1..100).to_a)
     assert_equal 100, ret.count
     assert_equal 10, ret.compact.count
@@ -304,7 +307,7 @@ class TestScoped < TestHBaseJRubyBase
     # Two filters
     scoped2 = scoped1.filter(
       # Rowkey 10 ~ 19 & 9 ~ 14 = 10 ~ 14
-      HBase::ColumnKey('cf1', 1) => 10..15
+      ['cf1', 1] => 10..15
     )
     ret = scoped2.get((1..100).to_a)
     assert_equal 100, ret.count

data/test/test_table.rb

@@ -36,28 +36,28 @@ class TestTable < TestHBaseJRubyBase
   def test_put_then_get
     # Single record put
     assert_equal 1, @table.put('row1',
-                               'cf1:a' => 2,
-                               'cf1:b' => 'b',
-                               'cf1:c' => 6.28,
-                               'cf1:d' => false,
-                               'cf1:f' => :bol,
-                               'cf1:g' => BigDecimal.new("456.123"),
-                               'cf1:byte'  => { :byte => 100 },
+                               'cf1:a'     => 2,
+                               'cf1:b'     => 'b',
+                               'cf1:c'     => 6.28,
+                               'cf1:d'     => false,
+                               'cf1:f'     => :bol,
+                               'cf1:g'     => BigDecimal.new("456.123"),
+                               'cf1:byte'  => { :byte  => 100 },
                                'cf1:short' => { :short => 200 },
-                               'cf1:int'   => { :int => 300 },
-                               'cf1:str1' => "Goodbye", 'cf1:str2' => "Cruel world")
+                               'cf1:int'   => { :int   => 300 },
+                               'cf1:str1'  => "Goodbye", 'cf1:str2' => "Cruel world")
     assert_equal 1, @table.put('row1',
-                               'cf1:a' => 1,
-                               'cf1:b' => 'a',
-                               'cf1:c' => 3.14,
-                               'cf1:d' => true,
-                               'cf1:f' => :sym,
-                               'cf1:g' => BigDecimal.new("123.456"),
-                               'cf1:byte'  => { :byte => 101 },
+                               'cf1:a'     => 1,
+                               'cf1:b'     => 'a',
+                               'cf1:c'     => 3.14,
+                               'cf1:d'     => true,
+                               'cf1:f'     => :sym,
+                               'cf1:g'     => BigDecimal.new("123.456"),
+                               'cf1:byte'  => { :byte  => 101 },
                                'cf1:short' => { :short => 201 },
-                               'cf1:int'   => { :int => 301 },
-                               'cf1:int2'  => { :int => 401 },
-                               'cf1:str1' => "Hello", 'cf1:str2' => "World")
+                               'cf1:int'   => { :int   => 301 },
+                               'cf1:int2'  => { :int   => 401 },
+                               'cf1:str1'  => "Hello", 'cf1:str2' => "World")
     # Batch put
     assert_equal 2, @table.put(
       'row2' => { 'cf1:a' => 2, 'cf1:b' => 'b', 'cf1:c' => 6.28 },
@@ -65,10 +65,12 @@ class TestTable < TestHBaseJRubyBase
 
     # single-get (latest version)
     result = @table.get('row1')
-    assert_equal result, result.each
+    # Test enumerator
+    assert_equal result.to_a, result.each.each.to_a
+    assert_equal result.to_a, result.each.take_while { true }.to_a
 
-    assert_equal 'row1', @table.get('row1').rowkey
-    assert_equal 'row1', @table.get('row1').rowkey
+    assert_equal 'row1', @table.get('row1').rowkey(:string)
+    assert_equal 'row1', @table.get('row1').rowkey(:string)
     assert_equal 1,      @table.get('row1').fixnum('cf1:a')
     assert_equal 'a',    @table.get('row1').string('cf1:b')
     assert_equal 'a',    String.from_java_bytes(@table.get('row1').raw('cf1:b'))
@@ -80,9 +82,9 @@ class TestTable < TestHBaseJRubyBase
     assert_equal 201,   @table.get('row1').short('cf1:short')
     assert_equal 301,   @table.get('row1').int('cf1:int')
 
-    # single-get-multi-col
-    assert_equal %w[Hello World], @table.get('row1').string(['cf1:str1', 'cf1:str2'])
-    assert_equal [301, 401], @table.get('row1').int(['cf1:int', 'cf1:int2'])
+    # single-get-multi-col (deprecated since 0.3)
+    # assert_equal %w[Hello World], @table.get('row1').string(['cf1:str1', 'cf1:str2'])
+    # assert_equal [301, 401], @table.get('row1').int(['cf1:int', 'cf1:int2'])
 
     # single-get-multi-ver
     assert_equal [1, 2],        @table.get('row1').fixnums('cf1:a').values
@@ -100,13 +102,13 @@ class TestTable < TestHBaseJRubyBase
 
     assert @table.get('row1').fixnums('cf1:a').keys.all? { |k| k.instance_of? Fixnum }
 
-    # single-get-multi-col-multi=ver
-    rets = @table.get('row1').strings(['cf1:str1', 'cf1:str2'])
-    assert_equal ['Hello', 'World'], rets.map(&:values).map(&:first)
-    assert_equal ['Goodbye', 'Cruel world'], rets.map(&:values).map(&:last)
+    # single-get-multi-col-multi=ver (deprecated since 0.3)
+    # rets = @table.get('row1').strings(['cf1:str1', 'cf1:str2'])
+    # assert_equal ['Hello', 'World'], rets.map(&:values).map(&:first)
+    # assert_equal ['Goodbye', 'Cruel world'], rets.map(&:values).map(&:last)
 
     # multi-get
-    assert_equal %w[row1 row2 row3], @table.get(['row1', 'row2', 'row3']).map { |r| r.rowkey }
+    assert_equal %w[row1 row2 row3], @table.get(['row1', 'row2', 'row3']).map { |r| r.rowkey :string }
     assert_equal [1, 2, 4         ], @table.get(['row1', 'row2', 'row3']).map { |r| r.fixnum('cf1:a') }
     assert_equal [3.14, 6.28, 6.28], @table.get(['row1', 'row2', 'row3']).map { |r| r.float('cf1:c') }
     assert_equal [nil, nil        ], @table.get(['xxx', 'yyy'])
@@ -154,54 +156,6 @@ class TestTable < TestHBaseJRubyBase
     assert_equal ['B1'], @table.get(rowkey).strings('cf1:b').values
   end
 
-  def test_to_hash
-    data = {
-      'cf1:a' => 'Hello',
-      'cf1:b' => 200,
-      'cf1:c' => 3.14,
-      'cf2:d' => :world,
-      'cf2:e' => false,
-      'cf3:f' => BigDecimal.new('1234567890123456789012345678901234567890'),
-      'cf3'   => true
-    }
-    schema = {
-      'cf1:a' => :string,
-      'cf1:b' => :fixnum,
-      'cf1:c' => :float,
-      HBase::ColumnKey(:cf2, :d) => :symbol,
-      HBase::ColumnKey(:cf2, :e) => :boolean,
-      HBase::ColumnKey(:cf3, :f) => :bigdecimal,
-      'cf3'   => :boolean
-    }
-    @table.put('row1', data)
-    @table.put('row2', 'cf1:a' => 'Goodbye')
-
-    assert_equal data, @table.get('row1').to_hash(schema).map { |k, v| { k.to_s => v } }.inject(:merge)
-    assert_equal 1,    @table.get('row1').to_hash_with_versions(schema)['cf1:a'].length
-    assert_equal 1,    @table.get('row1').to_hash_with_versions(schema)[HBase::ColumnKey(:cf1, :a)].length
-
-    # Better testing for versioned values
-    @table.put('row1', data)
-    assert_equal data, @table.get('row1').to_hash(schema).map { |k, v| { k.to_s => v } }.inject(:merge)
-
-    assert_equal 2, @table.get('row1').to_hash_with_versions(schema)['cf1:a'].length
-    assert_equal 1, @table.get('row1').to_hash_with_versions(schema)['cf3:f'].length
-
-    # get option: :versions
-    assert_equal 1, @table.versions(1).get('row1').to_hash_with_versions(schema)['cf1:a'].length
-
-    # scoped get with filters
-    assert_equal 2, @table.get(['row1', 'row2']).count
-    assert_equal 2, @table.range('row1'...'row2').get(['row1', 'row2']).count
-    assert_equal 2, @table.range('row1'..'row2').get(['row1', 'row2']).compact.count
-    assert_equal 1, @table.range('row1'...'row2').get(['row1', 'row2']).compact.count
-    assert_equal 1, @table.range(:prefix => 'row2').get(['row1', 'row2']).compact.count
-    assert_equal 1, @table.filter('cf1:a' => 'Hello').get(['row1', 'row2']).compact.count
-
-    # scoped get with projection
-    assert_equal %w[cf3 cf3:f], @table.project('cf3').get('row1').to_hash.keys.map(&:to_s)
-  end
-
   def test_increment
     @table.put('row1', 'cf1:counter' => 1, 'cf1:counter2' => 100)
     assert_equal 1, @table.get('row1').fixnum('cf1:counter')
@@ -216,6 +170,15 @@ class TestTable < TestHBaseJRubyBase
     @table.increment('row1', 'cf1:counter' => 4, 'cf1:counter2' => 100)
     assert_equal 8,   @table.get('row1').fixnum('cf1:counter')
     assert_equal 200, @table.get('row1').fixnum('cf1:counter2')
+
+    # Multi-row multi-column increment
+    @table.put('row2', 'cf1:counter' => 1, 'cf1:counter2' => 100)
+    @table.increment 'row1' => { 'cf1:counter' => 4, 'cf1:counter2' => 100 },
+                     'row2' => { 'cf1:counter' => 1, 'cf1:counter2' => 100 }
+    assert_equal 12,  @table.get('row1').fixnum('cf1:counter')
+    assert_equal 300, @table.get('row1').fixnum('cf1:counter2')
+    assert_equal 2,   @table.get('row2').fixnum('cf1:counter')
+    assert_equal 200, @table.get('row2').fixnum('cf1:counter2')
   end
 
   def test_delete
@@ -224,34 +187,34 @@ class TestTable < TestHBaseJRubyBase
     @table.put('row1', 'cf2:d' => 5)
     sleep 0.1
     @table.put('row1', 'cf2:d' => 6)
-    versions = @table.get('row1').to_hash_with_versions['cf2:d'].keys
+    versions = @table.get('row1').to_H[%w[cf2 d]].keys
     assert versions[0] > versions[1]
     assert versions[1] > versions[2]
 
     # Deletes a version (Fixnum and Time as timestamps)
     @table.delete('row1', 'cf2:d', versions[0], Time.at(versions[2] / 1000.0))
-    new_versions = @table.get('row1').to_hash_with_versions['cf2:d'].keys
+    new_versions = @table.get('row1').to_H[%w[cf2 d]].keys
     assert_equal new_versions, [versions[1]]
 
     # Deletes a column
     assert_equal 3, @table.get('row1').fixnum('cf2:c')
     @table.delete('row1', 'cf2:c')
-    assert_nil @table.get('row1').to_hash['cf2:c']
+    assert_nil @table.get('row1').to_h['cf2:c']
 
     # Deletes a column with empty qualifier
     assert_equal 0, @table.get('row1').fixnum('cf1')
     @table.delete('row1', 'cf1:')
     assert_equal 1, @table.get('row1').fixnum('cf1:a')
     assert_equal 2, @table.get('row1').fixnum('cf1:b')
-    assert_nil @table.get('row1').to_hash['cf1']
-    assert_nil @table.get('row1').to_hash['cf1:']
+    assert_nil @table.get('row1').to_h['cf1']
+    assert_nil @table.get('row1').to_h['cf1:']
 
     # Deletes a column family
     assert_equal 1, @table.get('row1').fixnum('cf1:a')
     assert_equal 2, @table.get('row1').fixnum('cf1:b')
     @table.delete('row1', 'cf1') # No trailing colon
-    assert_nil @table.get('row1').to_hash['cf1:a']
-    assert_nil @table.get('row1').to_hash['cf1:b']
+    assert_nil @table.get('row1').to_h['cf1:a']
+    assert_nil @table.get('row1').to_h['cf1:b']
 
     # Deletes a row
     @table.delete('row1')
@@ -263,7 +226,7 @@ class TestTable < TestHBaseJRubyBase
 
     @table.delete ['row2'], ['row3', 'cf1:a']
     assert_nil @table.get('row2')
-    assert_nil @table.get('row3').to_hash['cf1:a']
+    assert_nil @table.get('row3').to_h['cf1:a']
     assert_equal 2, @table.get('row3').fixnum('cf1:b')
   end
 

data/test/test_table_admin.rb

@@ -205,8 +205,8 @@ class TestTableAdmin < TestHBaseJRubyBase
       rprops = @table.raw_properties
       assert_equal true.to_s,              rprops['DEFERRED_LOG_FLUSH']
       assert_equal false.to_s,             rprops['READONLY']
-      assert_equal (64 * 1024 ** 2).to_s,  rprops['MEMSTORE_FLUSHSIZE']
-      assert_equal (512 * 1024 ** 2).to_s, rprops['MAX_FILESIZE']
+      assert_equal((64 * 1024 ** 2).to_s,  rprops['MEMSTORE_FLUSHSIZE'])
+      assert_equal((512 * 1024 ** 2).to_s, rprops['MAX_FILESIZE'])
 
       # Column family properties
       cf = @table.families['cf']
@@ -278,7 +278,7 @@ class TestTableAdmin < TestHBaseJRubyBase
 
     @hbase.snapshots.each do |snapshot|
       assert_equal @table.name, snapshot[:table]
-      assert_match /hbase_jruby_test_snapshot[12]/, snapshot[:name]
+      assert_match(/hbase_jruby_test_snapshot[12]/, snapshot[:name])
     end
 
     @hbase.admin do |admin|