hbase-jruby 0.2.4-java → 0.2.5-java

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 Changelog
 =========
 
+0.2.5
+-----
+- Added `HBase::Table#snapshots` method
+- Added `HBase::Table#snapshot!` method
+- Added `HBase#snapshots` method
+- Added `HBase::Cell#{raw,int,short,byte}` methods
+- Updated dependency profiles: cdh4.2.1, cdh4.1.4
+
 0.2.4
 -----
 - Fixed NameError when HBase::ByteArray is used without first creating an HBase instance

data/README.md

@@ -147,14 +147,9 @@ table = hbase.table(:test_table)
 table = hbase[:test_table]
 ```
 
-
-## Basic table administration
-
 ### Creating a table
 
 ```ruby
-table = hbase[:my_table]
-
 # Drop table if exists
 table.drop! if table.exists?
 
@@ -163,80 +158,6 @@ table.create! :cf1 => {},
               :cf2 => { :compression => :snappy, :bloomfilter => :row }
 ```
 
-### Table inspection
-
-```ruby
-# Table properties
-table.properties
-  # {:max_filesize       => 2147483648,
-  #  :readonly           => false,
-  #  :memstore_flushsize => 134217728,
-  #  :deferred_log_flush => false}
-
-# Properties of the column families
-table.families
-  # {"cf"=>
-  #   {:blockcache            => true,
-  #    :blocksize             => 65536,
-  #    :bloomfilter           => "NONE",
-  #    :cache_blooms_on_write => false,
-  #    :cache_data_on_write   => false,
-  #    :cache_index_on_write  => false,
-  #    :compression           => "NONE",
-  #    :compression_compact   => "NONE",
-  #    :data_block_encoding   => "NONE",
-  #    :evict_blocks_on_close => false,
-  #    :in_memory             => false,
-  #    :keep_deleted_cells    => false,
-  #    :min_versions          => 0,
-  #    :replication_scope     => 0,
-  #    :ttl                   => 2147483647,
-  #    :versions              => 3}}
-```
-
-There are also `raw_` variants of `properties` and `families`.
-They return properties in their internal String format (mainly used in HBase shell).
-(See [HTableDescriptor.values](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HTableDescriptor.html#values) and
-[HColumnDescriptor.values](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HColumnDescriptor.html#values))
-
-```ruby
-table.raw_properties
-  # {"IS_ROOT"      => "false",
-  #  "IS_META"      => "false",
-  #  "MAX_FILESIZE" => "2147483648"}
-
-table.raw_families
-  # {"cf" =>
-  #   {"DATA_BLOCK_ENCODING" => "NONE",
-  #    "BLOOMFILTER"         => "NONE",
-  #    "REPLICATION_SCOPE"   => "0",
-  #    "VERSIONS"            => "3",
-  #    "COMPRESSION"         => "NONE",
-  #    "MIN_VERSIONS"        => "0",
-  #    "TTL"                 => "2147483647",
-  #    "KEEP_DELETED_CELLS"  => "false",
-  #    "BLOCKSIZE"           => "65536",
-  #    "IN_MEMORY"           => "false",
-  #    "ENCODE_ON_DISK"      => "true",
-  #    "BLOCKCACHE"          => "true"}}
-```
-
-These String key-value pairs are not really a part of the public API of HBase, and thus might change over time.
-However, they are most useful when you need to create a table with the same properties as the existing one.
-
-```ruby
-hbase[:dupe_table].create!(table.raw_families, table.raw_properties)
-```
-
-With `regions` method, you can even presplit the new table just like the old one.
-
-```ruby
-hbase[:dupe_table].create!(
-  table.raw_families,
-  table.raw_properties.merge(
-    :splits => table.regions.map { |r| r[:start_key] }.compact))
-```
-
 ## Basic operations
 
 ### PUT
@@ -329,13 +250,16 @@ row.each do |cell|
   timestamp = cell.timestamp
 
   # Cell value as Java byte array
-  bytes     = cell.bytes
+  bytes     = cell.raw
 
   # Typed access
   # value_as_string = cell.string
   # value_as_fixnum = cell.fixnum
   # ...
 end
+
+# Array of HBase::Cells
+cells = row.to_a
 ```
 
 #### `to_hash`
@@ -697,130 +621,88 @@ For other data types, you can pass your own ColumnInterpreter.
 table.project('cf1:b').aggregate(:sum, MyColumnInterpreter.new)
 ```
 
-## Advanced topics
-
-### Lexicographic scan order
-
-HBase stores rows in the lexicographic order of the rowkeys in their byte array representations.
-Thus the type of row key affects the scan order.
-
-```ruby
-(1..15).times do |i|
-  table.put i, data
-  table.put i.to_s, data
-end
-
-table.range(1..3).map { |r| r.rowkey :fixnum }
-  # [1, 2, 3]
-table.range('1'..'3').map { |r| r.rowkey :string }
-  # %w[1 10 11 12 13 14 15 2 3]
-```
-
-### Non-string column qualifier
-
-If a column qualifier is not a String, *an HBase::ColumnKey instance* should be used
-instead of a conventional `FAMILY:QUALIFIER` String.
-
-```ruby
-table.put 'rowkey',
-  'cf1:col1'                    => 'Hello world',
-  HBase::ColumnKey(:cf1, 100)   => "Byte representation of an 8-byte integer",
-  HBase::ColumnKey(:cf1, bytes) => "Qualifier is an arbitrary byte array"
-
-table.get('rowkey').string('cf1:col1')
-table.get('rowkey').string(HBase::ColumnKey(:cf1, 100))
-# ...
-```
-
-### Shorter integers
-
-A Ruby Fixnum is an 8-byte integer, which is equivalent `long` type in Java.
-When you want to use shorter integer types such as int, short, or byte,
-you can then use the special Hash representation of integers.
-
-```ruby
-# 4-byte int value as the rowkey
-table.put({ int: 12345 }, 'cf1:a' => { byte: 100 },   # 1-byte integer
-                          'cf1:b' => { short: 200 },  # 2-byte integer
-                          'cf1:c' => { int: 300 },    # 4-byte integer
-                          'cf1:4' => 400)             # Ordinary 8-byte integer
-
-result = table.get(int: 12345)
-
-result.byte('cf1:a')   # 100
-result.short('cf1:b')  # 200
-result.int('cf1:c')    # 300
-# ...
-```
-
-### Working with byte arrays
-
-In HBase, virtually everything is stored as a byte array.
-Although *hbase-jruby* tries hard to hide the fact,
-at some point you may need to get your hands dirty with native Java byte arrays.
-For example, it's [a common practice] [1] to use a composite row key,
-which is a concatenation of several components of different types.
-
-  [1]: http://blog.sematext.com/2012/08/09/consider-using-fuzzyrowfilter-when-in-need-for-secondary-indexes-in-hbase/
-
-`HBase::ByteArray` is a boxed class for native Java byte arrays,
-which makes byte array manipulation much easier.
-
-A ByteArray can be created as a concatenation of any number of objects.
-
-```ruby
-ba = HBase::ByteArray(100, 3.14, {int: 300}, "Hello World")
-```
-
-Then you can slice it and decode each part,
+## Table inspection
 
 ```ruby
-# Slicing
-first  = ba[0, 8]
-second = ba[8...16]
+# Table properties
+table.properties
+  # {:max_filesize       => 2147483648,
+  #  :readonly           => false,
+  #  :memstore_flushsize => 134217728,
+  #  :deferred_log_flush => false}
 
-first.decode(:fixnum)  # 100
-second.decode(:float)  # 3.14
+# Properties of the column families
+table.families
+  # {"cf"=>
+  #   {:blockcache            => true,
+  #    :blocksize             => 65536,
+  #    :bloomfilter           => "NONE",
+  #    :cache_blooms_on_write => false,
+  #    :cache_data_on_write   => false,
+  #    :cache_index_on_write  => false,
+  #    :compression           => "NONE",
+  #    :compression_compact   => "NONE",
+  #    :data_block_encoding   => "NONE",
+  #    :evict_blocks_on_close => false,
+  #    :in_memory             => false,
+  #    :keep_deleted_cells    => false,
+  #    :min_versions          => 0,
+  #    :replication_scope     => 0,
+  #    :ttl                   => 2147483647,
+  #    :versions              => 3}}
 ```
 
-append, prepend more elements to it,
+There are also `raw_` variants of `properties` and `families`.
+They return properties in their internal String format (mainly used in HBase shell).
+(See [HTableDescriptor.values](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HTableDescriptor.html#values) and
+[HColumnDescriptor.values](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HColumnDescriptor.html#values))
 
 ```ruby
-ba.unshift 200, true
-ba << { short: 300 }
-```
-
-concatenate another ByteArray,
+table.raw_properties
+  # {"IS_ROOT"      => "false",
+  #  "IS_META"      => "false",
+  #  "MAX_FILESIZE" => "2147483648"}
 
-```ruby
-ba += HBase::ByteArray(1024)
+table.raw_families
+  # {"cf" =>
+  #   {"DATA_BLOCK_ENCODING" => "NONE",
+  #    "BLOOMFILTER"         => "NONE",
+  #    "REPLICATION_SCOPE"   => "0",
+  #    "VERSIONS"            => "3",
+  #    "COMPRESSION"         => "NONE",
+  #    "MIN_VERSIONS"        => "0",
+  #    "TTL"                 => "2147483647",
+  #    "KEEP_DELETED_CELLS"  => "false",
+  #    "BLOCKSIZE"           => "65536",
+  #    "IN_MEMORY"           => "false",
+  #    "ENCODE_ON_DISK"      => "true",
+  #    "BLOCKCACHE"          => "true"}}
 ```
 
-or shift decoded objects from it.
+These String key-value pairs are not really a part of the public API of HBase, and thus might change over time.
+However, they are most useful when you need to create a table with the same properties as the existing one.
 
 ```ruby
-ba.shift(:fixnum)
-ba.shift(:boolean)
-ba.shift(:fixnum)
-ba.shift(:float)
-ba.shift(:int)
-ba.shift(:string, 11)  # Byte length must be given as Strings are not fixed in size
+hbase[:dupe_table].create!(table.raw_families, table.raw_properties)
 ```
 
-`ByteArray#java` method returns the underlying native Java byte array.
+With `regions` method, you can even presplit the new table just like the old one.
 
 ```ruby
-ba.java  # Returns the native Java byte array (byte[])
+hbase[:dupe_table].create!(
+  table.raw_families,
+  table.raw_properties.merge(
+    :splits => table.regions.map { |r| r[:start_key] }.compact))
 ```
 
-### Table administration
+## Table administration
 
 `HBase#Table` provides a number of *bang_methods!* for table administration tasks.
 They run synchronously, except when mentioned otherwise (e.g. `HTable#split!`).
 Some of them take an optional block to allow progress monitoring
 and come with non-bang, asynchronous counterparts.
 
-#### Creation and alteration
+### Creation and alteration
 
 ```ruby
 # Create a table with configurable table-level properties
@@ -856,7 +738,7 @@ table.alter(
 )
 ```
 
-##### List of column family properties
+#### List of column family properties
 
 http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HColumnDescriptor.html
 
@@ -882,7 +764,7 @@ Some of the properties are only available on recent versions of HBase.
 | `:ttl`                   | Fixnum        | Time-to-live of cell contents, in seconds                                                                          |
 | `:versions`              | Fixnum        | The maximum number of versions. (By default, all available versions are retrieved.)                                |
 
-##### List of table properties
+#### List of table properties
 
 http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HTableDescriptor.html
 
@@ -894,7 +776,7 @@ http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/HTableDescriptor.html
 | `:deferred_log_flush` | Boolean | Defer the log edits syncing to the file system                                                          |
 | `:splits`             | Array   | Region split points                                                                                     |
 
-#### Managing column families
+### Managing column families
 
 ```ruby
 # Add column family
@@ -908,7 +790,7 @@ table.alter_family! :cf2, :bloomfilter => :rowcol
 table.delete_family! :cf1
 ```
 
-#### Coprocessors
+### Coprocessors
 
 ```ruby
 # Add Coprocessor
@@ -922,31 +804,165 @@ table.add_coprocessor! cp_class_name2,
 table.remove_coprocessor! cp_class_name1
 ```
 
-#### Region splits (asynchronous)
+### Region splits (asynchronous)
 
 ```ruby
 table.split!(1000)
 table.split!(2000, 3000)
 ```
 
-#### Advanced table administration
+### Snapshots
+
+```ruby
+# Returns a list of all snapshot information
+hbase.snapshots
+
+# Table snapshots
+table.snapshots
+# Equivalent to
+#   hbase.snapshots.select { |info| info[:table] == table.name }
+
+# Creating a snapshot
+table.snapshot! 'my_table_snapshot'
+```
+
+### Advanced table administration
 
 You can perform other types of administrative tasks
-with native Java [HBaseAdmin object](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/client/HBaseAdmin.html),
+with the native Java [HBaseAdmin object](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/client/HBaseAdmin.html),
 which can be obtained by `HBase#admin` method. Optionally, a block can be given
-so that the HBaseAdmin object is automatically closed at the end of the given block.
+so that the object is automatically closed at the end of the given block.
 
 ```ruby
 admin = hbase.admin
 # ...
 admin.close
 
-# With the block
+# Access native HBaseAdmin object within the block
 hbase.admin do |admin|
+  admin.snapshot       'my_snapshot', 'my_table'
+  admin.cloneSnapshot  'my_snapshot', 'my_clone_table'
+  admin.deleteSnapshot 'my_snapshot'
   # ...
 end
 ```
 
+## Advanced topics
+
+### Lexicographic scan order
+
+HBase stores rows in the lexicographic order of the rowkeys in their byte array representations.
+Thus the type of row key affects the scan order.
+
+```ruby
+(1..15).times do |i|
+  table.put i, data
+  table.put i.to_s, data
+end
+
+table.range(1..3).map { |r| r.rowkey :fixnum }
+  # [1, 2, 3]
+table.range('1'..'3').map { |r| r.rowkey :string }
+  # %w[1 10 11 12 13 14 15 2 3]
+```
+
+### Non-string column qualifier
+
+If a column qualifier is not a String, *an HBase::ColumnKey instance* should be used
+instead of a conventional `FAMILY:QUALIFIER` String.
+
+```ruby
+table.put 'rowkey',
+  'cf1:col1'                    => 'Hello world',
+  HBase::ColumnKey(:cf1, 100)   => "Byte representation of an 8-byte integer",
+  HBase::ColumnKey(:cf1, bytes) => "Qualifier is an arbitrary byte array"
+
+table.get('rowkey').string('cf1:col1')
+table.get('rowkey').string(HBase::ColumnKey(:cf1, 100))
+# ...
+```
+
+### Shorter integers
+
+A Ruby Fixnum is an 8-byte integer, which is equivalent `long` type in Java.
+When you want to use shorter integer types such as int, short, or byte,
+you can then use the special Hash representation of integers.
+
+```ruby
+# 4-byte int value as the rowkey
+table.put({ int: 12345 }, 'cf1:a' => { byte: 100 },   # 1-byte integer
+                          'cf1:b' => { short: 200 },  # 2-byte integer
+                          'cf1:c' => { int: 300 },    # 4-byte integer
+                          'cf1:4' => 400)             # Ordinary 8-byte integer
+
+result = table.get(int: 12345)
+
+result.byte('cf1:a')   # 100
+result.short('cf1:b')  # 200
+result.int('cf1:c')    # 300
+# ...
+```
+
+### Working with byte arrays
+
+In HBase, virtually everything is stored as a byte array.
+Although *hbase-jruby* tries hard to hide the fact,
+at some point you may need to get your hands dirty with native Java byte arrays.
+For example, it's [a common practice] [1] to use a composite row key,
+which is a concatenation of several components of different types.
+
+  [1]: http://blog.sematext.com/2012/08/09/consider-using-fuzzyrowfilter-when-in-need-for-secondary-indexes-in-hbase/
+
+`HBase::ByteArray` is a boxed class for native Java byte arrays,
+which makes byte array manipulation much easier.
+
+A ByteArray can be created as a concatenation of any number of objects.
+
+```ruby
+ba = HBase::ByteArray(100, 3.14, {int: 300}, "Hello World")
+```
+
+Then you can slice it and decode each part,
+
+```ruby
+# Slicing
+first  = ba[0, 8]
+second = ba[8...16]
+
+first.decode(:fixnum)  # 100
+second.decode(:float)  # 3.14
+```
+
+append, prepend more elements to it,
+
+```ruby
+ba.unshift 200, true
+ba << { short: 300 }
+```
+
+concatenate another ByteArray,
+
+```ruby
+ba += HBase::ByteArray(1024)
+```
+
+or shift decoded objects from it.
+
+```ruby
+ba.shift(:fixnum)
+ba.shift(:boolean)
+ba.shift(:fixnum)
+ba.shift(:float)
+ba.shift(:int)
+ba.shift(:string, 11)  # Byte length must be given as Strings are not fixed in size
+```
+
+`ByteArray#java` method returns the underlying native Java byte array.
+
+```ruby
+ba.java  # Returns the native Java byte array (byte[])
+```
+
 ## Test
 
 ```bash

data/lib/hbase-jruby/cell.rb

@@ -70,13 +70,31 @@ class Cell
   end
   alias sym symbol
 
-  # Returns the column value as a Fixnum
+  # Returns the 8-byte column value as a Fixnum
   # @return [Fixnum]
   def fixnum
     Util.from_bytes :fixnum, value
   end
   alias long fixnum
 
+  # Returns the 4-byte column value as a Fixnum
+  # @return [Fixnum]
+  def int
+    Util.from_bytes :int, value
+  end
+
+  # Returns the 2-byte column value as a Fixnum
+  # @return [Fixnum]
+  def short
+    Util.from_bytes :short, value
+  end
+
+  # Returns the 1-byte column value as a Fixnum
+  # @return [Fixnum]
+  def byte
+    Util.from_bytes :byte, value
+  end
+
   # Returns the column value as a BigDecimal
   # @return [BigDecimal]
   def bigdecimal

data/lib/hbase-jruby/dependency.rb

@@ -12,8 +12,8 @@ class HBase
   # https://ccp.cloudera.com/display/SUPPORT/CDH+Downloads
   SUPPORTED_PROFILES = {
     # Prefix => Latest known version
-    'cdh4.2' => 'cdh4.2.0',
-    'cdh4.1' => 'cdh4.1.3',
+    'cdh4.2' => 'cdh4.2.1',
+    'cdh4.1' => 'cdh4.1.4',
     'cdh3'   => 'cdh3u6',
     '0.95'   => '0.95.0',
     '0.94'   => '0.94.6.1',

data/lib/hbase-jruby/hbase.rb

@@ -127,6 +127,17 @@ class HBase
   end
   alias [] table
 
+  # Returns an Array of snapshot information
+  # @return [Array<Hash>]
+  def snapshots
+    with_admin { |admin| admin.listSnapshots }.map { |sd|
+      props = sd.getAllFields.map { |k, v|
+        [k.name.to_sym, v.respond_to?(:name) ? v.name : v]
+      }
+      Hash[props]
+    }
+  end
+
 private
   def check_closed
     raise RuntimeError, "Connection already closed" if closed?

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

@@ -4,7 +4,7 @@
 
   <groupId>hbase-jruby</groupId>
   <artifactId>hbase-project</artifactId>
-  <version>0.2.4</version>
+  <version><%= HBase::JRuby::VERSION %></version>
   <packaging>jar</packaging>
 
   <name>hbase-jruby</name>

data/lib/hbase-jruby/{result.rb → row.rb}

@@ -3,7 +3,7 @@ require 'bigdecimal'
 class HBase
 # Represents a row returned by HBase
 # @author Junegunn Choi <junegunn.c@gmail.com>
-class Result
+class Row
   include Enumerable
 
   # Returns the rowkey of the row
@@ -450,6 +450,9 @@ private
       end
     }
   end
-end#Result
+end#Row
 end#HBase
 
+# For backward compatibility
+HBase::Result = HBase::Row
+

data/lib/hbase-jruby/scoped.rb

@@ -24,7 +24,7 @@ class Scoped
       if block_given?
         scanner = htable.getScanner(filtered_scan)
         scanner.each do |result|
-          cnt += 1 if yield(Result.send(:new, result))
+          cnt += 1 if yield(Row.send(:new, result))
         end
       else
         scanner = htable.getScanner(filtered_scan_minimum)
@@ -41,29 +41,29 @@ class Scoped
   #   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]
+  #   @return [HBase::Row, 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>]
+  #   @return [Array<HBase::Row>]
   def get rowkeys
     check_closed
 
     case rowkeys
     when Array
       htable.get(rowkeys.map { |rk| getify rk }).map { |result|
-        result.isEmpty ? nil : Result.new(result)
+        result.isEmpty ? nil : Row.new(result)
       }
     else
       result = htable.get(getify rowkeys)
-      result.isEmpty ? nil : Result.new(result)
+      result.isEmpty ? nil : Row.new(result)
     end
   end
 
   # Iterate through the scope.
   # @yield [row] Yields each row in the scope
-  # @yieldparam [HBase::Result] row
+  # @yieldparam [HBase::Row] row
   def each
     check_closed
 
@@ -71,7 +71,7 @@ class Scoped
       begin
         scanner = htable.getScanner(filtered_scan)
         scanner.each do |result|
-          yield Result.send(:new, result)
+          yield Row.send(:new, result)
         end
       ensure
         scanner.close if scanner

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

@@ -240,6 +240,21 @@ class Table
     end
   end
 
+  # Creates a snapshot of the table
+  # @param [String] snapshot_name Snapshot name
+  # @return [nil]
+  def snapshot! snapshot_name
+    with_admin do |admin|
+      admin.snapshot snapshot_name, @name
+    end
+  end
+
+  # Returns an Array of snapshot information for this table
+  # @return [Array<Hash>]
+  def snapshots
+    @hbase.snapshots.select { |h| h[:table] == @name }
+  end
+
 private
   COLUMN_PROPERTIES = {
     :blockcache            => { :set => :setBlockCacheEnabled,         :get => :isBlockCacheEnabled },

data/lib/hbase-jruby/table.rb

@@ -183,7 +183,7 @@ class Table
 
   # Scan through the table
   # @yield [row] Yields each row in the scope
-  # @yieldparam [HBase::Result] row
+  # @yieldparam [HBase::Row] row
   # @return [HBase::Scoped]
   def each
     check_closed

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end
 end

data/lib/hbase-jruby.rb

@@ -14,7 +14,7 @@ require "hbase-jruby/scoped"
 require "hbase-jruby/table"
 require "hbase-jruby/table/admin"
 require "hbase-jruby/table/inspection"
-require "hbase-jruby/result"
+require "hbase-jruby/row"
 require 'hbase-jruby/hbase'
 
 HBase.import_java_classes!

data/test/test_cell.rb

@@ -11,13 +11,16 @@ class TestCell < Test::Unit::TestCase
   def test_cell
     ts = Time.now.to_i * 1000
     {
-      'value'                        => :string,
-      :value                         => :symbol,
-      123                            => :fixnum,
-      123.456                        => :float,
-      true                           => :boolean,
-      false                          => :boolean,
-      BigDecimal.new("123.456")      => :bigdecimal
+      'value'                   => :string,
+      :value                    => :symbol,
+      123                       => :fixnum,
+      123.456                   => :float,
+      true                      => :boolean,
+      false                     => :boolean,
+      BigDecimal.new("123.456") => :bigdecimal,
+      { :int   => 10240 }       => :int,
+      { :short => 1024 }        => :short,
+      { :byte  => 100 }         => :byte
     }.each do |value, type|
       kv = KeyValue.new("rowkey".to_java_bytes, "hello".to_java_bytes, "world".to_java_bytes, ts, Util.to_bytes(value))
       cell = HBase::Cell.new(kv)
@@ -26,7 +29,12 @@ class TestCell < Test::Unit::TestCase
       assert_equal "hello",  cell.cf, cell.family
       assert_equal "world",  cell.cq, cell.qualifier
       assert_equal ts,       cell.ts
-      assert_equal value,    cell.send(type)
+      if value.is_a?(Hash)
+        assert_equal value.values.first, cell.send(type)
+      else
+        assert_equal value, cell.send(type)
+      end
+      assert HBase::Util.java_bytes?(cell.raw)
       assert_equal HBase::ColumnKey.new(:hello, :world), cell.column_key
       assert_instance_of String, cell.inspect
     end

data/test/test_table_admin.rb

@@ -259,5 +259,37 @@ class TestTableAdmin < TestHBaseJRubyBase
       @table.drop!
     end
   end
+
+  def test_snapshots
+    @hbase.admin do |admin|
+      @hbase.snapshots.map { |e| e[:name] }.each do |name|
+        admin.deleteSnapshot name
+      end
+    end
+
+    assert_equal 0, @hbase.snapshots.length
+    assert_equal 0, @table.snapshots.length
+
+    @table.snapshot! 'hbase_jruby_test_snapshot1'
+    @table.snapshot! 'hbase_jruby_test_snapshot2'
+
+    assert_equal 2, @hbase.snapshots.length
+    assert_equal 2, @table.snapshots.length # FIXME: table-wise snapshots
+
+    @hbase.snapshots.each do |snapshot|
+      assert_equal @table.name, snapshot[:table]
+      assert_match /hbase_jruby_test_snapshot[12]/, snapshot[:name]
+    end
+
+    @hbase.admin do |admin|
+      admin.deleteSnapshot 'hbase_jruby_test_snapshot1'
+      admin.deleteSnapshot 'hbase_jruby_test_snapshot2'
+    end
+
+    assert_equal 0, @hbase.snapshots.length
+    assert_equal 0, @table.snapshots.length
+  rescue Exception
+    # TODO: Only works on HBase 0.94 or above
+  end
 end unless ENV['HBASE_JRUBY_TEST_SKIP_ADMIN']
 

metadata

@@ -2,14 +2,14 @@
 name: hbase-jruby
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.2.4
+  version: 0.2.5
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-04-09 00:00:00.000000000 Z
+date: 2013-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -69,7 +69,7 @@ files:
 - lib/hbase-jruby/dependency.rb
 - lib/hbase-jruby/hbase.rb
 - lib/hbase-jruby/pom/pom.xml.erb
-- lib/hbase-jruby/result.rb
+- lib/hbase-jruby/row.rb
 - lib/hbase-jruby/scoped.rb
 - lib/hbase-jruby/scoped/aggregation.rb
 - lib/hbase-jruby/table.rb