lib/sparkey/log_iterator.rb in sparkey-1.0.0 vs lib/sparkey/log_iterator.rb in sparkey-1.1.0

@@ -1,77 +1,129 @@
 class Sparkey::LogIterator
   include Sparkey::Errors
 
-  def initialize(log_reader, hash_reader = nil)
+  def initialize(log_reader)
     @log_reader = log_reader
-    @hash_reader = hash_reader
 
     ptr = FFI::MemoryPointer.new(:pointer)
 
     handle_status Sparkey::Native.logiter_create(ptr, @log_reader.ptr)
 
-    @log_iter_ptr = ptr.get_pointer(0)
+    @log_iter_ptr = ptr.read_pointer
   end
 
   def next
     handle_status Sparkey::Native.logiter_next(@log_iter_ptr, @log_reader.ptr)
   end
 
-  def hash_next
-    handle_status Sparkey::Native.logiter_hashnext(@log_iter_ptr, @hash_reader.ptr)
+  def skip(count)
+    handle_status Sparkey::Native.logiter_skip(@log_iter_ptr, @log_reader.ptr, count)
   end
 
+  def reset
+    handle_status Sparkey::Native.logiter_reset(@log_iter_ptr, @log_reader.ptr)
+  end
+
   def state
     Sparkey::Native.logiter_state(@log_iter_ptr)
   end
 
   def type
     Sparkey::Native.logiter_type(@log_iter_ptr)
   end
 
   def <=>(iterator)
-    ptr = FFI::MemoryPointer.new(:int, 1)
+    ptr = FFI::MemoryPointer.new(:int)
 
-    handle_status Sparkey::Native.logiter_keycmp(@log_iter_ptr, interator.ptr, @log_reader.ptr, ptr)
+    handle_status Sparkey::Native.logiter_keycmp(@log_iter_ptr, iterator.ptr, @log_reader.ptr, ptr)
 
     ptr.read_int
   end
 
+  def new?
+    state == :iter_new
+  end
+
   def active?
     state == :iter_active
   end
 
+  def invalid?
+    state == :iter_invalid
+  end
+
+  def closed?
+    state == :iter_closed
+  end
+
+  def entry_put?
+    type == :entry_put
+  end
+
+  def entry_delete?
+    type == :entry_delete
+  end
+
   def key_length
     Sparkey::Native.logiter_keylen(@log_iter_ptr)
   end
 
   def value_length
     Sparkey::Native.logiter_valuelen(@log_iter_ptr)
   end
 
   def get_key
-    wanted_key_length = key_length
-    key_ptr = FFI::MemoryPointer.new(:uint8, wanted_key_length)
-    actual_key_length_ptr = FFI::MemoryPointer.new(:uint64, 1)
+    max_key_length = @log_reader.max_key_length
+    buffer_ptr = FFI::MemoryPointer.new(:uint8, max_key_length)
+    buffer_length_ptr = FFI::MemoryPointer.new(:uint64)
 
-    handle_status Sparkey::Native.logiter_fill_key(@log_iter_ptr, @log_reader.ptr, wanted_key_length, key_ptr, actual_key_length_ptr)
+    handle_status Sparkey::Native.logiter_fill_key(@log_iter_ptr, @log_reader.ptr, max_key_length, buffer_ptr, buffer_length_ptr)
 
-    key_ptr.read_bytes(actual_key_length_ptr.read_uint64)
+    buffer_ptr.read_bytes(buffer_length_ptr.read_uint64)
   end
 
+  def get_key_chunk(chunk_size = 1024)
+    buffer = FFI::Buffer.alloc_out(:uint8, chunk_size)
+    buffer_length_ptr = FFI::MemoryPointer.new(:uint64)
+
+    loop do
+      handle_status Sparkey::Native.logiter_keychunk(@log_iter_ptr, @log_reader.ptr, chunk_size, buffer, buffer_length_ptr)
+
+      buffer_length = buffer_length_ptr.read_uint64
+
+      break if buffer_length.zero?
+
+      yield buffer.read_pointer.read_bytes(buffer_length)
+    end
+  end
+
   def get_value
-    wanted_value_length = value_length
-    value_ptr = FFI::MemoryPointer.new(:uint8, wanted_value_length)
-    actual_value_length_ptr = FFI::MemoryPointer.new(:uint64, 1)
+    max_value_length = @log_reader.max_value_length
+    buffer_ptr = FFI::MemoryPointer.new(:uint8, max_value_length)
+    buffer_length_ptr = FFI::MemoryPointer.new(:uint64)
 
-    handle_status Sparkey::Native.logiter_fill_value(@log_iter_ptr, @log_reader.ptr, wanted_value_length, value_ptr, actual_value_length_ptr)
+    handle_status Sparkey::Native.logiter_fill_value(@log_iter_ptr, @log_reader.ptr, max_value_length, buffer_ptr, buffer_length_ptr)
 
-    value_ptr.read_bytes(actual_value_length_ptr.read_uint64)
+    buffer_ptr.read_bytes(buffer_length_ptr.read_uint64)
   end
 
+  def get_value_chunk(chunk_size = 1024)
+    buffer = FFI::Buffer.alloc_out(:uint8, chunk_size)
+    buffer_length_ptr = FFI::MemoryPointer.new(:uint64)
+
+    loop do
+      handle_status Sparkey::Native.logiter_valuechunk(@log_iter_ptr, @log_reader.ptr, chunk_size, buffer, buffer_length_ptr)
+
+      buffer_length = buffer_length_ptr.read_uint64
+
+      break if buffer_length.zero?
+
+      yield buffer.read_pointer.read_bytes(buffer_length)
+    end
+  end
+
   def close
-    ptr = FFI::MemoryPointer.new(:pointer)
-    ptr.put_pointer(0, @log_iter_ptr)
+    ptr = FFI::MemoryPointer.new(:pointer).write_pointer(@log_iter_ptr)
 
     Sparkey::Native.logiter_close(ptr)
   end
 
   def ptr