hbase-jruby 0.3.2-java → 0.3.3-java

data/CHANGELOG.md

@@ -1,6 +1,21 @@
 Changelog
 =========
 
+0.3.3
+-----
+
+0.3.3 changes the way null values are handled, and introduces interface for CAS operations.
+It is strongly advised that you upgrade to 0.3.3 since it contains important fixes.
+
+- [PUT will not store null values](https://github.com/junegunn/hbase-jruby/issues/15)
+- `filter(column: nil)` will match rows without the column
+- `filter(column: value)` will *NOT* match rows without the column
+  - However, `filter(column: { ne: value })` *WILL* match rows without the column
+- [Added `HBase::Table#check` method for check-and-put and check-and-delete operations](https://github.com/junegunn/hbase-jruby/issues/14)
+  - `bool = table.check(1, in_print: false).delete(:price)`
+  - `bool = table.check(1, in_print: true).put(price: 100)`
+- Fix: invalid count when filter is used
+
 0.3.2
 -----
 - Added CDH4.3 dependency profile

data/README.md

@@ -24,23 +24,25 @@ hbase = HBase.new
 
 # Define table schema for easier data access
 hbase.schema = {
+  # Schema for `book` table
   book: {
     # Columns in cf1 family
     cf1: {
-      title:    :string,
+      title:    :string,     # String (UTF-8)
       author:   :string,
       category: :string,
-      year:     :short,
-      pages:    :fixnum,
-      price:    :bigdecimal,
-      weight:   :float,
-      in_print: :boolean
+      year:     :short,      # Short integer (2-byte)
+      pages:    :int,        # Integer (4-byte)
+      price:    :bigdecimal, # BigDecimal
+      weight:   :float,      # Double-precision floating-point number
+      in_print: :boolean,    # Boolean (true | false)
+      image:    :raw         # Java byte array; no automatic type conversion
     },
     # Columns in cf2 family
     cf2: {
-      summary: :string,
-      reviews: :fixnum,
-      stars:   :fixnum,
+      summary:  :string,
+      reviews:  :fixnum,     # Long integer (8-byte)
+      stars:    :fixnum,
       /^comment\d+/ => :string
     }
   }
@@ -54,7 +56,7 @@ unless table.exists?
 end
 
 # PUT
-table.put 1 => {
+table.put 1,
   title:     'The Golden Bough: A Study of Magic and Religion',
   author:    'Sir James G. Frazer',
   category:  'Occult',
@@ -63,12 +65,12 @@ table.put 1 => {
   price:     BigDecimal('21.50'),
   weight:    3.0,
   in_print:  true,
+  image:     File.open('thumbnail.png', 'rb') { |f| f.read }.to_java_bytes,
   summary:   'A wide-ranging, comparative study of mythology and religion',
   reviews:   52,
   stars:     226,
   comment1:  'A must-have',
   comment2:  'Rewarding purchase'
-}
 
 # GET
 book     = table.get(1)
@@ -78,12 +80,12 @@ as_hash  = book.to_h
 
 # SCAN
 table.range(0..100)
+     .project(:cf1, :reviews, :summary)
      .filter(year:     1880...1900,
              in_print: true,
              category: ['Comics', 'Fiction', /cult/i],
              price:    { lt: BigDecimal('30.00') },
              summary:  /myth/i)
-     .project(:cf1, :reviews)
      .each do |book|
 
   # Update columns
@@ -92,8 +94,8 @@ table.range(0..100)
   # Atomic increment
   table.increment book.rowkey, reviews: 1, stars: 5
 
-  # Delete a column
-  table.delete book.rowkey, :comment1
+  # Delete two columns
+  table.delete book.rowkey, :comment1, :comment2
 end
 
 # Delete row
@@ -228,20 +230,21 @@ hbase.schema = {
   book: {
     # Columns in cf1 family
     cf1: {
-      title:    :string,
+      title:    :string,     # String (UTF-8)
       author:   :string,
       category: :string,
-      year:     :short,
-      pages:    :fixnum,
-      price:    :bigdecimal,
-      weight:   :float,
-      in_print: :boolean
+      year:     :short,      # Short integer (2-byte)
+      pages:    :int,        # Integer (4-byte)
+      price:    :bigdecimal, # BigDecimal
+      weight:   :float,      # Double-precision floating-point number
+      in_print: :boolean,    # Boolean (true | false)
+      image:    :raw         # Java byte array; no automatic type conversion
     },
     # Columns in cf2 family
     cf2: {
-      summary: :string,
-      reviews: :fixnum,
-      stars:   :fixnum,
+      summary:  :string,
+      reviews:  :fixnum,     # Long integer (8-byte)
+      stars:    :fixnum,
       /^comment\d+/ => :string
     }
   }
@@ -266,13 +269,12 @@ table.put 'rowkey1' => { title: 'foo',    year: 2013 },
           'rowkey3' => { title: 'foobar', year: 2015 }
 
 # Putting values with timestamps
-table.put 'rowkey1' => {
-    title: {
-      1353143856665 => "Hello world",
-      1352978648642 => "Goodbye world"
-    },
-    year: 2013
-  }
+table.put 'rowkey1',
+  title: {
+    1353143856665 => "Hello world",
+    1352978648642 => "Goodbye world"
+  },
+  year: 2013
 ```
 
 ### GET
@@ -322,12 +324,11 @@ Hash is returned with which you can also reference them with `FAMILY:QUALIFIER`
 notation or `[cf, cq]` array notation.
 
 ```ruby
-table.put 1000 => {
+table.put 1000,
   title:      'Hello world', # Known column
   comment100: 'foo',         # Known column
   'cf2:extra' => 'bar',      # Unknown column
   [:cf2, 10]  => 'foobar'    # Unknown column, non-string qualifier
-}
 
 book = table.get 10000
 hash = book.to_h
@@ -389,26 +390,35 @@ cells = row.to_a
 ### DELETE
 
 ```ruby
-# Deletes a row
+# Delete a row
 table.delete('rowkey1')
 
-# Deletes all columns in the specified column family
+# Delete all columns in the specified column family
 table.delete('rowkey1', :cf1)
 
-# Deletes a column
+# Delete a column
 table.delete('rowkey1', :author)
 
-# Deletes a column with empty qualifier.
+# Delete multiple columns
+table.delete('rowkey1', :author, :title, :image)
+
+# Delete a column with empty qualifier.
 # (!= deleing the entire columns in the family. See the trailing colon.)
 table.delete('rowkey1', 'cf1:')
 
-# Deletes a version of a column
+# Delete a version of a column
 table.delete('rowkey1', :author, 1352978648642)
 
-# Deletes multiple versions of a column
+# Delete multiple versions of a column
 table.delete('rowkey1', :author, 1352978648642, 1352978649642)
 
-# Batch delete
+# Delete multiple versions of multiple columns
+# - Two versions of :author
+# - One version of :title
+# - All versions of :image
+table.delete('rowkey1', :author, 1352978648642, 1352978649642, :title, 1352978649642, :image)
+
+# Batch delete; combination of aforementioned arguments each given as an Array
 table.delete(['rowkey1'], ['rowkey2'], ['rowkey3', :author, 1352978648642, 135297864964])
 ```
 
@@ -421,6 +431,19 @@ table.delete_row 'rowkey1'
 table.delete_row 'rowkey1', 'rowkey2', 'rowkey3'
 ```
 
+### Checked PUT and DELETE
+
+```ruby
+table.check(:rowkey, in_print: false)
+     .put(in_print: true, price: BigDecimal('10.0'))
+
+table.check(:rowkey, in_print: false)
+     .delete(:price, :image)
+       # Takes the same parameters as those of HBase::Table#delete
+       # except for the first rowkey
+       #   https://github.com/junegunn/hbase-jruby#delete
+```
+
 ### Atomic increment of column values
 
 ```ruby
@@ -567,9 +590,12 @@ table.range(nil, 1000).
         year: 2013,
 
         # Range of numbers or characters: Checks if the value falls within the range
-        weight: 2.0..4.0
+        weight: 2.0..4.0,
         author: 'A'..'C'
 
+        # Will match rows *without* price column
+        price: nil,
+
         # Regular expression: Checks if the value matches the regular expression
         summary: /classic$/i,
 
@@ -995,8 +1021,24 @@ you can then use the special Hash representation of integers.
 table.put({ int: 12345 }, 'cf1:a' => { byte: 100 },   # 1-byte integer
                           'cf1:b' => { short: 200 },  # 2-byte integer
                           'cf1:c' => { int: 300 },    # 4-byte integer
-                          'cf1:4' => 400)             # Ordinary 8-byte integer
+                          'cf1:d' => 400)             # Ordinary 8-byte integer
+
+row = table.get(int: 12345)
+```
+
+The use of these Hash-notations can be minimized if we define table schema as follows.
+
+```ruby
+hbase.schema[table.name] = {
+  cf1: {
+    a: :byte,
+    b: :short,
+    c: :int,
+    d: :fixnum
+  }
+}
 
+table.put({ int: 12345 }, a: 100, b: 200, c: 300, d: 400)
 row = table.get(int: 12345)
 ```
 

data/lib/hbase-jruby/row.rb

@@ -269,7 +269,7 @@ class Row
 
 private
   def get_value col, with_versions = false
-    cf, cq = Util.parse_column_name(col)
+    cf, cq, _ = @table.lookup_and_parse col
     if with_versions
       # Need to make it a Ruby hash:
       #   Prevents implicit conversion from ruby type to java type when updating the Hash

data/lib/hbase-jruby/scoped.rb

@@ -416,11 +416,13 @@ private
       FilterList.new(FilterList::Operator::MUST_PASS_ALL, [
         SingleColumnValueFilter.new(
           cf, cq,
-          CompareFilter::CompareOp::GREATER_OR_EQUAL, min),
+          CompareFilter::CompareOp::GREATER_OR_EQUAL, min
+        ).tap { |f| f.setFilterIfMissing(true) },
         SingleColumnValueFilter.new(
           cf, cq,
           (val.exclude_end? ? CompareFilter::CompareOp::LESS :
-                              CompareFilter::CompareOp::LESS_OR_EQUAL), max)
+                              CompareFilter::CompareOp::LESS_OR_EQUAL), max
+        ).tap { |f| f.setFilterIfMissing(true) }
       ])
     when Hash
       FilterList.new(FilterList::Operator::MUST_PASS_ALL,
@@ -457,11 +459,15 @@ private
                 FilterList::Operator::MUST_PASS_ONE
               end,
               v.map { |vv|
-                SingleColumnValueFilter.new(cf, cq, operator, Util.to_typed_bytes(type, vv))
+                SingleColumnValueFilter.new(cf, cq, operator, Util.to_typed_bytes(type, vv)).tap { |f|
+                  f.setFilterIfMissing( op != :ne )
+                }
               }
             )
           else
-            SingleColumnValueFilter.new(cf, cq, operator, Util.to_typed_bytes(type, v))
+            SingleColumnValueFilter.new(cf, cq, operator, Util.to_typed_bytes(type, v)).tap { |f|
+              f.setFilterIfMissing( op != :ne )
+            }
           end
         }
       )
@@ -470,12 +476,21 @@ private
         cf, cq,
         CompareFilter::CompareOp::EQUAL,
         RegexStringComparator.new(val.to_s)
+      ).tap { |f| f.setFilterIfMissing(true) }
+    when nil
+      # - has value < '' -> not ok
+      # - no value       -> ok
+      SingleColumnValueFilter.new(
+        cf, cq,
+        CompareFilter::CompareOp::LESS,
+        HBase::Util::JAVA_BYTE_ARRAY_EMPTY
       )
     else
       SingleColumnValueFilter.new(
         cf, cq,
         CompareFilter::CompareOp::EQUAL,
-        Util.to_typed_bytes(type, val))
+        Util.to_typed_bytes(type, val)
+      ).tap { |f| f.setFilterIfMissing(true) }
     end
   end
 
@@ -554,12 +569,8 @@ private
 
       # A filter that will only return the first KV from each row
       # A filter that will only return the key component of each KV
-      filters = [FirstKeyOnlyFilter.new, KeyOnlyFilter.new]
-      if flist = scan.getFilter
-        filters.each do |filter|
-          flist.addFilter filter
-        end
-      else
+      unless scan.getFilter
+        filters = [FirstKeyOnlyFilter.new, KeyOnlyFilter.new]
         scan.setFilter FilterList.new(filters)
       end
     end
@@ -623,12 +634,6 @@ private
     end
   end
 
-  # @private
-  def typed_bytes col, v
-    _, _, type = @table.lookup_schema(col)
-    Util.to_typed_bytes(type || :raw, v)
-  end
-
   def check_closed
     raise RuntimeError, "HBase connection is already closed" if @table.closed?
   end

data/lib/hbase-jruby/table/checked_operation.rb

@@ -0,0 +1,24 @@
+class HBase
+class Table
+  class CheckedOperation
+    def initialize table, rowkey, cf, cq, val
+      @table  = table
+      @rowkey = rowkey
+      @cf     = cf
+      @cq     = cq
+      @val    = val
+    end
+
+    # @param [Hash] props
+    def put props
+      @table.htable.checkAndPut @rowkey, @cf, @cq, @val, @table.send(:make_put, @rowkey, props)
+    end
+
+    # @param [Object] *extra Optional delete specification. Column family, qualifier, and timestamps
+    def delete *extra
+      @table.htable.checkAndDelete @rowkey, @cf, @cq, @val, @table.send(:make_delete, @rowkey, *extra)
+    end
+  end
+end
+end
+

data/lib/hbase-jruby/table.rb

@@ -69,11 +69,17 @@ class Table
   def put *args
     check_closed
 
-    return put(args.first => args.last) if args.length == 2
-
-    puts = args.first.map { |rowkey, props| putify rowkey, props }
-    htable.put puts
-    puts.length
+    case args.length
+    when 1
+      puts = args.first.map { |rowkey, props| make_put rowkey, props }
+      htable.put puts
+      puts.length
+    when 2
+      htable.put make_put(*args)
+      1
+    else
+      raise ArgumentError, 'invalid number of arguments'
+    end
   end
 
   # Deletes data
@@ -83,31 +89,31 @@ class Table
   #   @return [nil]
   #   @example
   #     table.delete('a000')
-  # @overload delete(rowkey, column_family)
-  #   Deletes columns with the given column family from the row
+  # @overload delete(rowkey, *extra)
+  #   Deletes columns in the row.
   #   @param [Object] rowkey
-  #   @param [String] column_family
-  #   @return [nil]
-  #   @example
-  #     table.delete('a000', 'cf1')
-  # @overload delete(rowkey, column)
-  #   Deletes a column
-  #   @param [Object] rowkey
-  #   @param [String, Array] column Column expression in String "FAMILY:QUALIFIER", or in Array [FAMILY, QUALIFIER]
+  #   @param [*Object] extra [Family|Qualifier [Timestamp ...]] ...
   #   @return [nil]
   #   @example
+  #     # A column (with schema)
+  #     table.delete('a000', :title)
+  #     # Two columns (with schema)
+  #     table.delete('a000', :title, :author)
+  #     # A column (without schema)
   #     table.delete('a000', 'cf1:col1')
-  # @overload delete(rowkey, column, *timestamps)
-  #   Deletes specified versions of a column
-  #   @param [Object] rowkey
-  #   @param [String, Array] column Column expression in String "FAMILY:QUALIFIER", or in Array [FAMILY, QUALIFIER]
-  #   @param [*Fixnum] timestamps Timestamps.
-  #   @return [nil]
-  #   @example
-  #     table.delete('a000', 'cf1:col1', 1352978648642)
+  #     # Columns in cf1 family
+  #     table.delete('a000', 'cf1')
+  #     # A version
+  #     table.delete('a000', :author, 1352978648642)
+  #     # Two versions
+  #     table.delete('a000', :author, 1352978648642, 1352978647642)
+  #     # Combination of columns and versions
+  #     table.delete('a000', :author, 1352978648642, 1352978647642,
+  #                          :title,
+  #                          :image, 1352978648642)
   # @overload delete(*delete_specs)
   #   Batch deletion
-  #   @param [Array<Array>] delete_specs
+  #   @param [*Array] delete_specs
   #   @return [nil]
   #   @example
   #     table.delete(
@@ -120,25 +126,7 @@ class Table
 
     specs = args.first.is_a?(Array) ? args : [args]
 
-    htable.delete specs.map { |spec|
-      rowkey, cfcq, *ts = spec
-      if cfcq
-        cf, cq, _ = lookup_and_parse cfcq
-      end
-
-      Delete.new(Util.to_bytes rowkey).tap { |del|
-        if !ts.empty?
-          ts.each do |t|
-            del.deleteColumn cf, cq, time_to_long(t)
-          end
-        elsif cq
-          # Delete all versions
-          del.deleteColumns cf, cq
-        elsif cf
-          del.deleteFamily cf
-        end
-      }
-    }
+    htable.delete specs.map { |spec| spec.empty? ? nil : make_delete(*spec) }.compact
   end
 
   # Delete rows.
@@ -207,10 +195,28 @@ class Table
     Scoped.send(:new, self)
   end
 
+  # Returns CheckedOperation instance for check-and-put and check-and-delete
+  # @param [Object] rowkey
+  # @param [Hash] cond
+  # @return [HBase::Table::CheckedOperation]
+  def check rowkey, cond
+    raise ArgumentError, 'invalid check condition' unless cond.length == 1
+    col, val = cond.first
+
+    cf, cq, type = lookup_and_parse(col)
+
+    # If the passed value is null, the check is for the lack of column
+    CheckedOperation.new self, Util.to_bytes(rowkey),
+      cf, cq,
+      (val.nil? ? nil : Util.to_typed_bytes(type, val))
+  end
+
+  # @private
   def lookup_schema col
     @hbase.schema.lookup @name_sym, col
   end
 
+  # @private
   def lookup_and_parse col
     @hbase.schema.lookup_and_parse @name_sym, col
   end
@@ -228,9 +234,11 @@ private
     raise RuntimeError, "HBase connection is already closed" if @hbase.closed?
   end
 
-  def putify rowkey, props
+  def make_put rowkey, props
     Put.new(Util.to_bytes rowkey).tap { |put|
       props.each do |col, val|
+        next if val.nil?
+
         cf, cq, type = lookup_and_parse col
 
         case val
@@ -243,12 +251,48 @@ private
             # Types: :byte, :short, :int, ...
             else
               put.add cf, cq, Util.to_typed_bytes(t, v)
-            end
+            end unless v.nil?
           end
         else
           put.add cf, cq, Util.to_typed_bytes(type, val)
         end
       end
+      raise ArgumentError, "no column to put" if put.empty?
+    }
+  end
+
+  def make_delete rowkey, *extra
+    Delete.new(Util.to_bytes rowkey).tap { |del|
+      cf = cq = nil
+      prcd = false
+
+      prc = lambda do
+        unless prcd
+          if cq
+            # Delete all versions
+            del.deleteColumns cf, cq
+          elsif cf
+            del.deleteFamily cf
+          end
+        end
+      end
+
+      extra.each do |x|
+        case x
+        when Fixnum, Time
+          if cq
+            del.deleteColumn cf, cq, time_to_long(x)
+            prcd = true
+          else
+            raise ArgumentError, 'qualifier not given'
+          end
+        else
+          prc.call
+          cf, cq, _ = lookup_and_parse x
+          prcd = false
+        end
+      end
+      prc.call
     }
   end
 end#Table

data/lib/hbase-jruby/util.rb

@@ -66,6 +66,7 @@ module Util
     end
 
     def to_typed_bytes type, val
+      return nil               if val.nil?
       return Util.to_bytes val if type.nil?
 
       import_java_classes!
@@ -75,7 +76,7 @@ module Util
       when :byte
         [val].to_java(Java::byte)
       when :boolean, :bool
-        Bytes.to_bytes val
+        Bytes.java_send :toBytes, [Java::boolean], val
       when :int
         Bytes.java_send :toBytes, [Java::int], val
       when :short

data/lib/hbase-jruby/version.rb

@@ -1,5 +1,5 @@
 class HBase
 module JRuby
-  VERSION = '0.3.2'
+  VERSION = '0.3.3'
 end
 end

data/lib/hbase-jruby.rb

@@ -14,6 +14,7 @@ require 'hbase-jruby/schema'
 require 'hbase-jruby/table'
 require 'hbase-jruby/table/admin'
 require 'hbase-jruby/table/inspection'
+require 'hbase-jruby/table/checked_operation'
 require 'hbase-jruby/row'
 require 'hbase-jruby/hbase'
 

data/test/test_schema.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# encoding: utf-8
 
 $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'helper'
@@ -177,10 +178,11 @@ class TestSchema < TestHBaseJRubyBase
         :author   => :string,
         :category => :string,
         :year     => :short,
-        :pages    => :fixnum,
+        :pages    => :int,
         :price    => :bigdecimal,
         :weight   => :float,
-        :in_print => :boolean
+        :in_print => :boolean,
+        :image    => :raw
       },
       # Columns in cf2 family
       :cf2 => {
@@ -201,6 +203,7 @@ class TestSchema < TestHBaseJRubyBase
       :price    => BigDecimal('21.50'),
       :weight   => 3.0,
       :in_print => true,
+      :image    => File.open(__FILE__, 'rb') { |f| f.read }.to_java_bytes, # 안녕?
       :summary  => 'A wide-ranging, comparative study of mythology and religion',
       :reviews  => 52,
       :stars    => 226,
@@ -208,36 +211,52 @@ class TestSchema < TestHBaseJRubyBase
       :comment2 => 'Rewarding purchase'
     }
     table.put 1, data
+    # Since we can't directly compare java byte arrays
+    data[:image] = HBase::ByteArray[ data[:image] ]
 
     # Get data (rowkey: 1)
     book = table.get 1
 
-    assert_equal data, book.to_h
-    assert_equal data[:title], book['title']
+    assert_equal data,            book.to_h.tap { |h| h[:image] = HBase::ByteArray[ h[:image] ] }
+    assert_equal data[:title],    book['title']
     assert_equal data[:comment2], book['comment2']
 
+    assert HBase::Util.java_bytes?(book[:image])
+    if defined?(Encoding) # --1.8
+      assert_equal Encoding::ASCII_8BIT, book[:image].to_s.encoding
+    end
+
     assert_equal true, book.to_H.values.map(&:keys).flatten.all? { |e| e.is_a? Fixnum }
 
     # Scan table
+    assert_equal 1890, table.range(0..100).first[:year]
+    assert_equal 2, table.range(0..100).first.raw(:year).length
+    assert_equal 1, table.range(0..100).filter(:year => 1890).to_a.length
+    assert_equal 1, table.range(0..100).filter(:year => 1890).count
+    assert_equal 1, table.range(0..100).filter(:year => 1880...1900).count
+    cnt = 0
     table.range(0..100).
           filter(:year     => 1880...1900,
                  :in_print => true,
                  :category => ['Comics', 'Fiction', /cult/i],
                  :price    => { :lt => BigDecimal('30.00') },
                  :summary  => /myth/i).
-          project(:cf1, :reviews).
+          project(:cf1, :reviews, :summary).
           each do |book|
 
-      assert_equal data[:title], book[:title]
+      assert_equal data[:title],   book[:title]
       assert_equal data[:reviews], book[:reviews]
-      assert_equal nil, book[:summary]
+      assert_equal data[:summary], book[:summary]
+      assert_equal nil,            book[:comment1]
 
       # Update price
       table.put book.rowkey => { :price => book[:price] + BigDecimal('1') }
 
       # Atomic increment
       table.increment book.rowkey, :reviews => 1, :stars => 5
+      cnt += 1
     end
+    assert_equal 1, cnt
 
     assert_equal data[:price]   + 1.0, table.get(1)[:price]
     assert_equal data[:reviews] + 1,   table.get(1)[:reviews]
@@ -293,5 +312,47 @@ class TestSchema < TestHBaseJRubyBase
     # Drop table for subsequent tests
     table.drop!
   end
+
+  def test_schema_nil_values
+    @hbase.schema[@table.name] = {
+      :cf1 => {
+        :a => :fixnum,
+        :b => :string,
+        :c => :short,
+        :d => :string
+      }
+    }
+
+    assert_raise(ArgumentError) {
+      @table.put 1, :a => nil, :b => nil, :c => nil, 'cf1:z' => nil
+    }
+    @table.put 1, :a => nil, :b => nil, :c => nil, :d => 'yo', 'cf1:z' => 1000
+    h = @table.get(1).to_h
+    assert !h.has_key?(:a)
+    assert !h.has_key?(:b)
+    assert !h.has_key?(:c)
+    assert h.has_key?(:d)
+
+    assert_equal nil,  h[:a]
+    assert_equal nil,  h[:b]
+    assert_equal nil,  h[:c]
+    assert_equal 'yo', h[:d]
+    assert_equal 1000, HBase::Util.from_bytes(:fixnum, h['cf1:z'])
+  end
+
+  def test_schema_delete
+    @hbase.schema[@table.name] = {
+      :cf1 => { :a => :fixnum }
+    }
+
+    @table.put 1, :a => 100
+    assert_equal 100, @table.get(1)[:a]
+    assert_equal 100, @table.get(1)['cf1:a']
+
+    @hbase.schema.delete @table.name
+    assert_equal nil,  @table.get(1)[:a]
+    assert_equal true, HBase::Util.java_bytes?(@table.get(1)['cf1:a'])
+    assert_equal 100,  HBase::Util.from_bytes(:fixnum, @table.get(1)['cf1:a'])
+  end
 end
 

data/test/test_scoped.rb

@@ -278,12 +278,35 @@ class TestScoped < TestHBaseJRubyBase
     }
   end
 
-  def test_null_value
+  def test_empty_value
     10.times do |i|
-      @table.put i, 'cf1:nil' => i % 2 == 0 ? nil : true
+      @table.put i, 'cf1:empty' => i % 2 == 0 ? '' : true
     end
     assert_equal 10, @table.count
-    assert_equal 5, @table.filter('cf1:nil' => nil).count
+    assert_equal 5, @table.filter('cf1:empty' => '').count
+  end
+
+  def test_null_filter
+    10.times do |i|
+      if i % 2 == 0
+        @table.put i, 'cf1:col1' => true
+      else
+        @table.put i, 'cf1:col2' => true
+      end
+    end
+    20.times do |i|
+      @table.put i + 10, 'cf1:col1' => 100, 'cf1:col2' => 100
+    end
+
+    assert_equal 30, @table.count
+    assert_equal 30, @table.filter('cf1:what' => nil).count
+    assert_equal  5, @table.filter('cf1:col1' => nil).count
+    assert_equal  5, @table.filter('cf1:col2' => nil).count
+    assert_equal  5, @table.filter('cf1:col1' => true).count
+    assert_equal  5, @table.filter('cf1:col2' => true).count
+    assert_equal 20, @table.filter('cf1:col1' => 90..100).count
+    assert_equal 20, @table.filter('cf1:col2' => 100..102).count
+    assert_equal 10, @table.filter('cf1:col1' => { :ne => 100 }).count
   end
 
   def test_scoped_get_intra_row_scan

data/test/test_table.rb

@@ -230,6 +230,68 @@ class TestTable < TestHBaseJRubyBase
     assert_equal 2, @table.get('row3').fixnum('cf1:b')
   end
 
+  def test_delete_advanced
+    @table.put('row1', 'cf1' => 0, 'cf1:a' => 1, 'cf1:b' => 2, 'cf2:c' => 3, 'cf2:d' => 4)
+    @table.delete('row1', 'cf1:', 'cf1:b', 'cf2')
+    assert_equal 1, @table.get('row1').to_h.keys.length
+    assert_equal 1, @table.get('row1').fixnum('cf1:a')
+
+    ts = Time.now
+    @table.put('drow2', 'cf1:a' => { 1000 => 1, 2000 => 2, 3000 => 3 },
+                        'cf1:b' => { 4000 => 4, 5000 => 5, 6000 => 6 },
+                        'cf2:c' => 3, 'cf2:d' => 4, 'cf3:e' => 5)
+    @table.delete('drow2', 'cf1:a', 1000, Time.at(2),
+                           'cf2:c',
+                           'cf1:b', 5000,
+                           'cf3')
+
+    assert_equal 3, @table.get('drow2').to_h.keys.length
+
+    assert_equal 1, @table.get('drow2').to_H['cf1:a'].length
+    assert_equal 2, @table.get('drow2').to_H['cf1:b'].length
+    assert_equal 3000, @table.get('drow2').to_H['cf1:a'].keys.first
+    assert_equal [6000, 4000], @table.get('drow2').to_H['cf1:b'].keys
+  end
+
+  def test_delete_advanced_with_schema
+    @hbase.schema[@table.name] = {
+      :cf1 => {
+        :a => :int,
+        :b => :short,
+      },
+      :cf2 => {
+        :c => :long,
+        :d => :byte
+      },
+      :cf3 => {
+        :e => :fixnum
+      }
+    }
+    @table.put('row1', 'cf1' => 0, :a => 1, :b => 2, :c => 3, :d => 4)
+    @table.delete('row1', 'cf1:', :b, 'cf2')
+    assert_equal 1, @table.get('row1').to_h.keys.length
+    assert_equal 1, @table.get('row1').to_h[:a]
+    assert_equal 1, @table.get('row1').int(:a)
+
+    ts = Time.now
+    @table.put('drow3', :a => { 1000 => 1, 2000 => 2, 3000 => 3 },
+                        :b => { 4000 => 4, 5000 => 5, 6000 => 6 },
+                        :c => 3,
+                        :d => 4,
+                        :e => 5)
+    @table.delete('drow3', :a, 1000, Time.at(2),
+                           :c,
+                           [:cf1, :b], 5000,
+                           'cf3')
+
+    assert_equal 3, @table.get('drow3').to_h.keys.length
+
+    assert_equal 1, @table.get('drow3').to_H[:a].length
+    assert_equal 2, @table.get('drow3').to_H[:b].length
+    assert_equal 3000, @table.get('drow3').to_H[:a].keys.first
+    assert_equal [6000, 4000], @table.get('drow3').to_H[:b].keys
+  end
+
   def test_delete_row
     @table.put(1 => { 'cf1:a' => 1 }, 's' => { 'cf1:a' => 2 }, { :short => 3 } => { 'cf1:a' => 3 })
 
@@ -245,5 +307,93 @@ class TestTable < TestHBaseJRubyBase
     assert_equal nil, @table.get({ :short => 3 })
     assert_equal 1,   @table.count
   end
+
+  def test_check
+    assert_raise(ArgumentError) { @table.check(1, :a => 1, :b => 2) }
+    assert_raise(ArgumentError) { @table.check(1) }
+  end
+
+  def test_check_and_put
+    @hbase.schema[@table.name] = {
+      :cf1 => {
+        :a => :short,
+        :b => :short,
+        :c => :short
+      }
+    }
+
+    [
+      # Without schema
+      [1, 'cf1:a', 'cf1:b', 'cf1:c'],
+    # [2, 'cf1:a', 'cf1:b', 'cf1:c'],
+      # With schema
+      [1, :a, :b, :c],
+    # [2, :a, :b, :c],
+    ].each do |args|
+      @table.delete_row 1
+      @table.put 1, 'cf1:a' => 100
+
+      rk, a, b, c = args
+
+      # not nil
+      assert_equal false, @table.check(rk, a => 200).put(b => 300)
+      assert_equal nil, @table.get(rk).short(b)
+
+      assert_equal true, @table.check(rk, a => 100).put(b => 300)
+      assert_equal 300, @table.get(rk).short(b)
+
+      # nil
+      assert_equal false, @table.check(rk, a => nil).put(c => 300)
+      assert_equal nil, @table.get(rk).short(c)
+
+      assert_equal true, @table.check(rk, c => nil).put(c => 300)
+      assert_equal 300, @table.get(rk).short(c)
+    end
+  end
+
+  def test_check_and_delete
+    @hbase.schema[@table.name] = {
+      :cf1 => {
+        :a => :short,
+        :b => :short,
+        :c => :short
+      }
+    }
+
+    [
+      ['cf1:a', 'cf1:b', 'cf1:c', 'cf2:d'],
+      [:a, :b, :c, :d]
+    ].each do |abcd|
+      a, b, c, d = abcd
+
+      rk = (Time.now.to_f * 1000).to_i
+      ts = Time.now
+      @table.put rk, a => 100, b => 200,
+        c => { ts => 300, (ts - 1000) => 400, (ts - 2000).to_i => 500 },
+        d => 1000
+      assert_equal 3, @table.get(rk).to_H[:c].length
+
+      assert_equal false, @table.check(rk, a => 200).delete(b)
+      assert_equal 200, @table.get(rk)[b]
+
+      assert_equal true, @table.check(rk, a => 100).delete(b)
+      assert_equal nil, @table.get(rk)[b]
+
+      assert_equal true, @table.check(rk, a => 100).delete(c, ts, (ts - 2000).to_i, 'cf2')
+      assert_equal 1, @table.get(rk).to_H[:c].length
+      assert_equal (ts - 1000).to_i, @table.get(rk).to_H[:c].keys.first / 1000
+      assert_equal nil, @table.get(rk)[d]
+
+      assert_equal true, @table.check(rk, a => 100).delete
+      assert_equal nil, @table.get(rk)
+
+      @table.delete rk
+
+      @hbase.schema[@table.name] = {
+        :cf1 => { :a => :fixnum, :b => :fixnum, :c => :fixnum },
+        :cf2 => { :d => :fixnum }
+      }
+    end
+  end
 end
 

metadata

@@ -2,14 +2,14 @@
 name: hbase-jruby
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.3.2
+  version: 0.3.3
 platform: java
 authors:
 - Junegunn Choi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-06-03 00:00:00.000000000 Z
+date: 2013-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -70,6 +70,7 @@ files:
 - lib/hbase-jruby/scoped/aggregation.rb
 - lib/hbase-jruby/table.rb
 - lib/hbase-jruby/table/admin.rb
+- lib/hbase-jruby/table/checked_operation.rb
 - lib/hbase-jruby/table/inspection.rb
 - lib/hbase-jruby/util.rb
 - lib/hbase-jruby/version.rb