hbase-jruby 0.1.1-java

data/lib/hbase-jruby/util.rb

@@ -0,0 +1,171 @@
+require 'bigdecimal'
+
+class HBase
+module Util
+  JAVA_BYTE_ARRAY_EMPTY = [].to_java(Java::byte) 
+  JAVA_BYTE_ARRAY_CLASS = JAVA_BYTE_ARRAY_EMPTY.java_class
+
+  class << self
+    # Returns byte array representation of the Ruby object
+    # @param [byte[]] v
+    # @return [byte[]]
+    def to_bytes v
+      case v
+      when String
+        v.to_java_bytes
+      when Fixnum
+        Bytes.java_send :toBytes, [Java::long], v
+      when Symbol
+        v.to_s.to_java_bytes
+      when Float
+        Bytes.java_send :toBytes, [Java::double], v
+      when true, false, ByteBuffer
+        Bytes.to_bytes v
+      when nil
+        ''.to_java_bytes
+      when Bignum
+        Bytes.java_send :toBytes, [java.math.BigDecimal], java.math.BigDecimal.new(v.to_s)
+      when BigDecimal
+        Bytes.java_send :toBytes, [java.math.BigDecimal], v.to_java
+      when java.math.BigDecimal
+        Bytes.java_send :toBytes, [java.math.BigDecimal], v
+      else
+        if v.respond_to?(:java_class) && v.java_class == JAVA_BYTE_ARRAY_CLASS
+          v
+        else
+          raise ArgumentError.new("Don't know how to convert #{v.class} into Java bytes")
+        end
+      end
+    end
+
+    # Returns Ruby object decoded from the byte array according to the given type
+    # @param [Symbol, Class] type Type to convert to
+    # @param [byte[]] val Java byte array
+    # @return [Object]
+    def from_bytes type, val
+      return nil if val.nil?
+
+      case type
+      when :string, :str
+        Bytes.to_string val
+      when :fixnum, :int, :integer
+        Bytes.to_long val
+      when :symbol, :sym
+        Bytes.to_string(val).to_sym
+      when :bignum, :bigint, :biginteger
+        BigDecimal.new(Bytes.to_big_decimal(val).to_s).to_i
+      when :bigdecimal
+        BigDecimal.new(Bytes.to_big_decimal(val).to_s)
+      when :float, :double
+        Bytes.to_double val
+      when :boolean, :bool
+        Bytes.to_boolean val
+      when :raw
+        val
+      else
+        raise ArgumentError, "Invalid type: #{type}"
+      end
+    end
+
+    # Returns a byte array with a trailing '0' byte
+    # @param [byte[]] v
+    # @return [byte[]]
+    def append_0 v
+      baos = java.io.ByteArrayOutputStream.new
+      baos.write v, 0, v.length
+      baos.write 0
+      baos.toByteArray
+    end
+
+    # Extracts a byte array pair of column family and column qualifier from the given object
+    # @param [Object, Array, KeyValue] col
+    def parse_column_name col
+      case col
+      when ColumnKey
+        return col.cf.to_java_bytes, col.cq(:raw)
+      when KeyValue
+        return col.getFamily, col.getQualifier
+      when Array
+        return to_bytes(col[0]), to_bytes(col[1])
+      when '', nil
+        raise ArgumentError, "Column family not specified"
+      else
+        cf, cq = KeyValue.parseColumn(col.to_s.to_java_bytes)
+        cq = JAVA_BYTE_ARRAY_EMPTY if cq.nil? && col.to_s[-1] == ':'
+        return cf, cq
+      end
+    end
+
+    # @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::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
+        ]
+
+        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.MultipleColumnPrefixFilter
+          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.PrefixFilter
+          org.apache.hadoop.hbase.filter.RowFilter
+          org.apache.hadoop.hbase.filter.SingleColumnValueFilter
+        ]
+      end
+    end
+  end
+end#Util
+end#HBase
+

data/lib/hbase-jruby/version.rb

@@ -0,0 +1,5 @@
+class HBase
+module JRuby
+  VERSION = "0.1.1"
+end
+end

data/test/helper.rb

@@ -0,0 +1,53 @@
+$VERBOSE = true
+
+require 'rubygems'
+require "test-unit"
+require 'simplecov'
+SimpleCov.start
+
+RECREATE = false
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "hbase-jruby"
+
+# Required
+HBase.resolve_dependency! 'cdh4.1.2'
+
+class TestHBaseJRubyBase < Test::Unit::TestCase
+  TABLE = 'test_hbase_jruby'
+  ZK    = ENV.fetch 'HBASE_JRUBY_TEST_ZK'
+
+  # Initialize
+  hbase = HBase.new 'hbase.zookeeper.quorum' => ZK
+  hbase.table(TABLE) do |table|
+    table.drop! if table.exists?
+  end
+  hbase.close
+
+  def setup
+    @hbase ||= HBase.new 'hbase.zookeeper.quorum' => ZK
+    @table = @hbase.table(TABLE)
+
+    # Drop & Create
+    @table.drop! if RECREATE && @table.exists?
+    @table.create!(
+      :cf1 => { :compression => :none, :bloomfilter => :row },
+      :cf2 => { :bloomfilter => :rowcol },
+      :cf3 => { :versions    => 1, :bloomfilter => org.apache.hadoop.hbase.regionserver.StoreFile::BloomType::ROWCOL }
+    ) unless @table.exists?
+    @table.enable! if @table.disabled?
+
+    unless RECREATE
+      @table.each do |row|
+        @table.delete row.rowkey :raw
+      end
+      assert_equal 0, @table.count
+    end
+  end
+
+  def teardown
+    if RECREATE
+      @table.drop! if @table && @table.exists?
+    end
+  end
+end

data/test/test_byte_array.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+
+class TestByteArray < Test::Unit::TestCase
+  def test_order
+    [
+      [(1..100).to_a, :fixnum],
+      [('aa'..'zz').to_a, :string],
+    ].each do |pair|
+      arr, type = pair
+      assert_equal arr,
+        arr.reverse.map { |e| HBase::ByteArray.new(e) }.sort.map { |ba|
+          HBase::Util.from_bytes type, ba.java
+        }
+    end
+  end
+
+  def test_stopkey_bytes_for_prefix
+    assert_equal HBase::ByteArray.new("hellp"),
+      HBase::ByteArray.new( HBase::ByteArray.new("hello").stopkey_bytes_for_prefix )
+    assert_equal HBase::ByteArray.new("BLUF"),
+      HBase::ByteArray.new( HBase::ByteArray.new("BLUE").stopkey_bytes_for_prefix )
+    assert_nil HBase::ByteArray.new([127, 127, 127].to_java(Java::byte)).stopkey_bytes_for_prefix
+    assert_equal HBase::ByteArray.new([126, 127].to_java(Java::byte)),
+      HBase::ByteArray.new(
+        HBase::ByteArray.new([126, 126, 127, 127, 127, 127].to_java(Java::byte)).stopkey_bytes_for_prefix
+      )
+  end
+
+  def test_as_hash_key
+    hash = {
+      HBase::ByteArray.new("Hello") => 1,
+      HBase::ByteArray.new("World") => 2
+    }
+    assert_equal 1, hash[ HBase::ByteArray.new("Hello") ]
+    assert_equal 2, hash[ HBase::ByteArray.new("World".to_java_bytes) ]
+  end
+end

data/test/test_cell.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+require 'bigdecimal'
+
+class TestCell < Test::Unit::TestCase
+  import org.apache.hadoop.hbase.KeyValue
+  Util = HBase::Util
+
+  def test_cell
+    ts = Time.now.to_i * 1000
+    {
+      'value'                        => :string,
+      :value                         => :symbol,
+      123                            => :fixnum,
+      123456789012345678901234567890 => :bignum,
+      123.456                        => :float,
+      true                           => :boolean,
+      false                          => :boolean,
+      BigDecimal.new("123.456")      => :bigdecimal
+    }.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)
+
+      assert_equal "rowkey", cell.rowkey
+      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)
+      assert_equal HBase::ColumnKey.new(:hello, :world), cell.column_key
+      assert_instance_of String, cell.inspect
+    end
+  end
+  
+  def test_order
+    ts = Time.now.to_i * 1000
+
+    val = "val".to_java_bytes
+    cells = 
+      [
+        KeyValue.new("rowkey".to_java_bytes, "apple".to_java_bytes,  "alpha".to_java_bytes, ts, val),
+        KeyValue.new("rowkey".to_java_bytes, "apple".to_java_bytes,  "alpha".to_java_bytes, ts - 1000, val),
+        KeyValue.new("rowkey".to_java_bytes, "apple".to_java_bytes,  "beta".to_java_bytes,  ts, val),
+        KeyValue.new("rowkey".to_java_bytes, "banana".to_java_bytes, "beta".to_java_bytes,  ts, val),
+        KeyValue.new("rowkey".to_java_bytes, "banana".to_java_bytes, "gamma".to_java_bytes, ts, val),
+      ].map { |kv| HBase::Cell.new kv }
+
+    assert_equal cells, cells.reverse.sort
+  end
+end

data/test/test_column_key.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+
+class TestColumnKey < Test::Unit::TestCase
+  Util = HBase::Util
+
+  def test_types
+    ck = HBase::ColumnKey("hello", "world")
+    assert_equal "hello", ck.family
+    assert_equal "hello", ck.cf
+    assert_equal "world", ck.qualifier
+    assert_equal "world", ck.cq
+    assert_equal 'hello:world', ck.to_s
+
+    ck = HBase::ColumnKey("hello".to_java_bytes, 123)
+    assert_equal "hello", ck.family
+    assert_equal "hello", ck.cf
+    assert_equal 123, ck.qualifier(:fixnum)
+    assert_equal 123, ck.cq(:fixnum)
+
+    ck = HBase::ColumnKey(:hello, nil)
+    assert_equal "hello", ck.family
+    assert_equal "hello", ck.cf
+    assert_equal '', ck.qualifier(:string)
+    assert_equal '', ck.cq(:string)
+    assert_equal 'hello', ck.to_s
+  end
+
+  def test_eql
+    ck1 = HBase::ColumnKey(:hello, :world)
+    ck2 = HBase::ColumnKey("hello", "world")
+
+    assert_equal ck1, ck2
+    assert_equal ck1, "hello:world"
+  end
+
+  def test_order
+    assert_equal (1..100).to_a,
+      (1..100).to_a.reverse.map { |cq|
+        HBase::ColumnKey(:cf, cq)
+      }.sort.map { |ck| ck.cq :fixnum }
+  end
+
+  def test_as_hash_key
+    assert({ HBase::ColumnKey(:hello, :world) => true }[ ck2 = HBase::ColumnKey("hello", "world") ])
+  end
+end

data/test/test_hbase.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+
+class TestHBase < TestHBaseJRubyBase 
+  def test_tables
+    assert @hbase.table_names.include?(TABLE)
+    assert @hbase.tables.map(&:name).include?(TABLE)
+  end
+
+  def test_close
+    @hbase.close
+
+    # TODO: Still usable after close?
+    assert @hbase.table_names.include?(TABLE)
+    assert_equal 1, @table.put('rowkey' => { 'cf1:a' => 1 })
+  end
+
+  def test_admin
+    assert_instance_of org.apache.hadoop.hbase.client.HBaseAdmin, @hbase.admin
+    @hbase.admin do |admin|
+      assert_instance_of org.apache.hadoop.hbase.client.HBaseAdmin, admin
+    end
+  end
+
+  def test_config
+    assert_instance_of org.apache.hadoop.conf.Configuration, @hbase.config
+  end
+
+  def test_shared_config
+    hbase2 = HBase.new @hbase.config
+    assert_equal @hbase.config, hbase2.config
+  end
+end
+

data/test/test_scoped.rb

@@ -0,0 +1,318 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+
+class TestScoped < TestHBaseJRubyBase 
+  def test_invalid_limit
+    assert_raise(ArgumentError) { @table.limit }
+    assert_raise(ArgumentError) { @table.limit(-1) }
+    assert_raise(ArgumentError) { @table.limit("hello") }
+  end
+
+  def test_invalid_versions
+    assert_raise(ArgumentError) { @table.versions }
+    assert_raise(ArgumentError) { @table.versions(0) }
+    assert_raise(ArgumentError) { @table.versions("hello") }
+  end
+
+  def test_invalid_batch
+    assert_raise(ArgumentError) { @table.batch }
+    assert_raise(ArgumentError) { @table.batch(0) }
+    assert_raise(ArgumentError) { @table.batch("hello") }
+  end
+
+  def test_invalid_range
+    assert_raise(ArgumentError) { @table.range }
+    assert_raise(ArgumentError) { @table.range(:xxx => 'row1') }
+    assert_raise(ArgumentError) { @table.range(1, 2, 3) }
+  end
+
+  def test_invalid_project
+    assert_raise(ArgumentError) { @table.project(:offset => 'a', :limit => 10).to_a }
+    assert_raise(ArgumentError) { @table.project(:offset => 10, :limit => 'a').to_a }
+
+    @table.project(:offset => 100) # Fine yet
+    @table.project(:limit => 10)
+    assert_raise(ArgumentError) { @table.project(:offset => 100).to_a }
+    assert_raise(ArgumentError) { @table.project(:limit  => 10).to_a }
+    assert_raise(ArgumentError) { @table.project(:offset => -1) }
+    assert_raise(ArgumentError) { @table.project(:limit  => -1) }
+    assert_raise(ArgumentError) { @table.project(:offset => :a) }
+    assert_raise(ArgumentError) { @table.project(:limit  => :a) }
+    assert_raise(ArgumentError) { @table.project(:xxx    => 1) }
+  end
+
+  def test_invalid_filter
+    assert_raise(ArgumentError) { @table.filter(3.14) }
+    assert_raise(ArgumentError) { @table.filter('cf1:a' => { xxx: 50 }) }
+    assert_raise(ArgumentError) { @table.filter('cf1:a' => { eq: { 1 => 2 } }) }
+  end
+
+  def test_each_and_count
+    (101..150).each do |i|
+      @table.put(i, 'cf1:a' => i, 'cf2:b' => i, 'cf3:c' => i * 3)
+    end
+
+    assert_instance_of HBase::Scoped, @table.each
+    scoped = @table.each
+    assert_equal scoped, scoped.each
+
+    assert_equal 50, @table.count
+    assert_equal 50, @table.each.count
+    assert_equal 50, @table.to_a.length # each
+
+    # Start key
+    assert_equal 40,  @table.range(111).count
+
+    # Stop key (exclusive)
+    assert_equal 19,  @table.range(nil, 120).count
+
+    # Start key ~ Stop key (exclusive)
+    assert_equal  9,  @table.range(111, 120).count
+
+    # Start key ~ Stop key (exclusive)
+    assert_equal  9,  @table.range(111...120).count
+
+    # Start key ~ Stop key (inclusive)
+    assert_equal 10,  @table.range(111..120).count
+
+    # Start key ~ Stop key (inclusive) + limit
+    begin
+      assert_equal 5, @table.range(111..120).limit(5).count
+    rescue NotImplementedError
+    end
+
+    # Start key ~ Stop key (inclusive) + filters
+    assert_equal 10,  @table.range(111..150).filter('cf1:a' => 131..140).count
+    assert_equal 9,   @table.range(111..150).filter('cf1:a' => 131...140).count
+    assert_equal 2,   @table.range(111..150).filter('cf1:a' => 131...140, 'cf2:b' => 132..133).count
+
+    # Unscope
+    assert_equal 50, @table.range(111..150).filter('cf1:a' => 131...140, 'cf2:b' => 132..133).unscope.count
+  end
+  def test_scan
+    insert = lambda do
+      (40..70).each do |i|
+        @table.put(i, 'cf1:a' => i, 'cf2:b' => i * 2, 'cf3:c' => i * 3, 'cf3:d' => 'dummy', 'cf3:e' => 3.14)
+      end
+    end
+    insert.call
+
+    assert_instance_of HBase::Scoped, @table.each
+
+    # Test both for HBase::Table and HBase::Scoped
+    [@table, @table.each].each do |table|
+      # project
+      project_cols = ['cf1:a', 'cf3:c']
+      assert table.project(*project_cols).all? { |result|
+        result.to_hash.keys == project_cols
+      }
+
+      # project: additive
+      assert_equal project_cols + ['cf3:d'], table.project(*project_cols).project('cf3:d').first.to_hash.keys.map(&:to_s)
+
+      # project: family
+      assert_equal %w[cf1:a cf3:c cf3:d cf3:e], table.project('cf1:a', 'cf3').first.to_hash.keys.map(&:to_s)
+
+      # filter: Hash
+      #   to_a.length instead of count :)
+      assert_equal 1,  table.filter('cf1:a' => 50).to_a.length
+      assert_equal 3,  table.filter('cf1:a' => [50, 60, 70]).to_a.length
+      assert_equal 2,  table.filter('cf1:a' => [50, 60, 70], 'cf2:b' => [100, 140]).to_a.length
+      assert_equal 20, table.filter('cf1:a' => [41..50, 55, 61...70]).to_a.length
+      assert_equal 12, table.filter('cf1:a' => [41..50, 61, 70]).to_a.length
+      assert_equal 0,  table.filter('cf1:a' => 50, 'cf2:b' => 60).to_a.length
+      assert_equal 1,  table.filter('cf1:a' => 50, 'cf2:b' => 90..100).to_a.length
+      assert_equal 0,  table.filter('cf1:a' => 50, 'cf2:b' => 90...100).to_a.length
+      assert_equal 6,  table.filter('cf1:a' => 50..60, 'cf2:b' => 100..110).to_a.length
+      assert_equal 10, table.filter('cf1:a' => { :> => 50,  :<= => 60 }).to_a.length
+      assert_equal 9,  table.filter('cf1:a' => { :> => 50,  :<= => 60, :!= => 55 }).to_a.length
+      assert_equal 10, table.filter('cf1:a' => { :>= => 50, :<= => 60, :!= => 55 }).to_a.length
+      assert_equal 9,  table.filter('cf1:a' => { :>= => 50, :< => 60,  :!= => 55 }).to_a.length
+      assert_equal 1,  table.filter('cf1:a' => { :> => 50,  :<= => 60, :== => 55 }).to_a.length
+      assert_equal 2,  table.filter('cf1:a' => { :> => 50,  :<= => 60, :== => [55, 57] }).to_a.length
+      assert_equal 9,  table.filter('cf1:a' => { gte: 50, lt: 60, ne: 55 }).to_a.length
+      assert_equal 7,  table.filter('cf1:a' => { gte: 50, lt: 60, ne: [55, 57, 59] }).to_a.length
+
+      # filter: Hash + additive
+      assert_equal 6, table.filter('cf1:a' => 50..60).filter('cf2:b' => 100..110).to_a.length
+
+      # filter: Java filter
+      # Bug: https://issues.apache.org/jira/browse/HBASE-6954
+      import org.apache.hadoop.hbase.filter.ColumnPaginationFilter
+      assert_equal 3, table.filter(ColumnPaginationFilter.new(3, 1)).first.to_hash.keys.length
+
+      # filter: Java filter list
+      import org.apache.hadoop.hbase.filter.FilterList 
+      import org.apache.hadoop.hbase.filter.ColumnRangeFilter
+      assert_equal %w[cf2:b cf3:c],
+          table.filter(FilterList.new [
+             ColumnRangeFilter.new('a'.to_java_bytes, true, 'd'.to_java_bytes, true),
+             ColumnPaginationFilter.new(2, 1),
+          ]).first.to_hash.keys.map(&:to_s)
+
+
+      # limit with filter
+      begin
+        assert_equal 4, table.filter('cf1:a' => 50..60).filter('cf2:b' => 100..110).limit(4).to_a.length
+      rescue NotImplementedError
+      end
+
+      # caching: How do we know if it's working? TODO
+      assert_equal 6, table.filter('cf1:a' => 50..60).filter('cf2:b' => 100..110).caching(10).to_a.length
+    end
+
+    insert.call
+    [@table, @table.each].each do |table|
+      # versions
+      assert table.all? { |result| result.to_hash_with_versions['cf1:a'].length == 2 }
+      assert table.versions(1).all? { |result| result.to_hash_with_versions['cf1:a'].length == 1 }
+    end
+  end
+
+  def test_scan_on_non_string_rowkey
+    (1..20).each do |rk|
+      @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 8, @table.range(1...9).count
+
+    @table.truncate!
+
+    (1..20).each do |rk|
+      @table.put rk.to_s, 'cf1:a' => rk
+    end
+    assert_equal 20, @table.range('1'..'9').count
+    assert_equal %w[1 10 11 12 13 14 15 16 17 18 19 2 20 3 4 5 6 7 8 9], @table.range('1'..'9').map(&:rowkey)
+
+    assert_equal 19, @table.range('1'...'9').count
+
+    @table.truncate!
+    data = { 'cf1:1' => 1 } # doesn't matter
+    (1..15).each do |i|
+      @table.put i, data
+      @table.put i.to_s, data
+    end
+
+    assert_equal [1, 2, 3], @table.range(1..3).map { |r| r.rowkey :integer }
+    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 @table.project(['cf1', 10], ['cf1', 20]).map { |r|
+      [r.integer(HBase::ColumnKey('cf1', 10)), r.integer(HBase::ColumnKey.new('cf1', 20))]
+    }.all? { |e| e == [10, 20] }
+
+    hash = @table.get('rowkey').to_hash(
+      HBase::ColumnKey('cf1', 1) => :fixnum,
+      HBase::ColumnKey('cf1', 2) => :fixnum,
+    )
+    assert_equal 1, hash[HBase::ColumnKey(:cf1, 1)]
+    assert_equal 2, hash[HBase::ColumnKey(:cf1, 2)]
+    assert_equal 3, HBase::Util.from_bytes(:fixnum, hash[HBase::ColumnKey(:cf1, 3)])
+  end
+
+  def test_table_descriptor
+    assert_instance_of org.apache.hadoop.hbase.client.UnmodifyableHTableDescriptor, @table.descriptor
+
+    # Should be read-only
+    assert_raise {
+      @table.descriptor.setMaxFileSize 100 * 1024 ** 2
+    }
+  end
+
+  def test_null_value
+    10.times do |i|
+      @table.put i, 'cf1:nil' => i % 2 == 0 ? nil : true
+    end
+    assert_equal 10, @table.count
+    assert_equal 5, @table.filter('cf1:nil' => nil).count
+  end
+
+  def test_scoped_get_intra_row_scan
+    # Preparation
+    all_data = {}
+    (1..100).each do |rk|
+      data = {}
+      (1..200).each do |cq|
+        data[HBase::ColumnKey(:cf1, cq)] = rk + cq
+      end
+      all_data[rk] = data
+    end
+    @table.put all_data
+
+    # One simple filter (Rowkey 10 ~ 19)
+    scoped1 = @table.filter(HBase::ColumnKey('cf1', 100) => 110...120)
+    ret = scoped1.get((1..100).to_a)
+    assert_equal 100, ret.count
+    assert_equal 10, ret.compact.count
+
+    # Two filters
+    scoped2 = scoped1.filter(
+      # Rowkey 10 ~ 19 & 9 ~ 14 = 10 ~ 14
+      HBase::ColumnKey('cf1', 1) => 10..15
+    )
+    ret = scoped2.get((1..100).to_a)
+    assert_equal 100, ret.count
+    assert_equal 5, ret.compact.count
+
+    # Range
+    assert_equal 4, scoped2.range(11).get((1..100).to_a).compact.count
+    assert_equal 3, scoped2.range(11..13).get((1..100).to_a).compact.count
+    assert_equal 2, scoped2.range(11...13).get((1..100).to_a).compact.count
+    assert_equal 2, scoped2.range(11, 13).get((1..100).to_a).compact.count
+    assert_equal 3, scoped2.range(nil, 13).get((1..100).to_a).compact.count
+  end
+
+  def test_prefix_filter
+    ('aa'..'zz').each do |rk|
+      @table.put rk, 'cf1:a' => 1
+    end
+
+    assert_equal 26, @table.range(:prefix => 'c').count
+    assert           @table.range(:prefix => 'c').get('cc')
+    assert_nil       @table.range(:prefix => 'c').get('dd')
+    assert           @table.range(:prefix => ['d', 'c']).get('dd')
+    assert_equal 52, @table.range(:prefix => ['a', 'c']).count
+    assert_equal 78, @table.range(:prefix => ['d', 'a', 'c']).count
+    assert_equal 52, @table.range(nil, 'd', :prefix => ['d', 'a', 'c']).count
+    assert_equal 52, @table.range('b', :prefix => ['d', 'a', 'c']).count
+    assert_equal 78, @table.range('a', 'e', :prefix => ['d', 'a', 'c']).count
+  end
+
+  def test_advanced_projection
+    @table.put :rk, Hash[ ('aa'..'zz').map { |cq| [ "cf1:#{cq}", 100 ] } ]
+
+    assert_equal 26,   @table.project(:prefix => 'd').first.count
+    assert_equal 52,   @table.project(:prefix => ['d', 'f']).first.count
+    assert_equal 52,   @table.project(:range => 'b'...'d').first.count
+    assert_equal 105,  @table.project(:range => ['b'...'d', 'x'..'za']).first.count
+    assert_equal 10,   @table.project(:offset => 10, :limit => 10).first.count
+    assert_equal 'da', @table.project(:offset => 26 * 3, :limit => 10).first.first.cq
+    assert_equal 10,   @table.project(:offset => 26 * 3).project(:limit => 10).first.count
+    assert_equal 'da', @table.project(:offset => 26 * 3).project(:limit => 10).first.first.cq
+  end
+
+  def test_batch
+    @table.put :rk, Hash[ ('aa'..'zz').map { |cq| [ "cf1:#{cq}", 100 ] } ]
+
+    assert_equal [10, 10, 6], @table.batch(10).project(:prefix => 'd').map(&:count)
+
+    # # README example
+    # (1..100).each do |rk|
+    #   @table.put rk, Hash[ ('aa'..'zz').map { |cq| [ "cf1:#{cq}", 100 ] } ]
+    # end
+    # scoped = @table.each
+    # scoped.range(1..100).
+    #        project(:prefix => 'c').
+    #        batch(10).
+    #        map { |row| [row.rowkey(:fixnum), row.count].map(&:to_s).join ': ' }
+  end
+end
+