hbase-jruby 0.3.5-java → 0.4.0-java

data/lib/hbase-jruby/table.rb

@@ -43,7 +43,7 @@ class Table
 
   [:get, :count, :aggregate,
    :range, :project, :filter, :while,
-   :limit, :versions, :caching, :batch,
+   :limit, :versions, :caching, # :batch,
    :time_range, :at
   ].each do |method|
     define_method(method) do |*args|
@@ -72,11 +72,11 @@ class Table
   def put *args
     case args.length
     when 1
-      puts = args.first.map { |rowkey, props| make_put rowkey, props }
+      puts = args.first.map { |rowkey, props| @mutation.put rowkey, props }
       htable.put puts
       puts.length
     when 2
-      htable.put make_put(*args)
+      htable.put @mutation.put(*args)
       1
     else
       raise ArgumentError, 'invalid number of arguments'
@@ -125,14 +125,24 @@ class Table
   def delete *args
     specs = args.first.is_a?(Array) ? args : [args]
 
-    htable.delete specs.map { |spec| spec.empty? ? nil : make_delete(*spec) }.compact
+    list = specs.map { |spec| spec.empty? ? nil : @mutation.delete(*spec) }.compact
+    if list.length == 1
+      htable.delete list.first
+    else
+      htable.delete list
+    end
   end
 
   # Delete rows.
   # @param [*Object] rowkeys List of rowkeys of rows to delete
   # @return [nil]
   def delete_row *rowkeys
-    htable.delete rowkeys.map { |rk| Delete.new(Util.to_bytes rk) }
+    list = rowkeys.map { |rk| Delete.new(Util.to_bytes rk) }
+    if list.length == 1
+      htable.delete list.first
+    else
+      htable.delete list
+    end
   end
 
   # Atomically increase numeric values
@@ -141,41 +151,69 @@ class Table
   #   @param [Object] rowkey Rowkey
   #   @param [String, Array] column Column expression in String "FAMILY:QUALIFIER", or in Array [FAMILY, QUALIFIER]
   #   @param [Fixnum] by Increment amount
-  #   @return [Fixnum] Column value after increment
+  #   @return [Hash]
   #   @example
   #     table.increment('a000', 'cf1:col1', 1)
   # @overload increment(rowkey, column_by_hash)
   #   Atomically increase values of multiple columns
   #   @param [Object] rowkey Rowkey
   #   @param [Hash] column_by_hash Column expression to increment amount pairs
+  #   @return [Hash]
   #   @example
   #     table.increment('a000', 'cf1:col1' => 1, 'cf1:col2' => 2)
   # @overload increment(inc_spec)
   #   Increase values of multiple columns from multiple rows.
   #   @param [Hash] inc_spec { rowkey => { col => by } }
+  #   @return [Hash]
   #   @example
   #     table.increment 'a000' => { 'cf1:col1' => 1, 'cf1:col2' => 2 },
   #                     'a001' => { 'cf1:col1' => 3, 'cf1:col2' => 4 }
   def increment rowkey, *args
     if args.empty? && rowkey.is_a?(Hash)
-      rowkey.each do |key, spec|
-        increment key, spec
-      end
-    elsif args.first.is_a?(Hash)
-      cols = args.first
-      htable.increment Increment.new(Util.to_bytes rowkey).tap { |inc|
-        cols.each do |col, by|
-          cf, cq, _ = lookup_and_parse col
-          inc.addColumn cf, cq, by
+      INSENSITIVE_ROW_HASH.clone.tap { |result|
+        rowkey.each do |key, spec|
+          result[Util.java_bytes?(key) ? ByteArray[key] : key] = increment(key, spec)
         end
       }
     else
-      col, by = args
-      cf, cq = lookup_and_parse col
-      htable.incrementColumnValue Util.to_bytes(rowkey), cf, cq, by || 1
+      incr = @mutation.increment(rowkey, *args)
+      Row.send(:new, self, htable.increment(incr)).to_h.tap { |h|
+        h.each do |k, v|
+          h[k] = Util.from_bytes :fixnum, v unless v.is_a?(Fixnum)
+        end
+      }
     end
   end
 
+  # Appends values to one or more columns within a single row.
+  # @param [Object] rowkey Rowkey
+  # @param [Hash] spec Hash (column to value)
+  # @return [Hash] Updated values
+  # @example
+  #   table.put :rowkey, col1: 'hello', col2: 'foo'
+  #   table.append :rowkey, col1: ' world', col2: 'bar'
+  #     # { col1: 'hello world', col2: 'foobar' }
+  def append rowkey, spec
+    result = htable.append @mutation.append(rowkey, spec)
+    Row.send(:new, self, result).to_h if result # (maybe null)
+  end
+
+  # Performs multiple mutations atomically on a single row.
+  # Currently Put and Delete are supported.
+  # The mutations are performed in the order in which they were specified.
+  # @param [Object] rowkey Rowkey
+  # @yield [HBase::Table::Mutation::Mutator]
+  # @return [nil]
+  # @example
+  #   table.mutate do |m|
+  #     m.put a: 100, b: 'hello'
+  #     m.delete :c, :d
+  #     m.put e: 3.14
+  #   end
+  def mutate(rowkey, &block)
+    htable.mutateRow @mutation.mutate(rowkey, &block)
+  end
+
   # Scan through the table
   # @yield [row] Yields each row in the scope
   # @yieldparam [HBase::Row] row
@@ -187,7 +225,7 @@ class Table
   # Returns HBase::Scoped object for this table
   # @return [HBase::Scoped]
   def scoped
-    Scoped.send(:new, self)
+    Scoped.send(:new, self, @hbase.config.get('hbase.client.scanner.caching').to_i)
   end
 
   # Returns CheckedOperation instance for check-and-put and check-and-delete
@@ -198,22 +236,82 @@ class Table
     raise ArgumentError, 'invalid check condition' unless cond.length == 1
     col, val = cond.first
 
-    cf, cq, type = lookup_and_parse(col)
+    cf, cq, type = lookup_and_parse(col, true)
 
     # If the passed value is null, the check is for the lack of column
-    CheckedOperation.new self, Util.to_bytes(rowkey),
+    CheckedOperation.new self, @mutation, Util.to_bytes(rowkey),
       cf, cq,
       (val.nil? ? nil : Util.to_typed_bytes(type, val))
   end
 
+  # Method that does a batch call on Deletes, Gets, Puts, Increments, Appends
+  # and RowMutations. The ordering of execution of the actions is not defined.
+  # An Array of Hashes are returned as the results of each operation. For
+  # Delete, Put, and RowMutation, :result entry of the returned Hash is
+  # Boolean. For Increment and Append, it will be plain Hashes, and for Get,
+  # HBase::Rows will be returned.
+  # When an error has occurred, you can still access the partial results using
+  # `results` method of the thrown BatchException instance.
+  # @yield [HBase::Table::BatchAction]
+  # @return [Array<Hash>]
+  # @raise [HBase::BatchException]
+  def batch arg = nil
+    if arg
+      # Backward compatibility
+      return scoped.batch(arg)
+    else
+      raise ArgumentError, "Block not given" unless block_given?
+    end
+    b = BatchAction.send(:new, self, @mutation)
+    yield b
+    results = Array.new(b.actions.length).to_java
+    process = lambda do
+      results.each_with_index do |r, idx|
+        action = b.actions[idx]
+        type = action[:type]
+        case type
+        when :get
+          action[:result] = (r.nil? || r.empty?) ? nil : Row.send(:new, self, r)
+        when :append
+          action[:result] = r && Row.send(:new, self, r).to_h
+        when :increment
+          action[:result] = r &&
+            Row.send(:new, self, r).to_h.tap { |h|
+              h.each do |k, v|
+                h[k] = Util.from_bytes :fixnum, v unless v.is_a?(Fixnum)
+              end
+            }
+        else
+          case r
+          when java.lang.Exception
+            action[:result] = false
+            action[:exception] = r
+          when nil
+            action[:result] = false
+          else
+            action[:result] = true
+          end
+        end
+      end
+      b.actions
+    end
+
+    begin
+      htable.batch b.actions.map { |a| a[:action] }, results
+      process.call
+    rescue Exception => e
+      raise HBase::BatchException.new(e, process.call)
+    end
+  end
+
   # @private
   def lookup_schema col
     @hbase.schema.lookup @name_sym, col
   end
 
   # @private
-  def lookup_and_parse col
-    @hbase.schema.lookup_and_parse @name_sym, col
+  def lookup_and_parse col, expect_cq
+    @hbase.schema.lookup_and_parse @name_sym, col, expect_cq
   end
 
 private
@@ -222,73 +320,23 @@ private
     @config   = config
     @name     = name.to_s
     @name_sym = name.to_sym
+    @mutation = Mutation.new(self)
   end
 
   def check_closed
     raise RuntimeError, "HBase connection is already closed" if @hbase.closed?
   end
 
-  def make_put rowkey, props
-    Put.new(Util.to_bytes rowkey).tap { |put|
-      props.each do |col, val|
-        next if val.nil?
-
-        cf, cq, type = lookup_and_parse col
-
-        case val
-        when Hash
-          val.each do |t, v|
-            case t
-            # Timestamp / Ruby Time
-            when Time, Fixnum
-              put.add cf, cq, time_to_long(t), Util.to_typed_bytes(type, v)
-            # Types: :byte, :short, :int, ...
-            else
-              put.add cf, cq, Util.to_typed_bytes(t, v)
-            end unless v.nil?
-          end
-        else
-          put.add cf, cq, Util.to_typed_bytes(type, val)
+  INSENSITIVE_ROW_HASH = {}.tap { |h|
+    h.instance_eval do
+      def [] key
+        if Util.java_bytes?(key)
+          key = ByteArray[key]
         end
+        super key
       end
-      raise ArgumentError, "no column to put" if put.empty?
-    }
-  end
-
-  def make_delete rowkey, *extra
-    Delete.new(Util.to_bytes rowkey).tap { |del|
-      cf = cq = nil
-      prcd = false
-
-      prc = lambda do
-        unless prcd
-          if cq
-            # Delete all versions
-            del.deleteColumns cf, cq
-          elsif cf
-            del.deleteFamily cf
-          end
-        end
-      end
-
-      extra.each do |x|
-        case x
-        when Fixnum, Time
-          if cq
-            del.deleteColumn cf, cq, time_to_long(x)
-            prcd = true
-          else
-            raise ArgumentError, 'qualifier not given'
-          end
-        else
-          prc.call
-          cf, cq, _ = lookup_and_parse x
-          prcd = false
-        end
-      end
-      prc.call
-    }
-  end
+    end
+  }
 end#Table
 end#HBase
 

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = '0.3.5'
+  VERSION = '0.4.0'
 end
 end

data/lib/hbase-jruby.rb

@@ -11,7 +11,10 @@ require 'hbase-jruby/admin'
 require 'hbase-jruby/scoped/aggregation'
 require 'hbase-jruby/scoped'
 require 'hbase-jruby/schema'
+require 'hbase-jruby/batch_exception'
 require 'hbase-jruby/table'
+require 'hbase-jruby/table/mutation'
+require 'hbase-jruby/table/batch_action'
 require 'hbase-jruby/table/admin'
 require 'hbase-jruby/table/inspection'
 require 'hbase-jruby/table/checked_operation'

data/test/helper.rb

@@ -12,6 +12,7 @@ unless defined? Enumerator
 end
 
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$rowkey = Time.now.to_i
 
 require "hbase-jruby"
 if dist = ENV['HBASE_JRUBY_TEST_DIST']
@@ -31,7 +32,9 @@ class TestHBaseJRubyBase < Test::Unit::TestCase
   hbase.close
 
   def connect
-    HBase.new 'hbase.zookeeper.quorum' => ZK
+    HBase.new('hbase.zookeeper.quorum' => ZK,
+              'hbase.client.retries.number' => 10,
+              'hbase.client.scanner.caching' => 100)
   end
 
   def setup
@@ -53,6 +56,10 @@ class TestHBaseJRubyBase < Test::Unit::TestCase
     end
   end
 
+  def next_rowkey
+    $rowkey += 1
+  end
+
   def teardown
     if RECREATE
       @table.drop! if @table && @table.exists?

data/test/test_byte_array.rb

@@ -142,4 +142,8 @@ class TestByteArray < Test::Unit::TestCase
     assert_equal "Hello", ba.shift(:string, 5)
     assert_equal 3.14, ba.shift(:float)
   end
+
+  def test_to_s
+    assert_equal 'hello', HBase::ByteArray['hello'].to_s
+  end
 end

data/test/test_schema.rb

@@ -52,17 +52,19 @@ class TestSchema < TestHBaseJRubyBase
     }
 
     # PUT
-    @table.put 1, 'cf1:a' => data[:a], 'cf1:b'  => data[:b],    'cf1:c' => data[:c],
+    rk1 = next_rowkey
+    rk2 = next_rowkey
+    @table.put rk1, '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
+    @table.put rk2, 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 ]
+    row = @table.get(rk2)
+    assert_equal Set[ *@table.get(rk1).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(rk1).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']
@@ -84,17 +86,20 @@ class TestSchema < TestHBaseJRubyBase
 
     assert_equal data[[:cf1, HBase::ByteArray['x']]], HBase::Util.from_bytes(:long, row['cf1:x'])
 
-    data1 = @table.get(1).to_h
+    data1 = @table.get(rk1).to_h
     data1[:a] *= 2
     data1[:b] = :new_symbol
-    @table.put 3, data1
-    @table.increment 3, :a => 5
+
+    rk3 = next_rowkey
+    @table.put rk3, data1
+    ret = @table.increment rk3, :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']
+    assert_equal data[:a] * 2 + 5, ret[:a]
+    assert_equal data[:a] * 2 + 5, @table.get(rk3)[:a]
+    assert_equal :new_symbol,      @table.get(rk3)[:b]
+    assert_equal :new_symbol,      @table.get(rk3)['b']
+    assert_equal :new_symbol,      @table.get(rk3)['cf1:b']
 
     # PROJECT
     assert_equal [:a, :c, :e, :f],
@@ -110,17 +115,18 @@ class TestSchema < TestHBaseJRubyBase
     assert_equal 1, @table.filter(:a => { :gt => 150 }).count
 
     # cf:g (automatic type conversion)
-    @table.put   3,    :g => 3.14
-    assert_equal 3.14, @table.get(3)[:g]
-    @table.put   3,    :g => 314
-    assert_equal 314,  @table.get(3)[:g]
+    @table.put   rk3,  :g => 3.14
+    assert_equal 3.14, @table.get(rk3)[:g]
+    @table.put   rk3,  :g => 314
+    assert_equal 314,  @table.get(rk3)[:g]
 
     # cf3:g vs. cf2:g
-    @table.put   4,    :g => 3.14, 'cf2:g' => 'String'
-    assert_equal 3.14,     @table.get(4)[:g]
-    assert_equal 'String', @table.get(4)['cf2:g'].to_s
-    assert_equal 3.14,     @table.get(4).to_h[:g]
-    assert_equal 'String', @table.get(4).to_h['cf2:g'].to_s
+    rk4 = next_rowkey
+    @table.put   rk4, :g => 3.14, 'cf2:g' => 'String'
+    assert_equal 3.14,     @table.get(rk4)[:g]
+    assert_equal 'String', @table.get(rk4)['cf2:g'].to_s
+    assert_equal 3.14,     @table.get(rk4).to_h[:g]
+    assert_equal 'String', @table.get(rk4).to_h['cf2:g'].to_s
   end
 
   def test_schema_readme
@@ -152,9 +158,10 @@ class TestSchema < TestHBaseJRubyBase
       :alive       => true
     }
 
-    @table.put(100 => data)
+    rk = next_rowkey
+    @table.put(rk => data)
 
-    john = @table.get(100)
+    john = @table.get(rk)
 
     data.each do |k, v|
       assert_equal v, john[k]
@@ -170,6 +177,7 @@ class TestSchema < TestHBaseJRubyBase
 
   def test_schema_book
     table = @table
+    rk = next_rowkey
 
     @hbase.schema[table.name] = {
       # Columns in cf1 family
@@ -210,12 +218,12 @@ class TestSchema < TestHBaseJRubyBase
       :comment1 => 'A must-have',
       :comment2 => 'Rewarding purchase'
     }
-    table.put 1, data
+    table.put rk, data
     # Since we can't directly compare java byte arrays
     data[:image] = HBase::ByteArray[ data[:image] ]
 
     # Get data (rowkey: 1)
-    book = table.get 1
+    book = table.get rk
 
     assert_equal data,            book.to_h.tap { |h| h[:image] = HBase::ByteArray[ h[:image] ] }
     assert_equal data[:title],    book['title']
@@ -229,13 +237,15 @@ class TestSchema < TestHBaseJRubyBase
     assert_equal true, book.to_H.values.map(&:keys).flatten.all? { |e| e.is_a? Fixnum }
 
     # Scan table
-    assert_equal 1890, table.range(0..100).first[:year]
-    assert_equal 2, table.range(0..100).first.raw(:year).length
-    assert_equal 1, table.range(0..100).filter(:year => 1890).to_a.length
-    assert_equal 1, table.range(0..100).filter(:year => 1890).count
-    assert_equal 1, table.range(0..100).filter(:year => 1880...1900).count
+    range = (rk - 1)..(rk + 1)
+    assert_equal 1890, table.range(range).first[:year]
+    assert_equal 2, table.range(range).first.raw(:year).length
+    assert_equal 1, table.range(range).filter(:year => 1890).to_a.length
+    assert_equal 1, table.range(range).filter(:year => 1890).count
+    assert_equal 1, table.range(range).filter(:year => 1880...1900).count
     cnt = 0
-    table.range(0..100).
+    inc1 = inc2 = nil
+    table.range(range).
           filter(:year     => 1880...1900,
                  :in_print => true,
                  :category => ['Comics', 'Fiction', /cult/i],
@@ -253,27 +263,33 @@ class TestSchema < TestHBaseJRubyBase
       table.put book.rowkey => { :price => book[:price] + BigDecimal('1') }
 
       # Atomic increment
-      table.increment book.rowkey, :reviews => 1, :stars => 5
+      inc1 = table.increment book.rowkey => { :reviews => 1, :stars => 2 }
+      inc2 = table.increment book.rowkey, :stars => 3
       cnt += 1
     end
     assert_equal 1, cnt
 
-    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]
+    assert_equal data[:price]   + 1.0, table.get(rk)[:price]
+    assert_equal data[:reviews] + 1,   table.get(rk)[:reviews]
+    assert_equal data[:stars]   + 5,   table.get(rk)[:stars]
+
+    assert_equal data[:reviews] + 1, inc1[book.rowkey][:reviews]
+    assert_equal data[:stars]   + 2, inc1[book.rowkey][:stars]
+    assert_equal nil,                inc2[:reviews]
+    assert_equal data[:stars]   + 5, inc2[:stars]
 
     # Coprocessor
     table.enable_aggregation!
-    table.put 2, :reviews => 100, :stars => 500
+    table.put next_rowkey, :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')
+    table.put rk, 'cf1:x'      => 1000
+    table.put rk, [:cf1, :y]   => 2000
+    table.put rk, [:cf1, 2013] => 3000
+    assert_equal 1000, table.get(rk).fixnum('cf1:x')
 
     [
       [:cf1, HBase::ByteArray['x']],
@@ -284,30 +300,68 @@ class TestSchema < TestHBaseJRubyBase
       %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])
+      assert_equal 1000, HBase::Util.from_bytes(:fixnum, table.get(rk)[param])
+      assert_equal 1000, HBase::Util.from_bytes(:fixnum, table.get(rk)[*param])
+      assert_equal 1000, HBase::Util.from_bytes(:fixnum, table.get(rk).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]])
+    assert_equal 2000, HBase::Util.from_bytes(:fixnum, table.get(rk)[:cf1, :y])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(rk)[:cf1, 2013])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(rk)[[:cf1, 2013]])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(rk).to_h[[:cf1, HBase::ByteArray[2013]]])
+    assert_equal 3000, HBase::Util.from_bytes(:fixnum, table.get(rk).to_h[[:cf1, 2013]])
+
+    # Append string to title column
+    ret = table.append rk, :title => '!!!'
+    assert_equal data[:title] + '!!!', ret[:title]
+    assert_equal data[:title] + '!!!', table.get(rk)[:title]
+
+    # Mutation
+    table.mutate(rk) do |m|
+      m.delete :comment1, :comment2
+      m.put :comment3 => 'nice', :comment4 => 'great'
+      assert_raise(ArgumentError) {
+        m.put :some_unknown_column => 'perfect'
+      }
+    end
+    assert_equal nil,     table.get(rk)[:comment1]
+    assert_equal nil,     table.get(rk)[:comment2]
+    assert_equal 'nice',  table.get(rk)[:comment3]
+    assert_equal 'great', table.get(rk)[:comment4]
+
+    # Batch
+    ret = table.batch do |b|
+      b.put rk, :comment5 => 'gnarly'
+      b.delete rk, :comment4
+      b.increment rk, :stars => 100, :reviews => 200
+      b.mutate(rk) do |m|
+        m.put :comment6 => 'rad'
+        m.delete :image
+      end
+      b.append rk, :category => '/Etc'
+      b.get rk
+    end
+    assert_equal 6, ret.length
+    assert_equal [true] * 3, ret.values_at(0, 1, 3).map { |r| r[:result] }
+    assert_equal data[:stars] + 5 + 100,   ret[2][:result][:stars]
+    assert_equal data[:reviews] + 1 + 200, ret[2][:result][:reviews]
+    assert_equal data[:category] + '/Etc', ret[4][:result][:category]
+    assert_instance_of HBase::Row, ret[5][:result]
+    assert_equal 1890, ret[5][:result][:year]
 
     # 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]
+    table.delete rk, :title
+    assert_equal nil, table.get(rk)[:title]
+    assert_equal data[:author], table.get(rk)[:author]
 
     # Delete column family
-    table.delete 1, :cf1
-    assert_equal nil, table.get(1)[:author]
-    assert_equal data[:summary], table.get(1)[:summary]
+    table.delete rk, :cf1
+    assert_equal nil, table.get(rk)[:author]
+    assert_equal data[:summary], table.get(rk)[:summary]
 
     # Delete book 1
-    table.delete 1
-    assert_equal nil, table.get(1)
+    table.delete rk
+    assert_equal nil, table.get(rk)
 
     # Drop table for subsequent tests
     table.drop!
@@ -323,11 +377,12 @@ class TestSchema < TestHBaseJRubyBase
       }
     }
 
+    rk = next_rowkey
     assert_raise(ArgumentError) {
-      @table.put 1, :a => nil, :b => nil, :c => nil, 'cf1:z' => nil
+      @table.put rk, :a => nil, :b => nil, :c => nil, 'cf1:z' => nil
     }
-    @table.put 1, :a => nil, :b => nil, :c => nil, :d => 'yo', 'cf1:z' => 1000
-    h = @table.get(1).to_h
+    @table.put rk, :a => nil, :b => nil, :c => nil, :d => 'yo', 'cf1:z' => 1000
+    h = @table.get(rk).to_h
     assert !h.has_key?(:a)
     assert !h.has_key?(:b)
     assert !h.has_key?(:c)
@@ -345,14 +400,15 @@ class TestSchema < TestHBaseJRubyBase
       :cf1 => { :a => :fixnum }
     }
 
-    @table.put 1, :a => 100
-    assert_equal 100, @table.get(1)[:a]
-    assert_equal 100, @table.get(1)['cf1:a']
+    rk = next_rowkey
+    @table.put rk, :a => 100
+    assert_equal 100, @table.get(rk)[:a]
+    assert_equal 100, @table.get(rk)['cf1:a']
 
     @hbase.schema.delete @table.name
-    assert_equal nil,  @table.get(1)[:a]
-    assert_equal true, HBase::Util.java_bytes?(@table.get(1)['cf1:a'])
-    assert_equal 100,  HBase::Util.from_bytes(:fixnum, @table.get(1)['cf1:a'])
+    assert_raise(ArgumentError) { @table.get(rk)[:a] }
+    assert_equal true, HBase::Util.java_bytes?(@table.get(rk)['cf1:a'])
+    assert_equal 100,  HBase::Util.from_bytes(:fixnum, @table.get(rk)['cf1:a'])
   end
 end