hbase-jruby 0.1.4-java → 0.1.5-java

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+0.1.5
+-----
+- Added support for shorter integers
+- Extended `HBase::ByteArray` for easy manipulation of Java byte arrays
+
 0.1.4
 -----
 - Fix: Start/stop row not correctly set when byte array rowkey range specified

data/README.md

@@ -65,9 +65,9 @@ Apache Maven is the de facto standard dependency management mechanism for Java p
 Current version of *hbase-jruby* is shipped with Maven dependency specifications
 for the following Hadoop/HBase distributions.
 
-* cdh4.1.2
+* [cdh4.1.2](https://github.com/junegunn/hbase-jruby/blob/master/lib/hbase-jruby/pom/cdh4.1.2.xml)
     * Recommended as of now
-* cdh3u5
+* [cdh3u5](https://github.com/junegunn/hbase-jruby/blob/master/lib/hbase-jruby/pom/cdh3u5.xml)
     * Does not support some features
 
 ```ruby
@@ -635,6 +635,87 @@ 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[])
+```
+
 ### Table administration
 
 `HBase#Table` provides a few *synchronous* table administration methods.

data/lib/hbase-jruby.rb

@@ -15,3 +15,4 @@ require "hbase-jruby/table"
 require "hbase-jruby/result"
 require 'hbase-jruby/hbase'
 
+HBase.import_java_classes!

data/lib/hbase-jruby/byte_array.rb

@@ -1,20 +1,36 @@
 class HBase
 class << self
   # Shortcut method to HBase::ByteArray.new
-  # @param [Object] value
-  def ByteArray value
-    ByteArray.new value
+  # @param [*Object] values
+  def ByteArray *values
+    ByteArray.new *values
   end
 end
 # Boxed class for Java byte arrays
 # @!attribute [r] java
-#   @return [byte[]] Java byte array
+#   @return [byte[]] The underlying native Java byte array
 class ByteArray
   attr_reader :java
+  alias to_java java
+  alias to_java_bytes java
 
-  # @param [Object] value
-  def initialize value
-    @java = Util.to_bytes value
+  include Enumerable
+
+  # Initializes ByteArray instance with the given objects,
+  # each converted to its byte array representation
+  # @param [*Object] values
+  def initialize *values
+    @java = values.inject(Util::JAVA_BYTE_ARRAY_EMPTY) { |sum, value|
+      Bytes.add sum, Util.to_bytes(value)
+    }
+  end
+
+  def each
+    if block_given?
+      @java.to_a.each { |byte| yield byte }
+    else
+      self
+    end
   end
 
   # Checks if the two byte arrays are the same
@@ -31,15 +47,77 @@ class ByteArray
   end
 
   # Concats two byte arrays
-  # @param [HBase::ByteArray] other
+  # @param [Object] other
   def + other
-    ByteArray.new(Bytes.add @java, other.java)
+    ByteArray.new(@java, other)
   end
 
-  # Returns the Java byte array
-  # @return [byte[]]
-  def to_java_bytes
-    @java
+  # Appends the byte array of the given object on to the end
+  # @param [Object] other
+  # @return [ByteArray] Modified self
+  def << other
+    @java = Bytes.add @java, Util.to_bytes(other)
+    self
+  end
+
+  # Prepends the byte array of the given object to the front
+  # @param [*Object] args Objects to prepend
+  # @return [ByteArray] Modified self
+  def unshift *args
+    @java = (ByteArray.new(*args) + self).java
+    self
+  end
+
+  # Returns the length of the byte array
+  # @return [Fixnum]
+  def length
+    @java.length
+  end
+
+  # Slices the byte array
+  # @param [Object] index
+  # @return [ByteArray]
+  def [] *index
+    if index.length == 1 && index.first.is_a?(Fixnum)
+      @java.to_a[*index]
+    else
+      ByteArray.new(@java.to_a[*index].to_java(Java::byte))
+    end
+  end
+
+  # @param [Symbol] type
+  # @return [Object]
+  def decode type
+    Util.from_bytes type, @java
+  end
+
+  # Returns the first element decoded as the given type
+  # and removes the portion from the byte array.
+  # For types of variable lengths, such as :string and :bigdecimal, byte size must be given.
+  # @param [Symbol] type
+  # @return [Object]
+  def shift type, length = nil
+    length =
+      case type
+      when :fixnum, :long, :float, :double
+        8
+      when :int
+        4
+      when :short
+        2
+      when :boolean, :bool, :byte
+        1
+      else
+        length
+      end
+    raise ArgumentError.new("Byte length must be specified for type: #{type}") unless length
+    raise ArgumentError.new("Not enought bytes for #{type}") if length > @java.length
+
+    arr   = @java.to_a
+    val   = arr[0, length].to_java(Java::byte)
+    @java = arr[length..-1].to_java(Java::byte)
+
+    Util.from_bytes type, val
   end
 
   # Returns the first byte array whose prefix doesn't match this byte array

data/lib/hbase-jruby/cell.rb

@@ -14,7 +14,7 @@ class Cell
 
   # Returns the rowkey of the cell decoded as the given type
   # @param [Symbol] type The type of the rowkey.
-  #   Can be one of :string, :symbol, :fixnum, :float, :bigdecimal, :boolean and :raw.
+  #   Can be one of :string, :symbol, :fixnum, :float, :short, :int, :bigdecimal, :boolean and :raw.
   # @return [String, byte[]]
   def rowkey type = :string
     Util.from_bytes type, @java.getRow
@@ -35,7 +35,7 @@ class Cell
 
   # Returns the column qualifier of the cell
   # @param [Symbol] type The type of the qualifier.
-  #   Can be one of :string, :symbol, :fixnum, :float, :bigdecimal, :boolean and :raw.
+  #   Can be one of :string, :symbol, :fixnum, :float, :short, :int, :bigdecimal, :boolean and :raw.
   # @return [Object]
   def qualifier type = :string
     Util.from_bytes type, @java.getQualifier
@@ -75,8 +75,7 @@ class Cell
   def fixnum
     Util.from_bytes :fixnum, value
   end
-  alias integer fixnum
-  alias int     fixnum
+  alias long fixnum
 
   # Returns the column value as a BigDecimal
   # @return [BigDecimal]

data/lib/hbase-jruby/dependency.rb

@@ -40,7 +40,7 @@ class HBase
                 f << xml
               end
             rescue OpenURI::HTTPError => e
-              # No such distribution anywhere
+              # No such distribution anywhere. Leave path to be nil.
             end
           end
 
@@ -57,15 +57,105 @@ class HBase
         end
 
       # Load jars
-      jars_loaded = jars.select { |jar| File.exists?(jar) && File.extname(jar) == '.jar' }.select do |jar|
-        require jar
-      end
+      jars_loaded = jars.select { |jar|
+        File.exists?(jar) &&
+        File.extname(jar) == '.jar' &&
+        require(jar)
+      }
 
-      Util.import_java_classes!
+      # Try importing Java classes again
+      not_found = HBase.import_java_classes!
+      if verbose && !not_found.empty?
+        warn "Java classes not found: #{not_found.join(', ')}"
+      end
 
       return jars_loaded
     ensure
       tempfiles.each { |tempfile| tempfile.unlink rescue nil }
     end
-  end
+
+    # Import Java classes (Prerequisite for classes in hbase-jruby)
+    # @return [Array<String>] List of Java classes not found
+    def import_java_classes!
+      imp = lambda { |hash|
+        hash.map { |base, classes|
+          base.class_eval do
+            classes.map { |klass|
+              begin
+                import klass
+                nil
+              rescue NameError => e
+                klass
+              end
+            }.compact
+          end
+        }.flatten
+      }
+
+      imp.call(
+        HBase => %w[
+          org.apache.hadoop.hbase.HBaseConfiguration
+          org.apache.hadoop.hbase.client.HBaseAdmin
+          org.apache.hadoop.hbase.client.HConnectionManager
+          org.apache.hadoop.hbase.client.HTablePool
+        ],
+        HBase::Util => %w[
+          java.nio.ByteBuffer
+          org.apache.hadoop.hbase.KeyValue
+          org.apache.hadoop.hbase.util.Bytes
+        ],
+        HBase::ByteArray => %w[
+          java.util.Arrays
+          org.apache.hadoop.hbase.util.Bytes
+        ],
+        HBase::Cell => %w[
+          org.apache.hadoop.hbase.KeyValue
+        ],
+        HBase::Result => %w[
+          org.apache.hadoop.hbase.util.Bytes
+        ],
+        HBase::ColumnKey => %w[
+          java.util.Arrays
+          org.apache.hadoop.hbase.util.Bytes
+        ],
+        HBase::Table => %w[
+          org.apache.hadoop.hbase.HColumnDescriptor
+          org.apache.hadoop.hbase.HTableDescriptor
+          org.apache.hadoop.hbase.client.Delete
+          org.apache.hadoop.hbase.client.Increment
+          org.apache.hadoop.hbase.client.Put
+          org.apache.hadoop.hbase.io.hfile.Compression
+          org.apache.hadoop.hbase.regionserver.StoreFile
+        ],
+        HBase::Scoped => %w[
+          org.apache.hadoop.hbase.client.Get
+          org.apache.hadoop.hbase.client.Scan
+          org.apache.hadoop.hbase.filter.BinaryComparator
+          org.apache.hadoop.hbase.filter.ColumnPaginationFilter
+          org.apache.hadoop.hbase.filter.ColumnRangeFilter
+          org.apache.hadoop.hbase.filter.CompareFilter
+          org.apache.hadoop.hbase.filter.FilterBase
+          org.apache.hadoop.hbase.filter.FilterList
+          org.apache.hadoop.hbase.filter.KeyOnlyFilter
+          org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter
+          org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter
+          org.apache.hadoop.hbase.filter.PrefixFilter
+          org.apache.hadoop.hbase.filter.RegexStringComparator
+          org.apache.hadoop.hbase.filter.RowFilter
+          org.apache.hadoop.hbase.filter.SingleColumnValueFilter
+          org.apache.hadoop.hbase.filter.WhileMatchFilter
+          org.apache.hadoop.hbase.client.coprocessor.AggregationClient
+          org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter
+        ]).tap { |not_found|
+
+        if not_found.empty?
+          self.instance_eval do
+            def import_java_classes!
+              []
+            end
+          end
+        end
+      }
+    end
+  end#class << self
 end

data/lib/hbase-jruby/hbase.rb

@@ -11,7 +11,7 @@ class HBase
   # Connects to HBase
   # @param [Hash] config A key-value pairs to build HBaseConfiguration from
   def initialize config = {}
-    Util.import_java_classes!
+    HBase.import_java_classes!
 
     @config =
       case config

data/lib/hbase-jruby/result.rb

@@ -8,7 +8,7 @@ class Result
 
   # Returns the rowkey of the row
   # @param [Symbol] type The type of the rowkey
-  #   Can be one of :string, :symbol, :fixnum, :float, :bigdecimal, :boolean and :raw.
+  #   Can be one of :string, :symbol, :fixnum, :float, :short, :int, :bigdecimal, :boolean and :raw.
   # @return [String, byte[]]
   def rowkey type = :string
     Util.from_bytes type, @result.getRow
@@ -168,37 +168,119 @@ class Result
   end
   alias syms symbols
 
-  # Returns column values as Fixnums
-  # @overload fixnum(column)
+  # Returns 1-byte column values as Fixnums
+  # @overload byte(column)
   #   Returns the latest column value as a Fixnum
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Fixnum]
+  # @overload byte(columns)
+  #   For each column specified,
+  #   returns the latest 1-byte column values as a Fixnum
+  #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
+  #   @return [Array<Fixnum>]
+  def byte cols
+    decode_values :byte, cols
+  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, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
+  #   @return [Hash<Fixnum, Fixnum>]
+  # @overload bytes(columns)
+  #   For each column specified,
+  #   returns all versions of 1-byte column values as Fixnums in a Hash indexed by their timestamps
+  #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
+  #   @return [Array<Hash<Fixnum, Fixnum>>]
+  def bytes cols
+    decode_values :byte, cols, true
+  end
+
+  # Returns 2-byte column values as Fixnums
+  # @overload short(column)
+  #   Returns the latest 2-byte column value as a Fixnum
+  #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
+  #   @return [Fixnum]
+  # @overload short(columns)
+  #   For each column specified,
+  #   returns the latest 2-byte column values as a Fixnum
+  #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
+  #   @return [Array<Fixnum>]
+  def short cols
+    decode_values :short, cols
+  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, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
+  #   @return [Hash<Fixnum, Fixnum>]
+  # @overload shorts(columns)
+  #   For each column specified,
+  #   returns all versions of 2-byte column values as Fixnums in a Hash indexed by their timestamps
+  #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
+  #   @return [Array<Hash<Fixnum, Fixnum>>]
+  def shorts cols
+    decode_values :short, cols, true
+  end
+
+  # Returns 4-byte column values as Fixnums
+  # @overload int(column)
+  #   Returns the latest 4-byte column value as a Fixnum
+  #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
+  #   @return [Fixnum]
+  # @overload int(columns)
+  #   For each column specified,
+  #   returns the latest 4-byte column values as a Fixnum
+  #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
+  #   @return [Array<Fixnum>]
+  def int cols
+    decode_values :int, cols
+  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, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
+  #   @return [Hash<Fixnum, Fixnum>]
+  # @overload ints(columns)
+  #   For each column specified,
+  #   returns all versions of 4-byte column values as Fixnums in a Hash indexed by their timestamps
+  #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
+  #   @return [Array<Hash<Fixnum, Fixnum>>]
+  def ints cols
+    decode_values :int, cols, true
+  end
+
+  # Returns 8-byte column values as Fixnums
+  # @overload fixnum(column)
+  #   Returns the latest 8-byte column value as a Fixnum
+  #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
+  #   @return [Fixnum]
   # @overload fixnum(columns)
   #   For each column specified,
-  #   returns the latest column values as a Fixnum
+  #   returns the latest 8-byte column values as a Fixnum
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<Fixnum>]
   def fixnum cols
     decode_values :fixnum, cols
   end
-  alias integer fixnum
-  alias int     fixnum
+  alias long fixnum
 
-  # Returns all versions of column values as Fixnums in a Hash indexed by their timestamps
+  # Returns all versions of 8-byte column values as Fixnums in a Hash indexed by their timestamps
   # @overload fixnums(column)
-  #   Returns all versions of column values as Fixnums in a Hash indexed by their timestamps
+  #   Returns all versions of 8-byte column values as Fixnums in a Hash indexed by their timestamps
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, Fixnum>]
   # @overload fixnums(columns)
   #   For each column specified,
-  #   returns all versions of column values as Fixnums in a Hash indexed by their timestamps
+  #   returns all versions of 8-byte column values as Fixnums in a Hash indexed by their timestamps
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<Hash<Fixnum, Fixnum>>]
   def fixnums cols
     decode_values :fixnum, cols, true
   end
-  alias integers fixnums
-  alias ints     fixnums
+  alias longs fixnums
 
   # Returns column values as Bigdecimals
   # @overload bigdecimal(column)

data/lib/hbase-jruby/scoped/aggregation.rb

@@ -34,7 +34,7 @@ private
 
   def column_interpreter_for type
     case type
-    when :fixnum, :int, :integer
+    when :fixnum, :long
       LongColumnInterpreter.new
     when org.apache.hadoop.hbase.coprocessor.ColumnInterpreter
       type

data/lib/hbase-jruby/table.rb

@@ -421,8 +421,15 @@ private
         cf, cq = Util.parse_column_name(col)
         case val
         when Hash
-          val.each do |ts, v|
-            put.add cf, cq, ts, Util.to_bytes(v)
+          val.each do |t, v|
+            case t
+            # Timestamp
+            when Fixnum
+              put.add cf, cq, t, Util.to_bytes(v)
+            # Types: :byte, :short, :int, ...
+            else
+              put.add cf, cq, Util.to_bytes(t => v)
+            end
           end
         else
           put.add cf, cq, Util.to_bytes(val)

data/lib/hbase-jruby/util.rb

@@ -33,6 +33,25 @@ module Util
         Bytes.java_send :toBytes, [java.math.BigDecimal], v.to_java
       when java.math.BigDecimal
         Bytes.java_send :toBytes, [java.math.BigDecimal], v
+      when Hash
+        len = v.length
+        raise ArgumentError, "Unknown value format" unless len == 1
+
+        val = v.values.first
+        raise ArgumentError, "Unknown value format" unless val.is_a?(Fixnum)
+
+        case v.keys.first
+        when :byte
+          [val].to_java(Java::byte)
+        when :int
+          Bytes.java_send :toBytes, [Java::int], val
+        when :short
+          Bytes.java_send :toBytes, [Java::short], val
+        when :long, :fixnum 
+          Bytes.java_send :toBytes, [Java::long], val
+        else
+          raise ArgumentError, "Invalid value format"
+        end
       else
         if java_bytes?(v)
           v
@@ -52,8 +71,14 @@ module Util
       case type
       when :string, :str
         Bytes.to_string val
-      when :fixnum, :int, :integer
+      when :fixnum, :long
         Bytes.to_long val
+      when :byte
+        val.first
+      when :int
+        Bytes.to_int val
+      when :short
+        Bytes.to_short val
       when :symbol, :sym
         Bytes.to_string(val).to_sym
       when :bigdecimal
@@ -97,89 +122,6 @@ module Util
         return cf, cq
       end
     end
-
-    # Import Java classes (Prerequisite for classes in hbase-jruby)
-    # @return [nil]
-    def import_java_classes!
-      imp = lambda { |base, classes|
-        base.class_eval do
-          classes.each do |klass|
-            begin
-              import klass
-            rescue NameError => e
-              warn e
-            end
-          end
-        end
-      }
-
-      @@imported ||= begin
-        imp.call HBase, %w[
-          org.apache.hadoop.hbase.HBaseConfiguration
-          org.apache.hadoop.hbase.client.HBaseAdmin
-          org.apache.hadoop.hbase.client.HTablePool
-          org.apache.hadoop.hbase.client.HConnectionManager
-        ]
-
-        imp.call HBase::Util, %w[
-          java.nio.ByteBuffer
-          org.apache.hadoop.hbase.util.Bytes
-          org.apache.hadoop.hbase.KeyValue
-        ]
-
-        imp.call HBase::ByteArray, %w[
-          java.util.Arrays
-          org.apache.hadoop.hbase.util.Bytes
-        ]
-
-        imp.call HBase::Cell, %w[
-          org.apache.hadoop.hbase.KeyValue
-        ]
-
-        imp.call HBase::Result, %w[
-          org.apache.hadoop.hbase.util.Bytes
-        ]
-
-        imp.call HBase::ColumnKey, %w[
-          java.util.Arrays
-          org.apache.hadoop.hbase.util.Bytes
-        ]
-
-        imp.call HBase::Table, %w[
-          org.apache.hadoop.hbase.HColumnDescriptor
-          org.apache.hadoop.hbase.HTableDescriptor
-          org.apache.hadoop.hbase.client.Delete
-          org.apache.hadoop.hbase.client.Increment
-          org.apache.hadoop.hbase.client.Put
-          org.apache.hadoop.hbase.io.hfile.Compression
-          org.apache.hadoop.hbase.regionserver.StoreFile
-          org.apache.hadoop.hbase.Coprocessor
-        ]
-
-        imp.call HBase::Scoped, %w[
-          org.apache.hadoop.hbase.client.Get
-          org.apache.hadoop.hbase.client.Scan
-          org.apache.hadoop.hbase.filter.BinaryComparator
-          org.apache.hadoop.hbase.filter.ColumnPaginationFilter
-          org.apache.hadoop.hbase.filter.ColumnRangeFilter
-          org.apache.hadoop.hbase.filter.CompareFilter
-          org.apache.hadoop.hbase.filter.FilterBase
-          org.apache.hadoop.hbase.filter.FilterList
-          org.apache.hadoop.hbase.filter.KeyOnlyFilter
-          org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter
-          org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter
-          org.apache.hadoop.hbase.filter.PrefixFilter
-          org.apache.hadoop.hbase.filter.RegexStringComparator
-          org.apache.hadoop.hbase.filter.RowFilter
-          org.apache.hadoop.hbase.filter.SingleColumnValueFilter
-          org.apache.hadoop.hbase.filter.WhileMatchFilter
-          org.apache.hadoop.hbase.client.coprocessor.AggregationClient
-          org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter
-        ]
-      end
-
-      nil
-    end
   end
 end#Util
 end#HBase

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end
 end

data/test/test_aggregation.rb

@@ -13,7 +13,7 @@ class TestAggregation < TestHBaseJRubyBase
     assert_nil @table.enable_aggregation! # no prob!
 
     lci = org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter.new
-    [nil, :fixnum, :int, :integer, lci].each do |ci|
+    [nil, :fixnum, :long, lci].each do |ci|
       assert_equal 100,  @table.project('cf1:a').aggregate(:row_count, *[*ci].compact)
       assert_equal 5050, @table.project('cf1:a').aggregate(:sum, *[*ci].compact)
       assert_equal 1,    @table.project('cf1:a').aggregate(:min, *[*ci].compact)

data/test/test_byte_array.rb

@@ -45,5 +45,101 @@ class TestByteArray < Test::Unit::TestCase
 
     assert_equal 100, HBase::Util.from_bytes( :fixnum, concat.to_java_bytes.to_a[0, 8].to_java(Java::byte) )
     assert_equal 200, HBase::Util.from_bytes( :fixnum, concat.java.to_a[8, 8].to_java(Java::byte) )
+
+    assert HBase::ByteArray(100, 200).eql?(concat)
+    assert concat.eql?(HBase::ByteArray(100) + 200)
+    assert concat.eql?(HBase::ByteArray(100) << 200)
+
+    ba = HBase::ByteArray(100)
+    ba += HBase::ByteArray(200)
+    assert_equal concat, ba
+  end
+
+  def test_default_constructor
+    assert_equal 0, HBase::ByteArray().java.to_a.length
+    assert_equal 0, HBase::ByteArray.new.java.to_a.length
+  end
+
+  def test_slice
+    ba = HBase::ByteArray(100, 200, "Hello", 3.14)
+
+    assert_equal 100, ba[0, 8].decode(:fixnum)
+    assert_equal 200, ba[8...16].decode(:fixnum)
+    assert_equal "Hello", ba[16, 5].decode(:string)
+    assert_equal 3.14, ba[21..-1].decode(:float)
+    assert_equal "H", ba[16].chr
+  end
+
+  def test_length_shift
+    ba = HBase::ByteArray(100, 200, "Hello", false, 3.14)
+
+    assert_equal 30, ba.length
+    assert_equal 100, ba.shift(:fixnum)
+    assert_equal 22, ba.length
+    assert_equal 200, ba.shift(:fixnum)
+    assert_equal 14, ba.length
+    assert_raise(ArgumentError) { ba.shift(:string) }
+    assert_equal "Hello", ba.shift(:string, 5)
+    assert_equal 9, ba.length
+    assert_equal false, ba.shift(:boolean)
+    assert_equal 8, ba.length
+    assert_equal 3.14, ba.shift(:float)
+    assert_equal 0, ba.length
+
+    assert_raise(ArgumentError) { ba.shift(:fixnum) }
+  end
+
+  def test_short_int
+    assert_equal 1,  HBase::ByteArray(:byte => 12).length
+    assert_equal 12, HBase::ByteArray(:byte => 12).decode(:byte)
+    assert_raise(RangeError) { HBase::ByteArray(:byte => 128) }
+
+    assert_equal 2,     HBase::ByteArray(:short => 12345).length
+    assert_equal 12345, HBase::ByteArray(:short => 12345).decode(:short)
+    assert_raise(RangeError) { HBase::ByteArray( :short => 1 << 16 ) }
+
+    assert_equal 4,     HBase::ByteArray(:int => 12345).length
+    assert_equal 12345, HBase::ByteArray(:int => 12345).decode(:int)
+    assert_raise(RangeError) { HBase::ByteArray.new( :int => 1 << 32 ) }
+
+    ba = HBase::ByteArray( {:int => 10000}, 20000, {:short => 30000}, "Hello" )
+    assert_equal 10000, ba[0, 4].decode(:int)
+    assert_equal 20000, ba[4, 8].decode(:long)
+    assert_equal 30000, ba[12, 2].decode(:short)
+    assert_equal "Hell", ba[14, 4].decode(:string)
+  end
+
+  def test_each
+    ba = HBase::ByteArray("Hello world")
+    Hash[ba.to_a.zip("Hello world".each_char.to_a)].each do |ord, chr|
+      assert_equal ord.chr, chr
+    end
+  end
+
+  def test_unshift
+    bd = BigDecimal.new("123456789012345678901234567890")
+    ba = HBase::ByteArray(bd)
+    oid = ba.object_id
+    assert_equal oid, ba.unshift(:short => 1000).object_id
+
+    ba.unshift("a", "b", "c")
+    assert_equal 'a', ba[0].chr
+    assert_equal 'b', ba[1].chr
+    assert_equal 'c', ba[2].chr
+    assert_equal 1000, ba[3, 2].decode(:short)
+    assert_equal bd, ba[5..-1].decode(:bigdecimal)
+  end
+
+  def test_append
+    ba = HBase::ByteArray()
+    oid = ba.object_id
+    assert_equal oid, (ba << 100).object_id
+
+    ba << 200 << {:int => 300} << "Hello" << 3.14
+    assert_equal 100, ba.shift(:fixnum)
+    assert_equal 200, ba.shift(:long)
+    assert_equal 300, ba.shift(:int)
+    assert_equal "Hello", ba.shift(:string, 5)
+    assert_equal 3.14, ba.shift(:float)
   end
 end

data/test/test_scoped.rb

@@ -181,7 +181,7 @@ class TestScoped < TestHBaseJRubyBase
       @table.put rk, 'cf1:a' => rk
     end
     assert_equal 9, @table.range(1..9).count
-    assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9], @table.range(1..9).map { |row| row.rowkey :integer }
+    assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9], @table.range(1..9).map { |row| row.rowkey :fixnum }
     assert_equal 8, @table.range(1...9).count
 
     @table.truncate!
@@ -201,17 +201,17 @@ class TestScoped < TestHBaseJRubyBase
       @table.put i.to_s, data
     end
 
-    assert_equal [1, 2, 3], @table.range(1..3).map { |r| r.rowkey :integer }
+    assert_equal [1, 2, 3], @table.range(1..3).map { |r| r.rowkey :fixnum }
     assert_equal %w[1 10 11 12 13 14 15 2 3], @table.range('1'..'3').map { |r| r.rowkey :string }
   end
 
   def test_non_string_column_name
     @table.put 'rowkey', Hash[ (1..20).map { |cq| [HBase::ColumnKey('cf1', cq), cq] } ]
 
-    assert((1..20).all? { |cq| @table.get('rowkey').integer(HBase::ColumnKey('cf1', cq)) == cq })
+    assert((1..20).all? { |cq| @table.get('rowkey').fixnum(HBase::ColumnKey('cf1', cq)) == cq })
 
     assert @table.project(['cf1', 10], ['cf1', 20]).map { |r|
-      [r.integer(HBase::ColumnKey('cf1', 10)), r.integer(HBase::ColumnKey.new('cf1', 20))]
+      [r.fixnum(HBase::ColumnKey('cf1', 10)), r.fixnum(HBase::ColumnKey.new('cf1', 20))]
     }.all? { |e| e == [10, 20] }
 
     hash = @table.get('rowkey').to_hash(

data/test/test_table.rb

@@ -32,6 +32,9 @@ class TestScoped < TestHBaseJRubyBase
                                'cf1:d' => false,
                                'cf1:f' => :bol,
                                'cf1:g' => BigDecimal.new("456.123"),
+                               'cf1:byte'  => { :byte => 100 },
+                               'cf1:short' => { :short => 200 },
+                               'cf1:int'   => { :int => 300 },
                                'cf1:str1' => "Goodbye", 'cf1:str2' => "Cruel world")
     assert_equal 1, @table.put('row1',
                                'cf1:a' => 1,
@@ -40,6 +43,10 @@ class TestScoped < TestHBaseJRubyBase
                                'cf1:d' => true,
                                'cf1:f' => :sym,
                                'cf1:g' => BigDecimal.new("123.456"),
+                               'cf1:byte'  => { :byte => 101 },
+                               'cf1:short' => { :short => 201 },
+                               'cf1:int'   => { :int => 301 },
+                               'cf1:int2'  => { :int => 401 },
                                'cf1:str1' => "Hello", 'cf1:str2' => "World")
     # Batch put
     assert_equal 2, @table.put(
@@ -59,9 +66,13 @@ class TestScoped < TestHBaseJRubyBase
     assert_equal true,   @table.get('row1').boolean('cf1:d')
     assert_equal :sym,   @table.get('row1').symbol('cf1:f')
     assert_equal BigDecimal.new("123.456"), @table.get('row1').bigdecimal('cf1:g')
+    assert_equal 101,   @table.get('row1').byte('cf1:byte')
+    assert_equal 201,   @table.get('row1').short('cf1:short')
+    assert_equal 301,   @table.get('row1').int('cf1:int')
 
     # single-get-multi-col
     assert_equal %w[Hello World], @table.get('row1').string(['cf1:str1', 'cf1:str2'])
+    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
@@ -73,6 +84,9 @@ class TestScoped < TestHBaseJRubyBase
     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
 
     assert @table.get('row1').fixnums('cf1:a').keys.all? { |k| k.instance_of? Fixnum }
 
@@ -83,13 +97,13 @@ class TestScoped < TestHBaseJRubyBase
 
     # multi-get
     assert_equal %w[row1 row2 row3], @table.get(['row1', 'row2', 'row3']).map { |r| r.rowkey }
-    assert_equal [1, 2, 4         ], @table.get(['row1', 'row2', 'row3']).map { |r| r.integer('cf1:a') }
+    assert_equal [1, 2, 4         ], @table.get(['row1', 'row2', 'row3']).map { |r| r.fixnum('cf1:a') }
     assert_equal [3.14, 6.28, 6.28], @table.get(['row1', 'row2', 'row3']).map { |r| r.float('cf1:c') }
     assert_equal [nil, nil        ], @table.get(['xxx', 'yyy'])
 
     # Unavailable columns
     assert_equal nil,    @table.get('row1').symbol('cf1:xxx')
-    assert_equal nil,    @table.get('row1').integer('cf1:xxx')
+    assert_equal nil,    @table.get('row1').fixnum('cf1:xxx')
 
     # Unavailable columns (plural form)
     assert_equal({},    @table.get('row1').strings('cf1:xxx'))
@@ -142,7 +156,7 @@ class TestScoped < TestHBaseJRubyBase
     }
     schema = {
       'cf1:a' => :string,
-      'cf1:b' => :integer,
+      'cf1:b' => :fixnum,
       'cf1:c' => :float,
       HBase::ColumnKey(:cf2, :d) => :symbol,
       HBase::ColumnKey(:cf2, :e) => :boolean,
@@ -183,15 +197,15 @@ class TestScoped < TestHBaseJRubyBase
     assert_equal 1, @table.get('row1').fixnum('cf1:counter')
 
     @table.increment('row1', 'cf1:counter', 1)
-    assert_equal 2, @table.get('row1').int('cf1:counter')
+    assert_equal 2, @table.get('row1').fixnum('cf1:counter')
 
     @table.increment('row1', 'cf1:counter', 2)
-    assert_equal 4, @table.get('row1').integer('cf1:counter')
+    assert_equal 4, @table.get('row1').fixnum('cf1:counter')
 
     # Multi-column increment
     @table.increment('row1', 'cf1:counter' => 4, 'cf1:counter2' => 100)
-    assert_equal 8,   @table.get('row1').integer('cf1:counter')
-    assert_equal 200, @table.get('row1').integer('cf1:counter2')
+    assert_equal 8,   @table.get('row1').fixnum('cf1:counter')
+    assert_equal 200, @table.get('row1').fixnum('cf1:counter2')
   end
 
   def test_delete
@@ -210,21 +224,21 @@ class TestScoped < TestHBaseJRubyBase
     assert_equal new_versions, [versions[1]]
 
     # Deletes a column
-    assert_equal 3, @table.get('row1').integer('cf2:c')
+    assert_equal 3, @table.get('row1').fixnum('cf2:c')
     @table.delete('row1', 'cf2:c')
     assert_nil @table.get('row1').to_hash['cf2:c']
 
     # Deletes a column with empty qualifier
-    assert_equal 0, @table.get('row1').integer('cf1')
+    assert_equal 0, @table.get('row1').fixnum('cf1')
     @table.delete('row1', 'cf1:')
-    assert_equal 1, @table.get('row1').integer('cf1:a')
-    assert_equal 2, @table.get('row1').integer('cf1:b')
+    assert_equal 1, @table.get('row1').fixnum('cf1:a')
+    assert_equal 2, @table.get('row1').fixnum('cf1:b')
     assert_nil @table.get('row1').to_hash['cf1']
     assert_nil @table.get('row1').to_hash['cf1:']
 
     # Deletes a column family
-    assert_equal 1, @table.get('row1').integer('cf1:a')
-    assert_equal 2, @table.get('row1').integer('cf1:b')
+    assert_equal 1, @table.get('row1').fixnum('cf1:a')
+    assert_equal 2, @table.get('row1').fixnum('cf1:b')
     @table.delete('row1', 'cf1') # No trailing colon
     assert_nil @table.get('row1').to_hash['cf1:a']
     assert_nil @table.get('row1').to_hash['cf1:b']
@@ -240,7 +254,7 @@ class TestScoped < TestHBaseJRubyBase
     @table.delete ['row2'], ['row3', 'cf1:a']
     assert_nil @table.get('row2')
     assert_nil @table.get('row3').to_hash['cf1:a']
-    assert_equal 2, @table.get('row3').integer('cf1:b')
+    assert_equal 2, @table.get('row3').fixnum('cf1:b')
   end
 end
 

data/test/test_util.rb

@@ -8,14 +8,20 @@ class TestUtil < Test::Unit::TestCase
   Util = HBase::Util
 
   def test_bytea_conversion
-    Util.import_java_classes!
-
     assert_raise(ArgumentError) { Util.to_bytes(10 ** 30) }
 
-    [:fixnum, :int, :integer].each do |type|
+    [:fixnum, :long].each do |type|
       assert_equal 100, Util.from_bytes( type, Util.to_bytes(100) )
       assert_equal 100, Util.from_bytes( type, Util.to_bytes(HBase::ByteArray(100)) )
     end
+
+    assert_equal 100, Util.from_bytes( :byte,  Util.to_bytes(:byte => 100) )
+    assert_equal 100, Util.from_bytes( :short, Util.to_bytes(:short => 100) )
+    assert_equal 100, Util.from_bytes( :int, Util.to_bytes(:int => 100) )
+    assert_raise(ArgumentError) { Util.to_bytes(:short => "Hello") }
+    assert_raise(ArgumentError) { Util.to_bytes(:xxx => 100) }
+    assert_raise(ArgumentError) { Util.to_bytes(:short => 100, :int => 200) }
+
     [:float, :double].each do |type|
       assert_equal 3.14, Util.from_bytes( type, Util.to_bytes(3.14) )
     end

metadata

@@ -2,14 +2,14 @@
 name: hbase-jruby
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.1.4
+  version: 0.1.5
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-11-30 00:00:00.000000000 Z
+date: 2012-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit