hbase-jruby 0.1.1-java → 0.1.2-java

data/lib/hbase-jruby/scoped.rb

@@ -1,8 +1,13 @@
 class HBase
-# Scope of table scan
+# Scope of data access
 # @author Junegunn Choi <junegunn.c@gmail.com>
+# @!attribute [r] table
+#   @return [HBase::Table] HBase::Table instance for this scope
 class Scoped
   include Enumerable
+  include Scoped::Aggregation
+
+  attr_reader :table
 
   # A clean HBase::Scoped object for the same table
   # @return [HBase::Scope] A clean HBase::Scoped object for the same table
@@ -14,8 +19,14 @@ class Scoped
   # @return [Fixnum, Bignum] The number of rows in the scope
   def count
     cnt = 0
-    htable.getScanner(filtered_scan_minimum).each do
-      cnt += 1
+    if block_given?
+      htable.getScanner(filtered_scan).each do |result|
+        cnt += 1 if yield(Result.send(:new, result))
+      end
+    else
+      htable.getScanner(filtered_scan_minimum).each do
+        cnt += 1
+      end
     end
     cnt
   end
@@ -124,26 +135,14 @@ class Scoped
   # @param [Array<Hash, FilterBase, FilterList>] filters
   # @return [HBase::Scoped] HBase::Scoped object also with the specified filters
   def filter *filters
-    spawn :@filters, @filters + filters.map { |f|
-      case f
-      when Hash
-        f.map { |col, val|
-          cf, cq = Util.parse_column_name col
+    spawn :@filters, @filters + parse_filter_input(filters)
+  end
 
-          case val
-          when Array
-            FilterList.new(FilterList::Operator::MUST_PASS_ONE,
-              val.map { |v| filter_for cf, cq, v })
-          else
-            filter_for cf, cq, val
-          end
-        }.flatten
-      when FilterBase, FilterList
-        f
-      else
-        raise ArgumentError, "Unknown filter type"
-      end
-    }.flatten
+  # Returns an HBase::Scoped object with the additional filters which will cause early termination of scan
+  # @param [Array<Hash, FilterBase, FilterList>] filters
+  # @return [HBase::Scoped]HBase::Scoped object with the additional filters which will cause early termination of scan
+  def while *filters
+    spawn :@filters, @filters + parse_filter_input(filters).map { |filter| WhileMatchFilter.new(filter) }
   end
 
   # Returns an HBase::Scoped object with the specified row number limit
@@ -354,7 +353,7 @@ private
     when Hash
       FilterList.new(FilterList::Operator::MUST_PASS_ALL,
         val.map { |op, v|
-          operator = 
+          operator =
             case op
             when :gt, :>
               CompareFilter::CompareOp::GREATER
@@ -392,6 +391,12 @@ private
           end
         }
       )
+    when Regexp
+      SingleColumnValueFilter.new(
+        cf, cq,
+        CompareFilter::CompareOp::EQUAL,
+        RegexStringComparator.new(val.to_s)
+      )
     else
       SingleColumnValueFilter.new(
         cf, cq,
@@ -484,6 +489,29 @@ private
 
     [start.java, stop.stopkey_bytes_for_prefix]
   end
+
+  def parse_filter_input filters
+    filters.map { |f|
+      case f
+      when Hash
+        f.map { |col, val|
+          cf, cq = Util.parse_column_name col
+
+          case val
+          when Array
+            FilterList.new(FilterList::Operator::MUST_PASS_ONE,
+              val.map { |v| filter_for cf, cq, v })
+          else
+            filter_for cf, cq, val
+          end
+        }.flatten
+      when FilterBase, FilterList
+        f
+      else
+        raise ArgumentError, "Unknown filter type"
+      end
+    }.flatten
+  end
 end#Scoped
 end#HBase
 

data/lib/hbase-jruby/table.rb

@@ -4,11 +4,15 @@ require 'thread'
 class HBase
 # @!attribute [r] name
 #   @return [String] The name of the table
+# @!attribute [r] config
+#   @return [org.apache.hadoop.conf.Configuration]
 class Table
   attr_reader :name
+  attr_reader :config
 
   include Enumerable
   include Admin
+  include Scoped::Aggregation::Admin
 
   # Returns a read-only org.apache.hadoop.hbase.HTableDescriptor object
   # @return [org.apache.hadoop.hbase.client.UnmodifyableHTableDescriptor]
@@ -160,11 +164,59 @@ class Table
     end
   end
 
+  # Adds the table coprocessor to the table
+  # @param [String] class_name Full class name of the coprocessor
+  # @param [Hash] props Coprocessor properties
+  # @option props [String] path The path of the JAR file
+  # @option props [Fixnum] priority Coprocessor priority
+  # @option props [Hash<#to_s, #to_s>] params Arbitrary key-value parameter pairs passed into the coprocessor
+  def add_coprocessor! class_name, props = {}
+    with_admin do |admin|
+      while_disabled(admin) do
+
+        htd = admin.get_table_descriptor(@name.to_java_bytes)
+        if props.empty?
+          htd.addCoprocessor class_name
+        else
+          path, priority, params = props.values_at :path, :priority, :params
+          params = Hash[ params.map { |k, v| [k.to_s, v.to_s] } ]
+          htd.addCoprocessor class_name, path, priority || Coprocessor::PRIORITY_USER, params
+        end
+        admin.modifyTable @name.to_java_bytes, htd
+        wait_async_admin(admin)
+      end
+    end
+  end
+
+  # Removes the coprocessor from the table.
+  # @param [String] class_name Full class name of the coprocessor
+  # @return [nil]
+  def remove_coprocessor! name
+    unless org.apache.hadoop.hbase.HTableDescriptor.respond_to?(:removeCoprocessor)
+      raise NotImplementedError, "org.apache.hadoop.hbase.HTableDescriptor.removeCoprocessor not implemented"
+    end
+    with_admin do |admin|
+      while_disabled(admin) do
+        htd = admin.get_table_descriptor(@name.to_java_bytes)
+        htd.removeCoprocessor name
+        admin.modifyTable @name.to_java_bytes, htd
+        wait_async_admin(admin)
+      end
+    end
+  end
+
+  # Return if the table has the coprocessor of the given class name
+  # @param [String] class_name Full class name of the coprocessor
+  # @return [true, false]
+  def has_coprocessor? class_name
+    descriptor.hasCoprocessor(class_name)
+  end
+
   # Enables the table
   # @return [nil]
   def enable!
     with_admin do |admin|
-      admin.enableTable @name unless admin.isTableEnabled(@name) 
+      admin.enableTable @name unless admin.isTableEnabled(@name)
     end
   end
 
@@ -172,7 +224,7 @@ class Table
   # @return [nil]
   def disable!
     with_admin do |admin|
-      admin.disableTable @name if admin.isTableEnabled(@name) 
+      admin.disableTable @name if admin.isTableEnabled(@name)
     end
   end
 
@@ -190,24 +242,19 @@ class Table
     with_admin do |admin|
       raise RuntimeError, 'Table does not exist' unless admin.tableExists @name
 
-      admin.disableTable @name if admin.isTableEnabled(@name) 
+      admin.disableTable @name if admin.isTableEnabled(@name)
       admin.deleteTable  @name
       close
     end
   end
 
-  # @overload get(rowkey)
-  #   Single GET.
-  #   Gets a record with the given rowkey. If the record is not found, nil is returned.
-  #   @param [Object] rowkey Rowkey
-  #   @return [HBase::Result, nil]
-  # @overload get(rowkeys)
-  #   Batch GET. Gets an array of records with the given rowkeys.
-  #   Nonexistent records will be returned as nils.
-  #   @param [Array<Object>] rowkeys Rowkeys
-  #   @return [Array<HBase::Result>]
-  def get rowkeys
-    each.get rowkeys
+  [:get, :count, :aggregate,
+   :range, :project, :filter, :while,
+   :limit, :versions, :caching, :batch
+  ].each do |method|
+    define_method(method) do |*args|
+      self.each.send(method, *args)
+    end
   end
 
   # @overload put(rowkey, data)
@@ -272,7 +319,7 @@ class Table
       rowkey, cfcq, *ts = spec
       cf, cq = Util.parse_column_name(cfcq) if cfcq
 
-      Delete.new(Util.to_bytes rowkey).tap { |del| 
+      Delete.new(Util.to_bytes rowkey).tap { |del|
         if !ts.empty?
           ts.each do |t|
             del.deleteColumn cf, cq, t
@@ -317,12 +364,6 @@ class Table
     end
   end
 
-  # Returns the count of the rows in the table
-  # @return [Fixnum]
-  def count
-    each.count
-  end
-
   # Scan through the table
   # @yield [HBase::Result] Yields each row in the scope
   # @return [HBase::Scoped]
@@ -334,48 +375,6 @@ class Table
     end
   end
 
-  # @see HBase::Scoped#range
-  # @return [HBase::Scoped]
-  def range *key_range
-    each.range(*key_range)
-  end
-
-  # @see HBase::Scoped#project
-  # @return [HBase::Scoped]
-  def project *columns
-    each.project(*columns)
-  end
-
-  # @see HBase::Scoped#filter
-  # @return [HBase::Scoped]
-  def filter *filters
-    each.filter(*filters)
-  end
-
-  # @see HBase::Scoped#limit
-  # @return [HBase::Scoped]
-  def limit rows
-    each.limit rows
-  end
-
-  # @see HBase::Scoped#versions
-  # @return [HBase::Scoped]
-  def versions vs
-    each.versions vs
-  end
-
-  # @see HBase::Scoped#caching
-  # @return [HBase::Scoped]
-  def caching rows
-    each.caching rows
-  end
-
-  # @see HBase::Scoped#batch
-  # @return [HBase::Scoped]
-  def batch b
-    each.batch b
-  end
-
   # Returns the underlying org.apache.hadoop.hbase.client.HTable object (local to current thread)
   # @return [org.apache.hadoop.hbase.client.HTable]
   def htable
@@ -405,7 +404,7 @@ private
 
   def while_disabled admin
     begin
-      admin.disableTable @name if admin.isTableEnabled(@name) 
+      admin.disableTable @name if admin.isTableEnabled(@name)
       yield
     ensure
       admin.enableTable @name
@@ -416,7 +415,14 @@ private
     Put.new(Util.to_bytes rowkey).tap { |put|
       props.each do |col, val|
         cf, cq = Util.parse_column_name(col)
-        put.add cf, cq, Util.to_bytes(val)
+        case val
+        when Hash
+          val.each do |ts, v|
+            put.add cf, cq, ts, Util.to_bytes(v)
+          end
+        else
+          put.add cf, cq, Util.to_bytes(val)
+        end
       end
     }
   end

data/lib/hbase-jruby/util.rb

@@ -2,7 +2,7 @@ require 'bigdecimal'
 
 class HBase
 module Util
-  JAVA_BYTE_ARRAY_EMPTY = [].to_java(Java::byte) 
+  JAVA_BYTE_ARRAY_EMPTY = [].to_java(Java::byte)
   JAVA_BYTE_ARRAY_CLASS = JAVA_BYTE_ARRAY_EMPTY.java_class
 
   class << self
@@ -24,7 +24,7 @@ module Util
       when nil
         ''.to_java_bytes
       when Bignum
-        Bytes.java_send :toBytes, [java.math.BigDecimal], java.math.BigDecimal.new(v.to_s)
+        raise ArgumentError, "Integer too large. Consider storing it as a BigDecimal."
       when BigDecimal
         Bytes.java_send :toBytes, [java.math.BigDecimal], v.to_java
       when java.math.BigDecimal
@@ -52,8 +52,6 @@ module Util
         Bytes.to_long val
       when :symbol, :sym
         Bytes.to_string(val).to_sym
-      when :bignum, :bigint, :biginteger
-        BigDecimal.new(Bytes.to_big_decimal(val).to_s).to_i
       when :bigdecimal
         BigDecimal.new(Bytes.to_big_decimal(val).to_s)
       when :float, :double
@@ -133,6 +131,10 @@ module Util
           org.apache.hadoop.hbase.KeyValue
         ]
 
+        imp.call HBase::Result, %w[
+          org.apache.hadoop.hbase.util.Bytes
+        ]
+
         imp.call HBase::ColumnKey, %w[
           java.util.Arrays
           org.apache.hadoop.hbase.util.Bytes
@@ -146,6 +148,7 @@ module Util
           org.apache.hadoop.hbase.client.Put
           org.apache.hadoop.hbase.io.hfile.Compression
           org.apache.hadoop.hbase.regionserver.StoreFile
+          org.apache.hadoop.hbase.Coprocessor
         ]
 
         imp.call HBase::Scoped, %w[
@@ -153,15 +156,19 @@ module Util
           org.apache.hadoop.hbase.client.Scan
           org.apache.hadoop.hbase.filter.BinaryComparator
           org.apache.hadoop.hbase.filter.ColumnPaginationFilter
-          org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter
           org.apache.hadoop.hbase.filter.ColumnRangeFilter
           org.apache.hadoop.hbase.filter.CompareFilter
           org.apache.hadoop.hbase.filter.FilterBase
           org.apache.hadoop.hbase.filter.FilterList
           org.apache.hadoop.hbase.filter.KeyOnlyFilter
+          org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter
           org.apache.hadoop.hbase.filter.PrefixFilter
+          org.apache.hadoop.hbase.filter.RegexStringComparator
           org.apache.hadoop.hbase.filter.RowFilter
           org.apache.hadoop.hbase.filter.SingleColumnValueFilter
+          org.apache.hadoop.hbase.filter.WhileMatchFilter
+          org.apache.hadoop.hbase.client.coprocessor.AggregationClient
+          org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter
         ]
       end
     end

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end
 end

data/lib/hbase-jruby.rb

@@ -9,6 +9,7 @@ require "hbase-jruby/byte_array"
 require "hbase-jruby/column_key"
 require "hbase-jruby/cell"
 require "hbase-jruby/admin"
+require "hbase-jruby/scoped/aggregation"
 require "hbase-jruby/scoped"
 require "hbase-jruby/table"
 require "hbase-jruby/result"

data/test/helper.rb

@@ -38,9 +38,7 @@ class TestHBaseJRubyBase < Test::Unit::TestCase
     @table.enable! if @table.disabled?
 
     unless RECREATE
-      @table.each do |row|
-        @table.delete row.rowkey :raw
-      end
+      @table.delete(*@table.map { |row| [row.rowkey(:raw)] })
       assert_equal 0, @table.count
     end
   end

data/test/test_aggregation.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+
+class TestAggregation < TestHBaseJRubyBase 
+  def test_aggregation
+    (1..100).each do |idx|
+      @table.put idx, 'cf1:a' => idx, 'cf1:b' => idx * 2
+    end
+
+    @table.enable_aggregation!
+
+    lci = org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter.new
+    [nil, :fixnum, :int, :integer, lci].each do |ci|
+      assert_equal 100,  @table.project('cf1:a').aggregate(:row_count, *[*ci])
+      assert_equal 5050, @table.project('cf1:a').aggregate(:sum, *[*ci])
+      assert_equal 1,    @table.project('cf1:a').aggregate(:min, *[*ci])
+      assert_equal 100,  @table.project('cf1:a').aggregate(:max, *[*ci])
+      assert_equal 50.5, @table.project('cf1:a').aggregate(:avg, *[*ci])
+      assert_equal 28,   @table.project('cf1:a').aggregate(:std, *[*ci]).to_i # FIXME: 28 or 29?
+    end
+
+    [%w[cf1:a cf1:b], %w[cf1]].each do |prj|
+      assert_equal 5050 * 3, @table.project(*prj).aggregate(:sum)
+      assert_equal 1,        @table.project(*prj).aggregate(:min)
+      assert_equal 200,      @table.project(*prj).aggregate(:max)
+    end
+
+    # No projection
+    assert_raise(ArgumentError) { @table.aggregate(:sum) }
+    assert_raise(ArgumentError) { @table.each.aggregate(:sum) }
+
+    # Invalid type
+    assert_raise(ArgumentError) { @table.project('cf1:a').aggregate(:sum, :float) }
+
+    @table.drop!
+  end
+end
+

data/test/test_cell.rb

@@ -14,7 +14,6 @@ class TestCell < Test::Unit::TestCase
       'value'                        => :string,
       :value                         => :symbol,
       123                            => :fixnum,
-      123456789012345678901234567890 => :bignum,
       123.456                        => :float,
       true                           => :boolean,
       false                          => :boolean,

data/test/test_hbase.rb

@@ -3,7 +3,7 @@
 $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
 
-class TestHBase < TestHBaseJRubyBase 
+class TestHBase < TestHBaseJRubyBase
   def test_tables
     assert @hbase.table_names.include?(TABLE)
     assert @hbase.tables.map(&:name).include?(TABLE)

data/test/test_scoped.rb

@@ -3,7 +3,7 @@
 $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
 
-class TestScoped < TestHBaseJRubyBase 
+class TestScoped < TestHBaseJRubyBase
   def test_invalid_limit
     assert_raise(ArgumentError) { @table.limit }
     assert_raise(ArgumentError) { @table.limit(-1) }
@@ -88,9 +88,14 @@ class TestScoped < TestHBaseJRubyBase
     assert_equal 9,   @table.range(111..150).filter('cf1:a' => 131...140).count
     assert_equal 2,   @table.range(111..150).filter('cf1:a' => 131...140, 'cf2:b' => 132..133).count
 
+    # Count with block
+    assert_equal 5,  @table.range(111..150).filter('cf1:a' => 131..140).
+                            count { |result| result.fixnum('cf1:a') % 2 == 0 }
+
     # Unscope
     assert_equal 50, @table.range(111..150).filter('cf1:a' => 131...140, 'cf2:b' => 132..133).unscope.count
   end
+
   def test_scan
     insert = lambda do
       (40..70).each do |i|
@@ -314,5 +319,44 @@ class TestScoped < TestHBaseJRubyBase
     #        batch(10).
     #        map { |row| [row.rowkey(:fixnum), row.count].map(&:to_s).join ': ' }
   end
+
+  def test_while
+    (0...100).each do |idx|
+      @table.put idx, 'cf1:a' => idx % 10, 'cf2:b' => 'Hello'
+    end
+
+    assert_equal 20, @table.filter('cf1:a' => { lte: 1 }, 'cf2:b' => 'Hello').count
+    assert_equal 2,  @table.while( 'cf1:a' => { lte: 1 }, 'cf2:b' => 'Hello').count
+
+    # while == filter for gets
+    assert_equal 20, @table.filter('cf1:a' => { lte: 1 }, 'cf2:b' => 'Hello').get((0..100).to_a).compact.length
+    assert_equal 20, @table.while( 'cf1:a' => { lte: 1 }, 'cf2:b' => 'Hello').get((0..100).to_a).compact.length
+  end
+
+  def test_min_max
+    (0...100).each do |idx|
+      @table.put idx, 'cf1:a' => 1
+      assert_equal 0,   @table.to_a.reverse.min.rowkey(:fixnum)
+      assert_equal idx, @table.to_a.reverse.max.rowkey(:fixnum)
+    end
+  end
+
+  def test_regex
+    ('aa'..'zz').each do |rowkey|
+      @table.put rowkey, 'cf1:a' => rowkey
+    end
+
+    assert_equal  1, @table.filter('cf1:a' => /gg/).count
+    assert_equal  1, @table.filter('cf1:a' => /GG/i).count
+    assert_equal 51, @table.filter('cf1:a' => /g/).count
+    assert_equal  0, @table.filter('cf1:a' => /G/).count
+    assert_equal 51, @table.filter('cf1:a' => /G/i).count
+    assert_equal 26, @table.filter('cf1:a' => /g./).count
+    assert_equal 26, @table.filter('cf1:a' => /^g/).count
+    assert_equal 26, @table.filter('cf1:a' => /g$/).count
+    assert_equal  2, @table.filter('cf1:a' => /gg|ff/).count
+    assert_equal 28, @table.filter('cf1:a' => ['aa', 'cc', /^g/]).count
+    assert_equal 54, @table.filter('cf1:a' => ['aa', 'cc', /^g/, { gte: 'xa', lt: 'y'}]).count
+  end
 end
 

data/test/test_table.rb

@@ -2,8 +2,9 @@
 
 $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
+require 'bigdecimal'
 
-class TestScoped < TestHBaseJRubyBase 
+class TestScoped < TestHBaseJRubyBase
   def test_table
     @hbase.table(TABLE) do |table|
       assert_equal TABLE, table.name
@@ -23,14 +24,12 @@ class TestScoped < TestHBaseJRubyBase
   end
 
   def test_put_then_get
-    bignum = 123456789123456789123456789
     # Single record put
     assert_equal 1, @table.put('row1',
                                'cf1:a' => 2,
                                'cf1:b' => 'b',
                                'cf1:c' => 6.28,
                                'cf1:d' => false,
-                               'cf1:e' => bignum + 1,
                                'cf1:f' => :bol,
                                'cf1:g' => BigDecimal.new("456.123"),
                                'cf1:str1' => "Goodbye", 'cf1:str2' => "Cruel world")
@@ -39,7 +38,6 @@ class TestScoped < TestHBaseJRubyBase
                                'cf1:b' => 'a',
                                'cf1:c' => 3.14,
                                'cf1:d' => true,
-                               'cf1:e' => bignum,
                                'cf1:f' => :sym,
                                'cf1:g' => BigDecimal.new("123.456"),
                                'cf1:str1' => "Hello", 'cf1:str2' => "World")
@@ -49,13 +47,16 @@ class TestScoped < TestHBaseJRubyBase
       'row3' => { 'cf1:a' => 4, 'cf1:b' => 'c', 'cf1:c' => 6.28 })
 
     # single-get (latest version)
+    result = @table.get('row1')
+    assert_equal result, result.each
+
+    assert_equal 'row1', @table.get('row1').rowkey
     assert_equal 'row1', @table.get('row1').rowkey
     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'))
     assert_equal 3.14,   @table.get('row1').float('cf1:c')
     assert_equal true,   @table.get('row1').boolean('cf1:d')
-    assert_equal bignum, @table.get('row1').bignum('cf1:e')
     assert_equal :sym,   @table.get('row1').symbol('cf1:f')
     assert_equal BigDecimal.new("123.456"), @table.get('row1').bigdecimal('cf1:g')
 
@@ -68,7 +69,6 @@ class TestScoped < TestHBaseJRubyBase
     assert_equal %w[a b],              @table.get('row1').raws('cf1:b').values.map { |v| String.from_java_bytes v }
     assert_equal [3.14, 6.28],         @table.get('row1').floats('cf1:c').values
     assert_equal [true, false],        @table.get('row1').booleans('cf1:d').values
-    assert_equal [bignum, bignum + 1], @table.get('row1').bignums('cf1:e').values
     assert_equal [:sym, :bol],         @table.get('row1').symbols('cf1:f').values
     assert_equal [
       BigDecimal.new("123.456"),
@@ -77,9 +77,9 @@ class TestScoped < TestHBaseJRubyBase
     assert @table.get('row1').fixnums('cf1:a').keys.all? { |k| k.instance_of? Fixnum }
 
     # single-get-multi-col-multi=ver
-    ret = @table.get('row1').strings(['cf1:str1', 'cf1:str2'])
-    assert_equal ['Hello', 'World'], ret.map(&:values).map(&:first)
-    assert_equal ['Goodbye', 'Cruel world'], ret.map(&:values).map(&:last)
+    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 }
@@ -91,10 +91,45 @@ class TestScoped < TestHBaseJRubyBase
     assert_equal nil,    @table.get('row1').symbol('cf1:xxx')
     assert_equal nil,    @table.get('row1').integer('cf1:xxx')
 
+    # Unavailable columns (plural form)
+    assert_equal({},    @table.get('row1').strings('cf1:xxx'))
+    assert_equal({},    @table.get('row1').strings('cfx:xxx'))
+
     # Row not found
     assert_equal nil,    @table.get('xxx')
   end
 
+  # Put added after a delete is overshadowed if its timestamp is older than than that of the tombstone
+  # https://issues.apache.org/jira/browse/HBASE-2847
+  def test_put_delete_put
+    pend("https://issues.apache.org/jira/browse/HBASE-2847") do
+      data = { 'cf1:pdp' => { 1250000000000 => 'A1' } }
+      @table.put :rowkey => data
+      assert_equal 'A1', @table.get(:rowkey).string('cf1:pdp')
+      @table.delete :rowkey
+      assert_nil @table.get(:rowkey)
+      @table.put :rowkey => data
+      assert_equal 'A1', @table.get(:rowkey).string('cf1:pdp')
+    end
+  end
+
+  def test_put_timestamp
+    rowkey = :test_put_timestamp
+    @table.put rowkey => {
+      'cf1:b' => 'B1',
+      'cf1:a' => {
+        1250000000000 => 'A1',
+        1260000000000 => 'A2',
+        1270000000000 => 'A3',
+      },
+    }
+
+    assert_equal [1270000000000, 'A3'], @table.get(rowkey).strings('cf1:a').first
+    assert_equal 'A2', @table.get(rowkey).strings('cf1:a')[1260000000000]
+    assert_equal [1250000000000, 'A1'], @table.get(rowkey).strings('cf1:a').to_a.last
+    assert_equal ['B1'], @table.get(rowkey).strings('cf1:b').values
+  end
+
   def test_to_hash
     data = {
       'cf1:a' => 'Hello',
@@ -102,7 +137,7 @@ class TestScoped < TestHBaseJRubyBase
       'cf1:c' => 3.14,
       'cf2:d' => :world,
       'cf2:e' => false,
-      'cf3:f' => 1234567890123456789012345678901234567890,
+      'cf3:f' => BigDecimal.new(1234567890123456789012345678901234567890),
       'cf3'   => true
     }
     schema = {
@@ -111,7 +146,7 @@ class TestScoped < TestHBaseJRubyBase
       'cf1:c' => :float,
       HBase::ColumnKey(:cf2, :d) => :symbol,
       HBase::ColumnKey(:cf2, :e) => :boolean,
-      HBase::ColumnKey(:cf3, :f) => :biginteger,
+      HBase::ColumnKey(:cf3, :f) => :bigdecimal,
       'cf3'   => :boolean
     }
     @table.put('row1', data)