Class: FDB::TransactionRead

Inherits:
Object
  • Object
show all
Defined in:
lib/fdbimpl.rb

Direct Known Subclasses

Transaction

Constant Summary collapse

@@RangeEnum = 
Class.new do
  include Enumerable
   def initialize(get_range, bsel, esel, limit, reverse, streaming_mode)
    @get_range = get_range
     @bsel = bsel
    @esel = esel
     @limit = limit
    @reverse = reverse
    @mode = streaming_mode
     @future = @get_range.call(@bsel, @esel, @limit, @mode, 1, @reverse)
  end
   def to_a
    o = self.dup
    o.instance_eval do
      if @mode == @@StreamingMode["ITERATOR"][0]
        if @limit.zero?
          @mode = @@StreamingMode["WANT_ALL"][0]
        else
          @mode = @@StreamingMode["EXACT"][0]
        end
      end
    end
    Enumerable.instance_method(:to_a).bind(o).call
  end
   def each
    bsel = @bsel
    esel = @esel
    limit = @limit
     iteration = 1 # the first read was fired off when the RangeEnum was initialized
    future = @future
     done = false
     while !done
      if future
        kvs, count, more = future.wait
        index = 0
        future = nil
         return if count.zero?
      end
       result = kvs[index]
      index += 1
       if index == count
        if more.zero? || limit == count
          done = true
        else
          iteration += 1
          if limit.nonzero?
            limit -= count
          end
          if @reverse.nonzero?
            esel = KeySelector.first_greater_or_equal(kvs.last.key)
          else
            bsel = KeySelector.first_greater_than(kvs.last.key)
          end
          future = @get_range.call(bsel, esel, limit, @mode, iteration, @reverse)
        end
      end
       yield result
    end
  end
end

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(tpointer, db, is_snapshot) ⇒ TransactionRead

Returns a new instance of TransactionRead.



714
715
716
717
718
719
720
 
# File 'lib/fdbimpl.rb', line 714

def initialize(tpointer, db, is_snapshot)
  @tpointer = tpointer
  @db = db
  @is_snapshot = is_snapshot

  ObjectSpace.define_finalizer(self, self.class.finalize(@tpointer))
end

Instance Attribute Details

#db ⇒ Object (readonly)

Returns the value of attribute db.



704
705
706
 
# File 'lib/fdbimpl.rb', line 704

def db
  @db
end

#tpointer ⇒ Object (readonly)

Returns the value of attribute tpointer.



705
706
707
 
# File 'lib/fdbimpl.rb', line 705

def tpointer
  @tpointer
end

Class Method Details

.finalize(ptr) ⇒ Object 



707
708
709
710
711
712
 
# File 'lib/fdbimpl.rb', line 707

def self.finalize(ptr)
  proc do
    #puts "Destroying transaction #{ptr}"
    FDBC.fdb_transaction_destroy(ptr)
  end
end

Instance Method Details

#get(key) ⇒ Object Also known as: [] 



730
731
732
733
 
# File 'lib/fdbimpl.rb', line 730

def get(key)
  key = FDB.key_to_bytes(key)
  Value.new(FDBC.fdb_transaction_get(@tpointer, key, key.bytesize, @is_snapshot))
end

#get_key(keysel) ⇒ Object 



736
737
738
739
 
# File 'lib/fdbimpl.rb', line 736

def get_key(keysel)
  key = FDB.key_to_bytes(keysel.key)
  Key.new(FDBC.fdb_transaction_get_key(@tpointer, key, key.bytesize, keysel.or_equal, keysel.offset, @is_snapshot))
end

#get_range(bkeysel, ekeysel, options = {}, &block) ⇒ Object 



824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
 
# File 'lib/fdbimpl.rb', line 824

def get_range(bkeysel, ekeysel, options={}, &block)
  defaults = { :limit => 0, :reverse => false, :streaming_mode => :iterator }
  options = defaults.merge options
  bsel = to_selector bkeysel
  esel = to_selector ekeysel

  if options[:streaming_mode].kind_of? Symbol
    streaming_mode = @@StreamingMode[options[:streaming_mode].to_s.upcase]
    raise ArgumentError, "#{options[:streaming_mode]} is not a valid streaming mode" if !streaming_mode
    streaming_mode = streaming_mode[0]
  else
    streaming_mode = options[:streaming_mode]
  end

  r = @@RangeEnum.new(lambda {|bsel, esel, limit, streaming_mode, iteration, reverse|
                        begin_key = FDB.key_to_bytes(bsel.key)
                        end_key = FDB.key_to_bytes(esel.key)
                        FDB::FutureKeyValueArray.new(FDBC.fdb_transaction_get_range(@tpointer, begin_key, begin_key.bytesize, bsel.or_equal, bsel.offset, end_key, end_key.bytesize, esel.or_equal, esel.offset, limit, 0, streaming_mode, iteration, @is_snapshot, reverse))
                      }, bsel, esel, options[:limit], options[:reverse] ? 1 : 0, streaming_mode)

  if !block_given?
    r
  else
    r.each &block
  end
end

#get_range_start_with(prefix, options = {}, &block) ⇒ Object 



851
852
853
854
855
 
# File 'lib/fdbimpl.rb', line 851

def get_range_start_with(prefix, options={}, &block)
  prefix = FDB.key_to_bytes(prefix)
  prefix = prefix.dup.force_encoding "BINARY"
  get_range(prefix, FDB.strinc(prefix), options, &block)
end

#get_read_version ⇒ Object 



726
727
728
 
# File 'lib/fdbimpl.rb', line 726

def get_read_version
  Version.new(FDBC.fdb_transaction_get_read_version @tpointer)
end

#transact {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:



722
723
724
 
# File 'lib/fdbimpl.rb', line 722

def transact
  yield self
end