hbase-jruby 0.2.5-java → 0.2.6-java

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+0.2.6
+-----
+- Fixed `HBase::Scoped#filter` method to take short integer (byte, short, int) values
+- Fixed `HBase::Scoped#range` method to take short integer (byte, short, int) values
+
 0.2.5
 -----
 - Added `HBase::Table#snapshots` method

data/README.md

@@ -68,8 +68,8 @@ Call `HBase.resolve_dependency!` helper method passing one of the arguments list
 
 | Argument   | Dependency               | Default version | Required executable |
 | ---------- | ------------------------ | --------------- | ------------------- |
-| cdh4.2[.*] | Cloudera CDH4.2          | cdh4.2.0        | mvn                 |
-| cdh4.1[.*] | Cloudera CDH4.1          | cdh4.1.3        | mvn                 |
+| cdh4.2[.*] | Cloudera CDH4.2          | cdh4.2.1        | mvn                 |
+| cdh4.1[.*] | Cloudera CDH4.1          | cdh4.1.4        | mvn                 |
 | cdh3[u*]   | Cloudera CDH3            | cdh3u6          | mvn                 |
 | 0.95[.*]   | Apache HBase 0.95        | 0.95.0          | mvn                 |
 | 0.94[.*]   | Apache HBase 0.94        | 0.94.6.1        | mvn                 |
@@ -492,10 +492,10 @@ See the following example.
   table.put idx, 'cf1:a' => idx % 10
 end
 
-table.filter('cf1:a' => { lte: 1 }).to_a
-  # 0, 1, 10, 11, 20, 21
-table.while('cf1:a' => { lte: 1 }).to_a
-  # 0, 1
+table.filter('cf1:a' => { lte: 1 }).map { |r| r.rowkey :fixnum }
+  # [0, 1, 10, 11, 20, 21]
+table.while('cf1:a'  => { lte: 1 }).map { |r| r.rowkey :fixnum }
+  # [0, 1]
   #   Scan terminates immediately when condition not met.
 ```
 

data/lib/hbase-jruby/scoped.rb

@@ -121,25 +121,32 @@ class Scoped
   #     table.range(:prefix => '2012')
   #     table.range(:prefix => ['2010', '2012'])
   def range *key_range
-    if key_range.last.is_a?(Hash)
-      prefixes  = arrayfy(key_range.last[:prefix]).compact
-      raise ArgumentError,
-        "Invalid range. Unknown option(s) specified." unless (key_range.last.keys - [:prefix]).empty?
-      key_range = key_range[0...-1]
+    if (last = key_range.last).is_a?(Hash)
+      prefixes = arrayfy(last[:prefix]).compact
+      last = last.reject { |k, v| k == :prefix }
+
+      key_range = key_range[0...-1] # defensive
+      key_range << last unless last.empty?
+    else
+      prefixes = []
     end
 
-    if prefixes
+    if key_range[0].is_a?(Range)
+      raise ArgumentError, "Invalid range" unless key_range.length == 1
+    elsif !prefixes.empty?
       raise ArgumentError, "Invalid range" unless [0, 1, 2].include?(key_range.length)
     else
       raise ArgumentError, "Invalid range" unless [1, 2].include?(key_range.length)
     end
 
+    raise ArgumentError, "Invalid range" if !key_range.empty? && key_range.all? { |e| e.nil? }
+
     spawn :@range,
           key_range[0].is_a?(Range) ?
               key_range[0] :
-              (key_range.empty? ? nil : key_range),
+              (key_range.empty? ? nil : key_range.map { |e| e.nil? ? nil : Util.to_bytes(e) }),
           :@prefixes,
-          prefixes || []
+          prefixes
   end
 
   # Returns an HBase::Scoped object with the filters added
@@ -368,12 +375,12 @@ private
         filters <<
           RowFilter.new(
             CompareFilter::CompareOp::GREATER_OR_EQUAL,
-            BinaryComparator.new(Util.to_bytes range[0])) if range[0]
+            BinaryComparator.new(range[0])) if range[0]
 
         filters <<
           RowFilter.new(
             CompareFilter::CompareOp::LESS,
-            BinaryComparator.new(Util.to_bytes range[1])) if range[1]
+            BinaryComparator.new(range[1])) if range[1]
       else
         raise ArgumentError, "Invalid range"
       end if range
@@ -432,7 +439,11 @@ private
             when :ne # , :!= # Ruby 1.8 compatibility
               CompareFilter::CompareOp::NOT_EQUAL
             else
-              raise ArgumentError, "Unknown operator: #{op}"
+              if val.length == 1
+                return filter_for(cf, cq, Util.to_bytes(val))
+              else
+                raise ArgumentError, "Unknown operator: #{op}"
+              end
             end
           case v
           when Array
@@ -448,8 +459,6 @@ private
                 SingleColumnValueFilter.new(cf, cq, operator, Util.to_bytes(vv))
               }
             )
-          when Hash
-            raise ArgumentError, "Hash predicate not supported"
           else
             SingleColumnValueFilter.new(cf, cq, operator, Util.to_bytes(v))
           end
@@ -483,8 +492,8 @@ private
           scan.setStopRow Util.append_0(Util.to_bytes range.end)
         end
       when Array
-        scan.setStartRow Util.to_bytes range[0] if range[0]
-        scan.setStopRow  Util.to_bytes range[1] if range[1]
+        scan.setStartRow range[0] if range[0]
+        scan.setStopRow  range[1] if range[1]
       else
         # This shouldn't happen though.
         raise ArgumentError, "Invalid range"

data/lib/hbase-jruby/version.rb

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

data/test/test_scoped.rb

@@ -25,7 +25,10 @@ class TestScoped < TestHBaseJRubyBase
   def test_invalid_range
     assert_raise(ArgumentError) { @table.range }
     assert_raise(ArgumentError) { @table.range(:xxx => 'row1') }
+    assert_raise(ArgumentError) { @table.range({}) }
     assert_raise(ArgumentError) { @table.range(1, 2, 3) }
+    assert_raise(ArgumentError) { @table.range(nil, nil) }
+    assert_raise(ArgumentError) { @table.range(1..3, 4..5) }
   end
 
   def test_invalid_project
@@ -96,6 +99,46 @@ class TestScoped < TestHBaseJRubyBase
     assert_equal 50, @table.range(111..150).filter('cf1:a' => 131...140, 'cf2:b' => 132..133).unscope.count
   end
 
+  def test_range_on_short_int
+    (1..10).each do |i|
+      @table.put({ :short => i }, 'cf1:a' => 'dummy')
+    end
+
+    assert_equal 5, @table.range({ :short => 6 }).count
+    assert_equal 2, @table.range({ :short => 6 }, { :short => 8 }).count
+    assert_equal 2, @table.range({ :short => 6 }, { :short => 8, :prefix => []}).count
+    assert_equal 2, @table.range({ :short => 6 }, { :short => 8 }, :prefix => []).count
+    assert_equal 3, @table.range(nil, { :short => 4 }).count
+    assert_equal 3, @table.range(nil, { :short => 4, :prefix => [] }).count
+    assert_equal 3, @table.range(nil, { :short => 4 }, :prefix => []).count
+  end
+
+  def test_filter_on_short_int
+    @table.put(1, 'cf1:a' => { :long  => 100 })
+    @table.put(2, 'cf1:a' => { :int   => 100 })
+    @table.put(3, 'cf1:a' => { :short => 100 })
+    @table.put(4, 'cf1:a' => { :byte  => 100 })
+    @table.put(5, 'cf1:a' => { :byte  => 110 })
+
+    assert_equal 1, @table.filter('cf1:a' => { :long  => 100 }).count
+    assert_equal 1, @table.filter('cf1:a' => { :int   => 100 }).count
+    assert_equal 1, @table.filter('cf1:a' => { :short => 100 }).count
+    assert_equal 1, @table.filter('cf1:a' => { :byte  => 100 }).count
+
+    assert_equal 1, @table.filter('cf1:a' => { :long  => 100 }).first.rowkey(:fixnum)
+    assert_equal 2, @table.filter('cf1:a' => { :int   => 100 }).first.rowkey(:fixnum)
+    assert_equal 3, @table.filter('cf1:a' => { :short => 100 }).first.rowkey(:fixnum)
+    assert_equal 4, @table.filter('cf1:a' => { :byte  => 100 }).first.rowkey(:fixnum)
+
+    assert_equal 5, @table.filter('cf1:a' => { :gt => { :byte => 100 } }).first.rowkey(:fixnum)
+  end
+
+  def test_filter_operator_and_short_int
+    assert_raise(ArgumentError) {
+      @table.filter('cf1:a' => { :long  => 100, :gt => 10 })
+    }
+  end
+
   def test_scan
     insert = lambda do
       (40..70).each do |i|

metadata

@@ -2,14 +2,14 @@
 name: hbase-jruby
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.2.5
+  version: 0.2.6
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-05-02 00:00:00.000000000 Z
+date: 2013-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit