hbase-jruby 0.4.4-java → 0.4.5-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2dfaa38a2fb45434fd395443b5f28494851f14da
-  data.tar.gz: ca32b60a6e041d476414f155ef7a507f9f7dd77b
+  metadata.gz: 317e3299f449c9c5f847ae8118c631d22ff91872
+  data.tar.gz: 092879ce25e3448c5a777310782c7fffab0ba586
 SHA512:
-  metadata.gz: cb3f85a89139153976e241009e20b8c05058891ba388855110e072d13b83e36170be3ae95bf4dffbcb99ab46ad0bf4e24299ed4406ad4f868cacae90cdd4244c
-  data.tar.gz: b5f50fa4a779ab31d1d827793aef548ff5d7582ed66f339eb889c6b1d00d3ecf6276cd96f358f5969048187e6bf706b821e347c8c98d6736b7ff5273cf0c74ac
+  metadata.gz: 3454275b00e7636a6d1bedf6b4172ad75f74da839f7bbdb91ac8882604c2e128cef248289abbb276629ed78d4da17834d59844c8fe949cf24bd5d180d3e42433
+  data.tar.gz: 1bb37e732100751e1861605af88f0cf0e1aef988a396a95478bc10af5966c8223bcc9f03bf31529c44846b6cc7b47aa64d2796e5852964e40528ac0a851bba43

data/CHANGELOG.md

@@ -1,9 +1,19 @@
 Changelog
 =========
 
+0.4.5
+-----
+- Fixed HBase 0.96 compatibily issues and tested on HBase 0.96 and 0.98
+- Added `:split_policy` table property
+- `Table#properties` and `Table#families` now include previously unknown
+  properties as String-String pairs
+- Added `Row#byte_array` which returns an instance of `HBase::ByteArray`
+    - Equivalent to `HBase::ByteArray[row.raw(col)]`
+
+
 0.4.4
 -----
-- Fixed HBase::Table#raw_families/raw_properties on HBase shell
+- Fixed `HBase::Table#raw_families/raw_properties` on HBase shell
 
 0.4.3
 -----

data/README.md

@@ -58,15 +58,16 @@ hbase.schema = {
   book: {
     # Columns in cf1 family
     cf1: {
-      title:    :string,     # String (UTF-8)
-      author:   :string,
-      category: :string,
-      year:     :short,      # Short integer (2-byte)
-      pages:    :int,        # Integer (4-byte)
-      price:    :bigdecimal, # BigDecimal
-      weight:   :float,      # Double-precision floating-point number
-      in_print: :boolean,    # Boolean (true | false)
-      image:    :raw         # Java byte array; no automatic type conversion
+      title:     :string,     # String (UTF-8)
+      author:    :string,
+      category:  :string,
+      year:      :short,      # Short integer (2-byte)
+      pages:     :int,        # Integer (4-byte)
+      price:     :bigdecimal, # BigDecimal
+      weight:    :float,      # Double-precision floating-point number
+      in_print:  :boolean,    # Boolean (true | false)
+      image:     :raw         # Java byte array; no automatic type conversion
+      thumbnail: :byte_array  # HBase::ByteArray
     },
     # Columns in cf2 family
     cf2: {
@@ -151,21 +152,23 @@ 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 |
-| ---------- | ------------------------ | --------------- | ------------------- |
-| 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.94[.*]   | Apache HBase 0.94        | 0.94.13         | 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 |
+| ---------- | ------------------------ | ---------------  | ------------------- |
+| 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.1.1-hadoop2 | mvn                 |
+| 0.94[.*]   | Apache HBase 0.94        | 0.94.16          | 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.0`)
+ e.g. `cdh4.2` defaults to `cdh4.2.2`)
 
 #### Examples
 
@@ -1016,13 +1019,15 @@ Some of the properties are only available on recent versions of HBase.
 
 http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HTableDescriptor.html
 
-| Property              | Type    | Description                                                                                             |
-|-----------------------|---------|---------------------------------------------------------------------------------------------------------|
-| `:max_filesize`       | Fixnum  | The maximum size upto which a region can grow to after which a region split is triggered                |
-| `:readonly`           | Boolean | If the table is read-only                                                                               |
-| `:memstore_flushsize` | Fixnum  | The maximum size of the memstore after which the contents of the memstore are flushed to the filesystem |
-| `:deferred_log_flush` | Boolean | Defer the log edits syncing to the file system                                                          |
-| `:splits`             | Array   | Region split points                                                                                     |
+| Property              | Type          | Description                                                                                               |
+| --------------------- | ------------- | --------------------------------------------------------------------------------------------------------- |
+| `:max_filesize`       | Fixnum        | The maximum size upto which a region can grow to after which a region split is triggered                  |
+| `:readonly`           | Boolean       | If the table is read-only                                                                                 |
+| `:memstore_flushsize` | Fixnum        | The maximum size of the memstore after which the contents of the memstore are flushed to the filesystem   |
+| `:deferred_log_flush` | Boolean       | Defer the log edits syncing to the file system (deprecated in 0.96)                                       |
+| `:durability`         | Symbol/String | Durability setting of the table                                                                           |
+| `:split_policy`       | String/Class  | Region split policy                                                                                       |
+| `:splits`             | Array         | Region split points                                                                                       |
 
 ### Managing column families
 

data/lib/hbase-jruby/cell.rb

@@ -119,7 +119,9 @@ class Cell
   # @param [Cell] other
   # @return [Fixnum] -1, 0, or 1
   def <=> other
-    KeyValue.COMPARATOR.compare(@java, other.java)
+    (@comparator ||=
+      KeyValue.const_defined?(:COMPARATOR) ?
+        KeyValue::COMPARATOR : KeyValue.COMPARATOR).compare(@java, other.java)
   end
 
   # Checks if the cells are the same

data/lib/hbase-jruby/dependency.rb

@@ -18,9 +18,10 @@ class HBase
     'cdh4.2' => 'cdh4.2.2',
     'cdh4.1' => 'cdh4.1.5',
     'cdh3'   => 'cdh3u6',
+    '0.98'   => '0.98.0-hadoop2',
     '0.96'   => '0.96.1.1-hadoop2',
     '0.95'   => '0.95.2-hadoop2',
-    '0.94'   => '0.94.15',
+    '0.94'   => '0.94.16',
     '0.92'   => '0.92.2',
   }
 
@@ -173,8 +174,8 @@ class HBase
           org.apache.hadoop.hbase.client.Put
           org.apache.hadoop.hbase.client.RowMutations
           org.apache.hadoop.hbase.io.hfile.Compression
-          org.apache.hadoop.hbase.regionserver.StoreFile
-        ],
+          org.apache.hadoop.hbase.io.compress.Compression
+        ], # hfile.Compression <= 0.94
         HBase::Scoped => %w[
           org.apache.hadoop.hbase.client.Get
           org.apache.hadoop.hbase.client.Scan

data/lib/hbase-jruby/hbase.rb

@@ -89,7 +89,12 @@ class HBase
       unless @closed
         @closed = true
         close_table_pool
-        HConnectionManager.deleteConnection(@config, true)
+        begin
+          HConnectionManager.deleteConnection(@config)
+        rescue ArgumentError
+          # HBase 0.92 or below
+          HConnectionManager.deleteConnection(@config, true)
+        end
       end
     end
   end

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

@@ -154,7 +154,7 @@
       </dependencies>
     </profile>
 
-    <% %w[0.95 0.96].each do |version| %>
+    <% %w[0.95 0.96 0.98].each do |version| %>
     <profile>
       <id><%= version %></id>
       <properties>
@@ -170,14 +170,14 @@
           <version>2.2.0</version>
           <% else %>
           <artifactId>hadoop-core</artifactId>
-          <version>1.1.2</version>
+          <version>1.2.1</version>
           <% end %>
           <scope>compile</scope>
         </dependency>
 
         <dependency>
           <groupId>org.apache.hbase</groupId>
-          <artifactId>hbase</artifactId>
+          <artifactId>hbase-client</artifactId>
           <version>${hbase.version}</version>
           <scope>compile</scope>
         </dependency>
@@ -190,7 +190,7 @@
       <id><%= version %></id>
       <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <hadoop.version>1.1.2</hadoop.version>
+        <hadoop.version>1.2.1</hadoop.version>
         <hbase.version><%= profiles[version] %></hbase.version>
       </properties>
 

data/lib/hbase-jruby/row.rb

@@ -80,191 +80,165 @@ class Row
   end
   alias to_hash_with_versions to_H
 
-  # Returns column values as byte arrays
-  # @overload raw(column)
-  #   Returns the latest column value as a byte array
-  #   @param [String, Array] col Column name as String or 2-element Array of family and qualifier
-  #   @return [byte[]] Byte array representation of the latest value
+  # Returns the latest column value as a Java byte array
+  # @param [String, Array] col Column name as String or 2-element Array of family and qualifier
+  # @return [byte[]] Byte array representation of the latest value
   def raw col
     get_value col
   end
 
-  # Returns all versions of column values as byte arrays in a Hash indexed by their timestamps
-  # @overload raws(column)
-  #   Returns all versions of column values as byte arrays in a Hash indexed by their timestamps
-  #   @param [String, Array] col Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, byte[]>]
+  # Returns all versions of column values as Java byte arrays in a Hash indexed by their timestamps
+  # @param [String, Array] col Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, byte[]>]
   def raws col
     get_value col, true
   end
 
-  # Returns column values as Strings
-  # @overload string(column)
-  #   Returns the latest column value as a String
-  #   @param [String, Array] col Column name as String or 2-element Array of family and qualifier
-  #   @return [String]
+  # Returns the latest column value as a HBase::ByteArray instance
+  # @param [String, Array] col Column name as String or 2-element Array of family and qualifier
+  # @return [byte[]] Byte array representation of the latest value
+  def byte_array col
+    decode_value :byte_array, col
+  end
+
+  # Returns all versions of column values as HBase::ByteArray instances in a Hash indexed by their timestamps
+  # @param [String, Array] col Column name as String or 2-element Array of family and qualifier
+  # @return [byte[]] Byte array representation of the latest value
+  def byte_arrays col
+    decode_value :byte_array, col, true
+  end
+
+  # Returns the latest column value as a String
+  # @param [String, Array] col Column name as String or 2-element Array of family and qualifier
+  # @return [String]
   def string col
     decode_value :string, col
   end
   alias str string
 
   # Returns all versions of column values as Strings in a Hash indexed by their timestamps
-  # @overload strings(column)
-  #   Returns all versions of column values as Strings in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, String>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, String>]
   def strings col
     decode_value :string, col, true
   end
   alias strs strings
 
-  # Returns column values as Symbols
-  # @overload symbol(column)
-  #   Returns the latest column value as a Symbol
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Symbol]
+  # Returns the latest column value as a Symbol
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Symbol]
   def symbol col
     decode_value :symbol, col
   end
   alias sym symbol
 
   # Returns all versions of column values as Symbols in a Hash indexed by their timestamps
-  # @overload symbols(column)
-  #   Returns all versions of column values as Symbols in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, Symbol>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, Symbol>]
   def symbols col
     decode_value :symbol, col, true
   end
   alias syms symbols
 
-  # Returns 1-byte column values as Fixnums
-  # @overload byte(column)
-  #   Returns the latest column value as a Fixnum
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Fixnum]
+  # Returns the latest 1-byte column value as a Fixnum
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Fixnum]
   def byte col
     decode_value :byte, col
   end
 
   # Returns all versions of 1-byte column values as Fixnums in a Hash indexed by their timestamps
-  # @overload bytes(column)
-  #   Returns all versions of column values as Fixnums in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, Fixnum>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, Fixnum>]
   def bytes col
     decode_value :byte, col, true
   end
 
-  # Returns 2-byte column values as Fixnums
-  # @overload short(column)
-  #   Returns the latest 2-byte column value as a Fixnum
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Fixnum]
+  # Returns the latest 2-byte column value as a Fixnum
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Fixnum]
   def short col
     decode_value :short, col
   end
 
   # Returns all versions of 2-byte column values as Fixnums in a Hash indexed by their timestamps
-  # @overload shorts(column)
-  #   Returns all versions of 2-byte column values as Fixnums in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, Fixnum>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, Fixnum>]
   def shorts col
     decode_value :short, col, true
   end
 
-  # Returns 4-byte column values as Fixnums
-  # @overload int(column)
-  #   Returns the latest 4-byte column value as a Fixnum
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Fixnum]
+  # Returns the latest 4-byte column value as a Fixnum
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Fixnum]
   def int col
     decode_value :int, col
   end
 
   # Returns all versions of 4-byte column values as Fixnums in a Hash indexed by their timestamps
-  # @overload ints(column)
-  #   Returns all versions of 4-byte column values as Fixnums in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, Fixnum>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, Fixnum>]
   def ints col
     decode_value :int, col, true
   end
 
-  # Returns 8-byte column values as Fixnums
-  # @overload fixnum(column)
-  #   Returns the latest 8-byte column value as a Fixnum
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Fixnum]
+  # Returns the latest 8-byte column value as a Fixnum
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Fixnum]
   def fixnum col
     decode_value :fixnum, col
   end
   alias long fixnum
 
   # Returns all versions of 8-byte column values as Fixnums in a Hash indexed by their timestamps
-  # @overload fixnums(column)
-  #   Returns all versions of 8-byte column values as Fixnums in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, Fixnum>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, Fixnum>]
   def fixnums col
     decode_value :fixnum, col, true
   end
   alias longs fixnums
 
-  # Returns column values as Bigdecimals
-  # @overload bigdecimal(column)
-  #   Returns the latest column value as a BigDecimal
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [BigDecimal]
+  # Returns the latest column value as a BigDecimal
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [BigDecimal]
   def bigdecimal col
     decode_value :bigdecimal, col
   end
 
   # Returns all versions of column values as BigDecimals in a Hash indexed by their timestamps
-  # @overload bigdecimals(column)
-  #   Returns all versions of column values as BigDecimals in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, BigDecimal>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, BigDecimal>]
   def bigdecimals col
     decode_value :bigdecimal, col, true
   end
 
-  # Returns column values as Floats
-  # @overload float(column)
-  #   Returns the latest column value as a Float
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Float]
+  # Returns the latest column value as a Float
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Float]
   def float col
     decode_value :float, col
   end
   alias double float
 
   # Returns all versions of column values as Floats in a Hash indexed by their timestamps
-  # @overload floats(column)
-  #   Returns all versions of column values as Floats in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, Float>]
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, Float>]
   def floats col
     decode_value :float, col, true
   end
   alias doubles floats
 
-  # Returns column values as Booleans
-  # @overload boolean(column)
-  #   Returns the latest column value as a boolean value
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [true, false]
+  # Returns the latest column value as a boolean value
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [true, false]
   def boolean col
     decode_value :boolean, col
   end
   alias bool boolean
 
-  # Returns all versions of column values as Booleans in a Hash indexed by their timestamps
-  # @overload booleans(column)
-  #   Returns all versions of column values as boolean values in a Hash indexed by their timestamps
-  #   @param [String, Array] column Column name as String or 2-element Array of family and qualifier
-  #   @return [Hash<Fixnum, true|false>]
+  # Returns all versions of column values as boolean values in a Hash indexed by their timestamps
+  # @param [String, Array] column Column name as String or 2-element Array of family and qualifier
+  # @return [Hash<Fixnum, true|false>]
   def booleans col
     decode_value :boolean, col, true
   end

data/lib/hbase-jruby/scoped.rb

@@ -28,7 +28,7 @@ class Scoped
 
     scan = block_given? ? filtered_scan : filtered_scan_minimum
     scan.cache_blocks = options[:cache_blocks]
-    if options[:caching] && (@mlimit.nil? || options[:caching] < @mlimit)
+    if options[:caching] && (@limit.nil? || options[:caching] < @limit)
       scan.caching = options[:caching]
     end
 
@@ -166,7 +166,7 @@ class Scoped
     unless (rows.is_a?(Fixnum) && rows >= 0) || rows.nil?
       raise ArgumentError, "Invalid limit. Must be a non-negative integer or nil."
     end
-    spawn :@limit, rows, :@mlimit, nil
+    spawn :@limit, rows
   end
 
   # Returns an HBase::Scoped object with the specified time range
@@ -264,7 +264,6 @@ private
     @dcaching = default_caching
     @caching  = nil
     @limit    = nil
-    @mlimit   = nil
     @trange   = nil
     @scan_cbs = []
     @get_cbs  = []
@@ -529,14 +528,8 @@ private
 
       # Limit
       if @limit
-        # setMaxResultSize not yet implemented in 0.94
-        if scan.respond_to?(:setMaxResultSize)
-          scan.setMaxResultSize(@limit)
-        else
-          @mlimit = @limit
-          if [@caching, @dcaching].compact.all? { |c| @mlimit < c }
-            scan.caching = @mlimit
-          end
+        if [@caching, @dcaching].compact.all? { |c| @limit < c }
+          scan.caching = @limit
         end
       end
 
@@ -649,10 +642,10 @@ private
 
   def iterate scan
     scanner = htable.getScanner(scan)
-    if @mlimit
+    if @limit
       scanner.each_with_index do |result, idx|
         yield result
-        break if idx == @mlimit - 1
+        break if idx == @limit - 1
       end
     else
       scanner.each do |result|

data/lib/hbase-jruby/table.rb

@@ -211,7 +211,8 @@ class Table
   #     m.put e: 3.14
   #   end
   def mutate(rowkey, &block)
-    htable.mutateRow @mutation.mutate(rowkey, &block)
+    ms = @mutation.mutate(rowkey, &block)
+    htable.mutateRow ms if ms
   end
 
   # Scan through the table

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

@@ -281,6 +281,29 @@ private
     :readonly           => { :get => :isReadOnly,           :set => :setReadOnly },
     :memstore_flushsize => { :get => :getMemStoreFlushSize, :set => :setMemStoreFlushSize },
     :deferred_log_flush => { :get => :isDeferredLogFlush,   :set => :setDeferredLogFlush },
+    :split_policy       => { :get => :getRegionSplitPolicyClassName,
+                             :set => proc { |htd, v|
+                               htd.setValue HTableDescriptor::SPLIT_POLICY,
+                                 case v
+                                 when String
+                                   v
+                                 when Class
+                                   v.java_class.name
+                                 when Java::JavaClass
+                                   v.name
+                                 else
+                                   raise ArgumentError, "Invalid type for region split policy"
+                                 end
+                             }
+                           },
+    :durability         => { :get => :getDurability,
+                             :set => proc { |htd, v|
+                                const = const_shortcut(
+                                  org.apache.hadoop.hbase.client.Durability, v,
+                                  "Invalid durability setting")
+                                htd.setDurability const
+                             }
+                           }
   }
 
   MAX_SPLIT_WAIT = 30
@@ -330,7 +353,7 @@ private
     end
   end
 
-  def const_shortcut base, v, message
+  def self.const_shortcut base, v, message
     # Match by constant value
     # - const_get doesn't work with symbols in 1.8 compatibility mode
     if base.constants.map { |c| base.const_get c }.any? { |cv| v == cv }
@@ -343,12 +366,20 @@ private
     end
   end
 
+  def const_shortcut *args
+    Table.const_shortcut(*args)
+  end
+
   def patch_table_descriptor! htd, props
     props.each do |key, value|
       next if key == :splits
 
       if method = TABLE_PROPERTIES[key] && TABLE_PROPERTIES[key][:set]
-        htd.send method, value
+        if method.is_a? Symbol
+          htd.send method, value
+        else
+          method.call htd, value
+        end
       elsif key.is_a?(String)
         htd.setValue key, value.to_s
       else
@@ -359,7 +390,7 @@ private
   end
 
   def _alter props, bang, &block
-    raise ArgumentError, ":split not supported" if props[:splits]
+    raise ArgumentError, ":splits not supported" if props[:splits]
     with_admin do |admin|
       htd = admin.get_table_descriptor(@name.to_java_bytes)
       patch_table_descriptor! htd, props

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

@@ -10,13 +10,19 @@ class Table
   # @return [Hash]
   def properties
     desc = descriptor
-    {}.tap { |props|
+    parse_raw_map(descriptor.values).tap { |props|
       TABLE_PROPERTIES.each do |prop, gs|
         get = gs[:get]
         if get && desc.respond_to?(get)
+          props.delete(prop.to_s.upcase)
           props[prop] = parse_property desc.send get
         end
       end
+
+      # deferred_log_flush is deprecated in 0.96
+      if props.has_key?(:durability) && props.has_key?(:deferred_log_flush)
+        props.delete :deferred_log_flush
+      end
     }
   end
 
@@ -33,10 +39,11 @@ class Table
       descriptor.families.each do |family|
         name = family.name_as_string
         ret[name] =
-          {}.tap { |props|
+          parse_raw_map(family.values).tap { |props|
             COLUMN_PROPERTIES.each do |prop, gs|
               get = gs[:get]
               if get && family.respond_to?(get)
+                props.delete(prop.to_s.upcase)
                 props[prop] = parse_property family.send get
               end
             end
@@ -83,7 +90,9 @@ private
         r[:id]        = ri.region_id
         r[:start_key] = nil_if_empty ri.start_key
         r[:end_key]   = nil_if_empty ri.end_key
-        r[:root]      = ri.is_root_region
+        if ri.respond_to?(:is_root_region)
+          r[:root]      = ri.is_root_region
+        end
         r[:meta]      = ri.is_meta_region
         r[:online]    = !ri.is_offline
       }

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

@@ -102,12 +102,16 @@ class Mutation
       rm.mutations.each do |action|
         m.add action
       end
-    }
+    } unless rm.empty?
   end
 
   class Mutator
     attr_reader :mutations
 
+    def empty?
+      @mutations.empty?
+    end
+
     def initialize mutation, rowkey
       @mutation  = mutation
       @rowkey    = rowkey

data/lib/hbase-jruby/util.rb

@@ -128,6 +128,8 @@ module Util
         Bytes.to_double val
       when :boolean, :bool
         Bytes.to_boolean val
+      when :byte_array
+        ByteArray[val]
       when :raw, nil
         val
       else

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = '0.4.4'
+  VERSION = '0.4.5'
 end
 end

data/test/helper.rb

@@ -33,19 +33,20 @@ class TestHBaseJRubyBase < Test::Unit::TestCase
 
   def connect
     HBase.new('hbase.zookeeper.quorum' => ZK,
-              'hbase.client.retries.number' => 10,
+              'hbase.client.retries.number' => 5,
               'hbase.client.scanner.caching' => 100)
   end
 
   def setup
     @hbase = connect
     @table = @hbase.table(TABLE)
+    @aggregation = defined?(org.apache.hadoop.hbase.client.coprocessor.AggregationClient)
 
     # Drop & Create
     @table.drop! if RECREATE && @table.exists?
     @table.create!(
-      :cf1 => { :compression => :none, :bloomfilter => :row },
-      :cf2 => { :bloomfilter => :rowcol },
+      :cf1 => { :compression => :none, :bloomfilter => :row, :versions => 3 },
+      :cf2 => { :bloomfilter => :rowcol, :versions => 3 },
       :cf3 => { :versions => 1, :bloomfilter => :rowcol }
     ) unless @table.exists?
     @table.enable! if @table.disabled?

data/test/test_aggregation.rb

@@ -5,6 +5,9 @@ require 'helper'
 
 class TestAggregation < TestHBaseJRubyBase
   def test_aggregation
+    # AggregationClient is removed in 0.96
+    return unless @aggregation
+
     (1..100).each do |idx|
       @table.put idx, 'cf1:a' => idx, 'cf1:b' => idx * 2
     end

data/test/test_schema.rb

@@ -279,11 +279,13 @@ class TestSchema < TestHBaseJRubyBase
     assert_equal data[:stars]   + 5, inc2[:stars]
 
     # Coprocessor
-    table.enable_aggregation!
-    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!
+    if @aggregation
+      table.enable_aggregation!
+      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!
+    end
 
     # Undefined columns
     table.put rk, 'cf1:x'      => 1000
@@ -330,24 +332,48 @@ 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
     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
+
+      # https://issues.apache.org/jira/browse/HBASE-10384
+      # Due to the bug introduced in 0.96 we have to order the columns
+      # b.increment rk, :stars => 100, :reviews => 200
+      b.increment rk, :reviews => 200, :stars => 100
       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
+    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 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[: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]
+    assert_equal data[:category] + '/Etc', ret[3][:result][:category]
+    assert_instance_of HBase::Row, ret[4][:result]
+    assert_equal 1890, ret[4][:result][:year]
+    assert_equal nil, table.get(rk)[:image]
+    assert_equal 'rad', table.get(rk)[:comment6]
 
     # Delete :title column of book 1
     table.delete rk, :title

data/test/test_table.rb

@@ -77,6 +77,7 @@ class TestTable < TestHBaseJRubyBase
     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 'a',    @table.get(row1).byte_array('cf1:b').as(:string)
     assert_equal 3.14,   @table.get(row1).float('cf1:c')
     assert_equal true,   @table.get(row1).boolean('cf1:d')
     assert_equal :sym,   @table.get(row1).symbol('cf1:f')
@@ -93,6 +94,7 @@ class TestTable < TestHBaseJRubyBase
     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
@@ -479,42 +481,56 @@ 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'
       b.increment rk2, 'cf1:a' => 10, 'cf1:b' => 20
       b.append rk2, 'cf2:c' => ' world'
-      b.mutate(rk3) do |m|
-        m.put 'cf2:d' => 'hola'
-        m.put 'cf2:e' => 'mundo'
-        m.delete 'cf1:b'
-      end
       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
     }
-    assert_equal 8,             ret.length
-    assert_equal [:put, :delete, :increment, :append, :mutate, :get, :get, :get],
-      ret.map { |r| r[:type] }
-    assert_equal [true, true, true],
-      ret.values_at(0, 1, 4).map { |r| r[:result] }
+    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 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
     # assert_equal nil,           ret[5][:result].long('cf1:a') # No guarantee
-    assert_equal 2,             ret[5][:result].long('cf1:b')
-    assert_equal nil,           ret[6][:result]
-    assert_equal nil,           ret[7][:result].fixnum('cf1:b')
-    assert_equal 'hello',       ret[7][:result].string('cf2:c')
-
-    assert_equal nil, @table.get(rk1)['cf1:a']
-    assert_equal 12,  @table.get(rk2).long('cf1:a')
-    assert_equal 23,  @table.get(rk2).long('cf1:b')
-    assert_equal 5,   @table.get(rk3).long('cf1:c')
+    assert_equal 2,             ret[4][:result].long('cf1:b')
+    assert_equal nil,           ret[5][:result]
+    assert_equal nil,           ret[6][:result].fixnum('cf1:b')
+    assert_equal 'hello',       ret[6][:result].string('cf2:c')
+
+    assert_equal nil,           @table.get(rk1)['cf1:a']
+    assert_equal 12,            @table.get(rk2).long('cf1:a')
+    assert_equal 23,            @table.get(rk2).long('cf1:b')
+    assert_equal 5,             @table.get(rk3).long('cf1:c')
     assert_equal 'hello world', @table.get(rk2).string('cf2:c')
-    assert_equal 'hola', @table.get(rk3).string('cf2:d')
-    assert_equal 'mundo', @table.get(rk3).string('cf2:e')
-    assert_equal nil, @table.get(rk3).string('cf2:b')
+    assert_equal 'hola',        @table.get(rk3).string('cf2:d')
+    assert_equal 'mundo',       @table.get(rk3).string('cf2:e')
+    assert_equal nil,           @table.get(rk3).string('cf2:b')
   end
 
   def test_batch_exception

data/test/test_table_admin.rb

@@ -143,6 +143,8 @@ class TestTableAdmin < TestHBaseJRubyBase
   end
 
   def test_add_coprocessor!
+    return unless @aggregation
+
     coproc = 'org.apache.hadoop.hbase.coprocessor.AggregateImplementation'
     assert_false @table.has_coprocessor? coproc
     assert_raise(ArgumentError) {
@@ -163,10 +165,31 @@ class TestTableAdmin < TestHBaseJRubyBase
     @table.drop!
     assert @table.inspect.is_a?(String)
 
+    gz = begin
+           org.apache.hadoop.hbase.io.hfile.Compression::Algorithm::GZ
+         rescue Exception
+           org.apache.hadoop.hbase.io.compress.Compression::Algorithm::GZ
+         end
+
+    table_props = {
+      :max_filesize       => 512 * 1024 ** 2,
+      :memstore_flushsize => 64 * 1024 ** 2,
+      :readonly           => false,
+      :splits             => [10, 20, 30, 40],
+      :split_policy       =>
+          'org.apache.hadoop.hbase.regionserver.IncreasingToUpperBoundRegionSplitPolicy',
+      'hello'             => 'world'
+    }
+    if org.apache.hadoop.hbase.HTableDescriptor.method_defined? :setDurability
+      table_props[:durability] = :async_wal
+    else
+      table_props[:deferred_log_flush] = true
+    end
+
     [
       'GZ',
       :gz,
-      org.apache.hadoop.hbase.io.hfile.Compression::Algorithm::GZ
+      gz
     ].each do |cmp|
       @table.create!({
           :cf => {
@@ -184,14 +207,9 @@ class TestTableAdmin < TestHBaseJRubyBase
             :replication_scope   => 0,
             :ttl                 => 100,
             :versions            => 10,
+            'whatever'           => 'works',
           }
-        },
-        :max_filesize       => 512 * 1024 ** 2,
-        :memstore_flushsize => 64 * 1024 ** 2,
-        :readonly           => false,
-        :deferred_log_flush => true,
-        :splits             => [10, 20, 30, 40]
-      )
+        }, table_props)
 
       # Initial region count
       regions = @table.regions
@@ -199,16 +217,23 @@ class TestTableAdmin < TestHBaseJRubyBase
 
       # Table properties
       props = @table.properties
-      assert_equal true,            props[:deferred_log_flush]
+      assert props[:deferred_log_flush] || props[:durability] == 'ASYNC_WAL'
       assert_equal false,           props[:readonly]
       assert_equal 64 * 1024 ** 2,  props[:memstore_flushsize]
       assert_equal 512 * 1024 ** 2, props[:max_filesize]
+      assert_equal 'world',         props['hello']
+      assert_equal 'org.apache.hadoop.hbase.regionserver.IncreasingToUpperBoundRegionSplitPolicy',
+                                    props[:split_policy]
 
       rprops = @table.raw_properties
-      assert_equal true.to_s,              rprops['DEFERRED_LOG_FLUSH']
+      assert rprops['DEFERRED_LOG_FLUSH'] == 'true' || rprops['DURABILITY'] == 'ASYNC_WAL'
+
       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 'world',                rprops['hello']
+      assert_equal 'org.apache.hadoop.hbase.regionserver.IncreasingToUpperBoundRegionSplitPolicy',
+                                           rprops['SPLIT_POLICY']
 
       # Column family properties
       cf = @table.families['cf']
@@ -221,6 +246,7 @@ class TestTableAdmin < TestHBaseJRubyBase
       assert_equal 131072, cf[:blocksize]
       assert_equal true,   cf[:in_memory]
       assert_equal true,   cf[:blockcache]
+      assert_equal 'works', cf['whatever']
 
       rcf = @table.raw_families['cf']
       assert_equal 'ROW',       rcf['BLOOMFILTER']
@@ -232,27 +258,16 @@ class TestTableAdmin < TestHBaseJRubyBase
       assert_equal 131072.to_s, rcf['BLOCKSIZE']
       assert_equal true.to_s,   rcf['IN_MEMORY']
       assert_equal true.to_s,   rcf['BLOCKCACHE']
+      assert_equal 'works',     rcf['whatever']
 
       @table.put 31, 'cf:a' => 100
       @table.put 37, 'cf:a' => 100
       @table.split!(35)
-
-      # FIXME
-      10.times do |i|
-        break if @table.regions.count == 6
-        sleep 1
-        assert false, "Region not split" if i == 9
-      end
+      wait_for_regions 6
 
       @table.put 39, 'cf:a' => 100
       @table.split!(38)
-
-      # FIXME
-      10.times do |i|
-        break if @table.regions.count == 7
-        sleep 1
-        assert false, "Region not split" if i == 9
-      end
+      wait_for_regions 7
 
       regions = @table.regions
       assert_equal [10, 20, 30, 35, 38, 40], regions.map { |r| HBase::Util.from_bytes :fixnum, r[:start_key] }.compact.sort
@@ -293,5 +308,17 @@ class TestTableAdmin < TestHBaseJRubyBase
   rescue Exception
     # TODO: Only works on HBase 0.94 or above
   end
+
+private
+  def wait_for_regions rnum, max_tries = 30
+    sleep 5
+    max_tries.times do |i|
+      if @table.regions.count == rnum && @table.regions.all? { |r| r[:online] }
+        return
+      end
+      sleep 1
+    end
+    assert false, "Region not split"
+  end
 end unless ENV['HBASE_JRUBY_TEST_SKIP_ADMIN']
 

data/test/test_util.rb

@@ -49,6 +49,10 @@ class TestUtil < Test::Unit::TestCase
 
     assert_equal 0, Util.to_bytes(nil).length
 
+    byte_array = Util.from_bytes :byte_array, "1234".to_java_bytes
+    assert_instance_of HBase::ByteArray, byte_array
+    assert_equal "1234", byte_array.as(:string)
+
     assert_raise(ArgumentError) { Util.from_bytes(:xxx, [].to_java(Java::byte)) }
     assert_raise(ArgumentError) { Util.to_bytes({}) }
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hbase-jruby
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-01-20 00:00:00.000000000 Z
+date: 2014-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit