hbase-jruby 0.1.6-java → 0.2.0-java

data/test/test_hbase.rb

@@ -6,15 +6,22 @@ require 'helper'
 class TestHBase < TestHBaseJRubyBase
   def test_tables
     assert @hbase.table_names.include?(TABLE)
+    assert @hbase.list.include?(TABLE)
     assert @hbase.tables.map(&:name).include?(TABLE)
   end
 
   def test_close
+    table = @hbase[TABLE]
+    table.exists?
+    assert @hbase.list.is_a?(Array)
+
+    assert !@hbase.closed?
     @hbase.close
+    assert @hbase.closed?
 
-    # TODO: Still usable after close?
-    assert @hbase.table_names.include?(TABLE)
-    assert_equal 1, @table.put('rowkey' => { 'cf1:a' => 1 })
+    assert_raise(RuntimeError) { @hbase.list }
+    assert_raise(RuntimeError) { table.exists? }
+    assert_raise(RuntimeError) { table.drop! }
   end
 
   def test_admin

data/test/test_scoped.rb

@@ -378,5 +378,40 @@ class TestScoped < TestHBaseJRubyBase
     # Fails on 0.1.3
     assert_equal 1,   @table.range(:prefix => (HBase::ByteArray(50) + HBase::ByteArray(50)).java).count
   end
+
+  def test_time_range_at
+    t1, t2, t3, t4 =
+      Time.now - 4000,
+      Time.now - 3000,
+      Time.now - 2000,
+      Time.now - 1000
+    @table.put :rowkey1 => { 'cf1:a' => { t1 => 1 } }
+    @table.put :rowkey2 => { 'cf1:a' => { t2 => 2 } }
+    @table.put :rowkey3 => { 'cf1:a' => { t3 => 3 } }
+    @table.put :rowkey4 => { 'cf1:a' => { t4 => 4 } }
+
+    assert_equal 1, @table.time_range(t2, t3).count
+    assert_equal 2, @table.time_range(t2, t3 + 1).count
+    assert_equal 2, @table.time_range(t2, t4).count
+    assert_equal 4, @table.time_range(0, t4 + 1).count
+
+    assert_equal [2, 3], @table.time_range(t2, t4).map { |r| r.fixnum 'cf1:a' }.sort
+    assert_equal %w[rowkey2 rowkey3], @table.time_range(t2, t4).map { |r| r.rowkey :string }.sort
+
+    assert_equal 1,   @table.at(t2).count
+    assert_equal 0,   @table.at(t2 - 1).count
+    assert_equal 0,   @table.at(t2 + 1).count
+    assert_equal [2], @table.at(t2).map { |r| r.fixnum 'cf1:a' }
+
+    @table.put :rowkey5 => { 'cf1:a' => { t1 => 'a', t4 => 'A' }, 'cf1:b' => { t4 => 'B' }}
+    assert_equal 'A', @table.get(:rowkey5).string('cf1:a')
+    assert_equal 'B', @table.get(:rowkey5).string('cf1:b')
+
+    assert_equal 'a', @table.time_range(t1, t3).get(:rowkey5).string('cf1:a')
+    assert_equal nil, @table.time_range(t1, t3).get(:rowkey5).string('cf1:b')
+
+    # according to current hbase impl, later call overrides the previous time ranges. but, why do this?
+    assert_equal 2, @table.time_range(t2, t3).at(t1).count
+  end
 end
 

data/test/test_table.rb

@@ -4,23 +4,33 @@ $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
 require 'bigdecimal'
 
-class TestScoped < TestHBaseJRubyBase
-  def test_table
+class TestTable < TestHBaseJRubyBase
+  def test_table_block
     @hbase.table(TABLE) do |table|
       assert_equal TABLE, table.name
       assert table.exists?
     end
+  end
 
+  def test_table_htable
+    htables = []
     table = @hbase.table(TABLE)
-    2.times do
-      assert_equal TABLE, table.name
-      assert table.exists?
-      table.close
-      table.close
+    4.times do
+      htables << table.htable
+    end
+    assert_equal 1, htables.uniq.length
 
-      # Gets another HTable instance from HTablePool
-      table.put('rowkey' => { 'cf1:a' => 1 })
+    # Multi-threaded
+    htables = []
+    table = @hbase.table(TABLE)
+    4.times do
+      Thread.new {
+        htables << table.htable
+      }.join
     end
+    assert_equal 4, htables.uniq.length
+
+    assert_equal @hbase.table(TABLE).htable, @hbase[TABLE].htable
   end
 
   def test_put_then_get
@@ -75,18 +85,18 @@ class TestScoped < TestHBaseJRubyBase
     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
-    assert_equal %w[a b],              @table.get('row1').strings('cf1:b').values
-    assert_equal %w[a b],              @table.get('row1').raws('cf1:b').values.map { |v| String.from_java_bytes v }
-    assert_equal [3.14, 6.28],         @table.get('row1').floats('cf1:c').values
-    assert_equal [true, false],        @table.get('row1').booleans('cf1:d').values
-    assert_equal [:sym, :bol],         @table.get('row1').symbols('cf1:f').values
+    assert_equal [1, 2],        @table.get('row1').fixnums('cf1:a').values
+    assert_equal %w[a b],       @table.get('row1').strings('cf1:b').values
+    assert_equal %w[a b],       @table.get('row1').raws('cf1:b').values.map { |v| String.from_java_bytes v }
+    assert_equal [3.14, 6.28],  @table.get('row1').floats('cf1:c').values
+    assert_equal [true, false], @table.get('row1').booleans('cf1:d').values
+    assert_equal [:sym, :bol],  @table.get('row1').symbols('cf1:f').values
     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_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 }
 
@@ -102,15 +112,15 @@ class TestScoped < TestHBaseJRubyBase
     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').fixnum('cf1:xxx')
+    assert_equal nil, @table.get('row1').symbol('cf1:xxx')
+    assert_equal nil, @table.get('row1').fixnum('cf1:xxx')
 
     # Unavailable columns (plural form)
-    assert_equal({},    @table.get('row1').strings('cf1:xxx'))
-    assert_equal({},    @table.get('row1').strings('cfx:xxx'))
+    assert_equal({}, @table.get('row1').strings('cf1:xxx'))
+    assert_equal({}, @table.get('row1').strings('cfx:xxx'))
 
     # Row not found
-    assert_equal nil,    @table.get('xxx')
+    assert_equal nil, @table.get('xxx')
   end
 
   # Put added after a delete is overshadowed if its timestamp is older than than that of the tombstone
@@ -134,7 +144,7 @@ class TestScoped < TestHBaseJRubyBase
       'cf1:a' => {
         1250000000000 => 'A1',
         1260000000000 => 'A2',
-        1270000000000 => 'A3',
+        Time.at(1270000000) => 'A3', # Ruby Time support
       },
     }
 
@@ -218,8 +228,8 @@ class TestScoped < TestHBaseJRubyBase
     assert versions[0] > versions[1]
     assert versions[1] > versions[2]
 
-    # Deletes a version
-    @table.delete('row1', 'cf2:d', versions[0], versions[2])
+    # Deletes a version (Fixnum and Time as timestamps)
+    @table.delete('row1', 'cf2:d', versions[0], Time.at(versions[2] / 1000.0))
     new_versions = @table.get('row1').to_hash_with_versions['cf2:d'].keys
     assert_equal new_versions, [versions[1]]
 

data/test/test_table_admin.rb

@@ -11,11 +11,25 @@ class TestTableAdmin < TestHBaseJRubyBase
   def test_create_table_symbol_string
     t = @hbase.table(:test_hbase_jruby_create_table)
     t.drop! if t.exists?
+
+    assert_raise(ArgumentError) do
+      t.create! :cf, :splits => :xxx
+    end
+
+    assert_raise(ArgumentError) do
+      t.create! :cf => { 1 => 2 }
+    end
+
+    assert_raise(ArgumentError) do
+      t.create! :cf, { 1 => 2 }
+    end
+
     [ :cf, 'cf', {:cf => {}} ].each do |cf|
       assert_false t.exists?
       t.create! cf
       assert t.exists?
       t.drop!
+
     end
   end
 
@@ -78,6 +92,10 @@ class TestTableAdmin < TestHBaseJRubyBase
     assert_raise(ArgumentError) do
       @table.alter! :hello => :world
     end
+    assert_raise(ArgumentError) do
+      # Splits not allowed
+      @table.alter! :readonly => :true, :splits => [1, 2, 3]
+    end
 
     max_fs = 512 * 1024 ** 2
     mem_fs =  64 * 1024 ** 2
@@ -138,39 +156,108 @@ class TestTableAdmin < TestHBaseJRubyBase
     @table.drop!
   end
 
-  def test_inspect
+  def test_inspection
+    assert @table.inspect.is_a?(String)
     @table.drop!
-    assert "{NAME => '#{TABLE}'}", @table.inspect # FIXME
-
-    @table.create! :cf => {
-      :blockcache          => true,
-      :blocksize           => 128 * 1024,
-      :bloomfilter         => :row,
-      :compression         => :gzip,
-    # :data_block_encoding => org.apache.hadoop.hbase.io.encoding.DataBlockEncoding::DIFF,
-    # :encode_on_disk      => true,
-    # :keep_deleted_cells  => true,
-      :in_memory           => true,
-      :min_versions        => 5,
-      :replication_scope   => 0,
-      :ttl                 => 100,
-      :versions            => 10,
-    }
-    props = eval @table.inspect.gsub(/([A-Z_]+) =>/) { ":#{$1.downcase} =>" }
-    assert_equal TABLE, props[:name]
-    cf = props[:families].first
-    assert_equal 'cf', cf[:name]
-    assert_equal 'ROW', cf[:bloomfilter]
-    assert_equal '0', cf[:replication_scope]
-    assert_equal '10', cf[:versions]
-    assert_equal 'GZIP', cf[:compression]
-    assert_equal '5', cf[:min_versions]
-    assert_equal '100', cf[:ttl]
-    assert_equal '131072', cf[:blocksize]
-    assert_equal 'true', cf[:in_memory]
-    assert_equal 'true', cf[:blockcache]
+    assert @table.inspect.is_a?(String)
 
-    @table.drop!
+    [
+      'GZ',
+      :gz,
+      org.apache.hadoop.hbase.io.hfile.Compression::Algorithm::GZ
+    ].each do |cmp|
+      @table.create!({
+          :cf => {
+            :blockcache          => true,
+            :blocksize           => 128 * 1024,
+            :bloomfilter         => :row, # as Symbol
+            :compression         => cmp,  # as String, Symbol, java.lang.Enum
+            :compression_compact => cmp,  # as String, Symbol, java.lang.Enum
+          # TODO
+          # :data_block_encoding => :diff,
+          # :encode_on_disk      => true,
+          # :keep_deleted_cells  => true,
+            :in_memory           => true,
+            :min_versions        => 5,
+            :replication_scope   => 0,
+            :ttl                 => 100,
+            :versions            => 10,
+          }
+        },
+        :max_filesize       => 512 * 1024 ** 2,
+        :memstore_flushsize => 64 * 1024 ** 2,
+        :readonly           => false,
+        :deferred_log_flush => true,
+        :splits             => [10, 20, 30, 40]
+      )
+
+      # Initial region count
+      regions = @table.regions
+      assert_equal 5, regions.count
+
+      # Table properties
+      props = @table.properties
+      assert_equal true,            props[:deferred_log_flush]
+      assert_equal false,           props[:readonly]
+      assert_equal 64 * 1024 ** 2,  props[:memstore_flushsize]
+      assert_equal 512 * 1024 ** 2, props[:max_filesize]
+
+      rprops = @table.raw_properties
+      assert_equal true.to_s,              rprops['DEFERRED_LOG_FLUSH']
+      assert_equal false.to_s,             rprops['READONLY']
+      assert_equal (64 * 1024 ** 2).to_s,  rprops['MEMSTORE_FLUSHSIZE']
+      assert_equal (512 * 1024 ** 2).to_s, rprops['MAX_FILESIZE']
+
+      # Column family properties
+      cf = @table.families['cf']
+      assert_equal 'ROW',  cf[:bloomfilter]
+      assert_equal 0,      cf[:replication_scope]
+      assert_equal 10,     cf[:versions]
+      assert_equal 'GZ',   cf[:compression]
+      assert_equal 5,      cf[:min_versions]
+      assert_equal 100,    cf[:ttl]
+      assert_equal 131072, cf[:blocksize]
+      assert_equal true,   cf[:in_memory]
+      assert_equal true,   cf[:blockcache]
+
+      rcf = @table.raw_families['cf']
+      assert_equal 'ROW',       rcf['BLOOMFILTER']
+      assert_equal 0.to_s,      rcf['REPLICATION_SCOPE']
+      assert_equal 10.to_s,     rcf['VERSIONS']
+      assert_equal 'GZ',        rcf['COMPRESSION']
+      assert_equal 5.to_s,      rcf['MIN_VERSIONS']
+      assert_equal 100.to_s,    rcf['TTL']
+      assert_equal 131072.to_s, rcf['BLOCKSIZE']
+      assert_equal true.to_s,   rcf['IN_MEMORY']
+      assert_equal true.to_s,   rcf['BLOCKCACHE']
+
+      @table.put 31, 'cf:a' => 100
+      @table.put 37, 'cf:a' => 100
+      @table.split!(35)
+
+      # FIXME
+      10.times do |i|
+        break if @table.regions.count == 6
+        sleep 1
+        assert false, "Region not split" if i == 9
+      end
+
+      @table.put 39, 'cf:a' => 100
+      @table.split!(38)
+
+      # FIXME
+      10.times do |i|
+        break if @table.regions.count == 7
+        sleep 1
+        assert false, "Region not split" if i == 9
+      end
+
+      regions = @table.regions
+      assert_equal [10, 20, 30, 35, 38, 40], regions.map { |r| HBase::Util.from_bytes :fixnum, r[:start_key] }.compact.sort
+      assert_equal [10, 20, 30, 35, 38, 40], regions.map { |r| HBase::Util.from_bytes :fixnum, r[:end_key] }.compact.sort
+
+      @table.drop!
+    end
   end
 end unless ENV['HBASE_JRUBY_TEST_SKIP_ADMIN']
 

metadata

@@ -2,14 +2,14 @@
 name: hbase-jruby
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.1.6
+  version: 0.2.0
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-01-19 00:00:00.000000000 Z
+date: 2013-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -73,6 +73,8 @@ files:
 - lib/hbase-jruby/scoped.rb
 - lib/hbase-jruby/scoped/aggregation.rb
 - lib/hbase-jruby/table.rb
+- lib/hbase-jruby/table/admin.rb
+- lib/hbase-jruby/table/inspection.rb
 - lib/hbase-jruby/util.rb
 - lib/hbase-jruby/version.rb
 - test/helper.rb