hbase-jruby 0.1.1-java

data/test/test_table.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+
+class TestScoped < TestHBaseJRubyBase 
+  def test_table
+    @hbase.table(TABLE) do |table|
+      assert_equal TABLE, table.name
+      assert table.exists?
+    end
+
+    table = @hbase.table(TABLE)
+    2.times do
+      assert_equal TABLE, table.name
+      assert table.exists?
+      table.close
+      table.close
+
+      # Gets another HTable instance from HTablePool
+      table.put('rowkey' => { 'cf1:a' => 1 })
+    end
+  end
+
+  def test_put_then_get
+    bignum = 123456789123456789123456789
+    # Single record put
+    assert_equal 1, @table.put('row1',
+                               'cf1:a' => 2,
+                               'cf1:b' => 'b',
+                               'cf1:c' => 6.28,
+                               'cf1:d' => false,
+                               'cf1:e' => bignum + 1,
+                               'cf1:f' => :bol,
+                               'cf1:g' => BigDecimal.new("456.123"),
+                               'cf1:str1' => "Goodbye", 'cf1:str2' => "Cruel world")
+    assert_equal 1, @table.put('row1',
+                               'cf1:a' => 1,
+                               'cf1:b' => 'a',
+                               'cf1:c' => 3.14,
+                               'cf1:d' => true,
+                               'cf1:e' => bignum,
+                               'cf1:f' => :sym,
+                               'cf1:g' => BigDecimal.new("123.456"),
+                               'cf1:str1' => "Hello", 'cf1:str2' => "World")
+    # Batch put
+    assert_equal 2, @table.put(
+      'row2' => { 'cf1:a' => 2, 'cf1:b' => 'b', 'cf1:c' => 6.28 },
+      'row3' => { 'cf1:a' => 4, 'cf1:b' => 'c', 'cf1:c' => 6.28 })
+
+    # single-get (latest version)
+    assert_equal 'row1', @table.get('row1').rowkey
+    assert_equal 1,      @table.get('row1').fixnum('cf1:a')
+    assert_equal 'a',    @table.get('row1').string('cf1:b')
+    assert_equal 'a',    String.from_java_bytes(@table.get('row1').raw('cf1:b'))
+    assert_equal 3.14,   @table.get('row1').float('cf1:c')
+    assert_equal true,   @table.get('row1').boolean('cf1:d')
+    assert_equal bignum, @table.get('row1').bignum('cf1:e')
+    assert_equal :sym,   @table.get('row1').symbol('cf1:f')
+    assert_equal BigDecimal.new("123.456"), @table.get('row1').bigdecimal('cf1:g')
+
+    # single-get-multi-col
+    assert_equal %w[Hello World], @table.get('row1').string(['cf1:str1', 'cf1:str2'])
+
+    # 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 [bignum, bignum + 1], @table.get('row1').bignums('cf1:e').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 @table.get('row1').fixnums('cf1:a').keys.all? { |k| k.instance_of? Fixnum }
+
+    # single-get-multi-col-multi=ver
+    ret = @table.get('row1').strings(['cf1:str1', 'cf1:str2'])
+    assert_equal ['Hello', 'World'], ret.map(&:values).map(&:first)
+    assert_equal ['Goodbye', 'Cruel world'], ret.map(&:values).map(&:last)
+
+    # 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 [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')
+
+    # Row not found
+    assert_equal nil,    @table.get('xxx')
+  end
+
+  def test_to_hash
+    data = {
+      'cf1:a' => 'Hello',
+      'cf1:b' => 200,
+      'cf1:c' => 3.14,
+      'cf2:d' => :world,
+      'cf2:e' => false,
+      'cf3:f' => 1234567890123456789012345678901234567890,
+      'cf3'   => true
+    }
+    schema = {
+      'cf1:a' => :string,
+      'cf1:b' => :integer,
+      'cf1:c' => :float,
+      HBase::ColumnKey(:cf2, :d) => :symbol,
+      HBase::ColumnKey(:cf2, :e) => :boolean,
+      HBase::ColumnKey(:cf3, :f) => :biginteger,
+      'cf3'   => :boolean
+    }
+    @table.put('row1', data)
+    @table.put('row2', 'cf1:a' => 'Goodbye')
+
+    assert_equal data, @table.get('row1').to_hash(schema).map { |k, v| { k.to_s => v } }.inject(:merge)
+    assert_equal 1,    @table.get('row1').to_hash_with_versions(schema)['cf1:a'].length
+    assert_equal 1,    @table.get('row1').to_hash_with_versions(schema)[HBase::ColumnKey(:cf1, :a)].length
+
+    # Better testing for versioned values
+    @table.put('row1', data)
+    assert_equal data, @table.get('row1').to_hash(schema).map { |k, v| { k.to_s => v } }.inject(:merge)
+
+    assert_equal 2, @table.get('row1').to_hash_with_versions(schema)['cf1:a'].length
+    assert_equal 1, @table.get('row1').to_hash_with_versions(schema)['cf3:f'].length
+
+    # get option: :versions
+    assert_equal 1, @table.versions(1).get('row1').to_hash_with_versions(schema)['cf1:a'].length
+
+    # scoped get with filters
+    assert_equal 2, @table.get(['row1', 'row2']).count
+    assert_equal 2, @table.range('row1'...'row2').get(['row1', 'row2']).count
+    assert_equal 2, @table.range('row1'..'row2').get(['row1', 'row2']).compact.count
+    assert_equal 1, @table.range('row1'...'row2').get(['row1', 'row2']).compact.count
+    assert_equal 1, @table.range(:prefix => 'row2').get(['row1', 'row2']).compact.count
+    assert_equal 1, @table.filter('cf1:a' => 'Hello').get(['row1', 'row2']).compact.count
+
+    # scoped get with projection
+    assert_equal %w[cf3 cf3:f], @table.project('cf3').get('row1').to_hash.keys.map(&:to_s)
+  end
+
+  def test_increment
+    @table.put('row1', 'cf1:counter' => 1, 'cf1:counter2' => 100)
+    assert_equal 1, @table.get('row1').fixnum('cf1:counter')
+
+    @table.increment('row1', 'cf1:counter', 1)
+    assert_equal 2, @table.get('row1').int('cf1:counter')
+
+    @table.increment('row1', 'cf1:counter', 2)
+    assert_equal 4, @table.get('row1').integer('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')
+  end
+
+  def test_delete
+    @table.put('row1', 'cf1' => 0, 'cf1:a' => 1, 'cf1:b' => 2, 'cf2:c' => 3, 'cf2:d' => 4)
+    sleep 0.1
+    @table.put('row1', 'cf2:d' => 5)
+    sleep 0.1
+    @table.put('row1', 'cf2:d' => 6)
+    versions = @table.get('row1').to_hash_with_versions['cf2:d'].keys
+    assert versions[0] > versions[1]
+    assert versions[1] > versions[2]
+
+    # Deletes a version
+    @table.delete('row1', 'cf2:d', versions[0], versions[2])
+    new_versions = @table.get('row1').to_hash_with_versions['cf2:d'].keys
+    assert_equal new_versions, [versions[1]]
+
+    # Deletes a column
+    assert_equal 3, @table.get('row1').integer('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')
+    @table.delete('row1', 'cf1:')
+    assert_equal 1, @table.get('row1').integer('cf1:a')
+    assert_equal 2, @table.get('row1').integer('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')
+    @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']
+
+    # Deletes a row
+    @table.delete('row1')
+    assert_nil @table.get('row1')
+
+    # Batch delete
+    @table.put('row2', 'cf1:a' => 1)
+    @table.put('row3', 'cf1:a' => 1, 'cf1:b' => 2)
+
+    @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')
+  end
+end
+

data/test/test_table_admin.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+
+class TestTableAdmin < TestHBaseJRubyBase 
+  def teardown
+    @table.drop! if @table.exists?
+  end
+
+  def test_create_table_symbol_string
+    t = @hbase.table(:test_hbase_jruby_create_table)
+    t.drop! if t.exists?
+    [ :cf, 'cf', :cf => {} ].each do |cf|
+      assert_false t.exists?
+      t.create! cf
+      assert t.exists?
+      t.drop!
+    end
+  end
+
+  def test_disable_and_drop
+    @table.disable!
+    @table.disable!
+    @table.drop!
+    assert_false @table.exists?
+  end
+
+  def test_create_table_props
+    max_fs = 1024 ** 3
+    @table.drop!
+    @table.create!({ :cf1 => {}, :cf2 => {} }, :max_filesize => max_fs)
+    assert_equal max_fs, @table.descriptor.get_max_file_size
+
+    max_fs = 300 * 1024 ** 2
+    @table.drop!
+    @table.create! :cf1, :max_filesize => max_fs
+    assert_equal max_fs, @table.descriptor.get_max_file_size
+  end
+
+  def test_create_table_invalid_input
+    @table.drop!
+    assert_raise(ArgumentError) do
+      @table.create! 3.14
+    end
+
+    assert_raise(ArgumentError) do
+      @table.create! :cf1 => { :bloom => 'by beach house' }
+    end
+
+    assert_raise(ArgumentError) do
+      @table.create! :cf1 => { :bloomfilter => :xxx }
+    end
+  end
+
+  def test_enabled_disabled
+    assert @table.enabled?
+    assert !@table.disabled?
+    @table.disable!
+    assert !@table.enabled?
+    assert @table.disabled?
+    @table.enable!
+    assert @table.enabled?
+    assert !@table.disabled?
+  end
+
+# def test_rename!
+#   new_name = TABLE + '_new'
+#   @table.rename! new_name
+#   assert_equal new_name, @table.name
+#   assert_equal new_name, @table.descriptor.get_name_as_string
+#   @table.drop!
+# end
+
+  def test_table_properties
+    assert_raise(ArgumentError) do
+      @table.alter! :hello => :world
+    end
+
+    max_fs = 512 * 1024 ** 2
+    mem_fs =  64 * 1024 ** 2
+    
+    @table.alter!(
+      :max_filesize       => max_fs,
+      :memstore_flushsize => mem_fs,
+      :readonly           => false,
+      :deferred_log_flush => true
+    )
+    
+    assert_equal max_fs, @table.descriptor.get_max_file_size
+    assert_equal mem_fs, @table.descriptor.get_mem_store_flush_size
+    assert_equal false,  @table.descriptor.is_read_only
+    assert_equal true,   @table.descriptor.is_deferred_log_flush
+  end
+
+  def test_column_family_alteration!
+    assert @table.descriptor.getFamilies.map(&:getNameAsString).include?('cf2')
+    @table.delete_family! :cf2
+    assert !@table.descriptor.getFamilies.map(&:getNameAsString).include?('cf2')
+    @table.add_family! :cf4, {}
+    assert @table.descriptor.getFamilies.map(&:getNameAsString).include?('cf4')
+
+    # TODO: test more props
+    @table.alter_family! :cf4, :versions => 10
+    assert_equal 10, @table.descriptor.getFamilies.select { |cf| cf.getNameAsString == 'cf4' }.first.getMaxVersions
+
+    assert_raise(ArgumentError) {
+      @table.alter_family! :cf4, :hello => 'world'
+    }
+    assert_raise(ArgumentError) {
+      @table.alter_family! :cf4, :bloomfilter => :xxx
+    }
+  end
+
+  def test_inspect
+    @table.drop!
+    assert "{NAME => '#{TABLE}'}", @table.inspect # FIXME
+
+    @table.create! :cf => {
+      :blockcache          => true,
+      :blocksize           => 128 * 1024,
+      :bloomfilter         => :row,
+      :compression         => :snappy,
+    # :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 'SNAPPY', 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]
+  end
+end
+

data/test/test_util.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'helper'
+require 'bigdecimal'
+
+class TestUtil < Test::Unit::TestCase
+  Util = HBase::Util
+
+  def test_bytea_conversion
+    Util.import_java_classes!
+
+    [:fixnum, :int, :integer].each do |type|
+      assert_equal 100, Util.from_bytes( type, Util.to_bytes(100) )
+    end
+    [:float, :double].each do |type|
+      assert_equal 3.14, Util.from_bytes( type, Util.to_bytes(3.14) )
+    end
+    [:bignum, :biginteger, :bigint].each do |type|
+      assert_equal 12345678901234567890, Util.from_bytes( type, Util.to_bytes(12345678901234567890) )
+    end
+    [:string, :str].each do |type|
+      assert_equal "Hello", Util.from_bytes( type, Util.to_bytes("Hello") )
+    end
+    [:bool, :boolean].each do |type|
+      assert_equal true,  Util.from_bytes( type, Util.to_bytes(true) )
+      assert_equal false, Util.from_bytes( type, Util.to_bytes(false) )
+    end
+    [:symbol, :sym].each do |type|
+      assert_equal :hello, Util.from_bytes( type, Util.to_bytes(:hello) )
+    end
+
+    bd  = BigDecimal.new("123456789.123456789")
+    jbd = java.math.BigDecimal.new("9876543210.987654321")
+    [:bigdecimal].each do |type|
+      assert_equal bd,  Util.from_bytes( type, Util.to_bytes(bd) )
+      assert_equal jbd, Util.from_bytes( type, Util.to_bytes(jbd) )
+    end
+
+    assert_equal String.from_java_bytes("asdf".to_java_bytes),
+                 String.from_java_bytes( Util.from_bytes( :raw, "asdf".to_java_bytes ) )
+
+    assert_equal 0, Util.to_bytes(nil).length
+
+    assert_raise(ArgumentError) { Util.from_bytes(:xxx, [].to_java(Java::byte)) }
+    assert_raise(ArgumentError) { Util.to_bytes({}) }
+  end
+
+  def test_parse_column_name
+    assert_equal ['abc', 'def'],  parse_to_str('abc:def') 
+    assert_equal ['abc', 'def:'], parse_to_str('abc:def:') 
+    assert_equal ['abc', ''],     parse_to_str('abc:')
+    assert_equal ['abc', nil],    parse_to_str('abc')
+    assert_equal ['abc', ':::'],  parse_to_str('abc::::')
+
+    assert_equal [:abc, :def],   parse_to_str([:abc, :def], :symbol)
+    assert_equal [123, 456],     parse_to_str([123, 456], :fixnum)
+    assert_equal ['abc', 'def'], parse_to_str(
+                                   org.apache.hadoop.hbase.KeyValue.new(
+                                     'rowkey'.to_java_bytes,
+                                     'abc'.to_java_bytes,
+                                     'def'.to_java_bytes))
+
+    assert_equal [:abc, :def],   parse_to_str(HBase::ColumnKey.new(:abc, :def), :symbol)
+
+    assert_raise(ArgumentError) { Util.parse_column_name(nil) }
+    assert_raise(ArgumentError) { Util.parse_column_name('') }
+
+    assert_equal nil, Util.from_bytes(:string, nil)
+  end
+
+  def test_append_0
+    assert_equal [97, 97, 97, 0], Util.append_0("aaa".to_java_bytes).to_a
+  end
+
+private
+  def parse_to_str v, type = :string
+    Util.parse_column_name(v).map { |e| Util.from_bytes type, e }
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: hbase-jruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: java
+authors:
+- Junegunn Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby-esque interface for accessing HBase from JRuby
+email:
+- junegunn.c@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hbase-jruby.gemspec
+- lib/hbase-jruby.rb
+- lib/hbase-jruby/admin.rb
+- lib/hbase-jruby/byte_array.rb
+- lib/hbase-jruby/cell.rb
+- lib/hbase-jruby/column_key.rb
+- lib/hbase-jruby/dependency.rb
+- lib/hbase-jruby/hbase.rb
+- lib/hbase-jruby/pom/cdh3u5.xml
+- lib/hbase-jruby/pom/cdh4.1.2.xml
+- lib/hbase-jruby/result.rb
+- lib/hbase-jruby/scoped.rb
+- lib/hbase-jruby/table.rb
+- lib/hbase-jruby/util.rb
+- lib/hbase-jruby/version.rb
+- test/helper.rb
+- test/test_byte_array.rb
+- test/test_cell.rb
+- test/test_column_key.rb
+- test/test_hbase.rb
+- test/test_scoped.rb
+- test/test_table.rb
+- test/test_table_admin.rb
+- test/test_util.rb
+homepage: https://github.com/junegunn/hbase-jruby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby-esque interface for accessing HBase from JRuby
+test_files:
+- test/helper.rb
+- test/test_byte_array.rb
+- test/test_cell.rb
+- test/test_column_key.rb
+- test/test_hbase.rb
+- test/test_scoped.rb
+- test/test_table.rb
+- test/test_table_admin.rb
+- test/test_util.rb
+has_rdoc: