hbase-jruby 0.1.1-java → 0.1.2-java

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+Changelog
+=========
+
+0.1.2
+-----
+
+- Dropped Bignum support. Automatic conversion from Fixnum to Bignum (or vice versa)
+  will produce columns whose values are of heterogeneous types, that are impossible to be read in a consistent way.
+  You can use BigDecimal type instead for large numbers.
+- Added `HBase::Scoped#while` which allows early termination of scan
+  with [WhileMatchFilter](http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/filter/WhileMatchFilter.html)
+- Filtering with regular expressions
+- Implemented comparator for `HBase::Result`
+- Added coprocessor administration methods
+- Basic aggregation with Coprocessor
+- `HBase::Scoped#count` with block
+- Allows PUT operation with timestamps

data/README.md

@@ -9,7 +9,7 @@ Anyhow, JRuby is Ruby, not Java, right?
 
 *hbase-jruby* provides the followings:
 - Easy, Ruby-esque interface for the fundamental HBase operations
-- ActiveRecord-like method chaining for scanning tables
+- ActiveRecord-like method chaining for data retrieval
 - Automatic Hadoop/HBase dependency resolution
 
 ## A quick example
@@ -17,6 +17,8 @@ Anyhow, JRuby is Ruby, not Java, right?
 ```ruby
 require 'hbase-jruby'
 
+HBase.resolve_dependency! 'cdh4.1.2'
+
 hbase = HBase.new
 table = hbase.table(:test_table)
 
@@ -25,16 +27,17 @@ table.put :rowkey1 => { 'cf1:a' => 100, 'cf2:b' => "Hello" }
 
 # GET
 row = table.get(:rowkey1)
-number = row.integer('cf1:a')
+number = row.fixnum('cf1:a')
 string = row.string('cf1:b')
 
 # SCAN
 table.range('rowkey1'..'rowkey9').
       filter('cf1:a' => 100..200,             # cf1:a between 100 and 200
-             'cf2:b' => 'Hello',              # cf1:b = 'Hello'
-             'cf2:c' => ['foo', 'bar']).      # cf2:c in ('foo', 'bar')
+             'cf1:b' => 'Hello',              # cf1:b = 'Hello'
+             'cf2:c' => /world/i).            # cf2:c matches /world/i
+             'cf2:d' => ['foo', /^BAR/i],     # cf2:d = 'foo' OR matches /^BAR/i
       project('cf1:a', 'cf2').each do |row|
-  puts row.integer('cf1:a')
+  puts row.fixnum('cf1:a')
 end
 
 # DELETE
@@ -174,6 +177,14 @@ table.put 'rowkey1', 'cf1:col1' => "Hello", 'cf2:col2' => "World"
 table.put 'rowkey1' => { 'cf1:col1' => "Hello",   'cf2:col2' => "World" },
           'rowkey2' => { 'cf1:col1' => "Howdy",   'cf2:col2' => "World" },
           'rowkey3' => { 'cf1:col1' => "So long", 'cf2:col2' => "World" }
+
+# Putting values with timestamps
+table.put 'rowkey1' => {
+    'cf1:col1' => {
+      1353143856665 => "Hello",
+      1352978648642 => "Goodbye" },
+    'cf2:col2' => "World"
+  }
 ```
 
 ### GET
@@ -191,12 +202,12 @@ rowk = row.rowkey
 col0 = row.raw 'cf1:col0'
 
 # Decode column values
-col1 = row.string  'cf1:col1'
-col2 = row.fixnum  'cf1:col2'
-col3 = row.bignum  'cf1:col3'
-col4 = row.float   'cf1:col4'
-col5 = row.boolean 'cf1:col5'
-col6 = row.symbol  'cf1:col6'
+col1 = row.string     'cf1:col1'
+col2 = row.fixnum     'cf1:col2'
+col3 = row.bigdecimal 'cf1:col3'
+col4 = row.float      'cf1:col4'
+col5 = row.boolean    'cf1:col5'
+col6 = row.symbol     'cf1:col6'
 
 # Decode multiple columns at once
 row.string ['cf1:str1', 'cf1:str2']
@@ -225,13 +236,13 @@ row.strings ['cf1:str1', 'cf1:str2']
   # ]
 
 # Plural-form methods are provided for any other data types as well
-cols0 = row.raws     'cf1:col0'
-cols1 = row.strings  'cf1:col1'
-cols2 = row.fixnums  'cf1:col2'
-cols3 = row.bignums  'cf1:col3'
-cols4 = row.floats   'cf1:col4'
-cols5 = row.booleans 'cf1:col5'
-cols6 = row.symbols  'cf1:col6'
+cols0 = row.raws        'cf1:col0'
+cols1 = row.strings     'cf1:col1'
+cols2 = row.fixnums     'cf1:col2'
+cols3 = row.bigdecimals 'cf1:col3'
+cols4 = row.floats      'cf1:col4'
+cols5 = row.booleans    'cf1:col5'
+cols6 = row.symbols     'cf1:col6'
 ```
 
 #### Intra-row scan
@@ -262,7 +273,7 @@ end
 schema = {
   'cf1:col1' => :string,
   'cf1:col2' => :fixnum,
-  'cf1:col3' => :bignum,
+  'cf1:col3' => :bigdecimal,
   'cf1:col4' => :float,
   'cf1:col5' => :boolean,
   'cf1:col6' => :symbol }
@@ -359,6 +370,7 @@ table.range('A'..'Z').                   # Row key range,
       filter('cf2:d' => 100..200).       # Range filter on cf2:d
       filter('cf2:e' => [10, 20..30]).   # Set-inclusion condition on cf2:e
       filter(RandomRowFilter.new(0.5)).  # Any Java HBase filter
+      while('cf2:f' => { ne: 'OPEN' }).  # Early termination of scan
       limit(10).                         # Limits the size of the result set
       versions(2).                       # Only fetches 2 versions for each value
       batch(100).                        # Batch size for scan set to 100
@@ -366,7 +378,7 @@ table.range('A'..'Z').                   # Row key range,
       to_a                               # To Array
 ```
 
-### range
+### *range*
 
 `HBase::Scoped#range` method is used to filter rows based on their row keys.
 
@@ -416,7 +428,7 @@ scope.range(1, 100).
   # Same as `scope.range(1, 1000)`
 ```
 
-### filter
+### *filter*
 
 You can configure server-side filtering of rows and columns with `HBase::Scoped#filter` calls.
 Multiple calls have conjunctive effects.
@@ -424,22 +436,56 @@ Multiple calls have conjunctive effects.
 ```ruby
 # Range scanning the table with filters
 table.range(nil, 1000).
-      filter('cf1:a' => 'Hello',                  # cf1:a = 'Hello'
-             'cf1:b' => 100...200,                # cf1:b between 100 and 200
-             'cf1:c' => %w[A B C],                # cf1:c in ('A', 'B', 'C')
-             'cf1:d' => ['A'...'B', 'C'],         # ('A' <= cf1:d < 'B') or cf1:d = 'C'
-             'cf1:e' => { gt: 1000, lte: 2000 }). # cf1:e > 1000 and cf1:e <= 2000
-             'cf1:f' => { ne: 1000 }).            # cf1:f != 1000
-                                                  #   Supported operators: gt, lt, gte, lte, eq, ne
-      filter('cf1:g' => ['Alice'..'Bob', 'Cat']). # Multiple calls for conjunctive filtering
+      filter(
+        # Numbers and characters: Checks if the value is equal to the given value
+        'cf1:a' => 'Hello',
+        'cf1:b' => 1024,
+
+        # Range of numbers or characters: Checks if the value falls within the range
+        'cf1:c' => 100..200,
+        'cf1:d' => 'A'..'C',
+
+        # Regular expression: Checks if the value matches the regular expression
+        'cf1:e' => /world$/i,
+
+        # Hash: Tests the value with 6 types of operators (:gt, :lt, :gte, :lte, :eq, :ne)
+        'cf1:f' => { gt: 1000, lte: 2000 },
+        'cf1:g' => { ne: 1000 },
+
+        # Array of the aforementioned types: OR condition (disjunctive)
+        'cf1:h' => %w[A B C],
+        'cf1:i' => ['A'...'B', 'C', /^D/, { lt: 'F' }]).
+
+      # Multiple calls for conjunctive filtering
+      filter('cf1:j' => ['Alice'..'Bob', 'Cat']).
+
+      # Any number of Java filters can be applied
       filter(org.apache.hadoop.hbase.filter.RandomRowFilter.new(0.5)).
-                                                  # Any number of Java filters can be applied
-      each do |record|
+  each do |record|
   # ...
 end
 ```
 
-### project
+### *while*
+
+`HBase::Scoped#while` method takes the same parameters as `filter` method, the difference is that
+each filtering condition passed to `while` method is wrapped by `WhileMatchFilter`,
+which aborts scan immediately when the condition is not met at a certain row.
+See the following example.
+
+```ruby
+(0...30).each do |idx|
+  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
+  #   Scan terminates immediately when condition not met.
+```
+
+### *project*
 
 `HBase::Scoped#project` allows you to fetch only a subset of columns from each row.
 Multiple calls have additive effects.
@@ -521,6 +567,44 @@ end
 scoped.count
 ```
 
+## Basic aggregation using coprocessor
+
+*hbase-jruby* provides a few basic aggregation methods using
+the built-in coprocessor called
+`org.apache.hadoop.hbase.coprocessor.AggregateImplementation`.
+
+To enable this feature, call `enable_aggregation!` method,
+which will first disable the table, add the coprocessor, then enable it.
+
+```ruby
+table.enable_aggregation!
+  # Just a shorthand notation for
+  #   table.add_coprocessor! 'org.apache.hadoop.hbase.coprocessor.AggregateImplementation'
+```
+
+Then you can get the sum, average, minimum, maximum, row count, and standard deviation
+of the projected columns.
+
+```ruby
+# cf1:a must hold 8-byte integer values
+table.project('cf1:a').aggregate(:sum)
+table.project('cf1:a').aggregate(:avg)
+table.project('cf1:a').aggregate(:min)
+table.project('cf1:a').aggregate(:max)
+table.project('cf1:a').aggregate(:std)
+table.project('cf1:a').aggregate(:row_count)
+
+# Aggregation of multiple columns
+table.project('cf1:a', 'cf1:b').aggregate(:sum)
+```
+
+By default, aggregate method assumes the column values are 8-byte integers.
+For types other than that, you can pass your own ColumnInterpreter.
+
+```ruby
+table.project('cf1:b').aggregate(:sum, MyColumnInterpreter.new)
+```
+
 ## Advanced topics
 
 ### Lexicographic scan order
@@ -556,7 +640,6 @@ table.get('rowkey').string(HBase::ColumnKey(:cf1, 100))
 # ...
 ```
 
-
 ### Table administration
 
 `HBase#Table` provides a few *synchronous* table administration methods.
@@ -588,6 +671,16 @@ table.alter_family! :cf2, :bloomfilter => :rowcol
 
 # Remove column family
 table.delete_family! :cf1
+
+# Add Coprocessor
+unless table.has_coprocessor?(cp_class_name1)
+  table.add_coprocessor! cp_class_name1
+end
+table.add_coprocessor! cp_class_name2,
+  :path => path, :priority => priority, :params => params
+
+# Remove coprocessor
+table.remove_coprocessor! cp_class_name1
 ```
 
 You can perform other types of administrative tasks

data/hbase-jruby.gemspec

@@ -12,6 +12,7 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{Ruby-esque interface for accessing HBase from JRuby}
   gem.homepage      = "https://github.com/junegunn/hbase-jruby"
   gem.platform      = 'java'
+  gem.license       = 'MIT'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lib/hbase-jruby/admin.rb

@@ -1,6 +1,7 @@
 require 'thread'
 
 class HBase
+# @private
 module Admin
 private
   def with_admin

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, :bignum, :bigdecimal, :boolean and :raw.
+  #   Can be one of :string, :symbol, :fixnum, :float, :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, :bignum, :bigdecimal, :boolean and :raw.
+  #   Can be one of :string, :symbol, :fixnum, :float, :bigdecimal, :boolean and :raw.
   # @return [Object]
   def qualifier type = :string
     Util.from_bytes type, @java.getQualifier
@@ -49,7 +49,7 @@ class Cell
   end
   alias ts timestamp
 
-  # Returns the value of the cell as a Java byte array 
+  # Returns the value of the cell as a Java byte array
   # @return [byte[]]
   def value
     @java.getValue
@@ -78,14 +78,6 @@ class Cell
   alias integer fixnum
   alias int     fixnum
 
-  # Returns the column value as a Bignum
-  # @return [Bignum]
-  def bignum
-    Util.from_bytes :bignum, value
-  end
-  alias biginteger bignum
-  alias bigint     bignum
-
   # Returns the column value as a BigDecimal
   # @return [BigDecimal]
   def bigdecimal

data/lib/hbase-jruby/result.rb

@@ -1,14 +1,14 @@
 require 'bigdecimal'
 
-# Represents a row returned by HBase
 class HBase
+# Represents a row returned by HBase
 # @author Junegunn Choi <junegunn.c@gmail.com>
 class Result
   include Enumerable
- 
+
   # Returns the rowkey of the row
   # @param [Symbol] type The type of the rowkey
-  #   Can be one of :string, :symbol, :fixnum, :float, :bignum, :bigdecimal, :boolean and :raw.
+  #   Can be one of :string, :symbol, :fixnum, :float, :bigdecimal, :boolean and :raw.
   # @return [String, byte[]]
   def rowkey type = :string
     Util.from_bytes type, @result.getRow
@@ -55,7 +55,7 @@ class Result
           name = ColumnKey.new(cf, cq)
           type = schema[name]
 
-          ret[name] = 
+          ret[name] =
             Hash[
               tsmap.map { |ts, val|
                 [ ts,  type ? Util.from_bytes(type, val) : val ]
@@ -71,7 +71,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [byte[]] Byte array representation of the latest value
   # @overload raw(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns the latest column value as a byte array
   #   @param [<String|HBase::ColumnKey>] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Array<byte[]>] Byte array representations of the latest values
@@ -91,7 +91,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, byte[]>]
   # @overload raws(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns all versions of column values as byte arrays 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, byte[]>>]
@@ -111,7 +111,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [String]
   # @overload string(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns the latest column value as a String
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<String>]
@@ -125,7 +125,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, String>]
   # @overload strings(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns all versions of column values as Strings 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, String>>]
@@ -139,7 +139,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Symbol]
   # @overload symbol(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns the latest column values as a Symbol
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<Symbol>]
@@ -153,7 +153,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, Symbol>]
   # @overload symbols(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns all versions of column values as Symbols 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, Symbol>>]
@@ -167,7 +167,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Fixnum]
   # @overload fixnum(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns the latest column values as a Fixnum
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<Fixnum>]
@@ -182,7 +182,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, Fixnum>]
   # @overload fixnums(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns all versions of 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>>]
@@ -192,42 +192,12 @@ class Result
   alias integers fixnums
   alias ints     fixnums
 
-  # @overload bignum(column)
-  #   Returns the latest column value as a Bignum
-  #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
-  #   @return [Bignum]
-  # @overload bignum(columns)
-  #   For each column specified, 
-  #   returns the latest column values as a Bignum
-  #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
-  #   @return [Array<Bignum>]
-  def bignum cols
-    decode_values :bignum, cols
-  end
-  alias biginteger bignum
-  alias bigint     bignum
-
-  # @overload bignums(column)
-  #   Returns all versions of column values as Bignums in a Hash indexed by their timestamps
-  #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
-  #   @return [Hash<Fixnum, Bignum>]
-  # @overload bignums(columns)
-  #   For each column specified, 
-  #   returns all versions of column values as Bignums 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, Bignum>>]
-  def bignums cols
-    decode_values :bignum, cols, true
-  end
-  alias bigintegers bignums
-  alias bigints     bignums
-
   # @overload bigdecimal(column)
   #   Returns the latest column value as a BigDecimal
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [BigDecimal]
   # @overload bigdecimal(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns the latest column values as a BigDecimal
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<BigDecimal>]
@@ -240,7 +210,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, BigDecimal>]
   # @overload bigdecimals(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns all versions of column values as BigDecimals 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, BigDecimal>>]
@@ -253,7 +223,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Float]
   # @overload float(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns the latest column values as a Float
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<Float>]
@@ -267,7 +237,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, Float>]
   # @overload floats(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns all versions of column values as Floats 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, Float>>]
@@ -281,7 +251,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [true, false]
   # @overload boolean(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns the latest column values as a boolean value
   #   @param [Array<String|HBase::ColumnKey>] columns Array of "FAMILY:QUALIFIER" expressions and ColumnKey objects.
   #   @return [Array<true|false>]
@@ -295,7 +265,7 @@ class Result
   #   @param [String, HBase::ColumnKey] column "FAMILY:QUALIFIER" expression or ColumnKey object.
   #   @return [Hash<Fixnum, true|false>]
   # @overload booleans(columns)
-  #   For each column specified, 
+  #   For each column specified,
   #   returns all versions of column values as boolean values 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, true|false>>]
@@ -304,6 +274,10 @@ class Result
   end
   alias bools booleans
 
+  def <=> other
+    Bytes.compareTo(rowkey(:raw), other.rowkey(:raw))
+  end
+
 private
   HASH_TEMPLATE = {}.tap { |h|
     h.instance_eval do
@@ -326,7 +300,9 @@ private
     cols.map { |col|
       cf, cq = Util.parse_column_name(col)
       if with_versions
-        Hash[ allmap[cf][cq] ]
+        # Need to make it a Ruby hash:
+        #   Prevents implicit conversion from ruby type to java type when updating the Hash
+        Hash[ allmap.fetch(cf, {}).fetch(cq, {}) ]
       else
         @result.getValue cf, cq
       end
@@ -365,7 +341,7 @@ private
   def parse_schema schema
     {}.tap { |ret|
       schema.each do |name, type|
-        ck = 
+        ck =
           case name
           when ColumnKey
             name
@@ -378,5 +354,5 @@ private
     }
   end
 end#Result
-end#HBase 
+end#HBase
 

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

@@ -0,0 +1,47 @@
+class HBase
+class Scoped
+# Basic data aggregation with coprocessor based on AggregateImplementation
+# @author Junegunn Choi <junegunn.c@gmail.com>
+module Aggregation
+  module Admin
+    # Enables aggregation support for the table
+    # @return [nil]
+    def enable_aggregation!
+      add_coprocessor! 'org.apache.hadoop.hbase.coprocessor.AggregateImplementation'
+    end
+  end
+
+  # Performs aggregation with coprocessor
+  # @param [Symbol] op Aggregation type: :sum, :min, :max, :avg, :std, :row_count
+  # @param [Symbol, org.apache.hadoop.hbase.coprocessor.ColumnInterpreter] type
+  #   Column type (only :fixnum is supported as of now) or ColumnInterpreter object used to decode the value
+  def aggregate op, type = :fixnum
+    aggregation_impl op, type
+  end
+
+private
+  def aggregation_impl method, type
+    raise ArgumentError.new("No column specified") if method != :row_count && @project.empty?
+
+    @aggregation_client ||= AggregationClient.new(table.config)
+    @aggregation_client.send(
+      method,
+      Util.to_bytes(table.name),
+      column_interpreter_for(type),
+      filtered_scan)
+  end
+
+  def column_interpreter_for type
+    case type
+    when :fixnum, :int, :integer
+      LongColumnInterpreter.new
+    when org.apache.hadoop.hbase.coprocessor.ColumnInterpreter
+      type
+    else
+      raise ArgumentError, "Column interpreter for #{type} not implemented."
+    end
+  end
+end#Aggregation
+end#Scoped
+end#HBase
+