hbase-jruby 0.5.1-java → 0.6.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c04d7e2d6f49d78fb778390c8711ce7bf627f15f
-  data.tar.gz: 604381ab596d50cea5cea4f75367922dbe885ed1
+  metadata.gz: 156f951a80f9417d27674a2056eb3f71ed17329c
+  data.tar.gz: 5fa71d8f88ba39badc690da581f2ccc64a5ca7f3
 SHA512:
-  metadata.gz: 93afab3c71ca6c297854e053b636d37a19f46af3be8c31ff78dc034dab53b664d60342db70875bce1161765eff60f0f00e920c86c11e3614fc65b97f01edb9c9
-  data.tar.gz: 70bc34ecaa532528a0ca26a31a123ec66e517c74875d43e6d007c56aa6c7a0573eb511bf0abd0ae3907f93ba07c0656085c33365cb42ef0b1b0a12c7244a623c
+  metadata.gz: 7a21f92d008748eca8c1c333721939356092770a0425891fa1f575d5bac14a3c4b0570f843f0ea2ce31fdd5dc58b4b5b2576330446622e9046f5abcaa497989a
+  data.tar.gz: 4f6f2bf84a19fc129bd5d4263e87d3344a9199c60734a5b95d2d3ec476fe54c9433b573a7837767df3c826b47eb1e744fc65d61972f4ca5a2123269f8b7a86cb

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 Changelog
 =========
 
+0.6.0
+-----
+
+0.6.0 includes a few backward-incompatible changes.
+
+- Default number of versions for a scan or get is now changed to 1 to match Java API
+    - Make sure to set versions to `:all` if you're calling `to_H` or plural datatype methods
+        - `scoped.versions(:all).to_H`
+        - `scoped.versions(:all).strings('d:title')`
+- Removed `HBase::Table::BatchAction#mutate` method
+    - RowMutation is not allowed in `HBase::Table#batch`
+        - https://issues.apache.org/jira/browse/HBASE-11421
+- Added CDH5.1 dependency profile
+
 0.5.1
 -----
 - Fixed `Table#aggregate` for HBase 0.98 or above

data/README.md

@@ -96,7 +96,7 @@ table.put 1,
   price:     BigDecimal('21.50'),
   weight:    3.0,
   in_print:  true,
-  image:     File.open('thumbnail.png', 'rb') { |f| f.read }.to_java_bytes,
+  image:     File.open('thumbnail.png', 'rb') { | f          | f.read }.to_java_bytes,
   summary:   'A wide-ranging, comparative study of mythology and religion',
   reviews:   52,
   stars:     226,
@@ -123,7 +123,7 @@ table.range(0..100)
              category: ['Comics', 'Fiction', /cult/i],
              price:    { lt: BigDecimal('30.00') },
              summary:  /myth/i)
-     .each do |book|
+     .each do                                   | book       |
 
   # Update columns
   table.put book.rowkey, price: book[:price] + BigDecimal('1')
@@ -152,21 +152,22 @@ or by `require`ing relevant JAR files after launching JRuby.
 Well, there's an easier way.
 Call `HBase.resolve_dependency!` helper method passing one of the arguments listed below.
 
-| Argument   | Dependency               | Default version | Required executable |
-| ---------- | ------------------------ | --------------- | ------------------- |
-| cdh5.0[.*] | Cloudera CDH5.0          | cdh5.0.0        | mvn                 |
-| cdh4.5[.*] | Cloudera CDH4.5          | cdh4.5.0        | mvn                 |
-| cdh4.4[.*] | Cloudera CDH4.4          | cdh4.4.0        | mvn                 |
-| cdh4.3[.*] | Cloudera CDH4.3          | cdh4.3.2        | mvn                 |
-| cdh4.2[.*] | Cloudera CDH4.2          | cdh4.2.2        | mvn                 |
-| cdh4.1[.*] | Cloudera CDH4.1          | cdh4.1.5        | mvn                 |
-| cdh3[u*]   | Cloudera CDH3            | cdh3u6          | mvn                 |
-| 0.98[.*]   | Apache HBase 0.98        | 0.98.0-hadoop2  | mvn                 |
-| 0.96[.*]   | Apache HBase 0.96        | 0.96.2-hadoop2  | mvn                 |
-| 0.94[.*]   | Apache HBase 0.94        | 0.94.18         | mvn                 |
-| 0.92[.*]   | Apache HBase 0.92        | 0.92.2          | mvn                 |
-| *POM PATH* | Custom Maven POM file    | -               | mvn                 |
-| `:local`   | Local HBase installation | -               | hbase               |
+                                                | Argument   | Dependency               | Default version | Required executable |
+                                                | ---------- | ------------------------ | --------------- | ------------------- |
+                                                | cdh5.1[.*] | Cloudera CDH5.1          | cdh5.1.0        | mvn                 |
+                                                | cdh5.0[.*] | Cloudera CDH5.0          | cdh5.0.0        | mvn                 |
+                                                | cdh4.5[.*] | Cloudera CDH4.5          | cdh4.5.0        | mvn                 |
+                                                | cdh4.4[.*] | Cloudera CDH4.4          | cdh4.4.0        | mvn                 |
+                                                | cdh4.3[.*] | Cloudera CDH4.3          | cdh4.3.2        | mvn                 |
+                                                | cdh4.2[.*] | Cloudera CDH4.2          | cdh4.2.2        | mvn                 |
+                                                | cdh4.1[.*] | Cloudera CDH4.1          | cdh4.1.5        | mvn                 |
+                                                | cdh3[u*]   | Cloudera CDH3            | cdh3u6          | mvn                 |
+                                                | 0.98[.*]   | Apache HBase 0.98        | 0.98.0-hadoop2  | mvn                 |
+                                                | 0.96[.*]   | Apache HBase 0.96        | 0.96.2-hadoop2  | mvn                 |
+                                                | 0.94[.*]   | Apache HBase 0.94        | 0.94.18         | mvn                 |
+                                                | 0.92[.*]   | Apache HBase 0.92        | 0.92.2          | mvn                 |
+                                                | *POM PATH* | Custom Maven POM file    | -               | mvn                 |
+                                                | `:local`   | Local HBase installation | -               | hbase               |
 
 (Default version is used when an argument prefix is given without specific patch version.
  e.g. `cdh4.2` defaults to `cdh4.2.2`)
@@ -261,7 +262,7 @@ table.create! cf1: {},
 | APPEND             | Appends values to one or more columns within a single row                                     |
 | Checked PUT/DELETE | Atomically checks if the pre-exising data matches the expected value and puts or deletes data |
 | MUTATE             | Performs multiple mutations (PUTS and DELETES) atomically on a single row                     |
-| Batch execution    | Performs multiple actions (PUT, GET, DELETE, INCREMENT, APPEND, and MUTATE) at once           |
+| Batch execution    | Performs multiple actions (PUT, GET, DELETE, INCREMENT, APPEND) at once                       |
 
 ### Defining table schema for easier data access
 
@@ -348,7 +349,7 @@ year   = book[:year]
 hash = book.to_h
 
 # Convert to Hash containing all versions of values indexed by their timestamps
-all_hash = book.to_H
+all_hash = table.versions(:all).get('rowkey1').to_H
 
 # Columns not defined in the schema are returned as Java byte arrays
 # They need to be decoded manually
@@ -412,7 +413,7 @@ hash['cf2:10']
 hash[[:cf2, 10]]
   # byte[102, 111, 111, 98, 97, 114]@6f28bb44
 
-hash_with_versions = book.to_H
+hash_with_versions = table.versions(:all).get(10000).to_H
   # {
   #   :title => {1369019227766 => "Hello world"},
   #   [:cf2, HBase::ByteArray<0, 0, 0, 0, 0, 0, 0, 10>] =>
@@ -539,17 +540,13 @@ ret = table.batch do |b|
   b.append rowkey3, 'cf1:b' => 'world'
   b.delete rowkey3, 'cf2', 'cf3:z'
   b.increment rowkey3, 'cf1:a' => 200, 'cf1:c' => 300
-  b.mutate(rowkey4) do |m|
-    m.put 'cf3:z' => 3.14
-    m.delete 'cf3:y', 'cf4'
-  end
 end
 ```
 
 `batch` method returns an Array of Hashes which contains the results of the
 actions in the order they are specified in the block. Each Hash has `:type` entry
 (:get, :put, :append, etc.) and `:result` entry. If the type of an action is
-:put, :delete, or :mutate, the `:result` will be given as a boolean. If it's an
+:put or :delete, the `:result` will be given as a boolean. If it's an
 :increment or :append, a plain Hash will be returned as the `:result`, just like
 in [increment](https://github.com/junegunn/hbase-jruby#increment-atomic-increment-of-column-values)
 and [append](https://github.com/junegunn/hbase-jruby#append) methods.

data/lib/hbase-jruby/dependency.rb

@@ -12,6 +12,7 @@ class HBase
   # https://ccp.cloudera.com/display/SUPPORT/CDH+Downloads
   SUPPORTED_PROFILES = {
     # Prefix => Latest known version
+    'cdh5.1' => 'cdh5.1.0',
     'cdh5.0' => 'cdh5.0.0',
     'cdh4.6' => 'cdh4.6.0',
     'cdh4.5' => 'cdh4.5.0',

data/lib/hbase-jruby/pom/pom.xml.erb

@@ -10,13 +10,13 @@
   <name>hbase-jruby</name>
 
   <profiles>
-    <% %w[cdh5.0].each do |cdh| %>
+    <% { 'cdh5.0' => '0.96.1.1', 'cdh5.1' => '0.98.1' }.each do |cdh, hbase_version| %>
     <profile>
       <id><%= cdh %></id>
       <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <hadoop.version>2.3.0-<%= profiles[cdh] %></hadoop.version>
-        <hbase.version>0.96.1.1-<%= profiles[cdh] %></hbase.version>
+        <hbase.version><%= hbase_version %>-<%= profiles[cdh] %></hbase.version>
       </properties>
       <repositories>
         <repository>

data/lib/hbase-jruby/scoped.rb

@@ -213,11 +213,13 @@ class Scoped
   end
 
   # Returns an HBase::Scoped object with the specified version number limit.
-  # If not set, all versions of each value are fetched by default.
-  # @param [Fixnum] vs Sets the maximum number of versions
+  # If not set or set to :all, all versions are fetched.
+  # @param [Fixnum|:all] vs Sets the maximum number of versions
   # @return [HBase::Scoped] HBase::Scoped object with the version number limit
   def versions vs
-    raise ArgumentError, "Invalid versions. Must be a positive integer." unless vs.is_a?(Fixnum) && vs > 0
+    unless vs.is_a?(Fixnum) && vs > 0 || vs == :all
+      raise ArgumentError, "Invalid versions. Must be a positive integer or :all."
+    end
     spawn :@versions, vs
   end
 
@@ -350,11 +352,7 @@ private
 
   def getify rowkey
     Get.new(Util.to_bytes rowkey).tap { |get|
-      if @versions
-        get.setMaxVersions @versions
-      else
-        get.setMaxVersions
-      end
+      set_max_versions get
 
       filters = []
       filters += process_projection!(get)
@@ -495,6 +493,15 @@ private
     end
   end
 
+  def set_max_versions obj
+    case @versions
+    when Fixnum
+      obj.setMaxVersions @versions
+    when :all
+      obj.setMaxVersions
+    end
+  end
+
   def filtered_scan
     Scan.new.tap { |scan|
       # Range
@@ -534,11 +541,7 @@ private
       end
 
       # Versions
-      if @versions
-        scan.setMaxVersions @versions
-      else
-        scan.setMaxVersions
-      end
+      set_max_versions scan
 
       # Timerange / Timestamp
       case @trange

data/lib/hbase-jruby/table/batch_action.rb

@@ -44,11 +44,6 @@ class BatchAction
     @actions << { :type => :increment, :action => @mutation.increment(*args) }
   end
 
-  # @see HBase::Table#mutate
-  def mutate *args, &blk
-    @actions << { :type => :mutate, :action => @mutation.mutate(*args, &blk) }
-  end
-
   [:get, :range, :project, :filter, :versions, :time_range, :at].each do |method|
     define_method(method) do |*args|
       BatchGetScoped.send(:new, @table.scoped, proc { |get|

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = '0.5.1'
+  VERSION = '0.6.0'
 end
 end

data/test/test_hbase.rb

@@ -54,6 +54,9 @@ class TestHBase < TestHBaseJRubyBase
     @hbase = connect
     table = @hbase[TABLE]
     assert_equal table.htable, Thread.current[:hbase_jruby][@hbase][TABLE]
+
+    # FIXME: Connection is closed, we have to update @table object
+    @table = @hbase.table(TABLE)
   end
 
   def test_admin

data/test/test_schema.rb

@@ -281,9 +281,18 @@ class TestSchema < TestHBaseJRubyBase
     # Coprocessor
     if @aggregation
       table.enable_aggregation!
+      # Expected:
+      # 844 = reviews(52) + inc(1) + stars(226) + inc(2 + 3) +
+      #       put-review(100) + put-stars(500)
       table.put next_rowkey, :reviews => 100, :stars => 500
-      assert_equal data[:reviews] + 1 + data[:stars] + 5 + 100 + 500,
+      assert_equal data[:reviews] + 1 + data[:stars] + 2 + 3 + 100 + 500,
         table.project(:reviews, :stars).aggregate(:sum)
+
+      assert_equal data[:reviews] + 1 + data[:stars] + 2 + 3 + 100 + 500,
+        table.project(:reviews, :stars).versions(1).aggregate(:sum)
+
+      assert_equal data[:reviews] * 2 + 1 + data[:stars] * 3 + 2 * 2 + 3 + 100 + 500,
+        table.project(:reviews, :stars).versions(:all).aggregate(:sum)
       #table.disable_aggregation!
     end
 
@@ -332,9 +341,7 @@ class TestSchema < TestHBaseJRubyBase
     assert_equal 'great', table.get(rk)[:comment4]
 
     # Batch
-    # FIXME: Mutation in batch hangs on 0.96, temporarily using @aggregation
-    # here to see if the version if 0.96 (no AggregationClient) or not
-    mutation_in_batch = @aggregation
+    # XXX: Mutation in batch is no more allowed in 0.98
     ret = table.batch do |b|
       b.put rk, :comment5 => 'gnarly'
       b.delete rk, :comment4
@@ -346,26 +353,12 @@ class TestSchema < TestHBaseJRubyBase
       b.append rk, :category => '/Etc'
       b.get rk
 
-      if mutation_in_batch
-        b.mutate(rk) do |m|
-          m.put :comment6 => 'rad'
-          m.delete :image
-        end
-      else
-        table.mutate(rk) do |m|
-          m.put :comment6 => 'rad'
-          m.delete :image
-        end
-      end
+      b.put rk, :comment6 => 'rad'
+      b.delete rk, :image
     end
 
-    if mutation_in_batch
-      assert_equal 6, ret.length
-      assert_equal [true] * 3, ret.values_at(0, 1, 5).map { |r| r[:result] }
-    else
-      assert_equal 5, ret.length
-      assert_equal [true] * 2, ret.values_at(0, 1).map { |r| r[:result] }
-    end
+    assert_equal 7, ret.length
+    assert_equal [true] * 4, ret.values_at(0, 1, 5, 6).map { |r| r[:result] }
 
     assert_equal data[:stars]   + 5 + 100, ret[2][:result][:stars]
     assert_equal data[:reviews] + 1 + 200, ret[2][:result][:reviews]

data/test/test_scoped.rb

@@ -240,7 +240,7 @@ class TestScoped < TestHBaseJRubyBase
     insert.call
     [@table, @table.scoped].each do |table|
       # versions
-      assert table.all? { |result| result.to_H[%w[cf1 a]].length == 2 }
+      assert table.versions(:all).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

data/test/test_table.rb

@@ -131,21 +131,21 @@ class TestTable < TestHBaseJRubyBase
     # 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
-    assert_equal %w[a b],       @table.get(row1).strings('cf1:b').values
-    assert_equal %w[a b],       @table.get(row1).raws('cf1:b').values.map { |v| String.from_java_bytes v }
-    assert_equal %w[a b],       @table.get(row1).byte_arrays('cf1:b').values.map { |v| v.as :string }
-    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 [:sym, :bol],  @table.get(row1).symbols('cf1:f').values
+    assert_equal [1, 2],        @table.versions(:all).get(row1).fixnums('cf1:a').values
+    assert_equal %w[a b],       @table.versions(:all).get(row1).strings('cf1:b').values
+    assert_equal %w[a b],       @table.versions(:all).get(row1).raws('cf1:b').values.map { |v| String.from_java_bytes v }
+    assert_equal %w[a b],       @table.versions(:all).get(row1).byte_arrays('cf1:b').values.map { |v| v.as :string }
+    assert_equal [3.14, 6.28],  @table.versions(:all).get(row1).floats('cf1:c').values
+    assert_equal [true, false], @table.versions(:all).get(row1).booleans('cf1:d').values
+    assert_equal [:sym, :bol],  @table.versions(:all).get(row1).symbols('cf1:f').values
     assert_equal [
       BigDecimal.new("123.456"),
-      BigDecimal.new("456.123")], @table.get(row1).bigdecimals('cf1:g').values
-    assert_equal [101, 100], @table.get(row1).bytes('cf1:byte').values
-    assert_equal [201, 200], @table.get(row1).shorts('cf1:short').values
-    assert_equal [301, 300], @table.get(row1).ints('cf1:int').values
+      BigDecimal.new("456.123")], @table.versions(:all).get(row1).bigdecimals('cf1:g').values
+    assert_equal [101, 100], @table.versions(:all).get(row1).bytes('cf1:byte').values
+    assert_equal [201, 200], @table.versions(:all).get(row1).shorts('cf1:short').values
+    assert_equal [301, 300], @table.versions(:all).get(row1).ints('cf1:int').values
 
-    assert @table.get(row1).fixnums('cf1:a').keys.all? { |k| k.instance_of? Fixnum }
+    assert @table.versions(:all).get(row1).fixnums('cf1:a').keys.all? { |k| k.instance_of? Fixnum }
 
     # single-get-multi-col-multi=ver (deprecated since 0.3)
     # rets = @table.get(row1).strings(['cf1:str1', 'cf1:str2'])
@@ -196,10 +196,10 @@ class TestTable < TestHBaseJRubyBase
       },
     }
 
-    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
+    assert_equal [1270000000000, 'A3'], @table.versions(:all).get(rowkey).strings('cf1:a').first
+    assert_equal 'A2',                  @table.versions(:all).get(rowkey).strings('cf1:a')[1260000000000]
+    assert_equal [1250000000000, 'A1'], @table.versions(:all).get(rowkey).strings('cf1:a').to_a.last
+    assert_equal ['B1'],                @table.versions(:all).get(rowkey).strings('cf1:b').values
   end
 
   def test_increment
@@ -250,13 +250,13 @@ class TestTable < TestHBaseJRubyBase
     @table.put(row1, 'cf2:d' => 5)
     sleep 0.1
     @table.put(row1, 'cf2:d' => 6)
-    versions = @table.get(row1).to_H[%w[cf2 d]].keys
+    versions = @table.versions(:all).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_H[%w[cf2 d]].keys
+    new_versions = @table.versions(:all).get(row1).to_H[%w[cf2 d]].keys
     assert_equal new_versions, [versions[1]]
 
     # Deletes a column
@@ -312,10 +312,10 @@ class TestTable < TestHBaseJRubyBase
 
     assert_equal 3, @table.get(drow).to_h.keys.length
 
-    assert_equal 1, @table.get(drow).to_H['cf1:a'].length
-    assert_equal 2, @table.get(drow).to_H['cf1:b'].length
-    assert_equal 3000, @table.get(drow).to_H['cf1:a'].keys.first
-    assert_equal [6000, 4000], @table.get(drow).to_H['cf1:b'].keys
+    assert_equal 1, @table.versions(:all).get(drow).to_H['cf1:a'].length
+    assert_equal 2, @table.versions(:all).get(drow).to_H['cf1:b'].length
+    assert_equal 3000, @table.versions(:all).get(drow).to_H['cf1:a'].keys.first
+    assert_equal [6000, 4000], @table.versions(:all).get(drow).to_H['cf1:b'].keys
   end
 
   def test_delete_advanced_with_schema
@@ -354,10 +354,10 @@ class TestTable < TestHBaseJRubyBase
 
     assert_equal 3, @table.get(drow).to_h.keys.length
 
-    assert_equal 1, @table.get(drow).to_H[:a].length
-    assert_equal 2, @table.get(drow).to_H[:b].length
-    assert_equal 3000, @table.get(drow).to_H[:a].keys.first
-    assert_equal [6000, 4000], @table.get(drow).to_H[:b].keys
+    assert_equal 1, @table.versions(:all).get(drow).to_H[:a].length
+    assert_equal 2, @table.versions(:all).get(drow).to_H[:b].length
+    assert_equal 3000, @table.versions(:all).get(drow).to_H[:a].keys.first
+    assert_equal [6000, 4000], @table.versions(:all).get(drow).to_H[:b].keys
   end
 
   def test_delete_row
@@ -438,7 +438,7 @@ class TestTable < TestHBaseJRubyBase
       @table.put rk, a => 100, b => 200,
         c => { ts => 300, (ts - 1000) => 400, (ts - 2000).to_i => 500 },
         d => 1000
-      assert_equal 3, @table.get(rk).to_H[:c].length
+      assert_equal 3, @table.versions(:all).get(rk).to_H[:c].length
 
       assert_equal false, @table.check(rk, a => 200).delete(b)
       assert_equal 200, @table.get(rk)[b]
@@ -447,8 +447,8 @@ class TestTable < TestHBaseJRubyBase
       assert_equal nil, @table.get(rk)[b]
 
       assert_equal true, @table.check(rk, a => 100).delete(c, ts, (ts - 2000).to_i, 'cf2')
-      assert_equal 1, @table.get(rk).to_H[:c].length
-      assert_equal (ts - 1000).to_i, @table.get(rk).to_H[:c].keys.first / 1000
+      assert_equal 1, @table.versions(:all).get(rk).to_H[:c].length
+      assert_equal (ts - 1000).to_i, @table.versions(:all).get(rk).to_H[:c].keys.first / 1000
       assert_equal nil, @table.get(rk)[d]
 
       assert_equal true, @table.check(rk, a => 100).delete
@@ -521,8 +521,6 @@ class TestTable < TestHBaseJRubyBase
     assert_equal true, ret[1][:result]
     assert_equal true, ret[2][:result]
 
-    # FIXME: Mutation in batch hangs on 0.96
-    mutation_in_batch = @aggregation
     ret = @table.batch { |b|
       b.put rk3, 'cf1:c' => 5
       b.delete rk1, 'cf1:a'
@@ -531,29 +529,13 @@ class TestTable < TestHBaseJRubyBase
       b.get(rk1)
       b.filter('cf1:a' => 0).get(rk1)
       b.versions(1).project('cf2').get(rk1)
-      if mutation_in_batch
-        b.mutate(rk3) do |m|
-          m.put 'cf2:d' => 'hola'
-          m.put 'cf2:e' => 'mundo'
-          m.delete 'cf1:b'
-        end
-      else
-        @table.mutate(rk3) do |m|
-          m.put 'cf2:d' => 'hola'
-          m.put 'cf2:e' => 'mundo'
-          m.delete 'cf1:b'
-        end
-      end
+      b.put rk3, 'cf2:d' => 'hola'
+      b.put rk3, 'cf2:e' => 'mundo'
+      b.delete rk3, 'cf1:b'
     }
-    if mutation_in_batch
-      assert_equal 8, ret.length
-      assert_equal [:put, :delete, :increment, :append, :get, :get, :get, :mutate], ret.map { |r| r[:type] }
-      assert_equal [true, true, true], ret.values_at(0, 1, 7).map { |r| r[:result] }
-    else
-      assert_equal 7, ret.length
-      assert_equal [:put, :delete, :increment, :append, :get, :get, :get], ret.map { |r| r[:type] }
-      assert_equal [true, true], ret.values_at(0, 1).map { |r| r[:result] }
-    end
+    assert_equal [:put, :delete, :increment, :append, :get, :get, :get, :put, :put, :delete], ret.map { |r| r[:type] }
+    assert_equal [true, true], ret.values_at(0, 1).map { |r| r[:result] }
+
     assert_equal 12,            ret[2][:result]['cf1:a']
     assert_equal 23,            ret[2][:result]['cf1:b']
     assert_equal 'hello world', ret[3][:result]['cf2:c'].to_s

data/test/test_table_admin.rb

@@ -143,7 +143,7 @@ class TestTableAdmin < TestHBaseJRubyBase
   end
 
   def test_add_coprocessor!
-    omit "AggregationClient is removed in 0.96" unless @aggregation
+    omit "AggregationClient not found" unless @aggregation
 
     coproc = 'org.apache.hadoop.hbase.coprocessor.AggregateImplementation'
     assert_false @table.has_coprocessor? coproc

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hbase-jruby
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-06-03 00:00:00.000000000 Z
+date: 2014-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit