oklahoma_mixer 0.1.0 → 0.2.0

data/CHANGELOG.rdoc

@@ -2,6 +2,16 @@
 
 Below is a complete listing of changes for each revision of Oklahoma Mixer.
 
+== 0.2.0
+
+* Added a to_hash() iterator that can preserve defaults
+* Added B+Tree Database support (order functions, key ranges,
+  and duplicate storages)
+* Added Fixed-length Database (indexing and iterating by ID's, support for
+  special ID constants, and size limits)
+* Fixed a bug that could cause Ruby to crash during GC after storing a value
+  with the duplication handler block
+
 == 0.1.0
 
 * Initial public release with Hash Database support

data/TODO.rdoc

@@ -3,9 +3,9 @@
 The following is a list of planned expansions for Oklahoma Mixer in the order I
 intend to address them.
 
-1. Add support for B+Tree and Fixed-length Databases
-2. Add support for Table Databases
-3. Ensure Ruby 1.9 compatibility
+1. Add support for Table Databases
+2. Ensure Ruby 1.9 compatibility
+3. Write API documentation
 4. Add support for Tokyo Tyrant
 5. Add support for Tokyo Dystopia
 6. Include some higher level abstractions like mixed tables, queues, and shards

data/lib/oklahoma_mixer.rb

@@ -7,18 +7,27 @@ require "oklahoma_mixer/extensible_string/c"
 require "oklahoma_mixer/extensible_string"
 require "oklahoma_mixer/array_list/c"
 require "oklahoma_mixer/array_list"
+require "oklahoma_mixer/cursor/c"
+require "oklahoma_mixer/cursor"
 
 require "oklahoma_mixer/hash_database/c"
 require "oklahoma_mixer/hash_database"
+require "oklahoma_mixer/b_tree_database/c"
+require "oklahoma_mixer/b_tree_database"
+require "oklahoma_mixer/fixed_length_database/c"
+require "oklahoma_mixer/fixed_length_database"
 
 module OklahomaMixer
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
   
   def self.open(path, *args)
-    db = case File.extname(path).downcase
-         when ".tch" then HashDatabase.new(path, *args)
-         else             fail ArgumentError, "unsupported database type"
-         end
+    db_class = case File.extname(path).downcase
+               when ".tch" then HashDatabase
+               when ".tcb" then BTreeDatabase
+               when ".tcf" then FixedLengthDatabase
+               else             fail ArgumentError, "unsupported database type"
+               end
+    db       = db_class.new(path, *args)
     if block_given?
       begin
         yield db

data/lib/oklahoma_mixer/b_tree_database.rb

@@ -0,0 +1,185 @@
+module OklahomaMixer
+  class BTreeDatabase < HashDatabase
+    ###################
+    ### File System ###
+    ###################
+    
+    def optimize(options)
+      try( options[:tune] ? :tune : :optimize,
+           options.fetch(:lmemb,  0).to_i,
+           options.fetch(:nmemb,  0).to_i,
+           options.fetch(:bnum,   0).to_i,
+           options.fetch(:apow,  -1).to_i,
+           options.fetch(:fpow,  -1).to_i,
+           to_enum_int(options.fetch(:opts, 0xFF), :opt) )
+    end
+    
+    ################################
+    ### Getting and Setting Keys ###
+    ################################
+
+    def store(key, value, mode = nil)
+      if mode == :dup
+        try(:putdup, cast_key_in(key), cast_value_in(value))
+        value
+      else
+        super
+      end
+    end
+    
+    def keys(options = { })
+      if options.include? :range
+        warn "range supersedes prefix" if options[:prefix]
+        range = options[:range]
+        fail ArgumentError, "Range expected" unless range.is_a? Range
+        start          = cast_key_in(range.first)
+        include_start  = !options.fetch(:exclude_start, false)
+        finish         = cast_key_in(range.last)
+        include_finish = !range.exclude_end?
+        limit          = options.fetch(:limit, -1)
+        begin
+          list = ArrayList.new( lib.range( @db,
+                                           *[ start,  include_start,
+                                              finish, include_finish,
+                                              limit ].flatten ) )
+          list.to_a
+        ensure
+          list.free if list
+        end
+      else
+        super
+      end
+    end
+
+    def values(key = nil)
+      if key.nil?
+        super()
+      else
+        begin
+          pointer = try( :get4, cast_key_in(key),
+                         :failure  => lambda { |ptr| ptr.address.zero? },
+                         :no_error => {22 => nil} )
+          if pointer.nil?
+            [ ]
+          else
+            list = ArrayList.new(pointer)
+            list.to_a
+          end
+        ensure
+          list.free if list
+        end
+      end
+    end
+    
+    def delete(key, mode = nil, &missing_handler)
+      if mode == :dup
+        values = values(key)
+        if try(:out3, cast_key_in(key), :no_error => {22 => false})
+          values
+        else
+          missing_handler ? missing_handler[key] : values
+        end
+      else
+        super(key, &missing_handler)
+      end
+    end
+
+    def size(key = nil)
+      if key.nil?
+        super()
+      else
+        try(:vnum, cast_key_in(key), :failure => 0, :no_error => {22 => 0})
+      end
+    end
+    alias_method :length, :size
+    
+    #################
+    ### Iteration ###
+    #################
+    
+    def each_key(start = nil)
+      cursor_in_loop(start) do |iterator|
+        throw(:finish_iteration) unless key = iterator.key
+        yield key
+      end
+    end
+    
+    def each(start = nil)
+      cursor_in_loop(start) do |iterator|
+        throw(:finish_iteration) unless key_and_value = iterator.key_and_value
+        yield key_and_value
+      end
+    end
+    alias_method :each_pair, :each
+    
+    def reverse_each(start = nil)
+      cursor_in_loop(start, :reverse) do |iterator|
+        throw(:finish_iteration) unless key_and_value = iterator.key_and_value
+        yield key_and_value
+      end
+    end
+    
+    def each_value(start = nil)
+      cursor_in_loop(start) do |iterator|
+        throw(:finish_iteration) unless value = iterator.value
+        yield value
+      end
+    end
+    
+    def delete_if(start = nil)
+      cursor(start) do |iterator|
+        loop do
+          break unless key_and_value = iterator.key_and_value
+          break unless iterator.send(yield(*key_and_value) ? :delete : :next)
+        end
+      end
+    end
+    
+    #######
+    private
+    #######
+    
+    def tune(options)
+      super
+      if cmpfunc = options[:cmpfunc]
+        callback = lambda { |a_pointer, a_size, b_pointer, b_size, _|
+          a = a_pointer.get_bytes(0, a_size)
+          b = b_pointer.get_bytes(0, b_size)
+          cmpfunc[a, b]
+        }
+        try(:setcmpfunc, callback, nil)
+      end
+      if options.values_at(:lmemb, :nmemb, :bnum, :apow, :fpow, :opts).any?
+        optimize(options.merge(:tune => true))
+      end
+      if options.values_at(:lcnum, :ncnum).any?
+        setcache(options)
+      end
+    end
+    
+    def setcache(options)
+      try( :setcache,
+           options.fetch(:lcnum, 0).to_i,
+           options.fetch(:ncnum, 0).to_i )
+    end
+    
+    def cursor(start = nil, reverse = false)
+      cursor = Cursor.new(@db, start.nil? ? start : cast_key_in(start), reverse)
+      yield cursor
+      self
+    ensure
+      cursor.free if cursor
+    end
+    
+    def cursor_in_loop(start = nil, reverse = false)
+      cursor(start, reverse) do |iterator|
+        catch(:finish_iteration) do
+          loop do
+            yield iterator
+            break unless iterator.next
+          end
+        end
+      end
+    end
+  end
+end

data/lib/oklahoma_mixer/b_tree_database/c.rb

@@ -0,0 +1,45 @@
+module OklahomaMixer
+  class BTreeDatabase < HashDatabase
+    module C  # :nodoc:
+      extend OklahomaMixer::Utilities::FFIDSL
+
+      prefix :tcbdb
+      
+      def_hash_database_consts_and_funcs
+
+      call :name    => :TCCMP,
+           :args    => [:pointer, :int, :pointer, :int, :pointer],
+           :returns => :int
+      func :name    => :setcmpfunc,
+           :args    => [:pointer, :TCCMP, :pointer],
+           :returns => :bool
+      func :name    => :tune,
+           :args    => [:pointer, :int32, :int32, :int64, :int8, :int8, OPTS],
+           :returns => :bool
+      func :name    => :setcache,
+           :args    => [:pointer, :int32, :int32],
+           :returns => :bool
+      func :name    => :optimize,
+           :args    => [:pointer, :int32, :int32, :int64, :int8, :int8, OPTS],
+           :returns => :bool
+
+      func :name    => :putdup,
+           :args    => [:pointer, :pointer, :int, :pointer, :int],
+           :returns => :bool
+      func :name    => :out3,
+           :args    => [:pointer, :pointer, :int],
+           :returns => :bool
+      func :name    => :get4,
+           :args    => [:pointer, :pointer, :int],
+           :returns => :pointer
+      func :name    => :vnum,
+           :args    => [:pointer, :pointer, :int],
+           :returns => :int
+
+      func :name    => :range,
+           :args    => [:pointer, :pointer, :int, :bool, :pointer, :int, :bool,
+                        :int],
+           :returns => :pointer
+    end
+  end
+end

data/lib/oklahoma_mixer/cursor.rb

@@ -0,0 +1,43 @@
+module OklahomaMixer
+  class Cursor  # :nodoc:
+    def initialize(b_tree_pointer, start = nil, reverse = false)
+      @pointer = C.new(b_tree_pointer)
+      @reverse = reverse
+      if start
+        C.jump(@pointer, *start)
+      else
+        C.send(@reverse ? :last : :first, @pointer)
+      end
+    end
+    
+    def key
+      C.read_from_func(:key, @pointer)
+    end
+    
+    def value
+      C.read_from_func(:val, @pointer)
+    end
+    
+    def key_and_value
+      Utilities.temp_xstr do |key|
+        Utilities.temp_xstr do |value|
+          if C.rec(@pointer, key.pointer, value.pointer)
+            [key.to_s, value.to_s]
+          end
+        end
+      end
+    end
+    
+    def next
+      C.send(@reverse ? :prev : :next, @pointer)
+    end
+    
+    def delete
+      C.out(@pointer)
+    end
+    
+    def free
+      C.del(@pointer)
+    end
+  end
+end

data/lib/oklahoma_mixer/cursor/c.rb

@@ -0,0 +1,45 @@
+module OklahomaMixer
+  class Cursor
+    module C  # :nodoc:
+      extend OklahomaMixer::Utilities::FFIDSL
+
+      prefix :tcbdbcur
+      
+      func :name    => :new,
+           :args    => :pointer,
+           :returns => :pointer
+      func :name    => :del,
+           :args    => :pointer
+
+      func :name    => :first,
+           :args    => :pointer,
+           :returns => :bool
+      func :name    => :last,
+           :args    => :pointer,
+           :returns => :bool
+      func :name    => :jump,
+           :args    => [:pointer, :pointer, :int],
+           :returns => :bool
+      func :name    => :next,
+           :args    => :pointer,
+           :returns => :bool
+      func :name    => :prev,
+           :args    => :pointer,
+           :returns => :bool
+
+      func :name    => :key,
+           :args    => [:pointer, :pointer],
+           :returns => :pointer
+      func :name    => :val,
+           :args    => [:pointer, :pointer],
+           :returns => :pointer
+      func :name    => :rec,
+           :args    => [:pointer, :pointer, :pointer],
+           :returns => :bool
+
+      func :name    => :out,
+           :args    => :pointer,
+           :returns => :bool
+    end
+  end
+end

data/lib/oklahoma_mixer/fixed_length_database.rb

@@ -0,0 +1,95 @@
+module OklahomaMixer
+  class FixedLengthDatabase < HashDatabase
+    ###################
+    ### File System ###
+    ###################
+    
+    def optimize(options)
+      try( options[:tune] ? :tune : :optimize,
+           options.fetch(:width,  0).to_i,
+           options.fetch(:limsiz, 0).to_i  )
+    end
+    
+    def defrag(steps = 0)
+      # do nothing:  not needed, but provided for a consistent interface
+    end
+    
+    ################################
+    ### Getting and Setting Keys ###
+    ################################
+    
+    def keys(options = { })
+      if options.include? :range
+        warn "range supersedes prefix" if options[:prefix]
+        range = options[:range]
+        unless range.respond_to?(:first) and range.respond_to?(:last)
+          fail ArgumentError, "Range or two element Array expected"
+        end
+        start          = cast_key_in(range.first)
+        include_start  = !options.fetch(:exclude_start, false)
+        finish         = cast_key_in(range.last)
+        include_finish = !( range.respond_to?(:exclude_end?) ?
+                            range.exclude_end?               :
+                            options.fetch(:exclude_end, false) )
+      else
+        fail ArgumentError, "prefix not supported" if options[:prefix]
+        start          = cast_key_in(:min)
+        include_start  = true
+        finish         = cast_key_in(:max)
+        include_finish = true
+      end
+      limit = options.fetch(:limit, -1)
+      Utilities.temp_int do |count|
+        begin
+          list  = lib.range(@db, start, finish, limit, count)
+          array = list.get_array_of_uint64(0, count.get_int(0))
+          array.shift if array.first == start  and not include_start
+          array.pop   if array.last  == finish and not include_finish
+          array
+        ensure
+          Utilities.free(list) if list
+        end
+      end
+    end
+    
+    #################
+    ### Iteration ###
+    #################
+
+    def each_key
+      try(:iterinit)
+      loop do
+        return self unless key = try( :iternext,
+                                      :failure  => 0,
+                                      :no_error => {22 => nil} )
+        yield key
+      end
+    end
+    
+    def each
+      each_key do |key|
+        yield [key, self[key]]
+      end
+    end
+    alias_method :each_pair, :each
+    
+    #######
+    private
+    #######
+    
+    def tune(options)
+      if options.values_at(:width, :limsiz).any?
+        optimize(options.merge(:tune => true))
+      end
+    end
+    
+    def cast_key_in(key)
+      case key
+      when :min, :max, :prev, :next, "min", "max", "prev", "next"
+        C::IDS["FDBID#{key.to_s.upcase}".to_sym]
+      else
+        key.to_i
+      end
+    end
+  end
+end